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: :param node_name: :type node_name: :return: No Output. """ res_table = super().extract_results(net, options, node_name) loads = net[cls.table_name()] is_loads = loads.in_service.values fj, tj = get_lookup(net, "node", "from_to")[node_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_calc = is_loads & is_juncts res_table["mdot_kg_per_s"].values[is_calc] = loads.mdot_kg_per_s.values[is_calc] \ * loads.scaling.values[is_calc]
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. """ ft_lookup = get_lookup(net, "node", "from_to") table_nr = get_table_number(get_lookup(net, "node", "table"), cls.table_name()) f, t = ft_lookup[cls.table_name()] 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[:, 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
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_lookup = get_lookup(net, "node", "table") table_nr = get_table_number(table_lookup, cls.internal_node_name()) if table_nr is None: return None, 0, 0, None, None, None 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_number = cls.get_internal_pipe_number(net) - 1 int_node_pit[:, ELEMENT_IDX] = np.arange(t - f) f_junction, t_junction = ft_lookup[node_name] junction_pit = node_pit[f_junction:t_junction, :] from_junctions = net[cls.table_name()].from_junction.values.astype( np.int32) to_junctions = net[cls.table_name()].to_junction.values.astype( np.int32) return table_nr, int_node_number, int_node_pit, junction_pit, from_junctions, to_junctions
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. """ res_table = super().extract_results(net, options, node_name) f, t = get_lookup(net, "node", "from_to")[cls.table_name()] fa, ta = get_lookup(net, "node", "from_to_active")[cls.table_name()] 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 at the nodes %s are negative' % junction_pit[junction_pit[:, PINIT] < 0, ELEMENT_IDX])) res_table["p_bar"].values[junctions_active] = junction_pit[:, PINIT] res_table["t_k"].values[junctions_active] = junction_pit[:, TINIT]
def create_pit_branch_entries(cls, net, branch_pit, node_name): """ Function which creates pit branch entries. :param net: The pandapipes network :type net: pandapipesNet :param branch_pit: :type branch_pit: :param node_name: :type node_name: :return: No Output. """ f, t = get_lookup(net, "branch", "from_to")[cls.table_name()] branch_table_nr = get_table_number(get_lookup(net, "branch", "table"), cls.table_name()) branch_component_pit = branch_pit[f:t, :] node_pit = net["_pit"]["node"] junction_idx_lookup = get_lookup(net, "node", "index")[node_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 return branch_component_pit, node_pit, from_nodes, to_nodes
def prepare_result_tables(cls, net, options, node_name): res_table = super().extract_results(net, options, node_name) f, t = get_lookup(net, "branch", "from_to")[cls.table_name()] fa, ta = get_lookup(net, "branch", "from_to_active")[cls.table_name()] placement_table = np.argsort(net[cls.table_name()].index.values) idx_pit = net["_pit"]["branch"][f:t, ELEMENT_IDX] pipe_considered = get_lookup(net, "branch", "active")[f:t] _, active_pipes = _sum_by_group(idx_pit, pipe_considered.astype(np.int32)) active_pipes = active_pipes > 0.99 placement_table = placement_table[active_pipes] branch_pit = net["_active_pit"]["branch"][fa:ta, :] return placement_table, branch_pit, res_table
def create_pit_branch_entries(cls, net, branch_winternals_pit, node_name): """ Function which creates pit branch entries. :param net: The pandapipes network :type net: pandapipesNet :param branch_pit: :type branch_pit: :return: No Output. """ branch_winternals_pit, node_pit, from_nodes, to_nodes\ = super().create_pit_branch_entries(net, branch_winternals_pit, node_name) internal_pipe_number = cls.get_internal_pipe_number(net) node_ft_lookups = get_lookup(net, "node", "from_to") if cls.internal_node_name() in node_ft_lookups: pipe_nodes_from, pipe_nodes_to = node_ft_lookups[cls.internal_node_name()] pipe_nodes_idx = np.arange(pipe_nodes_from, pipe_nodes_to) insert_places = np.repeat(np.arange(len(from_nodes)), internal_pipe_number - 1) from_nodes = np.insert(from_nodes, insert_places + 1, pipe_nodes_idx) to_nodes = np.insert(to_nodes, insert_places, pipe_nodes_idx) branch_winternals_pit[:, ELEMENT_IDX] = np.repeat(net[cls.table_name()].index.values, internal_pipe_number) branch_winternals_pit[:, FROM_NODE] = from_nodes branch_winternals_pit[:, TO_NODE] = to_nodes branch_winternals_pit[:, TINIT] = (node_pit[from_nodes, TINIT_NODE] + node_pit[to_nodes, TINIT_NODE]) / 2 fluid = get_fluid(net) branch_winternals_pit[:, RHO] = fluid.get_density(branch_winternals_pit[:, TINIT]) branch_winternals_pit[:, ETA] = fluid.get_viscosity(branch_winternals_pit[:, TINIT]) branch_winternals_pit[:, CP] = fluid.get_heat_capacity(branch_winternals_pit[:, TINIT]) branch_winternals_pit[:, ACTIVE] = np.repeat(net[cls.table_name()][cls.active_identifier()].values, internal_pipe_number) return branch_winternals_pit, internal_pipe_number
def solve_hydraulics(net): """ 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 magnitudes (pressure and velocity) for the network nodes and branches. :param net: The pandapipesNet for which to solve the hydraulic matrix :type net: pandapipesNet :return: """ 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']: if issubclass(comp, BranchComponent): comp.calculate_derivatives_hydraulic(net, branch_pit, node_pit, branch_lookups, options) jacobian, epsilon = build_system_matrix(net, branch_pit, node_pit, False) v_init_old = branch_pit[:, VINIT].copy() p_init_old = node_pit[:, PINIT].copy() x = spsolve(jacobian, epsilon) branch_pit[:, VINIT] += x[len(node_pit):] node_pit[:, PINIT] += x[:len(node_pit)] * options["alpha"] return branch_pit[:, VINIT], node_pit[:, PINIT], v_init_old, p_init_old, epsilon
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. """ circ_pump, press = super().create_pit_node_entries( net, node_pit, node_name) junction_idx_lookups = get_lookup(net, "node", "index")[node_name] juncts_p, press_sum, number = _sum_by_group( circ_pump.to_junction.values, 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 net["_lookups"]["ext_grid"] = np.array( list(set(np.concatenate([net["_lookups"]["ext_grid"], index_p]))))
def test_connectivity_hydraulic2(create_test_net): net = copy.deepcopy(create_test_net) net.junction.in_service = True net.pipe.in_service = True net.valve.opened = True pandapipes.create_fluid_from_lib(net, "water") pandapipes.pipeflow(net, iter=100, tol_p=1e-7, tol_v=1e-7, friction_model="nikuradse") pandapipes.create_junction(net, 1., 293.15) pandapipes.create_junction(net, 1., 293.15) j = pandapipes.create_junction(net, 1., 293.15) pandapipes.create_junction(net, 1, 293.15) pandapipes.create_junction(net, 1, 293.15) pandapipes.create_pipe_from_parameters(net, 0, j, 0.1, 0.1) pandapipes.create_sink(net, j, 0.1) pandapipes.pipeflow(net, iter=100, tol_p=1e-7, tol_v=1e-7, friction_model="nikuradse") active_branches = get_lookup(net, "branch", "active") active_nodes = get_lookup(net, "node", "active") assert np.all(active_nodes == np.array([ True, True, True, True, True, True, True, False, False, True, False, False, True, True, True ])) assert np.all(active_branches) assert not np.all( np.isnan(net.res_junction.loc[[0, 1, 2, 3, 4, 5, 9], :].values)) assert not np.all(np.isnan(net.res_pipe.values)) assert np.any(np.isnan(net.res_junction.loc[[7, 8, 10, 11], :].values))
def test_connectivity_hydraulic(create_test_net): """ :param create_test_net: :type create_test_net: :return: :rtype: """ net = copy.deepcopy(create_test_net) net.junction.in_service = True net.pipe.in_service = [True, False, False, True, True] pandapipes.create_fluid_from_lib(net, "water") pandapipes.pipeflow(net, iter=100, tol_p=1e-7, tol_v=1e-7, friction_model="nikuradse") assert np.all(np.isnan(net.res_junction.loc[[2, 5, 6], :].values)) assert np.all(np.isnan(net.res_pipe.loc[[1, 2, 3], :].values)) assert not np.any(np.isnan(net.res_junction.loc[[0, 1, 3, 4], :].values)) assert not np.any( np.isnan(net.res_pipe.loc[ [0, 4], ["v_mean_m_per_s", "p_from_bar", "p_to_bar"]].values)) assert not np.any( np.isnan(net.res_sink.loc[[0, 2], "mdot_kg_per_s"].values)) assert np.all(np.isnan(net.res_sink.loc[[1, 3, 4], "mdot_kg_per_s"].values)) assert np.allclose(net.res_ext_grid.mdot_kg_per_s.sum(), -net.res_sink.mdot_kg_per_s.sum(), rtol=1e-10, atol=0) active_branches = get_lookup(net, "branch", "active") active_nodes = get_lookup(net, "node", "active") assert np.all(active_nodes == np.array( [True, True, False, True, True, False, False, False, False, True])) assert np.all(active_branches == np.array( [True, False, False, False, False, False, True, True, True, False]))
def test_gas_internal_nodes(): """ :return: :rtype: """ net = pandapipes.create_empty_network("net", add_stdtypes=False) d = 209.1e-3 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) pandapipes.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.pipeflow(net, stop_condition="tol", iter=70, friction_model="nikuradse", transient=False, nonlinear_method="automatic", tol_p=1e-4, tol_v=1e-4) pipe_results = Pipe.get_internal_results(net, [0]) data = pd.read_csv(os.path.join(internals_data_path, "gas_sections_an.csv"), sep=';', header=0, keep_default_na=False) p_an = data["p1"] / 1e5 v_an = data["v"] v_an = v_an.drop([0]) pipe_p_data_idx = np.where(pipe_results["PINIT"][:, 0] == 0) pipe_v_data_idx = np.where(pipe_results["VINIT"][:, 0] == 0) pipe_p_data = pipe_results["PINIT"][pipe_p_data_idx, 1] pipe_v_data = pipe_results["VINIT"][pipe_v_data_idx, 1] node_pit = net["_pit"]["node"] junction_idx_lookup = get_lookup(net, "node", "index")[Junction.table_name()] from_junction_nodes = junction_idx_lookup[net["pipe"]["from_junction"].values] 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[1:-1] = pipe_p_data[:] p_pandapipes[-1] = node_pit[to_junction_nodes[0], PINIT] p_pandapipes = p_pandapipes + 1.01325 v_pandapipes = pipe_v_data[0, :] p_diff = np.abs(1 - p_pandapipes / p_an) v_diff = np.abs(v_an - v_pandapipes) assert np.all(p_diff < 0.01) assert np.all(v_diff < 0.4)
def plot_pipe(cls, net, pipe, pipe_results): """ :param net: The pandapipes network :type net: pandapipesNet :param pipe: :type pipe: :param pipe_results: :type pipe_results: :return: No Output. """ pipe_p_data_idx = np.where(pipe_results["PINIT"][:, 0] == pipe) pipe_v_data_idx = np.where(pipe_results["VINIT"][:, 0] == pipe) pipe_p_data = pipe_results["PINIT"][pipe_p_data_idx, 1] pipe_t_data = pipe_results["TINIT"][pipe_p_data_idx, 1] pipe_v_data = pipe_results["VINIT"][pipe_v_data_idx, 1] node_pit = net["_pit"]["node"] junction_idx_lookup = get_lookup(net, "node", "index")[Junction.table_name()] 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[1:-1] = pipe_p_data[:] p_values[-1] = node_pit[to_junction_nodes[pipe], PINIT] t_values = np.zeros(len(pipe_t_data[0]) + 2) t_values[0] = node_pit[from_junction_nodes[pipe], TINIT_NODE] t_values[1:-1] = pipe_t_data[:] t_values[-1] = node_pit[to_junction_nodes[pipe], TINIT_NODE] v_values = pipe_v_data[0, :] x_pt = np.linspace(0, net.pipe["length_km"], len(p_values)) x_v = np.linspace(0, net.pipe["length_km"], len(v_values)) f, axes = plt.subplots(3, 1, sharex="all") axes[0].plot(x_pt, p_values) axes[0].set_title("Pressure [bar]") axes[1].plot(x_v, v_values) axes[1].set_title("Velocity [m/s]") axes[2].plot(x_pt, t_values) axes[2].set_title("Temperature [K]") plt.show()
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: :param node_name: :type node_name: :return: No Output. """ ext_grids = net[cls.table_name()] if len(ext_grids) == 0: return res_table = super().extract_results(net, options, node_name) branch_pit = net['_pit']['branch'] node_pit = net["_pit"]["node"] p_grids = np.isin(ext_grids.type.values, ["p", "pt"]) junction = cls.get_connected_junction(net) eg_nodes = get_lookup(net, "node", "index")[node_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(all_index_nodes, all_mass_flows) # 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
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. """ loads = net[cls.table_name()] helper = loads.in_service.values * loads.scaling.values * cls.sign() mf = np.nan_to_num(loads.mdot_kg_per_s.values) mass_flow_loads = mf * helper juncts, loads_sum = _sum_by_group(loads.junction.values, mass_flow_loads) junction_idx_lookups = get_lookup(net, "node", "index")[node_name] index = junction_idx_lookups[juncts] node_pit[index, LOAD] += loads_sum
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. """ circ_pump, press = super().create_pit_node_entries(net, node_pit, node_name) mf = np.nan_to_num(circ_pump.mdot_kg_per_s.values) mass_flow_loads = mf * circ_pump.in_service.values juncts, loads_sum = _sum_by_group(circ_pump.to_junction.values, mass_flow_loads) junction_idx_lookups = get_lookup(net, "node", "index")[node_name] index = junction_idx_lookups[juncts] node_pit[index, LOAD] += loads_sum
def solve_temperature(net): """ This function contains the procedure to build and solve a linearized system of equation based on an underlying net and the necessary graph data structures. Temperature values are calculated. Returned are the solution vectors for the new iteration, the original solution vectors and a vector containing component indices for the system matrix entries :param net: The pandapipesNet for which to solve the temperature matrix :type net: pandapipesNet :return: branch_pit """ options = net["_options"] branch_pit = net["_active_pit"]["branch"] node_pit = net["_active_pit"]["node"] 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']: if issubclass(comp, BranchComponent): comp.calculate_derivatives_thermal(net, branch_pit, node_pit, branch_lookups, options) jacobian, epsilon = build_system_matrix(net, branch_pit, node_pit, True) t_init_old = node_pit[:, TINIT].copy() t_out_old = branch_pit[:, T_OUT].copy() x = spsolve(jacobian, epsilon) node_pit[:, TINIT] += x[:len(node_pit)] * options["alpha"] branch_pit[:, T_OUT] += x[len(node_pit):] return branch_pit[:, T_OUT], t_out_old, node_pit[:, TINIT], t_init_old, epsilon
def test_temperature_internal_nodes_single_pipe(): """ :return: :rtype: """ net = pandapipes.create_empty_network("net", add_stdtypes=False) d = 75e-3 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_sink(net, 1, mdot_kg_per_s=1) pandapipes.create_fluid_from_lib(net, "water", overwrite=True) pandapipes.pipeflow(net, stop_condition="tol", iter=3, friction_model="nikuradse", mode="all", transient=False, nonlinear_method="automatic", tol_p=1e-4, tol_v=1e-4) pipe_results = Pipe.get_internal_results(net, [0]) data = pd.read_csv(os.path.join(internals_data_path, "Temperature_one_pipe_an.csv"), sep=';', header=0, keep_default_na=False) temp_an = data["T"] pipe_temp_data_idx = np.where(pipe_results["TINIT"][:, 0] == 0) pipe_temp_data = pipe_results["TINIT"][pipe_temp_data_idx, 1] node_pit = net["_pit"]["node"] junction_idx_lookup = get_lookup(net, "node", "index")[Junction.table_name()] from_junction_nodes = junction_idx_lookup[net["pipe"]["from_junction"].values] 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[1:-1] = pipe_temp_data[:] temp_pandapipes[-1] = node_pit[to_junction_nodes[0], TINIT] temp_diff = np.abs(1 - temp_pandapipes / temp_an) assert np.all(temp_diff < 0.01)
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. """ res_table, circ_pump, index_nodes_from, node_pit, branch_pit = \ super().extract_results(net, options, node_name) 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")[node_name][junct_uni_to] deltap_bar = node_pit[index_nodes_from, PINIT] - node_pit[index_nodes_to, PINIT] res_table["deltap_bar"].values[:] = deltap_bar
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: :param node_name: :type node_name: :return: No Output. """ ext_grids = net[cls.table_name()] p_mask = np.where(np.isin(ext_grids.type.values, ["p", "pt"])) press = ext_grids.p_bar.values[p_mask] * ext_grids.in_service.values[ p_mask] junction_idx_lookups = get_lookup(net, "node", "index")[node_name] junction = cls.get_connected_junction(net) juncts_p, press_sum, number = _sum_by_group( 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 t_mask = np.where(np.isin(ext_grids.type.values, ["t", "pt"])) t_k = ext_grids.t_k.values[t_mask] * ext_grids.in_service.values[t_mask] juncts_t, t_sum, number = _sum_by_group( 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 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 return ext_grids, press
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 extract_results(cls, net, options, node_name): placement_table, branch_pit, res_table = cls.prepare_result_tables( 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]]] from_nodes = branch_pit[:, FROM_NODE].astype(np.int32) to_nodes = branch_pit[:, TO_NODE].astype(np.int32) p_scale = get_net_option(net, "p_scale") fluid = get_fluid(net) v_mps = branch_pit[:, VINIT] t0 = node_pit[from_nodes, TINIT_NODE] t1 = node_pit[to_nodes, TINIT_NODE] mf = branch_pit[:, LOAD_VEC_NODES] vf = branch_pit[:, LOAD_VEC_NODES] / get_fluid(net).get_density( (t0 + t1) / 2) idx_active = branch_pit[:, ELEMENT_IDX] _, v_sum, mf_sum, vf_sum, internal_pipes = \ _sum_by_group(idx_active, v_mps, mf, vf, np.ones_like(idx_active)) 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 * branch_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 = ~np.isclose(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 _, _, _, 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)) v_gas_from_ordered = select_from_pit(from_nodes, from_junction_nodes, v_gas_from) v_gas_to_ordered = select_from_pit(to_nodes, to_junction_nodes, v_gas_to) res_table["v_from_m_per_s"].values[ placement_table] = v_gas_from_ordered res_table["v_to_m_per_s"].values[ placement_table] = v_gas_to_ordered 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 / internal_pipes 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 / internal_pipes res_table["mdot_from_kg_per_s"].values[ placement_table] = mf_sum / internal_pipes res_table["vdot_norm_m3_per_s"].values[ placement_table] = vf_sum / internal_pipes idx_pit = branch_pit[:, ELEMENT_IDX] _, lambda_sum, reynolds_sum, = \ _sum_by_group(idx_pit, branch_pit[:, LAMBDA], branch_pit[:, RE]) res_table["lambda"].values[ placement_table] = lambda_sum / internal_pipes res_table["reynolds"].values[ placement_table] = reynolds_sum / internal_pipes
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