pandapipes 0.12.0.dev2__tar.gz → 0.12.0.dev3__tar.gz

{pandapipes-0.12.0.dev2 → pandapipes-0.12.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pandapipes
-Version: 0.12.0.dev2
+Version: 0.12.0.dev3
 Summary: A pipeflow calculation tool that complements pandapower in the simulation of multi energy grids
 Author-email: Simon Ruben Drauz-Mauel <simon.ruben.drauz-mauel@iee.fraunhofer.de>, Daniel Lohmeier <daniel.lohmeier@retoflow.de>, Jolando Marius Kisse <jolando.kisse@uni-kassel.de>
 License: Copyright (c) 2020-2024 by Fraunhofer Institute for Energy Economics

{pandapipes-0.12.0.dev2 → pandapipes-0.12.0.dev3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pandapipes"
-version = "0.12.0.dev2"  # File format version '__format_version__' is tracked in __init__.py
+version = "0.12.0.dev3"  # File format version '__format_version__' is tracked in __init__.py
 authors=[
     { name = "Simon Ruben Drauz-Mauel", email = "simon.ruben.drauz-mauel@iee.fraunhofer.de" },
     { name = "Daniel Lohmeier", email = "daniel.lohmeier@retoflow.de" },

{pandapipes-0.12.0.dev2 → pandapipes-0.12.0.dev3}/src/pandapipes/component_models/abstract_models/circulation_pump.py

@@ -6,9 +6,10 @@ import numpy as np
 
 from pandapipes.component_models.abstract_models.branch_wzerolength_models import BranchWZeroLengthComponent
 from pandapipes.component_models.component_toolbox import set_fixed_node_entries, standard_branch_wo_internals_result_lookup
-from pandapipes.idx_branch import D, AREA, BRANCH_TYPE, CIRC, LOAD_VEC_BRANCHES_T, TO_NODE
-from pandapipes.idx_node import MDOTSLACKINIT, VAR_MASS_SLACK, JAC_DERIV_MSL
-from pandapipes.pf.pipeflow_setup import get_fluid
+from pandapipes.idx_branch import D, AREA, LOAD_VEC_BRANCHES_T, TO_NODE, TOUTINIT, JAC_DERIV_DT, JAC_DERIV_DTOUT, MDOTINIT
+from pandapipes.idx_node import MDOTSLACKINIT, VAR_MASS_SLACK, JAC_DERIV_MSL, NODE_TYPE_T, GE, TINIT
+from pandapipes.pf.pipeflow_setup import get_fluid, get_lookup
+from pandapipes.pf.internals_toolbox import get_from_nodes_corrected
 from pandapipes.pf.result_extraction import extract_branch_results_without_internals
 
 try:
@@ -42,11 +43,11 @@ class CirculationPump(BranchWZeroLengthComponent):
         :rtype: (list, bool)
         """
         if get_fluid(net).is_gas:
-            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",
+            output = ["p_from_bar", "p_to_bar", "t_from_k",
                       "t_to_k", "t_outlet_k", "mdot_from_kg_per_s", "mdot_to_kg_per_s", "vdot_norm_m3_per_s",
                       "normfactor_from", "normfactor_to"]
         else:
-            output = ["v_mean_m_per_s", "p_from_bar", "p_to_bar", "t_from_k", "t_to_k", "t_outlet_k", "mdot_from_kg_per_s",
+            output = ["p_from_bar", "p_to_bar", "t_from_k", "t_to_k", "t_outlet_k", "mdot_from_kg_per_s",
                       "mdot_to_kg_per_s", "vdot_m3_per_s"]
         output += ['deltat_k', 'qext_w']
         return output, True
@@ -83,11 +84,10 @@ class CirculationPump(BranchWZeroLengthComponent):
         #       not contain "p", as this should not be allowed for this component
         types = circ_pump_tbl.type.values
         p_values = circ_pump_tbl.p_flow_bar.values
-        t_values = circ_pump_tbl.t_flow_k.values
         index_p = set_fixed_node_entries(
             net, node_pit, junction, types, p_values, cls.get_connected_node_type(), 'p')
-        set_fixed_node_entries(net, node_pit, junction, types, t_values, cls.get_connected_node_type(), 't')
         node_pit[index_p, JAC_DERIV_MSL] = -1.
+        node_pit[index_p, NODE_TYPE_T] = GE
         return circ_pump_tbl, p_values
 
     @classmethod
@@ -100,10 +100,11 @@ class CirculationPump(BranchWZeroLengthComponent):
         :type branch_pit:
         :return: No Output.
         """
+        circ_pump_tbl = net[cls.table_name()][net[cls.table_name()][cls.active_identifier()].values]
         circ_pump_pit = super().create_pit_branch_entries(net, branch_pit)
         circ_pump_pit[:, D] = 0.1
         circ_pump_pit[:, AREA] = circ_pump_pit[:, D] ** 2 * np.pi / 4
-        circ_pump_pit[:, BRANCH_TYPE] = CIRC
+        circ_pump_pit[:, TOUTINIT] = circ_pump_tbl.t_flow_k.values
         return circ_pump_pit
 
     @classmethod
@@ -136,6 +137,9 @@ class CirculationPump(BranchWZeroLengthComponent):
         f, t = idx_lookups[cls.table_name()]
         circ_pump_pit = branch_pit[f:t, :]
         circ_pump_pit[:, LOAD_VEC_BRANCHES_T] = 0
+        circ_pump_pit[:, JAC_DERIV_DTOUT] = 1
+        circ_pump_pit[:, JAC_DERIV_DT] = 0
+
 
     @classmethod
     def extract_results(cls, net, options, branch_results, mode):
@@ -152,8 +156,32 @@ class CirculationPump(BranchWZeroLengthComponent):
         :type options:
         :return: No Output.
         """
+        node_pit = net['_pit']['node']
+        branch_pit = net['_pit']['branch']
+        branch_lookups = get_lookup(net, "branch", "from_to")
+        f, t = branch_lookups[cls.table_name()]
+
+        mask = branch_pit[f:t, MDOTINIT] < 0
+        if np.any(mask):
+            raise UserWarning(r'Your grid is badly modelled and would lead to a direction change in circulation pump %s'
+                              % str(net[cls.table_name()].index[mask].tolist()))
 
         required_results_hyd, required_results_ht = standard_branch_wo_internals_result_lookup(net)
 
         extract_branch_results_without_internals(net, branch_results, required_results_hyd, required_results_ht,
                                                  cls.table_name(), mode)
+
+        res_table = net["res_" + cls.table_name()]
+
+        from_nodes = get_from_nodes_corrected(branch_pit[f:t])
+        t_from = node_pit[from_nodes, TINIT]
+        tout = branch_pit[f:t, TOUTINIT]
+        res_table['deltat_k'].values[:] = t_from - tout
+
+        fluid = get_fluid(net)
+
+        cp_i = fluid.get_heat_capacity(t_from)
+        cp_i1 = fluid.get_heat_capacity(tout)
+
+        mass = branch_pit[f:t, MDOTINIT]
+        res_table['qext_w'].values[:] = mass * (cp_i1 * tout - cp_i * t_from)

{pandapipes-0.12.0.dev2 → pandapipes-0.12.0.dev3}/src/pandapipes/component_models/flow_control_component.py

@@ -124,10 +124,9 @@ class FlowControlComponent(BranchWZeroLengthComponent):
         if get_fluid(net).is_gas:
             output = ["p_from_bar", "p_to_bar",
                       "t_from_k", "t_to_k", "t_outlet_k", "mdot_from_kg_per_s", "mdot_to_kg_per_s",
-                      "vdot_norm_m3_per_s", "reynolds", "lambda", "normfactor_from",
+                      "vdot_norm_m3_per_s", "normfactor_from",
                       "normfactor_to"]
         else:
             output = ["p_from_bar", "p_to_bar", "t_from_k", "t_to_k", "t_outlet_k",
-                      "mdot_from_kg_per_s", "mdot_to_kg_per_s", "vdot_m3_per_s", "reynolds",
-                      "lambda"]
+                      "mdot_from_kg_per_s", "mdot_to_kg_per_s", "vdot_m3_per_s"]
         return output, True

{pandapipes-0.12.0.dev2 → pandapipes-0.12.0.dev3}/src/pandapipes/component_models/heat_consumer_component.py

@@ -238,11 +238,11 @@ class HeatConsumer(BranchWZeroLengthComponent):
         """
         if get_fluid(net).is_gas:
             output = ["p_from_bar", "p_to_bar", "t_from_k",
-                      "t_to_k", "t_outlet_k", "mdot_from_kg_per_s", "mdot_to_kg_per_s", "vdot_norm_m3_per_s", "reynolds", "lambda",
+                      "t_to_k", "t_outlet_k", "mdot_from_kg_per_s", "mdot_to_kg_per_s", "vdot_norm_m3_per_s",
                       "normfactor_from", "normfactor_to"]
         else:
             output = ["p_from_bar", "p_to_bar", "t_from_k", "t_to_k", "t_outlet_k", "mdot_from_kg_per_s",
-                      "mdot_to_kg_per_s", "vdot_m3_per_s", "reynolds", "lambda"]
+                      "mdot_to_kg_per_s", "vdot_m3_per_s"]
         output += ['deltat_k', 'qext_w']
         return output, True
 

{pandapipes-0.12.0.dev2 → pandapipes-0.12.0.dev3}/src/pandapipes/component_models/heat_exchanger_component.py

@@ -105,10 +105,9 @@ class HeatExchanger(BranchWZeroLengthComponent):
         if get_fluid(net).is_gas:
             output = ["p_from_bar", "p_to_bar",
                       "t_from_k", "t_to_k", "t_outlet_k", "mdot_from_kg_per_s", "mdot_to_kg_per_s",
-                      "vdot_norm_m3_per_s", "reynolds", "lambda", "normfactor_from",
+                      "vdot_norm_m3_per_s", "normfactor_from",
                       "normfactor_to"]
         else:
             output = ["p_from_bar", "p_to_bar", "t_from_k", "t_to_k", "t_outlet_k",
-                      "mdot_from_kg_per_s", "mdot_to_kg_per_s", "vdot_m3_per_s", "reynolds",
-                      "lambda"]
+                      "mdot_from_kg_per_s", "mdot_to_kg_per_s", "vdot_m3_per_s"]
         return output, True

{pandapipes-0.12.0.dev2 → pandapipes-0.12.0.dev3}/src/pandapipes/create.py

@@ -756,6 +756,9 @@ def create_circ_pump_const_pressure(net, return_junction, flow_junction, p_flow_
         >>>                                 t_flow_k=350, type="p")
 
     """
+    logger.info(r"The circulation pump's behaviour has changed. Rather than setting a slack temperature node, "
+                r"the outlet temperature of the circulation pump is now fixed. In most cases this does not change, "
+                r"the outcome, but be aware of the adaptations!")
 
     add_new_component(net, CirculationPumpPressure)
 
@@ -820,6 +823,9 @@ def create_circ_pump_const_mass_flow(net, return_junction, flow_junction, p_flow
         >>>                                  t_flow_k=350, type="pt")
 
     """
+    logger.info(r"The circulation pump's behaviour has changed. Rather than setting a slack temperature node, "
+                r"the outlet temperature of the circulation pump is now fixed. In most cases this does not change, "
+                r"the outcome, but be aware of the adaptations!")
 
     add_new_component(net, CirculationPumpMass)
 

{pandapipes-0.12.0.dev2 → pandapipes-0.12.0.dev3}/src/pandapipes/idx_branch.py

@@ -3,8 +3,7 @@
 # Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
 
 # branch types
-CIRC = 1  # Circ pump branch
-PC = 2  # Pressure controller branch
+PC = 1  # Pressure controller branch
 
 # branch indices
 TABLE_IDX = 0  # number of the table that this branch belongs to

{pandapipes-0.12.0.dev2 → pandapipes-0.12.0.dev3}/src/pandapipes/idx_node.py

@@ -7,6 +7,7 @@ P = 1  # Reference node, pressure is fixed
 L = 2  # All other nodes
 T = 3  # Reference node with fixed temperature, otherwise 0
 PC = 4  # Controlled node with fixed pressure p
+GE = 5
 
 # node indices
 TABLE_IDX = 0  # number of the table that this node belongs to

{pandapipes-0.12.0.dev2 → pandapipes-0.12.0.dev3}/src/pandapipes/pf/derivative_calculation.py

@@ -9,7 +9,7 @@ from pandapipes.idx_branch import (LENGTH, D, K, RE, LAMBDA, LOAD_VEC_BRANCHES,
                                    LOAD_VEC_NODES_FROM, LOAD_VEC_NODES_TO,
                                    LOAD_VEC_NODES_FROM_T,
                                    LOAD_VEC_NODES_TO_T, JAC_DERIV_DTOUT, JAC_DERIV_DTOUT_NODE,
-                                   MDOTINIT, BRANCH_TYPE, CIRC)
+                                   MDOTINIT)
 from pandapipes.idx_node import (
     TINIT as TINIT_NODE,
     INFEED,
@@ -119,7 +119,6 @@ def calculate_derivatives_thermal(net, branch_pit, node_pit, _):
     alpha = branch_pit[:, ALPHA] * np.pi * branch_pit[:, D]
     tl = branch_pit[:, TL]
     qext = branch_pit[:, QEXT]
-    no_cp = branch_pit[:, BRANCH_TYPE] != CIRC
     infeed_node = None
 
     node_pit[:, LOAD_T] = node_pit[:, LOAD] * cp_n * t_init_n + node_pit[:, MDOTSLACKINIT] * cp_n * t_init_n
@@ -206,8 +205,8 @@ def calculate_derivatives_thermal(net, branch_pit, node_pit, _):
             branch_pit[fn_zero, LOAD_VEC_NODES_FROM_T] = 0
             branch_pit[tn_zero, LOAD_VEC_NODES_TO_T] = 0
 
-            from_nodes_not_zero = from_nodes[no_cp & ~nodes_zero_fl[from_nodes]]
-            to_nodes_not_zero = to_nodes[no_cp & ~nodes_zero_fl[to_nodes]]
+            from_nodes_not_zero = from_nodes[~nodes_zero_fl[from_nodes]]
+            to_nodes_not_zero = to_nodes[~nodes_zero_fl[to_nodes]]
             infeed_node = np.setdiff1d(from_nodes_not_zero, to_nodes_not_zero)
 
     else:
@@ -220,7 +219,7 @@ def calculate_derivatives_thermal(net, branch_pit, node_pit, _):
                     t_amb - t_m) * length + qext
 
     if infeed_node is None:
