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
