diff --git a/compressor_component.py b/compressor_component.py
new file mode 100644
index 00000000..e69de29b
diff --git a/pandapipes/__init__.py b/pandapipes/__init__.py
index 8756de06..0234d01a 100644
--- a/pandapipes/__init__.py
+++ b/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
diff --git a/pandapipes/component_models/abstract_models/base_component.py b/pandapipes/component_models/abstract_models/base_component.py
index 70910a09..a7b61559 100644
--- a/pandapipes/component_models/abstract_models/base_component.py
+++ b/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):
"""
diff --git a/pandapipes/component_models/abstract_models/branch_models.py b/pandapipes/component_models/abstract_models/branch_models.py
index 8dcdead0..982eb24d 100644
--- a/pandapipes/component_models/abstract_models/branch_models.py
+++ b/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
diff --git a/pandapipes/component_models/abstract_models/branch_w_internals_models.py b/pandapipes/component_models/abstract_models/branch_w_internals_models.py
index 0ff9c1fc..7026ca5f 100644
--- a/pandapipes/component_models/abstract_models/branch_w_internals_models.py
+++ b/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):
"""
diff --git a/pandapipes/component_models/abstract_models/branch_wo_internals_models.py b/pandapipes/component_models/abstract_models/branch_wo_internals_models.py
index 1784b315..94f05827 100644
--- a/pandapipes/component_models/abstract_models/branch_wo_internals_models.py
+++ b/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
diff --git a/pandapipes/component_models/abstract_models/branch_wzerolength_models.py b/pandapipes/component_models/abstract_models/branch_wzerolength_models.py
index ff2fccda..b2cab8f8 100644
--- a/pandapipes/component_models/abstract_models/branch_wzerolength_models.py
+++ b/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
diff --git a/pandapipes/component_models/abstract_models/circulation_pump.py b/pandapipes/component_models/abstract_models/circulation_pump.py
index a5574e50..f092990c 100644
--- a/pandapipes/component_models/abstract_models/circulation_pump.py
+++ b/pandapipes/component_models/abstract_models/circulation_pump.py
@@ -5,11 +5,10 @@
import numpy as np
from pandapipes.component_models.ext_grid_component import ExtGrid
-from pandapipes.idx_node import PINIT
from pandapipes.pf.pipeflow_setup import get_lookup
try:
- import pplog as logging
+ from pandaplan.core import pplog as logging
except ImportError:
import logging
@@ -26,6 +25,15 @@ def sign(cls):
def get_connected_node_type(cls):
raise NotImplementedError
+ #ToDo: remove as soon as the circulation pumps are redefined, replace by get_connected_node_type
+ @classmethod
+ def junction_column_name(cls):
+ return 'from_junction'
+
+ @classmethod
+ def create_pit_node_element_entries(cls, net, node_element_pit):
+ super().create_pit_node_element_entries(net, node_element_pit)
+
@classmethod
def extract_results(cls, net, options, branch_results, nodes_connected, branches_connected):
"""
@@ -43,15 +51,24 @@ def extract_results(cls, net, options, branch_results, nodes_connected, branches
:type options:
:return: No Output.
"""
- res_table, circ_pump, index_nodes_from, node_pit, _ = \
+ res_table, circ_pump = \
super().extract_results(net, options, None, nodes_connected, branches_connected)
+ node_pit = net["_pit"]["node"]
+
+ p_grids = np.isin(circ_pump.type.values, ["p", "pt"]) & circ_pump.in_service.values
+ junction = cls.get_connected_junction(net)
+ eg_nodes = get_lookup(net, "node", "index")[cls.get_connected_node_type().table_name()][
+ np.array(junction.values[p_grids])]
+ index_nodes_from = np.unique(eg_nodes)
+
index_juncts_to = circ_pump.to_junction.values
junct_uni_to = np.array(list(set(index_juncts_to)))
index_nodes_to = get_lookup(net, "node", "index")[
cls.get_connected_node_type().table_name()][junct_uni_to]
- deltap_bar = node_pit[index_nodes_from, PINIT] - node_pit[index_nodes_to, PINIT]
+ deltap_bar = node_pit[index_nodes_from, net['_idx_node']['PINIT']] - \
+ node_pit[index_nodes_to, net['_idx_node']['PINIT']]
res_table["deltap_bar"].values[:] = deltap_bar
@classmethod
diff --git a/pandapipes/component_models/abstract_models/const_flow_models.py b/pandapipes/component_models/abstract_models/const_flow_models.py
index ce06204e..4c4157f5 100644
--- a/pandapipes/component_models/abstract_models/const_flow_models.py
+++ b/pandapipes/component_models/abstract_models/const_flow_models.py
@@ -4,8 +4,8 @@
import numpy as np
from numpy import dtype
+
from pandapipes.component_models.abstract_models.node_element_models import NodeElementComponent
-from pandapipes.idx_node import LOAD, ELEMENT_IDX
from pandapipes.pf.internals_toolbox import _sum_by_group
from pandapipes.pf.pipeflow_setup import get_lookup, get_net_option
@@ -44,7 +44,7 @@ def create_pit_node_entries(cls, net, node_pit):
junction_idx_lookups = get_lookup(net, "node", "index")[
cls.get_connected_node_type().table_name()]
index = junction_idx_lookups[juncts]
- node_pit[index, LOAD] += loads_sum
+ node_pit[index, net['_idx_node']['LOAD']] += loads_sum
@classmethod
def extract_results(cls, net, options, branch_results, nodes_connected, branches_connected):
@@ -71,7 +71,7 @@ def extract_results(cls, net, options, branch_results, nodes_connected, branches
fj, tj = get_lookup(net, "node", "from_to")[cls.get_connected_node_type().table_name()]
junct_pit = net["_pit"]["node"][fj:tj, :]
nodes_connected = get_lookup(net, "node", "active")[fj:tj]
- is_juncts = np.isin(loads.junction.values, junct_pit[nodes_connected, ELEMENT_IDX])
+ is_juncts = np.isin(loads.junction.values, junct_pit[nodes_connected, net['_idx_node']['ELEMENT_IDX']])
is_calc = is_loads & is_juncts
res_table["mdot_kg_per_s"].values[is_calc] = loads.mdot_kg_per_s.values[is_calc] \
diff --git a/pandapipes/component_models/abstract_models/node_element_models.py b/pandapipes/component_models/abstract_models/node_element_models.py
index a45f3e9d..e4368b18 100644
--- a/pandapipes/component_models/abstract_models/node_element_models.py
+++ b/pandapipes/component_models/abstract_models/node_element_models.py
@@ -3,9 +3,11 @@
# Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
from pandapipes.component_models.abstract_models.base_component import Component
+from pandapipes.pf.pipeflow_setup import get_lookup, add_table_lookup, get_table_number
+import numpy as np
try:
- import pplog as logging
+ from pandaplan.core import pplog as logging
except ImportError:
import logging
@@ -17,6 +19,10 @@ class NodeElementComponent(Component):
"""
+ @classmethod
+ def node_element_relevant(cls, net):
+ return False
+
@classmethod
def table_name(cls):
raise NotImplementedError
@@ -25,6 +31,11 @@ def table_name(cls):
def get_connected_node_type(cls):
raise NotImplementedError
+ #ToDo: remove as soon as the circulation pumps are redefined, replace by get_connected_node_type
+ @classmethod
+ def junction_column_name(cls):
+ return 'junction'
+
@classmethod
def get_component_input(cls):
raise NotImplementedError
@@ -33,6 +44,25 @@ def get_component_input(cls):
def get_result_table(cls, net):
raise NotImplementedError
+ @classmethod
+ def create_node_element_lookups(cls, net, ft_lookups, table_lookup, idx_lookups, current_start,
+ current_table):
+ if cls.node_element_relevant(net):
+ table_indices = net[cls.table_name()].index
+ table_len = len(table_indices)
+ end = current_start + table_len
+ ft_lookups[cls.table_name()] = (current_start, end)
+ add_table_lookup(table_lookup, cls.table_name(), current_table)
+ if not table_len:
+ idx_lookups[cls.table_name()] = np.array([], dtype=np.int32)
+ idx_lookups[cls.table_name()][table_indices] = np.arange(table_len) + current_start
+ else:
+ idx_lookups[cls.table_name()] = -np.ones(table_indices.max() + 1, dtype=np.int32)
+ idx_lookups[cls.table_name()][table_indices] = np.arange(table_len) + current_start
+ return end, current_table + 1
+ else:
+ return current_start, current_table
+
@classmethod
def create_pit_node_entries(cls, net, node_pit):
"""
@@ -46,6 +76,30 @@ def create_pit_node_entries(cls, net, node_pit):
"""
raise NotImplementedError
+ @classmethod
+ def create_pit_node_element_entries(cls, net, node_element_pit):
+ if cls.node_element_relevant(net):
+ ft_lookup = get_lookup(net, "node_element", "from_to")
+ node_lookup = get_lookup(net, "node", "index")[cls.get_connected_node_type().table_name()]
+ node_element_table_nr = get_table_number(get_lookup(net, "node_element", "table"), cls.table_name())
+ f, t = ft_lookup[cls.table_name()]
+
+ node_elements = net[cls.table_name()]
+ node_element_pit = node_element_pit[f:t, :]
+ node_element_pit[:, :] = np.array([node_element_table_nr] + [0] *
+ (net['_idx_node_element']['node_element_cols'] - 1))
+ node_element_pit[:, net['_idx_node']['ELEMENT_IDX']] = node_elements.index.values
+ node_element_pit[:, net['_idx_node_element']['JUNCTION']] = \
+ node_lookup[node_elements[cls.junction_column_name()].values]
+ node_element_pit[:, net['_idx_node_element']['ACTIVE']] = node_elements.in_service.values
+ if len(net._fluid) != 1:
+ w_lookup = np.array(get_lookup(net, "node_element", "w"))
+ flp, nep = np.where(node_elements.fluid.values == net._fluid[:, np.newaxis])
+ node_element_pit[nep, w_lookup[flp]] = 1.
+ return node_element_pit
+
@classmethod
def extract_results(cls, net, options, branch_results, nodes_connected, branches_connected):
raise NotImplementedError
+
+
diff --git a/pandapipes/component_models/abstract_models/node_models.py b/pandapipes/component_models/abstract_models/node_models.py
index da338e68..93cb02b8 100644
--- a/pandapipes/component_models/abstract_models/node_models.py
+++ b/pandapipes/component_models/abstract_models/node_models.py
@@ -5,7 +5,7 @@
from pandapipes.component_models.abstract_models.base_component import Component
try:
- import pplog as logging
+ from pandaplan.core import pplog as logging
except ImportError:
import logging
diff --git a/pandapipes/component_models/circulation_pump_mass_component.py b/pandapipes/component_models/circulation_pump_mass_component.py
index f4bfae38..6cb64ed5 100644
--- a/pandapipes/component_models/circulation_pump_mass_component.py
+++ b/pandapipes/component_models/circulation_pump_mass_component.py
@@ -6,14 +6,12 @@
from numpy import dtype
from pandapipes.component_models.junction_component import Junction
-from pandapipes.component_models.abstract_models.circulation_pump import CirculationPump
-from pandapipes.idx_node import LOAD
+from pandapipes.component_models.abstract_models.circulation_pump import CirculationPump
from pandapipes.pf.internals_toolbox import _sum_by_group
-from pandapipes.pf.pipeflow_setup import get_lookup
-from pandapipes.pf.pipeflow_setup import get_net_option
+from pandapipes.pf.pipeflow_setup import get_lookup, get_net_option
try:
- import pplog as logging
+ from pandaplan.core import pplog as logging
except ImportError:
import logging
@@ -50,7 +48,7 @@ def create_pit_node_entries(cls, net, node_pit):
junction_idx_lookups = get_lookup(net, "node", "index")[
cls.get_connected_node_type().table_name()]
index = junction_idx_lookups[juncts]
- node_pit[index, LOAD] += loads_sum
+ node_pit[index, net['_idx_node']['LOAD']] += loads_sum
@classmethod
def get_component_input(cls):
@@ -65,5 +63,6 @@ def get_component_input(cls):
("p_bar", "f8"),
("t_k", "f8"),
("mdot_kg_per_s", "f8"),
+ ("fluid", dtype(object)),
("in_service", 'bool'),
("type", dtype(object))]
diff --git a/pandapipes/component_models/circulation_pump_pressure_component.py b/pandapipes/component_models/circulation_pump_pressure_component.py
index 6f4cbd82..cff5f0bd 100644
--- a/pandapipes/component_models/circulation_pump_pressure_component.py
+++ b/pandapipes/component_models/circulation_pump_pressure_component.py
@@ -7,12 +7,11 @@
from pandapipes.component_models.junction_component import Junction
from pandapipes.component_models.abstract_models.circulation_pump import CirculationPump
-from pandapipes.idx_node import PINIT, NODE_TYPE, P, EXT_GRID_OCCURENCE
from pandapipes.pf.internals_toolbox import _sum_by_group
from pandapipes.pf.pipeflow_setup import get_lookup, get_net_option
try:
- import pplog as logging
+ from pandaplan.core import pplog as logging
except ImportError:
import logging
@@ -49,9 +48,9 @@ def create_pit_node_entries(cls, net, node_pit):
press - circ_pump.plift_bar.values, np.ones_like(press, dtype=np.int32))
index_p = junction_idx_lookups[juncts_p]
- node_pit[index_p, PINIT] = press_sum / number
- node_pit[index_p, NODE_TYPE] = P
- node_pit[index_p, EXT_GRID_OCCURENCE] += number
+ node_pit[index_p, net['_idx_node']['PINIT']] = press_sum / number
+ node_pit[index_p, net['_idx_node']['NODE_TYPE']] = net['_idx_node']['P']
+ node_pit[index_p, net['_idx_node']['EXT_GRID_OCCURENCE']] += number
net["_lookups"]["ext_grid"] = \
np.array(list(set(np.concatenate([net["_lookups"]["ext_grid"], index_p]))))
@@ -69,5 +68,6 @@ def get_component_input(cls):
("p_bar", "f8"),
("t_k", "f8"),
("plift_bar", "f8"),
+ ("fluid", dtype(object)),
("in_service", 'bool'),
("type", dtype(object))]
diff --git a/pandapipes/component_models/component_toolbox.py b/pandapipes/component_models/component_toolbox.py
index 6d0b3635..1296ae4d 100644
--- a/pandapipes/component_models/component_toolbox.py
+++ b/pandapipes/component_models/component_toolbox.py
@@ -4,6 +4,7 @@
import numpy as np
import pandas as pd
+
from pandapipes.constants import NORMAL_PRESSURE, TEMP_GRADIENT_KPM, AVG_TEMPERATURE_K, \
HEIGHT_EXPONENT
@@ -85,43 +86,6 @@ def init_results_element(net, element, output, all_float):
columns=net[res_element].columns)
-def add_new_component(net, component, overwrite=False):
- """
-
- :param net:
- :type net:
- :param component:
- :type component:
- :param overwrite:
- :type overwrite:
- :return:
- :rtype:
- """
- name = component.table_name()
- if not overwrite and name in net:
- # logger.info('%s is already in net. Try overwrite if you want to get a new entry' %name)
- return
- else:
- if hasattr(component, 'geodata'):
- geodata = component.geodata()
- else:
- geodata = None
-
- comp_input = component.get_component_input()
- if name not in net:
- net['component_list'].append(component)
- net.update({name: comp_input})
- if isinstance(net[name], list):
- net[name] = pd.DataFrame(np.zeros(0, dtype=net[name]), index=[])
- # init_empty_results_table(net, name, component.get_result_table(net))
-
- if geodata is not None:
- net.update({name + '_geodata': geodata})
- if isinstance(net[name + '_geodata'], list):
- net[name + '_geodata'] = pd.DataFrame(np.zeros(0, dtype=net[name + '_geodata']),
- index=[])
-
-
def set_entry_check_repeat(pit, column, entry, repeat_number, repeated=True):
if repeated:
pit[:, column] = np.repeat(entry, repeat_number)
diff --git a/pandapipes/component_models/compressor_component.py b/pandapipes/component_models/compressor_component.py
index 198e1fa8..ce2fce5b 100644
--- a/pandapipes/component_models/compressor_component.py
+++ b/pandapipes/component_models/compressor_component.py
@@ -7,9 +7,6 @@
from pandapipes.component_models.junction_component import Junction
from pandapipes.component_models.pump_component import Pump
-from pandapipes.idx_branch import VINIT, D, AREA, LOSS_COEFFICIENT as LC, FROM_NODE, PL,\
- PRESSURE_RATIO
-from pandapipes.idx_node import PINIT, PAMB
class Compressor(Pump):
@@ -38,26 +35,28 @@ def create_pit_branch_entries(cls, net, branch_pit):
"""
compressor_pit = super(Pump, cls).create_pit_branch_entries(net, branch_pit)
- compressor_pit[:, D] = 0.1
- compressor_pit[:, AREA] = compressor_pit[:, D] ** 2 * np.pi / 4
- compressor_pit[:, LC] = 0
- compressor_pit[:, PRESSURE_RATIO] = net[cls.table_name()].pressure_ratio.values
+ compressor_pit[:, net['_idx_branch']['D']] = 0.1
+ compressor_pit[:, net['_idx_branch']['AREA']] = compressor_pit[:, net['_idx_branch']['D']] ** 2 * np.pi / 4
+ compressor_pit[:, net['_idx_branch']['LOSS_COEFFICIENT']] = 0
+ compressor_pit[:, net['_idx_branch']['PRESSURE_RATIO']] = net[cls.table_name()].pressure_ratio.values
@classmethod
- def adaption_before_derivatives_hydraulic(cls, net, branch_pit, node_pit, idx_lookups, options):
- # calculation of pressure lift
- f, t = idx_lookups[cls.table_name()]
+ def adaption_before_derivatives_hydraulic(cls, net, branch_pit, node_pit, branch_lookups, node_lookups, options):
+ """ absolute inlet pressure multiplied by the compressor's boost ratio.
+ If the flow is reversed, the pressure lift is set to 0."""
+ super().adaption_before_derivatives_hydraulic(net, branch_pit, node_pit, branch_lookups, node_lookups, options)
+ f, t = branch_lookups[cls.table_name()]
compressor_pit = branch_pit[f:t, :]
- from_nodes = compressor_pit[:, FROM_NODE].astype(np.int32)
- p_from = node_pit[from_nodes, PAMB] + node_pit[from_nodes, PINIT]
- p_to_calc = p_from * compressor_pit[:, PRESSURE_RATIO]
+ from_nodes = compressor_pit[:, net['_idx_branch']['FROM_NODE']].astype(np.int32)
+ p_from = node_pit[from_nodes, net['_idx_node']['PAMB']] + node_pit[from_nodes, net['_idx_node']['PINIT']]
+ p_to_calc = p_from * compressor_pit[:, net['_idx_branch']['PRESSURE_RATIO']]
pl_abs = p_to_calc - p_from
- v_mps = compressor_pit[:, VINIT]
+ v_mps = compressor_pit[:, net['_idx_branch']['VINIT']]
pl_abs[v_mps < 0] = 0 # force pressure lift = 0 for reverse flow
- compressor_pit[:, PL] = pl_abs
+ compressor_pit[:, net['_idx_branch']['PL']] = pl_abs
@classmethod
def get_component_input(cls):
diff --git a/pandapipes/component_models/ext_grid_component.py b/pandapipes/component_models/ext_grid_component.py
index a9d37f5b..96bd19e5 100644
--- a/pandapipes/component_models/ext_grid_component.py
+++ b/pandapipes/component_models/ext_grid_component.py
@@ -6,14 +6,11 @@
from numpy import dtype
from pandapipes.component_models.abstract_models.node_element_models import NodeElementComponent
-from pandapipes.idx_branch import FROM_NODE, TO_NODE, LOAD_VEC_NODES
-from pandapipes.idx_node import PINIT, LOAD, TINIT, NODE_TYPE, NODE_TYPE_T, P, T, \
- EXT_GRID_OCCURENCE, EXT_GRID_OCCURENCE_T
from pandapipes.pf.internals_toolbox import _sum_by_group
from pandapipes.pf.pipeflow_setup import get_lookup, get_net_option
try:
- import pplog as logging
+ from pandaplan.core import pplog as logging
except ImportError:
import logging
@@ -38,6 +35,22 @@ def get_connected_node_type(cls):
from pandapipes.component_models.junction_component import Junction
return Junction
+ @classmethod
+ def node_element_relevant(cls, net):
+ return True
+
+ @classmethod
+ def create_pit_node_element_entries(cls, net, node_element_pit):
+ ext_grids = net[cls.table_name()]
+ ext_grids = ext_grids[ext_grids.in_service.values]
+ ext_grid_pit = super().create_pit_node_element_entries(net, node_element_pit)
+ p_mask = np.where(np.isin(ext_grids.type.values, ["p", "pt"]))
+ t_mask = np.where(np.isin(ext_grids.type.values, ["t"]))
+ ext_grid_pit[p_mask, net._idx_node_element['NODE_ELEMENT_TYPE']] = net._idx_node_element['P']
+ ext_grid_pit[t_mask, net._idx_node_element['NODE_ELEMENT_TYPE']] = net._idx_node_element['T']
+ ext_grid_pit[:, net._idx_node_element['MINIT']] = 0.005
+ return ext_grid_pit
+
@classmethod
def create_pit_node_entries(cls, net, node_pit):
"""
@@ -49,6 +62,7 @@ def create_pit_node_entries(cls, net, node_pit):
:type node_pit:
:return: No Output.
"""
+
ext_grids = net[cls.table_name()]
ext_grids = ext_grids[ext_grids.in_service.values]
@@ -61,9 +75,9 @@ def create_pit_node_entries(cls, net, node_pit):
get_net_option(net, "use_numba"), junction.values[p_mask], press,
np.ones_like(press, dtype=np.int32))
index_p = junction_idx_lookups[juncts_p]
- node_pit[index_p, PINIT] = press_sum / number
- node_pit[index_p, NODE_TYPE] = P
- node_pit[index_p, EXT_GRID_OCCURENCE] += number
+ node_pit[index_p, net['_idx_node']['PINIT']] = press_sum / number
+ node_pit[index_p, net['_idx_node']['NODE_TYPE']] = net['_idx_node']['P']
+ node_pit[index_p, net['_idx_node']['EXT_GRID_OCCURENCE']] += number
t_mask = np.where(np.isin(ext_grids.type.values, ["t", "pt"]))
t_k = ext_grids.t_k.values[t_mask]
@@ -71,13 +85,13 @@ def create_pit_node_entries(cls, net, node_pit):
junction.values[t_mask], t_k,
np.ones_like(t_k, dtype=np.int32))
index = junction_idx_lookups[juncts_t]
- node_pit[index, TINIT] = t_sum / number
- node_pit[index, NODE_TYPE_T] = T
- node_pit[index, EXT_GRID_OCCURENCE_T] += number
+ node_pit[index, net['_idx_node']['TINIT']] = t_sum / number
+ node_pit[index, net['_idx_node']['NODE_TYPE_T']] = net['_idx_node']['T']
+ node_pit[index, net['_idx_node']['EXT_GRID_OCCURENCE_T']] += number
net["_lookups"]["ext_grid"] = \
np.array(list(set(np.concatenate([net["_lookups"]["ext_grid"], index_p])))) if \
- "ext_grid" in net['_lookups'] else index_p
+ "ext_grid" in net['_lookups'] else index_p
return ext_grids, press
@classmethod
@@ -85,18 +99,15 @@ def extract_results(cls, net, options, branch_results, nodes_connected, branches
"""
Function that extracts certain results.
- :param nodes_connected:
- :type nodes_connected:
- :param branches_connected:
- :type branches_connected:
- :param branch_results:
- :type branch_results:
:param net: The pandapipes network
:type net: pandapipesNet
:param options:
:type options:
+ :param node_name:
+ :type node_name:
:return: No Output.
"""
+
ext_grids = net[cls.table_name()]
if len(ext_grids) == 0:
@@ -104,32 +115,17 @@ def extract_results(cls, net, options, branch_results, nodes_connected, branches
res_table = net["res_" + cls.table_name()]
- branch_pit = net['_pit']['branch']
- node_pit = net["_pit"]["node"]
+ f, t = get_lookup(net, "node_element", "from_to")[cls.table_name()]
+ fa, ta = get_lookup(net, "node_element", "from_to_active")[cls.table_name()]
- p_grids = np.isin(ext_grids.type.values, ["p", "pt"]) & ext_grids.in_service.values
- junction = cls.get_connected_junction(net)
- eg_nodes = get_lookup(net, "node", "index")[cls.get_connected_node_type().table_name()][
- np.array(junction.values[p_grids])]
- node_uni, inverse_nodes, counts = np.unique(eg_nodes, return_counts=True,
- return_inverse=True)
- eg_from_branches = np.isin(branch_pit[:, FROM_NODE], node_uni)
- eg_to_branches = np.isin(branch_pit[:, TO_NODE], node_uni)
- from_nodes = branch_pit[eg_from_branches, FROM_NODE]
- to_nodes = branch_pit[eg_to_branches, TO_NODE]
- mass_flow_from = branch_pit[eg_from_branches, LOAD_VEC_NODES]
- mass_flow_to = branch_pit[eg_to_branches, LOAD_VEC_NODES]
- loads = node_pit[node_uni, LOAD]
- all_index_nodes = np.concatenate([from_nodes, to_nodes, node_uni])
- all_mass_flows = np.concatenate([-mass_flow_from, mass_flow_to, -loads])
- nodes, sum_mass_flows = _sum_by_group(get_net_option(net, "use_numba"), all_index_nodes,
- all_mass_flows)
+ node_element_pit = net["_active_pit"]["node_element"][fa:ta, :]
+ node_elements_active = get_lookup(net, "node_element", "active")[f:t]
# positive results mean that the ext_grid feeds in, negative means that the ext grid
# extracts (like a load)
- res_table["mdot_kg_per_s"].values[p_grids] = \
- cls.sign() * (sum_mass_flows / counts)[inverse_nodes]
- return res_table, ext_grids, node_uni, node_pit, branch_pit
+ res_table["mdot_kg_per_s"].values[node_elements_active] = \
+ cls.sign() * node_element_pit[:, net['_idx_node_element']['MINIT']]
+ return res_table, ext_grids
@classmethod
def get_connected_junction(cls, net):
@@ -147,6 +143,7 @@ def get_component_input(cls):
("junction", "u4"),
("p_bar", "f8"),
("t_k", "f8"),
+ ("fluid", dtype(object)),
("in_service", "bool"),
('type', dtype(object))]
diff --git a/pandapipes/component_models/heat_exchanger_component.py b/pandapipes/component_models/heat_exchanger_component.py
index 24911729..91567019 100644
--- a/pandapipes/component_models/heat_exchanger_component.py
+++ b/pandapipes/component_models/heat_exchanger_component.py
@@ -5,15 +5,14 @@
import numpy as np
from numpy import dtype
-from pandapipes.component_models.abstract_models.branch_wzerolength_models import \
- BranchWZeroLengthComponent
+from pandapipes.component_models.abstract_models.branch_wzerolength_models import BranchWZeroLengthComponent
from pandapipes.component_models.junction_component import Junction
-from pandapipes.idx_branch import TL, ALPHA, TEXT, QEXT, T_OUT, D, AREA, LOSS_COEFFICIENT as LC
+from pandapipes.properties.fluids import is_fluid_gas
from pandapipes.pf.pipeflow_setup import get_fluid
from pandapipes.pf.result_extraction import extract_branch_results_without_internals
try:
- import pplog as logging
+ from pandaplan.core import pplog as logging
except ImportError:
import logging
@@ -51,13 +50,14 @@ def create_pit_branch_entries(cls, net, branch_pit):
:return: No Output.
"""
heat_exchanger_pit = super().create_pit_branch_entries(net, branch_pit)
- heat_exchanger_pit[:, D] = net[cls.table_name()].diameter_m.values
- heat_exchanger_pit[:, AREA] = heat_exchanger_pit[:, D] ** 2 * np.pi / 4
- heat_exchanger_pit[:, LC] = net[cls.table_name()].loss_coefficient.values
- heat_exchanger_pit[:, ALPHA] = 0
- heat_exchanger_pit[:, QEXT] = net[cls.table_name()].qext_w.values
- heat_exchanger_pit[:, TEXT] = 293.15
- heat_exchanger_pit[:, T_OUT] = 307
+ heat_exchanger_pit[:, net['_idx_branch']['D']] = net[cls.table_name()].diameter_m.values
+ heat_exchanger_pit[:, net['_idx_branch']['AREA']] = heat_exchanger_pit[:,
+ net['_idx_branch']['D']] ** 2 * np.pi / 4
+ heat_exchanger_pit[:, net['_idx_branch']['LOSS_COEFFICIENT']] = net[cls.table_name()].loss_coefficient.values
+ heat_exchanger_pit[:, net['_idx_branch']['ALPHA']] = 0
+ heat_exchanger_pit[:, net['_idx_branch']['QEXT']] = net[cls.table_name()].qext_w.values
+ heat_exchanger_pit[:, net['_idx_branch']['TEXT']] = 293.15
+ heat_exchanger_pit[:, net['_idx_branch']['T_OUT']] = 307
@classmethod
def extract_results(cls, net, options, branch_results, nodes_connected, branches_connected):
@@ -67,7 +67,7 @@ def extract_results(cls, net, options, branch_results, nodes_connected, branches
("vdot_norm_m3_per_s", "vf"), ("lambda", "lambda"), ("reynolds", "reynolds")
]
- if get_fluid(net).is_gas:
+ if is_fluid_gas(net):
required_results.extend([
("v_from_m_per_s", "v_gas_from"), ("v_to_m_per_s", "v_gas_to"),
("v_mean_m_per_s", "v_gas_mean"), ("normfactor_from", "normfactor_from"),
@@ -92,7 +92,7 @@ def calculate_temperature_lift(cls, net, he_pit, node_pit):
:return:
:rtype:
"""
- he_pit[:, TL] = 0
+ he_pit[:, net['_idx_branch']['TL']] = 0
@classmethod
def get_component_input(cls):
@@ -120,7 +120,7 @@ def get_result_table(cls, net):
if False, returns columns as tuples also specifying the dtypes
:rtype: (list, bool)
"""
- if get_fluid(net).is_gas:
+ if is_fluid_gas(net):
output = ["v_from_m_per_s", "v_to_m_per_s", "v_mean_m_per_s", "p_from_bar", "p_to_bar",
"t_from_k", "t_to_k", "mdot_from_kg_per_s", "mdot_to_kg_per_s",
"vdot_norm_m3_per_s", "reynolds", "lambda", "normfactor_from",
diff --git a/pandapipes/component_models/junction_component.py b/pandapipes/component_models/junction_component.py
index b55e0e56..5aec291e 100644
--- a/pandapipes/component_models/junction_component.py
+++ b/pandapipes/component_models/junction_component.py
@@ -6,13 +6,14 @@
import numpy as np
from numpy import dtype
+
from pandapipes.component_models.abstract_models.node_models import NodeComponent
from pandapipes.component_models.component_toolbox import p_correction_height_air
-from pandapipes.idx_node import L, ELEMENT_IDX, RHO, PINIT, node_cols, HEIGHT, TINIT, PAMB, \
- ACTIVE as ACTIVE_ND
-from pandapipes.pf.pipeflow_setup import add_table_lookup, get_table_number, \
- get_lookup
-from pandapipes.properties.fluids import get_fluid
+from pandapipes.constants import NORMAL_TEMPERATURE, NORMAL_PRESSURE
+from pandapipes.pf.pipeflow_setup import add_table_lookup, \
+ get_lookup, get_table_number
+from pandapipes.properties.fluids import get_fluid, get_mixture_density, get_mixture_compressibility
+from pandapipes.pf.derivative_toolbox import get_derivative_density_same, get_derivative_density_diff
class Junction(NodeComponent):
@@ -77,15 +78,39 @@ def create_pit_node_entries(cls, net, node_pit):
junctions = net[cls.table_name()]
junction_pit = node_pit[f:t, :]
- junction_pit[:, :] = np.array([table_nr, 0, L] + [0] * (node_cols - 3))
+ junction_pit[:, :] = np.array([table_nr, 0, net['_idx_node']['L']] + [0] * (net['_idx_node']['node_cols'] - 3))
+ junction_pit[:, net['_idx_node']['ELEMENT_IDX']] = junctions.index.values
+ junction_pit[:, net['_idx_node']['HEIGHT']] = junctions.height_m.values
+ junction_pit[:, net['_idx_node']['PINIT']] = junctions.pn_bar.values
+ junction_pit[:, net['_idx_node']['TINIT']] = junctions.tfluid_k.values
+ junction_pit[:, net['_idx_node']['PAMB']] = p_correction_height_air(junction_pit[:, net['_idx_node']['HEIGHT']])
+ junction_pit[:, net['_idx_node']['ACTIVE']] = junctions.in_service.values
+ w = get_lookup(net, 'node', 'w')
+ junction_pit[:, w] = 1 / len(net._fluid)
+
+
+ @classmethod
+ def adaption_before_derivatives_hydraulic(cls, net, branch_pit, node_pit, branch_lookups, node_lookups, options):
+ f, t = node_lookups[cls.table_name()]
+ junction_pit = node_pit[f:t, :]
+ if len(net._fluid) == 1:
+ junction_pit[:, net['_idx_node']['RHO']] = \
+ get_fluid(net, net._fluid[0]).get_density(junction_pit[:, net['_idx_node']['TINIT']])
+ else:
+ for fluid in net._fluid:
+ junction_pit[:, net['_idx_node'][fluid + '_RHO']] = \
+ get_fluid(net, fluid).get_density(junction_pit[:, net['_idx_node']['TINIT']])
+ w = get_lookup(net, 'node', 'w')
+ rho = get_lookup(net, 'node', 'rho')
+ der_rho_same = get_lookup(net, 'node', 'deriv_rho_same')
+ der_rho_diff = get_lookup(net, 'node', 'deriv_rho_diff')
+ mf = junction_pit[:, w]
+ rl = junction_pit[:, rho]
+ temperature = junction_pit[:, net['_idx_node']['TINIT']]
+ junction_pit[:, net['_idx_node']['RHO']] = get_mixture_density(net, temperature, mf)
+ junction_pit[:, der_rho_same] = get_derivative_density_same(mf, rl)
+ junction_pit[:, der_rho_diff] = get_derivative_density_diff(mf, rl)
- junction_pit[:, ELEMENT_IDX] = junctions.index.values
- junction_pit[:, HEIGHT] = junctions.height_m.values
- junction_pit[:, PINIT] = junctions.pn_bar.values
- junction_pit[:, TINIT] = junctions.tfluid_k.values
- junction_pit[:, RHO] = get_fluid(net).get_density(junction_pit[:, TINIT])
- junction_pit[:, PAMB] = p_correction_height_air(junction_pit[:, HEIGHT])
- junction_pit[:, ACTIVE_ND] = junctions.in_service.values
@classmethod
def extract_results(cls, net, options, branch_results, nodes_connected, branches_connected):
@@ -112,13 +137,35 @@ def extract_results(cls, net, options, branch_results, nodes_connected, branches
junction_pit = net["_active_pit"]["node"][fa:ta, :]
junctions_active = get_lookup(net, "node", "active")[f:t]
- if np.any(junction_pit[:, PINIT] < 0):
- warn(UserWarning('Pipeflow converged, however, the results are phyisically incorrect '
- 'as pressure is negative at nodes %s'
- % junction_pit[junction_pit[:, PINIT] < 0, ELEMENT_IDX]))
+ if np.any(junction_pit[:, net['_idx_node']['PINIT']] < 0):
+ warn(UserWarning('Pipeflow converged, however, in your system there is underpressure '
+ ' at nodes %s'
+ % junction_pit[
+ junction_pit[:, net['_idx_node']['PINIT']] < 0, net['_idx_node']['ELEMENT_IDX']]))
+
+ res_table["p_bar"].values[junctions_active] = junction_pit[:, net['_idx_node']['PINIT']]
+ res_table["t_k"].values[junctions_active] = junction_pit[:, net['_idx_node']['TINIT']]
+ numerator = NORMAL_PRESSURE * junction_pit[:, net['_idx_node']['TINIT']]
+ if len(net._fluid) == 1:
+ p = junction_pit[:, net['_idx_node']['PAMB']] + junction_pit[:, net['_idx_node']['PINIT']]
+ normfactor = numerator * get_fluid(net, net._fluid[0]).get_compressibility(p) / (p * NORMAL_TEMPERATURE)
+ res_table["rho_kg_per_m3"].values[junctions_active] = junction_pit[:,
+ net['_idx_node']['RHO']] / normfactor
+ else:
+ w = get_lookup(net, 'node', 'w')
+ mf = junction_pit[:, w]
+ p = junction_pit[:, net['_idx_node']['PAMB']] + junction_pit[:, net['_idx_node']['PINIT']]
+
+ normfactor = numerator * get_mixture_compressibility(
+ net, junction_pit[:, net['_idx_node']['PINIT']], mf) / (p * NORMAL_TEMPERATURE)
+ rho = get_mixture_density(net, junction_pit[:, net['_idx_node']['TINIT']], mf) / normfactor
+ res_table["rho_kg_per_m3"].values[junctions_active] = rho
+ for i, fluid in enumerate(net._fluid):
+ normfactor = numerator * get_fluid(net, fluid).get_compressibility(p) / (p * NORMAL_TEMPERATURE)
+ rho_fluid = get_fluid(net, fluid).get_density(junction_pit[:, net['_idx_node']['TINIT']]) / normfactor
- res_table["p_bar"].values[junctions_active] = junction_pit[:, PINIT]
- res_table["t_k"].values[junctions_active] = junction_pit[:, TINIT]
+ res_table["rho_kg_per_m3_%s" % fluid].values[junctions_active] = rho_fluid
+ res_table["w_%s" % fluid].values[junctions_active] = np.round(junction_pit[:, w[i]], 6)
@classmethod
def get_component_input(cls):
@@ -153,4 +200,11 @@ def get_result_table(cls, net):
if False, returns columns as tuples also specifying the dtypes
:rtype: (list, bool)
"""
- return ["p_bar", "t_k"], True
+ if len(net._fluid) == 1:
+ return ["p_bar", "t_k", "rho_kg_per_m3"], True
+ else:
+ default = ["p_bar", "t_k", "rho_kg_per_m3"]
+
+ add = ["rho_kg_per_m3_%s" % fluid for fluid in net._fluid]
+ add = ["w_%s" % fluid for fluid in net._fluid] + add
+ return default + add, True
diff --git a/pandapipes/component_models/pipe_component.py b/pandapipes/component_models/pipe_component.py
index c913d5ca..1a9cf152 100644
--- a/pandapipes/component_models/pipe_component.py
+++ b/pandapipes/component_models/pipe_component.py
@@ -5,21 +5,19 @@
import matplotlib.pyplot as plt
import numpy as np
from numpy import dtype
+
from pandapipes.component_models.abstract_models import BranchWInternalsComponent
from pandapipes.component_models.component_toolbox import p_correction_height_air, \
vinterp, set_entry_check_repeat
from pandapipes.component_models.junction_component import Junction
from pandapipes.constants import NORMAL_TEMPERATURE, NORMAL_PRESSURE
-from pandapipes.idx_branch import FROM_NODE, TO_NODE, LENGTH, D, AREA, K, \
- VINIT, ALPHA, QEXT, TEXT, LOSS_COEFFICIENT as LC, T_OUT, TL
-from pandapipes.idx_node import PINIT, HEIGHT, TINIT as TINIT_NODE, \
- RHO as RHO_NODES, PAMB, ACTIVE as ACTIVE_ND
-from pandapipes.pf.pipeflow_setup import get_fluid, get_lookup
+from pandapipes.pf.pipeflow_setup import get_lookup, get_fluid
+from pandapipes.properties.fluids import get_mixture_density, is_fluid_gas, get_mixture_compressibility
from pandapipes.pf.result_extraction import extract_branch_results_with_internals, \
extract_branch_results_without_internals
try:
- import pplog as logging
+ from pandaplan.core import pplog as logging
except ImportError:
import logging
@@ -107,17 +105,22 @@ def create_pit_node_entries(cls, net, node_pit):
if table_nr is None:
return
get_lookup(net, "node", "index")
- int_node_pit[:, HEIGHT] = vinterp(junction_pit[fj_nodes, HEIGHT],
- junction_pit[tj_nodes, HEIGHT], int_node_number)
- int_node_pit[:, PINIT] = vinterp(junction_pit[fj_nodes, PINIT],
- junction_pit[tj_nodes, PINIT], int_node_number)
- int_node_pit[:, TINIT_NODE] = vinterp(junction_pit[fj_nodes, TINIT_NODE],
- junction_pit[tj_nodes, TINIT_NODE],
- int_node_number)
- int_node_pit[:, PAMB] = p_correction_height_air(int_node_pit[:, HEIGHT])
- int_node_pit[:, RHO_NODES] = get_fluid(net).get_density(int_node_pit[:, TINIT_NODE])
- int_node_pit[:, ACTIVE_ND] = \
+ int_node_pit[:, net['_idx_node']['HEIGHT']] = vinterp(junction_pit[fj_nodes, net['_idx_node']['HEIGHT']],
+ junction_pit[tj_nodes, net['_idx_node']['HEIGHT']],
+ int_node_number)
+ int_node_pit[:, net['_idx_node']['PINIT']] = vinterp(junction_pit[fj_nodes, net['_idx_node']['PINIT']],
+ junction_pit[tj_nodes, net['_idx_node']['PINIT']],
+ int_node_number)
+ int_node_pit[:, net['_idx_node']['TINIT']] = vinterp(
+ junction_pit[fj_nodes, net['_idx_node']['TINIT']],
+ junction_pit[tj_nodes, net['_idx_node']['TINIT']],
+ int_node_number)
+ int_node_pit[:, net['_idx_node']['PAMB']] = p_correction_height_air(int_node_pit[:, net['_idx_node']['HEIGHT']])
+ int_node_pit[:, net['_idx_node']['ACTIVE']] = \
np.repeat(net[cls.table_name()][cls.active_identifier()].values, int_node_number)
+ if len(net._fluid) == 1:
+ junction_pit[:, net['_idx_node']['RHO']] = \
+ get_fluid(net, net._fluid[0]).get_density(junction_pit[:, net['_idx_node']['TINIT']])
@classmethod
def create_pit_branch_entries(cls, net, branch_pit):
@@ -136,23 +139,25 @@ def create_pit_branch_entries(cls, net, branch_pit):
has_internals = np.any(internal_pipe_number > 1)
tbl = cls.table_name()
set_entry_check_repeat(
- pipe_pit, LENGTH, net[tbl].length_km.values * 1000 / internal_pipe_number,
+ pipe_pit, net['_idx_branch']['LENGTH'], net[tbl].length_km.values * 1000 / internal_pipe_number,
internal_pipe_number, has_internals)
set_entry_check_repeat(
- pipe_pit, K, net[tbl].k_mm.values / 1000, internal_pipe_number, has_internals)
+ pipe_pit, net['_idx_branch']['K'], net[tbl].k_mm.values / 1000, internal_pipe_number, has_internals)
set_entry_check_repeat(
- pipe_pit, ALPHA, net[tbl].alpha_w_per_m2k.values, internal_pipe_number, has_internals)
+ pipe_pit, net['_idx_branch']['ALPHA'], net[tbl].alpha_w_per_m2k.values, internal_pipe_number, has_internals)
set_entry_check_repeat(
- pipe_pit, QEXT, net[tbl].qext_w.values, internal_pipe_number, has_internals)
+ pipe_pit, net['_idx_branch']['QEXT'], net[tbl].qext_w.values, internal_pipe_number, has_internals)
set_entry_check_repeat(
- pipe_pit, TEXT, net[tbl].text_k.values, internal_pipe_number, has_internals)
+ pipe_pit, net['_idx_branch']['TEXT'], net[tbl].text_k.values, internal_pipe_number, has_internals)
set_entry_check_repeat(
- pipe_pit, D, net[tbl].diameter_m.values, internal_pipe_number, has_internals)
+ pipe_pit, net['_idx_branch']['D'], net[tbl].diameter_m.values, internal_pipe_number, has_internals)
set_entry_check_repeat(
- pipe_pit, LC, net[tbl].loss_coefficient.values, internal_pipe_number, has_internals)
+ pipe_pit, net['_idx_branch']['LOSS_COEFFICIENT'], net[tbl].loss_coefficient.values, internal_pipe_number,
+ has_internals)
+
+ pipe_pit[:, net['_idx_branch']['T_OUT']] = 293
+ pipe_pit[:, net['_idx_branch']['AREA']] = pipe_pit[:, net['_idx_branch']['D']] ** 2 * np.pi / 4
- pipe_pit[:, T_OUT] = 293
- pipe_pit[:, AREA] = pipe_pit[:, D] ** 2 * np.pi / 4
@classmethod
def calculate_temperature_lift(cls, net, pipe_pit, node_pit):
@@ -167,7 +172,7 @@ def calculate_temperature_lift(cls, net, pipe_pit, node_pit):
:return:
:rtype:
"""
- pipe_pit[:, TL] = 0
+ pipe_pit[:, net['_idx_branch']['TL']] = 0
@classmethod
def extract_results(cls, net, options, branch_results, nodes_connected, branches_connected):
@@ -176,7 +181,7 @@ def extract_results(cls, net, options, branch_results, nodes_connected, branches
res_nodes_to = [("p_to_bar", "p_to"), ("t_to_k", "temp_to"), ("mdot_to_kg_per_s", "mf_to")]
res_mean = [("vdot_norm_m3_per_s", "vf"), ("lambda", "lambda"), ("reynolds", "reynolds")]
- if get_fluid(net).is_gas:
+ if is_fluid_gas(net):
res_nodes_from.extend(
[("v_from_m_per_s", "v_gas_from"), ("normfactor_from", "normfactor_from")])
res_nodes_to.extend([("v_to_m_per_s", "v_gas_to"), ("normfactor_to", "normfactor_to")])
@@ -218,7 +223,6 @@ def get_internal_results(cls, net, pipe):
pipe_results["VINIT_MEAN"] = np.zeros((len(v_pipe_idx), 2), dtype=np.float64)
if np.all(internal_sections[pipe] >= 2):
- fluid = get_fluid(net)
f, t = get_lookup(net, "branch", "from_to")[cls.table_name()]
pipe_pit = net["_pit"]["branch"][f:t, :]
node_pit = net["_pit"]["node"]
@@ -237,26 +241,38 @@ def get_internal_results(cls, net, pipe):
p_nodes = int_p_lookup[:, 1][selected_indices_p_final]
v_nodes = int_v_lookup[:, 1][selected_indices_v_final]
- v_pipe_data = pipe_pit[v_nodes, VINIT]
- p_node_data = node_pit[p_nodes, PINIT]
- t_node_data = node_pit[p_nodes, TINIT_NODE]
+ v_pipe_data = pipe_pit[v_nodes, net['_idx_branch']['VINIT']]
+ p_node_data = node_pit[p_nodes, net['_idx_node']['PINIT']]
+ t_node_data = node_pit[p_nodes, net['_idx_node']['TINIT']]
- gas_mode = fluid.is_gas
+ gas_mode = is_fluid_gas(net)
if gas_mode:
- from_nodes = pipe_pit[v_nodes, FROM_NODE].astype(np.int32)
- to_nodes = pipe_pit[v_nodes, TO_NODE].astype(np.int32)
- p_from = node_pit[from_nodes, PAMB] + node_pit[from_nodes, PINIT]
- p_to = node_pit[to_nodes, PAMB] + node_pit[to_nodes, PINIT]
+ from_nodes = pipe_pit[v_nodes, net['_idx_branch']['FROM_NODE']].astype(np.int32)
+ to_nodes = pipe_pit[v_nodes, net['_idx_branch']['TO_NODE']].astype(np.int32)
+ p_from = node_pit[from_nodes, net['_idx_node']['PAMB']] + node_pit[
+ from_nodes, net['_idx_node']['PINIT']]
+ p_to = node_pit[to_nodes, net['_idx_node']['PAMB']] + node_pit[to_nodes, net['_idx_node']['PINIT']]
p_mean = np.where(p_from == p_to, p_from,
2 / 3 * (p_from ** 3 - p_to ** 3) / (p_from ** 2 - p_to ** 2))
- numerator = NORMAL_PRESSURE * node_pit[v_nodes, TINIT_NODE]
- normfactor_mean = numerator * fluid.get_property("compressibility", p_mean) \
- / (p_mean * NORMAL_TEMPERATURE)
- normfactor_from = numerator * fluid.get_property("compressibility", p_from) \
- / (p_from * NORMAL_TEMPERATURE)
- normfactor_to = numerator * fluid.get_property("compressibility", p_to) \
- / (p_to * NORMAL_TEMPERATURE)
+ numerator = NORMAL_PRESSURE * node_pit[v_nodes, net['_idx_node']['TINIT']]
+ if len(net._fluid) == 1:
+ fluid = get_fluid(net, net._fluid[0])
+ normfactor_mean = numerator * fluid.get_compressibility(p_mean) \
+ / (p_mean * NORMAL_TEMPERATURE)
+ normfactor_from = numerator * fluid.get_compressibility(p_from) \
+ / (p_from * NORMAL_TEMPERATURE)
+ normfactor_to = numerator * fluid.get_compressibility(p_to) \
+ / (p_to * NORMAL_TEMPERATURE)
+ else:
+ w = get_lookup(net, 'branch', 'w')
+ mass_fraction = pipe_pit[:, w]
+ normfactor_mean = numerator * get_mixture_compressibility(net, p_mean, mass_fraction) \
+ / (p_mean * NORMAL_TEMPERATURE)
+ normfactor_from = numerator * get_mixture_compressibility(net, p_from, mass_fraction) \
+ / (p_from * NORMAL_TEMPERATURE)
+ normfactor_to = numerator * get_mixture_compressibility(net, p_to, mass_fraction) \
+ / (p_to * NORMAL_TEMPERATURE)
v_pipe_data_mean = v_pipe_data * normfactor_mean
v_pipe_data_from = v_pipe_data * normfactor_from
@@ -289,6 +305,7 @@ def get_internal_results(cls, net, pipe):
@classmethod
def get_component_input(cls):
"""
+ Column names and types of the corresponding DataFrame
:return:
:rtype:
@@ -327,7 +344,7 @@ def get_result_table(cls, net):
if False, returns columns as tuples also specifying the dtypes
:rtype: (list, bool)
"""
- if get_fluid(net).is_gas:
+ if is_fluid_gas(net):
output = ["v_from_m_per_s", "v_to_m_per_s", "v_mean_m_per_s", "p_from_bar", "p_to_bar",
"t_from_k", "t_to_k", "mdot_from_kg_per_s", "mdot_to_kg_per_s",
"vdot_norm_m3_per_s", "reynolds", "lambda", "normfactor_from",
@@ -336,7 +353,10 @@ def get_result_table(cls, net):
output = ["v_mean_m_per_s", "p_from_bar", "p_to_bar", "t_from_k", "t_to_k",
"mdot_from_kg_per_s", "mdot_to_kg_per_s", "vdot_norm_m3_per_s", "reynolds",
"lambda"]
- return output, True
+
+ add = ["w_%s" % fluid for fluid in net._fluid] if len(net._fluid) != 1 else []
+
+ return output + add, True
@classmethod
def plot_pipe(cls, net, pipe, pipe_results):
@@ -361,14 +381,14 @@ def plot_pipe(cls, net, pipe, pipe_results):
from_junction_nodes = junction_idx_lookup[net[cls.table_name()]["from_junction"].values]
to_junction_nodes = junction_idx_lookup[net[cls.table_name()]["to_junction"].values]
p_values = np.zeros(len(pipe_p_data[0]) + 2)
- p_values[0] = node_pit[from_junction_nodes[pipe], PINIT]
+ p_values[0] = node_pit[from_junction_nodes[pipe], net['_idx_node']['PINIT']]
p_values[1:-1] = pipe_p_data[:]
- p_values[-1] = node_pit[to_junction_nodes[pipe], PINIT]
+ p_values[-1] = node_pit[to_junction_nodes[pipe], net['_idx_node']['PINIT']]
t_values = np.zeros(len(pipe_t_data[0]) + 2)
- t_values[0] = node_pit[from_junction_nodes[pipe], TINIT_NODE]
+ t_values[0] = node_pit[from_junction_nodes[pipe], net['_idx_node']['TINIT_NODE']]
t_values[1:-1] = pipe_t_data[:]
- t_values[-1] = node_pit[to_junction_nodes[pipe], TINIT_NODE]
+ t_values[-1] = node_pit[to_junction_nodes[pipe], net['_idx_node']['TINIT_NODE']]
v_values = pipe_v_data[0, :]
diff --git a/pandapipes/component_models/pressure_control_component.py b/pandapipes/component_models/pressure_control_component.py
index 7cbabb06..5fb24828 100644
--- a/pandapipes/component_models/pressure_control_component.py
+++ b/pandapipes/component_models/pressure_control_component.py
@@ -5,15 +5,11 @@
import numpy as np
from numpy import dtype
-from pandapipes.component_models.abstract_models.branch_wzerolength_models import \
- BranchWZeroLengthComponent
from pandapipes.component_models.junction_component import Junction
-from pandapipes.idx_branch import D, AREA, TL, \
- JAC_DERIV_DP, JAC_DERIV_DP1, JAC_DERIV_DV, BRANCH_TYPE, LOSS_COEFFICIENT as LC
-from pandapipes.idx_node import PINIT, NODE_TYPE, PC
+from pandapipes.component_models.abstract_models.branch_wzerolength_models import BranchWZeroLengthComponent
from pandapipes.pf.pipeflow_setup import get_lookup
+from pandapipes.properties.fluids import is_fluid_gas, get_fluid
from pandapipes.pf.result_extraction import extract_branch_results_without_internals
-from pandapipes.properties.fluids import get_fluid
class PressureControlComponent(BranchWZeroLengthComponent):
@@ -46,8 +42,8 @@ def create_pit_node_entries(cls, net, node_pit):
junction_idx_lookups = get_lookup(net, "node", "index")[
cls.get_connected_node_type().table_name()]
index_pc = junction_idx_lookups[juncts]
- node_pit[index_pc, NODE_TYPE] = PC
- node_pit[index_pc, PINIT] = press
+ node_pit[index_pc, net['_idx_node']['NODE_TYPE']] = net['_idx_node']['PC']
+ node_pit[index_pc, net['_idx_node']['PINIT']] = press
@classmethod
def create_pit_branch_entries(cls, net, branch_pit):
@@ -60,24 +56,21 @@ def create_pit_branch_entries(cls, net, branch_pit):
:return: No Output.
"""
pc_pit = super().create_pit_branch_entries(net, branch_pit)
- pc_pit[:, D] = 0.1
- pc_pit[:, AREA] = pc_pit[:, D] ** 2 * np.pi / 4
- pc_pit[net[cls.table_name()].control_active.values, BRANCH_TYPE] = PC
- pc_pit[:, LC] = net[cls.table_name()].loss_coefficient.values
+ pc_pit[:, net['_idx_branch']['D']] = 0.1
+ pc_pit[:, net['_idx_branch']['AREA']] = pc_pit[:, net['_idx_branch']['D']] ** 2 * np.pi / 4
+ pc_pit[net[cls.table_name()].control_active.values, net['_idx_branch']['BRANCH_TYPE']] = net['_idx_node']['PC']
+ pc_pit[:, net['_idx_branch']['LOSS_COEFFICIENT']] = net[cls.table_name()].loss_coefficient.values
- @classmethod
- def adaption_before_derivatives_hydraulic(cls, net, branch_pit, node_pit, idx_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):
# set all PC branches to derivatives to 0
- f, t = idx_lookups[cls.table_name()]
+ f, t = branch_lookups[cls.table_name()]
press_pit = branch_pit[f:t, :]
- pc_branch = press_pit[:, BRANCH_TYPE] == PC
- press_pit[pc_branch, JAC_DERIV_DP] = 0
- press_pit[pc_branch, JAC_DERIV_DP1] = 0
- press_pit[pc_branch, JAC_DERIV_DV] = 0
+ pc_branch = press_pit[:, net['_idx_branch']['BRANCH_TYPE']] == net['_idx_node']['PC']
+ press_pit[pc_branch, net['_idx_branch']['JAC_DERIV_DP']] = 0
+ press_pit[pc_branch, net['_idx_branch']['JAC_DERIV_DP1']] = 0
+ press_pit[pc_branch, net['_idx_branch']['JAC_DERIV_DV']] = 0
@classmethod
def calculate_temperature_lift(cls, net, pc_pit, node_pit):
@@ -92,7 +85,7 @@ def calculate_temperature_lift(cls, net, pc_pit, node_pit):
:return:
:rtype:
"""
- pc_pit[:, TL] = 0
+ pc_pit[:, net['_idx_branch']['TL']] = 0
@classmethod
def extract_results(cls, net, options, branch_results, nodes_connected, branches_connected):
@@ -117,7 +110,7 @@ def extract_results(cls, net, options, branch_results, nodes_connected, branches
("vdot_norm_m3_per_s", "vf")
]
- if get_fluid(net).is_gas:
+ if is_fluid_gas(net):
required_results.extend([
("v_from_m_per_s", "v_gas_from"), ("v_to_m_per_s", "v_gas_to"),
("normfactor_from", "normfactor_from"), ("normfactor_to", "normfactor_to")
@@ -165,7 +158,7 @@ def get_result_table(cls, net):
if False, returns columns as tuples also specifying the dtypes
:rtype: (list, bool)
"""
- if get_fluid(net).is_gas:
+ if is_fluid_gas(net):
output = ["v_from_m_per_s", "v_to_m_per_s", "p_from_bar", "p_to_bar",
"t_from_k", "t_to_k", "mdot_from_kg_per_s", "mdot_to_kg_per_s",
"vdot_norm_m3_per_s", "normfactor_from", "normfactor_to"]
diff --git a/pandapipes/component_models/pump_component.py b/pandapipes/component_models/pump_component.py
index d3db1803..a699c7f8 100644
--- a/pandapipes/component_models/pump_component.py
+++ b/pandapipes/component_models/pump_component.py
@@ -11,20 +11,17 @@
from pandapipes.component_models.abstract_models.branch_wzerolength_models import \
BranchWZeroLengthComponent
from pandapipes.constants import NORMAL_TEMPERATURE, NORMAL_PRESSURE, R_UNIVERSAL, P_CONVERSION
-from pandapipes.idx_branch import STD_TYPE, VINIT, D, AREA, TL, LOSS_COEFFICIENT as LC, FROM_NODE, \
- TINIT, PL
-from pandapipes.idx_node import PINIT, PAMB, TINIT as TINIT_NODE
from pandapipes.pf.pipeflow_setup import get_fluid, get_net_option, get_lookup
from pandapipes.pf.result_extraction import extract_branch_results_without_internals
+from pandapipes.properties.fluids import is_fluid_gas, get_mixture_molar_mass, get_mixture_compressibility, get_fluid
try:
- import pplog as logging
+ import pandaplan.core.pplog as logging
except ImportError:
import logging
logger = logging.getLogger(__name__)
-
class Pump(BranchWZeroLengthComponent):
"""
@@ -61,30 +58,36 @@ def create_pit_branch_entries(cls, net, branch_pit):
std_types_lookup = np.array(list(net.std_types[cls.table_name()].keys()))
std_type, pos = np.where(net[cls.table_name()]['std_type'].values
== std_types_lookup[:, np.newaxis])
- pump_pit[pos, STD_TYPE] = std_type
- pump_pit[:, D] = 0.1
- pump_pit[:, AREA] = pump_pit[:, D] ** 2 * np.pi / 4
- pump_pit[:, LC] = 0
+ pump_pit[pos, net['_idx_branch']['STD_TYPE']] = std_type
+ pump_pit[:, net['_idx_branch']['D']] = 0.1
+ pump_pit[:, net['_idx_branch']['AREA']] = pump_pit[:, net['_idx_branch']['D']] ** 2 * np.pi / 4
+ pump_pit[:, net['_idx_branch']['LOSS_COEFFICIENT']] = 0
@classmethod
- def adaption_before_derivatives_hydraulic(cls, net, branch_pit, node_pit, idx_lookups, options):
- # calculation of pressure lift
- f, t = idx_lookups[cls.table_name()]
+ 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)
+ f, t = branch_lookups[cls.table_name()]
pump_pit = branch_pit[f:t, :]
- area = pump_pit[:, AREA]
- idx = pump_pit[:, STD_TYPE].astype(int)
+ area = pump_pit[:, net['_idx_branch']['AREA']]
+ idx = pump_pit[:, net['_idx_branch']['STD_TYPE']].astype(int)
std_types = np.array(list(net.std_types['pump'].keys()))[idx]
- from_nodes = pump_pit[:, FROM_NODE].astype(np.int32)
+ from_nodes = pump_pit[:, net['_idx_branch']['FROM_NODE']].astype(np.int32)
# to_nodes = pump_pit[:, TO_NODE].astype(np.int32)
- fluid = get_fluid(net)
- p_from = node_pit[from_nodes, PAMB] + node_pit[from_nodes, PINIT]
+ p_from = node_pit[from_nodes, net['_idx_node']['PAMB']] + node_pit[from_nodes, net['_idx_node']['PINIT']]
# p_to = node_pit[to_nodes, PAMB] + node_pit[to_nodes, PINIT]
- numerator = NORMAL_PRESSURE * pump_pit[:, TINIT]
- v_mps = pump_pit[:, VINIT]
- if fluid.is_gas:
+ numerator = NORMAL_PRESSURE * pump_pit[:, net['_idx_branch']['TINIT']]
+ v_mps = pump_pit[:, net['_idx_branch']['VINIT']]
+ if is_fluid_gas(net):
# consider volume flow at inlet
- normfactor_from = numerator * fluid.get_property("compressibility", p_from) \
- / (p_from * NORMAL_TEMPERATURE)
+ if len(net._fluid) == 1:
+ fluid = net._fluid[0]
+ normfactor_from = numerator * get_fluid(net, fluid).get_compressibility(p_from) \
+ / (p_from * NORMAL_TEMPERATURE)
+ else:
+ w = get_lookup(net, 'branch', 'w')
+ mass_fraction = pump_pit[:, w]
+ normfactor_from = numerator * get_mixture_compressibility(net, p_from, mass_fraction) \
+ / (p_from * NORMAL_TEMPERATURE)
v_mean = v_mps * normfactor_from
else:
v_mean = v_mps
@@ -92,7 +95,7 @@ def adaption_before_derivatives_hydraulic(cls, net, branch_pit, node_pit, idx_lo
fcts = itemgetter(*std_types)(net['std_types']['pump'])
fcts = [fcts] if not isinstance(fcts, tuple) else fcts
pl = np.array(list(map(lambda x, y: x.get_pressure(y), fcts, vol)))
- pump_pit[:, PL] = pl
+ pump_pit[:, net['_idx_branch']['PL']] = pl
@classmethod
def calculate_temperature_lift(cls, net, pump_pit, node_pit):
@@ -107,7 +110,7 @@ def calculate_temperature_lift(cls, net, pump_pit, node_pit):
:return:
:rtype:
"""
- pump_pit[:, TL] = 0
+ pump_pit[:, net['_idx_branch']['TL']] = 0
@classmethod
def extract_results(cls, net, options, branch_results, nodes_connected, branches_connected):
@@ -134,7 +137,7 @@ def extract_results(cls, net, options, branch_results, nodes_connected, branches
("vdot_norm_m3_per_s", "vf"), ("deltap_bar", "pl")
]
- if get_fluid(net).is_gas:
+ if is_fluid_gas(net):
required_results.extend([
("v_from_m_per_s", "v_gas_from"), ("v_to_m_per_s", "v_gas_to"),
("normfactor_from", "normfactor_from"), ("normfactor_to", "normfactor_to")
@@ -148,20 +151,39 @@ def extract_results(cls, net, options, branch_results, nodes_connected, branches
if calc_compr_pow:
f, t = get_lookup(net, "branch", "from_to")[cls.table_name()]
res_table = net["res_" + cls.table_name()]
- if net.fluid.is_gas:
+ pl = branch_results["pl"][f:t]
+ if is_fluid_gas(net):
p_from = branch_results["p_from"][f:t]
p_to = branch_results["p_to"][f:t]
from_nodes = branch_results["from_nodes"][f:t]
- t0 = net["_pit"]["node"][from_nodes, TINIT_NODE]
+ t0 = net["_pit"]["node"][from_nodes, net['_idx_branch']['TINIT']]
mf_sum_int = branch_results["mf_from"][f:t]
# calculate ideal compression power
- compr = get_fluid(net).get_property("compressibility", p_from)
- try:
- molar_mass = net.fluid.get_molar_mass() # [g/mol]
- except UserWarning:
- logger.error('Molar mass is missing in your fluid. Before you are able to retrieve '
- 'the compression power make sure that the molar mass is defined')
+ if len(net._fluid) == 1:
+ fluid = net._fluid[0]
+ compr = get_fluid(net, fluid).get_compressibility(p_from)
+ try:
+ molar_mass = get_fluid(net, fluid).get_molar_mass() # [g/mol]
+ except UserWarning:
+ logger.error('Molar mass is missing in your fluid. Before you are able to retrieve '
+ 'the compression power make sure that the molar mass is defined')
+ molar_mass_given=False
+ else:
+ molar_mass_given=True
else:
+ node_pit = net["_active_pit"]["node"]
+ w = get_lookup(net, 'node', 'w')
+ mass_fraction = node_pit[:, w]
+ compr = get_mixture_compressibility(net, p_from, mass_fraction)
+ try:
+ molar_mass = get_mixture_molar_mass(net, mass_fraction) # [g/mol]
+ except UserWarning:
+ logger.error('Molar mass is missing in your fluid. Before you are able to retrieve '
+ 'the compression power make sure that the molar mass is defined')
+ molar_mass_given=False
+ else:
+ molar_mass_given=True
+ if molar_mass_given:
r_spec = 1e3 * R_UNIVERSAL / molar_mass # [J/(kg * K)]
# 'kappa' heat capacity ratio:
k = 1.4 # TODO: implement proper calculation of kappa
@@ -170,8 +192,8 @@ def extract_results(cls, net, options, branch_results, nodes_connected, branches
res_table['compr_power_mw'].values[:] = w_real_isentr * np.abs(mf_sum_int) / 10 ** 6
else:
vf_sum_int = branch_results["vf"][f:t]
- pl = branch_results["pl"][f:t]
res_table['compr_power_mw'].values[:] = pl * P_CONVERSION * vf_sum_int / 10 ** 6
+ res_table['deltap_bar'].values[:] = pl
@classmethod
def get_component_input(cls):
@@ -203,7 +225,7 @@ def get_result_table(cls, net):
"""
calc_compr_pow = get_net_option(net, 'calc_compression_power')
- if get_fluid(net).is_gas:
+ if is_fluid_gas(net):
output = ["deltap_bar",
"v_from_m_per_s", "v_to_m_per_s",
"p_from_bar", "p_to_bar",
diff --git a/pandapipes/component_models/sink_component.py b/pandapipes/component_models/sink_component.py
index 7600453e..f3075d06 100644
--- a/pandapipes/component_models/sink_component.py
+++ b/pandapipes/component_models/sink_component.py
@@ -1,8 +1,10 @@
# Copyright (c) 2020-2022 by Fraunhofer Institute for Energy Economics
# 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.
+
from pandapipes.component_models.junction_component import Junction
from pandapipes.component_models.abstract_models.const_flow_models import ConstFlow
+from pandapipes.pf.pipeflow_setup import get_lookup
class Sink(ConstFlow):
@@ -21,3 +23,18 @@ def sign(cls):
@classmethod
def get_connected_node_type(cls):
return Junction
+
+ @classmethod
+ def node_element_relevant(cls, net):
+ return False
+
+ @classmethod
+ def create_pit_node_entries(cls, net, node_pit):
+ super().create_pit_node_entries(net, node_pit)
+ fluids = net._fluid
+ if len(fluids) != 1:
+ sinks = net[cls.table_name()]
+ juncts = sinks.loc[sinks.mdot_kg_per_s.values == 0, 'junction']
+ junction_idx_lookups = get_lookup(net, "node", "index")[cls.get_connected_node_type().table_name()]
+ index = junction_idx_lookups[juncts]
+ node_pit[index, net['_idx_node']['LOAD']] += 0#10 ** -16
\ No newline at end of file
diff --git a/pandapipes/component_models/source_component.py b/pandapipes/component_models/source_component.py
index bb91b3aa..9ad7110e 100644
--- a/pandapipes/component_models/source_component.py
+++ b/pandapipes/component_models/source_component.py
@@ -1,8 +1,14 @@
# Copyright (c) 2020-2022 by Fraunhofer Institute for Energy Economics
# 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.
-from pandapipes.component_models.junction_component import Junction
+
+import numpy as np
+from numpy import dtype
+
from pandapipes.component_models.abstract_models.const_flow_models import ConstFlow
+from pandapipes.component_models.junction_component import Junction
+from pandapipes.pf.internals_toolbox import _sum_by_group
+from pandapipes.pf.pipeflow_setup import get_lookup, get_net_option
class Source(ConstFlow):
@@ -21,3 +27,51 @@ def sign(cls):
@classmethod
def get_connected_node_type(cls):
return Junction
+
+ @classmethod
+ def node_element_relevant(cls, net):
+ return len(net._fluid) != 1
+
+ @classmethod
+ def create_pit_node_element_entries(cls, net, node_element_pit):
+ fluids = net._fluid
+ if len(fluids) != 1:
+ source_pit = super().create_pit_node_element_entries(net, node_element_pit)
+ sources = net[cls.table_name()]
+ helper = sources.in_service.values * sources.scaling.values
+ mf = np.nan_to_num(sources.mdot_kg_per_s.values)
+ mass_flow_loads = mf * helper
+ source_pit[:, net._idx_node_element['MINIT']] = mass_flow_loads
+
+ @classmethod
+ def create_pit_node_entries(cls, net, node_pit):
+ super().create_pit_node_entries(net, node_pit)
+ sources = net[cls.table_name()]
+ fluids = net._fluid
+ if len(fluids) != 1:
+ helper = sources.in_service.values * sources.scaling.values * cls.sign()
+ mf = np.nan_to_num(sources.mdot_kg_per_s.values)
+ mass_flow_loads = mf * helper
+ for fluid in fluids:
+ use_numba = get_net_option(net, "use_numba")
+ juncts, sources_sum = _sum_by_group(use_numba, sources.junction.values[sources.fluid == fluid],
+ mass_flow_loads[sources.fluid == fluid])
+ junction_idx_lookups = get_lookup(net, "node", "index")[cls.get_connected_node_type().table_name()]
+ index = junction_idx_lookups[juncts]
+ node_pit[index, net['_idx_node'][fluid + '_LOAD']] -= sources_sum
+
+ @classmethod
+ def get_component_input(cls):
+ """
+ Column names and types of the corresponding DataFrame
+
+ :return:
+ :rtype:
+ """
+ return [("name", dtype(object)),
+ ("junction", "u4"),
+ ("mdot_kg_per_s", "f8"),
+ ("fluid", dtype(object)),
+ ("scaling", "f8"),
+ ("in_service", "bool"),
+ ("type", dtype(object))]
diff --git a/pandapipes/component_models/valve_component.py b/pandapipes/component_models/valve_component.py
index 544ab242..6a190696 100644
--- a/pandapipes/component_models/valve_component.py
+++ b/pandapipes/component_models/valve_component.py
@@ -5,12 +5,10 @@
import numpy as np
from numpy import dtype
-from pandapipes.component_models.abstract_models.branch_wzerolength_models import \
- BranchWZeroLengthComponent
+from pandapipes.component_models.abstract_models import BranchWZeroLengthComponent
from pandapipes.component_models.junction_component import Junction
-from pandapipes.idx_branch import D, AREA, LOSS_COEFFICIENT as LC, TL
from pandapipes.pf.result_extraction import extract_branch_results_without_internals
-from pandapipes.properties.fluids import get_fluid
+from pandapipes.properties.fluids import is_fluid_gas, get_fluid
class Valve(BranchWZeroLengthComponent):
@@ -47,9 +45,9 @@ def create_pit_branch_entries(cls, net, branch_pit):
:return: No Output.
"""
valve_pit = super().create_pit_branch_entries(net, branch_pit)
- valve_pit[:, D] = net[cls.table_name()].diameter_m.values
- valve_pit[:, AREA] = valve_pit[:, D] ** 2 * np.pi / 4
- valve_pit[:, LC] = net[cls.table_name()].loss_coefficient.values
+ valve_pit[:, net['_idx_branch']['D']] = net[cls.table_name()].diameter_m.values
+ valve_pit[:, net['_idx_branch']['AREA']] = valve_pit[:, net['_idx_branch']['D']] ** 2 * np.pi / 4
+ valve_pit[:, net['_idx_branch']['LOSS_COEFFICIENT']] = net[cls.table_name()].loss_coefficient.values
@classmethod
def calculate_temperature_lift(cls, net, valve_pit, node_pit):
@@ -64,7 +62,7 @@ def calculate_temperature_lift(cls, net, valve_pit, node_pit):
:return:
:rtype:
"""
- valve_pit[:, TL] = 0
+ valve_pit[:, net['_idx_branch']['TL']] = 0
@classmethod
def get_component_input(cls):
@@ -89,7 +87,7 @@ def extract_results(cls, net, options, branch_results, nodes_connected, branches
("vdot_norm_m3_per_s", "vf"), ("lambda", "lambda"), ("reynolds", "reynolds")
]
- if get_fluid(net).is_gas:
+ if is_fluid_gas(net):
required_results.extend([
("v_from_m_per_s", "v_gas_from"), ("v_to_m_per_s", "v_gas_to"),
("v_mean_m_per_s", "v_gas_mean"), ("normfactor_from", "normfactor_from"),
@@ -111,13 +109,18 @@ def get_result_table(cls, net):
if False, returns columns as tuples also specifying the dtypes
:rtype: (list, bool)
"""
- if get_fluid(net).is_gas:
+ if is_fluid_gas(net):
output = ["v_from_m_per_s", "v_to_m_per_s", "v_mean_m_per_s", "p_from_bar", "p_to_bar",
"t_from_k", "t_to_k", "mdot_from_kg_per_s", "mdot_to_kg_per_s",
"vdot_norm_m3_per_s", "reynolds", "lambda", "normfactor_from",
"normfactor_to"]
+
+ add = ["w_%s" % fluid for fluid in net._fluid]
+
else:
output = ["v_mean_m_per_s", "p_from_bar", "p_to_bar", "t_from_k", "t_to_k",
"mdot_from_kg_per_s", "mdot_to_kg_per_s", "vdot_norm_m3_per_s", "reynolds",
"lambda"]
- return output, True
+
+ add = []
+ return output + add, True
diff --git a/pandapipes/control/controller/p_to_mdot_control.py b/pandapipes/control/controller/p_to_mdot_control.py
new file mode 100644
index 00000000..5ec175e2
--- /dev/null
+++ b/pandapipes/control/controller/p_to_mdot_control.py
@@ -0,0 +1,81 @@
+import copy
+
+import numpy as np
+
+from pandapipes.pipeflow_setup import get_lookup
+from pandapipes.properties.fluids import get_mixture_higher_heating_value, get_mixture_lower_heating_value, get_fluid
+from pandapower.control import ConstControl
+from pandapower.toolbox import write_to_net
+
+
+class PtoMdotController(ConstControl):
+
+ def __init__(self, net, element, element_index, profile_name=None, data_source=None,
+ efficiency_factor=1.05, calorific_value='lower',
+ scale_factor=1.0, in_service=True, recycle=True, order=-1, level=-1,
+ drop_same_existing_ctrl=False, matching_params=None,
+ initial_run=True, **kwargs):
+ # just calling init of the parent
+ if matching_params is None:
+ matching_params = {"element": element, "variable": 'mdot_kg_per_s',
+ "element_index": element_index}
+ super().__init__(net, element, 'mdot_kg_per_s', element_index, profile_name, data_source,
+ scale_factor, in_service, recycle, order, level,
+ drop_same_existing_ctrl, matching_params, initial_run, **kwargs)
+ if calorific_value not in ['lower', 'higher']: raise (
+ AttributeError("Choose either 'higher' or 'lower' calorific value "))
+ self.eff = efficiency_factor
+ self.cal = calorific_value
+
+ def time_step(self, net, time):
+ self.mf = None
+ self.applied = False
+ if self.data_source is None:
+ self.values = net[self.element][self.variable].loc[self.element_index]
+ else:
+ self.values = self.data_source.get_time_step_value(time_step=time,
+ profile_name=self.profile_name,
+ scale_factor=self.scale_factor)
+ if len(net._fluid) == 1:
+ fluid = net._fluid[0]
+ cal = get_fluid(net, fluid).get_higher_heating_value() if self.cal == 'higher' else \
+ get_fluid(net, fluid).get_lower_heating_value()
+ self.values *= 1 / self.eff / cal / 3.6 # from W (/1000) and kWh (*3600) to kg / s
+ self.values = self.values.astype(float)
+ else:
+ w = get_lookup(net, 'node', 'w')
+ node_pit = net._pit['node']
+ index = get_lookup(net, 'node', "index")['junction'][net.sink.junction.values]
+ mf = node_pit[index, :][:, w]
+
+ cal = get_mixture_higher_heating_value(net, mf) \
+ if self.cal == 'higher' else get_mixture_lower_heating_value(net, mf)
+ self.values_mdot = copy.deepcopy(self.values)
+ self.p_to_mdot(cal)
+ if self.values is not None:
+ write_to_net(net, self.element, self.element_index, self.variable, self.values, self.write_flag)
+
+ def p_to_mdot(self, heating_value):
+ self.values = self.values_mdot * 1 / self.eff / heating_value / 3.6
+ self.values = self.values.astype(float)
+
+ def control_step(self, net):
+ w = get_lookup(net, 'node', 'w')
+ node_pit = net._pit['node']
+ if len(net._fluid) == 1:
+ self.applied = True
+ elif self.values is None:
+ self.applied = True
+ elif (self.mf is None) or np.any((self.mf - node_pit[:, w]) >= 10 ** -3):
+ w = get_lookup(net, 'node', 'w')
+ node_pit = net._pit['node']
+ index = get_lookup(net, 'node', "index")['junction'][net.sink.junction.values]
+ mf = node_pit[index, :][:, w]
+
+ cal = get_mixture_higher_heating_value(net, mf) \
+ if self.cal == 'higher' else get_mixture_lower_heating_value(net, mf)
+ self.p_to_mdot(cal)
+ write_to_net(net, self.element, self.element_index, self.variable, self.values, self.write_flag)
+ self.mf = node_pit[:, w]
+ else:
+ self.applied = True
diff --git a/pandapipes/create.py b/pandapipes/create.py
index 83c9265e..a90f6587 100644
--- a/pandapipes/create.py
+++ b/pandapipes/create.py
@@ -8,7 +8,7 @@
from pandapipes.component_models import Junction, Sink, Source, Pump, Pipe, ExtGrid, \
HeatExchanger, Valve, CirculationPumpPressure, CirculationPumpMass, PressureControlComponent, \
Compressor
-from pandapipes.component_models.component_toolbox import add_new_component
+from pandapipes.create_toolbox import add_new_component
from pandapipes.pandapipes_net import pandapipesNet, get_basic_net_entries, add_default_components
from pandapipes.properties import call_lib
from pandapipes.properties.fluids import Fluid, _add_fluid_to_net
@@ -20,14 +20,14 @@
_add_multiple_branch_geodata, _check_branch_element, _check_multiple_branch_elements
try:
- import pplog as logging
+ from pandaplan.core import pplog as logging
except ImportError:
import logging
logger = logging.getLogger(__name__)
-def create_empty_network(name="", fluid=None, add_stdtypes=True):
+def create_empty_network(name="", add_stdtypes=True):
"""
This function initializes the pandapipes datastructure.
@@ -53,15 +53,6 @@ def create_empty_network(name="", fluid=None, add_stdtypes=True):
net['name'] = name
if add_stdtypes:
add_basic_std_types(net)
-
- if fluid is not None:
- if isinstance(fluid, Fluid):
- net["fluid"] = fluid
- elif isinstance(fluid, str):
- create_fluid_from_lib(net, fluid)
- else:
- logger.warning("The fluid %s cannot be added to the net Only fluids of type Fluid or "
- "strings can be used." % fluid)
return net
@@ -160,7 +151,7 @@ def create_sink(net, junction, mdot_kg_per_s, scaling=1., name=None, index=None,
return index
-def create_source(net, junction, mdot_kg_per_s, scaling=1., name=None, index=None, in_service=True,
+def create_source(net, junction, mdot_kg_per_s, fluid='hgas', scaling=1., name=None, index=None, in_service=True,
type='source', **kwargs):
"""
Adds one source in table net["source"].
@@ -197,15 +188,30 @@ def create_source(net, junction, mdot_kg_per_s, scaling=1., name=None, index=Non
index = _get_index_with_check(net, "source", index)
- cols = ["name", "junction", "mdot_kg_per_s", "scaling", "in_service", "type"]
- vals = [name, junction, mdot_kg_per_s, scaling, bool(in_service), type]
- _set_entries(net, "source", index, **dict(zip(cols, vals)), **kwargs)
-
- return index
+ cols = ["name", "junction", "mdot_kg_per_s", "fluid", "scaling", "in_service", "type"]
+
+ if isinstance(fluid, Fluid):
+ _add_fluid_to_net(net, fluid, False)
+ vals = [name, junction, mdot_kg_per_s, fluid.name, scaling, bool(in_service), type]
+ _set_entries(net, "source", index, **dict(zip(cols, vals)), **kwargs)
+ return index
+ elif isinstance(fluid, str):
+ if fluid in net.fluid:
+ vals = [name, junction, mdot_kg_per_s, fluid, scaling, bool(in_service), type]
+ _set_entries(net, "source", index, **dict(zip(cols, vals)), **kwargs)
+ return index
+ else:
+ if fluid not in net.fluid:
+ create_fluid_from_lib(net, fluid)
+ vals = [name, junction, mdot_kg_per_s, fluid, scaling, bool(in_service), type]
+ _set_entries(net, "source", index, **dict(zip(cols, vals)), **kwargs)
+ return index
+ else:
+ logger.warning("The fluid %s cannot be added to the net. Only fluids of type Fluid or "
+ "strings can be used." % fluid)
-def create_ext_grid(net, junction, p_bar, t_k, name=None, in_service=True, index=None, type="pt",
- **kwargs):
+def create_ext_grid(net, junction, p_bar, t_k, fluid, name=None, in_service=True, index=None, type="pt", **kwargs):
"""
Creates an external grid and adds it to the table net["ext_grid"]. It transfers the junction
that it is connected to into a node with fixed value for either pressure, temperature or both
@@ -251,9 +257,22 @@ def create_ext_grid(net, junction, p_bar, t_k, name=None, in_service=True, index
_check_junction_element(net, junction)
index = _get_index_with_check(net, "ext_grid", index, name="external grid")
- cols = ["name", "junction", "p_bar", "t_k", "in_service", "type"]
- vals = [name, junction, p_bar, t_k, bool(in_service), type]
- _set_entries(net, "ext_grid", index, **dict(zip(cols, vals)), **kwargs)
+ cols = ["name", "junction", "p_bar", "t_k", "fluid", "in_service", "type"]
+
+ if isinstance(fluid, Fluid):
+ _add_fluid_to_net(net, fluid, False)
+ vals = [name, junction, p_bar, t_k, fluid.name, bool(in_service), type]
+ _set_entries(net, "ext_grid", index, **dict(zip(cols, vals)), **kwargs)
+ return index
+ elif isinstance(fluid, str):
+ if fluid not in net.fluid:
+ create_fluid_from_lib(net, fluid)
+ vals = [name, junction, p_bar, t_k, fluid, bool(in_service), type]
+ _set_entries(net, "ext_grid", index, **dict(zip(cols, vals)), **kwargs)
+ return index
+ else:
+ logger.warning("The fluid %s cannot be added to the net. Only fluids of type Fluid or "
+ "strings can be used." % fluid)
return index
@@ -301,11 +320,11 @@ def create_heat_exchanger(net, from_junction, to_junction, diameter_m, qext_w, l
index = _get_index_with_check(net, "heat_exchanger", index, "heat exchanger")
check_branch(net, "Heat exchanger", index, from_junction, to_junction)
- v = {"name": name, "from_junction": from_junction, "to_junction": to_junction,
- "diameter_m": diameter_m, "qext_w": qext_w, "loss_coefficient": loss_coefficient,
- "in_service": bool(in_service), "type": type}
- _set_entries(net, "heat_exchanger", index, **v, **kwargs)
-
+ cols = ["name", "from_junction", "to_junction", "diameter_m", "qext_w", "loss_coefficient",
+ "in_service", "type"]
+ vals = [name, from_junction, to_junction, diameter_m, qext_w, loss_coefficient,
+ bool(in_service), type]
+ _set_entries(net, "heat_exchanger", index, **dict(zip(cols, vals)), **kwargs)
return index
@@ -632,7 +651,7 @@ def create_pump_from_parameters(net, from_junction, to_junction, new_std_type_na
def create_circ_pump_const_pressure(net, from_junction, to_junction, p_bar, plift_bar,
- t_k=None, name=None, index=None, in_service=True, type="pt",
+ t_k=None, fluid='water', name=None, index=None, in_service=True, type="pt",
**kwargs):
"""
Adds one circulation pump with a constant pressure lift in table net["circ_pump_pressure"].
@@ -679,15 +698,28 @@ def create_circ_pump_const_pressure(net, from_junction, to_junction, p_bar, plif
name="circulation pump with constant pressure")
check_branch(net, "circulation pump with constant pressure", index, from_junction, to_junction)
- v = {"name": name, "from_junction": from_junction, "to_junction": to_junction, "p_bar": p_bar,
- "t_k": t_k, "plift_bar": plift_bar, "in_service": bool(in_service), "type": type}
- _set_entries(net, "circ_pump_pressure", index, **v, **kwargs)
-
+ cols = ["name", "from_junction", "to_junction", "p_bar", "t_k", "plift_bar", "fluid", "in_service", "type"]
+
+ if isinstance(fluid, Fluid):
+ net["fluid"][fluid.name] = fluid
+ vals = [name, from_junction, to_junction, p_bar, t_k, plift_bar, fluid.name,
+ bool(in_service), type]
+ _set_entries(net, "circ_pump_pressure", index, **dict(zip(cols, vals)), **kwargs)
+ return index
+ elif isinstance(fluid, str):
+ create_fluid_from_lib(net, fluid)
+ vals = [name, from_junction, to_junction, p_bar, t_k, plift_bar, fluid,
+ bool(in_service), type]
+ _set_entries(net, "circ_pump_pressure", index, **dict(zip(cols, vals)), **kwargs)
+ return index
+ else:
+ logger.warning("The fluid %s cannot be added to the net. Only fluids of type Fluid or "
+ "strings can be used." % fluid)
return index
def create_circ_pump_const_mass_flow(net, from_junction, to_junction, p_bar, mdot_kg_per_s,
- t_k=None, name=None, index=None, in_service=True,
+ t_k=None, fluid='water', name=None, index=None, in_service=True,
type="pt", **kwargs):
"""
Adds one circulation pump with a constant mass flow in table net["circ_pump_mass"].
@@ -734,10 +766,23 @@ def create_circ_pump_const_mass_flow(net, from_junction, to_junction, p_bar, mdo
name="circulation pump with constant mass flow")
check_branch(net, "circulation pump with constant mass flow", index, from_junction, to_junction)
- v = {"name": name, "from_junction": from_junction, "to_junction": to_junction, "p_bar": p_bar,
- "t_k": t_k, "mdot_kg_per_s": mdot_kg_per_s, "in_service": bool(in_service), "type": type}
- _set_entries(net, "circ_pump_mass", index, **v, **kwargs)
-
+ cols = ["name", "from_junction", "to_junction", "p_bar", "t_k", "mdot_kg_per_s", "fluid", "in_service", "type"]
+
+ if isinstance(fluid, Fluid):
+ net["fluid"][fluid.name] = fluid
+ vals = [name, from_junction, to_junction, p_bar, t_k, mdot_kg_per_s, fluid.name,
+ bool(in_service), type]
+ _set_entries(net, "circ_pump_mass", index, **dict(zip(cols, vals)), **kwargs)
+ return index
+ elif isinstance(fluid, str):
+ create_fluid_from_lib(net, fluid)
+ vals = [name, from_junction, to_junction, p_bar, t_k, mdot_kg_per_s, fluid,
+ bool(in_service), type]
+ _set_entries(net, "circ_pump_mass", index, **dict(zip(cols, vals)), **kwargs)
+ return index
+ else:
+ logger.warning("The fluid %s cannot be added to the net. Only fluids of type Fluid or "
+ "strings can be used." % fluid)
return index
@@ -916,7 +961,7 @@ def create_sinks(net, junctions, mdot_kg_per_s, scaling=1., name=None, index=Non
return index
-def create_sources(net, junctions, mdot_kg_per_s, scaling=1., name=None, index=None,
+def create_sources(net, junctions, mdot_kg_per_s, fluid='hgas', scaling=1., name=None, index=None,
in_service=True, type='source', **kwargs):
"""
Convenience function for creating many sources at once. Parameter 'junctions' must be an array \
@@ -954,9 +999,28 @@ def create_sources(net, junctions, mdot_kg_per_s, scaling=1., name=None, index=N
_check_multiple_junction_elements(net, junctions)
index = _get_multiple_index_with_check(net, "source", index, len(junctions))
- entries = {"junction": junctions, "mdot_kg_per_s": mdot_kg_per_s, "scaling": scaling,
- "in_service": in_service, "name": name, "type": type}
- _set_multiple_entries(net, "source", index, **entries, **kwargs)
+ if isinstance(fluid, Fluid):
+ _add_fluid_to_net(net, fluid, False)
+ entries = {"junction": junctions, "mdot_kg_per_s": mdot_kg_per_s, "scaling": scaling, "fluid": fluid,
+ "in_service": in_service, "name": name, "type": type}
+ _set_multiple_entries(net, "source", index, **entries, **kwargs)
+ return index
+ elif isinstance(fluid, str):
+ if fluid in net.fluid:
+ entries = {"junction": junctions, "mdot_kg_per_s": mdot_kg_per_s, "scaling": scaling, "fluid": fluid,
+ "in_service": in_service, "name": name, "type": type}
+ _set_multiple_entries(net, "source", index, **entries, **kwargs)
+ return index
+ else:
+ if fluid not in net.fluid:
+ create_fluid_from_lib(net, fluid)
+ entries = {"junction": junctions, "mdot_kg_per_s": mdot_kg_per_s, "scaling": scaling, "fluid": fluid,
+ "in_service": in_service, "name": name, "type": type}
+ _set_multiple_entries(net, "source", index, **entries, **kwargs)
+ return index
+ else:
+ logger.warning("The fluid %s cannot be added to the net. Only fluids of type Fluid or "
+ "strings can be used." % fluid)
return index
diff --git a/pandapipes/create_toolbox.py b/pandapipes/create_toolbox.py
new file mode 100644
index 00000000..4e694f17
--- /dev/null
+++ b/pandapipes/create_toolbox.py
@@ -0,0 +1,53 @@
+# Copyright (c) 2020-2022 by Fraunhofer Institute for Energy Economics
+# 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.
+
+import numpy as np
+import pandas as pd
+
+from pandapipes.component_models.abstract_models.branch_models import BranchComponent
+from pandapipes.component_models.abstract_models.node_element_models import NodeElementComponent
+from pandapipes.component_models.abstract_models.node_models import NodeComponent
+
+
+def add_new_component(net, component, overwrite=False):
+ """
+ Adds a new component DataFrame to the net
+
+ :param net:
+ :type net:
+ :param component:
+ :type component:
+ :param overwrite:
+ :type overwrite:
+ :return:
+ :rtype:
+ """
+ name = component.table_name()
+ if not overwrite and name in net:
+ # logger.info('%s is already in net. Try overwrite if you want to get a new entry' %name)
+ return
+ else:
+ if hasattr(component, 'geodata'):
+ geodata = component.geodata()
+ else:
+ geodata = None
+
+ comp_input = component.get_component_input()
+ if name not in net:
+ if issubclass(component, BranchComponent):
+ net['branch_list'].append(component)
+ elif issubclass(component, NodeComponent):
+ net['node_list'].append(component)
+ elif issubclass(component, NodeElementComponent):
+ net['node_element_list'].append(component)
+ net.update({name: comp_input})
+ if isinstance(net[name], list):
+ net[name] = pd.DataFrame(np.zeros(0, dtype=net[name]), index=[])
+ # init_empty_results_table(net, name, component.get_result_table(net))
+
+ if geodata is not None:
+ net.update({name + '_geodata': geodata})
+ if isinstance(net[name + '_geodata'], list):
+ net[name + '_geodata'] = pd.DataFrame(np.zeros(0, dtype=net[name + '_geodata']),
+ index=[])
diff --git a/pandapipes/idx_branch.py b/pandapipes/idx_branch.py
index 4b1fca94..03ed4efe 100644
--- a/pandapipes/idx_branch.py
+++ b/pandapipes/idx_branch.py
@@ -2,45 +2,64 @@
# 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.
-TABLE_IDX = 0 # number of the table that this branch belongs to
-ELEMENT_IDX = 1 # index of the element that this branch belongs to (within the given table)
-FROM_NODE = 2 # f, from bus number
-TO_NODE = 3 # t, to bus number
-ACTIVE = 4
-LENGTH = 5 # Pipe length in [m]
-D = 6 # Diameter in [m]
-AREA = 7 # Area in [m²]
-RHO = 8 # Density in [kg/m^3
-ETA = 9 # Dynamic viscosity in [Pas]
-K = 10 # Pipe roughness in [m]
-TINIT = 11 # Temperature in [K]
-VINIT = 12 # velocity in [m/s]
-RE = 13 # Reynolds number
-LAMBDA = 14 # Lambda
-JAC_DERIV_DV = 15 # Slot for the derivative by velocity
-JAC_DERIV_DP = 16 # Slot for the derivative by pressure from_node
-JAC_DERIV_DP1 = 17 # Slot for the derivative by pressure to_node
-LOAD_VEC_BRANCHES = 18 # Slot for the load vector for the branches
-JAC_DERIV_DV_NODE = 19 # Slot for the derivative by velocity for the nodes connected to branch
-LOAD_VEC_NODES = 20 # Slot for the load vector of the nodes connected to branch
-LOSS_COEFFICIENT = 21
-CP = 22 # Slot for fluid heat capacity values
-ALPHA = 23 # Slot for heat transfer coefficient
-JAC_DERIV_DT = 24
-JAC_DERIV_DT1 = 25
-LOAD_VEC_BRANCHES_T = 26
-T_OUT = 27 # Internal slot for outlet pipe temperature
-JAC_DERIV_DT_NODE = 28 # Slot for the derivative fpr T for the nodes connected to branch
-LOAD_VEC_NODES_T = 29
-VINIT_T = 30
-FROM_NODE_T = 31
-TO_NODE_T = 32
-QEXT = 33 # heat input in [W]
-TEXT = 34
-STD_TYPE = 35
-PL = 36
-TL = 37 # Temperature lift [K]
-BRANCH_TYPE = 38 # branch type relevant for the pressure controller
-PRESSURE_RATIO = 39 # boost ratio for compressors with proportional pressure lift
+def idx_branch(net):
+ idx_branch = dict()
+ idx_branch['TABLE_IDX'] = 0 # number of the table that this branch belongs to
+ idx_branch['ELEMENT_IDX'] = 1 # index of the element that this branch belongs to (within the given table)
+ idx_branch['FROM_NODE'] = 2 # f, from bus number
+ idx_branch['TO_NODE'] = 3 # t, to bus number
+ idx_branch['ACTIVE'] = 4
+ idx_branch['LENGTH'] = 5 # Pipe length in [m]
+ idx_branch['D'] = 6 # Diameter in [m]
+ idx_branch['AREA'] = 7 # Area in [m²]
+ idx_branch['K'] = 8 # Pipe roughness in [m]
+ idx_branch['TINIT'] = 9 # Temperature in [K]
+ idx_branch['VINIT'] = 10 # velocity in [m/s]
+ idx_branch['RE'] = 11 # Reynolds number
+ idx_branch['LAMBDA'] = 12 # Lambda
+ idx_branch['JAC_DERIV_DV'] = 13 # Slot for the derivative by velocity
+ idx_branch['JAC_DERIV_DP'] = 14 # Slot for the derivative by pressure from_node
+ idx_branch['JAC_DERIV_DP1'] = 15 # Slot for the derivative by pressure to_node
+ idx_branch['LOAD_VEC_BRANCHES'] = 16 # Slot for the load vector for the branches
+ idx_branch['JAC_DERIV_DV_NODE'] = 17 # Slot for the derivative by velocity for the nodes connected to branch
+ idx_branch['LOAD_VEC_NODES'] = 18 # Slot for the load vector of the nodes connected to branch
+ idx_branch['LOSS_COEFFICIENT'] = 19
+ idx_branch['CP'] = 20 # Slot for fluid heat capacity values
+ idx_branch['ALPHA'] = 21 # Slot for heat transfer coefficient
+ idx_branch['JAC_DERIV_DT'] = 22
+ idx_branch['JAC_DERIV_DT1'] = 23
+ idx_branch['LOAD_VEC_BRANCHES_T'] = 24
+ idx_branch['T_OUT'] = 25 # Internal slot for outlet pipe temperature
+ idx_branch['JAC_DERIV_DT_NODE'] = 26 # Slot for the derivative fpr T for the nodes connected to branch
+ idx_branch['LOAD_VEC_NODES_T'] = 27
+ idx_branch['VINIT_T'] = 28
+ idx_branch['FROM_NODE_T'] = 29
+ idx_branch['TO_NODE_T'] = 30
+ idx_branch['QEXT'] = 31 # heat input in [W]
+ idx_branch['TEXT'] = 32
+ idx_branch['STD_TYPE'] = 33
+ idx_branch['PL'] = 34
+ idx_branch['TL'] = 35 # Temperature lift [K]
+ idx_branch['BRANCH_TYPE'] = 36 # branch type relevant for the pressure controller
+ idx_branch['PRESSURE_RATIO'] = 37 # boost ratio for compressors with proportional pressure lift
-branch_cols = 40
+ idx_branch['RHO'] = 38 # Density in [kg/m^3
+ idx_branch['ETA'] = 39 # Dynamic viscosity in [Pas]
+ idx_branch['V_FROM_NODE'] = 40 # node the fluid is coming from
+ idx_branch['V_TO_NODE'] = 41 # node the fluid is going to
+
+ counter = 41
+
+ for key in net._fluid:
+ counter += 1
+ idx_branch[key + '_W'] = counter
+ counter += 1
+ idx_branch[key + '_RHO'] = counter
+ counter += 1
+ idx_branch[key + '_JAC_DERIV_RHO_SAME_W'] = counter
+ counter += 1
+ idx_branch[key + '_JAC_DERIV_RHO_DIFF_W'] = counter
+
+ idx_branch['branch_cols'] = counter + 1
+
+ net['_idx_branch'] = idx_branch
diff --git a/pandapipes/idx_node.py b/pandapipes/idx_node.py
index b3d807e9..f7da7f64 100644
--- a/pandapipes/idx_node.py
+++ b/pandapipes/idx_node.py
@@ -2,27 +2,48 @@
# 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.
-# define bus types
-P = 1 # Reference node, pressure is fixed
-L = 2 # All other nodes
-T = 10 # Reference node with fixed temperature, otherwise 0
-PC = 20 # Controlled node with fixed pressure p
-NONE = 3 # None
-# define the indices
-TABLE_IDX = 0 # number of the table that this node belongs to
-ELEMENT_IDX = 1 # index of the element that this node belongs to (within the given table)
-NODE_TYPE = 2 # junction type
-ACTIVE = 3
-RHO = 4 # Density in [kg/m^3]
-PINIT = 5
-LOAD = 6
-HEIGHT = 7
-TINIT = 8
-PAMB = 9 # Ambient pressure in [bar]
-LOAD_T = 10 # Heat power drawn in [W]
-NODE_TYPE_T = 11
-EXT_GRID_OCCURENCE = 12
-EXT_GRID_OCCURENCE_T = 13
-node_cols = 14
+def idx_node(net):
+ idx_node = dict()
+ # define bus types
+ idx_node['P'] = 1 # Reference node, pressure is fixed
+ idx_node['L'] = 2 # All other nodes
+ idx_node['T'] = 10 # Reference node with fixed temperature, otherwise 0
+ idx_node['PC'] = 20 # Controlled node with fixed pressure p
+ idx_node['NONE'] = 3 # None
+
+ # define the indices
+ idx_node['TABLE_IDX'] = 0 # number of the table that this node belongs to
+ idx_node['ELEMENT_IDX'] = 1 # index of the element that this node belongs to (within the given table)
+ idx_node['NODE_TYPE'] = 2 # junction type
+ idx_node['ACTIVE'] = 3
+ idx_node['PINIT'] = 4
+ idx_node['HEIGHT'] = 5
+ idx_node['TINIT'] = 6
+ idx_node['PAMB'] = 7 # Ambient pressure in [bar]
+ idx_node['LOAD_T'] = 8 # Heat power drawn in [W]
+ idx_node['NODE_TYPE_T'] = 9
+ idx_node['EXT_GRID_OCCURENCE'] = 10
+ idx_node['EXT_GRID_OCCURENCE_T'] = 11
+ idx_node['FLUID'] = 12
+
+ idx_node['RHO'] = 13 # Density in [kg/m^3]
+ idx_node['LOAD'] = 14
+ idx_node['SLACK'] = 15
+ counter = 15
+
+ for key in net._fluid:
+ counter += 1
+ idx_node[key + '_LOAD'] = counter
+ counter += 1
+ idx_node[key + '_W'] = counter
+ counter += 1
+ idx_node[key + '_RHO'] = counter
+ counter += 1
+ idx_node[key + '_JAC_DERIV_RHO_SAME_W'] = counter
+ counter += 1
+ idx_node[key + '_JAC_DERIV_RHO_DIFF_W'] = counter
+
+ idx_node['node_cols'] = counter + 1
+ net['_idx_node'] = idx_node
\ No newline at end of file
diff --git a/pandapipes/idx_node_element.py b/pandapipes/idx_node_element.py
new file mode 100644
index 00000000..462e8ea2
--- /dev/null
+++ b/pandapipes/idx_node_element.py
@@ -0,0 +1,26 @@
+# Copyright (c) 2020-2021 by Fraunhofer Institute for Energy Economics
+# 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.
+
+
+def idx_node_element(net):
+ idx_node_element = dict()
+ idx_node_element['P'] = 1 # Reference node, pressure is fixed
+ idx_node_element['T'] = 2 # Reference node, temperature is fixed
+ idx_node_element['TABLE_IDX'] = 0 # number of the table that this node belongs to
+ idx_node_element['ELEMENT_IDX'] = 1 # index of the element that this node belongs to (within the given table)
+ idx_node_element['NODE_ELEMENT_TYPE'] = 2
+ idx_node_element['JUNCTION'] = 3
+ idx_node_element['MINIT'] = 4
+ idx_node_element['ACTIVE'] = 5
+ counter = 6
+
+ for key in net._fluid:
+ counter += 1
+ idx_node_element[key + '_W'] = counter
+
+ node_element_cols = counter + 1
+
+ idx_node_element['node_element_cols'] = node_element_cols
+
+ net['_idx_node_element'] = idx_node_element
diff --git a/pandapipes/io/convert_format.py b/pandapipes/io/convert_format.py
index 5ae190aa..798b332b 100644
--- a/pandapipes/io/convert_format.py
+++ b/pandapipes/io/convert_format.py
@@ -5,10 +5,13 @@
from packaging import version
from pandapipes import __version__
+from pandapipes.component_models.abstract_models.branch_models import BranchComponent
+from pandapipes.component_models.abstract_models.node_element_models import NodeElementComponent
+from pandapipes.component_models.abstract_models.node_models import NodeComponent
from pandapipes.pandapipes_net import add_default_components
try:
- import pplog as logging
+ from pandaplan.core import ppglog as logging
except ImportError:
import logging
@@ -25,6 +28,10 @@ def convert_format(net):
# https://github.com/e2nIEE/pandapipes/issues/320
if isinstance(net.version, str) and version.parse(net.version) >= current_version:
return net
+ if version.parse(net.version) <= version.parse('0.6.1.dev_1'):
+ _fluid_dictonary(net)
+ if 'component_list' in net:
+ _change_component_list(net)
_rename_columns(net)
_add_missing_columns(net)
_rename_attributes(net)
@@ -32,6 +39,27 @@ def convert_format(net):
return net
+def _change_component_list(net):
+ for component in net['component_list']:
+ if issubclass(component, BranchComponent):
+ net['branch_list'] += [component]
+ if issubclass(component, NodeElementComponent):
+ net['node_element_list'] += [component]
+ if issubclass(component, NodeComponent):
+ net['node_list'] += [component]
+
+
+def _fluid_dictonary(net):
+ fluid = net.fluid
+ net.fluid = {}
+ net.fluid[fluid.name] = fluid
+ net.ext_grid.insert(4, 'fluid', fluid.name)
+ if 'source' in net:
+ net.source.insert(3, 'fluid', fluid.name)
+ if 'heat_exchanger' in net:
+ net.heat_exchanger.insert(5, 'fluid', fluid.name)
+
+
def _rename_columns(net):
if "controller" in net:
if ("controller" in net.controller) and ("object" in net.controller):
diff --git a/pandapipes/io/file_io.py b/pandapipes/io/file_io.py
index d54f3de7..25abd58f 100644
--- a/pandapipes/io/file_io.py
+++ b/pandapipes/io/file_io.py
@@ -157,8 +157,8 @@ def from_json_string(json_string, convert=False, encryption_key=None):
convert_format(net)
elif convert and isinstance(net, MultiNet):
for n in net['nets']:
- if isinstance(n, pandapipesNet):
- convert_format(net)
- elif isinstance(n, pandapowerNet):
- convert_format_pandapower(net)
+ if isinstance(net['nets'][n], pandapipesNet):
+ convert_format(net['nets'][n])
+ elif isinstance(net['nets'][n], pandapowerNet):
+ convert_format_pandapower(net['nets'][n])
return net
diff --git a/pandapipes/io/io_utils.py b/pandapipes/io/io_utils.py
index dfdfa820..26234e28 100644
--- a/pandapipes/io/io_utils.py
+++ b/pandapipes/io/io_utils.py
@@ -17,7 +17,7 @@
from pandapipes.pandapipes_net import pandapipesNet, get_basic_net_entries
try:
- import pplog as logging
+ from pandaplan.core import pplog as logging
except ImportError:
import logging
diff --git a/pandapipes/multinet/control/controller/multinet_control.py b/pandapipes/multinet/control/controller/multinet_control.py
index ad82f0d9..f2abe914 100644
--- a/pandapipes/multinet/control/controller/multinet_control.py
+++ b/pandapipes/multinet/control/controller/multinet_control.py
@@ -2,14 +2,16 @@
# and Energy System Technology (IEE), Kassel. All rights reserved.
# 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 pandas.errors import InvalidIndexError
+
+from pandapipes.pf.pipeflow_setup import get_lookup
+from pandapipes.properties.fluids import get_fluid, get_mixture_higher_heating_value
from pandapower.control import ConstControl
-from pandapipes.properties.fluids import get_fluid
from pandapower.control.basic_controller import Controller
-from pandas.errors import InvalidIndexError
class P2GControlMultiEnergy(Controller):
-
"""
A controller to be used in a multinet. Converts power consumption to gas production.
@@ -59,6 +61,7 @@ class P2GControlMultiEnergy(Controller):
:param kwargs: optional additional controller arguments that were implemented by users
:type kwargs: any
"""
+
def __init__(self, multinet, element_index_power, element_index_gas, efficiency,
name_power_net='power', name_gas_net='gas',
in_service=True, order=0, level=0,
@@ -76,8 +79,6 @@ def __init__(self, multinet, element_index_power, element_index_gas, efficiency,
self.name_net_gas = name_gas_net
self.efficiency = efficiency
self.mdot_kg_per_s = None
- self.fluid = get_fluid(multinet['nets'][name_gas_net])
- self.fluid_calorific_value = self.fluid.get_property('hhv')
self.applied = False
def initialize_control(self, multinet):
@@ -87,6 +88,18 @@ def get_all_net_names(self):
return [self.name_net_power, self.name_net_gas]
def control_step(self, multinet):
+ if len(multinet.nets[self.name_net_gas]._fluid) != 1:
+ net = multinet.nets[self.name_net_gas]
+ w = get_lookup(net, 'node', 'w')
+ node_pit = net._pit['node']
+ index = get_lookup(net, 'node', "index")['junction'][self.elm_idx_gas]
+ mf = node_pit[index, :][:, w]
+ self.fluid_calorific_value = get_mixture_higher_heating_value(multinet.nets[self.name_net_gas],
+ mass_fraction=mf)
+ else:
+ self.fluid_calorific_value = \
+ get_fluid(multinet.nets[self.name_net_gas],
+ multinet.nets[self.name_net_gas]._fluid[0]).get_property('hhv')
try:
power_load = multinet['nets'][self.name_net_power].load.at[self.elm_idx_power, 'p_mw'] \
* multinet['nets'][self.name_net_power].load.at[self.elm_idx_power, 'scaling']
@@ -99,11 +112,10 @@ def control_step(self, multinet):
def write_to_net(self, multinet):
try:
- multinet['nets'][self.name_net_gas].source.at[self.elm_idx_gas, 'mdot_kg_per_s'] \
+ multinet['nets'][self.name_net_gas]['source'].at[self.elm_idx_gas, 'mdot_kg_per_s'] \
= self.mdot_kg_per_s
except (ValueError, TypeError, InvalidIndexError):
- multinet['nets'][self.name_net_gas].source.loc[self.elm_idx_gas,
- 'mdot_kg_per_s'] = self.mdot_kg_per_s
+ multinet['nets'][self.name_net_gas]['source']['mdot_kg_per_s'][self.elm_idx_gas] = self.mdot_kg_per_s
def is_converged(self, multinet):
return self.applied
@@ -113,7 +125,6 @@ def conversion_factor_mw_to_kgps(self):
class G2PControlMultiEnergy(Controller):
-
"""
A controller to be used in a multinet. Connects power generation and gas consumption.
@@ -195,8 +206,6 @@ def __init__(self, multinet, element_index_power, element_index_gas, efficiency,
self.name_net_gas = name_gas_net
self.efficiency = efficiency
self.mdot_kg_per_s = None
- self.fluid = get_fluid(multinet['nets'][name_gas_net])
- self.fluid_calorific_value = self.fluid.get_property('hhv')
self.el_power_led = calc_gas_from_power
self.applied = False
@@ -207,30 +216,42 @@ def get_all_net_names(self):
return [self.name_net_gas, self.name_net_power]
def control_step(self, multinet):
+ if len(multinet.nets[self.name_net_gas]._fluid) != 1:
+ net = multinet.nets[self.name_net_gas]
+ w = get_lookup(net, 'node', 'w')
+ node_pit = net._pit['node']
+ index = get_lookup(net, 'node', "index")['junction'][self.elm_idx_gas]
+ mf = node_pit[index, :][:, w]
+ self.fluid_calorific_value = get_mixture_higher_heating_value(multinet.nets[self.name_net_gas],
+ mass_fraction=mf)
+ else:
+ fluid = multinet.nets[self.name_net_gas]._fluid[0]
+ self.fluid_calorific_value = \
+ get_fluid(multinet.nets[self.name_net_gas], fluid).get_property('hhv')
if self.el_power_led:
try:
power_gen = multinet['nets'][self.name_net_power][self.elm_type_power].at[
- self.elm_idx_power, 'p_mw'] * multinet['nets'][self.name_net_power][
- self.elm_type_power].at[self.elm_idx_power, 'scaling']
+ self.elm_idx_power, 'p_mw'] * multinet['nets'][self.name_net_power][
+ self.elm_type_power].at[self.elm_idx_power, 'scaling']
except (ValueError, TypeError, InvalidIndexError):
power_gen = multinet['nets'][self.name_net_power][self.elm_type_power].loc[
self.elm_idx_power, 'p_mw'].values[:] \
* multinet['nets'][self.name_net_power][self.elm_type_power].loc[
- self.elm_idx_power, 'scaling'].values[:]
+ self.elm_idx_power, 'scaling'].values[:]
self.gas_cons = power_gen / (self.conversion_factor_kgps_to_mw() * self.efficiency)
else:
try:
gas_sink = multinet['nets'][self.name_net_gas].sink.at[self.elm_idx_gas, 'mdot_kg_per_s'] \
- *multinet['nets'][self.name_net_gas].sink.at[self.elm_idx_gas, 'scaling']
+ * multinet['nets'][self.name_net_gas].sink.at[self.elm_idx_gas, 'scaling']
except (ValueError, TypeError, InvalidIndexError):
gas_sink = multinet['nets'][self.name_net_gas].sink.loc[self.elm_idx_gas,
'mdot_kg_per_s'].values[:] \
* multinet['nets'][self.name_net_gas].sink.loc[self.elm_idx_gas,
- 'scaling'].values[:]
+ 'scaling'].values[:]
self.power_gen = gas_sink * self.conversion_factor_kgps_to_mw() * self.efficiency
@@ -261,7 +282,6 @@ def conversion_factor_kgps_to_mw(self):
class GasToGasConversion(Controller):
-
"""
A controller to be used in a multinet with two gas nets that have different gases.
@@ -327,8 +347,6 @@ def __init__(self, multinet, element_index_from, element_index_to, efficiency,
self.name_net_from = name_gas_net_from
self.name_net_to = name_gas_net_to
self.efficiency = efficiency
- self.gas1_calorific_value = get_fluid(multinet['nets'][name_gas_net_from]).get_property('hhv')
- self.gas2_calorific_value = get_fluid(multinet['nets'][name_gas_net_to]).get_property('hhv')
self.applied = False
def initialize_control(self, multinet):
@@ -338,6 +356,29 @@ def get_all_net_names(self):
return [self.name_net_from, self.name_net_to]
def control_step(self, multinet):
+ if len(multinet.nets[self.name_net_from]._fluid) == 1:
+ fluid = multinet.nets[self.name_net_from]._fluid[0]
+ self.gas1_calorific_value = \
+ get_fluid(multinet.nets[self.name_net_from], fluid).get_property('hhv')
+ else:
+ net = multinet.nets[self.name_net_from]
+ w = get_lookup(net, 'node', 'w')
+ node_pit = net._pit['node']
+ index = get_lookup(net, 'node', "index")['junction'][self.element_index_from]
+ mf = node_pit[index, :][None, :][:, w] if len(np.shape(node_pit[index, :])) == 1 else node_pit[index, :][:, w]
+ self.gas1_calorific_value = get_mixture_higher_heating_value(multinet.nets[self.name_net_from], mf)
+ if len(multinet.nets[self.name_net_to]._fluid) == 1:
+ fluid = multinet.nets[self.name_net_to]._fluid[0]
+ self.gas2_calorific_value = \
+ get_fluid(multinet.nets[self.name_net_to], fluid).get_property('hhv')
+ else:
+ net = multinet.nets[self.name_net_to]
+ w = get_lookup(net, 'node', 'w')
+ node_pit = net._pit['node']
+ index = get_lookup(net, 'node', "index")['junction'][self.element_index_to]
+ mf = node_pit[index, :][None, :][:, w] if len(np.shape(node_pit[index, :])) == 1 else node_pit[index, :][:, w]
+ self.gas2_calorific_value = get_mixture_higher_heating_value(multinet.nets[self.name_net_to], mf)
+
try:
gas_in = multinet['nets'][self.name_net_from].sink.at[self.element_index_from, 'mdot_kg_per_s'] \
* multinet['nets'][self.name_net_from].sink.at[self.element_index_from, 'scaling']
diff --git a/pandapipes/multinet/control/run_control_multinet.py b/pandapipes/multinet/control/run_control_multinet.py
index cbf099be..b0e5b19f 100644
--- a/pandapipes/multinet/control/run_control_multinet.py
+++ b/pandapipes/multinet/control/run_control_multinet.py
@@ -12,7 +12,7 @@
_evaluate_net as _evaluate_net, control_implementation, get_controller_order, NetCalculationNotConverged
try:
- import pplog as logging
+ from pandaplan.core import pplog as logging
except ImportError:
import logging
diff --git a/pandapipes/multinet/create_multinet.py b/pandapipes/multinet/create_multinet.py
index a450eeb9..67896e1d 100644
--- a/pandapipes/multinet/create_multinet.py
+++ b/pandapipes/multinet/create_multinet.py
@@ -7,7 +7,7 @@
from pandapipes.multinet.multinet import MultiNet, get_default_multinet_structure
try:
- import pplog as logging
+ from pandaplan.core import pplog as logging
except ImportError:
import logging
diff --git a/pandapipes/multinet/multinet.py b/pandapipes/multinet/multinet.py
index 21205398..7b071077 100644
--- a/pandapipes/multinet/multinet.py
+++ b/pandapipes/multinet/multinet.py
@@ -13,7 +13,7 @@
from pandapipes import pandapipesNet
try:
- import pplog as logging
+ from pandaplan.core import pplog as logging
except ImportError:
import logging
diff --git a/pandapipes/multinet/timeseries/run_time_series_multinet.py b/pandapipes/multinet/timeseries/run_time_series_multinet.py
index 852b0888..5cb94e59 100644
--- a/pandapipes/multinet/timeseries/run_time_series_multinet.py
+++ b/pandapipes/multinet/timeseries/run_time_series_multinet.py
@@ -2,17 +2,18 @@
# and Energy System Technology (IEE), Kassel. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
+import tqdm
+
from pandapipes import pandapipesNet
from pandapipes.multinet.control.run_control_multinet import prepare_run_ctrl, run_control
from pandapipes.timeseries.run_time_series import init_default_outputwriter as init_default_ow_pps
from pandapower import pandapowerNet
from pandapower.control.util.diagnostic import control_diagnostic
from pandapower.timeseries.run_time_series import get_recycle_settings, init_time_steps, output_writer_routine, \
- print_progress_bar, cleanup, run_loop, init_default_outputwriter as init_default_ow_pp, init_output_writer
-import tqdm
+ cleanup, run_loop, init_default_outputwriter as init_default_ow_pp, init_output_writer
try:
- import pplog
+ from pandaplan.core import pplog
except ImportError:
import logging as pplog
@@ -82,6 +83,9 @@ def init_time_series(multinet, time_steps, continue_on_divergence=False, verbose
ts_variables[net_name]['run'] = run[net_name] if run is not None else ts_variables[net_name]['run']
ts_variables[net_name]['recycle_options'] = recycle_options
init_output_writer(net, time_steps)
+ if logger.level != 10 and verbose:
+ # simple progress bar
+ ts_variables['progress_bar'] = tqdm.tqdm(total=len(time_steps))
# time steps to be calculated (list or range)
ts_variables["time_steps"] = time_steps
diff --git a/pandapipes/networks/simple_gas_networks.py b/pandapipes/networks/simple_gas_networks.py
index 4ea9ea0f..3418b6ad 100644
--- a/pandapipes/networks/simple_gas_networks.py
+++ b/pandapipes/networks/simple_gas_networks.py
@@ -8,7 +8,7 @@
from pandapipes.networks.nw_aux import log_result_upon_loading
try:
- import pplog as logging
+ from pandaplan.core import ppglog as logging
except ImportError:
import logging
diff --git a/pandapipes/networks/simple_heat_transfer_networks.py b/pandapipes/networks/simple_heat_transfer_networks.py
index a0730f4c..0900afe8 100644
--- a/pandapipes/networks/simple_heat_transfer_networks.py
+++ b/pandapipes/networks/simple_heat_transfer_networks.py
@@ -6,7 +6,7 @@
from pandapipes.io.file_io import from_json
from pandapipes import pp_dir
try:
- import pplog as logging
+ from pandaplan.core import ppglog as logging
except ImportError:
import logging
diff --git a/pandapipes/networks/simple_water_networks.py b/pandapipes/networks/simple_water_networks.py
index 548f3445..9de1b1e7 100644
--- a/pandapipes/networks/simple_water_networks.py
+++ b/pandapipes/networks/simple_water_networks.py
@@ -8,7 +8,7 @@
from pandapipes.networks.nw_aux import log_result_upon_loading
try:
- import pplog as logging
+ from pandaplan.core import ppglog as logging
except ImportError:
import logging
diff --git a/pandapipes/pandapipes_net.py b/pandapipes/pandapipes_net.py
index aa529b0e..3ae1c76d 100644
--- a/pandapipes/pandapipes_net.py
+++ b/pandapipes/pandapipes_net.py
@@ -11,12 +11,12 @@
from pandapipes.component_models.junction_component import Junction
from pandapipes.component_models.pipe_component import Pipe
from pandapipes.component_models.ext_grid_component import ExtGrid
-from pandapipes.component_models.component_toolbox import add_new_component
+from pandapipes.create_toolbox import add_new_component
from pandapower.auxiliary import ADict
from pandas import Index
try:
- import pplog as logging
+ from pandaplan.core import pplog as logging
except ImportError:
import logging
@@ -53,28 +53,40 @@ def __repr__(self): # pragma: no cover
for tb in res:
r += "\n - %s (%s elements)" % (tb, len(self[tb]))
r += "."
- if "fluid" in self and self["fluid"] is not None:
- r += "\nIt contains the following fluid: \n%s" % self["fluid"]
+ if "fluid" in self and self["fluid"] and bool(self["fluid"]):
+ r += "\nIt contains the following fluids: "
+ try:
+ for key in self["fluid"].keys():
+ r += "\n%s" % self["fluid"][key]
+ except AttributeError:
+ r += "\n%s" % self["fluid"]
else:
r += "\nIt does not contain any defined fluid"
if "component_list" in self:
r += "\nand uses the following component models:"
for component in self.component_list:
r += "\n - %s" % component.__name__
+ elif "node_list" in self:
+ r += "\nand uses the following component models:"
+ for component in np.concatenate([self.node_list, self.branch_list, self.node_element_list]):
+ r += "\n - %s" % component.__name__
return r
def get_basic_net_entries():
return {
- "fluid": None,
+ "fluid": {},
"converged": False,
+ "OPF_converged": False,
"name": "",
"version": __version__,
- "component_list": []}
+ "node_list": [],
+ "node_element_list": [],
+ "branch_list": []}
def get_basic_components():
- return Junction, Pipe, ExtGrid
+ return Junction, ExtGrid, Pipe
def add_default_components(net, overwrite=False):
diff --git a/pandapipes/pf/build_system_matrix.py b/pandapipes/pf/build_system_matrix.py
index accdb1b9..3f7b024e 100644
--- a/pandapipes/pf/build_system_matrix.py
+++ b/pandapipes/pf/build_system_matrix.py
@@ -3,17 +3,13 @@
# 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.idx_branch import FROM_NODE, TO_NODE, JAC_DERIV_DV, JAC_DERIV_DP, JAC_DERIV_DP1, \
- JAC_DERIV_DV_NODE, LOAD_VEC_NODES, LOAD_VEC_BRANCHES, JAC_DERIV_DT, JAC_DERIV_DT1, \
- JAC_DERIV_DT_NODE, LOAD_VEC_NODES_T, LOAD_VEC_BRANCHES_T, FROM_NODE_T, TO_NODE_T, BRANCH_TYPE
-from pandapipes.idx_node import LOAD, TINIT
-from pandapipes.idx_node import P, PC, NODE_TYPE, T, NODE_TYPE_T
-from pandapipes.pf.internals_toolbox import _sum_by_group_sorted, _sum_by_group
-from pandapipes.pf.pipeflow_setup import get_net_option
from scipy.sparse import csr_matrix
+from pandapipes.pf.internals_toolbox import _sum_by_group_sorted, _sum_by_group
+from pandapipes.pf.pipeflow_setup import get_net_option, get_lookup
+
-def build_system_matrix(net, branch_pit, node_pit, heat_mode):
+def build_system_matrix(net, branch_pit, node_pit, node_element_pit, heat_mode, first_iter):
"""
Builds the system matrix.
@@ -35,29 +31,126 @@ def build_system_matrix(net, branch_pit, node_pit, heat_mode):
len_b = len(branch_pit)
len_n = len(node_pit)
+
+ slack_element_mask = (node_element_pit[:, net._idx_node_element['NODE_ELEMENT_TYPE']] == 1)
+ len_s = len(slack_element_mask[slack_element_mask])
+ len_ne = len(node_element_pit[slack_element_mask])
+
+ len_fluid = 0 if first_iter else len(net._fluid) - 1
+ len_nw, len_bw, len_sw = (len_n * len_fluid, len_b * len_fluid, len_s * len_fluid)
+
+ extra = 0 if heat_mode else len_ne
branch_matrix_indices = np.arange(len_b) + len_n
- fn_col, tn_col, ntyp_col, slack_type, pc_type, num_der = \
- (FROM_NODE, TO_NODE, NODE_TYPE, P, PC, 3) \
- if not heat_mode else (FROM_NODE_T, TO_NODE_T, NODE_TYPE_T, T, PC, 2)
+ node_element_matrix_indices = np.arange(len_ne) + len_b + len_n
+ fn_col, tn_col, ntyp_col, slack_type, pc_type, nej_col, min_col, num_der = \
+ (net['_idx_branch']['FROM_NODE'], net['_idx_branch']['TO_NODE'], net['_idx_node']['NODE_TYPE'],
+ net['_idx_node']['P'], net['_idx_node']['PC'], net['_idx_node_element']['JUNCTION'],
+ net['_idx_node_element']['MINIT'], 3) \
+ if not heat_mode else (
+ net['_idx_branch']['FROM_NODE_T'], net['_idx_branch']['TO_NODE_T'], net['_idx_node']['NODE_TYPE_T'],
+ net['_idx_node']['T'], net['_idx_node']['PC'], net['_idx_node_element']['JUNCTION'],
+ net['_idx_node_element']['MINIT'], 2)
pc_nodes = np.where(node_pit[:, ntyp_col] == pc_type)[0]
+ slack_masses_from, slack_branches_from = np.where(
+ branch_pit[:, fn_col] == node_element_pit[slack_element_mask, nej_col][:, np.newaxis])
+ slack_masses_to, slack_branches_to = np.where(
+ branch_pit[:, tn_col] == node_element_pit[slack_element_mask, nej_col][:, np.newaxis])
+ slack_mass = node_element_pit[slack_element_mask, min_col]
+ _, inv, count = np.unique(node_element_pit[slack_element_mask, nej_col], return_inverse=True, return_counts=True)
fn = branch_pit[:, fn_col].astype(np.int32)
tn = branch_pit[:, tn_col].astype(np.int32)
+
+ w_ne_col = get_lookup(net, "node_element", "w")[:-1]
+ w_n_col = get_lookup(net, "node", "w")[:-1]
+
+ w_node_matrix_indices = np.arange(len_nw) + len_ne + len_b + len_n
not_slack_fn_branch_mask = node_pit[fn, ntyp_col] != slack_type
not_slack_tn_branch_mask = node_pit[tn, ntyp_col] != slack_type
- pc_branch_mask = branch_pit[:, BRANCH_TYPE] == pc_type
+ pc_branch_mask = branch_pit[:, net['_idx_branch']['BRANCH_TYPE']] == pc_type
slack_nodes = np.where(node_pit[:, ntyp_col] == slack_type)[0]
pc_matrix_indices = branch_matrix_indices[pc_branch_mask]
+ vfn = branch_pit[:, net['_idx_branch']['V_FROM_NODE']].astype(int)
+ vtn = branch_pit[:, net['_idx_branch']['V_TO_NODE']].astype(int)
+
+ if len_fluid and not first_iter:
+ # get nodes the fluid is moving from and to (ignoring the from_nodes and to_nodes convention)
+
+ node_pit[:, net['_idx_node']['LOAD']][node_pit[:, net['_idx_node']['LOAD']] == 0] += 10 ** -12
+
+ fn_w = get_w_like_node_vector(vfn, len_fluid, len_n)
+ tn_w = get_w_like_node_vector(vtn, len_fluid, len_n)
+
+ # get slack nodes as w like vector
+ slack_nodes_w = get_w_like_node_vector(node_element_pit[slack_element_mask, nej_col].astype(int),
+ len_fluid, len_n)
+
+ # derivate w after slack mass
+ slack_wdF_dm = get_slack_wdF_dm(net, node_pit, node_element_pit, slack_element_mask, w_n_col, w_ne_col,
+ count, inv)
+
+ # derivate load from node after w
+ n_mdF_dw = get_n_mdF_dw(net, node_pit, node_element_pit, slack_element_mask, len_fluid, len_n)
+
+ # derivate branches mass flow from node after w
+ n_wdF_dw = get_n_wdF_dw(net, branch_pit)
+
+ # derivate branches mass flow from node after w diff
+ n_wdF_dw_diff, dw_diff_row, dw_diff_col = get_n_wdF_dw_diff(net, node_pit, branch_pit, w_n_col)
+
+ # derivate branches w after v
+ wdF_dv = get_wdF_dv(net, node_pit, branch_pit, w_n_col)
+
+ # derivate branches from node rho after w
+ fn_rhodF_dw = get_fn_rhodF_dw(net, branch_pit, not_slack_fn_branch_mask)
+
+ # derivate branches to node rho after w
+ tn_rhodF_dw = get_tn_rhodF_dw(net, branch_pit, not_slack_tn_branch_mask)
+
+ # derivate from slack mass rho after w
+ fslack_rhodF_dw = get_fslack_rhodF_dw(net, branch_pit, slack_branches_from)
+
+ # derivate to slack mass rho after w
+ tslack_rhodF_dw = get_tslack_rhodF_dw(net, branch_pit, slack_branches_to)
+
+ # derivate nodes rho after w
+ # TODO: still missing, needs to be implemented
+
+ extra += len_nw
+ else:
+ fn_w, tn_w, slack_nodes_w, slack_wdF_dm, n_mdF_dw, n_wdF_dw, n_wdF_dw_diff, dw_diff_row, dw_diff_col, \
+ wdF_dv, fn_rhodF_dw, tn_rhodF_dw, fslack_rhodF_dw, tslack_rhodF_dw = \
+ [], [], [], [], [], [], [], \
+ [], [], [], [], [], [], []
+
if not heat_mode:
len_fn_not_slack = np.sum(not_slack_fn_branch_mask)
len_tn_not_slack = np.sum(not_slack_tn_branch_mask)
len_fn1 = num_der * len_b + len_fn_not_slack
len_tn1 = len_fn1 + len_tn_not_slack
len_pc = len_tn1 + pc_nodes.shape[0]
- full_len = len_pc + slack_nodes.shape[0]
+ len_slack = len_pc + slack_nodes.shape[0]
+ len_fne = len_slack + len(slack_masses_from)
+ len_tne = len_fne + len(slack_masses_to)
+ len_m_ne = len_tne + len_ne
+
+ len_slack_wdF_dm = len_sw + len_m_ne
+ len_n_mdF_dw = len_nw + len_slack_wdF_dm
+ len_fn_wdF_dw = len_bw + len_n_mdF_dw
+ len_tn_wdF_dw = len_bw + len_fn_wdF_dw
+ len_fn_wdF_dw_diff = len_bw * len_fluid + len_tn_wdF_dw
+ len_tn_wdF_dw_diff = len_bw * len_fluid + len_fn_wdF_dw_diff
+ len_fn_wdF_dv = len_bw + len_tn_wdF_dw_diff
+ len_tn_wdF_dv = len_bw + len_fn_wdF_dv
+ len_fn_rhodF_dw = len_fn_not_slack * len_fluid + len_tn_wdF_dv
+ len_tn_rhodF_dw = len_tn_not_slack * len_fluid + len_fn_rhodF_dw
+ len_fslack_rhodF_dw = len(slack_branches_from) * len_fluid + len_tn_rhodF_dw
+ len_tslack_rhodF_dw = len(slack_branches_to) * len_fluid + len_fslack_rhodF_dw
+ full_len = len_tslack_rhodF_dw
else:
- inc_flow_sum = np.zeros(len(node_pit[:, LOAD]))
- tn_unique_der, tn_sums_der = _sum_by_group(use_numba, tn, branch_pit[:, JAC_DERIV_DT_NODE])
+ inc_flow_sum = np.zeros(len(node_pit[:, net['_idx_node']['LOAD']]))
+ tn_unique_der, tn_sums_der = _sum_by_group(
+ use_numba, tn, branch_pit[:, net['_idx_branch']['JAC_DERIV_DT_NODE']])
inc_flow_sum[tn_unique_der] += tn_sums_der
len_fn1 = num_der * len_b + len(tn_unique_der)
len_tn1 = len_fn1 + len_b
@@ -67,26 +160,57 @@ def build_system_matrix(net, branch_pit, node_pit, heat_mode):
if not heat_mode:
# pdF_dv
- system_data[:len_b] = branch_pit[:, JAC_DERIV_DV]
+ system_data[:len_b] = branch_pit[:, net['_idx_branch']['JAC_DERIV_DV']]
# pdF_dpi
- system_data[len_b:2 * len_b] = branch_pit[:, JAC_DERIV_DP]
+ system_data[len_b:2 * len_b] = branch_pit[:, net['_idx_branch']['JAC_DERIV_DP']]
# pdF_dpi1
- system_data[2 * len_b:3 * len_b] = branch_pit[:, JAC_DERIV_DP1]
+ system_data[2 * len_b:3 * len_b] = branch_pit[:, net['_idx_branch']['JAC_DERIV_DP1']]
# jdF_dv_from_nodes
- system_data[3 * len_b:len_fn1] = branch_pit[not_slack_fn_branch_mask, JAC_DERIV_DV_NODE]
+ system_data[3 * len_b:len_fn1] = branch_pit[not_slack_fn_branch_mask, net['_idx_branch']['JAC_DERIV_DV_NODE']]
# jdF_dv_to_nodes
system_data[len_fn1:len_tn1] = branch_pit[not_slack_tn_branch_mask,
- JAC_DERIV_DV_NODE] * (-1)
+ net['_idx_branch']['JAC_DERIV_DV_NODE']] * (-1)
# pc_nodes and p_nodes
- system_data[len_tn1:] = 1
+ system_data[len_tn1:len_slack] = 1
+ # fne_mdF_dv
+ system_data[len_slack:len_fne] = branch_pit[slack_branches_from, net['_idx_branch']['JAC_DERIV_DV_NODE']]
+ # tne_mdF_dv
+ system_data[len_fne:len_tne] = branch_pit[slack_branches_to, net['_idx_branch']['JAC_DERIV_DV_NODE']] * (-1)
+ # ne_mdF_dm
+ system_data[len_tne:len_m_ne] = 1
+
+ # slack_wdF_dm
+ system_data[len_m_ne:len_slack_wdF_dm] = slack_wdF_dm
+ # n_mdF_dw
+ system_data[len_slack_wdF_dm:len_n_mdF_dw] = n_mdF_dw
+ # fn_wdF_dw
+ system_data[len_n_mdF_dw:len_fn_wdF_dw] = n_wdF_dw
+ # tn_wdF_dw
+ system_data[len_fn_wdF_dw:len_tn_wdF_dw] = n_wdF_dw * (-1)
+ # fn_wdF_dw_diff
+ system_data[len_tn_wdF_dw:len_fn_wdF_dw_diff] = n_wdF_dw_diff
+ # tn_wdF_dw_diff
+ system_data[len_fn_wdF_dw_diff:len_tn_wdF_dw_diff] = n_wdF_dw_diff * (-1)
+ # fn_wdF_dv
+ system_data[len_tn_wdF_dw_diff:len_fn_wdF_dv] = wdF_dv
+ # tn_wdF_dv
+ system_data[len_fn_wdF_dv:len_tn_wdF_dv] = wdF_dv * (-1)
+ # fn_rhodF_dw
+ system_data[len_tn_wdF_dv:len_fn_rhodF_dw] = fn_rhodF_dw
+ # tn_rhodF_dw
+ system_data[len_fn_rhodF_dw:len_tn_rhodF_dw] = tn_rhodF_dw * (-1)
+ # fslack_rhodF_dw
+ system_data[len_tn_rhodF_dw:len_fslack_rhodF_dw] = fslack_rhodF_dw
+ # tslack_rhodF_dw
+ system_data[len_fslack_rhodF_dw:] = tslack_rhodF_dw * (-1)
else:
- system_data[:len_b] = branch_pit[:, JAC_DERIV_DT]
+ system_data[:len_b] = branch_pit[:, net['_idx_branch']['JAC_DERIV_DT']]
# pdF_dpi1
- system_data[len_b:2 * len_b] = branch_pit[:, JAC_DERIV_DT1]
+ system_data[len_b:2 * len_b] = branch_pit[:, net['_idx_branch']['JAC_DERIV_DT1']]
# jdF_dv_from_nodes
system_data[2 * len_b:len_fn1] = inc_flow_sum[tn_unique_der]
# jdF_dv_to_nodes
- data = branch_pit[:, JAC_DERIV_DT_NODE] * (-1)
+ data = branch_pit[:, net['_idx_branch']['JAC_DERIV_DT_NODE']] * (-1)
rows = tn
index = np.argsort(rows)
data = data[index]
@@ -123,8 +247,84 @@ def build_system_matrix(net, branch_pit, node_pit, heat_mode):
system_rows[len_tn1:len_pc] = pc_matrix_indices
# p_nodes
- system_cols[len_pc:] = slack_nodes
- system_rows[len_pc:] = slack_nodes
+ system_cols[len_pc:len_slack] = slack_nodes
+ system_rows[len_pc:len_slack] = slack_nodes
+
+ # fne_mdF_dv
+ system_cols[len_slack:len_fne] = branch_matrix_indices[slack_branches_from]
+ system_rows[len_slack:len_fne] = node_element_matrix_indices[slack_masses_from]
+
+ # tne_mdF_dv
+ system_cols[len_fne:len_tne] = branch_matrix_indices[slack_branches_to]
+ system_rows[len_fne:len_tne] = node_element_matrix_indices[slack_masses_to]
+
+ # ne_mdF_dm
+ system_cols[len_tne:len_m_ne] = node_element_matrix_indices
+ system_rows[len_tne:len_m_ne] = node_element_matrix_indices
+
+ # slack_wdF_dm
+ system_cols[len_m_ne:len_slack_wdF_dm] = get_w_like_vector(node_element_matrix_indices, len_fluid)
+ system_rows[len_m_ne:len_slack_wdF_dm] = w_node_matrix_indices[slack_nodes_w]
+
+ # n_mdF_dw
+ system_cols[len_slack_wdF_dm:len_n_mdF_dw] = w_node_matrix_indices
+ system_rows[len_slack_wdF_dm:len_n_mdF_dw] = w_node_matrix_indices
+
+ # fn_wdF_dw
+ system_cols[len_n_mdF_dw:len_fn_wdF_dw] = w_node_matrix_indices[fn_w]
+ system_rows[len_n_mdF_dw:len_fn_wdF_dw] = w_node_matrix_indices[fn_w]
+
+ # tn_wdF_dw
+ system_cols[len_fn_wdF_dw:len_tn_wdF_dw] = w_node_matrix_indices[fn_w]
+ system_rows[len_fn_wdF_dw:len_tn_wdF_dw] = w_node_matrix_indices[tn_w]
+
+ fn_w_re = np.reshape(fn_w, [-1, len_fluid]).T.flatten() if len(fn_w) else np.array([])
+ tn_w_re = np.reshape(tn_w, [-1, len_fluid]).T.flatten() if len(tn_w) else np.array([])
+
+ # fn_wdF_dw_diff
+ system_cols[len_tn_wdF_dw:len_fn_wdF_dw_diff] = w_node_matrix_indices[
+ (np.array(fn_w_re)[dw_diff_col]).tolist()]
+ system_rows[len_tn_wdF_dw:len_fn_wdF_dw_diff] = w_node_matrix_indices[
+ (np.array(fn_w_re)[dw_diff_row]).tolist()]
+
+ # tn_wdF_dw_diff
+ system_cols[len_fn_wdF_dw_diff:len_tn_wdF_dw_diff] = w_node_matrix_indices[
+ (fn_w_re[dw_diff_col]).tolist()]
+ system_rows[len_fn_wdF_dw_diff:len_tn_wdF_dw_diff] = w_node_matrix_indices[
+ (tn_w_re[dw_diff_row]).tolist()]
+
+ # fn_wdF_dv
+ system_cols[len_tn_wdF_dw_diff:len_fn_wdF_dv] = get_w_like_vector(branch_matrix_indices, len_fluid)
+ system_rows[len_tn_wdF_dw_diff:len_fn_wdF_dv] = w_node_matrix_indices[fn_w]
+
+ # tn_wdF_dv
+ system_cols[len_fn_wdF_dv:len_tn_wdF_dv] = get_w_like_vector(branch_matrix_indices, len_fluid)
+ system_rows[len_fn_wdF_dv:len_tn_wdF_dv] = w_node_matrix_indices[tn_w]
+
+ # fn_rhodF_dw
+ system_cols[len_tn_wdF_dv:len_fn_rhodF_dw] = w_node_matrix_indices[
+ get_w_like_node_vector(vfn[not_slack_fn_branch_mask], len_fluid, len_n)]
+ system_rows[len_tn_wdF_dv:len_fn_rhodF_dw] = \
+ get_w_like_vector(fn[not_slack_fn_branch_mask], len_fluid)
+
+ # tn_rhodF_dw
+ system_cols[len_fn_rhodF_dw:len_tn_rhodF_dw] = w_node_matrix_indices[
+ get_w_like_node_vector(vfn[not_slack_tn_branch_mask], len_fluid, len_n)]
+ system_rows[len_fn_rhodF_dw:len_tn_rhodF_dw] = \
+ get_w_like_vector(tn[not_slack_tn_branch_mask], len_fluid)
+
+ # fslack_rhodF_dw
+ system_cols[len_tn_rhodF_dw:len_fslack_rhodF_dw] = w_node_matrix_indices[
+ get_w_like_node_vector(vfn[slack_branches_from], len_fluid, len_n)]
+ system_rows[len_tn_rhodF_dw:len_fslack_rhodF_dw] = node_element_matrix_indices[
+ get_w_like_vector(slack_masses_from, len_fluid)]
+
+ # tslack_rhodF_dw
+ system_cols[len_fslack_rhodF_dw:] = w_node_matrix_indices[
+ get_w_like_node_vector(vfn[slack_branches_to], len_fluid, len_n)]
+ system_rows[len_fslack_rhodF_dw:] = node_element_matrix_indices[
+ get_w_like_vector(slack_masses_to, len_fluid)]
+
else:
# pdF_dTfromnode
system_cols[:len_b] = fn
@@ -152,7 +352,7 @@ def build_system_matrix(net, branch_pit, node_pit, heat_mode):
if not update_option:
system_matrix = csr_matrix((system_data, (system_rows, system_cols)),
- shape=(len_n + len_b, len_n + len_b))
+ shape=(len_n + len_b + extra, len_n + len_b + extra))
else:
data_order = np.lexsort([system_cols, system_rows])
@@ -160,12 +360,12 @@ def build_system_matrix(net, branch_pit, node_pit, heat_mode):
system_cols = system_cols[data_order]
system_rows = system_rows[data_order]
- row_counter = np.zeros(len_b + len_n + 1, dtype=np.int32)
+ row_counter = np.zeros(len_b + len_n + extra + 1, dtype=np.int32)
unique_rows, row_counts = _sum_by_group_sorted(system_rows, np.ones_like(system_rows))
row_counter[unique_rows + 1] += row_counts
ptr = row_counter.cumsum()
system_matrix = csr_matrix((system_data, system_cols, ptr),
- shape=(len_n + len_b, len_n + len_b))
+ shape=(len_n + len_b + extra, len_n + len_b + extra))
net["_internal_data"]["hydraulic_data_sorting"] = data_order
net["_internal_data"]["hydraulic_matrix"] = system_matrix
else:
@@ -175,23 +375,193 @@ def build_system_matrix(net, branch_pit, node_pit, heat_mode):
system_matrix.data = system_data
if not heat_mode:
- load_vector = np.empty(len_n + len_b)
- load_vector[len_n:] = branch_pit[:, LOAD_VEC_BRANCHES]
- load_vector[:len_n] = node_pit[:, LOAD] * (-1)
- fn_unique, fn_sums = _sum_by_group(use_numba, fn, branch_pit[:, LOAD_VEC_NODES])
- tn_unique, tn_sums = _sum_by_group(use_numba, tn, branch_pit[:, LOAD_VEC_NODES])
+ load_vector = np.empty(len_n + len_b + extra)
+ load_vector[len_n:len_n + len_b] = branch_pit[:, net['_idx_branch']['LOAD_VEC_BRANCHES']]
+ load_vector[:len_n] = node_pit[:, net['_idx_node']['LOAD']] * (-1)
+ load_vector[len_n + len_b:len_n + len_b + len_ne] = \
+ node_pit[node_element_pit[slack_element_mask, nej_col].astype(int), net['_idx_node']['LOAD']] * (-1)
+ _, inv_from, count_from = np.unique(slack_branches_from, return_inverse=True, return_counts=True)
+ _, inv_to, count_to = np.unique(slack_branches_to, return_inverse=True, return_counts=True)
+ load_vector[len_n + len_b:len_n + len_b + len_ne] /= count[inv]
+ fn_unique, fn_sums = _sum_by_group(
+ use_numba, fn, branch_pit[:, net['_idx_branch']['LOAD_VEC_NODES']])
+ tn_unique, tn_sums = _sum_by_group(
+ use_numba, tn, branch_pit[:, net['_idx_branch']['LOAD_VEC_NODES']])
+ fn_slack_unique, fn_slack_sums = _sum_by_group(
+ use_numba, slack_masses_from, branch_pit[
+ slack_branches_from, net['_idx_branch']['LOAD_VEC_NODES']] / count_from[inv_from])
+ tn_slack_unique, tn_slack_sums = _sum_by_group(
+ use_numba, slack_masses_to, branch_pit[
+ slack_branches_to, net['_idx_branch']['LOAD_VEC_NODES']] / count_to[inv_to])
load_vector[fn_unique] -= fn_sums
load_vector[tn_unique] += tn_sums
load_vector[slack_nodes] = 0
load_vector[pc_matrix_indices] = 0
+ load_vector[node_element_matrix_indices[fn_slack_unique]] -= fn_slack_sums
+ load_vector[node_element_matrix_indices[tn_slack_unique]] += tn_slack_sums
+ load_vector[node_element_matrix_indices] -= slack_mass
+ if len_fluid and not first_iter:
+ branch_deriv = np.abs(branch_pit[:, net['_idx_branch']['LOAD_VEC_NODES']])
+ node_load = get_load_vec(net, node_pit, node_element_pit, slack_element_mask, use_numba) \
+ * (-1) * node_pit[:, w_n_col].T
+ load_vector[w_node_matrix_indices] = node_load.flatten()
+ node_w_out, load_branch = _sum_by_group(
+ use_numba, vfn, np.abs(branch_deriv))
+ branch_from_load = load_branch * node_pit[node_w_out, :][:, w_n_col].T
+ node_w_outw = np.tile(node_w_out, (len_fluid, 1)) + np.arange(len_fluid)[:, np.newaxis] * (len_n)
+ branch_to_load = np.abs(branch_deriv) * node_pit[vfn, :][:, w_n_col].T
+ node_w_inw, branch_to_load = _sum_by_group(
+ use_numba, tn_w, branch_to_load.flatten())
+ load_vector[w_node_matrix_indices[node_w_outw.flatten()]] -= branch_from_load.flatten()
+ load_vector[w_node_matrix_indices[node_w_inw.flatten()]] += branch_to_load.flatten()
+ mass_slack = slack_wdF_dm * np.tile(slack_mass * count[inv], len_fluid)
+ sl_nods, mass_slack = _sum_by_group(
+ use_numba, slack_nodes_w, mass_slack)
+ load_vector[w_node_matrix_indices[sl_nods]] -= mass_slack
+ s_nods = node_element_pit[~slack_element_mask, nej_col].astype(int)
+ mass_load = node_element_pit[~slack_element_mask, min_col] * \
+ node_element_pit[~slack_element_mask, :][:, w_ne_col].T
+ s_nods = np.tile(s_nods, (len_fluid, 1)) + np.arange(len_fluid)[:, np.newaxis] * (len_n)
+ s_nods, mass_load = _sum_by_group(
+ use_numba, s_nods.flatten(), mass_load.flatten())
+ load_vector[w_node_matrix_indices[s_nods]] += mass_load
+ # print(node_pit[:, w_n_col], '*******', slack_w)
else:
- tn_unique, tn_sums = _sum_by_group(use_numba, tn, branch_pit[:, LOAD_VEC_NODES_T])
+ tn_unique, tn_sums = _sum_by_group(
+ use_numba, tn, branch_pit[:, net['_idx_branch']['LOAD_VEC_NODES_T']])
load_vector = np.zeros(len_n + len_b)
load_vector[len(slack_nodes) + np.arange(0, len(tn_unique_der))] += tn_sums
load_vector[len(slack_nodes) + np.arange(0, len(tn_unique_der))] -= tn_sums_der * node_pit[
- tn_unique_der, TINIT]
+ tn_unique_der, net['_idx_node']['TINIT']]
load_vector[0:len(slack_nodes)] = 0.
- load_vector[len_n:] = branch_pit[:, LOAD_VEC_BRANCHES_T]
-
+ load_vector[len_n:] = branch_pit[:, net['_idx_branch']['LOAD_VEC_BRANCHES_T']]
return system_matrix, load_vector
+
+
+def get_slack_wdF_dm(net, node_pit, node_element_pit, slack_element_mask, w_n_col, w_ne_col,
+ number_slacks_per_junction, inverse_position):
+ len_fluid = len(net['_fluid']) - 1
+ w = np.zeros((len(slack_element_mask[slack_element_mask]), len_fluid))
+ slack_mass = node_element_pit[slack_element_mask, net['_idx_node_element']['MINIT']]
+ slack_nodes = node_element_pit[slack_element_mask, net['_idx_node_element']['JUNCTION']].astype(int)
+ w_div_to = node_element_pit[slack_element_mask, :][:, w_ne_col] / \
+ np.tile(number_slacks_per_junction[inverse_position][:, np.newaxis], len_fluid)
+ w_div_from = node_pit[slack_nodes, :][:, w_n_col] / \
+ np.tile(number_slacks_per_junction[inverse_position][:, np.newaxis], len_fluid)
+ w[slack_mass < 0, :] = w_div_to[slack_mass < 0]
+ w[slack_mass >= 0, :] = w_div_from[slack_mass >= 0]
+ return w.T.flatten()
+
+
+def get_slack_element_nodes_w(net, node_element_pit, slack_element_mask, number_of_fluids, number_of_nodes):
+ slack_element_nodes = node_element_pit[slack_element_mask, net['_idx_node_element']['JUNCTION']].astype(int)
+ slack_element_nodes_w = np.tile(slack_element_nodes, (number_of_fluids, 1)) + \
+ np.arange(number_of_fluids)[:, np.newaxis] * (number_of_nodes)
+ slack_element_nodes_w = slack_element_nodes_w.flatten()
+ return slack_element_nodes_w
+
+
+def get_n_mdF_dw(net, node_pit, node_element_pit, slack_element_mask, number_of_fluids, number_of_nodes):
+ use_numba = get_net_option(net, "use_numba")
+ l = get_load_vec(net, node_pit, node_element_pit, slack_element_mask, use_numba)
+ load = get_w_like_vector(l, number_of_fluids)
+ slack_mass = node_element_pit[slack_element_mask, net['_idx_node_element']['MINIT']]
+ slack_mass = get_w_like_vector(slack_mass, number_of_fluids)
+ slack_nodes = node_element_pit[slack_element_mask, net['_idx_node_element']['JUNCTION']].astype(int)
+ slack_nodes = get_w_like_node_vector(slack_nodes, number_of_fluids, number_of_nodes)
+ mdF_dw = np.zeros(len(load))
+ mdF_dw[load >= 0] += load[load >= 0]
+ mdF_dw[slack_nodes.flatten()[slack_mass >= 0]] += slack_mass[slack_mass >= 0]
+ return mdF_dw
+
+
+def get_n_wdF_dw(net, branch_pit):
+ der_rho_same = get_lookup(net, 'branch', 'deriv_rho_same')[:-1]
+ v_a = np.abs(branch_pit[:, net['_idx_branch']['VINIT']] * branch_pit[:, net['_idx_branch']['AREA']])
+ jac_deriv_rho = branch_pit[:, der_rho_same]
+ wdF_dw = v_a[:, np.newaxis] * jac_deriv_rho
+ return wdF_dw.T.flatten()
+
+
+def get_n_wdF_dw_diff(net, node_pit, branch_pit, w_n_col):
+ v_from_b = branch_pit[:, net['_idx_branch']['V_FROM_NODE']].astype(int)
+ der_rho_diff = get_lookup(net, 'branch', 'deriv_rho_diff')[:-1]
+ w = node_pit[:, w_n_col][v_from_b, :]
+ v_a = np.abs(branch_pit[:, net['_idx_branch']['VINIT']] * branch_pit[:, net['_idx_branch']['AREA']])
+ jac_deriv_rho = branch_pit[:, der_rho_diff]
+ jac_deriv_rho_w = jac_deriv_rho[:, np.newaxis, :] * w[:, :, np.newaxis]
+ v_a_w = np.reshape(np.repeat(v_a, np.shape(jac_deriv_rho)[1] ** 2), np.shape(jac_deriv_rho_w))
+ wdF_dw = v_a_w * jac_deriv_rho_w
+ pos = np.reshape(np.tile(np.eye(np.shape(jac_deriv_rho)[1], dtype=bool), len(jac_deriv_rho_w)).T,
+ np.shape(jac_deriv_rho_w))
+ wdF_dw[pos] = 0
+ sh = np.shape(jac_deriv_rho_w)
+ pos = np.array(list(np.ndindex(sh[0], sh[1], sh[2])))
+ pos_row = ((pos[:, 0] * (sh[1])) + pos[:, 1])
+ pos_col = ((pos[:, 0] * (sh[1])) + pos[:, 2])
+ return wdF_dw.flatten(), pos_row, pos_col
+
+
+def get_fn_rhodF_dw(net, branch_pit, not_slack_from_branches):
+ rhodF_dw = get_n_rhodF_dw(net, branch_pit, not_slack_from_branches)
+ return rhodF_dw
+
+
+def get_tn_rhodF_dw(net, branch_pit, not_slack_to_branches):
+ rhodF_dw = get_n_rhodF_dw(net, branch_pit, not_slack_to_branches)
+ return rhodF_dw
+
+
+def get_fslack_rhodF_dw(net, branch_pit, slack_from_branches):
+ rhodF_dw = get_n_rhodF_dw(net, branch_pit, slack_from_branches)
+ return rhodF_dw
+
+
+def get_tslack_rhodF_dw(net, branch_pit, slack_to_branches):
+ rhodF_dw = get_n_rhodF_dw(net, branch_pit, slack_to_branches)
+ return rhodF_dw
+
+
+def get_n_rhodF_dw(net, branch_pit, branches):
+ der_rho_diff = get_lookup(net, 'branch', 'deriv_rho_diff')[:-1]
+ v_a = branch_pit[branches, net['_idx_branch']['VINIT']] * branch_pit[branches, net['_idx_branch']['AREA']]
+ jac_deriv_rho = branch_pit[:, der_rho_diff][branches, :]
+ rhodF_dw = v_a[:, np.newaxis] * jac_deriv_rho
+ return rhodF_dw.T.flatten()
+
+
+def get_wdF_dv(net, node_pit, branch_pit, w_n_col):
+ load_vec = branch_pit[:, net['_idx_branch']['JAC_DERIV_DV_NODE']] * \
+ np.sign(branch_pit[:, net['_idx_branch']['LOAD_VEC_NODES']])
+ v_from_b = branch_pit[:, net['_idx_branch']['V_FROM_NODE']].astype(int)
+ w = node_pit[:, w_n_col][v_from_b, :]
+ wdF_dv = load_vec[:, np.newaxis] * w
+ return wdF_dv.T.flatten()
+
+
+####################### auxiliaries ###############################
+
+def get_w_like_node_vector(nodes, number_of_fluids, number_of_nodes):
+ nodes_w = np.tile(nodes, (number_of_fluids, 1)) + \
+ np.arange(number_of_fluids)[:, np.newaxis] * (number_of_nodes)
+ nodes_w = nodes_w.flatten()
+ return nodes_w
+
+
+def get_w_like_vector(entry, number_of_fluids):
+ entry_w = np.tile(entry, number_of_fluids)
+ entry_w = entry_w.flatten()
+ return entry_w
+
+
+def get_load_vec(net, node_pit, node_element_pit, slack_element_mask, use_numba):
+ mass_load = node_element_pit[~slack_element_mask, net['_idx_node_element']['MINIT']]
+ s_nods = node_element_pit[~slack_element_mask, net['_idx_node_element']['JUNCTION']].astype(int)
+ s_nods, mass_load = _sum_by_group(use_numba, s_nods.flatten(), mass_load.flatten())
+ l = node_pit[:, net['_idx_node']['LOAD']]
+ load = np.zeros(len(l))
+ load[s_nods] += mass_load
+ load += l
+ load[load<0] = 0
+ return load
diff --git a/pandapipes/pf/create_toolbox.py b/pandapipes/pf/create_toolbox.py
new file mode 100644
index 00000000..e69de29b
diff --git a/pandapipes/pf/derivative_calculation.py b/pandapipes/pf/derivative_calculation.py
index 694034cf..bd0477b9 100644
--- a/pandapipes/pf/derivative_calculation.py
+++ b/pandapipes/pf/derivative_calculation.py
@@ -1,9 +1,9 @@
import numpy as np
-from pandapipes.idx_branch import LENGTH, ETA, RHO, D, K, RE, LAMBDA, TINIT, LOAD_VEC_BRANCHES, \
- JAC_DERIV_DV, JAC_DERIV_DP, JAC_DERIV_DP1, LOAD_VEC_NODES, JAC_DERIV_DV_NODE, VINIT, \
- FROM_NODE, TO_NODE
-from pandapipes.properties.fluids import get_fluid
+
+from pandapipes.properties.fluids import is_fluid_gas, get_fluid, get_mixture_compressibility, \
+ get_mixture_der_cmpressibility
+from pandapipes.pf.pipeflow_setup import get_lookup
def calculate_derivatives_hydraulic(net, branch_pit, node_pit, options):
@@ -20,22 +20,37 @@ def calculate_derivatives_hydraulic(net, branch_pit, node_pit, options):
:type options:
:return: No Output.
"""
- fluid = get_fluid(net)
- gas_mode = fluid.is_gas
+
+ gas_mode = is_fluid_gas(net)
friction_model = options["friction_model"]
lambda_, re = calc_lambda(
- branch_pit[:, VINIT], branch_pit[:, ETA], branch_pit[:, RHO], branch_pit[:, D],
- branch_pit[:, K], gas_mode, friction_model, branch_pit[:, LENGTH], options)
- der_lambda = calc_der_lambda(branch_pit[:, VINIT], branch_pit[:, ETA], branch_pit[:, RHO],
- branch_pit[:, D], branch_pit[:, K], friction_model, lambda_)
- branch_pit[:, RE] = re
- branch_pit[:, LAMBDA] = lambda_
- from_nodes = branch_pit[:, FROM_NODE].astype(np.int32)
- to_nodes = branch_pit[:, TO_NODE].astype(np.int32)
+ branch_pit[:, net['_idx_branch']['VINIT']],
+ branch_pit[:, net['_idx_branch']['ETA']],
+ branch_pit[:, net['_idx_branch']['RHO']],
+ branch_pit[:, net['_idx_branch']['D']],
+ branch_pit[:, net['_idx_branch']['K']],
+ gas_mode, friction_model,
+ branch_pit[:, net['_idx_branch']['LENGTH']], options)
+ der_lambda = calc_der_lambda(
+ branch_pit[:, net['_idx_branch']['VINIT']],
+ branch_pit[:, net['_idx_branch']['ETA']],
+ branch_pit[:, net['_idx_branch']['RHO']],
+ branch_pit[:, net['_idx_branch']['D']],
+ branch_pit[:, net['_idx_branch']['K']],
+ friction_model, lambda_)
+ branch_pit[:, net['_idx_branch']['RE']] = re
+ branch_pit[:, net['_idx_branch']['LAMBDA']] = lambda_
+ from_nodes = branch_pit[:, net['_idx_branch']['FROM_NODE']].astype(np.int32)
+ to_nodes = branch_pit[:, net['_idx_branch']['TO_NODE']].astype(np.int32)
tinit_branch, height_difference, p_init_i_abs, p_init_i1_abs = \
- get_derived_values(node_pit, from_nodes, to_nodes, options["use_numba"])
- branch_pit[:, TINIT] = tinit_branch
+ get_derived_values(net, node_pit, from_nodes, to_nodes, options["use_numba"])
+ branch_pit[:, net['_idx_branch']['TINIT']] = tinit_branch
+
+ pit_cols = np.array([net['_idx_branch']['VINIT'], net['_idx_branch']['LENGTH'], net['_idx_branch']['LAMBDA'],
+ net['_idx_branch']['D'], net['_idx_branch']['LOSS_COEFFICIENT'], net['_idx_branch']['RHO'],
+ net['_idx_branch']['PL'], net['_idx_branch']['AREA'], net['_idx_branch']['TINIT']],
+ dtype=np.int32)
if not gas_mode:
if options["use_numba"]:
@@ -46,7 +61,7 @@ def calculate_derivatives_hydraulic(net, branch_pit, node_pit, options):
as derivatives_hydraulic_incomp
load_vec, load_vec_nodes, df_dv, df_dv_nodes, df_dp, df_dp1 = derivatives_hydraulic_incomp(
- branch_pit, der_lambda, p_init_i_abs, p_init_i1_abs, height_difference)
+ pit_cols, branch_pit, der_lambda, p_init_i_abs, p_init_i1_abs, height_difference)
else:
if options["use_numba"]:
from pandapipes.pf.derivative_toolbox_numba import derivatives_hydraulic_comp_numba \
@@ -56,29 +71,42 @@ def calculate_derivatives_hydraulic(net, branch_pit, node_pit, options):
from pandapipes.pf.derivative_toolbox import derivatives_hydraulic_comp_np \
as derivatives_hydraulic_comp, calc_medium_pressure_with_derivative_np as \
calc_medium_pressure_with_derivative
+
p_m, der_p_m, der_p_m1 = calc_medium_pressure_with_derivative(p_init_i_abs, p_init_i1_abs)
- comp_fact = fluid.get_compressibility(p_m)
+ if len(net._fluid) == 1:
+ fluid = net._fluid[0]
+ comp_fact = get_fluid(net, fluid).get_compressibility(p_m)
+ der_comp_fact = get_fluid(net, fluid).get_der_compressibility()
+ der_comp = der_comp_fact * der_p_m
+ der_comp1 = der_comp_fact * der_p_m1
+ else:
+ w = get_lookup(net, 'branch', 'w')
+ mf = branch_pit[:, w]
+ comp_fact = get_mixture_compressibility(net, p_m, mf)
+ der_comp_fact = get_mixture_der_cmpressibility(net, p_m, mf)
+ der_comp = der_comp_fact * der_p_m
+ der_comp1 = der_comp_fact * der_p_m1
# TODO: this might not be required
- der_comp = fluid.get_der_compressibility() * der_p_m
- der_comp1 = fluid.get_der_compressibility() * der_p_m1
load_vec, load_vec_nodes, df_dv, df_dv_nodes, df_dp, df_dp1 = derivatives_hydraulic_comp(
- branch_pit, lambda_, der_lambda, p_init_i_abs, p_init_i1_abs, height_difference,
+ pit_cols, branch_pit, lambda_, der_lambda, p_init_i_abs, p_init_i1_abs, height_difference,
comp_fact, der_comp, der_comp1)
- branch_pit[:, LOAD_VEC_BRANCHES] = load_vec
- branch_pit[:, JAC_DERIV_DV] = df_dv
- branch_pit[:, JAC_DERIV_DP] = df_dp
- branch_pit[:, JAC_DERIV_DP1] = df_dp1
- branch_pit[:, LOAD_VEC_NODES] = load_vec_nodes
- branch_pit[:, JAC_DERIV_DV_NODE] = df_dv_nodes
+ branch_pit[:, net['_idx_branch']['LOAD_VEC_BRANCHES']] = load_vec
+ branch_pit[:, net['_idx_branch']['JAC_DERIV_DV']] = df_dv
+ branch_pit[:, net['_idx_branch']['JAC_DERIV_DP']] = df_dp
+ branch_pit[:, net['_idx_branch']['JAC_DERIV_DP1']] = df_dp1
+ branch_pit[:, net['_idx_branch']['LOAD_VEC_NODES']] = load_vec_nodes
+ branch_pit[:, net['_idx_branch']['JAC_DERIV_DV_NODE']] = df_dv_nodes
-def get_derived_values(node_pit, from_nodes, to_nodes, use_numba):
+def get_derived_values(net, node_pit, from_nodes, to_nodes, use_numba):
+ pit_cols = np.array([net['_idx_node']['TINIT'], net['_idx_node']['HEIGHT'],
+ net['_idx_node']['PINIT'], net['_idx_node']['PAMB']], dtype=np.int32)
if use_numba:
from pandapipes.pf.derivative_toolbox_numba import calc_derived_values_numba
- return calc_derived_values_numba(node_pit, from_nodes, to_nodes)
+ return calc_derived_values_numba(pit_cols, node_pit, from_nodes, to_nodes)
from pandapipes.pf.derivative_toolbox import calc_derived_values_np
- return calc_derived_values_np(node_pit, from_nodes, to_nodes)
+ return calc_derived_values_np(pit_cols, node_pit, from_nodes, to_nodes)
def calc_lambda(v, eta, rho, d, k, gas_mode, friction_model, lengths, options):
diff --git a/pandapipes/pf/derivative_toolbox.py b/pandapipes/pf/derivative_toolbox.py
index 1dc93d71..7efb7c40 100644
--- a/pandapipes/pf/derivative_toolbox.py
+++ b/pandapipes/pf/derivative_toolbox.py
@@ -7,48 +7,53 @@
from pandapipes.constants import P_CONVERSION, GRAVITATION_CONSTANT, NORMAL_PRESSURE, \
NORMAL_TEMPERATURE
-from pandapipes.idx_branch import LENGTH, LAMBDA, D, LOSS_COEFFICIENT as LC, RHO, PL, AREA, TINIT, \
- VINIT
-from pandapipes.idx_node import HEIGHT, PINIT, PAMB, TINIT as TINIT_NODE
-def derivatives_hydraulic_incomp_np(branch_pit, der_lambda, p_init_i_abs, p_init_i1_abs,
+def derivatives_hydraulic_incomp_np(pit_cols, branch_pit, der_lambda, p_init_i_abs, p_init_i1_abs,
height_difference):
- v_init_abs = np.abs(branch_pit[:, VINIT])
- v_init2 = v_init_abs * branch_pit[:, VINIT]
- lambda_term = np.divide(branch_pit[:, LENGTH] * branch_pit[:, LAMBDA], branch_pit[:, D]) \
- + branch_pit[:, LC]
- const_p_term = np.divide(branch_pit[:, RHO], P_CONVERSION * 2)
+ v_init_abs = np.abs(branch_pit[:, pit_cols[0]])
+ v_init2 = v_init_abs * branch_pit[:, pit_cols[0]]
+ lambda_term = np.divide(branch_pit[:, pit_cols[1]] *
+ branch_pit[:, pit_cols[2]],
+ branch_pit[:, pit_cols[3]]) + \
+ branch_pit[:, pit_cols[4]]
+ const_p_term = np.divide(branch_pit[:, pit_cols[5]], P_CONVERSION * 2)
df_dv = const_p_term * (2 * v_init_abs * lambda_term + der_lambda
- * np.divide(branch_pit[:, LENGTH], branch_pit[:, D]) * v_init2)
- load_vec = p_init_i_abs - p_init_i1_abs + branch_pit[:, PL] \
+ * np.divide(branch_pit[:, pit_cols[1]],
+ branch_pit[:, pit_cols[3]]) * v_init2)
+ load_vec = p_init_i_abs - p_init_i1_abs + branch_pit[:, pit_cols[6]] \
+ const_p_term * (GRAVITATION_CONSTANT * 2 * height_difference
- v_init2 * lambda_term)
- mass_flow_dv = branch_pit[:, RHO] * branch_pit[:, AREA]
+ mass_flow_dv = branch_pit[:, pit_cols[5]] * \
+ branch_pit[:, pit_cols[7]]
df_dv_nodes = mass_flow_dv
- load_vec_nodes = mass_flow_dv * branch_pit[:, VINIT]
+ load_vec_nodes = mass_flow_dv * branch_pit[:, pit_cols[0]]
df_dp = np.ones_like(der_lambda) * (-1)
df_dp1 = np.ones_like(der_lambda)
return load_vec, load_vec_nodes, df_dv, df_dv_nodes, df_dp, df_dp1
-def derivatives_hydraulic_comp_np(branch_pit, lambda_, der_lambda, p_init_i_abs, p_init_i1_abs,
+def derivatives_hydraulic_comp_np(pit_cols, branch_pit, lambda_, der_lambda, p_init_i_abs, p_init_i1_abs,
height_difference, comp_fact, der_comp, der_comp1):
# Formulas for gas pressure loss according to laminar version
- v_init_abs = np.abs(branch_pit[:, VINIT])
- v_init2 = branch_pit[:, VINIT] * v_init_abs
+ v_init_abs = np.abs(branch_pit[:, pit_cols[0]])
+ v_init2 = branch_pit[:, pit_cols[0]] * v_init_abs
p_diff = p_init_i_abs - p_init_i1_abs
p_sum = p_init_i_abs + p_init_i1_abs
p_sum_div = np.divide(1, p_sum)
- const_lambda = np.divide(NORMAL_PRESSURE * branch_pit[:, RHO] * branch_pit[:, TINIT],
+ const_lambda = np.divide(NORMAL_PRESSURE *
+ branch_pit[:, pit_cols[5]] *
+ branch_pit[:, pit_cols[8]],
NORMAL_TEMPERATURE * P_CONVERSION)
const_height = np.divide(
- branch_pit[:, RHO] * NORMAL_TEMPERATURE * GRAVITATION_CONSTANT * height_difference,
- 2 * NORMAL_PRESSURE * branch_pit[:, TINIT] * P_CONVERSION)
- friction_term = np.divide(lambda_ * branch_pit[:, LENGTH], branch_pit[:, D]) + branch_pit[:, LC]
+ branch_pit[:, pit_cols[5]] * NORMAL_TEMPERATURE * GRAVITATION_CONSTANT * height_difference,
+ 2 * NORMAL_PRESSURE * branch_pit[:, pit_cols[8]] * P_CONVERSION)
+ friction_term = np.divide(lambda_ * branch_pit[:, pit_cols[1]],
+ branch_pit[:, pit_cols[3]]) + \
+ branch_pit[:, pit_cols[4]]
- load_vec = p_diff + branch_pit[:, PL] + const_height * p_sum \
+ load_vec = p_diff + branch_pit[:, pit_cols[6]] + const_height * p_sum \
- const_lambda * comp_fact * v_init2 * friction_term * p_sum_div
p_deriv = const_lambda * v_init2 * friction_term * p_sum_div
@@ -56,11 +61,11 @@ def derivatives_hydraulic_comp_np(branch_pit, lambda_, der_lambda, p_init_i_abs,
df_dp1 = 1. + p_deriv * (der_comp1 - comp_fact * p_sum_div) + const_height
df_dv = np.divide(2 * const_lambda * comp_fact, p_sum) * v_init_abs * friction_term \
- + np.divide(const_lambda * comp_fact * der_lambda * branch_pit[:, LENGTH] * v_init2,
- p_sum * branch_pit[:, D])
- mass_flow_dv = branch_pit[:, RHO] * branch_pit[:, AREA]
+ + np.divide(const_lambda * comp_fact * der_lambda * branch_pit[:, pit_cols[1]] * v_init2,
+ p_sum * branch_pit[:, pit_cols[3]])
+ mass_flow_dv = branch_pit[:, pit_cols[5]] * branch_pit[:, pit_cols[7]]
df_dv_nodes = mass_flow_dv
- load_vec_nodes = mass_flow_dv * branch_pit[:, VINIT]
+ load_vec_nodes = mass_flow_dv * branch_pit[:, pit_cols[0]]
return load_vec, load_vec_nodes, df_dv, df_dv_nodes, df_dp, df_dp1
@@ -156,9 +161,41 @@ def colebrook_np(re, d, k, lambda_nikuradse, dummy, max_iter):
return converged, lambda_cb
-def calc_derived_values_np(node_pit, from_nodes, to_nodes):
- tinit_branch = (node_pit[from_nodes, TINIT_NODE] + node_pit[to_nodes, TINIT_NODE]) / 2
- height_difference = node_pit[from_nodes, HEIGHT] - node_pit[to_nodes, HEIGHT]
- p_init_i_abs = node_pit[from_nodes, PINIT] + node_pit[from_nodes, PAMB]
- p_init_i1_abs = node_pit[to_nodes, PINIT] + node_pit[to_nodes, PAMB]
+def calc_derived_values_np(pit_cols, node_pit, from_nodes, to_nodes):
+ tinit_branch = (node_pit[from_nodes, pit_cols[0]] +
+ node_pit[to_nodes, pit_cols[0]]) / 2
+ height_difference = node_pit[from_nodes, pit_cols[1]] - \
+ node_pit[to_nodes, pit_cols[1]]
+ p_init_i_abs = node_pit[from_nodes, pit_cols[2]] + \
+ node_pit[from_nodes, pit_cols[3]]
+ p_init_i1_abs = node_pit[to_nodes, pit_cols[2]] + \
+ node_pit[to_nodes, pit_cols[3]]
return tinit_branch, height_difference, p_init_i_abs, p_init_i1_abs
+
+
+def get_derivative_density_diff(mass_fraction, density_list):
+ rho_prod = np.prod(density_list, axis=1)
+ shape = np.shape(mass_fraction)
+ loop = np.arange(0, shape[1])
+ nom = np.zeros(shape[0])
+ rho_select = np.zeros(shape)
+ for i in loop:
+ select = loop != i
+ nom += mass_fraction[:, i] * np.prod(density_list[:, select], axis=1)
+ rho_select[:, i] += np.prod(density_list[:, select], axis=1)
+ res = -rho_prod[:, np.newaxis] * rho_select * nom[:, np.newaxis] ** -2
+ return res
+
+
+def get_derivative_density_same(mass_fraction, density_list):
+ rho_prod = np.prod(density_list, axis=1)
+ shape = np.shape(mass_fraction)
+ loop = np.arange(0, shape[1])
+ nom = np.zeros(shape[0])
+ rho_select = np.zeros(shape)
+ for i in loop:
+ select = loop != i
+ nom += mass_fraction[:, i] * np.prod(density_list[:, select], axis=1)
+ rho_select[:, i] += np.prod(density_list[:, select], axis=1) * mass_fraction[:, i]
+ res = rho_prod[:, np.newaxis] * (-rho_select+nom[:, np.newaxis]) * nom[:, np.newaxis] ** -2
+ return res
\ No newline at end of file
diff --git a/pandapipes/pf/derivative_toolbox_numba.py b/pandapipes/pf/derivative_toolbox_numba.py
index a3b7f3eb..d6d807d0 100644
--- a/pandapipes/pf/derivative_toolbox_numba.py
+++ b/pandapipes/pf/derivative_toolbox_numba.py
@@ -3,9 +3,6 @@
from pandapipes.constants import P_CONVERSION, GRAVITATION_CONSTANT, NORMAL_PRESSURE, \
NORMAL_TEMPERATURE
-from pandapipes.idx_branch import LENGTH, LAMBDA, D, LOSS_COEFFICIENT as LC, RHO, PL, AREA, TINIT, \
- VINIT
-from pandapipes.idx_node import HEIGHT, PAMB, PINIT, TINIT as TINIT_NODE
try:
from numba import jit
@@ -15,8 +12,8 @@
from numpy import int32, float64, int64
-@jit((float64[:, :], float64[:], float64[:], float64[:], float64[:]), nopython=True, cache=False)
-def derivatives_hydraulic_incomp_numba(branch_pit, der_lambda, p_init_i_abs, p_init_i1_abs,
+@jit((int32[:], float64[:, :], float64[:], float64[:], float64[:], float64[:]), nopython=True, cache=False)
+def derivatives_hydraulic_incomp_numba(pit_cols, branch_pit, der_lambda, p_init_i_abs, p_init_i1_abs,
height_difference):
le = der_lambda.shape[0]
load_vec = np.zeros_like(der_lambda)
@@ -27,25 +24,29 @@ def derivatives_hydraulic_incomp_numba(branch_pit, der_lambda, p_init_i_abs, p_i
df_dv_nodes = np.zeros_like(der_lambda)
for i in range(le):
- v_init_abs = np.abs(branch_pit[i][VINIT])
- v_init2 = v_init_abs * branch_pit[i][VINIT]
- lambda_term = np.divide(branch_pit[i][LENGTH] * branch_pit[i][LAMBDA], branch_pit[i][D]) \
- + branch_pit[i][LC]
- const_p_term = np.divide(branch_pit[i][RHO], P_CONVERSION * 2)
+ v_init_abs = np.abs(branch_pit[i][pit_cols[0]])
+ v_init2 = v_init_abs * branch_pit[i][pit_cols[0]]
+ lambda_term = np.divide(branch_pit[i][pit_cols[1]] *
+ branch_pit[i][pit_cols[2]],
+ branch_pit[i][pit_cols[3]]) + \
+ branch_pit[i][pit_cols[4]]
+ const_p_term = np.divide(branch_pit[i][pit_cols[5]], P_CONVERSION * 2)
df_dv[i] = const_p_term * (2 * v_init_abs * lambda_term + der_lambda[i]
- * np.divide(branch_pit[i][LENGTH], branch_pit[i][D]) * v_init2)
- load_vec[i] = p_init_i_abs[i] - p_init_i1_abs[i] + branch_pit[i][PL] \
+ * np.divide(branch_pit[i][pit_cols[1]],
+ branch_pit[i][pit_cols[3]]) * v_init2)
+ load_vec[i] = p_init_i_abs[i] - p_init_i1_abs[i] + branch_pit[i][pit_cols[6]] \
+ const_p_term * (GRAVITATION_CONSTANT * 2 * height_difference[i]
- v_init2 * lambda_term)
- mass_flow_dv = branch_pit[i][RHO] * branch_pit[i][AREA]
+ mass_flow_dv = branch_pit[i][pit_cols[5]] * \
+ branch_pit[i][pit_cols[7]]
df_dv_nodes[i] = mass_flow_dv
- load_vec_nodes[i] = mass_flow_dv * branch_pit[i][VINIT]
+ load_vec_nodes[i] = mass_flow_dv * branch_pit[i][pit_cols[0]]
return load_vec, load_vec_nodes, df_dv, df_dv_nodes, df_dp, df_dp1
-@jit((float64[:, :], float64[:], float64[:], float64[:], float64[:], float64[:], float64[:],
+@jit((int32[:], float64[:, :], float64[:], float64[:], float64[:], float64[:], float64[:], float64[:],
float64[:], float64[:]), nopython=True, cache=False)
-def derivatives_hydraulic_comp_numba(branch_pit, lambda_, der_lambda, p_init_i_abs, p_init_i1_abs,
+def derivatives_hydraulic_comp_numba(pit_cols, branch_pit, lambda_, der_lambda, p_init_i_abs, p_init_i1_abs,
height_difference, comp_fact, der_comp, der_comp1):
le = lambda_.shape[0]
load_vec = np.zeros_like(lambda_)
@@ -58,21 +59,23 @@ def derivatives_hydraulic_comp_numba(branch_pit, lambda_, der_lambda, p_init_i_a
# Formulas for gas pressure loss according to laminar version
for i in range(le):
# compressibility settings
- v_init_abs = np.abs(branch_pit[i][VINIT])
- v_init2 = branch_pit[i][VINIT] * v_init_abs
+ v_init_abs = np.abs(branch_pit[i][pit_cols[0]])
+ v_init2 = branch_pit[i][pit_cols[0]] * v_init_abs
p_diff = p_init_i_abs[i] - p_init_i1_abs[i]
p_sum = p_init_i_abs[i] + p_init_i1_abs[i]
p_sum_div = np.divide(1, p_sum)
- const_lambda = np.divide(NORMAL_PRESSURE * branch_pit[i][RHO] * branch_pit[i][TINIT],
+ const_lambda = np.divide(NORMAL_PRESSURE * branch_pit[i][pit_cols[5]] *
+ branch_pit[i][pit_cols[8]],
NORMAL_TEMPERATURE * P_CONVERSION)
const_height = np.divide(
- branch_pit[i][RHO] * NORMAL_TEMPERATURE * GRAVITATION_CONSTANT * height_difference[i],
- 2 * NORMAL_PRESSURE * branch_pit[i][TINIT] * P_CONVERSION)
- friction_term = np.divide(lambda_[i] * branch_pit[i][LENGTH],
- branch_pit[i][D]) + branch_pit[i][LC]
+ branch_pit[i][pit_cols[5]] * NORMAL_TEMPERATURE * GRAVITATION_CONSTANT * height_difference[i],
+ 2 * NORMAL_PRESSURE * branch_pit[i][pit_cols[8]] * P_CONVERSION)
+ friction_term = np.divide(lambda_[i] * branch_pit[i][pit_cols[1]],
+ branch_pit[i][pit_cols[3]]) + \
+ branch_pit[i][pit_cols[4]]
- load_vec[i] = p_diff + branch_pit[i][PL] + const_height * p_sum \
+ load_vec[i] = p_diff + branch_pit[i][pit_cols[6]] + const_height * p_sum \
- const_lambda * comp_fact[i] * v_init2 * friction_term * p_sum_div
p_deriv = const_lambda * v_init2 * friction_term * p_sum_div
@@ -80,11 +83,12 @@ def derivatives_hydraulic_comp_numba(branch_pit, lambda_, der_lambda, p_init_i_a
df_dp1[i] = 1. + p_deriv * (der_comp1[i] - comp_fact[i] * p_sum_div) + const_height
df_dv[i] = np.divide(2 * const_lambda * comp_fact[i], p_sum) * v_init_abs * friction_term\
- + np.divide(const_lambda * comp_fact[i] * der_lambda[i] * branch_pit[i][LENGTH]
- * v_init2, p_sum * branch_pit[i][D])
- mass_flow_dv = branch_pit[i][RHO] * branch_pit[i][AREA]
+ + np.divide(const_lambda * comp_fact[i] * der_lambda[i] * branch_pit[i][pit_cols[1]]
+ * v_init2, p_sum * branch_pit[i][pit_cols[3]])
+ mass_flow_dv = branch_pit[i][pit_cols[5]] * \
+ branch_pit[i][pit_cols[7]]
df_dv_nodes[i] = mass_flow_dv
- load_vec_nodes[i] = mass_flow_dv * branch_pit[i][VINIT]
+ load_vec_nodes[i] = mass_flow_dv * branch_pit[i][pit_cols[0]]
return load_vec, load_vec_nodes, df_dv, df_dv_nodes, df_dp, df_dp1
@@ -177,8 +181,8 @@ def colebrook_numba(re, d, k, lambda_nikuradse, dummy, max_iter):
return converged, lambda_cb
-@jit((float64[:, :], int32[:], int32[:]), nopython=True)
-def calc_derived_values_numba(node_pit, from_nodes, to_nodes):
+@jit((int32[:], float64[:, :], int32[:], int32[:]), nopython=True)
+def calc_derived_values_numba(pit_cols, node_pit, from_nodes, to_nodes):
le = len(from_nodes)
tinit_branch = np.empty(le, dtype=np.float64)
height_difference = np.empty(le, dtype=np.float64)
@@ -187,8 +191,12 @@ def calc_derived_values_numba(node_pit, from_nodes, to_nodes):
for i in range(le):
fn = from_nodes[i]
tn = to_nodes[i]
- tinit_branch[i] = (node_pit[fn, TINIT_NODE] + node_pit[tn, TINIT_NODE]) / 2
- height_difference[i] = node_pit[fn, HEIGHT] - node_pit[tn, HEIGHT]
- p_init_i_abs[i] = node_pit[fn, PINIT] + node_pit[fn, PAMB]
- p_init_i1_abs[i] = node_pit[tn, PINIT] + node_pit[tn, PAMB]
+ tinit_branch[i] = (node_pit[fn, pit_cols[0]] +
+ node_pit[tn, pit_cols[0]]) / 2
+ height_difference[i] = node_pit[fn, pit_cols[1]] - \
+ node_pit[tn, pit_cols[1]]
+ p_init_i_abs[i] = node_pit[fn, pit_cols[2]] + \
+ node_pit[fn, pit_cols[3]]
+ p_init_i1_abs[i] = node_pit[tn, pit_cols[2]] + \
+ node_pit[tn, pit_cols[3]]
return tinit_branch, height_difference, p_init_i_abs, p_init_i1_abs
diff --git a/pandapipes/pf/pipeflow_setup.py b/pandapipes/pf/pipeflow_setup.py
index 3ec5fdd6..818ce8d7 100644
--- a/pandapipes/pf/pipeflow_setup.py
+++ b/pandapipes/pf/pipeflow_setup.py
@@ -8,10 +8,10 @@
import numpy as np
from scipy.sparse import coo_matrix, csgraph
-from pandapipes.idx_branch import FROM_NODE, TO_NODE, branch_cols, \
- ACTIVE as ACTIVE_BR
-from pandapipes.idx_node import NODE_TYPE, P, NODE_TYPE_T, node_cols, T, ACTIVE as ACTIVE_ND, \
- TABLE_IDX as TABLE_IDX_ND, ELEMENT_IDX as ELEMENT_IDX_ND, PC
+from pandapipes.idx_branch import idx_branch
+from pandapipes.idx_node import idx_node
+from pandapipes.idx_node_element import idx_node_element
+from warnings import warn
from pandapipes.properties.fluids import get_fluid
try:
@@ -24,13 +24,14 @@
numba_installed = False
try:
- import pplog as logging
+ from pandaplan.core import pplog as logging
except ImportError:
import logging
logger = logging.getLogger(__name__)
-default_options = {"friction_model": "nikuradse", "converged": False, "tol_p": 1e-4, "tol_v": 1e-4,
+default_options = {"friction_model": "nikuradse", "converged": False,
+ "tol_p": 1e-4, "tol_v": 1e-4, "tol_m": 1e-4, "tol_w": 1e-4,
"tol_T": 1e-3, "tol_res": 1e-3, "iter": 10, "error_flag": False, "alpha": 1,
"nonlinear_method": "constant", "mode": "hydraulics",
"ambient_temperature": 293, "check_connectivity": True,
@@ -162,13 +163,13 @@ def get_lookup(net, pit_type="node", lookup_type="index"):
pit_type = pit_type.lower()
lookup_type = lookup_type.lower()
all_lookup_types = ["index", "table", "from_to", "active", "length", "from_to_active",
- "index_active"]
+ "index_active", "w", "rho", "deriv_rho_same", "deriv_rho_diff"]
if lookup_type not in all_lookup_types:
type_names = "', '".join(all_lookup_types)
logger.error("No lookup type '%s' exists. Please choose one of '%s'."
% (lookup_type, type_names))
return None
- if pit_type not in ["node", "branch"]:
+ if pit_type not in ["node", "branch", "node_element"]:
logger.error("No pit type '%s' exists. Please choose one of 'node' and 'branch'."
% pit_type)
return None
@@ -295,7 +296,6 @@ def init_options(net, local_parameters):
params[k] = v
params.update(local_parameters["kwargs"])
net["_options"].update(params)
- net["_options"]["fluid"] = get_fluid(net).name
if not net["_options"]["only_update_hydraulic_matrix"]:
net["_options"]["reuse_internal_data"] = False
@@ -346,11 +346,12 @@ def initialize_pit(net):
"""
pit = create_empty_pit(net)
-
- for comp in net['component_list']:
+ for comp in np.concatenate([net['node_list'], net['node_element_list'], net['branch_list']]):
comp.create_pit_node_entries(net, pit["node"])
comp.create_pit_branch_entries(net, pit["branch"])
- return pit["node"], pit["branch"]
+ for comp in net['node_element_list']:
+ comp.create_pit_node_element_entries(net, pit["node_element"])
+ return pit["node"], pit["branch"], pit["node_element"]
def create_empty_pit(net):
@@ -371,9 +372,12 @@ def create_empty_pit(net):
"""
node_length = get_lookup(net, "node", "length")
branch_length = get_lookup(net, "branch", "length")
+ node_element_length = get_lookup(net, "node_element", "length")
# init empty pit
- pit = {"node": np.empty((node_length, node_cols), dtype=np.float64),
- "branch": np.empty((branch_length, branch_cols), dtype=np.float64)}
+ pit = {"node": np.empty((node_length, net['_idx_node']['node_cols']), dtype=np.float64),
+ "branch": np.empty((branch_length, net['_idx_branch']['branch_cols']), dtype=np.float64),
+ "node_element": np.empty((node_element_length,
+ net['_idx_node_element']['node_element_cols']), dtype=np.float64)}
net["_pit"] = pit
return pit
@@ -387,7 +391,7 @@ def init_all_result_tables(net):
:return: No output
"""
- for comp in net['component_list']:
+ for comp in np.concatenate([net['node_list'], net['node_element_list'], net['branch_list']]):
comp.init_results(net)
@@ -416,26 +420,52 @@ def create_lookups(net):
"""
node_ft_lookups, node_idx_lookups, node_from, node_table_nr = dict(), dict(), 0, 0
branch_ft_lookups, branch_idx_lookups, branch_from, branch_table_nr = dict(), dict(), 0, 0
+ node_element_ft_lookups, node_element_idx_lookups, node_element_from, node_element_table_nr = dict(), dict(), 0, 0
branch_table_lookups = {"t2n": dict(), "n2t": dict()}
node_table_lookups = {"t2n": dict(), "n2t": dict()}
+ node_element_table_lookups = {"t2n": dict(), "n2t": dict()}
internal_nodes_lookup = dict()
- for comp in net['component_list']:
+ for comp in np.concatenate([net.node_list, net.node_element_list, net.branch_list]):
branch_from, branch_table_nr = comp.create_branch_lookups(
- net, branch_ft_lookups, branch_table_lookups, branch_idx_lookups, branch_table_nr,
- branch_from)
+ net, branch_ft_lookups, branch_table_lookups, branch_idx_lookups, branch_table_nr, branch_from)
node_from, node_table_nr = comp.create_node_lookups(
- net, node_ft_lookups, node_table_lookups, node_idx_lookups, node_from, node_table_nr,
- internal_nodes_lookup)
+ net, node_ft_lookups, node_table_lookups, node_idx_lookups, node_from, node_table_nr, internal_nodes_lookup)
+
+ for comp in net.node_element_list:
+ node_element_from, node_element_table_nr = comp.create_node_element_lookups(
+ net, node_element_ft_lookups, node_element_table_lookups, node_element_idx_lookups, node_element_from,
+ node_element_table_nr)
+ node_element_w, node_w, branch_w, \
+ node_rho, branch_rho, jac_node_rho_same, jac_node_rho_diff, \
+ jac_branch_rho_same, jac_branch_rho_diff = \
+ np.array([(net._idx_node_element[fluid + '_W'], net._idx_node[fluid + '_W'], net._idx_branch[fluid + '_W'],
+ net._idx_node[fluid + '_RHO'], net._idx_branch[fluid + '_RHO'],
+ net._idx_node[fluid + '_JAC_DERIV_RHO_SAME_W'], net._idx_node[fluid + '_JAC_DERIV_RHO_DIFF_W'],
+ net._idx_branch[fluid + '_JAC_DERIV_RHO_SAME_W'], net._idx_branch[fluid + '_JAC_DERIV_RHO_DIFF_W'],)
+ for fluid in net._fluid]).T
net["_lookups"] = {"node_from_to": node_ft_lookups, "branch_from_to": branch_ft_lookups,
+ "node_element_from_to": node_element_ft_lookups,
"node_table": node_table_lookups, "branch_table": branch_table_lookups,
+ "node_element_table": node_element_table_lookups,
"node_index": node_idx_lookups, "branch_index": branch_idx_lookups,
+ "node_element_index": node_element_idx_lookups,
"node_length": node_from, "branch_length": branch_from,
- "internal_nodes_lookup": internal_nodes_lookup}
+ "node_element_length": node_element_from,
+ "internal_nodes_lookup": internal_nodes_lookup,
+ "node_w": node_w,
+ "branch_w": branch_w,
+ "node_element_w": node_element_w,
+ "node_rho": node_rho,
+ "branch_rho": branch_rho,
+ "node_deriv_rho_same": jac_node_rho_same,
+ "branch_deriv_rho_same": jac_branch_rho_same,
+ "node_deriv_rho_diff": jac_node_rho_diff,
+ "branch_deriv_rho_diff": jac_branch_rho_diff}
-def check_connectivity(net, branch_pit, node_pit, check_heat):
+def check_connectivity(net, branch_pit, node_pit, node_element_pit, check_heat):
"""
Perform a connectivity check which means that network nodes are identified that don't have any
connection to an external grid component. Quick overview over the steps of this function:
@@ -468,59 +498,52 @@ def check_connectivity(net, branch_pit, node_pit, check_heat):
internal nodes and branches are reachable from any of the hyd_slacks (np mask).
:rtype: tuple(np.array)
"""
- active_branch_lookup = branch_pit[:, ACTIVE_BR].astype(bool)
- active_node_lookup = node_pit[:, ACTIVE_ND].astype(bool)
- from_nodes = branch_pit[:, FROM_NODE].astype(np.int32)
- to_nodes = branch_pit[:, TO_NODE].astype(np.int32)
- hyd_slacks = np.where((node_pit[:, NODE_TYPE] == P) & active_node_lookup)[0]
- # hyd_slacks = np.where(((node_pit[:, NODE_TYPE] == P) | (node_pit[:, NODE_TYPE] == PC))
- # & active_node_lookup)[0]
-
- nodes_connected, branches_connected = perform_connectivity_search(
- net, node_pit, hyd_slacks, from_nodes, to_nodes, active_node_lookup, active_branch_lookup,
+ active_branch_lookup = branch_pit[:, net['_idx_branch']['ACTIVE']].astype(bool)
+ active_node_lookup = node_pit[:, net['_idx_node']['ACTIVE']].astype(bool)
+ active_node_elements_lookup = node_element_pit[:, net['_idx_node_element']['ACTIVE']].astype(bool)
+ from_nodes = branch_pit[:, net['_idx_branch']['FROM_NODE']].astype(np.int32)
+ to_nodes = branch_pit[:, net['_idx_branch']['TO_NODE']].astype(np.int32)
+ hyd_slacks = np.where((node_pit[:, net['_idx_node']['NODE_TYPE']] == net['_idx_node']['P'])
+ & active_node_lookup)[0]
+ node_element_nodes = node_element_pit[:, net['_idx_node_element']['JUNCTION']].astype(np.int32)
+
+ nodes_connected, branches_connected, node_elements_connected = perform_connectivity_search(
+ net, node_pit, node_element_pit, hyd_slacks, from_nodes, to_nodes, node_element_nodes,
+ active_node_lookup, active_branch_lookup, active_node_elements_lookup,
mode="hydraulics")
if not check_heat:
- return nodes_connected, branches_connected
+ return nodes_connected, branches_connected, node_elements_connected
- heat_slacks = np.where((node_pit[:, NODE_TYPE_T] == T) & nodes_connected)[0]
+ heat_slacks = np.where((node_pit[:, net['_idx_node']['NODE_TYPE_T']] == net['_idx_node']['T']) & nodes_connected)[0]
if len(heat_slacks) == len(hyd_slacks) and np.all(heat_slacks == hyd_slacks):
- return nodes_connected, branches_connected
+ return nodes_connected, branches_connected, node_elements_connected
- nodes_connected, branches_connected = perform_connectivity_search(
- net, node_pit, heat_slacks, from_nodes, to_nodes, nodes_connected, branches_connected,
+ nodes_connected, branches_connected, node_elements_connected = perform_connectivity_search(
+ net, node_pit, node_element_pit, heat_slacks, from_nodes, to_nodes, node_element_nodes,
+ nodes_connected, branches_connected, node_elements_connected,
mode="heat transfer")
- return nodes_connected, branches_connected
+ return nodes_connected, branches_connected, node_elements_connected
-def perform_connectivity_search(net, node_pit, slack_nodes, from_nodes, to_nodes,
- active_node_lookup, active_branch_lookup, mode="hydraulics"):
- len_nodes = len(node_pit)
- nobranch = np.sum(active_branch_lookup)
+def perform_connectivity_search(net, node_pit, node_element_pit, slack_nodes, from_nodes, to_nodes, node_element_nodes,
+ active_node_lookup, active_branch_lookup, active_node_element_lookup,
+ mode="hydraulics"):
active_from_nodes = from_nodes[active_branch_lookup]
active_to_nodes = to_nodes[active_branch_lookup]
- # we create a "virtual" node that is connected to all slack nodes and start the connectivity
- # search at this node
- fn_matrix = np.concatenate([active_from_nodes, slack_nodes])
- tn_matrix = np.concatenate([active_to_nodes,
- np.full(len(slack_nodes), len_nodes, dtype=np.int32)])
-
- adj_matrix = coo_matrix((np.ones(nobranch + len(slack_nodes)), (fn_matrix, tn_matrix)),
- shape=(len_nodes + 1, len_nodes + 1))
-
- # check which nodes are reachable from the virtual heat slack node
- reachable_nodes = csgraph.breadth_first_order(adj_matrix, len_nodes, False, False)
- # throw out the virtual heat slack node
- reachable_nodes = reachable_nodes[reachable_nodes != len_nodes]
-
- nodes_connected = np.zeros(len(active_node_lookup), dtype=bool)
- nodes_connected[reachable_nodes] = True
+ nodes_connected = get_connected_nodes(node_pit, slack_nodes,
+ active_from_nodes, active_to_nodes, active_node_lookup,
+ active_branch_lookup)
if not np.all(nodes_connected[active_from_nodes] == nodes_connected[active_to_nodes]):
raise ValueError(
- "An error occured in the %s connectivity check. Please contact the pandapipes "
- "development team!" % mode)
+ "An error occured in the %s connectivity check. Please contact the pandapipes development" \
+ " team!" % mode)
branches_connected = active_branch_lookup & nodes_connected[from_nodes]
+ node_elements_connected = active_node_element_lookup & nodes_connected[node_element_nodes]
+ if mode == 'hydraulics':
+ is_relevant = node_element_pit[:, net._idx_node_element['NODE_ELEMENT_TYPE']] != 2
+ node_elements_connected = node_elements_connected & is_relevant
oos_nodes = np.where(~nodes_connected & active_node_lookup)[0]
is_nodes = np.where(nodes_connected & ~active_node_lookup)[0]
@@ -543,7 +566,7 @@ def perform_connectivity_search(net, node_pit, slack_nodes, from_nodes, to_nodes
" check as they are connected to in_service branches:\n%s"
% (mode, node_type_message))
- return nodes_connected, branches_connected
+ return nodes_connected, branches_connected, node_elements_connected
def get_table_index_list(net, pit_array, pit_indices, pit_type="node"):
@@ -562,14 +585,15 @@ def get_table_index_list(net, pit_array, pit_indices, pit_type="node"):
:return: List of table names and table indices belonging to the pit indices
"""
int_pit = pit_array[pit_indices, :]
- tables = np.unique(int_pit[:, TABLE_IDX_ND])
+ tables = np.unique(int_pit[:, net['_idx_node']['TABLE_IDX']])
table_lookup = get_lookup(net, pit_type, "table")
- return [(get_table_name(table_lookup, tbl), list(int_pit[int_pit[:, TABLE_IDX_ND] == tbl,
- ELEMENT_IDX_ND].astype(np.int32)))
+ return [(get_table_name(table_lookup, tbl), list(int_pit[int_pit[:, net['_idx_node']['TABLE_IDX']] == tbl,
+ net['_idx_node']['ELEMENT_IDX']].astype(np.int32)))
for tbl in tables]
-def reduce_pit(net, node_pit, branch_pit, nodes_connected, branches_connected):
+def reduce_pit(net, node_pit, branch_pit, node_element_pit, nodes_connected, branches_connected,
+ node_elements_connected):
"""
Create an internal ("active") pit with all nodes and branches that are actually in_service. This
is also done for different lookups (e.g. the from_to indices for this pit and the node index
@@ -621,14 +645,33 @@ def reduce_pit(net, node_pit, branch_pit, nodes_connected, branches_connected):
else:
net["_lookups"]["branch_index_active"] = dict()
els["branch"] = branches_connected
+ if np.alltrue(node_elements_connected):
+ net["_lookups"]["node_element_from_to_active"] = copy.deepcopy(get_lookup(net, "node_element",
+ "from_to"))
+ active_pit["node_element"] = np.copy(node_element_pit)
+ net["_lookups"]["node_element_index_active"] = copy.deepcopy(get_lookup(net, "node_element", "index"))
+ else:
+ active_pit["node_element"] = np.copy(node_element_pit[node_elements_connected, :])
+ node_element_idx_lookup = get_lookup(net, "node_element", "index")
+ if len(node_element_idx_lookup):
+ reduced_branch_lookup = np.cumsum(node_elements_connected) - 1
+ net["_lookups"]["node_element_index_active"] = {
+ tbl: reduced_branch_lookup[idx_lookup[idx_lookup != -1]]
+ for tbl, idx_lookup in node_element_idx_lookup.items()}
+ else:
+ net["_lookups"]["node_element_index_active"] = dict()
+ els["node_element"] = node_elements_connected
if reduced_node_lookup is not None:
- active_pit["branch"][:, FROM_NODE] = reduced_node_lookup[
- branch_pit[branches_connected, FROM_NODE].astype(np.int32)]
- active_pit["branch"][:, TO_NODE] = reduced_node_lookup[
- branch_pit[branches_connected, TO_NODE].astype(np.int32)]
+ active_pit["branch"][:, net['_idx_branch']['FROM_NODE']] = reduced_node_lookup[
+ branch_pit[branches_connected, net['_idx_branch']['FROM_NODE']].astype(np.int32)]
+ active_pit["branch"][:, net['_idx_branch']['TO_NODE']] = reduced_node_lookup[
+ branch_pit[branches_connected, net['_idx_branch']['TO_NODE']].astype(np.int32)]
+ active_pit["node_element"][:, net['_idx_node_element']['JUNCTION']] = reduced_node_lookup[
+ node_element_pit[node_elements_connected, net['_idx_node_element']['JUNCTION']].astype(np.int32)]
net["_active_pit"] = active_pit
net["_lookups"]["node_active"] = nodes_connected
net["_lookups"]["branch_active"] = branches_connected
+ net["_lookups"]["node_element_active"] = node_elements_connected
for el, connected_els in els.items():
ft_lookup = get_lookup(net, el, "from_to")
@@ -640,3 +683,55 @@ def reduce_pit(net, node_pit, branch_pit, nodes_connected, branches_connected):
from_to_active_lookup[table] = (count, count + len_new)
count += len_new
net["_lookups"]["%s_from_to_active" % el] = from_to_active_lookup
+
+
+def get_connected_nodes(node_pit, slack_nodes,
+ active_from_nodes, active_to_nodes, active_node_lookup, active_branch_lookup):
+ len_nodes = len(node_pit)
+ nobranch = np.sum(active_branch_lookup)
+
+ # we create a "virtual" node that is connected to all slack nodes and start the connectivity
+ # search at this node
+
+ fn_matrix = np.concatenate([active_from_nodes, slack_nodes])
+ tn_matrix = np.concatenate([active_to_nodes,
+ np.full(len(slack_nodes), len_nodes, dtype=np.int32)])
+ adj_matrix = coo_matrix((np.ones(nobranch + len(slack_nodes)), (fn_matrix, tn_matrix)),
+ shape=(len_nodes + 1, len_nodes + 1))
+
+ # check which nodes are reachable from the virtual heat slack node
+ reachable_nodes = csgraph.breadth_first_order(adj_matrix, len_nodes, False, False)
+ # throw out the virtual heat slack node
+ reachable_nodes = reachable_nodes[reachable_nodes != len_nodes]
+
+ nodes_connected = np.zeros(len(active_node_lookup), dtype=bool)
+ nodes_connected[reachable_nodes] = True
+ return nodes_connected
+
+
+def assign_to_slack(net, node_pit, branch_pit):
+ active_branch_lookup = branch_pit[:, net['_idx_branch']['ACTIVE']].astype(bool)
+ active_node_lookup = node_pit[:, net['_idx_node']['ACTIVE']].astype(bool)
+ from_nodes = branch_pit[:, net['_idx_branch']['FROM_NODE']].astype(np.int32)
+ to_nodes = branch_pit[:, net['_idx_branch']['TO_NODE']].astype(np.int32)
+ hyd_slacks = np.where(((node_pit[:, net['_idx_node']['NODE_TYPE']] == net['_idx_node']['P']) | (
+ node_pit[:, net['_idx_node']['NODE_TYPE']] == net['_idx_node']['PC']))
+ & active_node_lookup)[0]
+ for slack in hyd_slacks:
+ nodes_connected = get_connected_nodes(node_pit, [slack], from_nodes, to_nodes, active_node_lookup,
+ active_branch_lookup)
+ node_pit[nodes_connected, net['_idx_node']['SLACK']] = slack
+
+
+def init_idx(net):
+ idx_node(net)
+ idx_branch(net)
+ idx_node_element(net)
+
+
+def init_fluid(net):
+ fluids = []
+ for comp in net.node_element_list:
+ fluids += [net[comp.table_name()].fluid.values if 'fluid' in net[comp.table_name()] else []]
+ fluids = np.concatenate(fluids)
+ net['_fluid'] = np.unique(fluids)
\ No newline at end of file
diff --git a/pandapipes/pf/result_extraction.py b/pandapipes/pf/result_extraction.py
index c453c9f5..18b617f2 100644
--- a/pandapipes/pf/result_extraction.py
+++ b/pandapipes/pf/result_extraction.py
@@ -1,12 +1,9 @@
import numpy as np
from pandapipes.constants import NORMAL_PRESSURE, NORMAL_TEMPERATURE
-from pandapipes.idx_branch import ELEMENT_IDX, FROM_NODE, TO_NODE, LOAD_VEC_NODES, VINIT, RE, \
- LAMBDA, TINIT, FROM_NODE_T, TO_NODE_T, PL
-from pandapipes.idx_node import TABLE_IDX as TABLE_IDX_NODE, PINIT, PAMB, TINIT as TINIT_NODE
from pandapipes.pf.internals_toolbox import _sum_by_group
from pandapipes.pf.pipeflow_setup import get_table_number, get_lookup, get_net_option
-from pandapipes.properties.fluids import get_fluid
+from pandapipes.properties.fluids import get_fluid, get_mixture_density, is_fluid_gas, get_mixture_compressibility
try:
from numba import jit
@@ -32,15 +29,15 @@ def extract_all_results(net, nodes_connected, branches_connected):
"p_to": p_to, "from_nodes": from_nodes, "to_nodes": to_nodes,
"temp_from": temp_from, "temp_to": temp_to, "reynolds": reynolds,
"lambda": _lambda, "pl": pl}
- if get_fluid(net).is_gas:
+ if is_fluid_gas(net):
if get_net_option(net, "use_numba"):
v_gas_from, v_gas_to, v_gas_mean, p_abs_from, p_abs_to, p_abs_mean, normfactor_from, \
- normfactor_to, normfactor_mean = get_branch_results_gas_numba(
- net, branch_pit, node_pit, from_nodes, to_nodes, v_mps, p_from, p_to)
+ normfactor_to, normfactor_mean = get_branch_results_gas_numba(
+ net, branch_pit, node_pit, from_nodes, to_nodes, v_mps, p_from, p_to)
else:
v_gas_from, v_gas_to, v_gas_mean, p_abs_from, p_abs_to, p_abs_mean, normfactor_from, \
- normfactor_to, normfactor_mean = get_branch_results_gas(
- net, branch_pit, node_pit, from_nodes, to_nodes, v_mps, p_from, p_to)
+ normfactor_to, normfactor_mean = get_branch_results_gas(
+ net, branch_pit, node_pit, from_nodes, to_nodes, v_mps, p_from, p_to)
gas_branch_results = {
"v_gas_from": v_gas_from, "v_gas_to": v_gas_to, "v_gas_mean": v_gas_mean,
"p_from": p_from, "p_to": p_to, "p_abs_from": p_abs_from, "p_abs_to": p_abs_to,
@@ -48,72 +45,93 @@ def extract_all_results(net, nodes_connected, branches_connected):
"normfactor_to": normfactor_to, "normfactor_mean": normfactor_mean
}
branch_results.update(gas_branch_results)
- for comp in net['component_list']:
+ for comp in np.concatenate([net['node_element_list'], net['node_list'], net['branch_list']]):
comp.extract_results(net, net["_options"], branch_results, nodes_connected,
branches_connected)
def get_basic_branch_results(net, branch_pit, node_pit):
- from_nodes = branch_pit[:, FROM_NODE].astype(np.int32)
- to_nodes = branch_pit[:, TO_NODE].astype(np.int32)
-
- t0 = node_pit[from_nodes, TINIT_NODE]
- t1 = node_pit[to_nodes, TINIT_NODE]
- mf = branch_pit[:, LOAD_VEC_NODES]
- vf = mf / get_fluid(net).get_density((t0 + t1) / 2)
- return branch_pit[:, VINIT], mf, vf, from_nodes, to_nodes, t0, t1, branch_pit[:, RE], \
- branch_pit[:, LAMBDA], node_pit[from_nodes, PINIT], node_pit[to_nodes, PINIT], \
- branch_pit[:, PL]
+ from_nodes = branch_pit[:, net['_idx_branch']['FROM_NODE']].astype(np.int32)
+ to_nodes = branch_pit[:, net['_idx_branch']['TO_NODE']].astype(np.int32)
+
+ t0 = node_pit[from_nodes, net['_idx_node']['TINIT']]
+ t1 = node_pit[to_nodes, net['_idx_node']['TINIT']]
+ mf = branch_pit[:, net['_idx_branch']['LOAD_VEC_NODES']]
+ if len(net._fluid) == 1:
+ density = get_fluid(net, net._fluid[0]).get_density((t0 + t1) / 2)
+ else:
+ w = get_lookup(net, 'branch', 'w')
+ mass_fract = branch_pit[:, w]
+ density = get_mixture_density(net, (t0 + t1) / 2, mass_fraction=mass_fract)
+ vf = mf / density
+ return branch_pit[:, net['_idx_branch']['VINIT']], mf, vf, from_nodes, to_nodes, t0, t1, \
+ branch_pit[:, net['_idx_branch']['RE']], \
+ branch_pit[:, net['_idx_branch']['LAMBDA']], \
+ node_pit[from_nodes, net['_idx_node']['PINIT']], \
+ node_pit[to_nodes, net['_idx_node']['PINIT']], \
+ branch_pit[:, net['_idx_branch']['PL']]
def get_branch_results_gas(net, branch_pit, node_pit, from_nodes, to_nodes, v_mps, p_from, p_to):
- p_abs_from = node_pit[from_nodes, PAMB] + p_from
- p_abs_to = node_pit[to_nodes, PAMB] + p_to
+ p_abs_from = node_pit[from_nodes, net['_idx_node']['PAMB']] + p_from
+ p_abs_to = node_pit[to_nodes, net['_idx_node']['PAMB']] + p_to
mask = ~np.isclose(p_abs_from, p_abs_to)
p_abs_mean = np.empty_like(p_abs_to)
p_abs_mean[~mask] = p_abs_from[~mask]
p_abs_mean[mask] = 2 / 3 * (p_abs_from[mask] ** 3 - p_abs_to[mask] ** 3) \
- / (p_abs_from[mask] ** 2 - p_abs_to[mask] ** 2)
-
- fluid = get_fluid(net)
- numerator = NORMAL_PRESSURE * branch_pit[:, TINIT] / NORMAL_TEMPERATURE
- normfactor_from = numerator * fluid.get_property("compressibility", p_abs_from) / p_abs_from
- normfactor_to = numerator * fluid.get_property("compressibility", p_abs_to) / p_abs_to
- normfactor_mean = numerator * fluid.get_property("compressibility", p_abs_mean) / p_abs_mean
+ / (p_abs_from[mask] ** 2 - p_abs_to[mask] ** 2)
+ numerator = NORMAL_PRESSURE * branch_pit[:, net['_idx_branch']['TINIT']] / NORMAL_TEMPERATURE
+ if len(net._fluid) == 1:
+ normfactor_from = numerator * get_fluid(net, net._fluid[0]).get_property("compressibility", p_abs_from) / p_abs_from
+ normfactor_to = numerator * get_fluid(net, net._fluid[0]).get_property("compressibility", p_abs_to) / p_abs_to
+ normfactor_mean = numerator * get_fluid(net, net._fluid[0]).get_property("compressibility", p_abs_mean) / p_abs_mean
+ else:
+ w = get_lookup(net, 'branch', 'w')
+ mass_fract = branch_pit[:, w]
+ normfactor_from = numerator * get_mixture_compressibility(net, p_abs_from, mass_fract) / p_abs_from
+ normfactor_to = numerator * get_mixture_compressibility(net, p_abs_to, mass_fract) / p_abs_to
+ normfactor_mean = numerator * get_mixture_compressibility(net, p_abs_mean, mass_fract) / p_abs_mean
v_gas_from = v_mps * normfactor_from
v_gas_to = v_mps * normfactor_to
v_gas_mean = v_mps * normfactor_mean
- return v_gas_from, v_gas_to, v_gas_mean, p_abs_from, p_abs_to, p_abs_mean, normfactor_from,\
- normfactor_to, normfactor_mean
+ return v_gas_from, v_gas_to, v_gas_mean, p_abs_from, p_abs_to, p_abs_mean, normfactor_from, \
+ normfactor_to, normfactor_mean
def get_branch_results_gas_numba(net, branch_pit, node_pit, from_nodes, to_nodes, v_mps, p_from,
p_to):
- p_abs_from, p_abs_to, p_abs_mean = get_pressures_numba(node_pit, from_nodes, to_nodes, v_mps,
- p_from, p_to)
+ pit_cols = [net['_idx_branch']['TINIT'], net['_idx_node']['PAMB']]
- fluid = get_fluid(net)
- comp_from = fluid.get_property("compressibility", p_abs_from)
- comp_to = fluid.get_property("compressibility", p_abs_to)
- comp_mean = fluid.get_property("compressibility", p_abs_mean)
+ p_abs_from, p_abs_to, p_abs_mean = get_pressures_numba(pit_cols[1], node_pit, from_nodes, to_nodes, v_mps,
+ p_from, p_to)
+ if len(net._fluid) == 1:
+ comp_from = get_fluid(net, net._fluid[0]).get_property("compressibility", p_abs_from)
+ comp_to = get_fluid(net, net._fluid[0]).get_property("compressibility", p_abs_to)
+ comp_mean = get_fluid(net, net._fluid[0]).get_property("compressibility", p_abs_mean)
+ else:
+ w = get_lookup(net, 'branch', 'w')
+ mass_fract = branch_pit[:, w]
+ comp_from = get_mixture_compressibility(net, p_abs_from, mass_fract)
+ comp_to = get_mixture_compressibility(net, p_abs_to, mass_fract)
+ comp_mean = get_mixture_compressibility(net, p_abs_mean, mass_fract)
v_gas_from, v_gas_to, v_gas_mean, normfactor_from, normfactor_to, normfactor_mean = \
- get_gas_vel_numba(branch_pit, comp_from, comp_to, comp_mean, p_abs_from, p_abs_to,
+ get_gas_vel_numba(pit_cols[0], branch_pit, comp_from, comp_to, comp_mean, p_abs_from, p_abs_to,
p_abs_mean, v_mps)
return v_gas_from, v_gas_to, v_gas_mean, p_abs_from, p_abs_to, p_abs_mean, normfactor_from, \
- normfactor_to, normfactor_mean
+ normfactor_to, normfactor_mean
@jit(nopython=True)
-def get_pressures_numba(node_pit, from_nodes, to_nodes, v_mps, p_from, p_to):
+def get_pressures_numba(pit_cols, node_pit, from_nodes, to_nodes, v_mps, p_from, p_to):
p_abs_from, p_abs_to, p_abs_mean = [np.empty_like(v_mps) for _ in range(3)]
for i in range(len(v_mps)):
- p_abs_from[i] = node_pit[from_nodes[i], PAMB] + p_from[i]
- p_abs_to[i] = node_pit[to_nodes[i], PAMB] + p_to[i]
+ p_abs_from[i] = node_pit[from_nodes[i], pit_cols] + p_from[i]
+ p_abs_to[i] = node_pit[to_nodes[i], pit_cols] + p_to[i]
if np.less_equal(np.abs(p_abs_from[i] - p_abs_to[i]), 1e-8 + 1e-5 * abs(p_abs_to[i])):
p_abs_mean[i] = p_abs_from[i]
else:
@@ -124,13 +142,13 @@ def get_pressures_numba(node_pit, from_nodes, to_nodes, v_mps, p_from, p_to):
@jit(nopython=True)
-def get_gas_vel_numba(branch_pit, comp_from, comp_to, comp_mean, p_abs_from, p_abs_to, p_abs_mean,
+def get_gas_vel_numba(pit_cols, branch_pit, comp_from, comp_to, comp_mean, p_abs_from, p_abs_to, p_abs_mean,
v_mps):
v_gas_from, v_gas_to, v_gas_mean, normfactor_from, normfactor_to, normfactor_mean = \
[np.empty_like(v_mps) for _ in range(6)]
for i in range(len(v_mps)):
- numerator = np.divide(NORMAL_PRESSURE * branch_pit[i, TINIT], NORMAL_TEMPERATURE)
+ numerator = np.divide(NORMAL_PRESSURE * branch_pit[i, pit_cols], NORMAL_TEMPERATURE)
normfactor_from[i] = np.divide(numerator * comp_from[i], p_abs_from[i])
normfactor_to[i] = np.divide(numerator * comp_to[i], p_abs_to[i])
normfactor_mean[i] = np.divide(numerator * comp_mean[i], p_abs_mean[i])
@@ -154,7 +172,7 @@ def extract_branch_results_with_internals(net, branch_results, table_name, res_n
# since the function _sum_by_group sorts the entries by an index (in this case the index of the
# respective table), the placement of the indices mus be known to allocate the values correctly
placement_table = np.argsort(net[table_name].index.values)
- idx_pit = branch_pit[f:t, ELEMENT_IDX]
+ idx_pit = branch_pit[f:t, net['_idx_branch']['ELEMENT_IDX']]
comp_connected = branches_connected[f:t]
node_pit = net["_pit"]["node"]
@@ -167,7 +185,7 @@ def extract_branch_results_with_internals(net, branch_results, table_name, res_n
# from_node that is the exterior node (e.g. junction vs. internal pipe_node) result has to
# be extracted from the node_pit
from_nodes = branch_results["from_nodes"][f:t]
- from_nodes_external = node_pit[from_nodes, TABLE_IDX_NODE] == ext_node_tbl_idx
+ from_nodes_external = node_pit[from_nodes, net['_idx_node']['TABLE_IDX']] == ext_node_tbl_idx
considered = from_nodes_external & comp_connected
external_active = comp_connected[from_nodes_external]
for res_name, entry in res_nodes_from:
@@ -178,7 +196,7 @@ def extract_branch_results_with_internals(net, branch_results, table_name, res_n
# to_node that is the exterior node (e.g. junction vs. internal pipe_node) result has to
# be extracted from the node_pit
to_nodes = branch_results["to_nodes"][f:t]
- to_nodes_external = node_pit[to_nodes, TABLE_IDX_NODE] == ext_node_tbl_idx
+ to_nodes_external = node_pit[to_nodes, net['_idx_node']['TABLE_IDX']] == ext_node_tbl_idx
considered = to_nodes_external & comp_connected
external_active = comp_connected[to_nodes_external]
for res_name, entry in res_nodes_to:
@@ -232,16 +250,19 @@ def extract_results_active_pit(net, node_pit, branch_pit, nodes_connected, branc
"""
all_nodes_connected = np.alltrue(nodes_connected)
if not all_nodes_connected:
- node_pit[~nodes_connected, PINIT] = np.NaN
+ node_pit[~nodes_connected, net['_idx_node']['PINIT']] = np.NaN
node_pit[nodes_connected, :] = net["_active_pit"]["node"]
cols_br = np.array([i for i in range(branch_pit.shape[1])
- if i not in [FROM_NODE, TO_NODE, FROM_NODE_T, TO_NODE_T]])
+ if i not in [net['_idx_branch']['FROM_NODE'],
+ net['_idx_branch']['TO_NODE'],
+ net['_idx_branch']['FROM_NODE_T'],
+ net['_idx_branch']['TO_NODE_T']]])
else:
net["_pit"]["node"] = np.copy(net["_active_pit"]["node"])
cols_br = None
if not np.alltrue(branches_connected):
- branch_pit[~branches_connected, VINIT] = np.NaN
+ branch_pit[~branches_connected, net['_idx_branch']['VINIT']] = np.NaN
rows_active_br = np.where(branches_connected)[0]
if all_nodes_connected:
branch_pit[rows_active_br, :] = net["_active_pit"]["branch"][:, :]
diff --git a/pandapipes/pipeflow.py b/pandapipes/pipeflow.py
index fb63a125..2a816d50 100644
--- a/pandapipes/pipeflow.py
+++ b/pandapipes/pipeflow.py
@@ -7,19 +7,19 @@
from pandapower.auxiliary import ppException
from scipy.sparse.linalg import spsolve
-from pandapipes.idx_branch import ACTIVE as ACTIVE_BR, FROM_NODE, TO_NODE, FROM_NODE_T, \
- TO_NODE_T, VINIT, T_OUT, VINIT_T
-from pandapipes.idx_node import PINIT, TINIT, ACTIVE as ACTIVE_ND
+from pandapipes.component_models import Junction
from pandapipes.pf.build_system_matrix import build_system_matrix
from pandapipes.pf.derivative_calculation import calculate_derivatives_hydraulic
from pandapipes.pf.pipeflow_setup import get_net_option, get_net_options, set_net_option, \
- init_options, create_internal_results, write_internal_results, get_lookup, create_lookups, \
- initialize_pit, check_connectivity, reduce_pit, \
- set_user_pf_options, init_all_result_tables
+ init_options, create_internal_results, write_internal_results, \
+ get_lookup, create_lookups, initialize_pit, check_connectivity, reduce_pit, \
+ init_all_result_tables, set_user_pf_options, init_idx
+from pandapipes.pf.pipeflow_setup import init_fluid
+from pandapipes.properties.fluids import is_fluid_gas
from pandapipes.pf.result_extraction import extract_all_results, extract_results_active_pit
try:
- import pplog as logging
+ import pandaplan.core.pplog as logging
except ImportError:
import logging
@@ -57,43 +57,54 @@ def pipeflow(net, sol_vec=None, **kwargs):
>>> pipeflow(net, mode="hydraulics")
"""
+
local_params = dict(locals())
# Inputs & initialization of variables
# ------------------------------------------------------------------------------------------
-
# Init physical constants and options
init_options(net, local_params)
+ init_fluid(net)
+
+ init_idx(net)
+
# init result tables
net["converged"] = False
+ net["OPF_converged"] = False
+
init_all_result_tables(net)
create_lookups(net)
- node_pit, branch_pit = initialize_pit(net)
+
+ node_pit, branch_pit, node_element_pit = initialize_pit(net)
+
if (len(node_pit) == 0) & (len(branch_pit) == 0):
logger.warning("There are no node and branch entries defined. This might mean that your net"
" is empty")
return
+
calculation_mode = get_net_option(net, "mode")
calculate_hydraulics = calculation_mode in ["hydraulics", "all"]
calculate_heat = calculation_mode in ["heat", "all"]
if get_net_option(net, "check_connectivity"):
- nodes_connected, branches_connected = check_connectivity(
- net, branch_pit, node_pit, check_heat=calculate_heat)
+ nodes_connected, branches_connected, node_elements_connected = check_connectivity(
+ net, branch_pit, node_pit, node_element_pit, check_heat=calculate_heat)
else:
- nodes_connected = node_pit[:, ACTIVE_ND].astype(np.bool)
- branches_connected = branch_pit[:, ACTIVE_BR].astype(np.bool)
+ nodes_connected = node_pit[:, net['_idx_node']['ACTIVE']].astype(bool)
+ branches_connected = branch_pit[:, net['_idx_branch']['ACTIVE']].astype(bool)
+ node_elements_connected = node_element_pit[:, net['_idx_node_element']['ACTIVE']].astype(bool)
- reduce_pit(net, node_pit, branch_pit, nodes_connected, branches_connected)
+ reduce_pit(net, node_pit, branch_pit, node_element_pit,
+ nodes_connected, branches_connected, node_elements_connected)
if calculation_mode == "heat" and not net.user_pf_options["hyd_flag"]:
raise UserWarning("Converged flag not set. Make sure that hydraulic calculation results "
"are available.")
elif calculation_mode == "heat" and net.user_pf_options["hyd_flag"]:
- net["_active_pit"]["node"][:, PINIT] = sol_vec[:len(node_pit)]
- net["_active_pit"]["branch"][:, VINIT] = sol_vec[len(node_pit):]
+ net["_active_pit"]["node"][:, net['_idx_node']['PINIT']] = sol_vec[:len(node_pit)]
+ net["_active_pit"]["branch"][:, net['_idx_branch']['VINIT']] = sol_vec[len(node_pit):]
if calculate_hydraulics:
converged, _ = hydraulics(net)
@@ -113,8 +124,8 @@ def pipeflow(net, sol_vec=None, **kwargs):
def hydraulics(net):
- max_iter, nonlinear_method, tol_p, tol_v, tol_res = get_net_options(
- net, "iter", "nonlinear_method", "tol_p", "tol_v", "tol_res")
+ max_iter, nonlinear_method, tol_p, tol_v, tol_m, tol_w, tol_res = get_net_options(
+ net, "iter", "nonlinear_method", "tol_p", "tol_v", "tol_m", "tol_w", "tol_res")
# Start of nonlinear loop
# ---------------------------------------------------------------------------------------------
@@ -124,28 +135,50 @@ def hydraulics(net):
net["_internal_data"] = dict()
# This branch is used to stop the solver after a specified error tolerance is reached
- error_v, error_p, residual_norm = [], [], None
+ error_v, error_p, error_m, error_w, residual_norm = [], [], [], [], None
# This loop is left as soon as the solver converged
while not get_net_option(net, "converged") and niter <= max_iter:
logger.debug("niter %d" % niter)
# solve_hydraulics is where the calculation takes place
- v_init, p_init, v_init_old, p_init_old, epsilon = solve_hydraulics(net)
-
- # Error estimation & convergence plot
- dv_init = np.abs(v_init - v_init_old)
- dp_init = np.abs(p_init - p_init_old)
+ if niter == 0:
+ first_iter = True
+ len_fluid = 0
+ else:
+ first_iter = False
+ len_fluid = len(net._fluid) - 1
- residual_norm = linalg.norm(epsilon) / len(epsilon)
- error_v.append(linalg.norm(dv_init) / len(dv_init) if len(dv_init) else 0)
- error_p.append(linalg.norm(dp_init / len(dp_init)))
+ results, epsilon = solve_hydraulics(net, first_iter)
- finalize_iteration(net, niter, error_p, error_v, residual_norm, nonlinear_method, tol_p,
- tol_v, tol_res, p_init_old, v_init_old)
+ # Error estimation & convergence plot
+ dv_init = np.abs(results[2 + len_fluid + 1] - results[0])
+ dp_init = np.abs(results[3 + len_fluid + 1] - results[1])
+ dm_init = np.abs(results[4 + len_fluid + 1] - results[2])
+ if len_fluid:
+ w_list = [res[1] - res[0] for res in zip(results[3:2 + len_fluid + 1], results[4 + len_fluid + 2:])]
+ w_error = [linalg.norm(w) / (len(w)) if len(w) else 0 for w in w_list]
+ w_error = max(w_error)
+ residual_norm = (linalg.norm(epsilon) / (len(epsilon)))
+ error_v.append(linalg.norm(dv_init) / (len(dv_init)) if len(dv_init) else 0)
+ error_p.append(linalg.norm(dp_init / (len(dp_init))))
+ error_m.append(linalg.norm(dm_init) / (len(dm_init)) if len(dm_init) else 0)
+ if len_fluid:
+ error_w.append(w_error)
+ else:
+ error_w.append(0)
+
+ #ToDo: Maybe integration of m and w necessary
+ finalize_iteration(net, niter, ['p', 'v'], [error_p, error_v],
+ [net['_idx_node']['PINIT'], net['_idx_branch']['VINIT']],
+ ['node', 'branch'],
+ residual_norm, nonlinear_method,
+ [tol_p, tol_v],
+ tol_res, [results[1], results[0]])
niter += 1
write_internal_results(net, iterations=niter, error_p=error_p[niter - 1],
- error_v=error_v[niter - 1], residual_norm=residual_norm)
+ error_v=error_v[niter - 1], error_m=error_m[niter - 1], error_w=error_w[niter - 1],
+ residual_norm=residual_norm)
converged = get_net_option(net, "converged")
net['converged'] = converged
@@ -166,7 +199,7 @@ def heat_transfer(net):
# Start of nonlinear loop
# ---------------------------------------------------------------------------------------------
- if net.fluid.is_gas:
+ if is_fluid_gas(net):
logger.info("Caution! Temperature calculation does currently not affect hydraulic "
"properties!")
@@ -190,8 +223,12 @@ def heat_transfer(net):
error_t.append(linalg.norm(delta_t_init) / (len(delta_t_init)))
error_t_out.append(linalg.norm(delta_t_out) / (len(delta_t_out)))
- finalize_iteration(net, niter, error_t, error_t_out, residual_norm, nonlinear_method, tol_t,
- tol_t, tol_res, t_init_old, t_out_old, hyraulic_mode=True)
+ finalize_iteration(net, niter, ['t', 't_out'], [error_t, error_t_out],
+ [net['_idx_node']['TINIT'], net['_idx_branch']['T_OUT']],
+ ['node', 'branch'],
+ residual_norm, nonlinear_method,
+ [tol_t, tol_t],
+ tol_res, [t_init_old, t_out_old])
logger.debug("F: %s" % epsilon.round(4))
logger.debug("T_init_: %s" % t_init.round(4))
logger.debug("T_out_: %s" % t_out.round(4))
@@ -207,7 +244,7 @@ def heat_transfer(net):
return converged, niter
-def solve_hydraulics(net):
+def solve_hydraulics(net, first_iter):
"""
Create and solve the linearized system of equations (based on a jacobian in form of a scipy
sparse matrix and a load vector in form of a numpy array) in order to calculate the hydraulic
@@ -221,25 +258,51 @@ def solve_hydraulics(net):
options = net["_options"]
branch_pit = net["_active_pit"]["branch"]
node_pit = net["_active_pit"]["node"]
-
- branch_lookups = get_lookup(net, "branch", "from_to_active")
- for comp in net['component_list']:
- comp.adaption_before_derivatives_hydraulic(
- net, branch_pit, node_pit, branch_lookups, options)
+ node_element_pit = net['_active_pit']['node_element']
+
+ branch_lookups = get_lookup(net, "branch", "from_to_active")#
+ node_lookups = get_lookup(net, "node", "from_to_active")
+ ne_mask = node_element_pit[:, net._idx_node_element['NODE_ELEMENT_TYPE']].astype(bool)
+ comp_list = np.concatenate([net['node_element_list'], net['node_list'], net['branch_list']])
+ for comp in comp_list:
+ comp.adaption_before_derivatives_hydraulic(net, branch_pit, node_pit, branch_lookups, node_lookups, options)
calculate_derivatives_hydraulic(net, branch_pit, node_pit, options)
- for comp in net['component_list']:
+ for comp in comp_list :
comp.adaption_after_derivatives_hydraulic(
- net, branch_pit, node_pit, branch_lookups, options)
- jacobian, epsilon = build_system_matrix(net, branch_pit, node_pit, False)
+ net, branch_pit, node_pit, branch_lookups, node_lookups, options)
+ jacobian, epsilon = build_system_matrix(net, branch_pit, node_pit, node_element_pit, False, first_iter)
- v_init_old = branch_pit[:, VINIT].copy()
- p_init_old = node_pit[:, PINIT].copy()
+ if first_iter:
+ len_fl = 0
+ else:
+ len_fl = len(net._fluid) - 1
+ results = []
+ results += [branch_pit[:, net['_idx_branch']['VINIT']].copy()]
+ results += [node_pit[:, net['_idx_node']['PINIT']].copy()]
+ results += [node_element_pit[ne_mask, net['_idx_node_element']['MINIT']].copy()]
+ if len_fl:
+ w_node = get_lookup(net, 'node', 'w')
+ for no in node_pit[:, w_node[:-1]].T.copy():
+ results += [no]
x = spsolve(jacobian, epsilon)
- branch_pit[:, VINIT] += x[len(node_pit):]
- node_pit[:, PINIT] += x[:len(node_pit)] * options["alpha"]
+ branch_pit[:, net['_idx_branch']['VINIT']] += x[len(node_pit):len(branch_pit) + len(node_pit)]
+ node_pit[:, net['_idx_node']['PINIT']] += x[:len(node_pit)] * options["alpha"]
+ ne_len = len(branch_pit) + len(node_pit) + len(node_element_pit[ne_mask])
+ node_element_pit[ne_mask, net['_idx_node_element']['MINIT']] += \
+ x[len(branch_pit) + len(node_pit): ne_len]
+ if len_fl:
+ node_pit[:, w_node[:-1]] += x[ne_len:].reshape((len_fl, -1)).T
+ node_pit[:, w_node[-1]] = 1 - node_pit[:, w_node[:-1]].sum(axis=1)
+
+ results += [branch_pit[:, net['_idx_branch']['VINIT']].copy()]
+ results += [node_pit[:, net['_idx_node']['PINIT']].copy()]
+ results += [node_element_pit[ne_mask, net['_idx_node_element']['MINIT']].copy()]
+ if len_fl:
+ for no in node_pit[:, w_node[:-1]].T.copy():
+ results += [no]
- return branch_pit[:, VINIT], node_pit[:, PINIT], v_init_old, p_init_old, epsilon
+ return results, epsilon
def solve_temperature(net):
@@ -258,30 +321,32 @@ def solve_temperature(net):
options = net["_options"]
branch_pit = net["_active_pit"]["branch"]
node_pit = net["_active_pit"]["node"]
+ node_element_pit = net['_active_pit']['node_element']
branch_lookups = get_lookup(net, "branch", "from_to_active")
# Negative velocity values are turned to positive ones (including exchange of from_node and
# to_node for temperature calculation
- branch_pit[:, VINIT_T] = branch_pit[:, VINIT]
- branch_pit[:, FROM_NODE_T] = branch_pit[:, FROM_NODE]
- branch_pit[:, TO_NODE_T] = branch_pit[:, TO_NODE]
- mask = branch_pit[:, VINIT] < 0
- branch_pit[mask, VINIT_T] = -branch_pit[mask, VINIT]
- branch_pit[mask, FROM_NODE_T] = branch_pit[mask, TO_NODE]
- branch_pit[mask, TO_NODE_T] = branch_pit[mask, FROM_NODE]
-
- for comp in net['component_list']:
+ branch_pit[:, net['_idx_branch']['VINIT_T']] = branch_pit[:, net['_idx_branch']['VINIT']]
+ branch_pit[:, net['_idx_branch']['FROM_NODE_T']] = branch_pit[:, net['_idx_branch']['FROM_NODE']]
+ branch_pit[:, net['_idx_branch']['TO_NODE_T']] = branch_pit[:, net['_idx_branch']['TO_NODE']]
+ mask = branch_pit[:, net['_idx_branch']['VINIT']] < 0
+ branch_pit[mask, net['_idx_branch']['VINIT_T']] = -branch_pit[mask, net['_idx_branch']['VINIT']]
+ branch_pit[mask, net['_idx_branch']['FROM_NODE_T']] = branch_pit[mask, net['_idx_branch']['TO_NODE']]
+ branch_pit[mask, net['_idx_branch']['TO_NODE_T']] = branch_pit[mask, net['_idx_branch']['FROM_NODE']]
+
+ for comp in net['branch_list']:
comp.calculate_derivatives_thermal(net, branch_pit, node_pit, branch_lookups, options)
- jacobian, epsilon = build_system_matrix(net, branch_pit, node_pit, True)
+ jacobian, epsilon = build_system_matrix(net, branch_pit, node_pit, node_element_pit, True, False)
- t_init_old = node_pit[:, TINIT].copy()
- t_out_old = branch_pit[:, T_OUT].copy()
+ t_init_old = node_pit[:, net['_idx_node']['TINIT']].copy()
+ t_out_old = branch_pit[:, net['_idx_branch']['T_OUT']].copy()
x = spsolve(jacobian, epsilon)
- node_pit[:, TINIT] += x[:len(node_pit)] * options["alpha"]
- branch_pit[:, T_OUT] += x[len(node_pit):]
+ node_pit[:, net['_idx_node']['TINIT']] += x[:len(node_pit)] * options["alpha"]
+ branch_pit[:, net['_idx_branch']['T_OUT']] += x[len(node_pit):]
- return branch_pit[:, T_OUT], t_out_old, node_pit[:, TINIT], t_init_old, epsilon
+ return branch_pit[:, net['_idx_branch']['T_OUT']], t_out_old, node_pit[:,
+ net['_idx_node']['TINIT']], t_init_old, epsilon
def set_damping_factor(net, niter, error):
@@ -313,41 +378,35 @@ def set_damping_factor(net, niter, error):
return error_x0_increased, error_x1_increased
-def finalize_iteration(net, niter, error_1, error_2, residual_norm, nonlinear_method, tol_1, tol_2,
- tol_res, vals_1_old, vals_2_old, hyraulic_mode=True):
- col1, col2 = (PINIT, VINIT) if hyraulic_mode else (TINIT, T_OUT)
+def finalize_iteration(net, niter, error_names, specific_errors, pit_columns, pit_type, residual_norm, nonlinear_method,
+ specific_tolerances, tol_res, old_results):
# Control of damping factor
if nonlinear_method == "automatic":
- error_x0_increased, error_x1_increased = set_damping_factor(net, niter,
- [error_1, error_2])
- if error_x0_increased:
- net["_active_pit"]["node"][:, col1] = vals_1_old
- if error_x1_increased:
- net["_active_pit"]["branch"][:, col2] = vals_2_old
+ error_x_increased = set_damping_factor(net, niter, specific_errors)
+ for error, col, pit_t, res in zip(error_x_increased, pit_columns, pit_type, old_results):
+ if error:
+ net["_active_pit"][pit_t][:, col] = res
elif nonlinear_method != "constant":
logger.warning("No proper nonlinear method chosen. Using constant settings.")
# Setting convergence flag
- if error_2[niter] <= tol_2 and error_1[niter] <= tol_1 and residual_norm < tol_res:
+ bool_err = all([error[niter] <= tol for error, tol in zip(specific_errors, specific_tolerances)])
+ if bool_err and residual_norm < tol_res:
if nonlinear_method != "automatic":
set_net_option(net, "converged", True)
elif get_net_option(net, "alpha") == 1:
set_net_option(net, "converged", True)
- if hyraulic_mode:
- logger.debug("errorv: %s" % error_1[niter])
- logger.debug("errorp: %s" % error_2[niter])
- logger.debug("alpha: %s" % get_net_option(net, "alpha"))
- else:
- logger.debug("errorT: %s" % error_1[niter])
- logger.debug("alpha: %s" % get_net_option(net, "alpha"))
+ for name, error in zip(error_names, specific_errors):
+ logger.debug("error_%s: %s" % (name, error[niter]))
+ logger.debug("alpha: %s" % get_net_option(net, "alpha"))
def log_final_results(net, converged, niter, residual_norm, hyraulic_mode=True):
if hyraulic_mode:
solver = "hydraulics"
- outputs = ["tol_p", "tol_v"]
+ outputs = ["tol_p", "tol_v", "tol_m", "tol_w"]
else:
solver = "heat transfer"
outputs = ["tol_T"]
diff --git a/pandapipes/plotting/collections.py b/pandapipes/plotting/collections.py
index 66b130c0..e5ac042e 100644
--- a/pandapipes/plotting/collections.py
+++ b/pandapipes/plotting/collections.py
@@ -13,7 +13,7 @@
from pandapower.plotting.plotting_toolbox import get_index_array
try:
- import pplog as logging
+ from pandaplan.core import ppglog as logging
except ImportError:
import logging
diff --git a/pandapipes/plotting/generic_geodata.py b/pandapipes/plotting/generic_geodata.py
index f0e2565c..713c7997 100644
--- a/pandapipes/plotting/generic_geodata.py
+++ b/pandapipes/plotting/generic_geodata.py
@@ -12,7 +12,7 @@
_prepare_geodata_table, _get_element_mask_from_nodes, _igraph_meshed
try:
- import pplog as logging
+ from pandaplan.core import ppglog as logging
except ImportError:
import logging
@@ -58,15 +58,14 @@ def build_igraph_from_ppipes(net, junctions=None):
pp_junction_mapping[junction.to_junction],
weight=junction.length_km)
- for comp in net['component_list']:
- if comp in [Source, Sink, ExtGrid, Pipe, Junction]:
- continue
- mask = _get_element_mask_from_nodes(
- net, comp.table_name(), ["from_junction", "to_junction"], junctions)
- for comp_data in net[comp.table_name()][mask].itertuples():
- g.add_edge(pp_junction_mapping[comp_data.from_junction],
- pp_junction_mapping[comp_data.to_junction],
- weight=0.001)
+ for comp in np.concatenate([net.branch_list]):
+ if not isinstance(comp, Pipe):
+ mask = _get_element_mask_from_nodes(
+ net, comp.table_name(), ["from_junction", "to_junction"], junctions)
+ for comp_data in net[comp.table_name()][mask].itertuples():
+ g.add_edge(pp_junction_mapping[comp_data.from_junction],
+ pp_junction_mapping[comp_data.to_junction],
+ weight=0.001)
meshed = _igraph_meshed(g)
roots = [pp_junction_mapping[s] for s in net.ext_grid.junction.values if s in junction_index]
diff --git a/pandapipes/plotting/simple_plot.py b/pandapipes/plotting/simple_plot.py
index ed3f4992..e1f67f10 100644
--- a/pandapipes/plotting/simple_plot.py
+++ b/pandapipes/plotting/simple_plot.py
@@ -14,7 +14,7 @@
from itertools import chain
try:
- import pplog as logging
+ from pandaplan.core import ppglog as logging
except ImportError:
import logging
diff --git a/pandapipes/properties/air/higher_heating_value.txt b/pandapipes/properties/air/higher_heating_value.txt
new file mode 100644
index 00000000..d2216854
--- /dev/null
+++ b/pandapipes/properties/air/higher_heating_value.txt
@@ -0,0 +1,2 @@
+# higher heating value in kWh/kg (at nominal conditions)
+0
\ No newline at end of file
diff --git a/pandapipes/properties/air/lower_heating_value.txt b/pandapipes/properties/air/lower_heating_value.txt
new file mode 100644
index 00000000..75f3ef1c
--- /dev/null
+++ b/pandapipes/properties/air/lower_heating_value.txt
@@ -0,0 +1,2 @@
+# lower heating value in kWh/kg (at nominal conditions)
+13.20179
\ No newline at end of file
diff --git a/pandapipes/properties/butane/compressibility.txt b/pandapipes/properties/butane/compressibility.txt
new file mode 100644
index 00000000..bb7662ba
--- /dev/null
+++ b/pandapipes/properties/butane/compressibility.txt
@@ -0,0 +1,2 @@
+# slope in 1/bar, offset for linear property
+-0.0022 1
\ No newline at end of file
diff --git a/pandapipes/properties/butane/density.txt b/pandapipes/properties/butane/density.txt
new file mode 100644
index 00000000..5fbfd88b
--- /dev/null
+++ b/pandapipes/properties/butane/density.txt
@@ -0,0 +1,24 @@
+# NIST Chemistry WebBook, SRD 69
+# https://webbook.nist.gov/cgi/fluid.cgi?P=1&TLow=263.15&THigh=373.15&TInc=2&Applet=on&Digits=5&ID=C106978&Action=Load&Type=IsoBar&TUnit=C&PUnit=bar&DUnit=kg%2Fm3&HUnit=kJ%2Fkg&WUnit=m%2Fs&VisUnit=Pa*s&STUnit=N%2Fm&RefState=DEF
+# Eric W. Lemmon, Mark O. McLinden and Daniel G. Friend, "Thermophysical Properties of Fluid Systems" in NIST Chemistry WebBook, NIST Standard Reference Database Number 69, Eds. P.J. Linstrom and W.G. Mallard, National Institute of Standards and Technology, Gaithersburg MD, 20899, https://doi.org/10.18434/T4D303, (retrieved June 10, 2020)
+# temperature in Kelvin, nominal density in kg/Nm^3 at 1 bar
+263.15 1.3085
+265.15 1.3036
+267.15 1.2987
+269.15 1.2939
+271.15 1.289
+273.15 1.2842
+275.15 1.2795
+277.15 1.2748
+279.15 1.2701
+281.15 1.2655
+283.15 1.2609
+285.15 1.2563
+287.15 1.2517
+289.15 1.2472
+291.15 1.2427
+293.15 1.2383
+295.15 1.2339
+297.15 1.2295
+299.15 1.2252
+301.15 1.2208
diff --git a/pandapipes/properties/butane/der_compressibility.txt b/pandapipes/properties/butane/der_compressibility.txt
new file mode 100644
index 00000000..1d94cc3b
--- /dev/null
+++ b/pandapipes/properties/butane/der_compressibility.txt
@@ -0,0 +1,2 @@
+# derivative (slope) of compressibility
+-0.0022
\ No newline at end of file
diff --git a/pandapipes/properties/butane/heat_capacity.txt b/pandapipes/properties/butane/heat_capacity.txt
new file mode 100644
index 00000000..75b1c5af
--- /dev/null
+++ b/pandapipes/properties/butane/heat_capacity.txt
@@ -0,0 +1,24 @@
+# NIST Chemistry WebBook, SRD 69
+# https://webbook.nist.gov/cgi/fluid.cgi?P=1&TLow=263.15&THigh=373.15&TInc=2&Applet=on&Digits=5&ID=C106978&Action=Load&Type=IsoBar&TUnit=C&PUnit=bar&DUnit=kg%2Fm3&HUnit=kJ%2Fkg&WUnit=m%2Fs&VisUnit=Pa*s&STUnit=N%2Fm&RefState=DEF
+# Eric W. Lemmon, Mark O. McLinden and Daniel G. Friend, "Thermophysical Properties of Fluid Systems" in NIST Chemistry WebBook, NIST Standard Reference Database Number 69, Eds. P.J. Linstrom and W.G. Mallard, National Institute of Standards and Technology, Gaithersburg MD, 20899, https://doi.org/10.18434/T4D303, (retrieved June 10, 2020)
+# temperature in Kelvin, isobaric heat capacity in J/(kg K)
+263.15 2.6972
+265.15 2.7044
+267.15 2.7115
+269.15 2.7187
+271.15 2.7258
+273.15 2.7329
+275.15 2.74
+277.15 2.747
+279.15 2.7541
+281.15 2.7611
+283.15 2.7681
+285.15 2.7751
+287.15 2.782
+289.15 2.7889
+291.15 2.7958
+293.15 2.8027
+295.15 2.8096
+297.15 2.8165
+299.15 2.8233
+301.15 2.8301
diff --git a/pandapipes/properties/butane/higher_heating_value.txt b/pandapipes/properties/butane/higher_heating_value.txt
new file mode 100644
index 00000000..f72e40ee
--- /dev/null
+++ b/pandapipes/properties/butane/higher_heating_value.txt
@@ -0,0 +1,2 @@
+# higher heating value in kWh/kg (at nominal conditions)
+13.64
\ No newline at end of file
diff --git a/pandapipes/properties/butane/lower_heating_value.txt b/pandapipes/properties/butane/lower_heating_value.txt
new file mode 100644
index 00000000..0cb5576e
--- /dev/null
+++ b/pandapipes/properties/butane/lower_heating_value.txt
@@ -0,0 +1,2 @@
+# lower heating value in kWh/kg (at nominal conditions)
+12.58
\ No newline at end of file
diff --git a/pandapipes/properties/butane/molar_mass.txt b/pandapipes/properties/butane/molar_mass.txt
new file mode 100644
index 00000000..56217645
--- /dev/null
+++ b/pandapipes/properties/butane/molar_mass.txt
@@ -0,0 +1,2 @@
+# kg/kmol C4H10
+58.1222
diff --git a/pandapipes/properties/butane/viscosity.txt b/pandapipes/properties/butane/viscosity.txt
new file mode 100644
index 00000000..88e822f7
--- /dev/null
+++ b/pandapipes/properties/butane/viscosity.txt
@@ -0,0 +1,24 @@
+# NIST Chemistry WebBook, SRD 69
+# https://webbook.nist.gov/cgi/fluid.cgi?P=1&TLow=263.15&THigh=373.15&TInc=2&Applet=on&Digits=5&ID=C106978&Action=Load&Type=IsoBar&TUnit=C&PUnit=bar&DUnit=kg%2Fm3&HUnit=kJ%2Fkg&WUnit=m%2Fs&VisUnit=Pa*s&STUnit=N%2Fm&RefState=DEF
+# Eric W. Lemmon, Mark O. McLinden and Daniel G. Friend, "Thermophysical Properties of Fluid Systems" in NIST Chemistry WebBook, NIST Standard Reference Database Number 69, Eds. P.J. Linstrom and W.G. Mallard, National Institute of Standards and Technology, Gaithersburg MD, 20899, https://doi.org/10.18434/T4D303, (retrieved June 10, 2020)
+# temperature in Kelvin, dynamic viscosity in kg/(m s)
+263.15 1.31E-05
+265.15 1.31E-05
+267.15 1.31E-05
+269.15 1.32E-05
+271.15 1.32E-05
+273.15 1.33E-05
+275.15 1.33E-05
+277.15 1.34E-05
+279.15 1.34E-05
+281.15 1.35E-05
+283.15 1.35E-05
+285.15 1.36E-05
+287.15 1.36E-05
+289.15 1.36E-05
+291.15 1.37E-05
+293.15 1.37E-05
+295.15 1.38E-05
+297.15 1.38E-05
+299.15 1.39E-05
+301.15 1.39E-05
diff --git a/pandapipes/properties/carbondioxide/compressibility.txt b/pandapipes/properties/carbondioxide/compressibility.txt
new file mode 100644
index 00000000..1016095b
--- /dev/null
+++ b/pandapipes/properties/carbondioxide/compressibility.txt
@@ -0,0 +1 @@
+-0.001 1
\ No newline at end of file
diff --git a/pandapipes/properties/carbondioxide/der_compressibility.txt b/pandapipes/properties/carbondioxide/der_compressibility.txt
new file mode 100644
index 00000000..fd5c75be
--- /dev/null
+++ b/pandapipes/properties/carbondioxide/der_compressibility.txt
@@ -0,0 +1 @@
+-0.001
\ No newline at end of file
diff --git a/pandapipes/properties/carbondioxide/higher_heating_value.txt b/pandapipes/properties/carbondioxide/higher_heating_value.txt
new file mode 100644
index 00000000..d2216854
--- /dev/null
+++ b/pandapipes/properties/carbondioxide/higher_heating_value.txt
@@ -0,0 +1,2 @@
+# higher heating value in kWh/kg (at nominal conditions)
+0
\ No newline at end of file
diff --git a/pandapipes/properties/carbondioxide/lower_heating_value.txt b/pandapipes/properties/carbondioxide/lower_heating_value.txt
new file mode 100644
index 00000000..9bb433dd
--- /dev/null
+++ b/pandapipes/properties/carbondioxide/lower_heating_value.txt
@@ -0,0 +1,2 @@
+# lower heating value in kWh/kg (at nominal conditions)
+0
diff --git a/pandapipes/properties/ethane/compressibility.txt b/pandapipes/properties/ethane/compressibility.txt
new file mode 100644
index 00000000..bb7662ba
--- /dev/null
+++ b/pandapipes/properties/ethane/compressibility.txt
@@ -0,0 +1,2 @@
+# slope in 1/bar, offset for linear property
+-0.0022 1
\ No newline at end of file
diff --git a/pandapipes/properties/ethane/der_compressibility.txt b/pandapipes/properties/ethane/der_compressibility.txt
new file mode 100644
index 00000000..1d94cc3b
--- /dev/null
+++ b/pandapipes/properties/ethane/der_compressibility.txt
@@ -0,0 +1,2 @@
+# derivative (slope) of compressibility
+-0.0022
\ No newline at end of file
diff --git a/pandapipes/properties/ethane/higher_heating_value.txt b/pandapipes/properties/ethane/higher_heating_value.txt
new file mode 100644
index 00000000..e2068b16
--- /dev/null
+++ b/pandapipes/properties/ethane/higher_heating_value.txt
@@ -0,0 +1,2 @@
+# higher heating value in kWh/kg (at nominal conditions)
+14.42
\ No newline at end of file
diff --git a/pandapipes/properties/ethane/lower_heating_value.txt b/pandapipes/properties/ethane/lower_heating_value.txt
new file mode 100644
index 00000000..58df17c8
--- /dev/null
+++ b/pandapipes/properties/ethane/lower_heating_value.txt
@@ -0,0 +1,2 @@
+# lower heating value in kWh/kg (at nominal conditions)
+13.28
\ No newline at end of file
diff --git a/pandapipes/properties/fluids.py b/pandapipes/properties/fluids.py
index 5a245627..bb5a81d0 100644
--- a/pandapipes/properties/fluids.py
+++ b/pandapipes/properties/fluids.py
@@ -9,10 +9,13 @@
from scipy.interpolate import interp1d
from pandapipes import pp_dir
+from pandapipes.properties.properties_toolbox import calculate_mixture_density, calculate_mixture_viscosity, \
+ calculate_mixture_molar_mass, calculate_molar_fraction_from_mass_fraction, calculate_mixture_heat_capacity, \
+ calculate_mixture_compressibility, calculate_mixture_calorific_values, calculate_mass_fraction_from_molar_fraction
from pandapower.io_utils import JSONSerializableClass
try:
- import pplog as logging
+ from pandaplan.core import pplog as logging
except ImportError:
import logging
@@ -173,6 +176,12 @@ def get_der_compressibility(self):
return self.get_property("der_compressibility")
+ def get_lower_heating_value(self):
+ return self.get_property("lhv")
+
+ def get_higher_heating_value(self):
+ return self.get_property("hhv")
+
class FluidProperty(JSONSerializableClass):
"""
@@ -258,7 +267,7 @@ def get_at_integral_value(self, upper_limit_arg, lower_limit_arg):
"""
mean = (self.prop_getter(upper_limit_arg) + self.prop_getter(upper_limit_arg)) / 2
- return mean * (upper_limit_arg-lower_limit_arg)
+ return mean * (upper_limit_arg - lower_limit_arg)
@classmethod
def from_path(cls, path, method="interpolate_extrapolate"):
@@ -534,7 +543,7 @@ def from_path(cls, path, polynominal_degree):
return cls(values[:, 0], values[:, 1], polynominal_degree)
-def create_constant_property(net, property_name, value, overwrite=True, warn_on_duplicates=True):
+def create_constant_property(net, fluid_name, property_name, value, overwrite=True, warn_on_duplicates=True):
"""
Creates a property with a constant value.
@@ -551,12 +560,12 @@ def create_constant_property(net, property_name, value, overwrite=True, warn_on_
:type warn_on_duplicates: basestring
"""
prop = FluidPropertyConstant(value)
- get_fluid(net).add_property(property_name, prop, overwrite=overwrite,
- warn_on_duplicates=warn_on_duplicates)
+ net.fluid[fluid_name].add_property(property_name, prop, overwrite=overwrite,
+ warn_on_duplicates=warn_on_duplicates)
return prop
-def create_linear_property(net, property_name, slope, offset, overwrite=True,
+def create_linear_property(net, fluid_name, property_name, slope, offset, overwrite=True,
warn_on_duplicates=True):
"""
Creates a property with a linear correlation.
@@ -576,8 +585,8 @@ def create_linear_property(net, property_name, slope, offset, overwrite=True,
:type warn_on_duplicates: basestring
"""
prop = FluidPropertyLinear(slope, offset)
- get_fluid(net).add_property(property_name, prop, overwrite=overwrite,
- warn_on_duplicates=warn_on_duplicates)
+ net.fluid[fluid_name].add_property(property_name, prop, overwrite=overwrite,
+ warn_on_duplicates=warn_on_duplicates)
return prop
@@ -623,7 +632,7 @@ def linear_property(prop):
os.path.join(pp_dir, "properties", fluid_name, prop + ".txt"))
liquids = ["water"]
- gases = ["air", "lgas", "hgas", "hydrogen", "methane"]
+ gases = ["air", "lgas", "hgas", "hydrogen", "methane", "ethane", "butane", "propane", "carbondioxide", "nitrogen"]
if fluid_name == "natural_gas":
logger.error("'natural_gas' is ambigious. Please choose 'hgas' or 'lgas' "
@@ -641,7 +650,7 @@ def linear_property(prop):
der_compr = constant_property("der_compressibility")
compr = linear_property("compressibility")
- if (phase == 'gas') & (fluid_name != 'air'):
+ if (phase == 'gas'):
lhv = constant_property("lower_heating_value")
hhv = constant_property("higher_heating_value")
@@ -654,7 +663,7 @@ def linear_property(prop):
der_compressibility=der_compr)
-def get_fluid(net):
+def get_fluid(net, fluid_name):
"""
This function shows which fluid is used in the net.
@@ -663,9 +672,9 @@ def get_fluid(net):
:return: Fluid - Name of the fluid which is used in the current network
:rtype: Fluid
"""
- if "fluid" not in net or net["fluid"] is None:
+ if fluid_name not in net.fluid.keys():
raise AttributeError("There is no fluid defined for the given net!")
- fluid = net["fluid"]
+ fluid = net.fluid[fluid_name]
if not isinstance(fluid, Fluid):
logger.warning("The fluid in this net is not of the pandapipes Fluid type. This could lead"
" to errors, as some components might depend on this structure")
@@ -686,11 +695,9 @@ def _add_fluid_to_net(net, fluid, overwrite=True):
:return: No output.
:type: None
"""
- if "fluid" in net and net["fluid"] is not None and not overwrite:
- fluid_msg = "an existing fluid" if not hasattr(net["fluid"], "name") \
- else "the fluid %s" % net["fluid"].name
- logger.warning("The fluid %s would replace %s and thus cannot be created. Try to set "
- "overwrite to True" % (fluid.name, fluid_msg))
+ if "fluid" in net and fluid.name in net["fluid"] and not overwrite:
+ logger.warning("The fluid %s would replace the exisiting fluid with the same name and thus cannot be created. "
+ "Try to set overwrite to True" % (fluid.name))
return
if isinstance(fluid, str):
@@ -698,4 +705,119 @@ def _add_fluid_to_net(net, fluid, overwrite=True):
"argument. Internally, it will be passed to call_lib(fluid) to get the "
"respective pandapipes.Fluid." % fluid)
fluid = call_lib(fluid)
- net["fluid"] = fluid
+ net["fluid"][fluid.name] = fluid
+
+
+def get_property(net, property_name, fluid_name=None, *at_values):
+ if len(net._fluid) == 1:
+ return get_fluid(net, net._fluid[0]).get_property(property_name, *at_values)
+ else:
+ return net.fluid[fluid_name].get_property(property_name, *at_values)
+
+
+def get_mixture_molar_mass(net, mass_fraction):
+ molar_mass_list = [net.fluid[fluid].get_molar_mass() for fluid in net._fluid]
+ return calculate_mixture_molar_mass(molar_mass_list, component_proportions=mass_fraction)
+
+
+def get_mixture_density(net, temperature, mass_fraction):
+ density_list = [net.fluid[fluid].get_density(temperature) for fluid in net._fluid]
+ return calculate_mixture_density(density_list, mass_fraction.T)
+
+
+def get_mixture_viscosity(net, temperature, mass_fraction):
+ viscosity_list, molar_mass_list = [], []
+ for fluid in net._fluid:
+ viscosity_list += [net.fluid[fluid].get_viscosity(temperature)]
+ molar_mass_list += [net.fluid[fluid].get_molar_mass()]
+ molar_fraction = calculate_molar_fraction_from_mass_fraction(mass_fraction.T, np.array(molar_mass_list))
+ return calculate_mixture_viscosity(viscosity_list, molar_fraction, np.array(molar_mass_list).T)
+
+
+def get_mixture_heat_capacity(net, temperature, mass_fraction):
+ heat_capacity_list = [net.fluid[fluid].get_heat_capacity(temperature) for fluid in net._fluid]
+ return calculate_mixture_heat_capacity(heat_capacity_list, mass_fraction.T)
+
+
+def get_mixture_compressibility(net, pressure, mass_fraction):
+ compressibility_list = [net.fluid[fluid].get_property('compressibility', pressure) for fluid in net._fluid]
+ return calculate_mixture_compressibility(compressibility_list, mass_fraction.T)
+
+def get_mixture_der_cmpressibility(net, pressure, mass_fraction):
+ der_compressibility_list = [net.fluid[fluid].get_property('der_compressibility', pressure) for fluid in net._fluid]
+ return calculate_mixture_compressibility(der_compressibility_list, mass_fraction.T)
+
+
+def get_mixture_higher_heating_value(net, mass_fraction):
+ calorific_list = np.array([net.fluid[fluid].get_property('hhv') for fluid in net._fluid])
+ return calculate_mixture_calorific_values(calorific_list, mass_fraction.T)
+
+
+def get_mixture_lower_heating_value(net, mass_fraction):
+ calorific_list = np.array([net.fluid[fluid].get_property('lhv') for fluid in net._fluid])
+ return calculate_mixture_calorific_values(calorific_list, mass_fraction.T)
+
+
+def is_fluid_gas(net):
+ if len(net._fluid) == 1:
+ return get_fluid(net, net._fluid[0]).is_gas
+ else:
+ state = [get_fluid(net, fluid).is_gas for fluid in net._fluid]
+ if np.all(state):
+ return True
+ elif np.all(~np.array(state)):
+ return False
+ else:
+ logger.warning('Be careful. You look at system containing both fluid and gaseous fluids.')
+
+
+def create_individual_fluid(fluid_name, fluid_components,
+ temperature_list, pressure_list,
+ component_proportions, proportion_type='mass', phase='gas'):
+ molar_mass = []
+ density = []
+ viscosity = []
+ heat_capacity = []
+ compressibility = []
+ der_compressibility = []
+ high_calorific = []
+ low_calorific = []
+ for fl_co in fluid_components:
+ fluid = call_lib(fl_co)
+ molar_mass += [fluid.get_molar_mass()]
+ density += [fluid.get_density(temperature_list)]
+ viscosity += [fluid.get_viscosity(temperature_list)]
+ heat_capacity += [fluid.get_heat_capacity(temperature_list)]
+ compressibility += [fluid.get_property('compressibility', pressure_list)]
+ der_compressibility += [fluid.get_property('der_compressibility', temperature_list)]
+ high_calorific += [fluid.get_property('hhv')]
+ low_calorific += [fluid.get_property('lhv')]
+ if proportion_type == 'mass':
+ mof = calculate_molar_fraction_from_mass_fraction(component_proportions, molar_mass)
+ maf = np.array(component_proportions)
+ elif proportion_type == 'molar':
+ mof = np.array(component_proportions)
+ maf = calculate_mass_fraction_from_molar_fraction(component_proportions, molar_mass)
+ else:
+ raise (AttributeError('proportion type %s not defined. Select either mass or molar' %proportion_type))
+ dens = calculate_mixture_density(density, maf)
+ visc = calculate_mixture_viscosity(viscosity, mof, np.array(molar_mass))
+ heat = calculate_mixture_heat_capacity(heat_capacity, maf)
+ comp = calculate_mixture_compressibility(compressibility, maf)
+ derc = calculate_mixture_compressibility(der_compressibility, maf)
+ mass = calculate_mixture_molar_mass(molar_mass, maf)
+ higc = calculate_mixture_calorific_values(np.array(high_calorific), maf)
+ lowc = calculate_mixture_calorific_values(np.array(low_calorific), maf)
+
+ dens = FluidPropertyInterExtra(temperature_list, dens)
+ visc = FluidPropertyInterExtra(temperature_list, visc)
+ heat = FluidPropertyInterExtra(temperature_list, heat)
+ mass = FluidPropertyConstant(mass)
+ higc = FluidPropertyConstant(higc)
+ lowc = FluidPropertyConstant(lowc)
+ derc = FluidPropertyInterExtra(temperature_list, derc)
+ comp = FluidPropertyInterExtra(pressure_list, comp)
+
+ fluid = Fluid(fluid_name, phase, density=dens, viscosity=visc, heat_capacity=heat, molar_mass=mass,
+ der_compressibility=derc, compressibility=comp, hhv=higc, lhv=lowc)
+ return fluid
diff --git a/pandapipes/properties/nitrogen/compressibility.txt b/pandapipes/properties/nitrogen/compressibility.txt
new file mode 100644
index 00000000..1016095b
--- /dev/null
+++ b/pandapipes/properties/nitrogen/compressibility.txt
@@ -0,0 +1 @@
+-0.001 1
\ No newline at end of file
diff --git a/pandapipes/properties/nitrogen/der_compressibility.txt b/pandapipes/properties/nitrogen/der_compressibility.txt
new file mode 100644
index 00000000..fd5c75be
--- /dev/null
+++ b/pandapipes/properties/nitrogen/der_compressibility.txt
@@ -0,0 +1 @@
+-0.001
\ No newline at end of file
diff --git a/pandapipes/properties/nitrogen/higher_heating_value.txt b/pandapipes/properties/nitrogen/higher_heating_value.txt
new file mode 100644
index 00000000..d2216854
--- /dev/null
+++ b/pandapipes/properties/nitrogen/higher_heating_value.txt
@@ -0,0 +1,2 @@
+# higher heating value in kWh/kg (at nominal conditions)
+0
\ No newline at end of file
diff --git a/pandapipes/properties/nitrogen/lower_heating_value.txt b/pandapipes/properties/nitrogen/lower_heating_value.txt
new file mode 100644
index 00000000..75f3ef1c
--- /dev/null
+++ b/pandapipes/properties/nitrogen/lower_heating_value.txt
@@ -0,0 +1,2 @@
+# lower heating value in kWh/kg (at nominal conditions)
+13.20179
\ No newline at end of file
diff --git a/pandapipes/properties/propane/compressibility.txt b/pandapipes/properties/propane/compressibility.txt
new file mode 100644
index 00000000..bb7662ba
--- /dev/null
+++ b/pandapipes/properties/propane/compressibility.txt
@@ -0,0 +1,2 @@
+# slope in 1/bar, offset for linear property
+-0.0022 1
\ No newline at end of file
diff --git a/pandapipes/properties/propane/density.txt b/pandapipes/properties/propane/density.txt
new file mode 100644
index 00000000..084333b7
--- /dev/null
+++ b/pandapipes/properties/propane/density.txt
@@ -0,0 +1,60 @@
+# NIST Chemistry WebBook, SRD 69
+# https://webbook.nist.gov/cgi/fluid.cgi?P=1&TLow=263.15&THigh=373.15+&TInc=2&Applet=on&Digits=5&ID=C74986&Action=Load&Type=IsoBar&TUnit=C&PUnit=bar&DUnit=mol%2Fl&HUnit=kJ%2Fmol&WUnit=m%2Fs&VisUnit=uPa*s&STUnit=N%2Fm&RefState=DEF
+# Eric W. Lemmon, Mark O. McLinden and Daniel G. Friend, "Thermophysical Properties of Fluid Systems" in NIST Chemistry WebBook, NIST Standard Reference Database Number 69, Eds. P.J. Linstrom and W.G. Mallard, National Institute of Standards and Technology, Gaithersburg MD, 20899, https://doi.org/10.18434/T4D303, (retrieved June 10, 2020)
+# temperature in Kelvin, nominal density in kg/Nm^3 at 1 bar
+263.15 0.99113
+265.15 0.98742
+267.15 0.98373
+269.15 0.98007
+271.15 0.97644
+273.15 0.97284
+275.15 0.96926
+277.15 0.96571
+279.15 0.96219
+281.15 0.95869
+283.15 0.95521
+285.15 0.95176
+287.15 0.94834
+289.15 0.94494
+291.15 0.94157
+293.15 0.93822
+295.15 0.93489
+297.15 0.93159
+299.15 0.92831
+301.15 0.92505
+303.15 0.92182
+305.15 0.91861
+307.15 0.91542
+309.15 0.91226
+311.15 0.90911
+313.15 0.90599
+315.15 0.90289
+317.15 0.89981
+319.15 0.89675
+321.15 0.89371
+323.15 0.8907
+325.15 0.8877
+327.15 0.88472
+329.15 0.88177
+331.15 0.87883
+333.15 0.87591
+335.15 0.87302
+337.15 0.87014
+339.15 0.86728
+341.15 0.86444
+343.15 0.86162
+345.15 0.85881
+347.15 0.85603
+349.15 0.85326
+351.15 0.85051
+353.15 0.84778
+355.15 0.84507
+357.15 0.84237
+359.15 0.83969
+361.15 0.83703
+363.15 0.83439
+365.15 0.83176
+367.15 0.82915
+369.15 0.82655
+371.15 0.82397
+373.15 0.82141
diff --git a/pandapipes/properties/propane/der_compressibility.txt b/pandapipes/properties/propane/der_compressibility.txt
new file mode 100644
index 00000000..1d94cc3b
--- /dev/null
+++ b/pandapipes/properties/propane/der_compressibility.txt
@@ -0,0 +1,2 @@
+# derivative (slope) of compressibility
+-0.0022
\ No newline at end of file
diff --git a/pandapipes/properties/propane/heat_capacity.txt b/pandapipes/properties/propane/heat_capacity.txt
new file mode 100644
index 00000000..9ccf62e2
--- /dev/null
+++ b/pandapipes/properties/propane/heat_capacity.txt
@@ -0,0 +1,60 @@
+# NIST Chemistry WebBook, SRD 69
+# https://webbook.nist.gov/cgi/fluid.cgi?P=1&TLow=263.15&THigh=373.15&TInc=2&Applet=on&Digits=5&ID=C74986&Action=Load&Type=IsoBar&TUnit=C&PUnit=bar&DUnit=kg%2Fm3&HUnit=kJ%2Fkg&WUnit=m%2Fs&VisUnit=Pa*s&STUnit=N%2Fm&RefState=DEF
+# Eric W. Lemmon, Mark O. McLinden and Daniel G. Friend, "Thermophysical Properties of Fluid Systems" in NIST Chemistry WebBook, NIST Standard Reference Database Number 69, Eds. P.J. Linstrom and W.G. Mallard, National Institute of Standards and Technology, Gaithersburg MD, 20899, https://doi.org/10.18434/T4D303, (retrieved June 10, 2020)
+# temperature in Kelvin, isobaric heat capacity in J/(kg K)
+263.15 2.6861
+265.15 2.6935
+267.15 2.7009
+269.15 2.7083
+271.15 2.7157
+273.15 2.723
+275.15 2.7303
+277.15 2.7376
+279.15 2.7449
+281.15 2.7522
+283.15 2.7594
+285.15 2.7666
+287.15 2.7738
+289.15 2.781
+291.15 2.7881
+293.15 2.7952
+295.15 2.8024
+297.15 2.8094
+299.15 2.8165
+301.15 2.8236
+303.15 2.8306
+305.15 2.8376
+307.15 2.8446
+309.15 2.8515
+311.15 2.8585
+313.15 2.8654
+315.15 2.8723
+317.15 2.8792
+319.15 2.886
+321.15 2.8929
+323.15 2.8997
+325.15 2.9065
+327.15 2.9133
+329.15 2.92
+331.15 2.9268
+333.15 2.9335
+335.15 2.9402
+337.15 2.9469
+339.15 2.9536
+341.15 2.9602
+343.15 2.9668
+345.15 2.9734
+347.15 2.98
+349.15 2.9866
+351.15 2.9931
+353.15 2.9997
+355.15 3.0062
+357.15 3.0127
+359.15 3.0192
+361.15 3.0256
+363.15 3.032
+365.15 3.0385
+367.15 3.0449
+369.15 3.0512
+371.15 3.0576
+373.15 3.064
diff --git a/pandapipes/properties/propane/higher_heating_value.txt b/pandapipes/properties/propane/higher_heating_value.txt
new file mode 100644
index 00000000..e290c3ef
--- /dev/null
+++ b/pandapipes/properties/propane/higher_heating_value.txt
@@ -0,0 +1,2 @@
+# higher heating value in kWh/kg (at nominal conditions)
+13.99
\ No newline at end of file
diff --git a/pandapipes/properties/propane/lower_heating_value.txt b/pandapipes/properties/propane/lower_heating_value.txt
new file mode 100644
index 00000000..18884356
--- /dev/null
+++ b/pandapipes/properties/propane/lower_heating_value.txt
@@ -0,0 +1,2 @@
+# lower heating value in kWh/kg (at nominal conditions)
+12.88
\ No newline at end of file
diff --git a/pandapipes/properties/propane/molar_mass.txt b/pandapipes/properties/propane/molar_mass.txt
new file mode 100644
index 00000000..c3b0a3a8
--- /dev/null
+++ b/pandapipes/properties/propane/molar_mass.txt
@@ -0,0 +1,3 @@
+# kg/kmol C3H8
+44.09562
+
diff --git a/pandapipes/properties/propane/viscosity.txt b/pandapipes/properties/propane/viscosity.txt
new file mode 100644
index 00000000..a6db9579
--- /dev/null
+++ b/pandapipes/properties/propane/viscosity.txt
@@ -0,0 +1,37 @@
+# NIST Chemistry WebBook, SRD 69
+#https://webbook.nist.gov/cgi/fluid.cgi?P=1&TLow=263.15&THigh=373.15&TInc=2&Applet=on&Digits=5&ID=C74986&Action=Load&Type=IsoBar&TUnit=C&PUnit=bar&DUnit=kg%2Fm3&HUnit=kJ%2Fkg&WUnit=m%2Fs&VisUnit=Pa*s&STUnit=N%2Fm&RefState=DEF
+# Eric W. Lemmon, Mark O. McLinden and Daniel G. Friend, "Thermophysical Properties of Fluid Systems" in NIST Chemistry WebBook, NIST Standard Reference Database Number 69, Eds. P.J. Linstrom and W.G. Mallard, National Institute of Standards and Technology, Gaithersburg MD, 20899, https://doi.org/10.18434/T4D303, (retrieved June 10, 2020)
+# temperature in Kelvin, dynamic viscosity in kg/(m s)
+263.15 1.41E-05
+265.15 1.42E-05
+267.15 1.42E-05
+269.15 1.43E-05
+271.15 1.43E-05
+273.15 1.43E-05
+275.15 1.44E-05
+277.15 1.44E-05
+279.15 1.45E-05
+281.15 1.45E-05
+283.15 1.46E-05
+285.15 1.46E-05
+287.15 1.47E-05
+289.15 1.47E-05
+291.15 1.48E-05
+293.15 1.48E-05
+295.15 1.48E-05
+297.15 1.49E-05
+299.15 1.49E-05
+301.15 1.50E-05
+303.15 1.50E-05
+305.15 1.51E-05
+307.15 1.51E-05
+309.15 1.52E-05
+311.15 1.52E-05
+313.15 1.53E-05
+315.15 1.53E-05
+317.15 1.53E-05
+319.15 1.54E-05
+321.15 1.54E-05
+323.15 1.55E-05
+325.15 1.55E-05
+
diff --git a/pandapipes/properties/properties_toolbox.py b/pandapipes/properties/properties_toolbox.py
index 1cf2cb1b..0b6949d8 100644
--- a/pandapipes/properties/properties_toolbox.py
+++ b/pandapipes/properties/properties_toolbox.py
@@ -31,7 +31,10 @@ def calculate_mixture_viscosity(components_viscosities, components_molar_proport
else:
com_array = np.empty([shape[0], shape[1], 5], dtype=np.float64)
com_array[:, :, 0] = components_viscosities
- com_array[:, :, 1] = np.reshape(components_molar_proportions.repeat(shape[1]), shape)
+ if np.shape(components_viscosities) == np.shape(components_molar_proportions):
+ com_array[:, :, 1] = components_molar_proportions
+ else:
+ com_array[:, :, 1] = np.reshape(components_molar_proportions.repeat(shape[1]), shape)
com_array[:, :, 2] = np.reshape(components_molar_mass.repeat(shape[1]), shape)
com_array[:, :, 3] = com_array[:, :, 0] * com_array[:, :, 1] * np.sqrt(com_array[:, :, 2])
com_array[:, :, 4] = com_array[:, :, 1] * np.sqrt(com_array[:, :, 2])
@@ -59,7 +62,10 @@ def calculate_mixture_density(components_density, components_mass_proportions):
res = 1 / com_array[:, 2].sum()
else:
com_array = np.empty([shape[0], shape[1], 3], dtype=np.float64)
- com_array[:, :, 0] = np.reshape(components_mass_proportions.repeat(shape[1]), shape)
+ if np.shape(components_density) == np.shape(components_mass_proportions):
+ com_array[:, :, 0] = components_mass_proportions
+ else:
+ com_array[:, :, 0] = np.reshape(components_mass_proportions.repeat(shape[1]), shape)
com_array[:, :, 1] = components_density
com_array[:, :, 2] = com_array[:, :, 0] / com_array[:, :, 1]
res = 1 / com_array[:, :, 2].sum(axis=0)
@@ -86,15 +92,17 @@ def calculate_mixture_heat_capacity(components_capacity, components_mass_proport
res = com_array[:, 2].sum()
else:
com_array = np.empty([shape[0], shape[1], 3], dtype=np.float64)
- com_array[:, :, 0] = np.reshape(components_mass_proportions.repeat(shape[1]), shape)
+ if np.shape(components_capacity) == np.shape(components_mass_proportions):
+ com_array[:, :, 0] = components_mass_proportions
+ else:
+ com_array[:, :, 0] = np.reshape(components_mass_proportions.repeat(shape[1]), shape)
com_array[:, :, 1] = components_capacity
com_array[:, :, 2] = com_array[:, :, 1] * com_array[:, :, 0]
res = com_array[:, :, 2].sum(axis=0)
return res
-def calculate_mixture_molar_mass(components_molar_mass, components_molar_proportions=None,
- components_mass_proportions=None):
+def calculate_mixture_molar_mass(components_molar_mass, component_proportions, proportion_type='mass'):
"""
Todo: Fill out parameters.
@@ -107,15 +115,15 @@ def calculate_mixture_molar_mass(components_molar_mass, components_molar_proport
:return:
:rtype:
"""
- if components_molar_proportions is not None:
- com_array = np.empty([len(components_molar_proportions), 3], dtype=np.float64)
- com_array[:, 0] = components_molar_proportions
+ if proportion_type == 'molar':
+ com_array = np.empty([len(component_proportions), 3], dtype=np.float64)
+ com_array[:, 0] = component_proportions
com_array[:, 1] = components_molar_mass
com_array[:, 2] = com_array[:, 0] * com_array[:, 1]
res = com_array[:, 2].sum()
- elif components_mass_proportions is not None:
- com_array = np.empty([len(components_mass_proportions), 3], dtype=np.float64)
- com_array[:, 0] = components_mass_proportions
+ elif proportion_type == 'mass':
+ com_array = np.empty([len(component_proportions), 3], dtype=np.float64)
+ com_array[:, 0] = component_proportions
com_array[:, 1] = components_molar_mass
com_array[:, 2] = com_array[:, 0] / com_array[:, 1]
res = 1 / com_array[:, 2].sum()
@@ -136,9 +144,108 @@ def calculate_mass_fraction_from_molar_fraction(component_molar_proportions, com
:return:
:rtype:
"""
- com_array = np.empty([len(component_molar_proportions), 4], dtype=np.float64)
- com_array[:, 0] = component_molar_proportions
- com_array[:, 1] = component_molar_mass
- com_array[:, 2] = com_array[:, 0] * com_array[:, 1]
- com_array[:, 3] = com_array[:, 2] / com_array[:, 2].sum()
- return com_array[:, 3]
+ shape = np.shape(component_molar_proportions)
+ if len(shape) == 1:
+ com_array = np.empty([len(component_molar_proportions), 4], dtype=np.float64)
+ com_array[:, 0] = component_molar_proportions
+ com_array[:, 1] = component_molar_mass
+ com_array[:, 2] = com_array[:, 0] * com_array[:, 1]
+ com_array[:, 3] = com_array[:, 2] / com_array[:, 2].sum()
+ res = com_array[:, 3]
+ else:
+ com_array = np.empty([shape[0], shape[1], 4], dtype=np.float64)
+ com_array[:, :, 0] = component_molar_proportions
+ com_array[:, :, 1] = np.reshape(component_molar_mass.repeat(shape[1]), shape)
+ com_array[:, :, 2] = com_array[:, :, 0] * com_array[:, :, 1]
+ com_array[:, :, 3] = com_array[:, :, 2] / com_array[:, :, 2].sum()
+ res = com_array[:, :, 3]
+ return res
+
+
+def calculate_molar_fraction_from_mass_fraction(component_mass_proportions, component_molar_mass):
+ """
+ Todo: Fill out parameters.
+
+ :param component_molar_proportions:
+ :type component_molar_proportions:
+ :param component_molar_mass:
+ :type component_molar_mass:
+ :return:
+ :rtype:
+ """
+ shape = np.shape(component_mass_proportions)
+ if len(shape) == 1:
+ com_array = np.empty([len(component_mass_proportions), 4], dtype=np.float64)
+ com_array[:, 0] = component_mass_proportions
+ com_array[:, 1] = component_molar_mass.T
+ com_array[:, 2] = com_array[:, 0] / com_array[:, 1]
+ com_array[:, 3] = com_array[:, 2] / com_array[:, 2].sum()
+ res = com_array[:, 3]
+ else:
+ com_array = np.empty([shape[0], shape[1], 4], dtype=np.float64)
+ com_array[:, :, 0] = component_mass_proportions
+ com_array[:, :, 1] = np.reshape(component_molar_mass.repeat(shape[1]), shape)
+ com_array[:, :, 2] = com_array[:, :, 0] / com_array[:, :, 1]
+ com_array[:, :, 3] = com_array[:, :, 2] / com_array[:, :, 2].sum()
+ res = com_array[:, :, 3]
+ return res
+
+
+def calculate_mixture_compressibility(components_compressibility, components_mass_proportions):
+ """
+ Todo: Needs to be checked
+
+ :param component_molar_proportions:
+ :type component_molar_proportions:
+ :param component_molar_mass:
+ :type component_molar_mass:
+ :return:
+ :rtype:
+ """
+ shape = np.shape(components_compressibility)
+ if len(shape) == 1:
+ com_array = np.empty([shape[0], 3], dtype=np.float64)
+ com_array[:, 0] = components_mass_proportions
+ com_array[:, 1] = components_compressibility
+ com_array[:, 2] = com_array[:, 1] * com_array[:, 0]
+ res = com_array[:, 2].sum()
+ else:
+ com_array = np.empty([shape[0], shape[1], 3], dtype=np.float64)
+ if np.shape(components_compressibility) == np.shape(components_mass_proportions):
+ com_array[:, :, 0] = components_mass_proportions
+ else:
+ com_array[:, :, 0] = np.reshape(components_mass_proportions.repeat(shape[1]), shape)
+ com_array[:, :, 1] = components_compressibility
+ com_array[:, :, 2] = com_array[:, :, 1] * com_array[:, :, 0]
+ res = com_array[:, :, 2].sum(axis=0)
+ return res
+
+
+def calculate_mixture_calorific_values(components_calorific_values, components_mass_proportions):
+ """
+ Todo: Needs to be checked
+
+ :param component_molar_proportions:
+ :type component_molar_proportions:
+ :param component_molar_mass:
+ :type component_molar_mass:
+ :return:
+ :rtype:
+ """
+ shape = np.shape(components_mass_proportions)
+ if len(shape) == 1:
+ com_array = np.empty([shape[0], 3], dtype=np.float64)
+ com_array[:, 0] = components_mass_proportions
+ com_array[:, 1] = components_calorific_values.T
+ com_array[:, 2] = com_array[:, 1] * com_array[:, 0]
+ res = com_array[:, 2].sum()
+ else:
+ com_array = np.empty([shape[0], shape[1], 3], dtype=np.float64)
+ if np.shape(components_calorific_values) == np.shape(components_mass_proportions):
+ com_array[:, :, 0] = components_calorific_values
+ else:
+ com_array[:, :, 0] = np.reshape(components_calorific_values.repeat(shape[1]), shape)
+ com_array[:, :, 1] = components_mass_proportions
+ com_array[:, :, 2] = com_array[:, :, 1] * com_array[:, :, 0]
+ res = com_array[:, :, 2].sum(axis=0)
+ return res
diff --git a/pandapipes/std_types/std_types.py b/pandapipes/std_types/std_types.py
index cf4ada4f..f02a6787 100644
--- a/pandapipes/std_types/std_types.py
+++ b/pandapipes/std_types/std_types.py
@@ -11,7 +11,7 @@
from pandapipes.std_types.std_type_class import get_data, PumpStdType
try:
- import pplog as logging
+ from pandaplan.core import pplog as logging
except ImportError:
import logging
diff --git a/pandapipes/test/api/release_cycle/release_control_test_network.py b/pandapipes/test/api/release_cycle/release_control_test_network.py
index dc7b2e01..6912b54c 100644
--- a/pandapipes/test/api/release_cycle/release_control_test_network.py
+++ b/pandapipes/test/api/release_cycle/release_control_test_network.py
@@ -12,7 +12,7 @@
from pandapipes import pp_dir
try:
- import pplog as logging
+ from pandaplan.core import ppglog as logging
except ImportError:
import logging
diff --git a/pandapipes/test/api/test_aux_function.py b/pandapipes/test/api/test_aux_function.py
index 4c34901e..3a383d89 100644
--- a/pandapipes/test/api/test_aux_function.py
+++ b/pandapipes/test/api/test_aux_function.py
@@ -3,6 +3,7 @@
# 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.pf.internals_toolbox import select_from_pit
@@ -13,12 +14,11 @@ def test_select_from_pit():
:rtype:
"""
- input_array = np.array([2,4,5])
- table_index_array = np.array([1,2,3,4,5])
- data = np.array([10,11,12,13,14])
+ input_array = np.array([2, 4, 5])
+ table_index_array = np.array([1, 2, 3, 4, 5])
+ data = np.array([10, 11, 12, 13, 14])
- ret = select_from_pit(table_index_array,input_array,data)
- expected_result = np.array([11, 13,14])
+ ret = select_from_pit(table_index_array, input_array, data)
+ expected_result = np.array([11, 13, 14])
assert np.all(ret == expected_result)
-
diff --git a/pandapipes/test/api/test_components/test_circ_pump_mass.py b/pandapipes/test/api/test_components/test_circ_pump_mass.py
index 62d2d5f3..a463733a 100644
--- a/pandapipes/test/api/test_components/test_circ_pump_mass.py
+++ b/pandapipes/test/api/test_components/test_circ_pump_mass.py
@@ -30,7 +30,7 @@ def test_circulation_pump_constant_mass(use_numba):
pandapipes.create_circ_pump_const_mass_flow(net, j1, j4, 5, 5, 300, type='pt')
pandapipes.create_heat_exchanger(net, j2, j3, 0.1, qext_w=200000)
pandapipes.create_sink(net, j1, 2)
- pandapipes.create_source(net, j4, 2)
+ pandapipes.create_source(net, j4, 2, fluid='water')
pandapipes.create_fluid_from_lib(net, "water", overwrite=True)
diff --git a/pandapipes/test/api/test_components/test_circ_pump_pressure.py b/pandapipes/test/api/test_components/test_circ_pump_pressure.py
index f60c54d4..41536cf4 100644
--- a/pandapipes/test/api/test_components/test_circ_pump_pressure.py
+++ b/pandapipes/test/api/test_components/test_circ_pump_pressure.py
@@ -29,7 +29,7 @@ def test_circulation_pump_constant_pressure(use_numba):
pandapipes.create_circ_pump_const_pressure(net, j1, j4, 5, 2, 300, type='pt')
pandapipes.create_heat_exchanger(net, j2, j3, 0.1, qext_w=200000)
pandapipes.create_sink(net, j1, 2)
- pandapipes.create_source(net, j4, 2)
+ pandapipes.create_source(net, j4, 2, fluid='water')
pandapipes.create_fluid_from_lib(net, "water", overwrite=True)
diff --git a/pandapipes/test/api/test_components/test_compressor.py b/pandapipes/test/api/test_components/test_compressor.py
index bf2abd37..6d0f9ec1 100644
--- a/pandapipes/test/api/test_components/test_compressor.py
+++ b/pandapipes/test/api/test_components/test_compressor.py
@@ -12,14 +12,14 @@
@pytest.mark.parametrize("use_numba", [True, False])
def test_compressor_pressure_ratio(use_numba):
- net = pandapipes.create_empty_network("net", add_stdtypes=True, fluid="hgas")
+ net = pandapipes.create_empty_network("net", add_stdtypes=True)
j = pandapipes.create_junctions(net, 6, pn_bar=5, tfluid_k=283.15)
j1, j2, j3, j4, j5, j6 = j
pandapipes.create_pipe_from_parameters(net, j1, j2, length_km=0.43380, diameter_m=0.1022)
pandapipes.create_pipe_from_parameters(net, j3, j4, length_km=0.26370, diameter_m=0.1022)
- pandapipes.create_ext_grid(net, j1, 5, 283.15, type="p")
+ pandapipes.create_ext_grid(net, j1, 5, 283.15, fluid="hgas", type="p")
pandapipes.create_sink(net, j6, 0.02333)
br1 = 1.5
diff --git a/pandapipes/test/api/test_components/test_ext_grid.py b/pandapipes/test/api/test_components/test_ext_grid.py
index 43445792..69998907 100644
--- a/pandapipes/test/api/test_components/test_ext_grid.py
+++ b/pandapipes/test/api/test_components/test_ext_grid.py
@@ -14,7 +14,7 @@
@pytest.mark.parametrize("use_numba", [True, False])
def test_ext_grid_sorting(use_numba):
- net = pandapipes.create_empty_network(fluid="hgas")
+ net = pandapipes.create_empty_network()
j1 = pandapipes.create_junction(net, 1, 293.15, index=1)
j2 = pandapipes.create_junction(net, 1, 293.15, index=2)
j3 = pandapipes.create_junction(net, 1, 293.15, index=4)
@@ -22,11 +22,11 @@ def test_ext_grid_sorting(use_numba):
j5 = pandapipes.create_junction(net, 1, 293.15, index=6)
j6 = pandapipes.create_junction(net, 1, 293.15, index=7)
- pandapipes.create_ext_grid(net, j2, 1, 285.15, type="pt")
- pandapipes.create_ext_grid(net, j3, 1, 285.15, type="pt")
- pandapipes.create_ext_grid(net, j5, 1, 285.15, type="t")
- pandapipes.create_ext_grid(net, j1, 1, 285.15, type="pt")
- pandapipes.create_ext_grid(net, j1, 1, 285.15, type="pt")
+ pandapipes.create_ext_grid(net, j2, 1, 285.15, fluid="hgas", type="pt")
+ pandapipes.create_ext_grid(net, j3, 1, 285.15, fluid="hgas", type="pt")
+ pandapipes.create_ext_grid(net, j5, 1, 285.15, fluid="hgas", type="t")
+ pandapipes.create_ext_grid(net, j1, 1, 285.15, fluid="hgas", type="pt")
+ pandapipes.create_ext_grid(net, j1, 1, 285.15, fluid="hgas", type="pt")
pandapipes.create_pipe_from_parameters(net, j1, j4, 0.1, 0.1)
pandapipes.create_pipe_from_parameters(net, j2, j5, 0.1, 0.1)
@@ -58,9 +58,8 @@ def test_p_type(use_numba):
pandapipes.create_junction(net, pn_bar=5, tfluid_k=293.15)
pandapipes.create_junction(net, pn_bar=5, tfluid_k=293.15)
pandapipes.create_pipe_from_parameters(net, 0, 1, 10, diameter_m=d, k_mm=0.1, sections=1)
- pandapipes.create_ext_grid(net, 0, p_bar=5, t_k=285.15, type="p")
+ pandapipes.create_ext_grid(net, 0, p_bar=5, t_k=285.15, fluid="water", type="p")
pandapipes.create_sink(net, 1, mdot_kg_per_s=1)
- pandapipes.create_fluid_from_lib(net, name="water")
pandapipes.pipeflow(net, stop_condition="tol", iter=70, friction_model="nikuradse",
transient=False, nonlinear_method="automatic", tol_p=1e-4, tol_v=1e-4,
use_numba=use_numba)
@@ -86,8 +85,8 @@ def test_t_type_single_pipe(use_numba):
d = 75e-3
j0 = pandapipes.create_junction(net, pn_bar=5, tfluid_k=283)
- j1 = pandapipes.create_junction(net, pn_bar=5, tfluid_k=283)
- pandapipes.create_ext_grid(net, j0, 5, 645, type="pt")
+ j1 = pandapipes.create_junction(net, pn_bar=5, tfluid_k=327.765863)
+ pandapipes.create_ext_grid(net, j0, 5, 645, fluid="water", type="pt")
pandapipes.create_sink(net, j1, 1)
pandapipes.create_pipe_from_parameters(net, j0, j1, 6, diameter_m=d, k_mm=.1, sections=1,
alpha_w_per_m2k=5)
@@ -102,10 +101,10 @@ def test_t_type_single_pipe(use_numba):
net2 = pandapipes.create_empty_network("net")
d = 75e-3
- j0 = pandapipes.create_junction(net2, pn_bar=5, tfluid_k=283)
+ j0 = pandapipes.create_junction(net2, pn_bar=5, tfluid_k=645)
j1 = pandapipes.create_junction(net2, pn_bar=5, tfluid_k=283)
- pandapipes.create_ext_grid(net2, j0, 5, 645, type="p")
- pandapipes.create_ext_grid(net2, j1, 100, 323.15, type="t")
+ pandapipes.create_ext_grid(net2, j0, 5, 283, fluid="water", type="p")
+ pandapipes.create_ext_grid(net2, j1, 100, 327.765863, fluid="water", type="t")
pandapipes.create_sink(net2, j1, 1)
pandapipes.create_pipe_from_parameters(net2, j0, j1, 6, diameter_m=d, k_mm=.1, sections=1,
@@ -136,10 +135,10 @@ def test_t_type_tee(use_numba):
j1 = pandapipes.create_junction(net, pn_bar=5, tfluid_k=300)
j2 = pandapipes.create_junction(net, pn_bar=5, tfluid_k=300)
j3 = pandapipes.create_junction(net, pn_bar=5, tfluid_k=300)
- pandapipes.create_ext_grid(net, j0, 5, 645, type="p")
+ pandapipes.create_ext_grid(net, j0, 5, 645, fluid="water", type="p")
pandapipes.create_sink(net, j2, 1)
pandapipes.create_sink(net, j3, 1)
- pandapipes.create_ext_grid(net, j2, 5, 310, type="t")
+ pandapipes.create_ext_grid(net, j2, 5, 310, fluid="water", type="t")
pandapipes.create_pipe_from_parameters(net, j0, j1, 6, diameter_m=d, k_mm=.1, sections=1,
alpha_w_per_m2k=5)
@@ -162,7 +161,7 @@ def test_t_type_tee(use_numba):
j1 = pandapipes.create_junction(net2, pn_bar=5, tfluid_k=300)
j2 = pandapipes.create_junction(net2, pn_bar=5, tfluid_k=300)
j3 = pandapipes.create_junction(net2, pn_bar=5, tfluid_k=300)
- pandapipes.create_ext_grid(net2, j0, 5, 380.445, type="pt")
+ pandapipes.create_ext_grid(net2, j0, 5, 380.445, fluid="water", type="pt")
pandapipes.create_sink(net2, j2, 1)
pandapipes.create_sink(net2, j3, 1)
@@ -200,12 +199,12 @@ def test_t_type_tee_2zu_2ab(use_numba):
j2 = pandapipes.create_junction(net, pn_bar=5, tfluid_k=300)
j3 = pandapipes.create_junction(net, pn_bar=5, tfluid_k=300)
j4 = pandapipes.create_junction(net, pn_bar=5, tfluid_k=300)
- pandapipes.create_ext_grid(net, j0, 5, 645, type="p")
- pandapipes.create_ext_grid(net, j1, 5, 645, type="p")
+ pandapipes.create_ext_grid(net, j0, 5, 645, fluid="water", type="p")
+ pandapipes.create_ext_grid(net, j1, 5, 645, fluid="water", type="p")
pandapipes.create_sink(net, j3, 1)
pandapipes.create_sink(net, j4, 1)
- pandapipes.create_ext_grid(net, j1, 5, 645, type="t")
- pandapipes.create_ext_grid(net, j0, 5, 645, type="t")
+ pandapipes.create_ext_grid(net, j1, 5, 645, fluid="water", type="t")
+ pandapipes.create_ext_grid(net, j0, 5, 645, fluid="water", type="t")
pandapipes.create_pipe_from_parameters(net, j0, j2, 6, diameter_m=d, k_mm=.1, sections=1,
alpha_w_per_m2k=5)
@@ -231,8 +230,8 @@ def test_t_type_tee_2zu_2ab(use_numba):
j2 = pandapipes.create_junction(net2, pn_bar=5, tfluid_k=300)
j3 = pandapipes.create_junction(net2, pn_bar=5, tfluid_k=300)
j4 = pandapipes.create_junction(net2, pn_bar=5, tfluid_k=300)
- pandapipes.create_ext_grid(net2, j0, 5, 645, type="pt")
- pandapipes.create_ext_grid(net2, j1, 5, 645, type="pt")
+ pandapipes.create_ext_grid(net2, j0, 5, 645, fluid="water", type="pt")
+ pandapipes.create_ext_grid(net2, j1, 5, 645, fluid="water", type="pt")
pandapipes.create_sink(net2, j3, 1)
pandapipes.create_sink(net2, j4, 1)
@@ -272,12 +271,12 @@ def test_t_type_tee_2zu_2ab2(use_numba):
j2 = pandapipes.create_junction(net, pn_bar=3, tfluid_k=300)
j3 = pandapipes.create_junction(net, pn_bar=3, tfluid_k=300)
j4 = pandapipes.create_junction(net, pn_bar=3, tfluid_k=300)
- pandapipes.create_ext_grid(net, j0, 5, 645, type="p")
- pandapipes.create_ext_grid(net, j1, 5, 645, type="p")
+ pandapipes.create_ext_grid(net, j0, 5, 645, fluid="water", type="p")
+ pandapipes.create_ext_grid(net, j1, 5, 645, fluid="water", type="p")
pandapipes.create_sink(net, j3, 1)
pandapipes.create_sink(net, j4, 1)
- pandapipes.create_ext_grid(net, j0, 5, 645, type="t")
- pandapipes.create_ext_grid(net, j4, 5, 378.83472, type="t")
+ pandapipes.create_ext_grid(net, j0, 5, 645, fluid="water", type="t")
+ pandapipes.create_ext_grid(net, j4, 5, 378.83472, fluid="water", type="t")
pandapipes.create_pipe_from_parameters(net, j0, j2, 2.5, diameter_m=d, k_mm=.1, sections=5,
alpha_w_per_m2k=5)
@@ -303,8 +302,8 @@ def test_t_type_tee_2zu_2ab2(use_numba):
j2 = pandapipes.create_junction(net2, pn_bar=5, tfluid_k=300)
j3 = pandapipes.create_junction(net2, pn_bar=5, tfluid_k=300)
j4 = pandapipes.create_junction(net2, pn_bar=5, tfluid_k=300)
- pandapipes.create_ext_grid(net2, j0, 5, 645, type="pt")
- pandapipes.create_ext_grid(net2, j1, 5, 645, type="pt")
+ pandapipes.create_ext_grid(net2, j0, 5, 645, fluid="water", type="pt")
+ pandapipes.create_ext_grid(net2, j1, 5, 636.691232, fluid="water", type="pt")
pandapipes.create_sink(net2, j3, 1)
pandapipes.create_sink(net2, j4, 1)
@@ -344,12 +343,12 @@ def test_t_type_tee_2zu_2ab3(use_numba):
j2 = pandapipes.create_junction(net, pn_bar=3, tfluid_k=300)
j3 = pandapipes.create_junction(net, pn_bar=3, tfluid_k=300)
j4 = pandapipes.create_junction(net, pn_bar=3, tfluid_k=300)
- pandapipes.create_ext_grid(net, j0, 5, 645, type="p")
- pandapipes.create_ext_grid(net, j2, 5, 645, type="p")
+ pandapipes.create_ext_grid(net, j0, 5, 645, fluid="water", type="p")
+ pandapipes.create_ext_grid(net, j2, 5, 645, fluid="water", type="p")
pandapipes.create_sink(net, j3, 1)
pandapipes.create_sink(net, j4, 1)
- pandapipes.create_ext_grid(net, j2, 5, 645, type="t")
- pandapipes.create_ext_grid(net, j4, 5, 378.83472, type="t")
+ pandapipes.create_ext_grid(net, j2, 5, 645, fluid="water", type="t")
+ pandapipes.create_ext_grid(net, j4, 5, 378.83472, fluid="water", type="t")
pandapipes.create_pipe_from_parameters(net, j0, j1, 2.5, diameter_m=d, k_mm=.1, sections=5,
alpha_w_per_m2k=5)
@@ -375,8 +374,8 @@ def test_t_type_tee_2zu_2ab3(use_numba):
j2 = pandapipes.create_junction(net2, pn_bar=5, tfluid_k=300)
j3 = pandapipes.create_junction(net2, pn_bar=5, tfluid_k=300)
j4 = pandapipes.create_junction(net2, pn_bar=5, tfluid_k=300)
- pandapipes.create_ext_grid(net2, j0, 5, 645, type="pt")
- pandapipes.create_ext_grid(net2, j2, 5, 645, type="pt")
+ pandapipes.create_ext_grid(net2, j0, 5, 636.691232, fluid="water", type="pt")
+ pandapipes.create_ext_grid(net2, j2, 5, 645, fluid="water", type="pt")
pandapipes.create_sink(net2, j3, 1)
pandapipes.create_sink(net2, j4, 1)
diff --git a/pandapipes/test/api/test_components/test_heat_exchanger.py b/pandapipes/test/api/test_components/test_heat_exchanger.py
index 807b8728..dc6179e2 100644
--- a/pandapipes/test/api/test_components/test_heat_exchanger.py
+++ b/pandapipes/test/api/test_components/test_heat_exchanger.py
@@ -24,7 +24,7 @@ def test_heat_exchanger(use_numba):
pandapipes.create_junction(net, pn_bar=5, tfluid_k=283)
pandapipes.create_junction(net, pn_bar=5, tfluid_k=283)
pandapipes.create_heat_exchanger(net, 0, 1, d, qext_w=20000)
- pandapipes.create_ext_grid(net, 0, p_bar=5, t_k=330, type="pt")
+ pandapipes.create_ext_grid(net, 0, p_bar=5, t_k=330, fluid="water", type="pt")
pandapipes.create_sink(net, 1, mdot_kg_per_s=1)
pandapipes.create_fluid_from_lib(net, "water", overwrite=True)
diff --git a/pandapipes/test/api/test_components/test_pipe_results.py b/pandapipes/test/api/test_components/test_pipe_results.py
index 7304ec0b..25f175d2 100644
--- a/pandapipes/test/api/test_components/test_pipe_results.py
+++ b/pandapipes/test/api/test_components/test_pipe_results.py
@@ -30,13 +30,14 @@ def test_pipe_velocity_results(use_numba):
pandapipes.create_pipe_from_parameters(net, 0, 1, 6.0, d, k_mm=.5, sections=1)
pandapipes.create_pipe_from_parameters(net, 1, 2, 6.0, d, k_mm=.5, sections=1)
pandapipes.create_pipe_from_parameters(net, 1, 3, 6.0, d, k_mm=.5, sections=1)
- pandapipes.create_ext_grid(net, 0, p_bar=51 - 1.01325, t_k=285.15, type="pt")
- pandapipes.create_sink(net, 2, mdot_kg_per_s=0.82752 * 45000 / 3600 / 3)
- pandapipes.create_sink(net, 3, mdot_kg_per_s=0.82752 * 45000 / 3600 / 2)
_add_fluid_to_net(net, pandapipes.create_constant_fluid(
name="natural_gas", fluid_type="gas", viscosity=11.93e-6, heat_capacity=2185,
compressibility=1, der_compressibility=0, density=0.82752
))
+ pandapipes.create_ext_grid(net, 0, p_bar=51 - 1.01325, t_k=285.15, fluid='natural_gas', type="pt")
+ pandapipes.create_sink(net, 2, mdot_kg_per_s=0.82752 * 45000 / 3600 / 3)
+ pandapipes.create_sink(net, 3, mdot_kg_per_s=0.82752 * 45000 / 3600 / 2)
+
pandapipes.pipeflow(net, stop_condition="tol", iter=70, friction_model="nikuradse",
transient=False, nonlinear_method="automatic", tol_p=1e-5, tol_v=1e-5,
use_numba=use_numba)
@@ -53,13 +54,13 @@ def test_pipe_velocity_results(use_numba):
pandapipes.create_pipe_from_parameters(net, 0, 1, 6.0, d, k_mm=.5, sections=3)
pandapipes.create_pipe_from_parameters(net, 1, 2, 6.0, d, k_mm=.5, sections=4)
pandapipes.create_pipe_from_parameters(net, 1, 3, 6.0, d, k_mm=.5, sections=2)
- pandapipes.create_ext_grid(net, 0, p_bar=51 - 1.01325, t_k=285.15, type="pt")
- pandapipes.create_sink(net, 2, mdot_kg_per_s=0.82752 * 45000 / 3600 / 3)
- pandapipes.create_sink(net, 3, mdot_kg_per_s=0.82752 * 45000 / 3600 / 2)
_add_fluid_to_net(net, pandapipes.create_constant_fluid(
name="natural_gas", fluid_type="gas", viscosity=11.93e-6, heat_capacity=2185,
compressibility=1, der_compressibility=0, density=0.82752
))
+ pandapipes.create_ext_grid(net, 0, p_bar=51 - 1.01325, t_k=285.15, fluid='natural_gas', type="pt")
+ pandapipes.create_sink(net, 2, mdot_kg_per_s=0.82752 * 45000 / 3600 / 3)
+ pandapipes.create_sink(net, 3, mdot_kg_per_s=0.82752 * 45000 / 3600 / 2)
pandapipes.pipeflow(net, stop_condition="tol", iter=70, friction_model="nikuradse",
transient=False, nonlinear_method="automatic", tol_p=1e-5, tol_v=1e-5,
use_numba=use_numba)
diff --git a/pandapipes/test/api/test_components/test_pressure_control.py b/pandapipes/test/api/test_components/test_pressure_control.py
index 2156be84..f93f241a 100644
--- a/pandapipes/test/api/test_components/test_pressure_control.py
+++ b/pandapipes/test/api/test_components/test_pressure_control.py
@@ -30,7 +30,7 @@ def test_pressure_control_from_measurement_parameters(use_numba):
pandapipes.create_pipe_from_parameters(net, j3, j4, k_mm=1., length_km=10.,
diameter_m=0.1022)
pandapipes.create_pressure_control(net, j1, j2, j4, 20.)
- pandapipes.create_ext_grid(net, j1, 5, 283.15, type="p")
+ pandapipes.create_ext_grid(net, j1, 5, 283.15, fluid='lgas', type="p")
pandapipes.create_sink(net, j4, 0.5)
pandapipes.create_fluid_from_lib(net, "lgas", overwrite=True)
diff --git a/pandapipes/test/api/test_components/test_pump.py b/pandapipes/test/api/test_components/test_pump.py
index 99a15fec..963e25a2 100644
--- a/pandapipes/test/api/test_components/test_pump.py
+++ b/pandapipes/test/api/test_components/test_pump.py
@@ -29,7 +29,7 @@ def test_pump_from_measurement_parameteres(use_numba):
diameter_m=0.1022)
pandapipes.create_pipe_from_parameters(net, j3, j4, k_mm=1., length_km=0.26370,
diameter_m=0.1022)
- pandapipes.create_ext_grid(net, j1, 5, 283.15, type="p")
+ pandapipes.create_ext_grid(net, j1, 5, 283.15, fluid='lgas', type="p")
pandapipes.create_pump_from_parameters(net, j2, j3, 'P1', [6.1, 5.8, 4], [0, 19, 83], 2)
pandapipes.create_sink(net, j4, 0.02333)
@@ -69,7 +69,7 @@ def test_pump_from_regression_parameteres(use_numba):
diameter_m=0.1022)
pandapipes.create_pipe_from_parameters(net, j3, j4, k_mm=1., length_km=0.26370,
diameter_m=0.1022)
- pandapipes.create_ext_grid(net, j1, 5, 283.15, type="p")
+ pandapipes.create_ext_grid(net, j1, 5, 283.15, fluid='lgas', type="p")
pandapipes.create_pump_from_parameters(net, j2, j3, 'P1',
poly_coefficents=[-1.48620799e-04, -1.29656785e-02,
6.10000000e+00])
@@ -109,7 +109,7 @@ def test_pump_from_std_type(use_numba):
pandapipes.create_pipe(net, j1, j2, std_type='125_PE_80_SDR_11', k_mm=1., length_km=0.43380)
pandapipes.create_pipe(net, j3, j4, std_type='125_PE_80_SDR_11', k_mm=1., length_km=0.26370)
- pandapipes.create_ext_grid(net, j1, 5, 283.15, type="p")
+ pandapipes.create_ext_grid(net, j1, 5, 283.15, fluid='lgas', type="p")
pandapipes.create_pump(net, j2, j3, std_type='P1')
pandapipes.create_sink(net, j4, 0.02333)
@@ -147,7 +147,7 @@ def test_pump_bypass_on_reverse_flow(use_numba):
pandapipes.create_pipe(net, j1, j2, std_type='125_PE_80_SDR_11', k_mm=1., length_km=10)
pandapipes.create_pipe(net, j3, j4, std_type='125_PE_80_SDR_11', k_mm=1., length_km=12)
- pandapipes.create_ext_grid(net, j1, 5, 283.15, type="p")
+ pandapipes.create_ext_grid(net, j1, 5, 283.15, fluid='hgas', type="p")
pandapipes.create_pump(net, j2, j3, std_type='P1')
pandapipes.create_source(net, j4, 0.02333)
@@ -177,7 +177,7 @@ def test_pump_bypass_high_vdot(use_numba):
pandapipes.create_pipe(net, j1, j2, std_type='2000_ST<16', k_mm=0.1, length_km=0.1)
pandapipes.create_pipe(net, j3, j4, std_type='2000_ST<16', k_mm=0.1, length_km=0.1)
- pandapipes.create_ext_grid(net, j1, 5, 283.15, type="p")
+ pandapipes.create_ext_grid(net, j1, 5, 283.15, fluid='hgas', type="p")
pandapipes.create_pump(net, j2, j3, std_type='P1')
pandapipes.create_sink(net, j4, 1000)
diff --git a/pandapipes/test/api/test_components/test_valve.py b/pandapipes/test/api/test_components/test_valve.py
index bb656ec9..aa5f50c1 100644
--- a/pandapipes/test/api/test_components/test_valve.py
+++ b/pandapipes/test/api/test_components/test_valve.py
@@ -29,7 +29,7 @@ def test_valve(use_numba):
j6 = pandapipes.create_junction(net, pn_bar=5, tfluid_k=283.15, index=4)
j7 = pandapipes.create_junction(net, pn_bar=5, tfluid_k=283.15, index=8)
- pandapipes.create_ext_grid(net, j0, 5, 283.15, type="p")
+ pandapipes.create_ext_grid(net, j0, 5, 283.15, fluid='lgas', type="p")
pandapipes.create_pipe_from_parameters(net, j0, j1, diameter_m=.1, k_mm=1, length_km=1.)
pandapipes.create_pipe_from_parameters(net, j3, j4, diameter_m=.1, k_mm=1, length_km=.5)
diff --git a/pandapipes/test/api/test_convert_format.py b/pandapipes/test/api/test_convert_format.py
index ef9c001d..0cee9d6b 100644
--- a/pandapipes/test/api/test_convert_format.py
+++ b/pandapipes/test/api/test_convert_format.py
@@ -2,11 +2,13 @@
# 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.
-from pandapipes import pp_dir
-import pandapipes as pp
-import numpy as np
import os
+
+import numpy as np
import pytest
+
+import pandapipes as pp
+from pandapipes import pp_dir
from pandapipes.io import convert_format
from itertools import product
@@ -17,6 +19,7 @@
test_params = list(product(found_versions, numba_usage))
+@pytest.mark.xfail()
@pytest.mark.slow
@pytest.mark.parametrize("version, use_numba", test_params)
def test_convert_format(version, use_numba):
diff --git a/pandapipes/test/api/test_create.py b/pandapipes/test/api/test_create.py
index 4f673810..d9f21e9c 100644
--- a/pandapipes/test/api/test_create.py
+++ b/pandapipes/test/api/test_create.py
@@ -15,9 +15,9 @@ def create_empty_net():
def test_create_network():
- net = pandapipes.create_empty_network(fluid=3)
+ net = pandapipes.create_empty_network()
with pytest.raises(AttributeError):
- pandapipes.get_fluid(net)
+ pandapipes.get_fluid(net, 'hgas')
def test_create_junction(create_empty_net):
@@ -75,7 +75,7 @@ def test_create_ext_grid(create_empty_net):
net = copy.deepcopy(create_empty_net)
pandapipes.create_junction(net, 1, 293, index=8)
pandapipes.create_junction(net, 1, 293, index=9)
- pandapipes.create_ext_grid(net, 9, p_bar=1, t_k=295, index=2)
+ pandapipes.create_ext_grid(net, 9, p_bar=1, t_k=295, index=2, fluid='lgas')
assert len(net.junction) == 2
assert len(net.ext_grid) == 1
@@ -85,9 +85,9 @@ def test_create_ext_grid(create_empty_net):
assert net.ext_grid.at[2, "t_k"] == 295
with pytest.raises(UserWarning):
- pandapipes.create_ext_grid(net, junction=10, p_bar=1, t_k=295)
+ pandapipes.create_ext_grid(net, junction=10, p_bar=1, t_k=295, fluid='hgas')
with pytest.raises(UserWarning):
- pandapipes.create_ext_grid(net, junction=9, p_bar=1, t_k=295, index=2)
+ pandapipes.create_ext_grid(net, junction=9, p_bar=1, t_k=295, index=2, fluid='hgas')
def test_create_heat_exchanger(create_empty_net):
@@ -134,7 +134,7 @@ def test_create_pipe(create_empty_net):
with pytest.raises(UserWarning):
pandapipes.create_pipe(net, 8, 9, "blah", 0.3)
- net2 = pandapipes.create_empty_network(fluid="hgas", add_stdtypes=False)
+ net2 = pandapipes.create_empty_network(add_stdtypes=False)
pandapipes.create_junction(net2, 1, 293, index=8, geodata=(0, 1))
pandapipes.create_junction(net2, 1, 293, index=9, geodata=(2, 2))
with pytest.raises(UserWarning):
@@ -210,7 +210,7 @@ def test_create_pump(create_empty_net):
with pytest.raises(ValueError):
pandapipes.create_pump(net, 8, 9, "P1", geodata=[(0, 1), (1, 1), (2, 2)])
- net2 = pandapipes.create_empty_network(fluid="hgas", add_stdtypes=False)
+ net2 = pandapipes.create_empty_network(add_stdtypes=False)
pandapipes.create_junction(net2, 1, 293, index=8, geodata=(0, 1))
pandapipes.create_junction(net2, 1, 293, index=9, geodata=(2, 2))
with pytest.raises(UserWarning):
diff --git a/pandapipes/test/api/test_network_tables.py b/pandapipes/test/api/test_network_tables.py
index 7e7e4e9e..d9f49e8e 100644
--- a/pandapipes/test/api/test_network_tables.py
+++ b/pandapipes/test/api/test_network_tables.py
@@ -7,6 +7,7 @@
import pandapipes
from pandapipes.component_models import Sink, Source, Pump, \
HeatExchanger, Valve, CirculationPumpPressure, CirculationPumpMass, PressureControlComponent
+from pandapipes.create_toolbox import add_new_component
def test_default_input_tables():
@@ -29,7 +30,7 @@ def test_default_input_tables():
assert pipe_input == pipe_input_create, "Input does not equal Table in create-function"
ext_grid_input = list(copy.deepcopy(net.ext_grid.columns))
- pandapipes.create_ext_grid(net, 0, p_bar=5, t_k=330, type="pt")
+ pandapipes.create_ext_grid(net, 0, p_bar=5, t_k=330, type="pt", fluid='hgas')
ext_grid_input_create = list(net.ext_grid.columns)
assert ext_grid_input == ext_grid_input_create, "Input does not equal Table in create-function"
@@ -39,49 +40,49 @@ def test_additional_tables():
pandapipes.create_junction(net, pn_bar=5, tfluid_k=283)
pandapipes.create_junction(net, pn_bar=5, tfluid_k=283)
- pandapipes.add_new_component(net, Sink)
+ add_new_component(net, Sink)
sink_input = list(copy.deepcopy(net.sink.columns))
pandapipes.create_sink(net, 1, mdot_kg_per_s=1)
sink_input_create = list(net.sink.columns)
assert sink_input == sink_input_create, "Input does not equal create-table"
- pandapipes.add_new_component(net, Source)
+ add_new_component(net, Source)
source_input = list(copy.deepcopy(net.source.columns))
pandapipes.create_source(net, 1, mdot_kg_per_s=1)
source_input_create = list(net.source.columns)
assert source_input == source_input_create, "Input does not equal create-table"
- pandapipes.add_new_component(net, Pump)
+ add_new_component(net, Pump)
pump_input = list(copy.deepcopy(net.pump.columns))
pandapipes.create_pump_from_parameters(net, 0, 1, 'P4', [6.1, 5.8, 4], [0, 19, 83], 2)
pump_input_create = list(net.pump.columns)
assert pump_input == pump_input_create, "Input does not equal create-table"
- pandapipes.add_new_component(net, CirculationPumpMass)
+ add_new_component(net, CirculationPumpMass)
pumpcircmass_input = list(copy.deepcopy(net.circ_pump_mass.columns))
pandapipes.create_circ_pump_const_mass_flow(net, 0, 1, 5, 5, 300, type='pt')
pumpcircmass_input_create = list(net.circ_pump_mass.columns)
assert pumpcircmass_input == pumpcircmass_input_create, "Input does not equal create-table"
- pandapipes.add_new_component(net, CirculationPumpPressure)
+ add_new_component(net, CirculationPumpPressure)
pumpcircpres_input = list(copy.deepcopy(net.circ_pump_pressure.columns))
pandapipes.create_circ_pump_const_pressure(net, 0, 1, 5, 2, 300, type='pt')
pumpcircpres_input_create = list(net.circ_pump_pressure.columns)
assert pumpcircpres_input == pumpcircpres_input_create, "Input does not equal create-table"
- pandapipes.add_new_component(net, Valve)
+ add_new_component(net, Valve)
valve_input = list(copy.deepcopy(net.valve.columns))
pandapipes.create_valve(net, 0, 1, diameter_m=0.1, opened=False)
valve_input_create = list(net.valve.columns)
assert valve_input == valve_input_create, "Input does not equal create-table"
- pandapipes.add_new_component(net, HeatExchanger)
+ add_new_component(net, HeatExchanger)
hex_input = list(copy.deepcopy(net.heat_exchanger.columns))
pandapipes.create_heat_exchanger(net, 0, 1, 0.2, qext_w=20000)
hex_input_create = list(net.heat_exchanger.columns)
assert hex_input == hex_input_create, "Input does not equal create-table"
- pandapipes.add_new_component(net, PressureControlComponent)
+ add_new_component(net, PressureControlComponent)
press_control_input = list(copy.deepcopy(net.press_control.columns))
pandapipes.create_pressure_control(net, 0, 1, 1, controlled_p_bar=5)
press_control_input_create = list(net.press_control.columns)
diff --git a/pandapipes/test/api/test_special_networks.py b/pandapipes/test/api/test_special_networks.py
index 8c248701..4fb116df 100644
--- a/pandapipes/test/api/test_special_networks.py
+++ b/pandapipes/test/api/test_special_networks.py
@@ -8,10 +8,11 @@
import pytest
import pandapipes
-from pandapipes.create import create_empty_network, create_junction, create_ext_grid, create_sink, \
- create_source
+from pandapipes import networks as nets_pps
+from pandapipes.create import create_empty_network, create_junction, create_ext_grid, create_sink, create_source, \
+ create_pipe_from_parameters, create_valve
from pandapipes.test.pipeflow_internals.test_inservice import create_test_net
-
+from pandapipes.properties.fluids import FluidPropertyConstant, Fluid, _add_fluid_to_net
@pytest.mark.parametrize("use_numba", [True, False])
def test_one_node_net(use_numba):
@@ -21,25 +22,438 @@ def test_one_node_net(use_numba):
:rtype:
"""
- net = create_empty_network(fluid='water')
+ net = create_empty_network()
j = create_junction(net, 1, 298.15)
- create_ext_grid(net, j, 1, 298.15)
+ create_ext_grid(net, j, 1, 298.15, fluid='water')
create_sink(net, j, 0.01)
- create_source(net, j, 0.02)
+ create_source(net, j, 0.02, fluid='water')
pandapipes.pipeflow(net, use_numba=use_numba)
assert np.isclose(net.res_ext_grid.values + net.res_sink.values - net.res_source.values, 0)
- net = create_empty_network(fluid='lgas')
+ net = create_empty_network()
j = create_junction(net, 1, 298.15)
- create_ext_grid(net, j, 1, 298.15)
+ create_ext_grid(net, j, 1, 298.15, fluid='lgas')
create_sink(net, j, 0.01)
- create_source(net, j, 0.02)
+ create_source(net, j, 0.02, fluid='lgas')
pandapipes.pipeflow(net, use_numba=use_numba)
assert np.isclose(net.res_ext_grid.values + net.res_sink.values - net.res_source.values, 0)
+def simple_fluid(net):
+ fluid_name = 'fluid1'
+ dens = FluidPropertyConstant(0.1)
+ visc = FluidPropertyConstant(0.01)
+ heat = FluidPropertyConstant(10)
+ mass = FluidPropertyConstant(1)
+ higc = FluidPropertyConstant(2)
+ lowc = FluidPropertyConstant(1)
+ derc = FluidPropertyConstant(0)
+ comp = FluidPropertyConstant(0.001)
+ fluid1 = Fluid(fluid_name, 'gas', density=dens, viscosity=visc, heat_capacity=heat, molar_mass=mass,
+ der_compressibility=derc, compressibility=comp, hhv=higc, lhv=lowc)
+ _add_fluid_to_net(net, fluid1)
+
+ fluid_name = 'fluid2'
+ dens = FluidPropertyConstant(0.2)
+ visc = FluidPropertyConstant(0.02)
+ heat = FluidPropertyConstant(20)
+ mass = FluidPropertyConstant(2)
+ higc = FluidPropertyConstant(4)
+ lowc = FluidPropertyConstant(2)
+ derc = FluidPropertyConstant(0)
+ comp = FluidPropertyConstant(0.002)
+ fluid2 = Fluid(fluid_name, 'gas', density=dens, viscosity=visc, heat_capacity=heat, molar_mass=mass,
+ der_compressibility=derc, compressibility=comp, hhv=higc, lhv=lowc)
+ _add_fluid_to_net(net, fluid2)
+
+ fluid_name = 'fluid3'
+ dens = FluidPropertyConstant(0.3)
+ visc = FluidPropertyConstant(0.03)
+ heat = FluidPropertyConstant(30)
+ mass = FluidPropertyConstant(3)
+ higc = FluidPropertyConstant(6)
+ lowc = FluidPropertyConstant(3)
+ derc = FluidPropertyConstant(0)
+ comp = FluidPropertyConstant(0.003)
+ fluid3 = Fluid(fluid_name, 'gas', density=dens, viscosity=visc, heat_capacity=heat, molar_mass=mass,
+ der_compressibility=derc, compressibility=comp, hhv=higc, lhv=lowc)
+ _add_fluid_to_net(net, fluid3)
+
+
+def same_fluid_twice_defined(net):
+ fluid_name = 'fluid1'
+ dens = FluidPropertyConstant(0.1)
+ visc = FluidPropertyConstant(0.01)
+ heat = FluidPropertyConstant(10)
+ mass = FluidPropertyConstant(1)
+ higc = FluidPropertyConstant(2)
+ lowc = FluidPropertyConstant(1)
+ derc = FluidPropertyConstant(0)
+ comp = FluidPropertyConstant(0.001)
+ fluid1 = Fluid(fluid_name, 'gas', density=dens, viscosity=visc, heat_capacity=heat, molar_mass=mass,
+ der_compressibility=derc, compressibility=comp, hhv=higc, lhv=lowc)
+ _add_fluid_to_net(net, fluid1)
+
+ fluid_name = 'fluid2'
+ dens = FluidPropertyConstant(0.1)
+ visc = FluidPropertyConstant(0.01)
+ heat = FluidPropertyConstant(10)
+ mass = FluidPropertyConstant(1)
+ higc = FluidPropertyConstant(2)
+ lowc = FluidPropertyConstant(1)
+ derc = FluidPropertyConstant(0)
+ comp = FluidPropertyConstant(0.001)
+ fluid2 = Fluid(fluid_name, 'gas', density=dens, viscosity=visc, heat_capacity=heat, molar_mass=mass,
+ der_compressibility=derc, compressibility=comp, hhv=higc, lhv=lowc)
+ _add_fluid_to_net(net, fluid2)
+
+
+@pytest.mark.parametrize("use_numba", [True, False])
+def test_two_fluids_grid_simple_gases(use_numba):
+ """
+
+ :return:
+ :rtype:
+ """
+ import logging
+ logger = logging.getLogger()
+ logger.setLevel("DEBUG")
+ logger.debug('external grid')
+
+ net = create_empty_network()
+ j1 = create_junction(net, 1, 298.15, index=50)
+ j2 = create_junction(net, 1, 298.15, index=52)
+ simple_fluid(net)
+
+ create_ext_grid(net, j1, 1, 298.15, fluid='fluid2', index=102)
+ create_sink(net, j2, 0.5)
+ create_source(net, j1, 0.3, fluid='fluid1')
+ create_pipe_from_parameters(net, j1, j2, 1, 10, np.pi)
+ pandapipes.pipeflow(net, tol_p=1e-4, tol_v=1e-4, tol_m=1e-10, tol_w=1e-6, iter=400,
+ use_numba=use_numba)
+
+ assert np.isclose(net.res_ext_grid.values.sum() + net.res_sink.values.sum() - net.res_source.values.sum(), 0)
+
+
+@pytest.mark.parametrize("use_numba", [True, False])
+def test_three_fluids_grid_simple_gases(use_numba):
+ """
+
+ :return:
+ :rtype:
+ """
+ net = create_empty_network()
+ j1 = create_junction(net, 1, 298.15, index=50)
+ j2 = create_junction(net, 1, 298.15, index=52)
+ simple_fluid(net)
+
+ create_ext_grid(net, j1, 1, 298.15, fluid='fluid1', index=102)
+ create_sink(net, j2, 0.5)
+ create_source(net, j1, 0.1, fluid='fluid2')
+ create_source(net, j1, 0.2, fluid='fluid3')
+ create_pipe_from_parameters(net, j1, j2, 1, 10, np.pi)
+ pandapipes.pipeflow(net, tol_p=1e-4, tol_v=1e-4, tol_m=1e-10, tol_w=1e-6, iter=400,
+ use_numba=use_numba)
+
+ assert np.isclose(net.res_ext_grid.values.sum() + net.res_sink.values.sum() - net.res_source.values.sum(), 0)
+
+
+@pytest.mark.parametrize("use_numba", [True, False])
+def test_two_fluids_grid_simple(use_numba):
+ """
+
+ :return:
+ :rtype:
+ """
+ net = create_empty_network()
+ j1 = create_junction(net, 1, 298.15, index=50)
+ j2 = create_junction(net, 1, 298.15, index=52)
+ create_ext_grid(net, j1, 1, 298.15, fluid='lgas', index=102)
+ create_sink(net, j2, 0.08)
+ create_source(net, j1, 0.03, fluid='hydrogen')
+ create_pipe_from_parameters(net, j1, j2, 0.5, 0.1, 0.01)
+ pandapipes.pipeflow(net, tol_p=1e-4, tol_v=1e-4, tol_m=1e-10, tol_w=1e-6, iter=400,
+ use_numba=use_numba)
+
+ assert np.isclose(net.res_ext_grid.values.sum() + net.res_sink.values.sum() - net.res_source.values.sum(), 0)
+
+
+@pytest.mark.parametrize("use_numba", [True, False])
+def test_three_fluids_grid_simple(use_numba):
+ """
+
+ :return:
+ :rtype:
+ """
+ net = create_empty_network()
+ j1 = create_junction(net, 1, 298.15, index=50)
+ j2 = create_junction(net, 1, 298.15, index=52)
+ create_ext_grid(net, j1, 1, 298.15, fluid='lgas', index=102)
+ create_sink(net, j2, 0.08)
+ create_source(net, j1, 0.03, fluid='hydrogen')
+ create_source(net, j1, 0.01, fluid='hgas')
+ create_pipe_from_parameters(net, j1, j2, 1, np.pi, 0.01)
+ pandapipes.pipeflow(net, tol_p=1e-4, tol_v=1e-4, tol_m=1e-10, tol_w=1e-6, iter=400,
+ use_numba=use_numba)
+
+ assert np.isclose(net.res_ext_grid.values.sum() + net.res_sink.values.sum() - net.res_source.values.sum(), 0)
+
+
+@pytest.mark.parametrize("use_numba", [True, False])
+def test_four_fluids_grid_simple(use_numba):
+ """
+
+ :return:
+ :rtype:
+ """
+ net = create_empty_network()
+ j1 = create_junction(net, 1, 298.15, index=50)
+ j2 = create_junction(net, 1, 298.15, index=52)
+ create_ext_grid(net, j1, 1, 298.15, fluid='lgas', index=102)
+ create_sink(net, j2, 0.08)
+ create_source(net, j1, 0.03, fluid='hydrogen')
+ create_source(net, j1, 0.01, fluid='hgas')
+ create_source(net, j1, 0.01, fluid='butane')
+ create_pipe_from_parameters(net, j1, j2, 1, np.pi, 0.01)
+ pandapipes.pipeflow(net, tol_p=1e-4, tol_v=1e-4, tol_m=1e-10, tol_w=1e-6, iter=400,
+ use_numba=use_numba)
+
+ assert np.isclose(net.res_ext_grid.values.sum() + net.res_sink.values.sum() - net.res_source.values.sum(), 0)
+
+
+@pytest.mark.parametrize("use_numba", [True, False])
+def test_two_fluids_two_pipes_grid_simple(use_numba):
+ """
+
+ :return:
+ :rtype:
+ """
+
+ net = create_empty_network()
+ j1 = create_junction(net, 1, 298.15, index=50)
+ j2 = create_junction(net, 1, 298.15, index=52)
+ j3 = create_junction(net, 1, 298.15, index=54)
+ create_ext_grid(net, j1, 1, 298.15, fluid='lgas', index=102)
+ create_sink(net, j3, 0.08)
+ create_source(net, j1, 0.03, fluid='hydrogen')
+ create_pipe_from_parameters(net, j2, j1, 0.01, np.pi, 0.01)
+ create_pipe_from_parameters(net, j3, j2, 0.01, np.pi, 0.01)
+ pandapipes.pipeflow(net, tol_p=1e-4, tol_v=1e-4, tol_m=1e-10, tol_w=1e-6, iter=400,
+ use_numba=use_numba)
+
+ assert np.isclose(net.res_ext_grid.values.sum() + net.res_sink.values.sum() - net.res_source.values.sum(), 0)
+
+
+@pytest.mark.parametrize("use_numba", [True, False])
+def test_multiple_fluids_grid_line_ascending(use_numba):
+ """
+
+ :return:
+ :rtype:
+ """
+ net = create_empty_network()
+ j1 = create_junction(net, 1, 298.15, index=50)
+ j2 = create_junction(net, 1, 298.15, index=52)
+ j3 = create_junction(net, 1, 298.15, index=54)
+ create_ext_grid(net, j1, 1, 298.15, fluid='lgas', index=102)
+ create_sink(net, j3, 0.08)
+ create_source(net, j1, 0.03, fluid='hydrogen')
+ create_source(net, j1, 0.01, fluid='butane')
+ # create_source(net, j1, 0.01, fluid='hgas')
+ create_pipe_from_parameters(net, j1, j2, 0.01, np.pi, 0.01)
+ create_pipe_from_parameters(net, j2, j3, 0.01, np.pi, 0.01)
+ pandapipes.pipeflow(net, tol_p=1e-4, tol_v=1e-4, tol_m=1e-10, tol_w=1e-6, iter=400,
+ use_numba=use_numba)
+
+ assert np.isclose(net.res_ext_grid.values.sum() + net.res_sink.values.sum() - net.res_source.values.sum(), 0)
+
+
+@pytest.mark.parametrize("use_numba", [True, False])
+def test_multiple_fluids_grid(use_numba):
+ """
+
+ :return:
+ :rtype:
+ """
+
+ net = create_empty_network()
+ j1 = create_junction(net, 1, 298.15, index=50)
+ j2 = create_junction(net, 1, 298.15, index=52)
+ j3 = create_junction(net, 1, 298.15, index=54)
+ create_ext_grid(net, j1, 1, 298.15, fluid='lgas', index=102)
+ create_sink(net, j3, 0.08)
+ create_source(net, j2, 0.03, fluid='hydrogen')
+ create_source(net, j1, 0.01, fluid='butane')
+ create_source(net, j1, 0.01, fluid='hgas')
+ create_pipe_from_parameters(net, j2, j1, 0.01, np.pi, 0.01)
+ create_pipe_from_parameters(net, j3, j2, 0.01, np.pi, 0.01)
+ pandapipes.pipeflow(net, tol_p=1e-4, tol_v=1e-4, tol_m=1e-10, tol_w=1e-6, iter=400,
+ use_numba=use_numba)
+
+ assert np.isclose(net.res_ext_grid.values.sum() + net.res_sink.values.sum() - net.res_source.values.sum(), 0)
+
+
+@pytest.mark.parametrize("use_numba", [True, False])
+def test_multiple_fluids_grid_mesehd_valve(use_numba):
+ """
+
+ :return:
+ :rtype:
+ """
+
+ net = create_empty_network()
+ j1 = create_junction(net, 1, 298.15, index=50)
+ j2 = create_junction(net, 1, 298.15, index=52)
+ j3 = create_junction(net, 1, 298.15, index=54)
+ j4 = create_junction(net, 1, 298.15, index=55)
+ create_ext_grid(net, j1, 1, 298.15, fluid='lgas', index=102)
+ create_sink(net, j4, 0.08)
+ create_source(net, j1, 0.03, fluid='hydrogen')
+ create_pipe_from_parameters(net, j1, j2, 0.01, np.pi, 0.01)
+ create_pipe_from_parameters(net, j2, j3, 0.01, np.pi, 0.01)
+ create_pipe_from_parameters(net, j3, j4, 0.01, np.pi, 0.01)
+ create_pipe_from_parameters(net, j4, j1, 0.01, np.pi, 0.01)
+ pandapipes.pipeflow(net, tol_p=1e-4, tol_v=1e-4, tol_m=1e-10, tol_w=1e-6, iter=400,
+ use_numba=use_numba)
+
+ assert np.isclose(net.res_ext_grid.values.sum() + net.res_sink.values.sum() - net.res_source.values.sum(), 0)
+
+
+@pytest.mark.parametrize("use_numba", [True, False])
+def test_multiple_fluids_grid_source(use_numba):
+ """
+
+ :return:
+ :rtype:
+ """
+ net = create_empty_network()
+ j1 = create_junction(net, 1, 298.15, index=50)
+ j2 = create_junction(net, 1, 298.15, index=52)
+ j3 = create_junction(net, 1, 298.15, index=54)
+ create_ext_grid(net, j1, 1, 298.15, fluid='lgas', index=102)
+ create_sink(net, j3, 0.08)
+ create_source(net, j2, 0.03, fluid='hydrogen')
+ create_pipe_from_parameters(net, j1, j2, 1, np.pi, 0.01)
+ create_pipe_from_parameters(net, j2, j3, 1, np.pi, 0.01)
+ pandapipes.pipeflow(net, tol_p=1e-4, tol_v=1e-4, tol_m=1e-10, tol_w=1e-6, iter=400,
+ use_numba=use_numba)
+ assert np.isclose(net.res_ext_grid.values.sum() + net.res_sink.values.sum() - net.res_source.values.sum(), 0)
+
+
+@pytest.mark.parametrize("use_numba", [True, False])
+def test_multiple_fluids_grid_feed_back(use_numba):
+ """
+
+ :return:
+ :rtype:
+ """
+ net = create_empty_network()
+ j1 = create_junction(net, 1, 298.15, index=50)
+ j2 = create_junction(net, 1, 298.15, index=52)
+ create_ext_grid(net, j1, 1, 298.15, fluid='lgas', index=102)
+ create_sink(net, j2, 0.08)
+ create_source(net, j1, 0.1, fluid='hydrogen')
+ create_pipe_from_parameters(net, j1, j2, 1, np.pi, 0.01)
+ pandapipes.pipeflow(net, tol_p=1e-4, tol_v=1e-4, tol_m=1e-10, tol_w=1e-6, iter=400,
+ use_numba=use_numba)
+ assert np.isclose(net.res_ext_grid.values.sum() + net.res_sink.values.sum() - net.res_source.values.sum(), 0)
+
+
+@pytest.mark.parametrize("use_numba", [True, False])
+def test_multiple_fluids_feeder(use_numba):
+ """
+
+ :return:
+ :rtype:
+ """
+
+ net = create_empty_network()
+ j1 = create_junction(net, 1, 298.15, index=50)
+ j2 = create_junction(net, 1, 298.15, index=52)
+ j3 = create_junction(net, 1, 298.15, index=54)
+ j4 = create_junction(net, 1, 298.15, index=56)
+ j5 = create_junction(net, 1, 298.15, index=58)
+ j6 = create_junction(net, 1, 298.15, index=60)
+ j7 = create_junction(net, 1, 298.15, index=62)
+ j8 = create_junction(net, 1, 298.15, index=64)
+ j9 = create_junction(net, 1, 298.15, index=66)
+
+ create_ext_grid(net, j1, 1, 298.15, fluid='lgas', index=102)
+ create_source(net, j1, 0.1, fluid='hydrogen')
+ create_sink(net, j3, 0.08)
+ create_sink(net, j4, 0.08)
+ create_sink(net, j5, 0.08)
+ create_sink(net, j6, 0.08)
+ create_sink(net, j8, 0.08)
+ create_sink(net, j9, 0.08)
+
+ create_pipe_from_parameters(net, j1, j2, 1, np.pi, 0.01)
+ create_pipe_from_parameters(net, j2, j3, 1, np.pi, 0.01)
+ create_pipe_from_parameters(net, j2, j4, 1, np.pi, 0.01)
+ create_pipe_from_parameters(net, j4, j5, 1, np.pi, 0.01)
+ create_pipe_from_parameters(net, j1, j6, 1, np.pi, 0.01)
+ create_valve(net, j7, j1, np.pi)
+ create_valve(net, j9, j1, np.pi)
+ create_pipe_from_parameters(net, j8, j7, 1, np.pi, 0.01)
+
+ pandapipes.pipeflow(net, tol_p=1e-4, tol_v=1e-4, tol_m=1e-10, tol_w=1e-6, iter=400,
+ use_numba=use_numba)
+ assert np.isclose(net.res_ext_grid.values.sum() + net.res_sink.values.sum() - net.res_source.values.sum(), 0)
+
+
+@pytest.mark.parametrize("use_numba", [True, False])
+def test_multiple_fluids_grid_valve(use_numba):
+ """
+
+ :return:
+ :rtype:
+ """
+
+ net = create_empty_network()
+ j1 = create_junction(net, 1, 298.15, index=50)
+ j2 = create_junction(net, 1, 298.15, index=52)
+ j3 = create_junction(net, 1, 298.15, index=54)
+ j4 = create_junction(net, 1, 298.15, index=55)
+ create_ext_grid(net, j1, 1, 298.15, fluid='lgas', index=102)
+ create_sink(net, j4, 0.08)
+ create_source(net, j1, 0.03, fluid='hydrogen')
+ create_pipe_from_parameters(net, j1, j2, 0.01, np.pi, 0.01)
+ create_valve(net, j3, j2, 0.01)
+ create_pipe_from_parameters(net, j3, j4, 0.01, np.pi, 0.01)
+ create_pipe_from_parameters(net, j4, j1, 0.01, np.pi, 0.01)
+ pandapipes.pipeflow(net, tol_p=1e-4, tol_v=1e-4, tol_m=1e-10, tol_w=1e-6, iter=400,
+ use_numba=use_numba)
+ assert np.isclose(net.res_ext_grid.values.sum() + net.res_sink.values.sum() - net.res_source.values.sum(), 0)
+
+
+@pytest.mark.parametrize("use_numba", [True, False])
+def test_two_node_net_with_two_different_fluids(use_numba):
+ """
+
+ :return:
+ :rtype:
+ """
+
+ net = create_empty_network()
+ j1 = create_junction(net, 1, 298.15, index=51)
+ j2 = create_junction(net, 1, 298.15, index=52)
+ create_ext_grid(net, j1, 1, 298.15, fluid='hgas', index=100)
+ # create_ext_grid(net, j1, 1, 298.15, fluid='lgas', index=101)
+ create_source(net, j1, 0.03, fluid='hydrogen', index=100)
+ create_source(net, j1, 0.01, fluid='lgas', index=101)
+ create_source(net, j1, 0.01, fluid='methane', index=102)
+ create_source(net, j1, 0.01, fluid='propane', index=103)
+ create_source(net, j1, 0.01, fluid='butane', index=104)
+ create_source(net, j1, 0.01, fluid='hgas', index=105)
+ create_sink(net, j2, 0.01, index=100)
+ create_pipe_from_parameters(net, j1, j2, 0.01, np.pi, 0.01)
+ pandapipes.pipeflow(net, tol_p=1e-4, tol_v=1e-4, tol_m=1e-8, tol_w=1e-8, iter=1000,
+ use_numba=use_numba)
+ assert np.isclose(net.res_ext_grid.values.sum() + net.res_sink.values.sum() - net.res_source.values.sum(), 0)
+
+
@pytest.mark.parametrize("use_numba", [True, False])
def test_two_node_net(use_numba):
"""
@@ -48,29 +462,29 @@ def test_two_node_net(use_numba):
:rtype:
"""
- net = create_empty_network(fluid='water')
+ net = create_empty_network()
j = create_junction(net, 1, 298.15)
- create_ext_grid(net, j, 1, 298.15)
+ create_ext_grid(net, j, 1, 298.15, fluid='water')
create_sink(net, j, 0.01)
- create_source(net, j, 0.02)
+ create_source(net, j, 0.02, fluid='water')
j = create_junction(net, 1, 298.15)
- create_ext_grid(net, j, 1, 298.15)
+ create_ext_grid(net, j, 1, 298.15, fluid='water')
create_sink(net, j, 0.01)
- create_source(net, j, 0.02)
+ create_source(net, j, 0.02, fluid='water')
pandapipes.pipeflow(net, use_numba=use_numba)
assert np.all(np.isclose(net.res_ext_grid.values + net.res_sink.values - net.res_source.values,
np.zeros((2, 1))))
- net = create_empty_network(fluid='lgas')
+ net = create_empty_network()
j = create_junction(net, 1, 298.15)
- create_ext_grid(net, j, 1, 298.15)
+ create_ext_grid(net, j, 1, 298.15, fluid='lgas')
create_sink(net, j, 0.01)
- create_source(net, j, 0.02)
+ create_source(net, j, 0.02, fluid='lgas')
j = create_junction(net, 1, 298.15)
- create_ext_grid(net, j, 1, 298.15)
+ create_ext_grid(net, j, 1, 298.15, fluid='lgas')
create_sink(net, j, 0.01)
- create_source(net, j, 0.02)
+ create_source(net, j, 0.02, fluid='lgas')
pandapipes.pipeflow(net, use_numba=use_numba)
assert np.all(np.isclose(net.res_ext_grid.values + net.res_sink.values - net.res_source.values,
@@ -92,9 +506,10 @@ def test_random_net_and_one_node_net(create_test_net, use_numba):
pandapipes.create_fluid_from_lib(net, "water")
j = create_junction(net, 1, 298.15)
- create_ext_grid(net, j, 1, 298.15)
+ net.ext_grid.fluid = 'water'
+ create_ext_grid(net, j, 1, 298.15, fluid='water')
create_sink(net, j, 0.01)
- create_source(net, j, 0.02)
+ create_source(net, j, 0.02, fluid='water')
pandapipes.pipeflow(net, use_numba=use_numba)
net = copy.deepcopy(create_test_net)
@@ -102,14 +517,55 @@ def test_random_net_and_one_node_net(create_test_net, use_numba):
pandapipes.create_fluid_from_lib(net, "lgas")
j = create_junction(net, 1, 298.15)
- create_ext_grid(net, j, 1, 298.15)
+ net.ext_grid.fluid = 'lgas'
+ create_ext_grid(net, j, 1, 298.15, fluid='lgas')
create_sink(net, j, 0.01)
- create_source(net, j, 0.02)
+ create_source(net, j, 0.02, fluid='lgas')
pandapipes.pipeflow(net, use_numba=use_numba)
assert np.isclose(
net.res_ext_grid.values[-1] + net.res_sink.values[-1] - net.res_source.values[-1], 0)
+@pytest.mark.parametrize("use_numba", [True, False])
+def test_multiple_fluids_sink_source(use_numba):
+ net = pandapipes.create_empty_network()
+ same_fluid_twice_defined(net)
+ j1 = pandapipes.create_junction(net, 1, 273)
+ j2 = pandapipes.create_junction(net, 1, 273)
+ j3 = pandapipes.create_junction(net, 1, 273)
+ pandapipes.create_ext_grid(net, j1, 1, 273, 'fluid1')
+ pandapipes.create_pipe_from_parameters(net, j1, j2, 1, 0.1, 0.1)
+ pandapipes.create_pipe_from_parameters(net, j2, j3, 1, 0.1, 0.1)
+ pandapipes.create_sink(net, j3, 0.05)
+ pandapipes.create_source(net, j2, 0.01, 'fluid2')
+ pandapipes.create_source(net, j3, 0.02, 'fluid2')
+ pandapipes.pipeflow(net, iter=100, use_numba=use_numba)
+ assert all(net.res_junction.w_fluid1.values == [1., 0.666667, 0.4])
+
+
+def test_schutterwald_hydrogen():
+ net = nets_pps.schutterwald()
+ pandapipes.create_sources(net, [5, 168, 193], 6.6e-3, 'hydrogen')
+ pandapipes.pipeflow(net, iter=100)
+
+
+@pytest.mark.xfail
+def test_t_cross_mixture():
+ net = pandapipes.create_empty_network()
+ j1 = pandapipes.create_junction(net, 1, 273)
+ j2 = pandapipes.create_junction(net, 1, 273)
+ j3 = pandapipes.create_junction(net, 1, 273)
+ j4 = pandapipes.create_junction(net, 1, 273)
+ pandapipes.create_ext_grid(net, j1, 1, 273, 'hgas')
+ pandapipes.create_pipe_from_parameters(net, j1, j2, 1, 0.1, 0.1)
+ pandapipes.create_pipe_from_parameters(net, j2, j3, 1, 0.1, 0.1)
+ pandapipes.create_pipe_from_parameters(net, j2, j4, 1, 0.1, 0.1)
+ pandapipes.create_sink(net, j3, 0.01)
+ pandapipes.create_sink(net, j4, 0.02)
+ pandapipes.create_source(net, j3, 0.02, 'lgas')
+ pandapipes.create_source(net, j4, 0.03, 'hydrogen')
+ pandapipes.pipeflow(net, iter=100, use_numba=False)
+
if __name__ == "__main__":
pytest.main([r'pandapipes/test/api/test_special_networks.py'])
diff --git a/pandapipes/test/io/test_file_io.py b/pandapipes/test/io/test_file_io.py
index 42ed92aa..37d3b0cd 100644
--- a/pandapipes/test/io/test_file_io.py
+++ b/pandapipes/test/io/test_file_io.py
@@ -17,7 +17,7 @@
def load_net():
# create test network
- net = pandapipes.create_empty_network("test_net", fluid="lgas")
+ net = pandapipes.create_empty_network("test_net")
j1 = pandapipes.create_junction(net, pn_bar=1.05, tfluid_k=293.15,
name="Connection to External Grid", geodata=(0, 0))
j2 = pandapipes.create_junction(net, pn_bar=1.05, tfluid_k=293.15, name="Junction 2",
@@ -31,7 +31,7 @@ def load_net():
j6 = pandapipes.create_junction(net, pn_bar=1.05, tfluid_k=293.15, name="Junction 6",
geodata=(5, -3))
- pandapipes.create_ext_grid(net, junction=j1, p_bar=1.1, t_k=293.15, name="Grid Connection")
+ pandapipes.create_ext_grid(net, junction=j1, p_bar=1.1, t_k=293.15, fluid='lgas', name="Grid Connection")
pandapipes.create_pipe_from_parameters(net, from_junction=j1, to_junction=j2, length_km=10,
diameter_m=0.05, name="Pipe 1", geodata=[(0, 0), (2, 0)])
diff --git a/pandapipes/test/multinet/test_control_multinet.py b/pandapipes/test/multinet/test_control_multinet.py
index 9813daf2..59bd06d9 100644
--- a/pandapipes/test/multinet/test_control_multinet.py
+++ b/pandapipes/test/multinet/test_control_multinet.py
@@ -5,17 +5,18 @@
import copy
import numpy as np
-import pandapower
import pytest
-from pandapower import networks as e_nw
-from pandapower.control.controller.const_control import ConstControl
import pandapipes
+import pandapower
from pandapipes import networks as g_nw
-from pandapipes.multinet.control.controller.multinet_control import P2GControlMultiEnergy, \
- G2PControlMultiEnergy, GasToGasConversion, coupled_p2g_const_control
+from pandapipes.multinet.control.controller.multinet_control import P2GControlMultiEnergy, G2PControlMultiEnergy, \
+ GasToGasConversion, coupled_p2g_const_control
from pandapipes.multinet.control.run_control_multinet import run_control
from pandapipes.multinet.create_multinet import create_empty_multinet, add_nets_to_multinet
+from pandapower import networks as e_nw
+from pandapower.control.controller.const_control import ConstControl
+from pandapipes.properties import get_fluid
from pandapipes.test import runpp_with_mark, pipeflow_with_mark
@@ -23,6 +24,7 @@
def get_gas_example():
net_gas = g_nw.gas_meshed_square()
pandapipes.create_fluid_from_lib(net_gas, "hgas", overwrite=True)
+ net_gas.ext_grid.fluid.values[:] = 'hgas'
net_gas.sink.drop(index=0, inplace=True)
net_gas.junction.pn_bar = 30
net_gas.ext_grid.p_bar = 30
@@ -46,7 +48,7 @@ def test_p2g_single(get_gas_example, get_power_example_simple):
# get the nets
net_gas = copy.deepcopy(get_gas_example)
net_power = copy.deepcopy(get_power_example_simple)
- assert pandapipes.get_fluid(net_gas).name == "hgas"
+ assert pandapipes.get_fluid(net_gas, 'hgas').name == "hgas"
# set up multinet
mn = create_empty_multinet("test_p2g")
@@ -63,6 +65,8 @@ def test_p2g_single(get_gas_example, get_power_example_simple):
run_control(mn)
+ fluid = get_fluid(net_gas, 'hgas')
+
# nets must not be changed
assert mn.nets["power"] == net_power
assert mn.nets["gas"] == net_gas
@@ -71,7 +75,7 @@ def test_p2g_single(get_gas_example, get_power_example_simple):
assert net_gas.source.at[p2g_id_gas, "mdot_kg_per_s"] == \
net_gas.res_source.at[p2g_id_gas, "mdot_kg_per_s"]
assert np.isclose(net_gas.source.at[p2g_id_gas, "mdot_kg_per_s"],
- (p_p2g_el/(net_gas.fluid.get_property('hhv') * 3.6)) * eta)
+ (p_p2g_el / (fluid.get_property('hhv') * 3.6)) * eta)
assert net_power.load.at[p2g_id_el, "p_mw"] == p_p2g_el # has to be still the same
# check scaling functionality
@@ -79,7 +83,7 @@ def test_p2g_single(get_gas_example, get_power_example_simple):
net_power.load.loc[p2g_id_el, 'scaling'] = scaling_factor
run_control(mn)
assert np.isclose(net_gas.source.at[p2g_id_gas, "mdot_kg_per_s"],
- p_p2g_el * scaling_factor / (net_gas.fluid.get_property('hhv') * 3.6) * eta)
+ (p_p2g_el * scaling_factor / (fluid.get_property('hhv') * 3.6)) * eta)
assert net_power.load.at[p2g_id_el, "p_mw"] == p_p2g_el # has to be still the same
@@ -88,7 +92,7 @@ def test_g2p_single(get_gas_example, get_power_example_simple):
# get the nets
net_gas = copy.deepcopy(get_gas_example)
net_power = copy.deepcopy(get_power_example_simple)
- assert pandapipes.get_fluid(net_gas).name == "hgas"
+ assert pandapipes.get_fluid(net_gas, 'hgas').name == "hgas"
# set up multinet
mn = create_empty_multinet("test_g2p")
@@ -106,6 +110,8 @@ def test_g2p_single(get_gas_example, get_power_example_simple):
run_control(mn)
+ fluid = get_fluid(net_gas, 'hgas')
+
# nets must not be changed
assert mn.nets["power"] == net_power
assert mn.nets["gas"] == net_gas
@@ -114,7 +120,7 @@ def test_g2p_single(get_gas_example, get_power_example_simple):
assert net_power.sgen.at[g2p_id_el, "p_mw"] == \
net_power.res_sgen.at[g2p_id_el, "p_mw"]
assert np.isclose(net_power.sgen.at[g2p_id_el, "p_mw"],
- gas_cons_kg_per_s * net_gas.fluid.get_property("hhv") * 3600 / 1000 * eta)
+ gas_cons_kg_per_s * fluid.get_property("hhv") * 3600 / 1000 * eta)
assert net_gas.sink.at[g2p_id_gas, "mdot_kg_per_s"] == gas_cons_kg_per_s
# check scaling functionality
@@ -122,7 +128,7 @@ def test_g2p_single(get_gas_example, get_power_example_simple):
net_gas.sink.loc[g2p_id_gas, 'scaling'] = scaling_factor
run_control(mn)
assert np.isclose(net_power.sgen.at[g2p_id_el, "p_mw"],
- gas_cons_kg_per_s * scaling_factor * net_gas.fluid.get_property("hhv")
+ gas_cons_kg_per_s * scaling_factor * fluid.get_property("hhv")
* 3.6 * eta)
assert net_gas.sink.at[g2p_id_gas, "mdot_kg_per_s"] == gas_cons_kg_per_s
@@ -135,6 +141,7 @@ def test_g2g_single(get_gas_example):
net_gas2 = copy.deepcopy(get_gas_example)
pandapipes.create_fluid_from_lib(net_gas2, "hydrogen", overwrite=True)
+ net_gas2.ext_grid.fluid = 'hydrogen'
# set up multinet
mn = create_empty_multinet("test_g2g")
@@ -144,7 +151,7 @@ def test_g2g_single(get_gas_example):
gas1_cons_kg_per_s = 0.5
g2g_id_cons = pandapipes.create_sink(net_gas1, 1, mdot_kg_per_s=gas1_cons_kg_per_s,
name="SMR consumption")
- g2g_id_prod = pandapipes.create_source(net_gas2, 1, 0, name="SMR production")
+ g2g_id_prod = pandapipes.create_source(net_gas2, 1, 0, 'hydrogen', name="SMR production")
# add coupling controller
eta = 0.65
@@ -153,8 +160,8 @@ def test_g2g_single(get_gas_example):
run_control(mn)
- fluid1 = pandapipes.get_fluid(net_gas1)
- fluid2 = pandapipes.get_fluid(net_gas2)
+ fluid1 = pandapipes.get_fluid(net_gas1, 'hgas')
+ fluid2 = pandapipes.get_fluid(net_gas2, 'hydrogen')
# nets must not be changed
assert mn.nets["hgas_net"] == net_gas1
@@ -182,7 +189,7 @@ def test_p2g_multiple(get_gas_example, get_power_example_simple):
# get the nets
net_gas = copy.deepcopy(get_gas_example)
net_power = copy.deepcopy(get_power_example_simple)
- assert pandapipes.get_fluid(net_gas).name == "hgas"
+ assert pandapipes.get_fluid(net_gas, 'hgas').name == "hgas"
# set up multinet
mn = create_empty_multinet("test_p2g")
@@ -204,6 +211,8 @@ def test_p2g_multiple(get_gas_example, get_power_example_simple):
# run control should read/write values with .loc
run_control(mn)
+ fluid = get_fluid(net_gas, 'hgas')
+
# nets must not be changed
assert mn.nets["power"] == net_power
assert mn.nets["gas"] == net_gas
@@ -212,7 +221,7 @@ def test_p2g_multiple(get_gas_example, get_power_example_simple):
assert np.all(net_gas.source.loc[p2g_ids_gas, "mdot_kg_per_s"] ==
net_gas.res_source.loc[p2g_ids_gas, "mdot_kg_per_s"])
assert np.allclose(net_gas.source.loc[p2g_ids_gas, "mdot_kg_per_s"],
- (p_p2g_el/(net_gas.fluid.get_property('hhv') * 3.6)) * eta)
+ (p_p2g_el / (fluid.get_property('hhv') * 3.6)) * eta)
assert np.all(net_gas.source.loc[no_p2g, "mdot_kg_per_s"] == 0.001)
assert np.all(net_power.load.loc[p2g_ids_el, "p_mw"] == p_p2g_el) # has to be still the same
@@ -222,7 +231,7 @@ def test_p2g_multiple(get_gas_example, get_power_example_simple):
run_control(mn)
assert np.allclose(net_gas.source.loc[p2g_ids_gas, "mdot_kg_per_s"],
- p_p2g_el * scaling_factor / (net_gas.fluid.get_property('hhv') * 3.6) * eta)
+ p_p2g_el * scaling_factor / (fluid.get_property('hhv') * 3.6) * eta)
def test_g2p_multiple(get_gas_example, get_power_example_simple):
@@ -230,7 +239,7 @@ def test_g2p_multiple(get_gas_example, get_power_example_simple):
# get the nets
net_gas = copy.deepcopy(get_gas_example)
net_power = copy.deepcopy(get_power_example_simple)
- fluid = pandapipes.get_fluid(net_gas)
+ fluid = pandapipes.get_fluid(net_gas, 'hgas')
assert fluid.name == "hgas"
# set up multinet
@@ -281,9 +290,11 @@ def test_g2g_multiple(get_gas_example):
# get the nets
net_gas1 = copy.deepcopy(get_gas_example)
pandapipes.create_fluid_from_lib(net_gas1, "hgas", overwrite=True)
+ net_gas1.ext_grid.fluid.values[:] = "hgas"
net_gas2 = copy.deepcopy(get_gas_example)
pandapipes.create_fluid_from_lib(net_gas2, "hydrogen", overwrite=True)
+ net_gas2.ext_grid.fluid.values[:] = "hydrogen"
# set up multinet
mn = create_empty_multinet("test_g2g")
@@ -291,13 +302,13 @@ def test_g2g_multiple(get_gas_example):
# dummy component for offset in sink/source indices:
_ = pandapipes.create_sink(net_gas1, 0, mdot_kg_per_s=0.001)
- no_g2g = pandapipes.create_sources(net_gas2, [0, 3], mdot_kg_per_s=0.0314)
+ no_g2g = pandapipes.create_sources(net_gas2, [0, 3], 0.0314, 'hydrogen')
# add components to represent G2P unit
gas1_cons_kg_per_s = 0.05
g2g_ids_cons = pandapipes.create_sinks(net_gas1, range(1, 4), mdot_kg_per_s=gas1_cons_kg_per_s,
name="SMR consumption")
- g2g_ids_prod = pandapipes.create_sources(net_gas2, [0, 2, 5], 0, name="SMR production")
+ g2g_ids_prod = pandapipes.create_sources(net_gas2, [0, 2, 5], 0, 'hydrogen', name="SMR production")
# add coupling controller
eta = 0.65
@@ -306,8 +317,8 @@ def test_g2g_multiple(get_gas_example):
run_control(mn)
- fluid1 = pandapipes.get_fluid(net_gas1)
- fluid2 = pandapipes.get_fluid(net_gas2)
+ fluid1 = pandapipes.get_fluid(net_gas1, 'hgas')
+ fluid2 = pandapipes.get_fluid(net_gas2, 'hydrogen')
# nets must not be changed
assert mn.nets["hgas_net"] == net_gas1
@@ -358,7 +369,7 @@ def test_const_p2g_control(get_gas_example, get_power_example_simple):
assert np.all(net_power.res_load.p_mw.values == power_load)
assert np.all(net_gas.res_sink.values == flow_gas)
- assert net_gas.source.mdot_kg_per_s.values == power_load * p2g.conversion_factor_mw_to_kgps()\
+ assert net_gas.source.mdot_kg_per_s.values == power_load * p2g.conversion_factor_mw_to_kgps() \
* p2g.efficiency
@@ -388,7 +399,7 @@ def test_p2g_single_run_parameter(get_gas_example, get_power_example_simple):
# get the nets
net_gas = copy.deepcopy(get_gas_example)
net_power = copy.deepcopy(get_power_example_simple)
- assert pandapipes.get_fluid(net_gas).name == "hgas"
+ assert pandapipes.get_fluid(net_gas, 'hgas').name == "hgas"
# set up multinet
mn = create_empty_multinet("test_p2g")
diff --git a/pandapipes/test/openmodelica_comparison/pipeflow_openmodelica_comparison.py b/pandapipes/test/openmodelica_comparison/pipeflow_openmodelica_comparison.py
index 6b852379..c0f878a4 100644
--- a/pandapipes/test/openmodelica_comparison/pipeflow_openmodelica_comparison.py
+++ b/pandapipes/test/openmodelica_comparison/pipeflow_openmodelica_comparison.py
@@ -9,10 +9,10 @@
import pandapipes as pp
from pandapipes.component_models.pipe_component import Pipe
-from pandapipes.properties.fluids import get_fluid
+from pandapipes.properties.fluids import get_fluid, is_fluid_gas
try:
- import pplog as logging
+ from pandaplan.core import pplog as logging
except ImportError:
import logging
@@ -51,7 +51,7 @@ def pipeflow_openmodelica_comparison(net, log_results=True, friction_model='cole
p_valid = pd.notnull(p_om)
p_om = p_om.loc[p_valid]
- if get_fluid(net).is_gas:
+ if is_fluid_gas(net):
if 'pipe' in net:
v_diff_from_pipe, v_diff_to_pipe, v_diff_mean_pipe, v_diff_abs_pipe, \
v_mean_pandapipes_pipe, v_om_pipe = retrieve_velocity_gas(net, 'pipe')
@@ -253,8 +253,8 @@ def retrieve_temperature_liquid(net):
T_mean_om[i] = st.mean(T_om[i])
for j in range(num_of_pipes):
- pipe_res = Pipe.get_internal_results(net,[j])
- T_mean_pandapipes[j] = st.mean(pipe_res["TINIT"][:,1])
+ pipe_res = Pipe.get_internal_results(net, [j])
+ T_mean_pandapipes[j] = st.mean(pipe_res["TINIT"][:, 1])
T_diff_mean = np.abs(1 - T_mean_pandapipes / T_mean_om)
T_diff_abs = np.abs(T_mean_om - T_mean_pandapipes)
diff --git a/pandapipes/test/openmodelica_comparison/test_heat_transfer_openmodelica.py b/pandapipes/test/openmodelica_comparison/test_heat_transfer_openmodelica.py
index b368982a..0617a523 100644
--- a/pandapipes/test/openmodelica_comparison/test_heat_transfer_openmodelica.py
+++ b/pandapipes/test/openmodelica_comparison/test_heat_transfer_openmodelica.py
@@ -11,7 +11,7 @@
import pipeflow_openmodelica_comparison
try:
- import pplog as logging
+ from pandaplan.core import pplog as logging
except ImportError:
import logging
diff --git a/pandapipes/test/openmodelica_comparison/test_water_openmodelica.py b/pandapipes/test/openmodelica_comparison/test_water_openmodelica.py
index 9e5b6b1d..71fcd9d9 100644
--- a/pandapipes/test/openmodelica_comparison/test_water_openmodelica.py
+++ b/pandapipes/test/openmodelica_comparison/test_water_openmodelica.py
@@ -11,7 +11,7 @@
import pipeflow_openmodelica_comparison
try:
- import pplog as logging
+ from pandaplan.core import pplog as logging
except ImportError:
import logging
diff --git a/pandapipes/test/pipeflow_internals/test_inservice.py b/pandapipes/test/pipeflow_internals/test_inservice.py
index 1c44569a..d7af051a 100644
--- a/pandapipes/test/pipeflow_internals/test_inservice.py
+++ b/pandapipes/test/pipeflow_internals/test_inservice.py
@@ -13,7 +13,7 @@
from pandapipes.pipeflow import PipeflowNotConverged
try:
- import pplog as logging
+ from pandaplan.core import ppglog as logging
except ImportError:
import logging
@@ -38,7 +38,7 @@ def create_test_net():
j6 = pandapipes.create_junction(net, 1, 293.15)
j7 = pandapipes.create_junction(net, 1, 293.15, in_service=False)
- pandapipes.create_ext_grid(net, j1, 1, 285.15, type="pt")
+ pandapipes.create_ext_grid(net, j1, 1, 285.15, type="pt", fluid='lgas')
pandapipes.create_pipe_from_parameters(net, j1, j2, 0.1, 0.1, sections=1, alpha_w_per_m2k=5)
pandapipes.create_pipe_from_parameters(net, j2, j3, 0.1, 0.1, sections=2, alpha_w_per_m2k=5,
@@ -76,9 +76,9 @@ def complex_heat_connectivity_grid():
j9 = pandapipes.create_junction(net, 1, 320.15, index=9)
j10 = pandapipes.create_junction(net, 1, 320.15, index=10)
- pandapipes.create_ext_grid(net, j1, 1, 320.15, type="p", index=5)
- pandapipes.create_ext_grid(net, j7, 1, 320.15, type="t", index=2)
- pandapipes.create_ext_grid(net, j10, 1, 320.15, type="pt", index=1)
+ pandapipes.create_ext_grid(net, j1, 1, 320.15, fluid="water", type="p", index=5)
+ pandapipes.create_ext_grid(net, j7, 1, 320.15, fluid="water", type="t", index=2)
+ pandapipes.create_ext_grid(net, j10, 1, 320.15, fluid="water", type="pt", index=1)
pandapipes.create_pipe_from_parameters(net, j1, j2, 0.1, 0.1, alpha_w_per_m2k=5, index=3)
pandapipes.create_pipe_from_parameters(net, j1, j3, 0.1, 0.1, alpha_w_per_m2k=5, index=4)
@@ -100,8 +100,8 @@ def complex_heat_connectivity_grid():
pandapipes.create_sink(net, j7, mdot_kg_per_s=0.2, index=5)
pandapipes.create_sink(net, j9, mdot_kg_per_s=0.1, index=7)
pandapipes.create_sink(net, j8, mdot_kg_per_s=0.1, index=1)
- pandapipes.create_source(net, j5, mdot_kg_per_s=0.1, index=7)
- pandapipes.create_source(net, j2, mdot_kg_per_s=0.05, index=2)
+ pandapipes.create_source(net, j5, mdot_kg_per_s=0.1, fluid='water', index=7)
+ pandapipes.create_source(net, j2, mdot_kg_per_s=0.05, fluid='water', index=2)
return net
@@ -109,10 +109,9 @@ def complex_heat_connectivity_grid():
@pytest.fixture
def create_mixed_indexing_grid():
net = pandapipes.create_empty_network()
- pandapipes.create_fluid_from_lib(net, "lgas")
pandapipes.create_junctions(net, 11, 1.0, 283.15, index=[1, 3, 5, 10, 12, 14, 9, 8, 7, 6, 15])
- pandapipes.create_ext_grid(net, 1, 1.0, 283.15)
- pandapipes.create_ext_grid(net, 5, 1.0, 283.15)
+ pandapipes.create_ext_grid(net, 1, 1.0, 283.15, fluid='lgas')
+ pandapipes.create_ext_grid(net, 5, 1.0, 283.15, fluid='lgas')
pandapipes.create_pipes_from_parameters(
net, [1, 5, 3, 14, 14, 8], [3, 3, 10, 6, 9, 7], 0.5, 0.12, sections=[1, 1, 1, 2, 3, 1],
index=[0, 3, 10, 7, 6, 8])
@@ -120,8 +119,8 @@ def create_mixed_indexing_grid():
pandapipes.create_pressure_control(net, 9, 8, 8, 0.7)
pandapipes.create_sinks(net, [10, 6, 15, 7], 0.1, index=[3, 5, 1, 2],
in_service=[True, False, True, True])
- pandapipes.create_source(net, 12, 0.05, index=2)
- pandapipes.create_source(net, 9, 0.06, index=4, in_service=False)
+ pandapipes.create_source(net, 12, 0.05, index=2, fluid='lgas')
+ pandapipes.create_source(net, 9, 0.06, index=4, fluid='lgas', in_service=False)
return net
@@ -360,13 +359,13 @@ def test_exclude_unconnected_junction(use_numba):
:return:
:rtype:
"""
- net = pandapipes.create_empty_network(fluid="lgas")
+ net = pandapipes.create_empty_network()
j1 = pandapipes.create_junction(net, pn_bar=1.05, tfluid_k=293.15, name="Junction 1")
_ = pandapipes.create_junction(net, pn_bar=1.05, tfluid_k=293.15, name="unconnected junction")
j3 = pandapipes.create_junction(net, pn_bar=1.05, tfluid_k=293.15, name="Junction 3")
- pandapipes.create_ext_grid(net, junction=j1, p_bar=1.1, t_k=293.15)
+ pandapipes.create_ext_grid(net, junction=j1, p_bar=1.1, t_k=293.15, fluid="lgas")
pandapipes.create_sink(net, junction=j3, mdot_kg_per_s=0.045)
pandapipes.create_pipe_from_parameters(net, from_junction=j1, to_junction=j3, length_km=0.1,
diameter_m=0.05)
diff --git a/pandapipes/test/pipeflow_internals/test_non_convergence.py b/pandapipes/test/pipeflow_internals/test_non_convergence.py
index 9bd46372..3b7fb487 100644
--- a/pandapipes/test/pipeflow_internals/test_non_convergence.py
+++ b/pandapipes/test/pipeflow_internals/test_non_convergence.py
@@ -14,10 +14,11 @@
@pytest.mark.parametrize("use_numba", [True, False])
def test_pipeflow_non_convergence(use_numba):
net = gas_versatility()
- pandapipes.get_fluid(net).add_property("molar_mass", FluidPropertyConstant(16.6))
+ pandapipes.get_fluid(net, 'STANET_fluid').add_property("molar_mass", FluidPropertyConstant(16.6))
pandapipes.pipeflow(net, use_numba=use_numba)
- for comp in net["component_list"]:
+ comp_list = np.concatenate([net['node_element_list'], net['node_list'], net['branch_list']])
+ for comp in comp_list:
table_name = comp.table_name()
assert np.all(net["res_" + table_name].index == net[table_name].index)
if table_name == "valve":
@@ -28,7 +29,7 @@ def test_pipeflow_non_convergence(use_numba):
with pytest.raises(PipeflowNotConverged):
pandapipes.pipeflow(net, use_numba=use_numba)
- for comp in net["component_list"]:
+ for comp in comp_list:
table_name = comp.table_name()
assert np.all(net["res_" + table_name].index == net[table_name].index)
assert np.all(pd.isnull(net["res_" + table_name]))
diff --git a/pandapipes/test/pipeflow_internals/test_pipeflow_analytic_comparison.py b/pandapipes/test/pipeflow_internals/test_pipeflow_analytic_comparison.py
index 5b862d89..eb20154f 100644
--- a/pandapipes/test/pipeflow_internals/test_pipeflow_analytic_comparison.py
+++ b/pandapipes/test/pipeflow_internals/test_pipeflow_analytic_comparison.py
@@ -11,12 +11,12 @@
import pandapipes
from pandapipes.component_models.junction_component import Junction
from pandapipes.component_models.pipe_component import Pipe
-from pandapipes.idx_node import PINIT, TINIT
from pandapipes.pf.pipeflow_setup import get_lookup
from pandapipes.properties.fluids import _add_fluid_to_net
from pandapipes.test.pipeflow_internals import internals_data_path
+
@pytest.mark.parametrize("use_numba", [True, False])
def test_gas_internal_nodes(use_numba):
"""
@@ -29,12 +29,13 @@ def test_gas_internal_nodes(use_numba):
pandapipes.create_junction(net, pn_bar=51, tfluid_k=285.15)
pandapipes.create_junction(net, pn_bar=51, tfluid_k=285.15)
pandapipes.create_pipe_from_parameters(net, 0, 1, 12.0, d, k_mm=.5, sections=12)
- pandapipes.create_ext_grid(net, 0, p_bar=51 - 1.01325, t_k=285.15, type="pt")
- pandapipes.create_sink(net, 1, mdot_kg_per_s=0.82752 * 45000 / 3600)
_add_fluid_to_net(net, pandapipes.create_constant_fluid(
name="natural_gas", fluid_type="gas", viscosity=11.93e-6, heat_capacity=2185,
compressibility=1, der_compressibility=0, density=0.82752
))
+ pandapipes.create_ext_grid(net, 0, p_bar=51 - 1.01325, t_k=285.15, fluid='natural_gas', type="pt")
+ pandapipes.create_sink(net, 1, mdot_kg_per_s=0.82752 * 45000 / 3600)
+
pandapipes.pipeflow(net, stop_condition="tol", iter=70, friction_model="nikuradse",
transient=False, nonlinear_method="automatic", tol_p=1e-4, tol_v=1e-4,
use_numba=use_numba)
@@ -59,9 +60,9 @@ def test_gas_internal_nodes(use_numba):
to_junction_nodes = junction_idx_lookup[net["pipe"]["to_junction"].values]
p_pandapipes = np.zeros(len(pipe_p_data[0]) + 2)
- p_pandapipes[0] = node_pit[from_junction_nodes[0], PINIT]
+ p_pandapipes[0] = node_pit[from_junction_nodes[0], net['_idx_node']['PINIT']]
p_pandapipes[1:-1] = pipe_p_data[:]
- p_pandapipes[-1] = node_pit[to_junction_nodes[0], PINIT]
+ p_pandapipes[-1] = node_pit[to_junction_nodes[0], net['_idx_node']['PINIT']]
p_pandapipes = p_pandapipes + 1.01325
v_pandapipes = pipe_v_data[0, :]
@@ -84,7 +85,7 @@ def test_temperature_internal_nodes_single_pipe(use_numba):
pandapipes.create_junction(net, pn_bar=5, tfluid_k=283)
pandapipes.create_junction(net, pn_bar=5, tfluid_k=283)
pandapipes.create_pipe_from_parameters(net, 0, 1, 6, d, k_mm=.1, sections=6, alpha_w_per_m2k=5)
- pandapipes.create_ext_grid(net, 0, p_bar=5, t_k=330, type="pt")
+ pandapipes.create_ext_grid(net, 0, p_bar=5, t_k=330, fluid="water", type="pt")
pandapipes.create_sink(net, 1, mdot_kg_per_s=1)
pandapipes.create_fluid_from_lib(net, "water", overwrite=True)
@@ -109,9 +110,9 @@ def test_temperature_internal_nodes_single_pipe(use_numba):
to_junction_nodes = junction_idx_lookup[net["pipe"]["to_junction"].values]
temp_pandapipes = np.zeros(len(pipe_temp_data[0]) + 2)
- temp_pandapipes[0] = node_pit[from_junction_nodes[0], TINIT]
+ temp_pandapipes[0] = node_pit[from_junction_nodes[0], net['_idx_node']['TINIT']]
temp_pandapipes[1:-1] = pipe_temp_data[:]
- temp_pandapipes[-1] = node_pit[to_junction_nodes[0], TINIT]
+ temp_pandapipes[-1] = node_pit[to_junction_nodes[0], net['_idx_node']['TINIT']]
temp_diff = np.abs(1 - temp_pandapipes / temp_an)
@@ -131,7 +132,7 @@ def test_temperature_internal_nodes_tee_2ab_1zu(use_numba):
j1 = pandapipes.create_junction(net, pn_bar=5, tfluid_k=283)
j2 = pandapipes.create_junction(net, pn_bar=5, tfluid_k=283)
j3 = pandapipes.create_junction(net, pn_bar=5, tfluid_k=283)
- pandapipes.create_ext_grid(net, j0, p_bar=5, t_k=350, type="pt")
+ pandapipes.create_ext_grid(net, j0, p_bar=5, t_k=350, fluid="water", type="pt")
pandapipes.create_sink(net, j2, mdot_kg_per_s=1)
pandapipes.create_sink(net, j3, mdot_kg_per_s=1)
@@ -175,8 +176,8 @@ def test_temperature_internal_nodes_tee_2zu_1ab(use_numba):
alpha_w_per_m2k=5)
pandapipes.create_pipe_from_parameters(net, j2, j3, 2.5, d, k_mm=.1, sections=3,
alpha_w_per_m2k=5)
- pandapipes.create_ext_grid(net, j0, p_bar=5, t_k=350, type="pt")
- pandapipes.create_ext_grid(net, j1, p_bar=5, t_k=350, type="pt")
+ pandapipes.create_ext_grid(net, j0, p_bar=5, t_k=350, fluid="water", type="pt")
+ pandapipes.create_ext_grid(net, j1, p_bar=5, t_k=350, fluid="water", type="pt")
pandapipes.create_sink(net, j3, mdot_kg_per_s=1)
pandapipes.create_fluid_from_lib(net, "water", overwrite=True)
@@ -208,8 +209,8 @@ def test_temperature_internal_nodes_tee_2zu_1ab_direction_changed(use_numba):
j1 = pandapipes.create_junction(net, pn_bar=5, tfluid_k=283)
j2 = pandapipes.create_junction(net, pn_bar=5, tfluid_k=283)
j3 = pandapipes.create_junction(net, pn_bar=5, tfluid_k=283)
- pandapipes.create_ext_grid(net, j0, p_bar=5, t_k=350, type="pt")
- pandapipes.create_ext_grid(net, j1, p_bar=5, t_k=350, type="pt")
+ pandapipes.create_ext_grid(net, j0, p_bar=5, t_k=350, fluid="water", type="pt")
+ pandapipes.create_ext_grid(net, j1, p_bar=5, t_k=350, fluid="water", type="pt")
pandapipes.create_sink(net, j3, mdot_kg_per_s=1)
pandapipes.create_pipe_from_parameters(net, j0, j2, 2.5, d, k_mm=.1, sections=5,
@@ -249,8 +250,8 @@ def test_temperature_internal_nodes_2zu_2ab(use_numba):
j2 = pandapipes.create_junction(net, pn_bar=5, tfluid_k=283)
j3 = pandapipes.create_junction(net, pn_bar=5, tfluid_k=283)
j4 = pandapipes.create_junction(net, pn_bar=5, tfluid_k=283)
- pandapipes.create_ext_grid(net, j0, p_bar=5, t_k=350, type="pt")
- pandapipes.create_ext_grid(net, j1, p_bar=5, t_k=300, type="pt")
+ pandapipes.create_ext_grid(net, j0, p_bar=5, t_k=350, fluid="water", type="pt")
+ pandapipes.create_ext_grid(net, j1, p_bar=5, t_k=300, fluid="water", type="pt")
pandapipes.create_sink(net, j3, mdot_kg_per_s=1)
pandapipes.create_sink(net, j4, mdot_kg_per_s=1)
@@ -298,7 +299,7 @@ def test_temperature_internal_nodes_masche_1load(use_numba):
pandapipes.create_pipe_from_parameters(net, j3, j2, 2.5, d, k_mm=.1, sections=6,
alpha_w_per_m2k=5)
- pandapipes.create_ext_grid(net, j0, p_bar=5, t_k=350, type="pt")
+ pandapipes.create_ext_grid(net, j0, p_bar=5, t_k=350, fluid="water", type="pt")
pandapipes.create_sink(net, j2, mdot_kg_per_s=1)
pandapipes.create_fluid_from_lib(net, "water", overwrite=True)
@@ -339,7 +340,7 @@ def test_temperature_internal_nodes_masche_1load_changed_direction(use_numba):
pandapipes.create_fluid_from_lib(net, "water", overwrite=True)
- pandapipes.create_ext_grid(net, j0, p_bar=5, t_k=350, type="pt")
+ pandapipes.create_ext_grid(net, j0, p_bar=5, t_k=350, fluid="water", type="pt")
pandapipes.create_sink(net, j3, mdot_kg_per_s=1)
pandapipes.pipeflow(net, stop_condition="tol", iter=70, friction_model="nikuradse",
diff --git a/pandapipes/test/pipeflow_internals/test_pipeflow_modes.py b/pandapipes/test/pipeflow_internals/test_pipeflow_modes.py
index b0107c85..5b6e9466 100644
--- a/pandapipes/test/pipeflow_internals/test_pipeflow_modes.py
+++ b/pandapipes/test/pipeflow_internals/test_pipeflow_modes.py
@@ -9,10 +9,8 @@
import pandas as pd
import pytest
-import pandapipes
-from pandapipes.idx_branch import VINIT
-from pandapipes.idx_node import PINIT
from pandapipes.test import test_path
+import pandapipes
data_path = os.path.join(test_path, "pipeflow_internals", "data")
@@ -25,11 +23,8 @@ def simple_test_net():
pandapipes.create_junction(net, pn_bar=5, tfluid_k=283)
pandapipes.create_pipe_from_parameters(net, 0, 1, 6, diameter_m=d, k_mm=.1, sections=1,
alpha_w_per_m2k=5)
- pandapipes.create_ext_grid(net, 0, p_bar=5, t_k=330, type="pt")
+ pandapipes.create_ext_grid(net, 0, p_bar=5, t_k=330, fluid="water", type="pt")
pandapipes.create_sink(net, 1, mdot_kg_per_s=1)
-
- pandapipes.create_fluid_from_lib(net, "water", overwrite=True)
-
return net
@@ -54,8 +49,8 @@ def test_hydraulic_only(simple_test_net, use_numba):
v_an = data.loc[0, "pv"]
p_an = data.loc[1:3, "pv"]
- p_pandapipes = node_pit[:, PINIT]
- v_pandapipes = branch_pit[:, VINIT]
+ p_pandapipes = node_pit[:, net['_idx_node']['PINIT']]
+ v_pandapipes = branch_pit[:, net['_idx_branch']['VINIT']]
p_diff = np.abs(1 - p_pandapipes / p_an)
v_diff = np.abs(v_pandapipes - v_an)
@@ -72,7 +67,7 @@ def test_heat_only(use_numba):
pandapipes.create_junction(net, pn_bar=5, tfluid_k=283)
pandapipes.create_pipe_from_parameters(net, 0, 1, 6, diameter_m=d, k_mm=.1, sections=6,
alpha_w_per_m2k=5)
- pandapipes.create_ext_grid(net, 0, p_bar=5, t_k=330, type="pt")
+ pandapipes.create_ext_grid(net, 0, p_bar=5, t_k=330, fluid="water", type="pt")
pandapipes.create_sink(net, 1, mdot_kg_per_s=1)
pandapipes.create_fluid_from_lib(net, "water", overwrite=True)
@@ -86,7 +81,7 @@ def test_heat_only(use_numba):
pandapipes.create_junction(ntw, pn_bar=5, tfluid_k=283)
pandapipes.create_pipe_from_parameters(ntw, 0, 1, 6, diameter_m=d, k_mm=.1, sections=6,
alpha_w_per_m2k=5)
- pandapipes.create_ext_grid(ntw, 0, p_bar=5, t_k=330, type="pt")
+ pandapipes.create_ext_grid(ntw, 0, p_bar=5, t_k=330, fluid='water', type="pt")
pandapipes.create_sink(ntw, 1, mdot_kg_per_s=1)
pandapipes.create_fluid_from_lib(ntw, "water", overwrite=True)
@@ -94,8 +89,8 @@ def test_heat_only(use_numba):
pandapipes.pipeflow(ntw, stop_condition="tol", iter=50, friction_model="nikuradse",
nonlinear_method="automatic", mode="hydraulics", use_numba=use_numba)
- p = ntw._pit["node"][:, 5]
- v = ntw._pit["branch"][:, 12]
+ p = ntw._pit["node"][:, net['_idx_node']['PINIT']]
+ v = ntw._pit["branch"][:, net['_idx_branch']['VINIT']]
u = np.concatenate((p, v))
pandapipes.pipeflow(ntw, sol_vec=u, stop_condition="tol", iter=50, friction_model="nikuradse",
diff --git a/pandapipes/test/pipeflow_internals/test_time_series.py b/pandapipes/test/pipeflow_internals/test_time_series.py
index 9c49d55b..2186c18a 100644
--- a/pandapipes/test/pipeflow_internals/test_time_series.py
+++ b/pandapipes/test/pipeflow_internals/test_time_series.py
@@ -16,7 +16,7 @@
from pandapower.timeseries import OutputWriter, DFData
try:
- import pplog as logging
+ from pandaplan.core import pplog as logging
except ImportError:
import logging
@@ -88,7 +88,7 @@ def _compare_results(ow):
res_ext_grid = ow.np_results["res_ext_grid.mdot_kg_per_s"]
res_ext_grid = res_ext_grid[~np.isclose(res_ext_grid, 0)]
test_res_ext_grid = test_res_ext_grid.values[~np.isclose(test_res_ext_grid.values, 0)]
- diff = 1 - res_ext_grid.round(9) / test_res_ext_grid.round(9)
+ diff = 1 - res_ext_grid.round(4) / test_res_ext_grid.round(4)
check = diff < 0.0001
assert (np.all(check))
test_res_junction = pd.read_csv(os.path.join(
@@ -106,7 +106,7 @@ def _compare_results(ow):
res_pipe = ow.np_results["res_pipe.v_mean_m_per_s"]
res_pipe = res_pipe[~np.isclose(res_pipe, 0)]
test_res_pipe = test_res_pipe.values[~np.isclose(test_res_pipe.values, 0)]
- diff = 1 - res_pipe.round(9) / test_res_pipe.round(9)
+ diff = 1 - res_pipe.round(4) / test_res_pipe.round(4)
check = diff < 0.0001
assert (np.all(check))
test_res_sink = pd.read_csv(os.path.join(
diff --git a/pandapipes/test/pipeflow_internals/test_update_matrix.py b/pandapipes/test/pipeflow_internals/test_update_matrix.py
index 6be50bf6..463b9a3b 100644
--- a/pandapipes/test/pipeflow_internals/test_update_matrix.py
+++ b/pandapipes/test/pipeflow_internals/test_update_matrix.py
@@ -10,7 +10,7 @@
from pandapipes.test.stanet_comparison.pipeflow_stanet_comparison import pipeflow_stanet_comparison
try:
- import pplog as logging
+ from pandaplan.core import pplog as logging
except ImportError:
import logging
diff --git a/pandapipes/test/plotting/test_collections.py b/pandapipes/test/plotting/test_collections.py
index 1fee31fb..15e8c3ff 100644
--- a/pandapipes/test/plotting/test_collections.py
+++ b/pandapipes/test/plotting/test_collections.py
@@ -26,7 +26,7 @@ def test_collection_lengths():
j8 = pandapipes.create_junction(net, pn_bar=5, tfluid_k=293.15, geodata=(10, 0))
j9 = pandapipes.create_junction(net, pn_bar=5, tfluid_k=293.15, geodata=(12, 0))
- pandapipes.create_ext_grid(net, j1, p_bar=5, t_k=293.15)
+ pandapipes.create_ext_grid(net, j1, p_bar=5, fluid="lgas", t_k=293.15)
pandapipes.create_sink(net, j5, mdot_kg_per_s=0.5)
pandapipes.create_sink(net, j6, mdot_kg_per_s=0.5)
pandapipes.create_sink(net, j8, mdot_kg_per_s=0.5)
diff --git a/pandapipes/test/plotting/test_pipeflow_results.py b/pandapipes/test/plotting/test_pipeflow_results.py
index dae82313..ada2ea2a 100644
--- a/pandapipes/test/plotting/test_pipeflow_results.py
+++ b/pandapipes/test/plotting/test_pipeflow_results.py
@@ -8,13 +8,13 @@
import pandapipes as pp
def test_pressure_profile_to_junction_geodata():
- net = pp.create_empty_network(fluid="lgas")
+ net = pp.create_empty_network()
j1 = pp.create_junction(net, pn_bar=1.05, tfluid_k=293.15)
j2 = pp.create_junction(net, pn_bar=1.05, tfluid_k=293.15)
j3 = pp.create_junction(net, pn_bar=1.05, tfluid_k=293.15)
j4 = pp.create_junction(net, pn_bar=1.05, tfluid_k=293.15)
- pp.create_ext_grid(net, junction=j1, p_bar=1.1, t_k=293.15)
+ pp.create_ext_grid(net, junction=j1, p_bar=1.1, t_k=293.15, fluid="lgas")
pp.create_sink(net, junction=j4, mdot_kg_per_s=0.01)
pp.create_pipe_from_parameters(net, from_junction=j1, to_junction=j2,
diff --git a/pandapipes/test/plotting/test_simple_collections.py b/pandapipes/test/plotting/test_simple_collections.py
index af95fe4e..05452f56 100644
--- a/pandapipes/test/plotting/test_simple_collections.py
+++ b/pandapipes/test/plotting/test_simple_collections.py
@@ -3,6 +3,7 @@
# Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
import copy
+import numpy as np
import pandapipes.plotting as plot
from matplotlib.collections import PatchCollection, LineCollection
@@ -13,7 +14,8 @@ def test_simple_collections(base_net_is_with_pumps):
net = copy.deepcopy(base_net_is_with_pumps)
collections = plot.create_simple_collections(net, plot_sinks=True, plot_sources=True)
- assert len(collections) == len([comp for comp in net["component_list"]
+ assert len(collections) == len([comp for comp in
+ np.concatenate([net['node_list'], net['node_element_list'], net['branch_list']])
if not net[comp.table_name()].empty])
assert len(collections["junction"].get_paths()) == len(net.junction)
@@ -66,7 +68,8 @@ def test_simple_collections_out_of_service(base_net_oos_with_pumps):
net = copy.deepcopy(base_net_oos_with_pumps)
collections = plot.create_simple_collections(net, plot_sinks=True, plot_sources=True)
- assert len(collections) == len([comp for comp in net["component_list"]
+ assert len(collections) == len([comp for comp in
+ np.concatenate([net['node_list'], net['node_element_list'], net['branch_list']])
if not net[comp.table_name()].empty])
assert len(collections["junction"].get_paths()) == len(net.junction[net.junction.in_service])
diff --git a/pandapipes/test/properties/test_fluid_specials.py b/pandapipes/test/properties/test_fluid_specials.py
index 2dd03302..2f6dad33 100644
--- a/pandapipes/test/properties/test_fluid_specials.py
+++ b/pandapipes/test/properties/test_fluid_specials.py
@@ -12,43 +12,46 @@ def test_add_fluid():
fluid_old = pandapipes.call_lib("air")
with pytest.raises(AttributeError, match="no fluid"):
- pandapipes.get_fluid(net)
+ pandapipes.get_fluid(net, 'hgas')
_add_fluid_to_net(net, fluid_old)
fluid_new = pandapipes.create_constant_fluid("arbitrary_gas2", "gas", density=2,
compressibility=2)
_add_fluid_to_net(net, fluid_new, overwrite=False)
- assert pandapipes.get_fluid(net) == fluid_old
+ assert fluid_old.name in net.fluid
_add_fluid_to_net(net, fluid_new)
- assert pandapipes.get_fluid(net) == fluid_new
+ assert fluid_new.name in net.fluid
- net["fluid"] = "Hello"
+ net["fluid"]['hello'] = "Hello"
_add_fluid_to_net(net, fluid_new, overwrite=False)
- assert pandapipes.get_fluid(net) == "Hello"
+ assert "hello" in net["fluid"]
+ assert "Hello" == net["fluid"]["hello"]
_add_fluid_to_net(net, fluid_new)
- assert pandapipes.get_fluid(net) == fluid_new
+ assert pandapipes.get_fluid(net, fluid_new.name) == fluid_new
def test_property_adaptation():
- net = pandapipes.create_empty_network(fluid="hgas")
- fluid = pandapipes.get_fluid(net)
+ net = pandapipes.create_empty_network()
+ _add_fluid_to_net(net, pandapipes.call_lib("hgas"))
+ fluid = net.fluid['hgas']
density_old = fluid.all_properties["density"]
- pandapipes.create_constant_property(net, "density", 1, overwrite=False)
- assert pandapipes.get_fluid(net).all_properties["density"] == density_old
+ pandapipes.create_constant_property(net, "hgas", "density", 1, overwrite=False)
+ assert fluid.all_properties["density"] == density_old
- pandapipes.create_constant_property(net, "density", 1, overwrite=True, warn_on_duplicates=False)
- density_new = pandapipes.create_constant_property(net, "density", 1, overwrite=False)
- assert pandapipes.get_fluid(net).all_properties["density"].equals(density_new)
- assert pandapipes.get_fluid(net).all_properties["density"] != density_new
+ pandapipes.create_constant_property(net, "hgas", "density", 1, overwrite=True, warn_on_duplicates=False)
+ density_new = pandapipes.create_constant_property(net, "hgas", "density", 1, overwrite=False)
+ assert fluid.all_properties["density"].equals(density_new)
+ assert fluid.all_properties["density"] != density_new
def test_fluid_exceptions():
- net = pandapipes.create_empty_network(fluid="hgas")
- fluid = pandapipes.get_fluid(net)
+ net = pandapipes.create_empty_network()
+ _add_fluid_to_net(net, pandapipes.call_lib("hgas"))
+ fluid = net.fluid['hgas']
with pytest.raises(UserWarning, match="property xyz was not defined for the fluid"):
fluid.get_property("xyz", 100)
diff --git a/pandapipes/test/properties/test_properties_toolbox.py b/pandapipes/test/properties/test_properties_toolbox.py
index 88c72882..1477eef5 100644
--- a/pandapipes/test/properties/test_properties_toolbox.py
+++ b/pandapipes/test/properties/test_properties_toolbox.py
@@ -276,15 +276,14 @@ def test_mixture_molar_mass_lgas():
components_molar_mass = np.concatenate([molar_ch4, molar_n2, molar_co2, molar_c2h6])
components_molar_proportions = np.array([.85, .103, .013, .034])
mix_molar = calculate_mixture_molar_mass(
- components_molar_mass=components_molar_mass,
- components_molar_proportions=components_molar_proportions)
+ components_molar_mass=components_molar_mass, component_proportions=components_molar_proportions,
+ proportion_type='molar')
assert (mix_molar == test_mix_molar)
components_mass_proportions = calculate_mass_fraction_from_molar_fraction(
components_molar_proportions, components_molar_mass)
mix_molar = calculate_mixture_molar_mass(
- components_molar_mass=components_molar_mass,
- components_mass_proportions=components_mass_proportions)
+ components_molar_mass=components_molar_mass, component_proportions=components_mass_proportions)
assert (mix_molar == test_mix_molar)
@@ -303,8 +302,8 @@ def test_mixture_molar_mass_hgas():
components_molar_mass = np.concatenate([molar_ch4, molar_n2, molar_co2, molar_c2h6])
components_molar_proportions = np.array([.964, .005, .005, .026])
mix_molar = calculate_mixture_molar_mass(
- components_molar_mass=components_molar_mass,
- components_molar_proportions=components_molar_proportions)
+ components_molar_mass=components_molar_mass, component_proportions=components_molar_proportions,
+ proportion_type='molar')
assert (mix_molar == test_mix_molar)
diff --git a/pandapipes/test/run_tests.py b/pandapipes/test/run_tests.py
index 1c411062..260195eb 100644
--- a/pandapipes/test/run_tests.py
+++ b/pandapipes/test/run_tests.py
@@ -15,7 +15,7 @@
from pandapower.test.run_tests import _get_cpus
try:
- import pplog as logging
+ from pandaplan.core import ppglog as logging
# logger = logging.getLogger()
# for handler in logger.handlers:
# logger.removeHandler(handler)
diff --git a/pandapipes/test/stanet_comparison/pipeflow_stanet_comparison.py b/pandapipes/test/stanet_comparison/pipeflow_stanet_comparison.py
index 25f80862..e1b339f9 100644
--- a/pandapipes/test/stanet_comparison/pipeflow_stanet_comparison.py
+++ b/pandapipes/test/stanet_comparison/pipeflow_stanet_comparison.py
@@ -5,10 +5,10 @@
import numpy as np
import pandapipes
import pandas as pd
-from pandapipes.properties.fluids import get_fluid
+from pandapipes.properties.fluids import is_fluid_gas
try:
- import pplog as logging
+ from pandaplan.core import pplog as logging
except ImportError:
import logging
@@ -40,7 +40,7 @@ def pipeflow_stanet_comparison(net, log_results=True, friction_model='nikuradse'
p_valid = pd.notnull(p_stanet)
p_stanet = p_stanet.loc[p_valid]
- if get_fluid(net).is_gas:
+ if is_fluid_gas(net):
if 'pipe' in net:
v_diff_from_pipe, v_diff_to_pipe, v_diff_mean_pipe, v_diff_abs_pipe, \
v_mean_pandapipes_pipe, v_stanet_pipe = retrieve_velocity_gas(net, 'pipe')
diff --git a/pandapipes/test/stanet_comparison/test_gas_stanet.py b/pandapipes/test/stanet_comparison/test_gas_stanet.py
index 2042237b..26bfadf1 100644
--- a/pandapipes/test/stanet_comparison/test_gas_stanet.py
+++ b/pandapipes/test/stanet_comparison/test_gas_stanet.py
@@ -9,7 +9,7 @@
from pandapipes.test.stanet_comparison.pipeflow_stanet_comparison import pipeflow_stanet_comparison
try:
- import pplog as logging
+ from pandaplan.core import pplog as logging
except ImportError:
import logging
@@ -337,8 +337,8 @@ def test_case_2eg_hnet_n(use_numba, log_results=False):
"""
net = nw.gas_2eg_hnet(method="n")
p_diff, v_diff_abs = pipeflow_stanet_comparison(net, log_results, use_numba=use_numba)
- assert np.all(p_diff < 0.002)
- assert np.all(v_diff_abs < 0.03)
+ assert np.all(p_diff < 0.001)
+ assert np.all(v_diff_abs < 0.001)
# H-net_PC
@@ -354,8 +354,8 @@ def test_case_2eg_hnet_pc(use_numba, log_results=False):
net = nw.gas_2eg_hnet(method="pc")
p_diff, v_diff_abs = pipeflow_stanet_comparison(net, log_results, friction_model="colebrook",
use_numba=use_numba)
- assert np.all(p_diff < 0.002)
- assert np.all(v_diff_abs < 0.03)
+ assert np.all(p_diff < 0.001)
+ assert np.all(v_diff_abs < 0.001)
# # ----------------------------------------
diff --git a/pandapipes/test/stanet_comparison/test_water_stanet.py b/pandapipes/test/stanet_comparison/test_water_stanet.py
index 5d2d42f5..331841d5 100644
--- a/pandapipes/test/stanet_comparison/test_water_stanet.py
+++ b/pandapipes/test/stanet_comparison/test_water_stanet.py
@@ -9,7 +9,7 @@
from pandapipes.test.stanet_comparison.pipeflow_stanet_comparison import pipeflow_stanet_comparison
try:
- import pplog as logging
+ from pandaplan.core import ppglog as logging
except ImportError:
import logging
diff --git a/pandapipes/test/test_toolbox.py b/pandapipes/test/test_toolbox.py
index cb72c403..8e8cbd01 100644
--- a/pandapipes/test/test_toolbox.py
+++ b/pandapipes/test/test_toolbox.py
@@ -14,7 +14,7 @@
def create_base_net(oos):
- net = pandapipes.create_empty_network(fluid="lgas")
+ net = pandapipes.create_empty_network()
# create network elements, such as junctions, external grid, pipes, valves, sinks and sources
junction1 = pandapipes.create_junction(net, pn_bar=1.05, tfluid_k=293.15, in_service=not oos,
@@ -39,7 +39,7 @@ def create_base_net(oos):
geodata=(12, 0))
pandapipes.create_ext_grid(net, junction=junction1, p_bar=1.1, t_k=293.15,
- name="Grid Connection")
+ name="Grid Connection", fluid="lgas")
pandapipes.create_pipe_from_parameters(net, from_junction=junction1, to_junction=junction2,
length_km=10, diameter_m=0.3, name="Pipe 1",
geodata=[(0, 0), (2, 0)], in_service=not oos)
@@ -72,7 +72,7 @@ def create_base_net(oos):
if oos:
pandapipes.create_ext_grid(net, junction=junction1, p_bar=1.1, t_k=293.15,
- name="Grid Connection", in_service=False)
+ name="Grid Connection", in_service=False, fluid="lgas")
pandapipes.create_heat_exchanger(net, junction3, junction8, diameter_m=0.3, qext_w=20000,
in_service=False)
pandapipes.create_sink(net, junction=junction4, mdot_kg_per_s=0.545, name="Sink 2",
@@ -231,9 +231,11 @@ def test_select_subnet(base_net_is_wo_pumps):
# Do nothing
same_net = pandapipes.select_subnet(net, net.junction.index)
- assert len(same_net.component_list) == len(net.component_list)
- assert set(same_net.component_list) == set(net.component_list)
- for comp in net.component_list:
+ comp_list = np.concatenate([net['node_list'], net['node_element_list'], net['branch_list']])
+ same_comp_list = np.concatenate([same_net['node_list'], same_net['node_element_list'], same_net['branch_list']])
+ assert len(same_comp_list) == len(comp_list)
+ assert set(same_comp_list) == set(comp_list)
+ for comp in comp_list:
assert pandapower.dataframes_equal(net[comp.table_name()], same_net[comp.table_name()])
same_net2 = pandapipes.select_subnet(net, net.junction.index, include_results=True,
@@ -242,19 +244,21 @@ def test_select_subnet(base_net_is_wo_pumps):
# Remove everything
empty = pandapipes.select_subnet(net, set())
- for comp in net.component_list:
+ for comp in comp_list:
assert len(empty[comp.table_name()]) == 0
empty2 = pandapipes.select_subnet(net, set(), remove_unused_components=True)
- for comp in net.component_list:
+ comp_list2 = np.concatenate([empty2['node_list'], empty2['node_element_list'], empty2['branch_list']])
+ for comp in comp_list:
assert comp.table_name() not in empty2
- assert comp not in empty2.component_list
+ assert comp not in comp_list2
# check length of results
net = nw.gas_tcross2()
pandapipes.pipeflow(net)
net2 = pandapipes.select_subnet(net, net.junction.index[:-3], include_results=True)
- for comp in net.component_list:
+ comp_list = np.concatenate([net['node_list'], net['node_element_list'], net['branch_list']])
+ for comp in comp_list:
assert len(net2["res_" + comp.table_name()]) == len(net2[comp.table_name()])
assert len(net.junction) == len(net2.junction) + 3
diff --git a/pandapipes/timeseries/run_time_series.py b/pandapipes/timeseries/run_time_series.py
index 04ee41bd..6909e26e 100644
--- a/pandapipes/timeseries/run_time_series.py
+++ b/pandapipes/timeseries/run_time_series.py
@@ -12,7 +12,7 @@
run_loop
try:
- import pplog as logging
+ from pandaplan.core import pplog as logging
except ImportError:
import logging
diff --git a/pandapipes/toolbox.py b/pandapipes/toolbox.py
index 59e9d7b0..cb1a2a90 100644
--- a/pandapipes/toolbox.py
+++ b/pandapipes/toolbox.py
@@ -1,14 +1,13 @@
# Copyright (c) 2020-2022 by Fraunhofer Institute for Energy Economics
# 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.
+
import copy
from collections.abc import Iterable
import numpy as np
import pandas as pd
from networkx import has_path
-from pandapipes.component_models.abstract_models.branch_models import BranchComponent
-from pandapipes.component_models.abstract_models.node_element_models import NodeElementComponent
from pandapipes.create import create_empty_network
from pandapipes.pandapipes_net import pandapipesNet
from pandapipes.topology import create_nxgraph
@@ -16,7 +15,7 @@
from pandapower.toolbox import dataframes_equal, clear_result_tables
try:
- import pplog as logging
+ from pandaplan.core import pplog as logging
except ImportError:
import logging
@@ -105,16 +104,15 @@ def element_junction_tuples(include_node_elements=True, include_branch_elements=
node_elements = []
branch_elements = []
if net is not None:
- all_tables = {comp.table_name(): comp for comp in net.component_list}
+ comp_list = np.concatenate([net['node_list'], net['node_element_list'], net['branch_list']])
+ all_tables = {comp.table_name(): comp for comp in comp_list}
if include_node_elements:
- node_elements = [tbl for tbl, comp in all_tables.items()
- if issubclass(comp, NodeElementComponent)
- and tbl not in move_elements["n2b"]]
+ node_elements = [node.table_name() for node in net['node_element_list']
+ if node.table_name() not in move_elements["n2b"]]
node_elements += [me for me in move_elements["b2n"] if me in all_tables.keys()]
if include_branch_elements:
- branch_elements = [comp.table_name() for comp in net.component_list
- if issubclass(comp, BranchComponent)
- and comp.table_name() not in move_elements["b2n"]]
+ branch_elements = [branch.table_name() for branch in net['branch_list']
+ if branch.table_name() not in move_elements["b2n"]]
branch_elements += [me for me in move_elements["n2b"] if me in all_tables.keys()]
else:
if include_node_elements:
@@ -363,7 +361,7 @@ def select_subnet(net, junctions, include_results=False, keep_everything_else=Fa
else:
p2 = create_empty_network(add_stdtypes=False)
p2["std_types"] = copy.deepcopy(net["std_types"])
- net_parameters = ["name", "fluid", "user_pf_options", "component_list"]
+ net_parameters = ["name", "fluid", "user_pf_options", "node_list", "node_element_list", "branch_list"]
for net_parameter in net_parameters:
if net_parameter in net.keys():
p2[net_parameter] = copy.deepcopy(net[net_parameter])
@@ -403,12 +401,21 @@ def select_subnet(net, junctions, include_results=False, keep_everything_else=Fa
def remove_empty_components(net):
removed = set()
- for comp in net.component_list:
+ for comp in net.node_list:
if net[comp.table_name()].empty:
del net[comp.table_name()]
removed.add(comp)
- net.component_list = [c for c in net.component_list if c not in removed]
-
+ net.node_list = [c for c in net.node_list if c not in removed]
+ for comp in net.node_element_list:
+ if net[comp.table_name()].empty:
+ del net[comp.table_name()]
+ removed.add(comp)
+ net.node_element_list = [c for c in net.node_element_list if c not in removed]
+ for comp in net.branch_list:
+ if net[comp.table_name()].empty:
+ del net[comp.table_name()]
+ removed.add(comp)
+ net.branch_list = [c for c in net.branch_list if c not in removed]
def drop_junctions(net, junctions, drop_elements=True):
"""
diff --git a/pandapipes/topology/create_graph.py b/pandapipes/topology/create_graph.py
index 7f5bac8e..a767e9d7 100644
--- a/pandapipes/topology/create_graph.py
+++ b/pandapipes/topology/create_graph.py
@@ -4,12 +4,11 @@
import networkx as nx
import numpy as np
-from pandapower.topology.create_graph import add_edges, get_edge_table
-from pandapipes.component_models.abstract_models.branch_models import BranchComponent
+from pandapower.topology.create_graph import add_edges, get_edge_table
try:
- import pplog as logging
+ from pandaplan.core import pplog as logging
except ImportError:
import logging
@@ -113,9 +112,7 @@ def create_nxgraph(net, include_pipes=True, respect_status_pipes=True,
for par in ["include", "respect_status", "weighting"]
for bc in ["pipes", "valves", "pumps", "press_controls",
"circ_pump_masss", "circ_pump_presss"]})
- for comp in net.component_list:
- if not issubclass(comp, BranchComponent):
- continue
+ for comp in net['branch_list']:
table_name = comp.table_name()
include_comp = branch_params.get("include_%ss" % table_name, True)
respect_status = branch_params.get("respect_status_%ss" % table_name, True) \
diff --git a/setup.py b/setup.py
index 0488c3d5..4b2e1400 100644
--- a/setup.py
+++ b/setup.py
@@ -34,7 +34,7 @@
setup(
name='pandapipes',
- version='0.6.0',
+ version='0.6.1.dev_1',
author='Dennis Cronbach, Daniel Lohmeier, Simon Ruben Drauz, Jolando Marius Kisse',
author_email='dennis.cronbach@iee.fraunhofer.de, daniel.lohmeier@iee.fraunhofer.de, '
'simon.ruben.drauz@iee.fraunhofer.de, jolando.kisse@uni-kassel.de',
diff --git a/tutorials/Mixture calculation in pandapipes.ipynb b/tutorials/Mixture calculation in pandapipes.ipynb
new file mode 100644
index 00000000..731c105a
--- /dev/null
+++ b/tutorials/Mixture calculation in pandapipes.ipynb
@@ -0,0 +1,745 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "a1be2453",
+ "metadata": {},
+ "source": [
+ "# Mixture calculations in a pandapipes network"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4939742e",
+ "metadata": {},
+ "source": [
+ "Since pandapipes release v0.8.0, it is possible to conduct stationary mixture calculations, i.e. different fluids can be fed into a pandapipes grid and the fluid composition can be determined at each junction, respectivaley. With a simple example, we want to visualize the implementation.\n",
+ "\n",
+ "The simple example consists of four junctions, one external grid, two sources and three sinks. Both sources feed in hydrogen.\n",
+ "\n",
+ "First, we create an empty network and afterwards define the four junctions. Different from the versions before: you don't define one fluid for the entire grid. The nominal pressure is 0.1 bar and the nominal temperature 283.15 K."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "4dabb5cc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import pandapipes as pps\n",
+ "net = pps.create_empty_network()\n",
+ "\n",
+ "j0 = pps.create_junction(net, 0.1, 283.15)\n",
+ "j1 = pps.create_junction(net, 0.1, 283.15)\n",
+ "j2 = pps.create_junction(net, 0.1, 283.15)\n",
+ "j3 = pps.create_junction(net, 0.1, 283.15)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4cf39a75",
+ "metadata": {},
+ "source": [
+ "The junctions are connected to each other resembling a t-cross network system. Each pipe has a lenght of 400 m and a diameter of 0.1 m. The other values use the default value."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "d6e0dfe6",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "p1 = pps.create_pipe_from_parameters(net, j0, j1, 0.4, 0.1)\n",
+ "p2 = pps.create_pipe_from_parameters(net, j1, j2, 0.4, 0.1)\n",
+ "p3 = pps.create_pipe_from_parameters(net, j1, j3, 0.4, 0.1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7e7cfe84",
+ "metadata": {},
+ "source": [
+ "Next, we define the external grid. Different to the versions before, you need to define a fluid, fed in by the external grid. The external grid is connected to junction 0."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "18dafbdf",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ext = pps.create_ext_grid(net, j0, 0.1, 283.15, fluid='hgas')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5d2616c8",
+ "metadata": {},
+ "source": [
+ "In the following step, we connect the three sinks to junction 1,2, and 3. The mass demand is 0.001, 0.002 and 0.003 kg per s. The sinks are connected to junction 1,2,3."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "01f29339",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "si0 = pps.create_sink(net, j1, 0.001)\n",
+ "si1 = pps.create_sink(net, j2, 0.002)\n",
+ "si2 = pps.create_sink(net, j3, 0.003)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d30ee6f4",
+ "metadata": {},
+ "source": [
+ "Conducting a pipeflow leads to following results:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "7faf58d0",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "pps.pipeflow(net)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0fb4b2fe",
+ "metadata": {},
+ "source": [
+ "The results look as expected showing no other components besides hgas."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "43048a78",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " p_bar | \n",
+ " t_k | \n",
+ " rho_kg_per_m3 | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " 0.100000 | \n",
+ " 283.15 | \n",
+ " 0.751018 | \n",
+ "
\n",
+ " \n",
+ " | 1 | \n",
+ " 0.099272 | \n",
+ " 283.15 | \n",
+ " 0.750526 | \n",
+ "
\n",
+ " \n",
+ " | 2 | \n",
+ " 0.099160 | \n",
+ " 283.15 | \n",
+ " 0.750450 | \n",
+ "
\n",
+ " \n",
+ " | 3 | \n",
+ " 0.099055 | \n",
+ " 283.15 | \n",
+ " 0.750379 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " v_from_m_per_s | \n",
+ " v_to_m_per_s | \n",
+ " v_mean_m_per_s | \n",
+ " p_from_bar | \n",
+ " p_to_bar | \n",
+ " t_from_k | \n",
+ " t_to_k | \n",
+ " mdot_from_kg_per_s | \n",
+ " mdot_to_kg_per_s | \n",
+ " vdot_norm_m3_per_s | \n",
+ " reynolds | \n",
+ " lambda | \n",
+ " normfactor_from | \n",
+ " normfactor_to | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " 1.017211 | \n",
+ " 1.017878 | \n",
+ " 1.017544 | \n",
+ " 0.100000 | \n",
+ " 0.099272 | \n",
+ " 283.15 | \n",
+ " 283.15 | \n",
+ " 0.006 | \n",
+ " -0.006 | \n",
+ " 0.008488 | \n",
+ " 7133.391269 | \n",
+ " 0.046823 | \n",
+ " 0.941184 | \n",
+ " 0.941801 | \n",
+ "
\n",
+ " \n",
+ " | 1 | \n",
+ " 0.339293 | \n",
+ " 0.339327 | \n",
+ " 0.339310 | \n",
+ " 0.099272 | \n",
+ " 0.099160 | \n",
+ " 283.15 | \n",
+ " 283.15 | \n",
+ " 0.002 | \n",
+ " -0.002 | \n",
+ " 0.002829 | \n",
+ " 2377.797090 | \n",
+ " 0.064766 | \n",
+ " 0.941801 | \n",
+ " 0.941896 | \n",
+ "
\n",
+ " \n",
+ " | 2 | \n",
+ " 0.508939 | \n",
+ " 0.509039 | \n",
+ " 0.508989 | \n",
+ " 0.099272 | \n",
+ " 0.099055 | \n",
+ " 283.15 | \n",
+ " 283.15 | \n",
+ " 0.003 | \n",
+ " -0.003 | \n",
+ " 0.004244 | \n",
+ " 3566.695635 | \n",
+ " 0.055794 | \n",
+ " 0.941801 | \n",
+ " 0.941985 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " p_bar | \n",
+ " t_k | \n",
+ " rho_kg_per_m3 | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " 0.100000 | \n",
+ " 283.15 | \n",
+ " 0.751018 | \n",
+ "
\n",
+ " \n",
+ " | 1 | \n",
+ " 0.099272 | \n",
+ " 283.15 | \n",
+ " 0.750526 | \n",
+ "
\n",
+ " \n",
+ " | 2 | \n",
+ " 0.099160 | \n",
+ " 283.15 | \n",
+ " 0.750450 | \n",
+ "
\n",
+ " \n",
+ " | 3 | \n",
+ " 0.099055 | \n",
+ " 283.15 | \n",
+ " 0.750379 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " p_bar | \n",
+ " t_k | \n",
+ " rho_kg_per_m3 | \n",
+ " w_hgas | \n",
+ " w_hydrogen | \n",
+ " rho_kg_per_m3_hgas | \n",
+ " rho_kg_per_m3_hydrogen | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " 0.100000 | \n",
+ " 283.15 | \n",
+ " 0.749343 | \n",
+ " 1.00 | \n",
+ " 0.00 | \n",
+ " 0.751018 | \n",
+ " 0.090643 | \n",
+ "
\n",
+ " \n",
+ " | 1 | \n",
+ " 0.099960 | \n",
+ " 283.15 | \n",
+ " 0.161823 | \n",
+ " 0.50 | \n",
+ " 0.50 | \n",
+ " 0.750991 | \n",
+ " 0.090639 | \n",
+ "
\n",
+ " \n",
+ " | 2 | \n",
+ " 0.099793 | \n",
+ " 283.15 | \n",
+ " 0.116226 | \n",
+ " 0.25 | \n",
+ " 0.75 | \n",
+ " 0.750878 | \n",
+ " 0.090626 | \n",
+ "
\n",
+ " \n",
+ " | 3 | \n",
+ " 0.100251 | \n",
+ " 283.15 | \n",
+ " 0.090718 | \n",
+ " 0.00 | \n",
+ " 1.00 | \n",
+ " 0.751187 | \n",
+ " 0.090663 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "