From a462e8d9fff4e2be3052fff6cfc1fa1215dd3c8f Mon Sep 17 00:00:00 2001 From: jenny Date: Thu, 16 May 2024 02:57:37 -0400 Subject: [PATCH] dss_to_nx_fulldata -> all changes in __init__ for outside use. modified hosting capacity.py to reflect the [G, pos] outputs. Fixed edge connections between buses, and between buses and loads. Fixed transformer misinterpretation. --- omf/models/hostingCapacity.py | 3 +- omf/solvers/opendss/__init__.py | 126 ++++++++++++++++++-------------- 2 files changed, 72 insertions(+), 57 deletions(-) diff --git a/omf/models/hostingCapacity.py b/omf/models/hostingCapacity.py index c0e19a4b8..c0a896c11 100644 --- a/omf/models/hostingCapacity.py +++ b/omf/models/hostingCapacity.py @@ -57,7 +57,8 @@ def run_downline_load_algorithm( modelDir, inputDict, outData): tree = opendss.dssConvert.omdToTree(path_to_omd) opendss.dssConvert.treeToDss(tree, Path(modelDir, 'downlineLoad.dss')) downline_start_time = time.time() - graph = opendss.dss_to_nx_fulldata( os.path.join( modelDir, 'downlineLoad.dss') ) + nx_data = opendss.dss_to_nx_fulldata( os.path.join( modelDir, 'downlineLoad.dss') ) + graph = nx_data[0] buses = opendss.get_all_buses( os.path.join( modelDir, 'downlineLoad.dss') ) buses_output = {} kwFromGraph = nx.get_node_attributes(graph, 'kw') diff --git a/omf/solvers/opendss/__init__.py b/omf/solvers/opendss/__init__.py index e174d4bf0..63e5badbb 100644 --- a/omf/solvers/opendss/__init__.py +++ b/omf/solvers/opendss/__init__.py @@ -841,65 +841,86 @@ def dss_to_nx_fulldata( dssFilePath, tree=None, fullData = True ): # new object=line.645646 bus1=645.2 bus2=646.2 phases=1 linecode=mtx603 length=300 units=ft # line.x <- is this the name? lines = [x for x in tree if x.get('object', 'N/A').startswith('line.')] - print( lines[0] ) lines_bus1 = [x.split('.')[0] for x in [x['bus1'] for x in lines if 'bus1' in x]] lines_bus2 = [x.split('.')[0] for x in [x['bus2'] for x in lines if 'bus2' in x]] + lines_name = [x.split('.')[1] for x in [x['object'] for x in lines if 'object' in x]] edges = [] - for bus1, bus2 in zip( lines_bus1, lines_bus2 ): + for bus1, bus2 in zip(lines_bus1, lines_bus2 ): edges.append( (bus1, bus2, {'color': 'blue'}) ) - G.add_edges_from(edges) - - if fullData: - line_phases = [x['phases'] for x in lines if 'phases' in x] - line_linecode = [x['linecode'] for x in lines if 'linecode' in x] - line_length = [x['length'] for x in lines if 'length' in x] - line_units = [x['units'] for x in lines if 'units' in x] - edges_with_attributes = {} - for edge, phase, linecode, length, unit in zip(edges, line_phases, line_linecode, line_length, line_units): - print( "edge: ", edge ) - edge_nodes = (edge[0], edge[1]) - edges_with_attributes[edge_nodes] = {"phases": phase, "linecode": linecode, "length": float(length), "units": unit} - nx.set_edge_attributes( G, edges_with_attributes ) + G.add_edges_from( edges ) - - # Need edges from bus --- trasnformr info ---> load - transformers = [x for x in tree if x.get('object', 'N/A').startswith('transformer.')] - transformer_bus_names = [x['buses'] for x in transformers if 'buses' in x] - bus_to_transformer_pairs = {} - for transformer_bus in transformer_bus_names: - strip_paren = transformer_bus.strip('[]') - split_buses = strip_paren.split(',') - bus = split_buses[0].split('.')[0] - transformer_name = split_buses[1].split('.')[0] - bus_to_transformer_pairs[transformer_name] = bus + # Need to add data for lines + # some lines have "switch" + # How to add data when sometimes there sometimes not # If there is a transformer tied to a load, we get it from here. loads = [x for x in tree if x.get('object', 'N/A').startswith('load.')] # This is an orderedDict load_names = [x['object'].split('.')[1] for x in loads if 'object' in x and x['object'].startswith('load.')] - load_transformer_name = [x.split('.')[0] for x in [x['bus1'] for x in loads if 'bus1' in x]] + load_bus = [x.split('.')[0] for x in [x['bus1'] for x in loads if 'bus1' in x]] + for load, bus in zip(load_names, load_bus): + pos_tuple_of_bus = pos[bus] + G.add_node(load, pos=pos_tuple_of_bus) + G.add_edge( bus, load ) + pos[load] = pos_tuple_of_bus - # Connects loads to buses via transformers - for load_name, load_transformer in zip(load_names, load_transformer_name): - # Add edge from bus to load, with transformer name as an attribute - if load_transformer in bus_to_transformer_pairs: - bus = bus_to_transformer_pairs[load_transformer] - G.add_edge(bus, load_name, transformer=load_transformer) - else: - G.add_edge(load_transformer, load_name ) - pos[load_name] = pos[load_transformer] + if fullData: + # Attributes for all loads + load_phases = [x['phases'] for x in loads if 'phases' in x] + load_conn = [x['conn'] for x in loads if 'conn' in x] + load_kv = [x['kv'] for x in loads if 'kv' in x] + load_kw = [x['kw'] for x in loads if 'kw' in x] + load_kvar = [x['kvar'] for x in loads if 'kvar' in x] + for load, phases, conn, kv, kw, kvar in zip( load_names, load_phases, load_conn, load_kv, load_kw, load_kvar): + G.nodes[load]['phases'] = phases + G.nodes[load]['conn'] = conn + G.nodes[load]['kv'] = kv + G.nodes[load]['kw'] = kw + G.nodes[load]['kvar'] = kvar + + # need lines between buses and loads + # print( G.nodes ) + + # Need edges from bus --- transformer info ---> bus + # How to put transformers in with the same u and v buses + # new object=transformer.reg1 buses=[650.1,rg60.1] phases=1 bank=reg1 xhl=0.01 kvas=[1666,1666] kvs=[2.4,2.4] %loadloss=0.01 + # new object=transformer.reg1 buses=[650.1,rg60.1] phases=1 bank=reg1 xhl=0.01 kvas=[1666,1666] kvs=[2.4,2.4] %loadloss=0.01 + # new object=transformer.reg3 buses=[650.3,rg60.3] phases=1 bank=reg1 xhl=0.01 kvas=[1666,1666] kvs=[2.4,2.4] %loadloss=0.01 + transformers = [x for x in tree if x.get('object', 'N/A').startswith('transformer.')] + transformer_buses = [x['buses'] for x in transformers if 'buses' in x] + transformer_buses_names_split = [[prefix.split('.')[0].strip() for prefix in sublist.strip('[]').split(',')] for sublist in transformer_buses] + transformer_name = [x.split('.')[1] for x in [x['object'] for x in transformers if 'object' in x]] + transformer_edges = [] + for bus_pair, t_name in zip(transformer_buses_names_split, transformer_name): + if bus_pair[0] and bus_pair[1] in G.nodes: + transformer_edges.append ( (bus_pair[0], bus_pair[1], {'key': t_name}) ) + G.add_edges_from(transformer_edges) + + # Need to add data for transformers + # Some have windings. - # Attributes for all loads - load_phases = [x['phases'] for x in loads if 'phases' in x] - load_conn = [x['conn'] for x in loads if 'conn' in x] - load_kv = [x['kv'] for x in loads if 'kv' in x] - load_kw = [x['kw'] for x in loads if 'kw' in x] - load_kvar = [x['kvar'] for x in loads if 'kvar' in x] - for load, phases, conn, kv, kw, kvar in zip( load_names, load_phases, load_conn, load_kv, load_kw, load_kvar): - G.nodes[load]['phases'] = phases - G.nodes[load]['conn'] = conn - G.nodes[load]['kv'] = kv - G.nodes[load]['kw'] = kw - G.nodes[load]['kvar'] = kvar + # if fullData: + # # %loadloss=0.01 + # transformer_edges_with_attributes = {} + # transformer_phases = [x['phases'] for x in lines if 'phases' in x] + # transformer_bank = [x['bank'] for x in lines if 'bank' in x] + # transformer_xhl = [x['xhl'] for x in lines if 'xhl' in x] + # transformer_kvas = [x['kvas'] for x in lines if 'kvas' in x] + # transformer_kvs = [x['kvs'] for x in lines if 'kvs' in x] + # transformer_loadloss = [x['loadloss'] for x in lines if 'loadloss' in x] + # for t_edge, phase, bank, xhl_val, kvas_val, kvs_val, loadloss_val in zip(transformer_edges, transformer_phases, transformer_bank, transformer_xhl, transformer_kvas, transformer_kvs, transformer_loadloss): + # t_edge_nodes = (t_edge[0], t_edge[1]) + # transformer_edges_with_attributes[t_edge_nodes] = { "phases": phase, "bank": bank, "xhl": xhl_val, "kvas": kvas_val, "kvs": kvs_val, "loadloss": loadloss_val } + # print( '{ "phases": phase, "bank": bank, "xhl": xhl_val, "kvas": kvas_val, "kvs": kvs_val, "loadloss": loadloss_val } ') + # print( "t_edge_nodes: ", t_edge_nodes ) + # nx.set_edge_attributes( G, transformer_edges_with_attributes ) + + # # buses=[650.2,rg60.2] phases=1 bank=reg1 xhl=0.01 kvas=[1666,1666] kvs=[2.4,2.4] %loadloss=0.01 + # print( G[ "633"]["634"]["phases"] ) + # print( G[ "633"]["634"]["bank"] ) + # print( G[ "633"]["634"]["xhl"] ) + # print( G[ "633"]["634"]["kvas"] ) + # print( G[ "633"]["634"]["kvs"] ) + # print( G[ "633"]["634"]["loadloss"] ) # Are there generators? If so, find them and add them as nodes. Their location is the same as buses. # Generators have generator. like solar_634 <- should i save this? @@ -922,14 +943,7 @@ def dss_to_nx_fulldata( dssFilePath, tree=None, fullData = True ): G.nodes[gen]['kw'] = kw G.nodes[gen]['pf'] = pf G.nodes[gen]['yearly'] = yearly - - # TEMP: Remove transformer nodes added from coordinates. Transformer data is edges, not nodes. - for transformer_name in load_transformer_name: - if transformer_name in G.nodes: - G.remove_node( transformer_name ) - pos.pop( transformer_name ) - - return G + return G, pos def THD(filePath): ''' Calculate and plot total harmonic distortion. '''