orientation=-angle + np.pi / 3, ec=col, fc=face_col, lw=lw))

                               edgecolor=col, facecolor='w', lw=lw))

            '%s is already in net.std_type["%s"]. Set overwrite=True if you want to change values!'

    pump_patches, pressure_control_patches

                                       size=5., junction_geodata=None,

                                       color='k', infofunc=None, picker=False, **kwargs):

    """

    Creates a matplotlib patch collection of pandapipes junction-junction valves. Valves are

    plotted in the center between two junctions with a "helper" line (dashed and thin) being drawn

    between the junctions as well.

    :param net: The pandapipes network

    :type net: pandapipesNet

    :param valves: The valves for which the collections are created. If None, all valves which have\

        entries in the respective junction geodata will be plotted.

    :type valves: list, default None

    :param size: Patch size

    :type size: float, default 5.

    :param junction_geodata: Coordinates to use for plotting. If None, net["junction_geodata"] is used.

    :type junction_geodata: pandas.DataFrame, default None

    :param colors: Color or list of colors for every valve

    :type colors: iterable, float, default None

    :param infofunc: infofunction for the patch element

    :type infofunc: function, default None

    :param picker: Picker argument passed to the patch collection

    :type picker: bool, default False

    :param fill_closed: If True, valves with parameter opened == False will be filled and those\

        with opened == True will have a white facecolor. Vice versa if False.

    :type fill_closed: bool, default True

    :param kwargs: Keyword arguments are passed to the patch function

    :return: lc - line collection, pc - patch collection

    """

        pcs, pc_table.from_junction.values, pc_table.to_junction.values,

        junction_geodata if junction_geodata is not None else net["junction_geodata"], table_name,

        "Junction")

        if infofunc is not None else []

                                               picker=picker, linewidths=linewidths,

                                               patch_edgecolor=color, line_color=color,

                                               **kwargs)

    create_valve_collection, create_source_collection, create_pressure_control_collection, \

    create_heat_exchanger_collection, create_sink_collection, create_pump_collection

                heat_exchanger_size=1.0, pressure_control_size=1.0, scale_size=True,

                junction_color="r", pipe_color='silver', ext_grid_color='orange',

                valve_color='silver', pump_color='silver', heat_exchanger_color='silver',

                pressure_control_color='silver', library="igraph", show_plot=True, ax=None,

                **kwargs):

    :param pressure_control_size: Relative size of pres_control to plot.

    :type pressure_control_size: float, default 1.0

    :param pressure_control_color: Pressure Control Color.

    :type pressure_control_color: str, tuple, default "silver"

        heat_exchanger_size, pressure_control_size, scale_size, junction_color, pipe_color,

        ext_grid_color, valve_color, pump_color, heat_exchanger_color, pressure_control_color,

        library, as_dict=False, **kwargs)

                              pump_size=1.0, heat_exchanger_size=1.0, pressure_control_size=1.0,

                              scale_size=True, junction_color="r", pipe_color='silver',

                              ext_grid_color='orange', valve_color='silver', pump_color='silver',

                              heat_exchanger_color='silver', pressure_control_color='silver',

                              library="igraph", as_dict=True, **kwargs):

    :param heat_exchanger_size: Relative size of heat_exchanger to plot.

    :type heat_exchanger_size: float, default 1.0

    :param pressure_control_size: Relative size of pres_control to plot.

    :type pressure_control_size: float, default 1.0

    :param pressure_control_color: Pressure Control Color.

    :type pressure_control_color: str, tuple, default "silver"

            net, junction_size, ext_grid_size, sink_size, source_size, valve_size, pump_size,

            heat_exchanger_size, pressure_control_size)

                net, pcs=net.press_control[net.press_control.in_service].index,

                size=pressure_control_size, linewidths=pipe_width, color=pressure_control_color)

        else:

                net, size=pressure_control_size, linewidths=pipe_width,

                color=pressure_control_color)

    ACTIVE as ACTIVE_ND, TABLE_IDX as TABLE_IDX_ND, ELEMENT_IDX as ELEMENT_IDX_ND, PC

                   BranchWInternalsComponent, PressureControlComponent):

                issubclass(comp, NodeElementComponent) | \

                (comp==PressureControlComponent):

                          & active_node_lookup)[0]

    :param fluid_name: Fluid which should be used

    :type fluid_name: str

            os.path.join(pp_dir, "properties", fluid_name, prop + ".txt"))

            os.path.join(pp_dir, "properties", fluid_name, prop + ".txt"))

            os.path.join(pp_dir, "properties", fluid_name, prop + ".txt"))

                             "implemented yet." % fluid_name)

    JAC_DERIV_DT_NODE, LOAD_VEC_NODES_T, LOAD_VEC_BRANCHES_T, FROM_NODE_T, TO_NODE_T, BRANCH_TYPE

        (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)

        # pc_nodes and p_nodes

            # pc_nodes

                           "heat_exchanger", "press_control"]

                or el in branch_elements)

                         valve_size=2.0, pump_size=1.0, heat_exchanger_size=1.0, pressure_control_size=1.0):

        "pump": pump_size * mean_distance_between_junctions * 8,

        "pressure_control": pressure_control_size * mean_distance_between_junctions * 8,

        :param branch_pit:

        :type branch_pit:

# Copyright (c) 2020 by Fraunhofer Institute for Energy Economics

# 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.

    TINIT_NODE

    JAC_DERIV_DP, JAC_DERIV_DP1, JAC_DERIV_DV, BRANCH_TYPE, FROM_NODE, TO_NODE, VINIT, \

    LOAD_VEC_NODES, ELEMENT_IDX, LOSS_COEFFICIENT as LC

    """

    """

        """

        Function which creates pit branch entries with a specific table.

        :param net: The pandapipes network

        :type net: pandapipesNet

        :param pc_pit:

        :type pc_pit:

        :param node_name:

        :type node_name:

        :return: No Output.

        """

                                                            options)

        """

        :param net: The pandapipes network

        :type net: pandapipesNet

        :param pc_pit:

        :type pc_pit:

        :param node_pit:

        :type node_pit:

        :return: power stroke

        :rtype: float

        """

        """

        :param net:

        :type net:

        :param pc_pit:

        :type pc_pit:

        :param node_pit:

        :type node_pit:

        :return:

        :rtype:

        """

        """

        Function that extracts certain results.

        :param net: The pandapipes network

        :type net: pandapipesNet

        :param options:

        :type options:

        :param node_name:

        :type node_name:

        :return: No Output.

        """

            net[cls.table_name()]["from_junction"].values[placement_table]]]

            net[cls.table_name()]["to_junction"].values[placement_table]]]

            _sum_by_group(idx_active, mf, vf, np.ones_like(idx_active))

            # 'kappa' heat capacity ratio:

                            (np.divide(p_to, p_from) ** ((k - 1) / k) - 1)

                w_real_isentr * abs(mf_sum / internal_pipes)

        """

        Get component input.

        :return:

        :rtype:

        """

                ("from_junction", "u4"),

                ("to_junction", "u4"),

                ("controlled_junction", "u4"),

                ("controlled_p_bar", "f8"),

                ("control_active", "bool"),

                ("loss_coefficient", "f8"),

                ("in_service", 'bool'),

                ("type", dtype(object))]

        """

        Gets the result table.

        :param net: The pandapipes network

        :type net: pandapipesNet

        :return: (columns, all_float) - the column names and whether they are all float type. Only

                if False, returns columns as tuples also specifying the dtypes

        :rtype: (list, bool)

        """

                          "vdot_norm_m3_per_s"]

    BranchComponent, BranchWInternalsComponent

                                          BranchComponent, BranchWInternalsComponent,

                                          PressureControlComponent)

    HeatExchanger, Valve, CirculationPumpPressure, CirculationPumpMass, PressureControlComponent

    HeatExchanger, Valve, CirculationPumpPressure, CirculationPumpMass, PressureControlComponent

                    **kwargs):

    :type index: int, default None

    :param kwargs: Additional keyword arguments will be added as further columns to the\

                    net["ext_grid"] table

                            control_active=True, loss_coefficient=0., name=None, index=None,

                            in_service=True, type="pressure_control", **kwargs):

    """

    Adds one pressure control with a constant mass flow in table net["press_control"].

    :param net: The net within this pump should be created

    :type net: pandapipesNet

    :param from_junction: ID of the junction on one side which the pressure control will be \

            connected with

    :type from_junction: int

    :param controlled_junction: ID of the junction at which the pressure is controlled

    :type controlled_junction: int

    :param to_junction: ID of the junction on the other side which the pressure control will be \

            connected with

    :type to_junction: int

    :param controlled_p_bar: Pressure set point

    :type controlled_p_bar: float

    :param control_active: Variable to state whether the pressure control is active (otherwise \

        behaviour similar to open valve)

    :type control_active: bool, default True

    :param loss_coefficient: The pressure loss coefficient introduced by the component's shape \

        (used only if control is not active).

    :type loss_coefficient: float, default 0

    :param name: Name of the pressure control element

    :type name: str

    :param index: Force a specified ID if it is available. If None, the index one higher than the\

            highest already existing index is selected.

    :type index: int, default None

    :param in_service: True for in_service or False for out of service

    :type in_service: bool, default True

    :param type: Currently not used - possibility to specify a certain type of pressure control

    :type type: str, default "pressure_control"

    :param kwargs: Additional keyword arguments will be added as further columns to the \

            net["press_control"] table

    :type kwargs: dict

    :return: index - The unique ID of the created element

    :rtype: int

    :Example:

        >>> create_pressure_control(net, 0, 1, 1, controlled_p_bar=5)

    """

    # check if junctions exist to attach the pump to

                 to_junction=to_junction, controlled_junction=controlled_junction,

                 control_active=bool(control_active), loss_coefficient=loss_coefficient,

                 controlled_p_bar=controlled_p_bar, in_service=bool(in_service), type=type,

                 **kwargs)

     Convenience function for creating many valves at once. Parameters 'from_junctions' and \

                             controlled_p_bar, control_active=True, loss_coefficient=0., name=None,

                             index=None, in_service=True, type="pressure_control", **kwargs):

    """

    Convenience function for creating many pressure controls at once. Parameters 'from_junctions'\

    and 'to_junctions' must be arrays of equal length. Other parameters may be either arrays of the\

    same length or single values.

    :param net: The net within this pump should be created

    :type net: pandapipesNet

    :param from_junctions: IDs of the junctions on one side which the pressure controls will be\

            connected to

    :type from_junctions: Iterable(int)

    :param to_junctions: IDs of the junctions on the other side to which the pressure controls will\

            be connected to

    :type to_junctions: Iterable(int)

    :param controlled_junctions: IDs of the junctions at which the pressure is controlled

    :type controlled_junctions: Iterable or int

    :param controlled_p_bar: Pressure set points

    :type controlled_p_bar: Iterable or float

    :param control_active: Variable to state whether the pressure control is active (otherwise \

        behaviour similar to open valve)

    :type control_active: bool, default True

    :param loss_coefficient: The pressure loss coefficient introduced by the component's shape \

        (used only if control is not active).

    :type loss_coefficient: float, default 0

    :param name: Name of the pressure control elements

    :type name: Iterable or str

    :param index: Force specified IDs if they are available. If None, the index one higher than the\

            highest already existing index is selected and counted onwards.

    :type index: Iterable(int), default None

    :param in_service: True for in_service or False for out of service

    :type in_service: Iterable or bool, default True

    :param type: Currently not used - possibility to specify a certain type of pressure control

    :type type: Iterable or str, default "pressure_control"

    :param kwargs: Additional keyword arguments will be added as further columns to the \

            net["press_control"] table

    :return: index - The unique IDs of the created elements

    :rtype: array(int)

    :Example:

        >>> create_pressure_controls(net, [0, 2], [1, 4], [1, 3], controlled_p_bar=[5, 4.9])

    """

               "controlled_junction": controlled_junctions, "controlled_p_bar": controlled_p_bar,

               "control_active": control_active, "loss_coefficient": loss_coefficient,

               "in_service": in_service, "type": type}