def get_result_table(cls, net): """ :param net: :type net: :return: :rtype: """ if get_fluid(net).is_gas: output = [("v_from_m_per_s", "f8"), ("v_to_m_per_s", "f8"), ("v_mean_m_per_s", "f8"), ("p_from_bar", "f8"), ("p_to_bar", "f8"), ("t_from_k", "f8"), ("t_to_k", "f8"), ("mdot_from_kg_per_s", "f8"), ("mdot_to_kg_per_s", "f8"), ("vdot_norm_m3_per_s", "f8"), ("reynolds", "f8"), ("lambda", "f8"), ("normfactor_from", "f8"), ("normfactor_to", "f8")] else: output = [("v_mean_m_per_s", "f8"), ("p_from_bar", "f8"), ("p_to_bar", "f8"), ("t_from_k", "f8"), ("t_to_k", "f8"), ("mdot_from_kg_per_s", "f8"), ("mdot_to_kg_per_s", "f8"), ("vdot_norm_m3_per_s", "f8"), ("reynolds", "f8"), ("lambda", "f8")] return output
def create_pit_node_entries(cls, net, node_pit, node_name): """ Function which creates pit node entries. :param net: The pandapipes network :type net: pandapipesNet :param node_pit: :type node_pit: :return: No Output. """ table_nr, int_node_number, int_node_pit, junction_pit, from_junctions, to_junctions = \ super().create_pit_node_entries(net, node_pit, node_name) if table_nr is None: return int_node_pit[:, HEIGHT] = vinterp(junction_pit[from_junctions, HEIGHT], junction_pit[to_junctions, HEIGHT], int_node_number) int_node_pit[:, PINIT] = vinterp(junction_pit[from_junctions, PINIT], junction_pit[to_junctions, PINIT], int_node_number) int_node_pit[:, TINIT_NODE] = vinterp( junction_pit[from_junctions, TINIT_NODE], junction_pit[to_junctions, 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] = np.repeat( net[cls.table_name()][cls.active_identifier()].values, int_node_number)
def get_result_table(cls, net): """ :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) """ 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", "t_to_k", "mdot_from_kg_per_s", "mdot_to_kg_per_s", "vdot_norm_m3_per_s", "reynolds", "lambda", "normfactor_from", "normfactor_to"] 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
def calculate_pressure_lift(cls, net, pump_pit, node_pit): """ :param net: The pandapipes network :type net: pandapipesNet :param pump_pit: :type pump_pit: :param node_pit: :type node_pit: :return: power stroke :rtype: float """ area = pump_pit[:, AREA] idx = pump_pit[:, STD_TYPE].astype(int) std_types = np.array(list(net.std_type['pump'].keys()))[idx] p_scale = get_net_option(net, "p_scale") from_nodes = pump_pit[:, 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_scale p_to = node_pit[to_nodes, PAMB] + node_pit[to_nodes, PINIT] * p_scale numerator = NORMAL_PRESSURE * pump_pit[:, TINIT] v_mps = pump_pit[:, VINIT] if fluid.is_gas: mask = p_from != p_to p_mean = np.empty_like(p_to) p_mean[~mask] = p_from[~mask] p_mean[mask] = 2 / 3 * (p_from[mask] ** 3 - p_to[mask] ** 3) \ / (p_from[mask] ** 2 - p_to[mask] ** 2) normfactor_mean = numerator * fluid.get_property("compressibility", p_mean) \ / (p_mean * NORMAL_TEMPERATURE) v_mean = v_mps * normfactor_mean else: v_mean = v_mps vol = v_mean * area fcts = itemgetter(*std_types)(net['std_type']['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
def extract_results(cls, net, options, node_name): """ Function that extracts certain results. :param net: The pandapipes network :type net: pandapipesNet :param options: :type options: :return: No Output. """ placement_table, heat_exchanger_pit, res_table = \ super().extract_results(net, options, node_name) node_pit = net["_active_pit"]["node"] 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[ net[cls.table_name()]["from_junction"].values[placement_table]]] to_junction_nodes = node_active_idx_lookup[junction_idx_lookup[ net[cls.table_name()]["to_junction"].values[placement_table]]] p_scale = get_net_option(net, "p_scale") from_nodes = heat_exchanger_pit[:, FROM_NODE].astype(np.int32) to_nodes = heat_exchanger_pit[:, TO_NODE].astype(np.int32) fluid = get_fluid(net) v_mps = heat_exchanger_pit[:, VINIT] t0 = node_pit[from_nodes, TINIT_NODE] t1 = node_pit[to_nodes, TINIT_NODE] mf = heat_exchanger_pit[:, LOAD_VEC_NODES] vf = heat_exchanger_pit[:, LOAD_VEC_NODES] / get_fluid(net).get_density((t0 + t1) / 2) idx_active = heat_exchanger_pit[:, ELEMENT_IDX] idx_sort, v_sum, mf_sum, vf_sum = \ _sum_by_group(idx_active, v_mps, mf, vf) if fluid.is_gas: # derived from the ideal gas law p_from = node_pit[from_nodes, PAMB] + node_pit[from_nodes, PINIT] * p_scale p_to = node_pit[to_nodes, PAMB] + node_pit[to_nodes, PINIT] * p_scale numerator = NORMAL_PRESSURE * heat_exchanger_pit[:, TINIT] 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) v_gas_from = v_mps * normfactor_from v_gas_to = v_mps * normfactor_to mask = p_from != p_to p_mean = np.empty_like(p_to) p_mean[~mask] = p_from[~mask] p_mean[mask] = 2 / 3 * (p_from[mask] ** 3 - p_to[mask] ** 3) \ / (p_from[mask] ** 2 - p_to[mask] ** 2) normfactor_mean = numerator * fluid.get_property("compressibility", p_mean) \ / (p_mean * NORMAL_TEMPERATURE) v_gas_mean = v_mps * normfactor_mean idx_sort, v_gas_from_sum, v_gas_to_sum, v_gas_mean_sum, nf_from_sum, nf_to_sum, \ internal_pipes = _sum_by_group( idx_active, v_gas_from, v_gas_to, v_gas_mean, normfactor_from, normfactor_to, np.ones_like(idx_active)) res_table["v_from_m_per_s"].values[placement_table] = v_gas_from_sum / internal_pipes res_table["v_to_m_per_s"].values[placement_table] = v_gas_to_sum / internal_pipes res_table["v_mean_m_per_s"].values[placement_table] = v_gas_mean_sum / internal_pipes res_table["normfactor_from"].values[placement_table] = nf_from_sum / internal_pipes res_table["normfactor_to"].values[placement_table] = nf_to_sum / internal_pipes else: res_table["v_mean_m_per_s"].values[placement_table] = v_sum res_table["p_from_bar"].values[placement_table] = node_pit[from_junction_nodes, PINIT] res_table["p_to_bar"].values[placement_table] = node_pit[to_junction_nodes, PINIT] res_table["t_from_k"].values[placement_table] = node_pit[from_junction_nodes, TINIT_NODE] res_table["t_to_k"].values[placement_table] = node_pit[to_junction_nodes, TINIT_NODE] res_table["mdot_to_kg_per_s"].values[placement_table] = -mf_sum res_table["mdot_from_kg_per_s"].values[placement_table] = mf_sum res_table["vdot_norm_m3_per_s"].values[placement_table] = vf_sum idx_pit = heat_exchanger_pit[:, ELEMENT_IDX] idx_sort, lambda_sum, reynolds_sum, = \ _sum_by_group(idx_pit, heat_exchanger_pit[:, LAMBDA], heat_exchanger_pit[:, RE]) res_table["lambda"].values[placement_table] = lambda_sum res_table["reynolds"].values[placement_table] = reynolds_sum
def get_internal_results(cls, net, pipe): """ :param net: The pandapipes network :type net: pandapipesNet :param pipe: :type pipe: :return: pipe_results :rtype: """ internal_sections = cls.get_internal_pipe_number(net) internal_p_nodes = internal_sections - 1 p_node_idx = np.repeat(pipe, internal_p_nodes[pipe]) v_pipe_idx = np.repeat(pipe, internal_sections[pipe]) pipe_results = dict() pipe_results["PINIT"] = np.zeros((len(p_node_idx), 2), dtype=np.float64) pipe_results["TINIT"] = np.zeros((len(p_node_idx), 2), dtype=np.float64) pipe_results["VINIT"] = 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"] int_p_lookup = net["_lookups"]["internal_nodes_lookup"]["TPINIT"] int_v_lookup = net["_lookups"]["internal_nodes_lookup"]["VINIT"] selected_indices_p = [] selected_indices_v = [] for i in pipe: selected_indices_p.append( np.where(int_p_lookup[:, 0] == i, True, False)) selected_indices_v.append( np.where(int_v_lookup[:, 0] == i, True, False)) selected_indices_p_final = np.logical_or.reduce( selected_indices_p[:]) selected_indices_v_final = np.logical_or.reduce( selected_indices_v[:]) # a = np.where(int_p_lookup[:,0] == True, False) # b = np.where(int_v_lookup[:, 0] == v_pipe_idx, True, False) 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] gas_mode = fluid.is_gas if gas_mode: p_scale = get_net_option(net, "p_scale") 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_scale p_to = node_pit[to_nodes, PAMB] + node_pit[to_nodes, PINIT] * p_scale 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 = numerator * fluid.get_property("compressibility", p_mean) \ / (p_mean * NORMAL_TEMPERATURE) v_pipe_data = v_pipe_data * normfactor pipe_results["PINIT"][:, 0] = p_node_idx pipe_results["PINIT"][:, 1] = p_node_data pipe_results["TINIT"][:, 0] = p_node_idx pipe_results["TINIT"][:, 1] = t_node_data pipe_results["VINIT"][:, 0] = v_pipe_idx pipe_results["VINIT"][:, 1] = v_pipe_data else: logger.warning( "For at least one pipe no internal data is available.") return pipe_results