-        infeed_node = np.setdiff1d(from_nodes[no_cp], to_nodes[no_cp])
+        infeed_node = np.setdiff1d(from_nodes, to_nodes)
     node_pit[:, INFEED] = False
     node_pit[infeed_node, INFEED] = True
 

{pandapipes-0.12.0.dev2 → pandapipes-0.12.0.dev3}/src/pandapipes/pf/pipeflow_setup.py

@@ -17,12 +17,9 @@ from pandapipes.idx_branch import (
     ACTIVE as ACTIVE_BR,
     FLOW_RETURN_CONNECT,
     ACTIVE,
-    BRANCH_TYPE,
-    CIRC,
 )
 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, INFEED
-from pandapipes.pf.internals_toolbox import _sum_by_group
+    TABLE_IDX as TABLE_IDX_ND, ELEMENT_IDX as ELEMENT_IDX_ND, INFEED, GE
 from pandapipes.properties.fluids import get_fluid
 
 try:
@@ -521,69 +518,42 @@ def identify_active_nodes_branches(net, hydraulic=True):
     branch_pit = net["_pit"]["branch"]
 
     if hydraulic:
-        # connectivity check for hydraulic simulation
+        nodes_connected = node_pit[:, ACTIVE_ND].astype(np.bool_)
+        branches_connected = branch_pit[:, ACTIVE_BR].astype(np.bool_)
         if get_net_option(net, "check_connectivity"):
