Compare da3d2d8 ... +60 ... 06d7494

        m = 3 * size / 4

        direc = diff / np.sqrt(diff[0] ** 2 + diff[1] ** 2)

        path1 = (p1 + diff / 2 + direc * m / 2) + normal * (size * 9 / 8)

        path2 = p1 + diff / 2 + direc * m / 2

        path4 = p1 + diff / 2 - direc * m / 2

        path5 = (p1 + diff / 2 - direc * m / 2) + normal * (size * 9 / 8)

        path = [path1, path2, path3, path4, path5]

        radius = size  # np.sqrt(diff[0]**2+diff[1]**2)/15

        line1 = _rotate_dim2(np.array([0, size * np.sqrt(2)]), angle - np.pi / 4)

        line2 = _rotate_dim2(np.array([0, size * np.sqrt(2)]), angle + np.pi / 4)

        lines.append([p1 + diff / 2 + vec_size, p1 + diff / 2 - vec_size + line1])

        lines.append([p1 + diff / 2 + vec_size, p1 + diff / 2 - vec_size + line2])

def pressure_control_patches(coords, size, **kwargs):

    polys, lines = list(), list()

    edgecolor = kwargs.pop('patch_edgecolor')

    colors = get_color_list(edgecolor, len(coords))

    lw = kwargs.get("linewidths", 2.)

    for geodata, col in zip(coords, colors):

        p1, p2 = np.array(geodata[0]), np.array(geodata[-1])

        diff = p2 - p1

        angle = np.arctan2(*diff)

        vec_size = _rotate_dim2(np.array([0, size]), angle)

        vec_size_or = _rotate_dim2(np.array([0, size * 1.2 / 2]), angle + np.pi / 2)

        pll = p1 + diff / 2 - vec_size + vec_size_or

        plr = p1 + diff / 2 - vec_size - vec_size_or

        pul = p1 + diff / 2 + vec_size + vec_size_or/3

        pur = p1 + diff / 2 + vec_size - vec_size_or/3

        polys.append(Rectangle(pll, 2 * size, size * 1.2, angle=np.rad2deg(-angle + np.pi/2),

        lines.append([p1, p1 + diff / 2 - vec_size])

        lines.append([p2, p1 + diff / 2 + vec_size])

        lines.append([pll, pul])

        lines.append([plr, pur])

    return lines, polys, {}

from pandapipes.plotting.patch_makers import valve_patches, source_patches, heat_exchanger_patches, \

def create_pressure_control_collection(net, pcs=None, table_name='press_control',

    pcs = get_index_array(pcs, net[table_name].index)

    pc_table = net[table_name].loc[pcs]

    coords, pcs_with_geo = coords_from_node_geodata(

    if len(pcs_with_geo) == 0:

        return None

    linewidths = kwargs.pop("linewidths", 2.)

    linewidths = kwargs.pop("linewidth", linewidths)

    linewidths = kwargs.pop("lw", linewidths)

    infos = list(np.repeat([infofunc(i) for i in range(len(pcs_with_geo))], 2)) \

    lc, pc = _create_complex_branch_collection(coords, pressure_control_patches, size, infos,

    return lc, pc

PC = 20  # Controlled node with fixed pressure p

        return branch_component_pit

        return placement_table, res_table, branch_pit, node_pit

import numpy as np

from numpy import dtype

from pandapipes.constants import R_UNIVERSAL

from pandapipes.component_models.abstract_models import BranchWZeroLengthComponent, get_fluid, \

from pandapipes.idx_branch import D, AREA, PL, TL, \

from pandapipes.idx_node import PINIT, NODE_TYPE, PC

from pandapipes.internals_toolbox import _sum_by_group

from pandapipes.pipeflow_setup import get_lookup, get_net_option

class PressureControlComponent(BranchWZeroLengthComponent):

    @classmethod

    def table_name(cls):

        return "press_control"

    @classmethod

    def active_identifier(cls):

        return "in_service"

    @classmethod

    def from_to_node_cols(cls):

    @classmethod

    def create_pit_node_entries(cls, net, node_pit, node_name):

        pcs = net[cls.table_name()]

        controlled = pcs.in_service & pcs.control_active

        juncts = pcs['controlled_junction'].values[controlled]

        press = pcs['controlled_p_bar'].values[controlled]

        junction_idx_lookups = get_lookup(net, "node", "index")[node_name]

        index_pc = junction_idx_lookups[juncts]

        node_pit[index_pc, NODE_TYPE] = PC

        node_pit[index_pc, PINIT] = press

    @classmethod

    def create_pit_branch_entries(cls, net, pc_pit, node_name):

        pc_pit = super().create_pit_branch_entries(net, pc_pit, node_name)

        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

    @classmethod

    def calculate_derivatives_hydraulic(cls, net, branch_pit, node_pit, idx_lookups, options):

        press_pit = super().calculate_derivatives_hydraulic(net, branch_pit, node_pit, idx_lookups,

        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

    @classmethod

    def calculate_pressure_lift(cls, net, pc_pit, node_pit):

        pc_pit[:, PL] = 0

    @classmethod

    def calculate_temperature_lift(cls, net, pc_pit, node_pit):

    @classmethod

    def extract_results(cls, net, options, node_name):

        placement_table, res_table, pc_pit, node_pit = super().extract_results(net, options, node_name)

        node_active_idx_lookup = get_lookup(net, "node", "index_active")[node_name]

        junction_idx_lookup = get_lookup(net, "node", "index")[node_name]

        from_junction_nodes = node_active_idx_lookup[junction_idx_lookup[

        to_junction_nodes = node_active_idx_lookup[junction_idx_lookup[

        p_to = node_pit[to_junction_nodes, PINIT]

        p_from = node_pit[from_junction_nodes, PINIT]

        res_table['deltap_bar'].values[placement_table] = p_to - p_from

        return placement_table, res_table, pc_pit

    @classmethod

    def get_component_input(cls):

        return [("name", dtype(object)),

    @classmethod

    def get_result_table(cls, net):

        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",

        output += ["deltap_bar"]

        return output, True