From 760309c5a1024d16eaa8c8c3d60f929ad8ec13c9 Mon Sep 17 00:00:00 2001 From: Sina Naeimi Date: Mon, 15 Jul 2024 19:10:33 -0700 Subject: [PATCH] changed the project_resulto result not only chanegd teh anmes but also added class method to teh project file to create the project fiel and saved it. In fact the function has been moved from initial to the project. In this way intiial will be smaler and the function will be in its pertinent porsition. --- rewet/{Result_Project.py => result.py} | 201 ++++++++++++------------- 1 file changed, 100 insertions(+), 101 deletions(-) rename rewet/{Result_Project.py => result.py} (94%) diff --git a/rewet/Result_Project.py b/rewet/result.py similarity index 94% rename from rewet/Result_Project.py rename to rewet/result.py index b572968..5c831bb 100644 --- a/rewet/Result_Project.py +++ b/rewet/result.py @@ -19,24 +19,24 @@ from rewet.Output.Curve import Curve from rewet.Output.Crew_Report import Crew_Report from rewet.Output.Result_Time import Result_Time -import rewet.Input.Input_IO as io +#import rewet.Input.Input_IO as io from rewet.Project import Project as MainProject -class Project_Result(Map, Raw_Data, Curve, Crew_Report, Result_Time): - def __init__(self, project_file_addr, result_directory=None, ignore_not_found=False, to_neglect_file=None, node_col='', result_file_dir = None, iObject=False): - +class Result(Map, Raw_Data, Curve, Crew_Report, Result_Time): + def __init__(self, in_project, result_directory=None, ignore_not_found=False, to_neglect_file=None, node_col='', result_file_dir = None, iObject=False): + if iObject==False: - self.readPorjectFile(project_file_addr) + self.readPorjectFile(in_project) else: - self.project = copy.deepcopy(project_file_addr) - - + self.project = copy.deepcopy(in_project) + + if result_file_dir != None: self.project.project_settings.process.settings['result_directory'] = result_file_dir #self.project.scenario_list = io.read_damage_list(self.project.project_settings.process['pipe_damage_file_list' ], self.project.project_settings.process['pipe_damage_file_directory']) #print(self.project.scenario_list) self.project.scenario_list = self.project.scenario_list.set_index('Scenario Name') - + self.demand_node_name_list = [] self._list = [] self.pipe_damages = {} @@ -60,43 +60,43 @@ def __init__(self, project_file_addr, result_directory=None, ignore_not_found=Fa self._RequiredDemandForAllNodesandtime = {} self.demand_ratio = self.project.project_settings.process['demand_ratio'] self.scn_name_list_that_result_file_not_found = [] - self.wn = wntrfr.network.WaterNetworkModel(self.project.project_settings.process['WN_INP'] ) - + self.wn = wntrfr.network.WaterNetworkModel(self.project.project_settings.process['WN_INP'] ) + self.result_directory = self.project.project_settings.process['result_directory'] - + if not isinstance(result_directory, type(None) ): self.result_directory = result_directory - + to_neglect=[]; if to_neglect_file != None and False: #sina hereeeee bug dadi amedane raise file_data = pd.read_excel(to_neglect_file) to_neglect = file_data[node_col].to_list() - + for node_name in self.wn.junction_name_list: node = self.wn.get_node(node_name) if node.demand_timeseries_list[0].base_value > 0 and node_name not in to_neglect: self.demand_node_name_list.append(node_name) - + self.node_name_list = self.wn.node_name_list.copy() ret_val = self.checkForNotExistingFile(ignore_not_found) self.prepareData() return ret_val - + def readPorjectFile(self, project_file_addr): print(project_file_addr) with open(project_file_addr, 'rb') as f: self.project = pickle.load(f) - + def loadPopulation(self, popuation_data, node_id_header, population_header): pop = popuation_data.copy() pop = pop.set_index(node_id_header) pop = pop[population_header] self._population_data = pop - + def checkForNotExistingFile(self, ignore_not_found): self.scn_name_list_that_result_file_not_found = [] - + result_directory = self.result_directory #print(self.project.scenario_list) for scn_name, row in self.project.scenario_list.iterrows(): @@ -106,7 +106,7 @@ def checkForNotExistingFile(self, ignore_not_found): registry_file_data_addr = os.path.join(result_directory, scenario_registry_file_name) if not os.path.exists(registry_file_data_addr): self.scn_name_list_that_result_file_not_found.append(scn_name) - + if len( self.scn_name_list_that_result_file_not_found)> 0: if ignore_not_found: #print(str(len(self.scn_name_list_that_result_file_not_found)) +" out of "+ repr(len(self.project.scenario_list)) +" Result Files are not found and ignored" ) @@ -115,33 +115,33 @@ def checkForNotExistingFile(self, ignore_not_found): #self.project.scenario_list.drop(self.scn_name_list_that_result_file_not_found, inplace=True) else: raise ValueError("Res File Not Found: "+ repr(self.scn_name_list_that_result_file_not_found) +" in "+repr(result_directory)) - - + + def prepareData(self): i=0 #result_directory = self.project.project_settings.process['result_directory'] #self.project.scenario_list = self.project.scenario_list.iloc[0:20] for scn_name, row in self.project.scenario_list.iterrows(): self._RequiredDemandForAllNodesandtime[scn_name] = None - #settings_file_name = scn_name+'.xlsx' - #settings_file_addr = os.path.join(result_directory, settings_file_name) + #settings_file_name = scn_name+'.xlsx' + #settings_file_addr = os.path.join(result_directory, settings_file_name) #scenario_set = pd.read_excel(settings_file_addr) #self.scenario_set[scn_name] = scenario_set self.data[scn_name] = None self.registry[scn_name] = None - + #self.time_size[scn_name] = len(self.data[scn_name].node['demand'].index) self.index_to_scen_name[i] = scn_name i+=1 - + self.scenario_prob[scn_name] = self.project.scenario_list.loc[scn_name, 'Probability'] - - + + ''' ATTENTION: We need probability for any prbablistic result ''' - + def loadScneariodata(self, scn_name): if self.data[scn_name] != None: return @@ -163,7 +163,7 @@ def loadScneariodata(self, scn_name): with open(res_addr, 'rb') as f: res_file_data = pickle.load(f) #scenario_registry_file_name = scn_name+".res" - #res_addr = os.path.join(result_directory, scenario_registry_file_name) + #res_addr = os.path.join(result_directory, scenario_registry_file_name) #with open(res_addr, 'rb') as f: #print(output_addr) #res_file_data = pickle.load(f) @@ -172,38 +172,38 @@ def loadScneariodata(self, scn_name): #res_file_data = self.registry[scn_name].result self.remove_maximum_trials(res_file_data) self.data[scn_name] = res_file_data - + def readData(self): #i=0 self.project.scenario_list = self.project.scenario_list.iloc[0:2] result_directory = self.result_directory - + for scn_name, row in self.project.scenario_list.iterrows(): self._RequiredDemandForAllNodesandtime[scn_name] = None scenario_registry_file_name = scn_name+"_registry.pkl" registry_file_data_addr = os.path.join(result_directory, scenario_registry_file_name) - + with open(registry_file_data_addr, 'rb') as f: if not os.path.exists(registry_file_data_addr): raise ValueError("Registry File Not Found: "+ str(registry_file_data_addr)) self.registry[scn_name] = pickle.load(f) - + #self.pipe_damages[scn_name] = current_scenario_registry.damage.pipe_all_damages #self.node_damages[scn_name] = current_scenario_registry.node_damage #self.pump_damages[scn_name] = current_scenario_registry.damaged_pumps - #self.tank_damages[scn_name] = current_scenario_registry.tank_damage - + #self.tank_damages[scn_name] = current_scenario_registry.tank_damage + #res_addr = os.path.join(result_directory, scn_name+'.res') - + #with open(res_addr, 'rb') as f: #print(output_addr) #res_file_data = pickle.load(f) - - #settings_file_name = scn_name+'.xlsx' - #settings_file_addr = os.path.join(result_directory, settings_file_name) + + #settings_file_name = scn_name+'.xlsx' + #settings_file_addr = os.path.join(result_directory, settings_file_name) #scenario_set = pd.read_excel(settings_file_addr) #self.scenario_set[scn_name] = scenario_set - + #res_file_data.node['head'] = None #res_file_data.node['quality'] = None res_file_data = self.registry[scn_name] @@ -212,21 +212,21 @@ def readData(self): #self.time_size[scn_name] = len(self.data[scn_name].node['demand'].index) #self.index_to_scen_name[i] = scn_name #i+=1 - + self.scenario_prob[scn_name] = self.project.scenario_list.loc[scn_name, 'Probability'] - - + + ''' ATTENTION: We need probability for any prbablistic result ''' print(str(scn_name) +" loaded") - + def remove_maximum_trials(self, data): all_time_list = data.maximum_trial_time result_time_list = data.node['demand'].index.to_list() result_time_max_trailed_list = [ time for time in result_time_list if time in all_time_list] - + for att in data.node: all_time_list = data.maximum_trial_time result_time_list = data.node[att].index.to_list() @@ -237,7 +237,7 @@ def remove_maximum_trials(self, data): att_data = data.node[att] att_data.drop(result_time_max_trailed_list, inplace=True) data.node[att] = att_data - + for att in data.link: all_time_list = data.maximum_trial_time result_time_list = data.link[att].index.to_list() @@ -245,14 +245,14 @@ def remove_maximum_trials(self, data): att_data = data.link[att] att_data.drop(result_time_max_trailed_list, inplace=True) data.link[att] = att_data - + flow_balance = data.node['demand'].sum(axis=1) - + time_to_drop = flow_balance[abs(flow_balance) >= 0.01 ].index - + #result_time_list = data.node['demand'].index.to_list() # = [ time for time in result_time_list if time in all_time_list] - + for att in data.node: #all_time_list = data.maximum_trial_time result_time_list = data.node[att].index.to_list() @@ -263,7 +263,7 @@ def remove_maximum_trials(self, data): att_data = data.node[att] att_data.drop(result_time_max_trailed_list, inplace=True) data.node[att] = att_data - + for att in data.link: #all_time_list = data.maximum_trial_time result_time_list = data.link[att].index.to_list() @@ -273,15 +273,15 @@ def remove_maximum_trials(self, data): att_data = data.link[att] att_data.drop(result_time_max_trailed_list, inplace=True) data.link[att] = att_data - + def remove_maximum_trials_demand_flow(self, data): flow_balance = data.node['demand'].sum(axis=1) - + time_to_drop = flow_balance[abs(flow_balance) >= 0.01 ].index - + #result_time_list = data.node['demand'].index.to_list() # = [ time for time in result_time_list if time in all_time_list] - + for att in data.node: #all_time_list = data.maximum_trial_time result_time_list = data.node[att].index.to_list() @@ -290,7 +290,7 @@ def remove_maximum_trials_demand_flow(self, data): att_data = data.node[att] att_data.drop(result_time_max_trailed_list, inplace=True) data.node[att] = att_data - + for att in data.link: #all_time_list = data.maximum_trial_time result_time_list = data.link[att].index.to_list() @@ -298,7 +298,7 @@ def remove_maximum_trials_demand_flow(self, data): att_data = data.link[att] att_data.drop(result_time_max_trailed_list, inplace=True) data.link[att] = att_data - + def readPopulation(self, population_xlsx_addr = 'demandNode-Northridge.xlsx', demand_node_header='NodeID', population_header='#Customer'): pop = pd.read_excel(population_xlsx_addr) pop = pop.set_index(demand_node_header) @@ -308,14 +308,14 @@ def readPopulation(self, population_xlsx_addr = 'demandNode-Northridge.xlsx', de if len(demand_node_without_population) > 0: raise ValueError("The following demand nodes are not population data: " + repr(demand_node_without_population)) - + def getRequiredDemandForAllNodesandtime(self, scn_name): """ ********** - ATTENTION: We Assume that all scnearios have teh same time indexing + ATTENTION: We Assume that all scnearios have teh same time indexing ********** - - Calculates and return required demands for all nodes in all the times steps + + Calculates and return required demands for all nodes in all the times steps Returns ------- @@ -335,10 +335,10 @@ def getRequiredDemandForAllNodesandtime(self, scn_name): _size=len(self.demand_node_name_list) i=0 #req_node_demand = req_node_demand.transpose() - + all_base_demand = [] all_node_name_list = [] - + while i < _size: node_name = self.demand_node_name_list[i] #print(i) @@ -361,18 +361,18 @@ def getRequiredDemandForAllNodesandtime(self, scn_name): patterns_list = node_pattern_list.unique() multiplier = pd.DataFrame(index=time_index, columns = patterns_list) - + for pattern_name in iter(patterns_list): cur_pattern = undamaged_wn.get_pattern(pattern_name) time_index = time_index.unique() for time in iter(time_index): multiplier[pattern_name].loc[time] = cur_pattern.at(time) - + variable_base_demand = [] variable_node_name_list = [] for node_name, pattern_name in node_pattern_list.items(): cur_node_req_demand = multiplier[pattern_name] * undamaged_wn.get_node(node_name).demand_timeseries_list[0].base_value * demand_ratio - + all_node_name_list.append(node_name) all_base_demand.append(cur_node_req_demand.to_list()) #cur_node_req_demand.name = node_name @@ -389,24 +389,24 @@ def getRequiredDemandForAllNodesandtime(self, scn_name): #req_node_demand = variable_base_demand #elif len(variable_base_demand) == 0 and len(variable_base_demand) == 0: #req_node_demand = constant_node_demand_df - #else: + #else: #req_node_demand = pd.concat([constant_node_demand_df.transpose(), variable_node_demand_df.transpose()]).transpose() - + #print(len(all_node_name_list)) #print(len(constant_base_demand)) #print(len(variant_base_demand)) #print("************************") #all_base_demand = constant_base_demand - - + + #req_node_demand = pd.DataFrame(index=time_index, columns=all_node_name_list, data=all_base_demand) #req_node_demand = req_node_demand.transpose() self._RequiredDemandForAllNodesandtime[scn_name] = req_node_demand.filter(self.demand_node_name_list) return self._RequiredDemandForAllNodesandtime[scn_name] self._RequiredDemandForAllNodesandtime[scn_name] = req_node_demand.filter(self.demand_node_name_list) return self._RequiredDemandForAllNodesandtime[scn_name] - - + + def AS_getDLIndexPopulation(self, iPopulation="No", ratio=False, consider_leak=False, leak_ratio=0.75): scenario_list = list(self.data.keys() ) all_scenario_DL_data = {} @@ -414,9 +414,9 @@ def AS_getDLIndexPopulation(self, iPopulation="No", ratio=False, consider_leak=F cur_scn_DL = self.getDLIndexPopulation_4(scn_name, iPopulation=iPopulation, ratio=ratio, consider_leak=consider_leak, leak_ratio=leak_ratio) cur_scn_DL = cur_scn_DL.to_dict() all_scenario_DL_data[scn_name] = cur_scn_DL - + return pd.DataFrame.from_dict(all_scenario_DL_data) - + def AS_getQNIndexPopulation(self, iPopulation="No", ratio=False, consider_leak=False, leak_ratio=0.75): scenario_list = list(self.data.keys() ) all_scenario_QN_data = {} @@ -425,9 +425,9 @@ def AS_getQNIndexPopulation(self, iPopulation="No", ratio=False, consider_leak=F cur_scn_QN = self.getQNIndexPopulation_4(scn_name, iPopulation=iPopulation, ratio=ratio, consider_leak=consider_leak, leak_ratio=leak_ratio) cur_scn_QN = cur_scn_QN.to_dict() all_scenario_QN_data[scn_name] = cur_scn_QN - + return pd.DataFrame.from_dict(all_scenario_QN_data) - + def AS_getOutage_4(self, LOS='DL', iConsider_leak=False, leak_ratio=0, consistency_time_window=7200): scenario_list = list(self.data.keys() ) all_scenario_outage_data = {} @@ -439,12 +439,12 @@ def AS_getOutage_4(self, LOS='DL', iConsider_leak=False, leak_ratio=0, consisten i+=1 return pd.DataFrame.from_dict(all_scenario_outage_data) - + def PR_getBSCPercentageExcedanceCurce(self, data_frame, restoration_percentage): max_time = data_frame.max().max() restore_time = {} - + if type(self._population_data) == type(None): demand_node_name_list = data_frame.index population = pd.Series(index = demand_node_name_list, data=1) @@ -463,15 +463,15 @@ def PR_getBSCPercentageExcedanceCurce(self, data_frame, restoration_percentage): satisfied_scenarios = (scenario_percentages[scenario_percentages >= restoration_percentage]).index already_recorded_scenarios = set(restore_time.keys() ) new_scenarios = set(satisfied_scenarios) - already_recorded_scenarios - + new_record = dict(zip(new_scenarios,[t for k in range(len(new_scenarios) )])) restore_time.update(new_record) - + already_recorded_scenarios = set(restore_time.keys() ) unsatisfied_scenarios = set(self.scenario_prob.keys() ) - already_recorded_scenarios new_record = dict(zip(unsatisfied_scenarios,[t for k in range(len(unsatisfied_scenarios) )])) restore_time.update(new_record) - + restore_data = pd.DataFrame.from_dict({'restore_time': restore_time} ) restore_data['restore_time'] = restore_data.loc[list(self.scenario_prob.keys() ) , 'restore_time'] @@ -479,25 +479,25 @@ def PR_getBSCPercentageExcedanceCurce(self, data_frame, restoration_percentage): restore_data.sort_values('restore_time', ascending = False, inplace = True) ep_mat = Helper.EPHelper(restore_data['prob'].to_numpy() ) restore_data['EP'] = ep_mat - + return restore_data - + def PR_getCurveExcedence(self, data_frame, result_type='mean', daily=False, min_time=0, max_time=24*3600*1000): data_size = len(data_frame.columns) table_temp = [] - + for i in np.arange(data_size): scn_name = data_frame.columns[i] - prob = self.scenario_prob[scn_name] + prob = self.scenario_prob[scn_name] cur_scn_data = data_frame[scn_name] dmg_index_list = [] - + cur_scn_data = cur_scn_data[cur_scn_data.index >= min_time] cur_scn_data = cur_scn_data[cur_scn_data.index <= max_time] - + if daily == True: cur_scn_data = self.getResultSeperatedDaily(cur_scn_data) - + if result_type == 'mean': cur_mean_res = cur_scn_data.mean() if type(cur_mean_res) != pd.core.series.Series: @@ -533,11 +533,11 @@ def PR_getCurveExcedence(self, data_frame, result_type='mean', daily=False, min_ dmg_index_list.append(temp_dmg_index) else: raise ValueError("Unknown group method: "+repr(result_type)) - + loop_res = {'prob':prob, 'index':scn_name} - loop_res.update(temp_res) + loop_res.update(temp_res) table_temp.append(loop_res) - + table = pd.DataFrame.from_dict(table_temp).set_index('index') res = pd.DataFrame(index=[i for i in range(0, len(table.index))], dtype=np.float64) @@ -546,27 +546,26 @@ def PR_getCurveExcedence(self, data_frame, result_type='mean', daily=False, min_ select_columns.extend([dmg_name]) loop_table = table[select_columns] loop_table.sort_values(dmg_name, inplace = True) - + ep_mat = Helper.EPHelper(loop_table['prob'].to_numpy()) res[dmg_name] = loop_table[dmg_name].to_numpy() res[dmg_name+'_EP'] = ep_mat - + return res - + def getResultSeperatedDaily(self, data, begin_time=0): data = data[data.index >= begin_time] data.index = (data.index - begin_time)/(24*3600) - + res_data = [] res_day = [] - + for day_iter in range(0, np.int64(np.ceil(np.max(data.index)))): day_data = data[(data.index >= day_iter) & (data.index <= day_iter+1)] res_data.append(day_data.to_list()) res_day.append(str(day_iter)+'-'+str(day_iter+1)) - + return pd.DataFrame(res_data, index = res_day).transpose() - - - \ No newline at end of file + +