-            nodes_connected, branches_connected = check_connectivity(net, branch_pit, node_pit)
-        else:
-            # if connectivity check is switched off, still consider oos elements
-            nodes_connected = node_pit[:, ACTIVE_ND].astype(np.bool_)
-            branches_connected = branch_pit[:, ACTIVE_BR].astype(np.bool_)
+            nodes_connected, branches_connected = check_connectivity(net, branch_pit, node_pit,
+                                                                     branches_connected, nodes_connected,
+                                                                     mode="hydraulics")
     else:
-        # connectivity check for heat simulation (needs to consider branches with 0 velocity as
-        # well)
+        nodes_connected = get_lookup(net, "node", "active_hydraulics")
+        branches_connected = get_lookup(net, "branch", "active_hydraulics")
         if get_net_option(net, "check_connectivity"):
-            # full connectivity check for hydraulic simulation
             nodes_connected, branches_connected = check_connectivity(net, branch_pit, node_pit,
+                                                                     branches_connected, nodes_connected,
                                                                      mode="heat_transfer")
-        else:
-            # if no full connectivity check is performed, all nodes that are not connected to the
-            # rest of the network wrt. flow can be identified by a more performant sum_by_group_call
-            # check for branches that are not traversed (for temperature calculation, this means
-            # that they are "out of service")
-
-            if get_net_option(net, "transient"):
-                branches_connected = np.copy(get_lookup(net, "branch", "active_hydraulics"))
-                nodes_connected = np.copy(get_lookup(net, "node", "active_hydraulics"))
-            else:
-                fn = branch_pit[:, FROM_NODE].astype(np.int32)
-                tn = branch_pit[:, TO_NODE].astype(np.int32)
-                branches_connected = get_lookup(
-                    net, "branch", "active_hydraulics"
-                ) & branches_connected_flow(branch_pit)
-                fn_tn, flow = _sum_by_group(
-                    get_net_option(net, "use_numba"),
-                    np.concatenate([fn, tn]),
-                    np.concatenate([branches_connected, branches_connected]).astype(
-                        np.int32
-                    ),
-                )
-                nodes_connected = np.copy(get_lookup(net, "node", "active_hydraulics"))
-                # set nodes oos that are not connected to any branches with flow > 0 (0.1 is arbitrary
-                # here, any value between 0 and 1 should work, excluding 0 and 1)
-                nodes_connected[fn_tn] = nodes_connected[fn_tn] & (flow > 0.1)
+        fn = branch_pit[:, FROM_NODE].astype(np.int32)
+        tn = branch_pit[:, TO_NODE].astype(np.int32)
+        branches_flow = branches_not_zero_flow(branch_pit)
+        nodes_flow = np.isin(np.arange(len(nodes_connected)), np.concatenate([fn[branches_flow], tn[branches_flow]]))
 
         if get_net_option(net, "transient"):
