import networkx import pandas import wntr import numpy as np import pandas as pd import math import copy import sys import networkx as nx import pymetis import influxdb_api from datetime import datetime import random import itertools import os from tjnetwork import * from api.project_backup import CopyProjectEx import simulation import globals import influxdb_api import concurrent.futures from datetime import datetime, timedelta, timezone import matplotlib.pyplot as plt def manually_get_burst_time_SCADA_pressure(name: str, manually_burst_time: str, scheme_Type: str, scheme_Name: str): """ 手动模拟爆管时，获取对应的SCADA数据 :param name: 数据库名称 :param manually_burst_time: 手动模拟爆管时间,格式为 '2024-11-24T17:30:00+08:00' :param scheme_Type: 方案类型 :param scheme_Name: 方案名称 :return: """ influxdb_api.query_corresponding_query_id_and_element_id(name=name) pressure_api_query_ids_list = list(globals.scheme_pressure_ids.keys()) # print(pressure_api_query_ids_list) # 用节点作为SCADA压力监测点名称 pressure_SCADA_IDs_list = [list(globals.scheme_pressure_ids.values())] # print(pressure_SCADA_IDs_list) # pressure_SCADA_IDs_list替换sensor_name # pressure_SCADA_IDs_list = list(pressure_SCADA_IDs_list) # normal_SCADA_pressure替换predicted_p normal_SCADA_pressure = influxdb_api.query_SCADA_data_by_device_ID_and_time( query_ids_list=pressure_api_query_ids_list, query_time=manually_burst_time ) # print(normal_SCADA_pressure) # 用 scheme_pressure_ids 中对应的value替换字典中的key，并且将原字典中的value转换为数字后乘以100 normal_SCADA_pressure = { globals.scheme_pressure_ids.get(k, k): (float(v) * 100 if v is not None else None) for k, v in normal_SCADA_pressure.items() } # print(normal_SCADA_pressure) normal_SCADA_pressure = pd.Series(normal_SCADA_pressure) # burst_SCADA_pressure替换leak_monitored burst_SCADA_pressure = influxdb_api.query_scheme_SCADA_data_by_device_ID_and_time( query_ids_list=pressure_SCADA_IDs_list, query_time=manually_burst_time, scheme_Type=scheme_Type, scheme_Name=scheme_Name ) # print(burst_SCADA_pressure) burst_SCADA_pressure = { globals.scheme_pressure_ids.get(k, k): (float(v) if v is not None else None) for k, v in burst_SCADA_pressure.items() } print(burst_SCADA_pressure) burst_SCADA_pressure = pd.Series(burst_SCADA_pressure) return burst_SCADA_pressure, pressure_SCADA_IDs_list, normal_SCADA_pressure # 2025/03/22 def manually_get_burst_flow(scheme_Type: str, scheme_Name: str, burst_start_time: str, bucket1: str="scheme_simulation_result", bucket2: str="SCADA_data") -> float: """ 进行手动模拟时，用（模拟得到的流量 - 前一时刻正常的SCADA流量）作为爆管流量 :param scheme_Type: 方案类型 :param scheme_Name: 方案名称 :param burst_start_time: 方案模拟开始时间，格式为 '2024-11-24T17:30:00+08:00'。 :param bucket1: 方案模拟数据存储的 bucket 名称。 :param bucket2: SCADA数据存储的 bucket 名称。 :return: 最后返回 m3/s为单位的的漏损水量 """ client = influxdb_api.get_new_client() if not client.ping(): print("{} -- Failed to connect to InfluxDB.".format(datetime.now().strftime('%Y-%m-%d %H:%M:%S'))) query_api = client.query_api() # 将北京时间转换为 UTC 时间 beijing_time = datetime.fromisoformat(burst_start_time) utc_time = beijing_time.astimezone(timezone.utc) utc_scheme_start_time = utc_time - timedelta(seconds=1) utc_scheme_stop_time = utc_time + timedelta(seconds=1) # 构建 Flux 查询语句 flux_query1 = f''' from(bucket: "{bucket1}") |> range(start: {utc_scheme_start_time.isoformat()}, stop: {utc_scheme_stop_time.isoformat()}) |> filter(fn: (r) => r["scheme_Type"] == "{scheme_Type}" and r["scheme_Name"] == "{scheme_Name}" and r["_measurement"] == "scheme_source_outflow") ''' table1 = query_api.query(flux_query1) result1 = [] for table in table1: for record in table.records: result1.append({ "device_ID": record["device_ID"], "value": float(record["_value"]) * 3.6 # L/s 转换为 m3/h }) # print(result1) scheme_sim_flow = sum(item['value'] for item in result1) # print(scheme_sim_flow) # 构建查询 SCADA 数据的 Flux 语句 flux_query2 = f''' from(bucket: "{bucket2}") |> range(start: {utc_scheme_start_time.isoformat()}, stop: {utc_scheme_stop_time.isoformat()}) |> filter(fn: (r) => r["_measurement"] == "source_outflow_realtime") ''' table2 = query_api.query(flux_query2) result2 = [] for table in table2: for record in table.records: result2.append({ "device_ID": record["device_ID"], "value": float(record["_value"]) }) # print(result2) scada_flow = sum(item['value'] for item in result2) # print(scada_flow) client.close() burst_flow = (scheme_sim_flow - scada_flow) / 3600 return burst_flow # 2025/03/25 def cal_if_detect(burst_SCADA_pressure: pd.Series, normal_SCADA_pressure: pd.Series, min_dpressure: float): """ 判断是否开始监测 :param burst_SCADA_pressure: 爆管时刻各压力表数值 :param normal_SCADA_pressure: 正常时刻各压力表数值 :param min_dpressure: 设定的压降值阈值，单位m :return: """ dpressure = normal_SCADA_pressure - burst_SCADA_pressure print(dpressure) # print(dpressure.loc['J06198']) max_dpressure = dpressure.max() max_dpressure_index = dpressure.idxmax() print(max_dpressure_index) print('max_dpressure', max_dpressure,type(max_dpressure)) print('min_dpressure', min_dpressure,type(min_dpressure)) if max_dpressure >= min_dpressure: if_detect = 1 tag = '压降在识别范围内，开始识别。' else: if_detect = 0 tag = '爆管造成的的压力下降小于设定值，故不展开识别。' print(tag) return if_detect, tag ## Simulation Module # load inp def load_inp(name: str, before_burst_time: str) -> wntr.network.WaterNetworkModel: """ 返回wntr类型的正常管网模型 :param name: 数据库名字 :param before_burst_time: 爆管发生前的时间，格式为'2024-11-25T09:00:00+08:00', 如果为手动模拟，则与爆管发生时间为同一个；如果为自动模拟则为前一个水力步长的时间 :return: """ new_name = f'before_burst_{name}' if have_project(new_name): if is_project_open(new_name): close_project(new_name) delete_project(new_name) CopyProjectEx()(name, new_name, ['operation', 'current_operation', 'restore_operation', 'batch_operation', 'operation_table']) open_project(new_name) simulation.run_simulation(name=new_name, simulation_type='manually_temporary', modify_pattern_start_time=before_burst_time) if is_project_open(new_name): close_project(new_name) delete_project(new_name) inp_file = f'./db_inp/{new_name}.db.inp' wn = wntr.network.WaterNetworkModel(inp_file) return wn # load inp information def read_inf_inp(wn): all_node = wn.node_name_list node_elevation = wn.query_node_attribute('elevation') node_coordinates = wn.query_node_attribute('coordinates') all_pipe = wn.pipe_name_list # 改_wz__________________________________ n_pipe = [] for p in all_pipe: pipe = wn.get_link(p) if pipe.initial_status == 0: # 状态为'Closed' n_pipe.append(p) candidate_pipe_init = list(set(all_pipe) - set(n_pipe)) pipe_start_node = wn.query_link_attribute('start_node_name', link_type=wntr.network.model.Pipe) pipe_end_node = wn.query_link_attribute('end_node_name', link_type=wntr.network.model.Pipe) pipe_length = wn.query_link_attribute('length') pipe_diameter = wn.query_link_attribute('diameter') return all_node, node_elevation, node_coordinates, candidate_pipe_init, pipe_start_node, pipe_end_node, pipe_length, pipe_diameter def read_inf_inp_other(wn): all_link = wn.link_name_list pipe_start_node_all = wn.query_link_attribute('start_node_name') pipe_end_node_all = wn.query_link_attribute('end_node_name') return all_link, pipe_start_node_all, pipe_end_node_all # 用新的漏损管道替换原管道 def simple_add_leak(wn, leak_mag, leak_pipe): whole_inf = dict() leak_pipe_self = wn.get_link(leak_pipe) pipe_diameter = leak_pipe_self.diameter pipe_length = leak_pipe_self.length pipe_roughness = leak_pipe_self.roughness pipe_minor_loss = leak_pipe_self.minor_loss # pipe_status = leak_pipe_self.status # pipe_check_valve = leak_pipe_self.check_valve pipe_start_node = leak_pipe_self.start_node_name pipe_end_node = leak_pipe_self.end_node_name # close the pipe # leak_pipe_self.status = 'Closed' wn.remove_link(leak_pipe) # add the pipe add_pipe1 = leak_pipe + 'A' add_pipe2 = leak_pipe + 'B' add_node = leak_pipe + '_' start_n = wn.get_node(pipe_start_node) end_n = wn.get_node(pipe_end_node) if start_n.node_type == 'Reservoir': end_n_elevation = end_n.elevation start_n_elevation = end_n_elevation elif end_n.node_type == 'Reservoir': start_n_elevation = start_n.elevation end_n_elevation = start_n_elevation else: end_n_elevation = end_n.elevation start_n_elevation = start_n.elevation elevation_self = (start_n_elevation + end_n_elevation) / 2 coordinates_self = ( (start_n.coordinates[0] + end_n.coordinates[0]) / 2, (start_n.coordinates[1] + end_n.coordinates[1])) wn.add_junction(add_node, base_demand=0, elevation=elevation_self, coordinates=coordinates_self) leak_node = wn.get_node(add_node) wn.add_pipe(add_pipe1, start_node_name=pipe_start_node, end_node_name=add_node, length=pipe_length / 2, diameter=pipe_diameter, roughness=pipe_roughness, minor_loss=pipe_minor_loss) wn.add_pipe(add_pipe2, start_node_name=pipe_end_node, end_node_name=add_node, length=pipe_length / 2, diameter=pipe_diameter, roughness=pipe_roughness, minor_loss=pipe_minor_loss) # simulation leak_node.add_demand(base=leak_mag, pattern_name='add_leak') whole_inf['leak_node_name'] = add_node whole_inf['add_pipe1'] = add_pipe1 whole_inf['add_pipe2'] = add_pipe2 whole_inf['leak_pipe'] = leak_pipe whole_inf['pipe_start_node'] = pipe_start_node whole_inf['pipe_end_node'] = pipe_end_node whole_inf['pipe_length'] = pipe_length whole_inf['pipe_diameter'] = pipe_diameter whole_inf['pipe_roughness'] = pipe_roughness whole_inf['pipe_minor_loss'] = pipe_diameter return wn, whole_inf, add_pipe1 def simple_recover_wn(wn, whole_inf): leak_node = wn.get_node(whole_inf['leak_node_name']) del leak_node.demand_timeseries_list[-1] # update wn.remove_link(whole_inf['add_pipe1']) wn.remove_link(whole_inf['add_pipe2']) wn.remove_node(whole_inf['leak_node_name']) # open the pipe # leak_pipe_self.status = 'Open' wn.add_pipe(whole_inf['leak_pipe'], start_node_name=whole_inf['pipe_start_node'], end_node_name=whole_inf['pipe_end_node'], length=whole_inf['pipe_length'], diameter=whole_inf['pipe_diameter'], roughness=whole_inf['pipe_roughness'], minor_loss=whole_inf['pipe_minor_loss']) return wn # 模拟管道漏损（而非节点漏损） def leak_simulation_pipe_dd_multi_pf(wn, leak_mag, leak_pipe, sensor_name, sensor_f_name): wn.options.hydraulic.demand_model = 'DD' leak_pipe_self = wn.get_link(leak_pipe) pipe_diameter = leak_pipe_self.diameter pipe_length = leak_pipe_self.length pipe_roughness = leak_pipe_self.roughness pipe_minor_loss = leak_pipe_self.minor_loss # pipe_status = leak_pipe_self.status # pipe_check_valve = leak_pipe_self.check_valve pipe_start_node = leak_pipe_self.start_node_name pipe_end_node = leak_pipe_self.end_node_name wn.remove_link(leak_pipe) # add the pipe add_pipe1 = leak_pipe + 'A' add_pipe2 = leak_pipe + 'B' add_node = leak_pipe + '_' start_n = wn.get_node(pipe_start_node) end_n = wn.get_node(pipe_end_node) if start_n.node_type == 'Reservoir': end_n_elevation = end_n.elevation start_n_elevation = end_n_elevation elif end_n.node_type == 'Reservoir': start_n_elevation = start_n.elevation end_n_elevation = start_n_elevation else: end_n_elevation = end_n.elevation start_n_elevation = start_n.elevation elevation_self = (start_n_elevation + end_n_elevation) / 2 coordinates_self = ( (start_n.coordinates[0] + end_n.coordinates[0]) / 2, (start_n.coordinates[1] + end_n.coordinates[1])) wn.add_junction(add_node, base_demand=0, elevation=elevation_self, coordinates=coordinates_self) leak_node = wn.get_node(add_node) wn.add_pipe(add_pipe1, start_node_name=pipe_start_node, end_node_name=add_node, length=pipe_length / 2, diameter=pipe_diameter, roughness=pipe_roughness, minor_loss=pipe_minor_loss) wn.add_pipe(add_pipe2, start_node_name=pipe_end_node, end_node_name=add_node, length=pipe_length / 2, diameter=pipe_diameter, roughness=pipe_roughness, minor_loss=pipe_minor_loss) # simulation leak_node.add_demand(base=leak_mag, pattern_name='add_leak') sim = wntr.sim.EpanetSimulator(wn) results = sim.run_sim() del leak_node.demand_timeseries_list[-1] pressure_output_all = results.node['pressure'][sensor_name] pressure_output = pressure_output_all if leak_pipe in sensor_f_name: f_sensor_name = [add_pipe1 if i == leak_pipe else i for i in sensor_f_name] flow_output = results.link['flowrate'][f_sensor_name] flow_output.columns = sensor_f_name else: flow_output = results.link['flowrate'][sensor_f_name] # update wn.remove_link(add_pipe1) wn.remove_link(add_pipe2) wn.remove_node(add_node) # open the pipe # leak_pipe_self.status = 'Open' wn.add_pipe(leak_pipe, start_node_name=pipe_start_node, end_node_name=pipe_end_node, length=pipe_length, diameter=pipe_diameter, roughness=pipe_roughness, minor_loss=pipe_minor_loss) return wn, pressure_output, flow_output # def 2 normal simulation 正常工况下的水力模拟 def normal_simulation_pf(wn: wntr.network.WaterNetworkModel, pressure_SCADA_IDs_list: list[str], flow_SCADA_IDs_list: list[str]): """ 在正常（无漏损）状态下进行水力仿真，并返回监测点压力、流量、全局压力分布、最低压力点（top_sensor）以及总需水量。 :param wn: wntr类型的管网模型 :param pressure_SCADA_IDs_list: 监测的节点压力的ID构成的列表 :return: pressure, basic_p, top_sensor, sum_demand """ sim = wntr.sim.EpanetSimulator(wn) results = sim.run_sim() pressure_all = results.node['pressure'][pressure_SCADA_IDs_list] pressure = pressure_all.iloc[0] demand_all = results.node['demand'] demand = demand_all.iloc[0] sum_demand: float = cal_sum_demand(demand) flow_all = results.link['flowrate'][flow_SCADA_IDs_list] flow = flow_all.iloc[0] top_sensor: str = pressure.idxmin() basic_p = results.node['pressure'] basic_p = basic_p.iloc[0] return pressure, flow, basic_p, top_sensor, sum_demand def normal_simulation_multi_pf(wn: wntr.network.WaterNetworkModel, pressure_SCADA_IDs_list: list[str], flow_SCADA_IDs_list: list[str]): # inp_time = 0 sim = wntr.sim.EpanetSimulator(wn) results = sim.run_sim() pressure_all = results.node['pressure'][pressure_SCADA_IDs_list] pressure = pressure_all demand_all = results.node['demand'] demand = demand_all flow = results.link['flowrate'][flow_SCADA_IDs_list] sum_demand = pd.Series(dtype=object) for i in range(len(demand.index)): sum_demand[str(demand.index[i])] = cal_sum_demand(demand.iloc[i]) if type(pressure) == pd.core.series.Series: top_sensor = pressure.idxmin() else: mean_pressure = pressure.mean() top_sensor = mean_pressure.idxmin() basic_p = results.node['pressure'] return pressure, flow, basic_p, top_sensor, sum_demand # leak_pipe：模拟漏损管道 # 获取模拟漏损后的压力（流量）监测点处压力（流量） def simple_simulation_pf(wn, sensor_name, sensor_f_name, leak_pipe, add_pipe1): sim = wntr.sim.EpanetSimulator(wn) results = sim.run_sim() pressure_all = results.node['pressure'][sensor_name] if len(leak_pipe) > 0 and leak_pipe in sensor_f_name: f_sensor_name = [add_pipe1 if i == leak_pipe else i for i in sensor_f_name] flow_all = results.link['flowrate'][f_sensor_name] flow_all.columns = sensor_f_name else: flow_all = results.link['flowrate'][sensor_f_name] return pressure_all, flow_all def cal_sum_demand(demand): sum_demand = 0 for i in range(len(demand)): if demand.iloc[i] > 0: sum_demand += demand.iloc[i] return sum_demand def pick_center_pipe(node_x, node_y, candidate_pipe, pipe_start_node, pipe_end_node): data_set_t = pd.DataFrame(dtype=object) data_set_t['x'] = (node_x[pipe_start_node[candidate_pipe]].values + node_x[ pipe_start_node[candidate_pipe]].values) / 2 data_set_t['y'] = (node_y[pipe_end_node[candidate_pipe]].values + node_y[pipe_end_node[candidate_pipe]].values) / 2 data_set_t.index = list(candidate_pipe) mean_x = data_set_t['x'].mean() mean_y = data_set_t['y'].mean() data_set_t['d'] = abs(data_set_t['x'] - mean_x) + abs(data_set_t['y'] - mean_y) distance_t = data_set_t['d'].sort_values(ascending=True, inplace=False) '''if distance_t.index==[]: print(candidate_pipe) else:''' center_t = distance_t.index[0] return center_t def find_new_center_pipe(node_x, node_y, candidate_pipe, pipe_start_node, pipe_end_node, record_center): new_candidate_pipe = list(set(candidate_pipe) - set(record_center)) if new_candidate_pipe == []: new_candidate_pipe = candidate_pipe center_t = pick_center_pipe(node_x, node_y, new_candidate_pipe, pipe_start_node, pipe_end_node) return center_t # 根据计算的爆管相关节点求出相关的爆管管段 def cal_area_node_linked_pipe(nodeset, node_pipe_dic): pipeset = [] nodeset = list(nodeset) for i in range(len(nodeset)): temp_node = nodeset[i] pipe = node_pipe_dic[temp_node] pipeset = pipeset + pipe return pipeset # kmeans 聚类后的拓扑优化 # 构建整个图 def construct_graph(wn): length = wn.query_link_attribute('length') G = wn.get_graph(wn, link_weight=length) # 转为无向图 G0 = G.to_undirected() # A0 = np.array(nx.adjacency_graph(G0).todense()) return G0 # , A0 # cal metis grouping def metis_grouping_pipe_weight(G0, wn, all_node_iter, candidate_pipe_input, group_num, node_x, node_y, pipe_start_node_all, pipe_end_node_all, node_pipe_dic, all_node_series, couple_node_length): all_node_iter_series_new = all_node_series[all_node_iter] all_node_iter_series_new = all_node_iter_series_new.sort_values(ascending=True) all_node_iter_new = list(all_node_iter_series_new.index) G1 = G0.subgraph(all_node_iter_new) delimiter = ' ' adjacency_list = [] node_dict = {} c_new = 0 for each_node in all_node_iter_new: node_dict[each_node] = c_new c_new = c_new + 1 correspond_dic = {} count_node = 0 w = [] for line in generate_adjlist_with_all_edges(G1, delimiter): temp_node_name = line.split(sep=delimiter) w_temp = [] for i in range(len(temp_node_name) - 1): temp_name_1 = temp_node_name[0] + ',' + temp_node_name[i + 1] w_temp.append(couple_node_length[temp_name_1]) w.append(w_temp) n_t = [] for each_node in temp_node_name: n_t.append(node_dict[each_node]) correspond_dic[n_t[0]] = count_node count_node = count_node + 1 # del n_t[0] adjacency_list.append(n_t) adjacency_list_new = [[] * 1 for i in range(len(adjacency_list))] w_new = [[] * 1 for i in range(len(adjacency_list))] for i in range(len(adjacency_list)): adjacency_list_new[int(adjacency_list[i][0])] = adjacency_list[i] w_new[int(adjacency_list[i][0])] = w[i] for i in range(len(adjacency_list)): del adjacency_list_new[i][0] xadj = [0] w_f = [] final_adjacency_list = [] for i in range(len(adjacency_list_new)): final_adjacency_list = final_adjacency_list + adjacency_list_new[i] xadj.append(len(final_adjacency_list)) w_f = w_f + w_new[i] # (edgecuts, parts) = pymetis.part_graph(nparts=group_num, adjacency=adjacency_list_new) (edgecuts, parts) = pymetis.part_graph(nparts=group_num, adjncy=final_adjacency_list, xadj=xadj, eweights=w_f) # (edgecuts, parts) = pymetis.part_graph(nparts=group_num, adjacency=adjacency_list_new) candidate_group_list = [[] * 1 for i in range(group_num)] for i in range(len(all_node_iter_new)): candidate_group_list[parts[i]].append(all_node_iter_new[i]) '''parts_new = np.zeros(len(candidate_node_input), dtype=int) for i in range(len(candidate_group_list)): temp_group = candidate_group_list[i] for each_node in temp_group: parts_new[node_dict[each_node]] = i parts_new = list(parts_new)''' new_center = [] new_group = [] new_all_node = [] candidate_pipe_set = set(candidate_pipe_input) all_grouped_pipe = [] for i in range(group_num): # 构建子图 G_sub = G0.subgraph(candidate_group_list[i]) # 计算联通子图 sub_graphs = networkx.connected_components(G_sub) if networkx.number_connected_components(G_sub) == 1: # 求交集 nodeset = G_sub.nodes() pipeset_set = set(cal_area_node_linked_pipe(nodeset, node_pipe_dic)) candidate_pipe = list(pipeset_set.intersection(candidate_pipe_set)) # 判断集合是否保留 if len(candidate_pipe) > 0: # 保留 计算中心 center_t = pick_center_pipe(node_x, node_y, candidate_pipe, pipe_start_node_all, pipe_end_node_all) # 更新 new_center.append(center_t) new_group.append(candidate_pipe) new_all_node.append(nodeset) all_grouped_pipe = all_grouped_pipe + candidate_pipe else: for c in sub_graphs: G_temp = G0.subgraph(c) nodeset = G_temp.nodes() pipeset = cal_area_node_linked_pipe(nodeset, node_pipe_dic) pipeset_set = set(pipeset) # 求交集 candidate_pipe = list(pipeset_set.intersection(candidate_pipe_set)) # print(len(candidate_node)) # 判断集合是否保留 if len(candidate_pipe) > 0: # 保留 计算中心 center_t = pick_center_pipe(node_x, node_y, candidate_pipe, pipe_start_node_all, pipe_end_node_all) # 更新 new_center.append(center_t) new_group.append(candidate_pipe) new_all_node.append(nodeset) all_grouped_pipe = all_grouped_pipe + candidate_pipe record_center = [] c_g = 0 for each_group in new_group: if len(each_group) < 3: record_center.append(new_center[c_g]) c_g += 1 c_g = 0 for each_group in new_group: if len(each_group) >= 3: if new_center[c_g] in record_center: new_center[c_g] = find_new_center_pipe(node_x, node_y, each_group, pipe_start_node_all, pipe_end_node_all, record_center) record_center.append(new_center[c_g]) c_g += 1 visualize_metis_partition( G0, new_center, new_group, node_x, node_y, pipe_start_node_all, pipe_end_node_all ) return new_center, new_group, new_all_node def visualize_metis_partition( G, center_pipes, pipe_groups, node_x, node_y, pipe_start_node_all, pipe_end_node_all ): """ 可视化METIS分区结果（单图模式） 参数： G: 原始管网图(nx.Graph) center_pipes: 中心管道列表(list) pipe_groups: 分组管道列表(list of lists) node_x: 节点X坐标字典(dict) node_y: 节点Y坐标字典(dict) pipe_start_node_all: 管道起点字典(dict) pipe_end_node_all: 管道终点字典(dict) """ plt.figure(figsize=(9, 10)) # 生成颜色映射（自动扩展颜色数量） colors = plt.cm.tab20(np.linspace(0, 1, len(pipe_groups))) # --- 绘制背景管网（灰色半透明） --- for edge in G.edges(): start_node, end_node = edge plt.plot( [node_x[start_node], node_x[end_node]], [node_y[start_node], node_y[end_node]], color='lightgray', linewidth=0.5, alpha=0.3, zorder=1 # 确保背景在底层 ) # --- 绘制各分区管道（彩色）--- legend_handles = [] # 用于图例的句柄 for i, (group, center) in enumerate(zip(pipe_groups, center_pipes)): color = colors[i % len(colors)] # 循环使用颜色 # 绘制分组管道 for pipe in group: start = pipe_start_node_all[pipe] end = pipe_end_node_all[pipe] line = plt.plot( [node_x[start], node_x[end]], [node_y[start], node_y[end]], color=color, linewidth=2.5, alpha=0.8, zorder=2 ) # 只为每个分组的第一个管道添加图例句柄 if pipe == group[0]: legend_handles.append(line[0]) # 高亮中心管道（红色虚线） if center in pipe_start_node_all and center in pipe_end_node_all: start = pipe_start_node_all[center] end = pipe_end_node_all[center] plt.plot( [node_x[start], node_x[end]], [node_y[start], node_y[end]], color='red', linewidth=4, linestyle='--', dash_capstyle='round', zorder=3 # 确保中心管道在最顶层 ) # --- 添加图例和标注 --- # 分组图例 group_labels = [f'Group {i + 1}' for i in range(len(pipe_groups))] plt.legend( legend_handles, group_labels, loc='upper right', title="Partitions", fontsize=8, title_fontsize=10 ) # 中心管道标注（可选） for i, center in enumerate(center_pipes): if center in pipe_start_node_all: x = (node_x[pipe_start_node_all[center]] + node_x[pipe_end_node_all[center]]) / 2 y = (node_y[pipe_start_node_all[center]] + node_y[pipe_end_node_all[center]]) / 2 plt.text( x, y, f'C{i + 1}', color='red', fontsize=10, ha='center', va='center', bbox=dict(facecolor='white', alpha=0.8, edgecolor='none') ) # --- 图形美化 --- plt.title("Water Network Partitioning Overview", fontsize=14, pad=20) plt.xlabel("X Coordinate", fontsize=10) plt.ylabel("Y Coordinate", fontsize=10) plt.grid(True, alpha=0.2, linestyle=':') plt.tight_layout() # 显示图形 plt.show() # def generate_adjlist_with_all_edges(G, delimiter): for s, nbrs in G.adjacency(): line = str(s) + delimiter for t, data in nbrs.items(): line += str(t) + delimiter yield line[: -len(delimiter)] # # Similarity matching module def cal_similarity_simple_return_dd(similarity_mode, monitor_p, predict_p, normal_p, leak_p, monitor_p_all, predict_p_all, normal_p_all, leak_p_all, important_sensor, mean_dpressure, dpressure_std, dpressure_std_all, if_gy=0, cos_or_flow=1): # cos_or_flow 用于 CAF dpressure_s = normal_p - leak_p dpressure = predict_p - monitor_p act_dpressure = pd.Series(dtype=object) for i in range(len(leak_p.index)): if dpressure_std.iloc[i] > -200: # 0.001: if if_gy == 1: act_dpressure[leak_p.index[i]] = (leak_p.iloc[i] - monitor_p.iloc[i]) / dpressure_std.iloc[i] else: act_dpressure[leak_p.index[i]] = leak_p.iloc[i] - monitor_p.iloc[i] if similarity_mode == 'COS' or (similarity_mode == 'CAF' and cos_or_flow == 1): '''if leak_p.min()<0: none_flag = 1 similarity_cos = 0 similarity_dis = 0 else:''' none_flag = 0 sensor_for_cos = list(set(dpressure_s.index).intersection(set(act_dpressure.index))) '''if len(dpressure_s) ==0 or len(dpressure) ==0: jj=9 else:''' try: s1 = np.dot(np.transpose(dpressure_s.loc[sensor_for_cos]), dpressure.loc[sensor_for_cos]) s2 = np.linalg.norm(dpressure_s.loc[sensor_for_cos]) * np.linalg.norm(dpressure.loc[sensor_for_cos]) if s2 == 0: s2 = s2 + 0.0001 similarity_cos = s1 / s2 similarity_dis = 0 except Exception as e: print(dpressure_s) print(sensor_for_cos) print(act_dpressure) print(dpressure_std) print(dpressure) elif similarity_mode == 'DIS' or (similarity_mode == 'CAF' and cos_or_flow == 2): '''if leak_p.min()<0: none_flag = 1 else:''' none_flag = 0 important_sensor = list(set(important_sensor).intersection(set(act_dpressure.index))) part_dpressure = dpressure_s[important_sensor] - dpressure[important_sensor] similarity_pre_DIS = np.linalg.norm(part_dpressure) # similarity_pre_DIS_later = 1 / (1 + similarity_pre_DIS) similarity_dis = similarity_pre_DIS similarity_cos = 0 elif similarity_mode == 'CAD_new': act_dpressure = leak_p - monitor_p '''if leak_p.min() < 0: none_flag = 1 similarity_cos = 0 similarity_dis =0 else:''' none_flag = 0 # cos s1 = np.dot(np.transpose(dpressure_s), dpressure) s2 = np.linalg.norm(dpressure_s) * np.linalg.norm(dpressure) if s2 == 0: s2 = s2 + 0.0001 similarity_cos = s1 / s2 # DIS part_dpressure = act_dpressure.loc[important_sensor] similarity_pre_DIS = np.linalg.norm(part_dpressure) similarity_pre_DIS_later = 1 / (1 + similarity_pre_DIS) similarity_dis = similarity_pre_DIS elif similarity_mode == 'CAD_new_gy' or similarity_mode == 'CDF': # cos sensor_for_cos = list(set(dpressure_s.index).intersection(set(act_dpressure.index))) if len(sensor_for_cos) == 0 and len(dpressure_s) == 0: similarity_cos = 0 elif len(sensor_for_cos) == 0 and len(dpressure_s) > 0: sensor_for_cos = list(dpressure_s.index) none_flag = 0 s1 = np.dot(np.transpose(dpressure_s.loc[sensor_for_cos]), dpressure.loc[sensor_for_cos]) s2 = np.linalg.norm(dpressure_s.loc[sensor_for_cos]) * np.linalg.norm(dpressure.loc[sensor_for_cos]) if s2 == 0: s2 = s2 + 0.0001 similarity_cos = s1 / s2 else: none_flag = 0 s1 = np.dot(np.transpose(dpressure_s.loc[sensor_for_cos]), dpressure.loc[sensor_for_cos]) s2 = np.linalg.norm(dpressure_s.loc[sensor_for_cos]) * np.linalg.norm(dpressure.loc[sensor_for_cos]) if s2 == 0: s2 = s2 + 0.0001 similarity_cos = s1 / s2 # DIS important_sensor_new = list(set(important_sensor).intersection(set(act_dpressure.index))) if len(important_sensor_new) == 0: important_sensor_new = important_sensor act_dpressure = pd.Series(dtype=object) for i in range(len(leak_p_all.index)): # if dpressure_std.iloc [i] > -200: # 0.001: if if_gy == 1: act_dpressure[leak_p_all.index[i]] = (leak_p_all.iloc[i] - monitor_p_all.iloc[i]) / \ dpressure_std_all.iloc[i] else: act_dpressure[leak_p_all.index[i]] = leak_p_all.iloc[i] - monitor_p_all.iloc[i] # part_dpressure = act_dpressure.loc[important_sensor_new] part_dpressure = (dpressure.loc[important_sensor_new] - dpressure_s.loc[important_sensor_new]) similarity_pre_DIS = np.linalg.norm(part_dpressure) ## chang test # part_dpressure = dpressure_s.loc[important_sensor]-dpressure.loc[important_sensor] # similarity_pre_DIS = np.linalg.norm(part_dpressure) # similarity_pre_DIS_later = 1 / (1 + similarity_pre_DIS) similarity_dis = similarity_pre_DIS elif similarity_mode == 'OF': # cos similarity_cos = 0 none_flag = 0 # DIS important_sensor_new = list(set(important_sensor).intersection(set(act_dpressure.index))) if len(important_sensor_new) == 0: important_sensor_new = important_sensor act_dpressure = pd.Series(dtype=object) for i in range(len(leak_p_all.index)): # if dpressure_std.iloc [i] > -200: # 0.001: if if_gy == 1: act_dpressure[leak_p_all.index[i]] = (leak_p_all.iloc[i] - monitor_p_all.iloc[i]) / \ dpressure_std_all.iloc[i] else: act_dpressure[leak_p_all.index[i]] = leak_p_all.iloc[i] - monitor_p_all.iloc[i] # part_dpressure = act_dpressure.loc[important_sensor_new] part_dpressure = (dpressure.loc[important_sensor_new] - dpressure_s.loc[important_sensor_new]) similarity_pre_DIS = np.linalg.norm(part_dpressure) ## chang test # part_dpressure = dpressure_s.loc[important_sensor]-dpressure.loc[important_sensor] # similarity_pre_DIS = np.linalg.norm(part_dpressure) # similarity_pre_DIS_later = 1 / (1 + similarity_pre_DIS) similarity_dis = similarity_pre_DIS return similarity_cos, similarity_dis, none_flag def adjust(similarity_cos, similarity_dis, record_success_candidate, record_success_no_candidate): if len(record_success_no_candidate) > 0: for each in record_success_no_candidate: similarity_cos[each] = similarity_cos[record_success_candidate].min() * 0.9 similarity_dis[each] = similarity_dis[record_success_candidate].max() * 1.1 return similarity_cos, similarity_dis def cal_sq_all_multi(similarity_cos, similarity_dis, similarity_f, candidate_pipe, timestep_list_spc, if_flow, if_only_cos, if_only_flow, cos_h_input, dis_h_input, dis_f_h_input, if_compalsive, cos_sensor_num, flow_sensor_num): if if_only_flow == 1: similarity_f, h_f = cal_sq_single_array(similarity_f.values.reshape((-1, 1)), if_direct=2) sq_cos = 0 sq_dis = 0 sq_f = 1 similarity_all = similarity_f * sq_f output_similarity = similarity_all.reshape((-1, len(candidate_pipe))) output_similarity_pd = pd.DataFrame(output_similarity, index=timestep_list_spc, columns=candidate_pipe) else: if if_only_cos == 0: if if_flow == 1: # standerdize similarity_cos, h_cos = cal_sq_single_array(similarity_cos.values.reshape((-1, 1)), if_direct=1) similarity_dis, h_dis = cal_sq_single_array(similarity_dis.values.reshape((-1, 1)), if_direct=2) similarity_f, h_f = cal_sq_single_array(similarity_f.values.reshape((-1, 1)), if_direct=2) if if_compalsive == 1: sq_cos = cos_h_input sq_dis = dis_h_input sq_f = dis_f_h_input else: '''sq_cos = h_cos/(h_cos +h_dis +h_f ) sq_dis = h_dis/(h_cos +h_dis +h_f ) sq_f = h_f/(h_cos +h_dis +h_f )''' sq_cos, sq_dis, sq_f = add_weight_for_SQ(h_cos, h_dis, h_f, cos_sensor_num, flow_sensor_num) '''if cos_sensor_num == 2 and sq_cos>0.2: sq_cos = 0.2 sq_dis = 0.8*h_dis / (h_dis + h_f) sq_f = 0.8*h_f / (h_dis + h_f) if cos_sensor_num == 1 and sq_dis > 0.3: sq_cos = 0.1 sq_dis = 0.3 sq_f = 0.6''' sq_cos, sq_dis, sq_f = adjust_ratio('CDF', sq_cos, sq_dis, sq_f) if cos_sensor_num <= 1: sq_cos = 0 # similarity similarity_all = similarity_cos * sq_cos + similarity_dis * sq_dis + similarity_f * sq_f output_similarity = similarity_all.reshape((-1, len(candidate_pipe))) output_similarity_pd = pd.DataFrame(output_similarity, index=timestep_list_spc, columns=candidate_pipe) else: # standerdize similarity_cos, h_cos = cal_sq_single_array(similarity_cos.values.reshape((-1, 1)), if_direct=1) similarity_dis, h_dis = cal_sq_single_array(similarity_dis.values.reshape((-1, 1)), if_direct=2) if if_compalsive == 1: sq_cos = cos_h_input sq_dis = dis_h_input else: sq_cos = h_cos / (h_cos + h_dis) sq_dis = h_dis / (h_cos + h_dis) if cos_sensor_num == 2 and sq_cos > 0.5: sq_cos = 0.5 sq_dis = 0.5 sq_cos, sq_dis, sq_f = adjust_ratio('CAD_new_gy', sq_cos, sq_dis, 0) sq_f = 0 # similarity similarity_all = similarity_cos * sq_cos + similarity_dis * sq_dis output_similarity = similarity_all.reshape((-1, len(candidate_pipe))) output_similarity_pd = pd.DataFrame(output_similarity, index=timestep_list_spc, columns=candidate_pipe) elif if_only_cos == 1: if if_flow == 1: # standerdize similarity_cos, h_cos = cal_sq_single_array(similarity_cos.values.reshape((-1, 1)), if_direct=1) similarity_f, h_f = cal_sq_single_array(similarity_f.values.reshape((-1, 1)), if_direct=1) # if_direct=2 if if_compalsive == 1: sq_cos = cos_h_input sq_f = dis_f_h_input else: sq_cos = h_cos / (h_cos + h_f) sq_f = h_f / (h_cos + h_f) sq_cos, sq_dis, sq_f = adjust_ratio('CAF', sq_cos, 0, sq_f) sq_dis = 0 # similarity similarity_all = similarity_cos * sq_cos + similarity_f * sq_f output_similarity = similarity_all.reshape((-1, len(candidate_pipe))) output_similarity_pd = pd.DataFrame(output_similarity, index=timestep_list_spc, columns=candidate_pipe) else: sq_cos = cos_h_input sq_dis = dis_h_input sq_f = dis_f_h_input output_similarity_pd = similarity_cos else: sq_cos = cos_h_input sq_dis = dis_h_input sq_f = dis_f_h_input output_similarity_pd = 1 / (similarity_dis + 1) return output_similarity_pd, sq_cos, sq_dis, sq_f def add_weight_for_SQ(h_cos, h_dis, h_f, sensor_cos_num, sensor_f_num): h_f_new = h_f * sensor_f_num if sensor_cos_num <= 1: h_cos_new = 0 h_dis_new = h_dis * sensor_cos_num else: h_cos_new = h_cos * sensor_cos_num # / 2 h_dis_new = h_dis * sensor_cos_num # / 2 cos_sq = h_cos_new / (h_cos_new + h_dis_new + h_f_new) dis_sq = h_dis_new / (h_cos_new + h_dis_new + h_f_new) f_sq = h_f_new / (h_cos_new + h_dis_new + h_f_new) if sensor_cos_num == 2 and cos_sq > 0.2: cos_sq = 0.2 dis_sq = 0.8 * h_dis_new / (h_dis_new + h_f_new) f_sq = 0.8 * h_f_new / (h_dis_new + h_f_new) '''if sensor_cos_num == 1: if dis_sq / f_sq > sensor_cos_num/sensor_f_num: dis_sq = sensor_cos_num/sensor_f_num f_sq=1-dis_sq''' # if h_dis_new/h_f_new > sensor_cos_num/sensor_f_num return cos_sq, dis_sq, f_sq def cal_sq_single_array(similarity_pre, if_direct): if similarity_pre.max() - similarity_pre.min() == 0: similarity_pre = np.ones(similarity_pre.shape) else: if if_direct == 1: similarity_pre = 0.998 * (similarity_pre - similarity_pre.min()) / ( similarity_pre.max() - similarity_pre.min()) + 0.002 else: similarity_pre = 0.998 * (similarity_pre.max() - similarity_pre) / ( similarity_pre.max() - similarity_pre.min()) + 0.002 # calculate pij similarity_p = similarity_pre / similarity_pre.sum() # cal xinxishang similarity_lnp = np.zeros((len(similarity_pre), 1)) for j in range(len(similarity_p)): similarity_lnp[j] = -similarity_p[j] * math.log(similarity_p[j], math.e) h = 1 - 1 / math.log(len(similarity_pre), math.e) * similarity_lnp.sum() return similarity_pre, h def cal_similarity_all_multi_new_sq_improve_double_lzr(candidate_pipe, similarity_mode, pressure_leak, monitor_p, predict_p, normal_p, if_flow, if_only_cos, if_only_flow, flow_leak, monitor_f, predict_f, normal_f, timestep_list, Top_sensor_num, if_gy, effective_sensor, cos_h, dis_h, dis_f_h, if_compalsive, max_flow): similarity = pd.Series(dtype=float, index=candidate_pipe) important_p_sensor = cal_top_sensors(monitor_p, predict_p, Top_sensor_num) # important_f_sensor, basic_f = cal_top_f_sensor(normal_f) important_f_sensor = monitor_f.columns if len(important_p_sensor) > 0 or len(important_f_sensor) > 0: # if len(important_p_sensor) > 0 break_flag = 0 pressure_leak_new = pressure_leak.swaplevel() flow_leak_new = flow_leak.swaplevel() total_similarity_cos = pd.DataFrame(index=timestep_list, columns=candidate_pipe) total_similarity_dis = pd.DataFrame(index=timestep_list, columns=candidate_pipe) total_similarity_dis_f = pd.DataFrame(index=timestep_list, columns=candidate_pipe) total_similarity_cos_f = pd.DataFrame(index=timestep_list, columns=candidate_pipe) for timestep in timestep_list: # cal p_cos, p_dis, f_dis if if_only_flow != 1: pressure_leak_temp = pressure_leak_new.loc[timestep].loc[:, effective_sensor] monitor_p_temp = monitor_p.loc[timestep, effective_sensor] predict_p_temp = predict_p.loc[timestep, effective_sensor] normal_p_temp = normal_p.loc[timestep, effective_sensor] total_similarity_cos.loc[timestep, :], total_similarity_dis.loc[timestep, :] = cal_similarity_all_cos_dis( candidate_pipe, pressure_leak_temp, similarity_mode, monitor_p_temp, predict_p_temp, normal_p_temp, pressure_leak_new.loc[timestep].loc[:, monitor_p.columns], monitor_p.loc[timestep, :], predict_p.loc[timestep, :], normal_p.loc[timestep, :], important_p_sensor, if_gy, cos_or_flow=1) if if_flow == 1: if len(timestep_list) == 1: leak_f_temp = flow_leak_new.loc[timestep].loc[:, important_f_sensor] monitor_f_temp = monitor_f.loc[timestep, important_f_sensor] predict_f_temp = predict_f.loc[timestep, important_f_sensor] normal_f_temp = normal_f.loc[timestep, important_f_sensor] basic_normal_f_temp = abs(max_flow.loc[important_f_sensor]) leak_f_temp = leak_f_temp / basic_normal_f_temp monitor_f_temp = monitor_f_temp / basic_normal_f_temp predict_f_temp = predict_f_temp / basic_normal_f_temp normal_f_temp = normal_f_temp / basic_normal_f_temp else: basic_f = abs(max_flow.loc[important_f_sensor]) leak_f_temp = flow_leak_new.loc[timestep].loc[:, important_f_sensor] / basic_f monitor_f_temp = monitor_f.loc[timestep, important_f_sensor] / basic_f predict_f_temp = predict_f.loc[timestep, important_f_sensor] / basic_f normal_f_temp = normal_f.loc[timestep, important_f_sensor] / basic_f total_similarity_cos_f.loc[timestep, :], total_similarity_dis_f.loc[timestep, :] = cal_similarity_all_cos_dis(candidate_pipe, leak_f_temp, similarity_mode, monitor_f_temp, predict_f_temp, normal_f_temp, flow_leak_new.loc[ timestep].loc[:, monitor_f.columns], monitor_f.loc[timestep, :], predict_f.loc[timestep, :], normal_f.loc[timestep, :], important_f_sensor, if_gy, cos_or_flow=1) # cos_or_flow=2 else: total_similarity_cos_f = [] # dis similarity_all, cos_h, dis_h, dis_f_h = cal_sq_all_multi(total_similarity_cos, total_similarity_dis, total_similarity_cos_f, candidate_pipe, timestep_list, if_flow, if_only_cos, if_only_flow, cos_h, dis_h, dis_f_h, if_compalsive, len(important_p_sensor), len(important_f_sensor)) if len(timestep_list) == 1: similarity = similarity_all.iloc[0] elif len(timestep_list) > 3: for each_candidate in candidate_pipe: similarity[each_candidate] = remove_3_sigma(similarity_all.loc[:, each_candidate]) else: for each_candidate in candidate_pipe: similarity[each_candidate] = similarity_all.loc[:, each_candidate].mean() similarity = similarity.sort_values(ascending=False) else: break_flag = 1 similarity = 0 cos_h = 0 dis_h = 0 dis_f_h = 0 return similarity, cos_h, dis_h, dis_f_h, break_flag def cal_similarity_all_cos_dis(candidate_pipe, pressure_leak, similarity_mode, monitor_p, predict_p, normal_p, pressure_leak_all, monitor_p_all, predict_p_all, normal_p_all, important_sensor, if_gy, cos_or_flow): similarity_cos = pd.Series(dtype=float, index=candidate_pipe) similarity_dis = pd.Series(dtype=float, index=candidate_pipe) dpressure = normal_p - pressure_leak # 无用 ---------------------------------------------- mean_dpressure = dpressure.mean() monitor_new = pd.DataFrame(index=['monitor'], columns=monitor_p.index) monitor_new.iloc[0] = monitor_p add_m_leak_pressure = [pressure_leak, monitor_p] add_m_leak_pressure = pd.concat(add_m_leak_pressure) pressure_leak_std = np.std(add_m_leak_pressure, ddof=1) pressure_leak_std = pd.Series(pressure_leak_std, index=pressure_leak.columns) add_m_leak_pressure_all = [pressure_leak_all, monitor_p_all] add_m_leak_pressure_all = pd.concat(add_m_leak_pressure_all) pressure_leak_std_all = np.std(add_m_leak_pressure_all, ddof=1) pressure_leak_std_all = pd.Series(pressure_leak_std_all, index=pressure_leak.columns) # 无用 ---------------------------------------------- monitor_p_temp = monitor_p predict_p_temp = predict_p normal_p_temp = normal_p monitor_p_temp_all = monitor_p_all predict_p_temp_all = predict_p_all normal_p_temp_all = normal_p_all record_success_candidate = [] record_success_no_candidate = [] for i in range(len(candidate_pipe)): leak_p = pressure_leak.iloc[i, :] leak_p_all = pressure_leak_all.iloc[i, :] similarity_cos.iloc[i], similarity_dis.iloc[i], none_flag = cal_similarity_simple_return_dd( similarity_mode, monitor_p_temp, predict_p_temp, normal_p_temp, leak_p, monitor_p_temp_all, predict_p_temp_all, normal_p_temp_all, leak_p_all, important_sensor, mean_dpressure, pressure_leak_std, pressure_leak_std_all, if_gy, cos_or_flow) if none_flag == 0: record_success_candidate.append(candidate_pipe[i]) else: record_success_no_candidate.append(candidate_pipe[i]) similarity_cos, similarity_dis = adjust(similarity_cos, similarity_dis, record_success_candidate, record_success_no_candidate) return similarity_cos, similarity_dis def cal_top_f_sensor(normal_f): if type(normal_f) == pd.core.frame.DataFrame: mean_f = normal_f.mean() else: mean_f = normal_f output_sensor = [] output_normal_f = pd.Series(dtype=object) for i in range(len(mean_f.index)): if abs(mean_f.iloc[i]) > 0.01 / 3600: output_sensor.append(mean_f.index[i]) output_normal_f[mean_f.index[i]] = mean_f.iloc[i] return output_sensor, output_normal_f def cal_top_sensors(monitor_p, predict_p, Top_sensor_num): dpressure = abs(predict_p - monitor_p) if type(dpressure) == pd.core.frame.DataFrame: dpressure = dpressure.mean() dpressure_rank = dpressure.sort_values(ascending=False) return list(dpressure_rank.index[:Top_sensor_num]) def remove_3_sigma(similarity_t): all_sample = len(similarity_t.index) apart_sample = math.ceil(all_sample * 0.6) similarity = similarity_t.astype('float') mean_t = similarity.mean() std_t = similarity.std() new_similarity = similarity[(similarity <= mean_t + 3 * std_t) & (similarity >= mean_t - 3 * std_t)] mean_t_new = new_similarity.mean() return mean_t_new ## other functions # OF 1 def cal_pipe_coordinate(all_pipe, pipe_start_node, pipe_end_node, node_coordinates): pipe_num = len(all_pipe) pipe_coordinates = np.zeros([pipe_num, 2]) pipe_x = copy.deepcopy(pipe_start_node) pipe_y = copy.deepcopy(pipe_start_node) for i in range(pipe_num): temp_pipe = all_pipe[i] pipe_x[temp_pipe] = (node_coordinates[pipe_start_node[temp_pipe]][0] + node_coordinates[pipe_end_node[temp_pipe]][0]) / 2 pipe_y[temp_pipe] = (node_coordinates[pipe_start_node[temp_pipe]][1] + node_coordinates[pipe_end_node[temp_pipe]][1]) / 2 return pipe_x, pipe_y # OF 1+ def cal_node_coordinate(all_node, node_coordinates): node_x = copy.deepcopy(node_coordinates) node_y = copy.deepcopy(node_coordinates) for i in range(len(node_x)): temp_node = all_node[i] node_x[temp_node] = node_coordinates[temp_node][0] node_y[temp_node] = node_coordinates[temp_node][1] return node_x, node_y # OF 4 def cal_signature_pipe_multi_pf(wn, leak_mag, candidate_center, timestep_list, sensor_name, sensor_f_name): candidate_center_num = len(candidate_center) pressure_leak = pd.DataFrame(index=pd.MultiIndex.from_product([candidate_center, timestep_list]), columns=sensor_name) flow_leak = pd.DataFrame(index=pd.MultiIndex.from_product([candidate_center, timestep_list]), columns=sensor_f_name) pressure_leak = pressure_leak.sort_index() flow_leak = flow_leak.sort_index() for i in range(candidate_center_num): wn, pressure_output, flow_output = leak_simulation_pipe_dd_multi_pf(wn, leak_mag, candidate_center[i], sensor_name, sensor_f_name) # leak_or_not_list.append(leak_or_not) pressure_leak.loc[candidate_center[i]].loc[:, :] = pressure_output flow_leak.loc[candidate_center[i]].loc[:, :] = flow_output sys.stdout.write('\r' + '已经完成计算' + str(i + 1) + '个特征中心') return pressure_leak, flow_leak, candidate_center # OF 6 根据流量计算可能爆管的管段及最小爆管管径 def cal_possible_pipe(leak_flow, all_pipe, pipe_diameter): basic_pressure = 10 # 基础压力 discharge_coeff = 0.6 # 经验系数 break_area_ratio = 1 # 爆管面积比 0.5 1.25 break_area = leak_flow / (discharge_coeff * math.sqrt(2 * basic_pressure * 9.81)) # 爆管面积 m3/h '''break_area_diameter = math.sqrt(4 * break_area / math.pi) min_diameter = (math.ceil(1000 * break_area_diameter / break_area_ratio)) / 1000''' break_area_diameter = math.sqrt(4 * break_area / math.pi / break_area_ratio) # 爆管直径 min_diameter = (math.ceil(1000 * break_area_diameter)) / 1000 # 向上取整 new_all_pipe = pick_pipe(all_pipe, pipe_diameter, min_diameter) return new_all_pipe, min_diameter # Press the green button in the gutter to run the script. def extract_links(data, link_types, direction): return [ link for res_data in data.values() for link_type in link_types for link in res_data[link_type][direction] ] def add_noise_pd(data, noise_type, noise_para): output_data = copy.deepcopy(data) if type(output_data) == pd.core.frame.Series: if noise_type == 'uni': for x in output_data.index: noise = (np.random.random() - 0.5) * 2 output_data[x] = output_data[x] + noise * noise_para elif noise_type == 'gauss': noise = np.random.normal(loc=0, scale=noise_para, size=output_data.shape) output_data = output_data + noise elif type(output_data) == pd.core.frame.DataFrame: if noise_type == 'uni': noise = (np.random.random(size=output_data.shape) - 0.5) * 2 output_data = output_data + noise * noise_para elif noise_type == 'gauss': noise = np.random.normal(loc=0, scale=noise_para, size=output_data.shape) output_data = output_data + noise return output_data def add_noise_number(data, noise_type, noise_para): output_data = copy.deepcopy(data) if noise_type == 'uni': noise = (np.random.random() - 0.5) * 2 output_data = output_data + noise * noise_para elif noise_type == 'gauss': noise = random.gauss(0, noise_para) output_data = output_data + noise return output_data def add_noise_number_flow(data, noise_para_mean, noise_para_std1, noise_para_std2): output_data = copy.deepcopy(data) noise_flag1 = (np.random.random() - 0.5) if noise_flag1 < 0: noise = noise_para_mean - abs(np.random.normal(loc=0, scale=noise_para_std1)) else: noise = noise_para_mean + abs(np.random.normal(loc=0, scale=noise_para_std2)) noise_flag2 = (np.random.random() - 0.5) if noise_flag2 < 0: noise_f = noise * (-1) else: noise_f = noise output_data = output_data + noise_f return output_data def produce_noise_number(noise_type, noise_para): if noise_type == 'uni': noise = (np.random.random() - 0.5) * 2 noise = noise * noise_para elif noise_type == 'gauss': noise = random.gauss(0, noise_para) else: noise = 0 return noise def add_noise_percentage_pd(data, noise_type, noise_para): output_data = copy.deepcopy(data) if type(output_data) == pd.core.frame.Series: if noise_type == 'uni': for x in output_data.index: noise = (np.random.random() - 0.5) * 2 output_data[x] = output_data[x] * (1 + noise * noise_para / 100) elif noise_type == 'gauss': for x in output_data.index: noise = np.random.gauss(0, noise_para) output_data[x] = output_data[x] * (1 + noise / 100) # std_noise = noise.std() elif type(output_data) == pd.core.frame.DataFrame: if noise_type == 'uni': noise = (np.random.random(size=output_data.shape) - 0.5) * 2 output_data = output_data * (1 + noise * noise_para / 100) elif noise_type == 'gauss': noise = np.random.normal(loc=0, scale=noise_para, size=output_data.shape) output_data = output_data * (1 + noise / 100) # std_noise = noise.std().mean() return output_data def produce_pattern_value(wn, all_node): wn_o = copy.deepcopy(wn) # 改_wz_____________________________ sample_node = wn_o.get_node(all_node[0]) num_categories = len(sample_node.demand_timeseries_list) columns = [f'D{i}' for i in range(num_categories)] basic_demand_pd = pd.DataFrame(index=all_node, columns=columns) for each in all_node: node = wn_o.get_node(each) for i in range(num_categories): basic_demand_pd.loc[each, columns[i]] = node.demand_timeseries_list[i].base_value return basic_demand_pd # 添加噪声 def add_noise_in_wn_pf(wn, pipe_c_noise, timestep_list, pipe_coefficient, sensor_name, sensor_f_name, all_node, basic_demand_pd, noise_type, noise_para, leak_pipe, leak_flow): wn.options.time.duration = 0 pipe_roughness_change = add_noise_pd(pipe_coefficient, noise_type, pipe_c_noise) wn = change_para_of_wn(wn, pipe_roughness_change) record_pressure = pd.DataFrame(index=timestep_list, columns=sensor_name) record_flow = pd.DataFrame(index=timestep_list, columns=sensor_f_name) record_noise_all = pd.DataFrame(index=pd.MultiIndex.from_product([timestep_list, all_node]), columns=basic_demand_pd.columns) record_noise_all = record_noise_all.sort_index() # normal 获取添加噪声后的监测点数据 for i in range(len(timestep_list)): wn, record_noise = change_node_demand(wn, basic_demand_pd, all_node, noise_type, noise_para) record_noise_all.loc[timestep_list[i]].loc[:, :] = record_noise pressure_temp, flow_temp = simple_simulation_pf(wn, sensor_name, sensor_f_name, [], []) record_pressure.iloc[i, :] = pressure_temp record_flow.iloc[i, :] = flow_temp # leak_simulation 获取添加漏损后的监测点数据 record_pressure_leak = pd.DataFrame(index=timestep_list, columns=sensor_name) record_flow_leak = pd.DataFrame(index=timestep_list, columns=sensor_f_name) # 改_wz_________________________________________ # add leak wn, whole_inf, add_pipe1 = simple_add_leak(wn, leak_flow, leak_pipe) # simulation for i in range(len(timestep_list)): record_noise = record_noise_all.loc[timestep_list[i]] wn = change_node_demand_leak(wn, record_noise, all_node) pressure_temp, flow_temp = simple_simulation_pf(wn, sensor_name, sensor_f_name, leak_pipe, add_pipe1) record_pressure_leak.iloc[i, :] = pressure_temp record_flow_leak.iloc[i, :] = flow_temp # delete leak wn = simple_recover_wn(wn, whole_inf) return wn, record_pressure, record_flow, record_pressure_leak, record_flow_leak def change_node_demand(wn, basic_demand_pd, all_node, noise_type, noise_para): # 改_wz_____________________________________ record_noise = pd.DataFrame(index=all_node, columns=basic_demand_pd.columns) for each_node in all_node: node = wn.get_node(each_node) num_columns = len(basic_demand_pd.columns) # 处理前N-1列（如果有） for i in range(num_columns - 1): # 获取原始值并添加噪声 record_noise.loc[each_node].iloc[i] = (1 + produce_noise_number(noise_type, noise_para)) * \ basic_demand_pd.loc[each_node].iloc[i] node.demand_timeseries_list[i].base_value = record_noise.loc[each_node].iloc[i] # 处理最后一列（当列数>=1时） if num_columns >= 1: last_col = basic_demand_pd.columns[-1] original_last = basic_demand_pd.loc[each_node, last_col] record_noise.loc[each_node, last_col] = original_last node.demand_timeseries_list[-1].base_value = original_last return wn, record_noise def change_node_demand_leak(wn, record_noise, all_node): # 改_wz_____________________________ sample_node = wn.get_node(all_node[0]) num_categories = len(sample_node.demand_timeseries_list) for each in all_node: node = wn.get_node(each) for i in range(num_categories): node.demand_timeseries_list[i].base_value = record_noise.loc[each].iloc[i] return wn def cal_group_num(candidate_node_input, cal_group_num): candidate_node_num = len(candidate_node_input) if candidate_node_num > 100: group_num_input = cal_group_num # 30 else: group_num_input = 10 return group_num_input def area_output_num_ki_improve(candidate_center, candidate_group, similarity, new_all_node, top_group_ratio, top_pipe_num_max, top_pipe_num_min, cut_ratio): final_area = [] final_center = [] all_node_iter = [] if similarity.index.is_unique == False: total_center_num = len(list(set(similarity.index))) else: total_center_num = len(similarity.index) next_group_num = min(total_center_num, math.ceil(total_center_num / cut_ratio * top_group_ratio)) for i in range(next_group_num): top_center = similarity.index[i] top_center_index = find_list_repeat(candidate_center, top_center) for j in range(len(top_center_index)): final_area = final_area + candidate_group[top_center_index[j]] all_node_iter = all_node_iter + list(new_all_node[top_center_index[j]]) final_center.append(top_center) final_area = list(set(final_area)) if len(final_area) > top_pipe_num_max: if_end = 0 elif len(final_area) > top_pipe_num_min: if_end = 1 elif total_center_num == next_group_num: if_end = 1 else: if_end = 1 for i in np.arange(next_group_num, total_center_num, 1): before_list = copy.deepcopy(final_area) top_center = similarity.index[i] top_center_index = candidate_center.index(top_center) temp_group = final_area + candidate_group[top_center_index] temp_area = list(set(temp_group)) if len(temp_area) < top_pipe_num_min: final_center.append(top_center) all_node_iter = all_node_iter + list(new_all_node[top_center_index]) final_area = temp_area elif len(temp_area) < top_pipe_num_max: final_center.append(top_center) all_node_iter = all_node_iter + list(new_all_node[top_center_index]) final_area = temp_area break else: a = len(temp_area) - top_pipe_num_max b = top_pipe_num_min - len(before_list) if a >= b: final_area = before_list else: final_center.append(top_center) all_node_iter = all_node_iter + list(new_all_node[top_center_index]) final_area = temp_area break final_center = list(set(final_center)) all_node_iter = list(set(all_node_iter)) return final_area, final_center, all_node_iter, if_end def find_list_repeat(candidate_center, target): repeated_list = [] for index, nums in enumerate(candidate_center): if nums == target: repeated_list.append(index) return repeated_list def change_para_of_wn(wn, pipe_roughness_change): for pipe_name, pipe in wn.pipes(): pipe.roughness = pipe_roughness_change[pipe_name] return wn def cal_DtoTop1(G0, pipe_leak, located_pipe, pipe_start_node_all, pipe_end_node_all, pipe_length): if pipe_leak == located_pipe: result_DtoTop1 = 0 result_DtoTop1_num = 0 else: pipe_leak_start_node = pipe_start_node_all[pipe_leak] pipe_leak_end_node = pipe_end_node_all[pipe_leak] located_pipe_start_node = pipe_start_node_all[located_pipe] located_pipe_end_node = pipe_end_node_all[located_pipe] DtoTop1_series = pd.Series(dtype=object) DtoTop1_num_series = pd.Series(dtype=object) DtoTop1_series['ss'] = nx.shortest_path_length(G0, pipe_leak_start_node, located_pipe_start_node, weight='weight') DtoTop1_series['se'] = nx.shortest_path_length(G0, pipe_leak_start_node, located_pipe_end_node, weight='weight') DtoTop1_series['es'] = nx.shortest_path_length(G0, pipe_leak_end_node, located_pipe_start_node, weight='weight') DtoTop1_series['ee'] = nx.shortest_path_length(G0, pipe_leak_end_node, located_pipe_end_node, weight='weight') DtoTop1_num_series['ss'] = nx.shortest_path_length(G0, pipe_leak_start_node, located_pipe_start_node) DtoTop1_num_series['se'] = nx.shortest_path_length(G0, pipe_leak_start_node, located_pipe_end_node) DtoTop1_num_series['es'] = nx.shortest_path_length(G0, pipe_leak_end_node, located_pipe_start_node) DtoTop1_num_series['ee'] = nx.shortest_path_length(G0, pipe_leak_end_node, located_pipe_end_node) if DtoTop1_num_series.min() == 0: result_DtoTop1_num = 1 result_DtoTop1 = DtoTop1_series.max() / 2 else: result_DtoTop1_num = DtoTop1_num_series.min() + 1 DtoTop1_type = DtoTop1_series.argmin() result_DtoTop1 = DtoTop1_series[DtoTop1_type] + (pipe_length[pipe_leak] + pipe_length[located_pipe]) / 2 return result_DtoTop1, result_DtoTop1_num def cal_RR(located_pipe, similarity_sp): if located_pipe in similarity_sp.index: rank = similarity_sp.index.get_loc(located_pipe) RR = rank / len(similarity_sp.index) else: RR = 1.1 return RR def cal_cover(similarity, leak_pipe): if leak_pipe in list(similarity.index): cover = 1 else: cover = 0 return cover def cal_SD(located_pipe, real_pipe, pipe_x, pipe_y): dx = pipe_x[located_pipe] - pipe_x[real_pipe] dy = pipe_y[located_pipe] - pipe_y[real_pipe] SD = math.sqrt(dx * dx + dy * dy) return SD def update_similarity(leak_candidate_center, similarity, leak_center_dict): similarity_new = pd.Series(dtype=object) for each_center in leak_candidate_center: houxuan_center = leak_center_dict[each_center] if len(houxuan_center) > 1: temp_similarity = similarity[houxuan_center] similarity_new[each_center] = temp_similarity.max() else: if type(similarity[each_center]) == pd.core.series.Series: similarity_new[each_center] = similarity[each_center].mean() else: similarity_new[each_center] = similarity[each_center] similarity_new = similarity_new.sort_values(ascending=False) return similarity_new def extra_judge(similarity): mean_similarity = float(similarity.mean()) record_sensor = [] record_value = [] for i in range(len(similarity.index)): if similarity.iloc[i] >= mean_similarity: record_value.append(similarity.iloc[i]) record_sensor.append(similarity.index[i]) out_put_similarity = pd.Series(record_value, index=record_sensor, dtype=object) cut_ratio = len(out_put_similarity.index) / len(similarity.index) return cut_ratio, out_put_similarity def adjust_ratio(similarity_mode, cos_h, dis_h, dis_f_h, low_limit=0.1): if similarity_mode == 'CAF': if cos_h < low_limit: cos_h = low_limit dis_f_h = 1 - cos_h elif dis_f_h < low_limit: dis_f_h = low_limit cos_h = 1 - dis_f_h elif similarity_mode == 'CAD_new_gy': if dis_h < low_limit: dis_h = low_limit cos_h = 1 - dis_h elif cos_h < low_limit: cos_h = low_limit dis_h = 1 - cos_h elif similarity_mode == 'CDF': normal_index = [0, 1, 2] h_list = [cos_h, dis_h, dis_f_h] if cos_h < low_limit: h_list[0] = low_limit normal_index.remove(0) if dis_h < low_limit: h_list[1] = low_limit normal_index.remove(1) if dis_f_h < low_limit: h_list[2] = low_limit normal_index.remove(2) if len(normal_index) == 1: h_list[normal_index[0]] = h_list[normal_index[0]] - (sum(h_list) - 1) elif len(normal_index) == 2: sum_list = sum(h_list) multiper = 1 - (sum_list - 1) / (h_list[normal_index[0]] + h_list[normal_index[1]]) h_list[normal_index[0]] = h_list[normal_index[0]] * multiper h_list[normal_index[1]] = h_list[normal_index[1]] * multiper cos_h, dis_h, dis_f_h = h_list[0], h_list[1], h_list[2] return cos_h, dis_h, dis_f_h # DAND def DN_search_multi_simple_add_flow_count_new(wn, G0, all_node, node_x, node_y, pipe_start_node_all, pipe_end_node_all, couple_node_length, node_pipe_dic, all_node_series, top_group_ratio, top_pipe_num_max, top_pipe_num_min, candidate_pipe_input_initial, similarity_mode, pressure_monitor, pressure_predict, pressure_normal, pressure_leak_all, flow_monitor, flow_predict, flow_normal, flow_leak_all, timestep_list, max_flow, group_basic_num, Top_sensor_num, if_gy, pressure_threshold): """ 是一个较为复杂的迭代搜索函数，用于通过多次分组、仿真与相似性计算，最终定位出最可能发生漏损（或爆管）的管道。 函数内部依次调用前述的分组（metis_grouping_pipe_weight）、相似性计算（cal_similarity_all_multi_new_sq_improve_double_lzr） 以及候选区域更新（area_output_num_ki_improve）函数。 :param wn: 水网模型 :param G0: 网络图 :param all_node: 节点列表 :param node_x: 节点坐标映射（字典或 Series） :param node_y: 节点坐标映射（字典或 Series） :param pipe_start_node_all: 字典 :param pipe_end_node_all: 字典 :param couple_node_length: 字典 :param node_pipe_dic: 字典 :param all_node_series: pandas Series :param top_group_ratio: 数值 :param top_pipe_num_max: 数值 :param top_pipe_num_min: 数值 :param candidate_pipe_input_initial: 候选管道列表 :param similarity_mode: 字符串 :param pressure_monitor: 压力数 :param pressure_predict: 压力数 :param pressure_normal: 压力数 :param pressure_leak_all: 压力数 :param timestep_list: 时间步列表 :param max_flow: Series 或字典 :param group_basic_num: 数值 :param Top_sensor_num: 整数 :param if_gy: 标志（整型或布尔） :param pressure_threshold: 数值 :return: 最终候选管道（最高相似性对应的管道名称）、耗时（秒）、模拟次数、更新后的 wn、以及最终相似性排序的 pandas Series """ iter_count = 0 all_node_iter = copy.deepcopy(all_node) candidate_pipe_input = copy.deepcopy(candidate_pipe_input_initial) # 可能漏损管段 t1 = datetime.now() if_flow, if_only_cos, if_only_flow = decode_mode(similarity_mode) # 定位方法 # threshold if if_only_flow == 1: dpressure = (flow_predict - flow_monitor).mean() dpressure = np.abs(dpressure) effective_sensor = list(dpressure.index) else: dpressure = (pressure_predict - pressure_monitor).mean() dpressure = np.abs(dpressure) dpressure = dpressure[dpressure > pressure_threshold] effective_sensor = list(dpressure.index) simulation_times = 0 # 模拟次数 if len(dpressure) > 0: cos_h = 0 dis_h = 0 dis_f_h = 0 if_compalsive = 0 record_center_dataset = [] # iter while 1: final_area = [] final_center = [] group_num = cal_group_num(candidate_pipe_input, group_basic_num) # group 分组，得出候选漏损中心 candidate_center_list, candidate_group_list, new_all_node = metis_grouping_pipe_weight(G0, wn, all_node_iter, candidate_pipe_input, group_num, node_x, node_y, pipe_start_node_all, pipe_end_node_all, node_pipe_dic, all_node_series, couple_node_length) simulation_times = simulation_times + len(candidate_center_list) # pick_pressure_leak pressure_leak = pressure_leak_all.loc[candidate_center_list].loc[:, :] flow_leak = flow_leak_all.loc[candidate_center_list].loc[:, :] # pressure_leak_f= pressure_leak.swaplevel() # -------------------------------------------------------- add_center = [] leak_center_dict = dict() for i in range(len(candidate_center_list)): houxuan_center = [] for each_center in record_center_dataset: if each_center in candidate_group_list[i] and each_center != candidate_center_list[i]: houxuan_center.append(each_center) add_center = add_center + houxuan_center houxuan_center.append(candidate_center_list[i]) leak_center_dict[candidate_center_list[i]] = houxuan_center for each_center in candidate_center_list: if each_center not in record_center_dataset: record_center_dataset.append(each_center) # -------------------------------------------------------- # -------------------------------------------------------- if len(add_center) > 0: s3 = pressure_leak_all.loc[add_center] pressure_leak = pd.concat([pressure_leak, s3]) s4 = flow_leak_all.loc[add_center] flow_leak = pd.concat([flow_leak, s4]) # -------------------------------------------------------- # -------------------------------------------------------- # if len(candidate_pipe_input) < 1.2 * top_pipe_num_max / top_group_ratio: if_compalsive = 1 cos_h, dis_h, dis_f_h = adjust_ratio(similarity_mode, cos_h, dis_h, dis_f_h) candidate_center_list_sup = candidate_center_list + add_center similarity, cos_h, dis_h, dis_f_h, break_flag = cal_similarity_all_multi_new_sq_improve_double_lzr( candidate_center_list_sup, similarity_mode, pressure_leak, pressure_monitor, pressure_predict, pressure_normal, if_flow, if_only_cos, if_only_flow, flow_leak, flow_monitor, flow_predict, flow_normal, timestep_list, Top_sensor_num, if_gy, effective_sensor, cos_h, dis_h, dis_f_h, if_compalsive, max_flow) if break_flag == 1: break new_similarity = update_similarity(candidate_center_list, similarity, leak_center_dict) if len(candidate_pipe_input) > top_pipe_num_max / top_group_ratio: cut_ratio, new_similarity = extra_judge(new_similarity) else: cut_ratio = 1 final_area_t, final_center_t, all_node_new_1, if_end = area_output_num_ki_improve(candidate_center_list, candidate_group_list, new_similarity, new_all_node, top_group_ratio, top_pipe_num_max, top_pipe_num_min, cut_ratio) final_area = final_area + final_area_t final_center = final_center + final_center_t final_area = list(set(final_area)) final_center = list(set(final_center)) if if_end == 1: break elif len(candidate_pipe_input) == len(final_area): break else: candidate_pipe_input = final_area all_node_iter = all_node_new_1 iter_count += 1 sys.stdout.write( '\r' + '已经完成' + str(iter_count) + '次迭代计算' + '候选节点' + str(len(final_area)) + '个') if break_flag == 0: final_area_pipe = copy.deepcopy(final_area) simulation_times = simulation_times + len(final_area) pressure_leak_sp = pressure_leak_all.loc[final_area_pipe].loc[:, :] flow_leak_sp = flow_leak_all.loc[final_area_pipe].loc[:, :] similarity_sp, cos_h, dis_h, dis_f_h, break_flag = cal_similarity_all_multi_new_sq_improve_double_lzr( final_area_pipe, similarity_mode, pressure_leak_sp, pressure_monitor, pressure_predict, pressure_normal, if_flow, if_only_cos, if_only_flow, flow_leak_sp, flow_monitor, flow_predict, flow_normal, timestep_list, Top_sensor_num, if_gy, effective_sensor, cos_h, dis_h, dis_f_h, if_compalsive, max_flow) else: dpressure = (pressure_predict - pressure_monitor).mean() dpressure = np.abs(dpressure) simulation_times = simulation_times + len(dpressure.index) similarity_sp = pd.Series(dtype=object) for each_node in dpressure.index: pipe = node_pipe_dic[each_node][0] similarity_sp.loc[pipe] = dpressure.loc[each_node] similarity_sp = similarity_sp.sort_values(ascending=False) t2 = datetime.now() final_area_pipe = [] sys.stdout.write( '\r' + '已经完成' + str(iter_count + 1) + '次迭代计算' + '候选节点' + str(len(final_area_pipe)) + '个') t2 = datetime.now() dt = (t2 - t1).seconds else: dpressure = (pressure_predict - pressure_monitor).mean() dpressure = np.abs(dpressure) similarity_sp = pd.Series(dtype=object) for each_node in dpressure.index: pipe = node_pipe_dic[each_node][0] similarity_sp.loc[pipe] = dpressure.loc[each_node] similarity_sp = similarity_sp.sort_values(ascending=False) t2 = datetime.now() dt = (t2 - t1).seconds return similarity_sp.index[0], dt, simulation_times, wn, similarity_sp def decode_mode(similarity_mode): if similarity_mode == 'COS': if_flow = 0 if_only_cos = 1 if_only_flow = 0 elif similarity_mode == 'CAD_new_gy': if_flow = 0 if_only_cos = 0 if_only_flow = 0 elif similarity_mode == 'CDF': if_flow = 1 if_only_cos = 0 if_only_flow = 0 elif similarity_mode == 'CAF': if_flow = 1 if_only_cos = 1 if_only_flow = 0 elif similarity_mode == 'DIS': if_flow = 1 if_only_cos = 2 if_only_flow = 0 elif similarity_mode == 'OF': if_flow = 1 if_only_cos = 0 if_only_flow = 1 return if_flow, if_only_cos, if_only_flow # 根据爆管直径选择可能管段 def pick_pipe(all_pipes, pipe_diameter, limited_diameter): candidate_pipe = [] for each_pipe in all_pipes: if pipe_diameter[each_pipe] >= limited_diameter: candidate_pipe.append(each_pipe) return candidate_pipe #2025/6/7 def locate_burst(name: str, pressure_SCADA_ID_list: list[list[str]], burst_SCADA_pressure: pd.Series, normal_SCADA_pressure: pd.Series, flow_SCADA_ID_list: list[list[str]], burst_SCADA_flow: pd.Series, normal_SCADA_flow: pd.Series, burst_leakage: float, burst_happen_time: str, basic_pressure: float = 10.0): """ 漏损定位 :param name: 数据库名称 :param pressure_SCADA_ID_list: 压力SCADA点的名称列表 :param burst_SCADA_pressure: 爆管时真实压力 or 爆管方案模拟的到的压力 :param normal_SCADA_pressure: 爆管时间数据平滑得到的压力 or 正常情况下的压力 :param burst_leakage: 爆管漏损水量 :param burst_happen_time: 爆管发生时间，格式为'2024-11-25T09:00:00+08:00' :param basic_pressure: 水厂给整片管网的最小服务压力。根据《城镇供水服务》（GB/T 32063-2015），管网末梢最小服务压力应不低于 0.14 MPa（14米水柱）, 《消防给水及消火栓系统技术规范》（GB 50974-2014）规定,火灾时管网压力应至少达到 0.10 MPa（10米水柱） :return: """ # candidate_type candidate_type = 'pipe' top_group_ratio = 0.4 top_pipe_num_max = 42 # 25 top_pipe_num_min = 34 # 35 # modified # similarity_mode_list = ['CDF_inflow','CDF_other','CAD_new_gy','CAF','COS'] method_rational = 0.5 # 保存路径 与 部分参数 修改 file_fold = './1mypaperdata_f/sensor_opt_validation/' # './sensor_opt/' Method_mode = 'DAND' Noise_level = 'N2' Leakage_level = 'L02' version = 'wz_0513' file_path = os.path.join(file_fold, f'{name}' + '_' + Method_mode + '_' + Noise_level + '_' + Leakage_level + '_' + version + '.xlsx') directory = os.path.dirname(file_path) if not os.path.exists(directory): os.makedirs(directory) writer = pd.ExcelWriter(file_path) # other basic_setting 可不修改 candidate_leak_ratio = [float(Leakage_level[1:]) / 10] node_d_noise_list = [0, 0.05, 0.1, 0.15] # /3.27 pipe_c_noise_list = [0, 5, 10, 15] # /3.27 noise_para_monitor_list = [0, 0.1, 0.2, 0.3] # noise_f_para_monitor_list = [0, 1, 2, 5] # % leak_flow_para_mean_list = [0, 0.0125, 0.0125, 0.0125] leak_flow_para_std1_list = [0, 0.0125 / 4, 0.0125 / 4, 0.0125 / 4] leak_flow_para_std2_list = [0, 0.0025 / 3, 0.0025 / 3, 0.0025 / 3] noise_level = int(Noise_level[1:]) ## other # driven_mode = 'DD' require_p = 100 * 1.42 # 20mh2o minimum_p = 0 # 0 if_plot = 0 # 加载原始管网模型及读取信息 # 调用 load_inp 构造水网模型（使用 wntr 模块），加载 正常工况的 INP 文件 wn_origin = load_inp(name=name, before_burst_time=burst_happen_time) # 由read_inf_inp 获取水网中所有节点、节点海拔、坐标、候选管道（初始状态为开）、管道起始和结束节点、长度和直径等信息 all_node, node_elevation, node_coordinates, candidate_pipe_init, pipe_start_node, pipe_end_node, pipe_length, pipe_diameter = read_inf_inp( wn_origin) candidate_pipe_input, min_diameter = cal_possible_pipe(burst_leakage, candidate_pipe_init, pipe_diameter) # 获取可能管段和最小爆管直径 node_x, node_y = cal_node_coordinate(all_node, node_coordinates) all_link, pipe_start_node_all, pipe_end_node_all = read_inf_inp_other(wn_origin) # 节点索引与节点-管道字典 # 首先取出所有节点名称，再构造一个 pandas Series，将每个节点名称映射到一个索引（0, 1, 2, …） all_node_series = wn_origin.node_name_list all_node_series = pd.Series(range(len(all_node_series)), index=all_node_series) node_pipe_dic = {node: wn_origin.get_links_for_node(node) for node in wn_origin.node_name_list} couple_node_length = dict() for each_link in all_link: start_node = pipe_start_node_all[each_link] end_node = pipe_end_node_all[each_link] name1 = start_node + ',' + end_node name2 = end_node + ',' + start_node if each_link in pipe_length.index: couple_node_length[name1] = math.ceil(pipe_length[each_link] * 10) couple_node_length[name2] = math.ceil(pipe_length[each_link] * 10) else: couple_node_length[name1] = 1 couple_node_length[name2] = 1 # 首先排除无关节点，直接对all_node操作 n_node = [] all_node = list(set(all_node) - set(n_node)) # 计算需要排除的节点 except_node_boundary = [] tank_names = wn_origin.tank_name_list reservoir_names = wn_origin.reservoir_name_list except_node_construction = list(tank_names + reservoir_names) except_node_list = except_node_boundary + except_node_construction all_node_temp = list(set(all_node) - set(except_node_boundary)) all_node_temp = list(set(all_node_temp) - set(except_node_construction)) all_node_new = all_node_temp all_node_pcv = [] ## 模拟漏损管道 candidate_pipe_input = list(set(candidate_pipe_input)) candidate_pipe_input_initial = list(set(candidate_pipe_input)) ## 随机选择一定数量的管段 num_to_select = max(2, int(len(candidate_pipe_input_initial) * 0.001)) leakage_position_list = random.sample(candidate_pipe_input_initial, num_to_select) # leakage_position_list = ['ZBBGXSZK001865','ZBBGXSZK002094','ZBBGXSZK002075'] ## 获取水塔和水库的进出水管段及水泵 # reservoir_links = {} # tank_links = {} # for res in reservoir_names: # reservoir_links[res] = {'pipes': {'pos': [], 'neg': []}, 'pumps': {'pos': [], 'neg': []}} # for tank in tank_names: # tank_links[tank] = {'pipes': {'pos': [], 'neg': []}, 'pumps': {'pos': [], 'neg': []}} # for pipe_name in wn_origin.pipe_name_list: # pipe = wn_origin.get_link(pipe_name) # start_node = pipe.start_node_name # end_node = pipe.end_node_name # # 水库相关的管道 # if start_node in reservoir_names: # reservoir_links[start_node]['pipes']['pos'].append(pipe_name) # if end_node in reservoir_names: # reservoir_links[end_node]['pipes']['neg'].append(pipe_name) # # 水塔相关的管道 # if start_node in tank_names: # tank_links[start_node]['pipes']['pos'].append(pipe_name) # if end_node in tank_names: # tank_links[end_node]['pipes']['neg'].append(pipe_name) # for pump_name in wn_origin.pump_name_list: # pump = wn_origin.get_link(pump_name) # start_node = pump.start_node_name # end_node = pump.end_node_name # # 水库相关水泵 # if start_node in reservoir_names: # reservoir_links[start_node]['pumps']['pos'].append(pump_name) # if end_node in reservoir_names: # reservoir_links[end_node]['pumps']['neg'].append(pump_name) # # 水塔相关水泵 # if start_node in tank_names: # tank_links[start_node]['pumps']['pos'].append(pump_name) # if end_node in tank_names: # tank_links[end_node]['pumps']['neg'].append(pump_name) # all_reservoir_pos_links = [ # link # for res_data in reservoir_links.values() # for link_type in ['pipes', 'pumps'] # for link in res_data[link_type]['pos'] # ] # all_reservoir_neg_links = [ # link # for res_data in reservoir_links.values() # for link_type in ['pipes', 'pumps'] # for link in res_data[link_type]['neg'] # ] # all_tank_pos_links = [ # link # for tan_data in tank_links.values() # for link_type in ['pipes', 'pumps'] # for link in tan_data[link_type]['pos'] # ] # all_tank_neg_links = [ # link # for tan_data in tank_links.values() # for link_type in ['pipes', 'pumps'] # for link in tan_data[link_type]['neg'] # ] # all_tank_pipe_links = [ # link # for tan_data in tank_links.values() # for link_type in ['pos', 'neg'] # for link in tan_data['pipes'][link_type] # ] # f1 = [] # f_corr2_f = all_tank_pipe_links # _pos = all_reservoir_pos_links + all_tank_pos_links # 出水 # _neg = all_reservoir_neg_links + all_tank_neg_links # 进水 # f0 = _pos + _neg # 需测试的监测点布局 ## sensor analyse S5_40 ---------------------------------------------- sensor_name_list_str = ['test'] # 每个监测布局的名称 sensor_name_list = pressure_SCADA_ID_list # 不同的监测点对应的定位方法，可设置全为'CAD_new_gy' similarity_mode_list = ['COS'] * len(sensor_name_list_str) sensor_f_name_list = [[] for _ in range(len(sensor_name_list_str))] # 流量监测点 # sensor_f_name_list = flow_SCADA_ID_list sensor_level_list = list(np.arange(len(sensor_name_list_str))) sensor_name = itertools.chain.from_iterable(sensor_name_list) sensor_name = list(set(sensor_name)) sensor_f_name = itertools.chain.from_iterable(sensor_f_name_list) sensor_f_name = list(set(sensor_f_name)) # sensor_f_name = sensor_f_name + f0 + f1 + f_corr2_f # sensor_f_name = list(set(sensor_f_name)) sensor_name_all = copy.deepcopy(sensor_name) sensor_f_name_all = copy.deepcopy(sensor_f_name) r2 = pd.DataFrame( index=pd.MultiIndex.from_product([sensor_name_list_str, leakage_position_list]), columns=['TD']) r3 = pd.DataFrame( index=pd.MultiIndex.from_product([sensor_name_list_str, leakage_position_list]), columns=['SD']) r4 = pd.DataFrame( index=pd.MultiIndex.from_product([sensor_name_list_str, leakage_position_list]), columns=['PD']) r5 = pd.DataFrame( index=pd.MultiIndex.from_product([sensor_name_list_str, leakage_position_list]), columns=['lpID']) r6 = pd.DataFrame( index=pd.MultiIndex.from_product([sensor_name_list_str, leakage_position_list]), columns=['Times']) r7 = pd.DataFrame( index=pd.MultiIndex.from_product([sensor_name_list_str, leakage_position_list]), columns=['Cover']) recorded_position = [] r2 = r2.sort_index() r3 = r3.sort_index() r4 = r4.sort_index() r5 = r5.sort_index() r6 = r6.sort_index() r7 = r7.sort_index() # 定位 basic_group_num = 10 # 无需修改部分 # load network G0 = construct_graph(wn_origin) # ==================================================================================================================== pressure_basic, flow_basic, basic_p, top_sensor, base_demand = normal_simulation_pf(wn_origin, sensor_name_all, sensor_f_name_all) timestep_list = [0] pipe_x, pipe_y = cal_pipe_coordinate(candidate_pipe_input, pipe_start_node, pipe_end_node, node_coordinates) ## ------------------------------------------------------------------------------------------------------------ ## ---------------------------------------------------------------------------- # get pipe coefficient pipe_coefficient = wn_origin.query_link_attribute('roughness', link_type=wntr.network.model.Pipe) basic_demand_pd = produce_pattern_value(wn_origin, all_node_new) ## ---------------------------------------------------------------------------- # 改_wz_________________________________________ # # noise ======================================================================= # sum_flow = 0 # for p in _pos: # sum_flow += flow_basic[p] # for p in _neg: # sum_flow -= flow_basic[p] # sum_flow = sum_flow.mean() # # noise # node_d_noise = node_d_noise_list[noise_level] # /3.27 # pipe_c_noise = pipe_c_noise_list[noise_level] # /3.27 # # leak_flow_para = 1 * sum_flow.values[0] * 0.017 /3600 # leak_flow_para_mean = 1 * sum_flow * leak_flow_para_mean_list[noise_level] # leak_flow_para_std1 = 1 * sum_flow * leak_flow_para_std1_list[noise_level] # leak_flow_para_std2 = 1 * sum_flow * leak_flow_para_std2_list[noise_level] # noise_para_monitor = noise_para_monitor_list[noise_level] # noise_f_para_monitor = noise_f_para_monitor_list[noise_level] # % velocity = 1 noise_f_max = pipe_diameter ** 2 * math.pi * velocity * noise_f_para_monitor / 400 max_flow = pipe_diameter ** 2 * math.pi * velocity / 4 # noise ======================================================================= # basic_leak_similation ======================================================================= # 进行管段模拟漏损（而非节点模拟漏损），获得每根管道的漏损流量和压力 pressure_leak_all_pre_new_all = pd.DataFrame( index=pd.MultiIndex.from_product([candidate_leak_ratio, candidate_pipe_input_initial, timestep_list]), columns=sensor_name_all) pressure_leak_all_pre_new_all = pressure_leak_all_pre_new_all.sort_index() flow_leak_all_pre_new_all = pd.DataFrame( index=pd.MultiIndex.from_product([candidate_leak_ratio, candidate_pipe_input_initial, timestep_list]), columns=sensor_f_name_all) flow_leak_all_pre_new_all = flow_leak_all_pre_new_all.sort_index() pressure_leak_basic_all = pd.DataFrame( index=pd.MultiIndex.from_product([candidate_leak_ratio, candidate_pipe_input_initial]), columns=sensor_name_all) for pick_leak_ratio in candidate_leak_ratio: # leak_flow_simu = sum_flow * pick_leak_ratio leak_flow_simu = burst_leakage wn = copy.deepcopy(wn_origin) pressure_leak_all_pre, flow_leak_all_pre, leak_candidate_center = cal_signature_pipe_multi_pf(wn, leak_flow_simu, candidate_pipe_input_initial, timestep_list, sensor_name_all, sensor_f_name_all) for each in candidate_pipe_input_initial: pressure_leak_all_pre_new_all.loc[pick_leak_ratio].loc[each].loc[:, :] = pressure_leak_all_pre.loc[ each].loc[:, sensor_name_all] for each in candidate_pipe_input_initial: flow_leak_all_pre_new_all.loc[pick_leak_ratio].loc[each].loc[:, :] = flow_leak_all_pre.loc[each].loc[:, sensor_f_name_all] for candidate_pipe in candidate_pipe_input_initial: pressure_leak_basic_all.loc[pick_leak_ratio].loc[candidate_pipe, :] = pressure_leak_all_pre.loc[ candidate_pipe].loc[:, :].mean() # sensor information ======================================================================= ## ---------------------------------------------------------------------------- DEMAND_COUNT = 0 wn_change = copy.deepcopy(wn_origin) wn = copy.deepcopy(wn_origin) # ========================================================================================================== pressure_basic_basic, flow_basic_basic, basic_p, top_sensor, base_demand = normal_simulation_multi_pf(wn, sensor_name_all, sensor_f_name_all) # for each_candidate in leakage_position_list: # each_candidate='111' # wn = copy.deepcopy(wn_origin) # r1 = pd.DataFrame( # index=sensor_name_list_str, # columns=['TD', 'SD', 'PD', 'lpID', 'Times', 'Cover', 'Simu Count']) # r1 = r1.sort_index() # # recorded_position.append(each_candidate) # leak_index = int(np.round(random.random() * (len(candidate_leak_ratio) - 1))) # leak_flow_simu =candidate_leak_ratio[leak_index] * sum_flow # leak_mag = add_noise_number(leak_flow_simu, 'uni', leak_flow_para) # wn_change = copy.deepcopy(wn_origin) # 获得对应模拟时刻下，正常噪声和添加漏损后的监测点数据 # wn_change, pressure_predict_basic, flow_predict_basic, pressure_output, flow_output = add_noise_in_wn_pf( # wn_change, pipe_c_noise, timestep_list, # pipe_coefficient, sensor_name_all, sensor_f_name_all, all_node_new, # basic_demand_pd, # 'uni', node_d_noise, # each_candidate, leak_mag) # # pressure_monitor_basic = add_noise_pd(pressure_output, 'uni', noise_para_monitor) # flow_monitor_basic = add_noise_percentage_pd(flow_output, 'uni', noise_f_para_monitor) leak_index = int(np.round(random.random() * (len(candidate_leak_ratio) - 1))) leak_mag = leak_flow_simu print('leak_mag' + str(leak_mag * 3600) + '.........') pressure_monitor = pd.DataFrame(index=timestep_list, columns=sensor_name) pressure_predict = pd.DataFrame(index=timestep_list, columns=sensor_name) pressure_basic = pd.DataFrame(index=timestep_list, columns=sensor_name) flow_monitor = pd.DataFrame(index=timestep_list, columns=sensor_f_name) flow_predict = pd.DataFrame(index=timestep_list, columns=sensor_f_name) flow_basic = pd.DataFrame(index=timestep_list, columns=sensor_f_name) for i in range(len(timestep_list)): for sensor_level in sensor_level_list: sensor_name = sensor_name_list[sensor_level] pressure_monitor.iloc[i, :] = burst_SCADA_pressure.loc[sensor_name] pressure_predict.iloc[i, :] = normal_SCADA_pressure.loc[sensor_name] pressure_basic.iloc[i, :] = pressure_basic_basic.loc[:, sensor_name] sensor_f_name = sensor_f_name_list[sensor_level] pressure_leak_all_pre_new = pd.DataFrame( index=pd.MultiIndex.from_product([candidate_pipe_input_initial, timestep_list]), # 笛卡尔积，生成多级索引 columns=sensor_name) pressure_leak_all_pre_new = pressure_leak_all_pre_new.sort_index() # 排序 flow_leak_all_pre_new = pd.DataFrame( index=pd.MultiIndex.from_product([candidate_pipe_input_initial, timestep_list]), columns=sensor_f_name) flow_leak_all_pre_new = flow_leak_all_pre_new.sort_index() for each in candidate_pipe_input_initial: pressure_leak_all_pre_new.loc[each].loc[:, :] = pressure_leak_all_pre_new_all.loc[candidate_leak_ratio[leak_index]].loc[each].loc[:, sensor_name] flow_leak_all_pre_new.loc[each].loc[:, :] = flow_leak_all_pre_new_all.loc[candidate_leak_ratio[leak_index]].loc[each].loc[:, sensor_f_name] wn = copy.deepcopy(wn_origin) # start DN search # ================================================================= use_similarity_mode = similarity_mode_list[sensor_level] flow_monitor.iloc[i, :] = burst_SCADA_flow.loc[sensor_f_name] flow_predict.iloc[i, :] = normal_SCADA_flow.loc[sensor_f_name] flow_basic.iloc[i, :] = flow_basic_basic.loc[:, sensor_f_name] # ================================================================= located_pipe, dt, simu_count, wn, similarity_sp = DN_search_multi_simple_add_flow_count_new(wn, G0, all_node, node_x, node_y, pipe_start_node_all, pipe_end_node_all, couple_node_length, node_pipe_dic, all_node_series, top_group_ratio, top_pipe_num_max, top_pipe_num_min, candidate_pipe_input_initial, use_similarity_mode, pressure_monitor, pressure_predict, pressure_basic, pressure_leak_all_pre_new, flow_monitor, flow_predict, flow_basic, flow_leak_all_pre_new, timestep_list, max_flow, basic_group_num, Top_sensor_num=len( sensor_name), if_gy=0, pressure_threshold=0.05) print(located_pipe, dt, simu_count, similarity_sp) # if len(list(similarity_sp.index)) == 0: # SD = 9999 # TD = 9999 # PD = 90 # lpID = '' # cover = 0 # else: # SD = cal_SD(located_pipe, each_candidate, pipe_x, pipe_y) # TD, PD = cal_DtoTop1(G0, each_candidate, located_pipe, pipe_start_node_all, pipe_end_node_all, # pipe_length) # lpID = located_pipe # cover = cal_cover(similarity_sp, each_candidate) # r1.loc[sensor_name_list_str[sensor_level]].loc['TD'] = TD # 定位拓扑距离 # r1.loc[sensor_name_list_str[sensor_level]].loc['SD'] = SD # 定位空间距离 # r1.loc[sensor_name_list_str[sensor_level]].loc['lpID'] = lpID # 不重要的参数，可删去 # r1.loc[sensor_name_list_str[sensor_level]].loc['Times'] = dt # 定位时间 # r1.loc[sensor_name_list_str[sensor_level]].loc['Cover'] = cover # 覆盖率 # r1.loc[sensor_name_list_str[sensor_level]].loc['PD'] = PD # 定位拓扑连接数 # r1.loc[sensor_name_list_str[sensor_level]].loc['Simu Count'] = simu_count # 模拟次数 # # # --- 获取当前候选点的前10管道 --- # top_10_pipes = similarity_sp.head(10) # df_to_export = pd.DataFrame({ # "管道ID": top_10_pipes.index, # "特征相似值": top_10_pipes.values # }) # sheet_name = str(each_candidate) # # --- 写入当前候选点的子表 --- # df_to_export.to_excel( # writer, # sheet_name=sheet_name, # index=False, # header=True # ) # print(f"所有候选点的相似度排名已保存") # # print( # 'finish candidate:' + each_candidate + ' and total calculation times:' + str( # DEMAND_COUNT) + '..') # # # r1.to_excel(writer, sheet_name=each_candidate) # # for sensor_level in sensor_level_list: # sensor_name = sensor_name_list_str[sensor_level] # # 获取该传感器在r1中的所有相关数据 # sensor_data = r1.loc[sensor_name] # r2.loc[(sensor_name, each_candidate)] = sensor_data['TD'] # r3.loc[(sensor_name, each_candidate)] = sensor_data['SD'] # r4.loc[(sensor_name, each_candidate)] = sensor_data['PD'] # r5.loc[(sensor_name, each_candidate)] = sensor_data['lpID'] # r6.loc[(sensor_name, each_candidate)] = sensor_data['Times'] # r7.loc[(sensor_name, each_candidate)] = sensor_data['Cover'] # # DEMAND_COUNT += 1 # print('finish' + str(DEMAND_COUNT) + 'candidates.........') # if DEMAND_COUNT > 1: # # for sensor_level in sensor_level_list: # print('sensor_level_' + str(sensor_level)) # print('--SD: ' + # str(r3.loc[sensor_name_list_str[sensor_level]].loc[recorded_position].mean()) + # ', nowTD:' + str(r2.loc[sensor_name_list_str[sensor_level]].loc[each_candidate].mean()) + # ', PD:' + str(r3.loc[sensor_name_list_str[sensor_level]].loc[recorded_position].mean()) + # ', Cover:' + str(r7.loc[sensor_name_list_str[sensor_level]].loc[recorded_position].mean()) ) # # print('====================================================') # # # # 保存的文件 里面包含的评估参数 主要的就是TD Cover TD # r2.to_excel(writer, sheet_name='TD') # r3.to_excel(writer, sheet_name='SD') # r4.to_excel(writer, sheet_name='PD') # r5.to_excel(writer, sheet_name='lpID') # r6.to_excel(writer, sheet_name='Times') # r7.to_excel(writer, sheet_name='Cover') # writer._save() if __name__ == '__main__': # influxdb_api.query_corresponding_query_id_and_element_id('bb') # pressure_SCADA_ID_list = [list(globals.scheme_pressure_ids.values())] # # print(pressure_SCADA_ID_list) # flow_SCADA_ID_list = [list(globals.scheme_pipe_flow_ids.values())] # burst_leakage = influxdb_api.manually_get_burst_flow(scheme_Type='burst_Analysis', scheme_Name='burst_scheme', scheme_start_time='2025-03-10T12:00:00+08:00') # # print(burst_leakage) burst_SCADA_pressure, pressure_SCADA_IDs_list, normal_SCADA_pressure = manually_get_burst_time_SCADA_pressure(name='bb', manually_burst_time='2025-03-30T12:00:00+08:00', scheme_Type='burst_Analysis', scheme_Name='test0618') print(type(pressure_SCADA_IDs_list), pressure_SCADA_IDs_list) ## 平铺 pressure_SCADA_IDs_list # SCADA数据有问题，使用模拟数据代替SCADA真实数据 flat_ids = [item for sublist in pressure_SCADA_IDs_list for item in sublist] result_records = influxdb_api.query_all_record_by_time_property(query_time='2025-03-30T12:00:00+08:00', type='node', property='pressure') simulation_normal_SCADA_presssure = [record for record in result_records if record['ID'] in flat_ids] normal_SCADA_pressure = {record['ID']: record['value'] for record in simulation_normal_SCADA_presssure} print(normal_SCADA_pressure) normal_SCADA_pressure = pd.Series(normal_SCADA_pressure) normal_SCADA_pressure = normal_SCADA_pressure.reindex(burst_SCADA_pressure.index) # burst_flow = manually_get_burst_flow(scheme_Type='burst_Analysis', scheme_Name='test0618', # burst_start_time='2025-03-30T12:00:00+08:00') flow_SCADA_ID_list = [[]] burst_SCADA_flow = pd.Series(index=[], dtype=float) normal_SCADA_flow = pd.Series(index=[], dtype=float) if_detect, tag = cal_if_detect(burst_SCADA_pressure=burst_SCADA_pressure, normal_SCADA_pressure=normal_SCADA_pressure, min_dpressure=2.0) locate_burst(name='bb', pressure_SCADA_ID_list=pressure_SCADA_IDs_list, burst_SCADA_pressure=burst_SCADA_pressure, normal_SCADA_pressure=normal_SCADA_pressure, flow_SCADA_ID_list=flow_SCADA_ID_list, burst_SCADA_flow=burst_SCADA_flow, normal_SCADA_flow=normal_SCADA_flow, burst_leakage=0.057, burst_happen_time='2025-03-30T12:00:00+08:00')