-            fn = branch_pit[:, FROM_NODE].astype(np.int32)
-            tn = branch_pit[:, TO_NODE].astype(np.int32)
-            branches_zero = branches_zero_flow(branch_pit)
-            connected_branches_not_zero = branches_connected & ~branches_zero
-            nodes_zero = ~np.isin(
-                np.arange(len(nodes_connected)),
-                np.concatenate([fn[connected_branches_not_zero], tn[connected_branches_not_zero]])
-            ) & nodes_connected
-            net["_lookups"]["node_zero_flow"] = nodes_zero
-            net["_lookups"]["branch_zero_flow"] = branches_zero
+            net["_lookups"]["branch_zero_flow"] = ~branches_flow & branches_connected
+            net["_lookups"]["node_zero_flow"] = ~nodes_flow & nodes_connected
+        else:
+            branches_connected = branches_flow & branches_connected
+            nodes_connected = nodes_flow & nodes_connected
+
     mode = "hydraulics" if hydraulic else "heat_transfer"
     if np.all(~nodes_connected):
         mode = 'hydraulic' if hydraulic else 'heat transfer'
         raise PipeflowNotConverged(" All nodes are set out of service. Probably they are not supplied."
                                    " Therefore, the %s pipeflow did not converge. "
-                                   " Have you forgotten to define an external grid?" % mode)
+                                   " Have you forgotten to define a supply component or is it not properly connected?" % mode)
     net["_lookups"]["node_active_" + mode] = nodes_connected
     net["_lookups"]["branch_active_" + mode] = branches_connected
 
 
-def branches_connected_flow(branch_pit):
+def branches_not_zero_flow(branch_pit):
     """
     Simple function to identify branches with flow based on the calculated velocity.
 
@@ -593,25 +563,12 @@ def branches_connected_flow(branch_pit):
     :rtype: np.array
     """
     # TODO: is this formulation correct or could there be any caveats?
-    return ~np.isnan(branch_pit[:, MDOTINIT]) \
-        & ~np.isclose(branch_pit[:, MDOTINIT], 0, rtol=1e-10, atol=1e-10)
+    return ~np.isnan(branch_pit[:, MDOTINIT]) & ~np.isclose(branch_pit[:, MDOTINIT], 0, rtol=1e-10, atol=1e-10)
 
 
-def branches_zero_flow(branch_pit):
-    """
-    Simple function to identify branches with flow based on the calculated velocity.
-
-    :param branch_pit: The pandapipes internal table of the network (including hydraulics results)
-    :type branch_pit: np.array
-    :return: branches_connected_flow - lookup array if branch is connected wrt. flow
-    :rtype: np.array
-    """
-    # TODO: is this formulation correct or could there be any caveats?
-    return ~np.isnan(branch_pit[:, MDOTINIT]) \
-        & np.isclose(branch_pit[:, MDOTINIT], 0, rtol=1e-10, atol=1e-10)
-
-
-def check_connectivity(net, branch_pit, node_pit, mode="hydraulics"):
+def check_connectivity(net, branch_pit, node_pit,
+                       branches_connected, nodes_connected,
+                       mode="hydraulics"):
     """
     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:
@@ -637,6 +594,10 @@ def check_connectivity(net, branch_pit, node_pit, mode="hydraulics"):
     :type branch_pit: np.array
     :param node_pit: Internal array with node entries
     :type node_pit: np.array
+    :param branches_connected: Array of bool if branches are connected or not
+    :type branches_connected: np.array(bool)
+    :param nodes_connected: Array of bool if nodes are connected or not
+    :type nodes_connected: np.array(bool)
     :param mode: two modes exist: "hydraulics" and "heat_transfer", representing the two modes of \
         the pipeflow calculation.
     :type mode: str
@@ -645,37 +606,29 @@ def check_connectivity(net, branch_pit, node_pit, mode="hydraulics"):
     :rtype: tuple(np.array)
     """
     if mode == "hydraulics":
-        active_branch_lookup = branch_pit[:, ACTIVE_BR].astype(np.bool_)
-        active_node_lookup = node_pit[:, ACTIVE_ND].astype(np.bool_)
-        slacks = np.where((node_pit[:, NODE_TYPE] == P) & active_node_lookup)[0]
+        slacks = np.where((node_pit[:, NODE_TYPE] == P) & nodes_connected)[0]
     else:
-        if get_net_option(net, "transient"):
-            active_branch_lookup = get_lookup(net, "branch", "active_hydraulics")
-        else:
-            active_branch_lookup = branches_connected_flow(branch_pit) \
-                                   & get_lookup(net, "branch", "active_hydraulics")
-        active_node_lookup = node_pit[:, ACTIVE_ND].astype(np.bool_) \
-                             & get_lookup(net, "node", "active_hydraulics")
-        slacks = np.where((node_pit[:, NODE_TYPE_T] == T) & active_node_lookup)[0]
+        slacks = np.where(((node_pit[:, NODE_TYPE_T] == T) | (node_pit[:, NODE_TYPE_T] == GE)) & nodes_connected)[0]
 
-    return perform_connectivity_search(net, node_pit, branch_pit, slacks, active_node_lookup,
-                                       active_branch_lookup, mode=mode)
+    return perform_connectivity_search(net, node_pit, branch_pit, slacks,
+                                       nodes_connected, branches_connected, mode=mode)
 
 
 def perform_connectivity_search(net, node_pit, branch_pit, slack_nodes, active_node_lookup, active_branch_lookup,
                                 mode="hydraulics"):
-    connect = branch_pit[:, FLOW_RETURN_CONNECT].astype(bool)
-    circ = branch_pit[:, BRANCH_TYPE] == CIRC
-    if np.any(circ) and mode == 'hydraulics':
+    if mode == 'hydraulics':
+        connect = branch_pit[:, FLOW_RETURN_CONNECT].astype(bool)
         active_branch_lookup = active_branch_lookup & ~connect
-    nodes_connected, branches_connected = (
-        _connectivity(net, branch_pit, node_pit, active_branch_lookup, active_node_lookup, slack_nodes, mode))
-    if np.any(connect) and mode == 'hydraulics':
+        nodes_connected, branches_connected = (
+            _connectivity(net, branch_pit, node_pit, active_branch_lookup, active_node_lookup, slack_nodes, mode))
         from_nodes = branch_pit[:, FROM_NODE].astype(np.int32)
         to_nodes = branch_pit[:, TO_NODE].astype(np.int32)
         branch_active = branch_pit[:, ACTIVE].astype(bool)
         active = nodes_connected[from_nodes] & nodes_connected[to_nodes] & branch_active
         branches_connected[connect & active] = True
+    else:
+        nodes_connected, branches_connected = (
+            _connectivity(net, branch_pit, node_pit, active_branch_lookup, active_node_lookup, slack_nodes, mode))
     return nodes_connected, branches_connected
 
 

{pandapipes-0.12.0.dev2 → pandapipes-0.12.0.dev3}/src/pandapipes/test/api/test_components/test_circ_pump_mass.py

@@ -35,7 +35,7 @@ def test_circulation_pump_constant_mass(use_numba):
     pandapipes.create_fluid_from_lib(net, "water", overwrite=True)
 
     max_iter_hyd = 4 if use_numba else 4
-    max_iter_therm = 4 if use_numba else 4
+    max_iter_therm = 6 if use_numba else 6
     pandapipes.pipeflow(net, max_iter_hyd=max_iter_hyd, max_iter_therm=max_iter_therm,
                         stop_condition="tol", friction_model="nikuradse",
                         mode='sequential', transient=False, nonlinear_method="automatic",

{pandapipes-0.12.0.dev2 → pandapipes-0.12.0.dev3}/src/pandapipes/test/api/test_components/test_circ_pump_pressure.py

@@ -36,7 +36,7 @@ def test_circulation_pump_constant_pressure(use_numba):
     pandapipes.create_fluid_from_lib(net, "water", overwrite=True)
 
     max_iter_hyd = 8 if use_numba else 8
-    max_iter_therm = 4 if use_numba else 4
+    max_iter_therm = 7 if use_numba else 7
     pandapipes.pipeflow(net, max_iter_hyd=max_iter_hyd, max_iter_therm=max_iter_therm,
                         stop_condition="tol", friction_model="nikuradse",
                         mode='sequential', transient=False, nonlinear_method="automatic",

{pandapipes-0.12.0.dev2 → pandapipes-0.12.0.dev3}/src/pandapipes/test/api/test_special_networks.py

@@ -9,7 +9,7 @@ import pytest
 
 import pandapipes
 from pandapipes.create import create_empty_network, create_junction, create_ext_grid, create_sink, create_source
-from pandapipes.pf.pipeflow_setup import get_net_option
+from pandapipes.pf.pipeflow_setup import get_net_option, PipeflowNotConverged
 from pandapipes.test.pipeflow_internals.test_inservice import create_test_net
 from pandapipes.test.test_toolbox import create_net_changed_indices
 
@@ -125,60 +125,74 @@ def test_wild_indexing(create_net_changed_indices):
 
 def test_valve_flow_contrl_heat_consumer():
     net = pandapipes.create_empty_network(fluid='water')
-    j1, j2, j3, j4, j5, j6, j7, j8, j9 = pandapipes.create_junctions(net, 9, 5, 400)
-    pandapipes.create_circ_pump_const_pressure(net, j9, j1, 5, 2, 400)
-    pandapipes.create_valves(net, [j1, j4, j6, j8], [j2, j5, j7, j9], 0.1)
-    pandapipes.create_flow_control(net, j3, j2, 10)
-    pandapipes.create_heat_exchanger(net, j8, j3, -5000)
-    pandapipes.create_pipes_from_parameters(net, [j2, j7], [j4, j8], 0.1, 0.1)
-    pandapipes.create_heat_consumer(net, j5, j6, 10000, 10)
+    j1f, j2f, j3f, j4f, j1r, j2r, j3r, j4r, j5 = pandapipes.create_junctions(net, 9, 5, 400)
+    pandapipes.create_circ_pump_const_pressure(net, j4r, j1f, 5, 2, 400)
+    pandapipes.create_valves(net, [j1f, j3f, j1r, j3r], [j2f, j4f, j2r, j4r], 0.1)
+    pandapipes.create_flow_control(net, j2f, j5, 10)
+    pandapipes.create_heat_exchanger(net, j5, j3r, 5000)
+    pandapipes.create_pipes_from_parameters(net, [j2f, j2r], [j3f, j3r], 0.1, 0.1)
+    pandapipes.create_heat_consumer(net, j4f, j1r, 10000, 10)
+
     net.valve.loc[0, 'opened'] = False
-    pandapipes.pipeflow(net, mode='sequential')
+    with pytest.raises(PipeflowNotConverged):
+        pandapipes.pipeflow(net, mode='sequential')
 
     amb_temp = get_net_option(net, 'ambient_temperature')
 
-    assert np.all(np.isclose(net.res_junction.loc[[j9, j8, j7, j6, j3], 'p_bar'].values, 3.))
-    assert np.all(np.isnan(net.res_junction.loc[[j5, j4, j2], 'p_bar']).values)
-    assert np.all(np.isclose(net.res_junction.loc[[j1], 'p_bar'].values, 5.))
-    assert np.all(np.isclose(net.res_junction.t_k.values[1:], amb_temp))
+    pandapipes.pipeflow(net, mode='hydraulics')
+
+    assert np.all(np.isclose(net.res_junction.loc[[j1r, j2r, j3r, j4r, j5], 'p_bar'].values, 3.))
+    assert np.all(np.isnan(net.res_junction.loc[[j2f, j3f, j4f], 'p_bar']).values)
+    assert np.all(np.isclose(net.res_junction.loc[[j1f], 'p_bar'].values, 5.))
 
     net.valve.loc[0, 'opened'] = True
     net.valve.loc[3, 'opened'] = False
-    pandapipes.pipeflow(net, mode='sequential')
+    with pytest.raises(PipeflowNotConverged):
+        pandapipes.pipeflow(net, mode='sequential')
+
+    pandapipes.pipeflow(net, mode='hydraulics')
 
-    assert np.all(np.isclose(net.res_junction.loc[[j9], 'p_bar'].values, 3.))
-    assert np.all(np.isnan(net.res_junction.loc[[j8, j7, j6, j3], 'p_bar']).values)
-    assert np.all(np.isclose(net.res_junction.loc[[j1, j2, j4, j5], 'p_bar'].values, 5.))
-    assert np.all(np.isclose(net.res_junction.t_k.values[1:], amb_temp))
+    assert np.all(np.isclose(net.res_junction.loc[[j4r], 'p_bar'].values, 3.))
+    assert np.all(np.isnan(net.res_junction.loc[[j5, j1r, j2r, j3r], 'p_bar']).values)
+    assert np.all(np.isclose(net.res_junction.loc[[j1f, j2f, j3f, j4f], 'p_bar'].values, 5.))
 
     net.valve.loc[3, 'opened'] = True
     net.valve.loc[1, 'opened'] = False
     pandapipes.pipeflow(net, mode='sequential')
 
-    assert np.all(np.isclose(net.res_junction.loc[[j9, j8, j7, j6, j3], 'p_bar'].values, 3.))
-    assert np.all(np.isnan(net.res_junction.loc[[j5], 'p_bar']).values)
-    assert np.all(np.isclose(net.res_junction.loc[[j1, j2, j4], 'p_bar'].values, 5.))
-    assert np.all(np.isclose(net.res_junction.t_k.values[[j4, j5, j6, j7]], amb_temp))
+    assert np.all(np.isclose(net.res_junction.loc[[j4r, j3r, j2r, j1r, j5], 'p_bar'].values, 3.))
+    assert np.all(np.isnan(net.res_junction.loc[[j4f], 'p_bar']).values)
+    assert np.all(np.isclose(net.res_junction.loc[[j1f, j2f, j3f], 'p_bar'].values, 5.))
+    assert np.all(np.isclose(net.res_junction.t_k.values[[j3f, j4f, j1r, j2r]], amb_temp))
 
     net.valve.loc[1, 'opened'] = True
     net.valve.loc[2, 'opened'] = False
     pandapipes.pipeflow(net, mode='sequential')
 
-    assert np.all(np.isclose(net.res_junction.loc[[j9, j8, j7, j3], 'p_bar'].values, 3.))
-    assert np.all(np.isnan(net.res_junction.loc[[j6], 'p_bar']).values)
-    assert np.all(np.isclose(net.res_junction.loc[[j1, j2, j4, j5], 'p_bar'].values, 5.))
-    assert np.all(np.isclose(net.res_junction.t_k.values[[j4, j5, j6, j7]], amb_temp))
+    assert np.all(np.isclose(net.res_junction.loc[[j4r, j3r, j2r, j5], 'p_bar'].values, 3.))
+    assert np.all(np.isnan(net.res_junction.loc[[j1r], 'p_bar']).values)
+    assert np.all(np.isclose(net.res_junction.loc[[j1f, j2f, j3f, j4f], 'p_bar'].values, 5.))
+    assert np.all(np.isclose(net.res_junction.t_k.values[[j3f, j4f, j1r, j2r]], amb_temp))
 
     net.valve.loc[1, 'opened'] = False
     pandapipes.pipeflow(net, mode='sequential')
 
-    assert np.all(np.isnan(net.res_junction.p_bar.values[4:6]))
+    assert np.all(np.isnan(net.res_junction.loc[[j1r, j4f], 'p_bar'].values))
 
     net.valve.loc[:, 'opened'] = False
-    pandapipes.pipeflow(net, mode='sequential')
+    with pytest.raises(PipeflowNotConverged):
+        pandapipes.pipeflow(net, mode='sequential')
 
     assert np.all(np.isnan(net.res_junction.p_bar.values[1:-1]))
 
+    net.heat_consumer.loc[0, 'controlled_mdot_kg_per_s'] = 11
+    net.valve.loc[:, 'opened'] = True
+    net.valve.loc[3, 'opened'] = False
+    pandapipes.create_circ_pump_const_pressure(net, j3r, j1f, 5, 2, 400)
+
+    pandapipes.pipeflow(net, mode='sequential')
+
+
 
 if __name__ == "__main__":
     pytest.main([r'pandapipes/test/api/test_special_networks.py'])

{pandapipes-0.12.0.dev2 → pandapipes-0.12.0.dev3}/src/pandapipes.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pandapipes
-Version: 0.12.0.dev2
+Version: 0.12.0.dev3
 Summary: A pipeflow calculation tool that complements pandapower in the simulation of multi energy grids
 Author-email: Simon Ruben Drauz-Mauel <simon.ruben.drauz-mauel@iee.fraunhofer.de>, Daniel Lohmeier <daniel.lohmeier@retoflow.de>, Jolando Marius Kisse <jolando.kisse@uni-kassel.de>
 License: Copyright (c) 2020-2024 by Fraunhofer Institute for Energy Economics