urbanopt-rnm-us 0.3.0 → 0.4.0

data/lib/urbanopt/rnm/api_client.rb

@@ -61,9 +61,9 @@ module URBANopt
 
         @use_localhost = use_localhost
         if @use_localhost
-          @base_api = 'http://0.0.0.0:8080/api/v1/'
+          @base_api = 'http://0.0.0.0:8080/api/v2/'
         else
-          @base_api = 'https://rnm.urbanopt.net/api/v1/'
+          @base_api = 'https://rnm.urbanopt.net/api/v2/'
         end
 
         puts "Running RNM-US at #{@base_api}"

data/lib/urbanopt/rnm/consumers.rb

@@ -144,10 +144,10 @@ module URBANopt
         case peak_apparent_power
           when 0..@lv_limit[:single_phase] # set by the catalog limits
             phases = 1
-            voltage_default = 0.416
+            voltage_default = 0.12
           when @lv_limit[:single_phase]..@lv_limit[:three_phase] # defined from the catalog (from the wires)
             phases = 3
-            voltage_default = 0.416
+            voltage_default = 0.48
             # MV and 3 phases untill 16 MVA, defined by the SMART-DS project
           when @lv_limit[:three_phase]..16000
             phases = 3
@@ -201,6 +201,7 @@ module URBANopt
           average_peak = mixed_use_av_peak # average peak per mixed use considering the building types which are in this building
           area = area_mixed_use
         end
+
         nodes_per_bldg = (average_peak / (@lv_limit[:three_phase] * @power_factor * conservative_factor)).to_f.ceil # computing number of nodes per building
         if nodes_per_bldg > @max_num_lv_nodes # to define this as an input in the geojson file
           nodes_per_bldg = 1

data/lib/urbanopt/rnm/input_files.rb

@@ -87,7 +87,7 @@ module URBANopt
         # lines with the highest capacity
         catalog['LINES'][1].each do |key, v|
           (0..catalog['LINES'][1][key].length - 1).each do |ii|
-            if catalog['LINES'][1][key][ii]['Voltage(kV)'] == '0.416'
+            if Float(catalog['LINES'][1][key][ii]['Voltage(kV)']) < 1
               if catalog['LINES'][1][key][ii]['Line geometry'][0]['phase'] != 'N'
                 wire = catalog['LINES'][1][key][ii]['Line geometry'][0]['wire']
               else

data/lib/urbanopt/rnm/prosumers.rb

@@ -201,10 +201,10 @@ module URBANopt
         case peak_apparent_power
           when -10000..@lv_limit[:single_phase] # set by the catalog limits
             phases = 1
-            voltage_default = 0.416
+            voltage_default = 0.12
           when @lv_limit[:single_phase]..@lv_limit[:three_phase] # defined from the catalog (from the wires)
             phases = 3
-            voltage_default = 0.416
+            voltage_default = 0.48
           # MV and 3 phases untill 16 MVA defined by SMART-DS project
           when @lv_limit[:three_phase]..16000
             phases = 3

data/lib/urbanopt/rnm/runner.rb

@@ -171,6 +171,16 @@ module URBANopt
         @rnm_pp = URBANopt::RNM::PostProcessor.new(@results, @run_dir, @feature_file)
         @rnm_pp.post_process
       end
+
+
+      ##
+      # Run OpenDSS validation
+      ##
+      def run_validation
+        # generate RNM-US input files
+        validation = URBANopt::RNM::Validation.new(@run_dir)
+        validation.run_validation
+      end
     end
   end
 end

data/lib/urbanopt/rnm/transformer_opendss.rb

@@ -52,11 +52,7 @@ module URBANopt
         hash[:resistance] = trafo['Low-voltage-side short-circuit resistance (ohms)'].to_f.round(2)
         hash[:reactance] = trafo['Reactance (p.u. transf)'].to_f.round(2)
         hash[:phases] = trafo['Nphases']
-        if trafo['Nphases'] == '3'
-          hash[:is_center_tap] = false
-        else
-          hash[:is_center_tap] = true
-        end
+        hash[:Centertap] = trafo['Centertap']
         hash[:high_voltage] = trafo['Primary Voltage (kV)']
         hash[:low_voltage] = trafo['Secondary Voltage (kV)']
         hash[:connection] = trafo['connection']

data/lib/urbanopt/rnm/validation/main_validation.py

@@ -0,0 +1,51 @@
+import opendssdirect as dss       
+import pandas as pd
+import matplotlib.pyplot as plt
+import numpy as np
+import sys as sys
+import math
+import networkx as nx
+import opendss_interface
+import plot_lib
+
+class Validation:
+    def __init__(self, folder):
+        self.folder = folder
+        
+    def main_validation(self):
+        master_file_full_path = folder + '/dss_files/' + 'Master.dss'
+        start_index = 0
+        num_periods=12
+        end_index = 8760
+        v_range_voltage=(0.9, 1.1)
+        v_limits_voltage=[0.95,1.05]
+        v_range_loading=(0,1.3)
+        v_limits_loading=[1]
+        v_range_show_all=(0,0)
+
+        #For tests
+        #end_index = 24
+        #v_range_voltage=(0.975, 1.025)
+
+        myopendss_io=opendss_interface.OpenDSS_Interface(folder)
+        v_dict_voltage,v_voltage_yearly,v_voltage_period,v_power_yearly,v_power_period,v_dict_loading,v_loading_yearly,v_loading_period,v_dict_losses,v_subs_losses_yearly,v_line_losses_yearly,dict_buses_element=myopendss_io.solve_powerflow_iteratively(num_periods,start_index,end_index,master_file_full_path,v_range_voltage,v_range_loading)
+        myopendss_io.write_dict(v_dict_voltage,v_range_show_all,'Voltages (p.u.)','Buses')
+        myopendss_io.write_dict(v_dict_voltage,v_range_voltage,'Voltage Violations (p.u.)','Buses')
+        myopendss_io.write_dict(v_dict_loading,v_range_show_all,'Loading (p.u.)','Branches')
+        myopendss_io.write_dict(v_dict_loading,v_range_loading,'Loading Violations (p.u.)','Branches')
+        myopendss_io.write_dict(v_dict_losses,v_range_show_all,'Losses','Branches')        
+        edges=myopendss_io.get_edges()
+        myplot_lib=plot_lib.Plot_Lib(folder)
+        myplot_lib.plot_hist('Voltage',v_voltage_yearly,v_voltage_period,v_range_voltage,40,num_periods,v_limits_voltage)
+        myplot_lib.plot_hist('Loading',v_loading_yearly,v_loading_period,v_range_loading,80,num_periods,v_limits_loading)
+        myplot_lib.plot_losses(v_subs_losses_yearly,v_line_losses_yearly)    
+        myplot_lib.plot_graph(edges,v_dict_voltage,v_range_voltage,v_dict_loading,v_range_loading,dict_buses_element)
+
+
+
+if __name__ == "__main__":
+    #Example to run it in command window
+    #python main_validation.py files
+    folder = sys.argv[1]
+    valid=Validation(folder)
+    valid.main_validation()

data/lib/urbanopt/rnm/validation/opendss_interface.py

@@ -0,0 +1,234 @@
+import opendssdirect as dss       
+import pandas as pd
+import matplotlib.pyplot as plt
+import numpy as np
+import sys as sys
+import math
+import networkx as nx
+
+class OpenDSS_Interface:
+    def __init__(self, folder):
+        self.folder = folder
+
+    def remove_terminal(self,bus):
+        if isinstance(bus,str):
+            return bus.split('.')[0]
+        else:
+            return bus
+
+
+    def extract_period(self,v_value_i,v_value_period,i,end_index,num_periods):
+        for j in range(num_periods):
+            if (i<=end_index*j/num_periods):
+                v_value_period[j].extend(v_value_i)
+                break
+        return v_value_period
+
+    def add_to_dictionary(self,v_dict_voltage,dict_voltage_i):
+        for idx,name in enumerate(dict_voltage_i):
+            if name in v_dict_voltage: #if not empty
+                v_dict_voltage[name].append(dict_voltage_i[name])
+            else:
+                v_dict_voltage[name]=[dict_voltage_i[name]]
+
+    def dss_run_command(self,command):
+        output=dss.run_command(command)
+        if (len(output)>0):
+            print(output)
+
+
+    def get_all_voltage(self):
+        """Computes over and under voltages for all buses"""
+        bus_names = dss.Circuit.AllBusNames()
+        dict_voltage = {}
+        v_voltage = [0 for _ in range(len(bus_names))]
+        for idx,b in enumerate(bus_names):
+            dss.Circuit.SetActiveBus(b)
+            vang = dss.Bus.puVmagAngle()
+            if len(vang[::2]) > 0:
+                vmag = sum(vang[::2])/(len(vang)/2)
+            else:
+                vmag = 0
+            dict_voltage[b] = vmag
+            v_voltage[idx]=vmag
+
+        return dict_voltage,v_voltage
+
+    def get_all_power(self):
+        """Computes power in all circuits"""
+        circuit_names = dss.Circuit.AllElementNames()
+        dict_power = {}
+        v_power = [0 for _ in range(len(circuit_names))]
+        for idx,b in enumerate(circuit_names):
+            dss.Circuit.SetActiveElement(b)
+            power = dss.CktElement.Powers()
+            if len(power[::2]) > 0:
+                poweravg = sum(power[::2])/(len(power)/2)
+            else:
+                poweravg = 0
+            dict_power[b] = poweravg
+            v_power[idx]=poweravg
+
+        return dict_power,v_power
+
+
+    def get_all_loading(self):
+        """Computes loading in all circuits"""
+        circuit_names = dss.Circuit.AllElementNames()
+        dict_loading = {}
+        dict_buses_element={} #Associate the element to the buses (this has the inconvenient that only associates one element to each pair of buses)
+        v_loading = [0 for _ in range(len(circuit_names))]
+        for idx,element in enumerate(circuit_names):
+            dss.Circuit.SetActiveElement(element)
+            #only if it is a branch (two buses)
+            buses = dss.CktElement.BusNames()
+            if (len(buses)>=2): 
+                current = dss.CktElement.CurrentsMagAng()
+                num_terminals=dss.CktElement.NumTerminals()
+                if len(current[::2]) > 0:
+                    #currentmag = sum(current[::2])/len(current[::2])
+                    #Take only the average of 1 terminal (discarding phases so every 2)
+                    lenc=len(current[::2])
+                    stop=round(2*lenc/num_terminals)
+                    #print(current[:stop:2])
+                    currentmag = sum(current[:stop:2])/lenc
+                else:
+                    currentmag = 0
+                currentmag = current[0]
+                nominal_current = dss.CktElement.NormalAmps()
+                #Transformers have applied a 1.1 factor in the calculation of NormalAmps
+                #See library that OpenDSSdirect uses in https://github.com/dss-extensions/dss_capi/blob/master/src/PDElements/Transformer.pas
+                #in particular line code AmpRatings[i] := 1.1 * kVARatings[i] / Fnphases / Vfactor;
+                if (element.startswith("Transformer")):
+                    nominal_current=nominal_current/1.1
+                if (nominal_current>0):
+                    dict_loading[element] = currentmag/nominal_current 
+                    v_loading[idx]=currentmag/nominal_current                            
+                    bus1to2=self.remove_terminal(buses[0])+'-->'+self.remove_terminal(buses[1])
+                    dict_buses_element[bus1to2]=element
+
+        return dict_loading,v_loading,dict_buses_element
+
+    def get_all_losses(self):
+        """Computes losses in all circuits"""
+        circuit_names = dss.Circuit.AllElementNames()
+        dict_losses = {}
+        v_losses = [0 for _ in range(len(circuit_names))]
+        total_losses=0
+        for idx,element in enumerate(circuit_names):
+            dss.Circuit.SetActiveElement(element)
+            #only if it is a branch (two buses)
+            buses = dss.CktElement.BusNames()
+            if (len(buses)>=2): 
+                #next if check discards vsources
+                nominal_current = dss.CktElement.NormalAmps()
+                if (nominal_current>0):
+                    losses = dss.CktElement.Losses()
+                    if len(losses) ==2:
+                        lossesavg = (losses[0]) #Verify this is correct, if not abs() they range from + to -, [0] to take active losses
+                    else:
+                        print("error - not correctly reading losses")
+                        lossesavg=0          
+                    #Convert to kW. This function is the exeption that return losses in W  
+                    lossesavg=lossesavg/1000 
+                    dict_losses[element] = lossesavg
+                    v_losses[idx]=lossesavg
+        
+        return dict_losses,total_losses
+
+    def get_total_subs_losses(self):
+        """Computes total substation losses"""
+        return dss.Circuit.SubstationLosses()[0]  #Real part
+
+    def get_total_line_losses(self):
+        """Computes total line losses"""
+        return dss.Circuit.LineLosses()[0] #Real part
+
+    def get_edges(self):
+        edges=[]
+        circuit_names = dss.Circuit.AllElementNames()
+        for idx,element in enumerate(circuit_names):
+            dss.Circuit.SetActiveElement(element)
+            buses = dss.CktElement.BusNames()
+            #Only if it is a branch
+            if (len(buses)>=2): #There can be 3 buses in single-phase center-tap transformer, in this case the two last ones are equals (different terminals only) and we can take just the 2 first ones
+                #remove terminal from the bus name (everything to the right of point)
+                edges.append([(self.remove_terminal(buses[0]),self.remove_terminal(buses[1]))])
+        return edges
+
+    def write_dict(self,v_dict,v_range,type,component):
+        output_file_full_path = self.folder + '/' + type + '_' + component + '.csv'
+        # Write directly as a CSV file with headers on first line
+        with open(output_file_full_path, 'w') as fp:
+            #Header: ID, hours (consider adding day, month in future)
+            for idx,name in enumerate(v_dict):
+                fp.write('Hour,'+','.join(str(idx2) for idx2,value in enumerate(v_dict[name])) + '\n')
+                break
+            #Write matrix
+            for idx,name in enumerate(v_dict):
+                #Truncate list to limits              
+                truncated_values=[]
+                for idx2,value in enumerate(v_dict[name]):  
+                    if value<v_range[0] or value>=v_range[1]:
+                        truncated_values.append(str(value))
+                    else:
+                        truncated_values.append("")
+                fp.write(name+','+','.join(truncated_values)+'\n')
+                #truncated_values=[i for i, lower, upper in zip(v_dict_voltage[name], [v_range_voltage[1]]*len(v_dict_voltage[name]), [v_range_voltage[1]]*len(v_dict_voltage[name])) if i <lower or i>upper]
+                #fp.write(name+','+','.join(map(str,v_dict_voltage[name]))+'\n')
+
+
+    def solve_powerflow_iteratively(self,num_periods,start_index,end_index,location,v_range_voltage,v_range_loading):
+        #Por flow solving mode
+        self.dss_run_command("Clear")
+        self.dss_run_command('Redirect '+location)
+        self.dss_run_command("solve mode = snap")
+        self.dss_run_command("Set mode=yearly stepsize=1h number=1")
+        #Init vectors
+        v_voltage_yearly=[]
+        v_voltage_period=[[] for _ in range(num_periods)]        
+        v_power_yearly=[]
+        v_power_period=[[] for _ in range(num_periods)]
+        v_loading_yearly=[]
+        v_loading_period=[[] for _ in range(num_periods)]
+        v_subs_losses_yearly=[]
+        v_line_losses_yearly=[]
+        v_dict_voltage={}
+        v_dict_loading={}
+        v_dict_losses={}
+        #Additional initializations
+        my_range=range(start_index,end_index,1)
+        old_percentage_str="" #Variable for tracking progress
+        for i in my_range:
+            #Solve power flow
+            self.dss_run_command("Solve")
+            #Get voltages
+            dict_voltage_i, v_voltage_i = self.get_all_voltage()
+            self.add_to_dictionary(v_dict_voltage,dict_voltage_i)
+            v_voltage_yearly.extend(v_voltage_i)            
+            self.extract_period(v_voltage_i,v_voltage_period,i,end_index,num_periods)
+            #Get power
+            dict_power_i, v_power_i = self.get_all_power()
+            v_power_yearly.extend(v_power_i)
+            v_power_period=self.extract_period(v_power_i,v_power_period,i,end_index,num_periods)
+            #Get loading
+            dict_loading_i, v_loading_i,dict_buses_element = self.get_all_loading()
+            self.add_to_dictionary(v_dict_loading,dict_loading_i)
+            v_loading_yearly.extend(v_loading_i)
+            v_loading_period=self.extract_period(v_loading_i,v_loading_period,i,end_index,num_periods)
+            #Get dict losses
+            dict_losses_i, v_losses_i = self.get_all_losses()
+            self.add_to_dictionary(v_dict_losses,dict_losses_i)
+            #Get losses
+            subs_losses_i = self.get_total_subs_losses()
+            v_subs_losses_yearly.append(subs_losses_i)
+            line_losses_i = self.get_total_line_losses()
+            v_line_losses_yearly.append(line_losses_i)
+            #Print progress
+            #percentage_str="{:.0f}".format(100*i/end_index)+"%"
+            #if (percentage_str!=old_percentage_str):
+            #    print(percentage_str)
+            #old_percentage_str=percentage_str
+        return v_dict_voltage,v_voltage_yearly,v_voltage_period,v_power_yearly,v_power_period,v_dict_loading,v_loading_yearly,v_loading_period,v_dict_losses,v_subs_losses_yearly,v_line_losses_yearly,dict_buses_element
+
+

data/lib/urbanopt/rnm/validation/plot_lib.py

@@ -0,0 +1,222 @@
+import opendssdirect as dss       
+import pandas as pd
+import matplotlib.pyplot as plt
+import numpy as np
+import sys as sys
+import math
+import networkx as nx
+import opendss_interface
+
+class Plot_Lib:
+    def __init__(self, folder):
+        self.folder = folder
+
+    def remove_terminal(self,bus):
+        myopendss_io=opendss_interface.OpenDSS_Interface(self.folder)
+        bus=myopendss_io.remove_terminal(bus)
+        return bus
+
+
+    def plot_hist(self,type,v_value,v_value_period,v_range,num_bins,num_periods,v_limits):
+        output_file_full_path_fig = self.folder + '/' + type +  ' Histogram (p.u.).png'
+        output_file_full_path_csv = self.folder + '/' + type + ' Histogram (p.u.).csv'
+        plt.figure
+        plt.grid(True)
+        v_legend=["" for _ in range(num_periods+2)]
+        matrix=np.empty((num_bins,num_periods+2)) #Matrix for writting to file (index+periods+yearly)
+        for j in range(num_periods):
+            plt.xlim(v_range)
+            v_weights = np.ones_like(v_value_period[j]) / len(v_value_period[j])
+            counts, bins = np.histogram(v_value_period[j], range=v_range, bins=num_bins, weights=v_weights)
+            if j==0:
+                v_legend[0]=type 
+                matrix[:,0]=bins[:num_bins:]
+            matrix[:,j+1]=counts
+            v_legend[j+1]= "M"+str(j+1)
+            plt.plot(bins[:-1]+(bins[1]-bins[0])*0.5, counts)
+
+        v_weights = np.ones_like(v_value) / len(v_value)
+        counts, bins = np.histogram(v_value, range=v_range, bins=num_bins, weights=v_weights)
+        matrix[:,num_periods+1]=counts
+        v_legend[num_periods+1]='Yearly'
+        plt.hist(bins[:-1], bins, weights=counts)
+        plt.legend(v_legend[1:num_periods+2:])
+        #Write line with the limits
+        for j in range(len(v_limits)):
+            h = plt.axvline(v_limits[j], color='r', linestyle='--')
+        #plt.text(0.76, 120000, '1,596 buses out of limits  ', fontsize = 10)
+        plt.xlabel(type+' (p.u.)')
+        plt.ylabel('Frequency (p.u.)')
+        plt.savefig(output_file_full_path_fig, dpi=300)
+        plt.show()
+        #Save to file
+        # Write directly as a CSV file with headers on first line
+        with open(output_file_full_path_csv, 'w') as fp:
+            fp.write(','.join(v_legend) + '\n')
+            np.savetxt(fp, matrix, '%s', ',')
+        #Deprecated with dataframes
+        #pd_values = pd.DataFrame(matrix,index=bins)
+        #pd_values.to_csv(output_file_full_path) 
+
+
+    def plot_losses(self,v_subs_losses_yearly,v_line_losses_yearly):
+        output_file_full_path_fig = self.folder + '/' + 'Losses' + '.png'
+        plt.figure
+        plt.plot(sorted(v_subs_losses_yearly,reverse=True))
+        plt.plot(sorted(v_line_losses_yearly,reverse=True))
+        plt.plot(sorted(np.add(v_subs_losses_yearly,v_line_losses_yearly),reverse=True))
+        plt.legend(['Substation losses','Line losses','Total losses'])
+        plt.xlabel('Hour (h)')
+        plt.ylabel('Losses (kWh)')
+        plt.savefig(output_file_full_path_fig)
+        plt.show()
+
+
+    def get_graph(self,edges):
+        graph=nx.Graph()
+        for idx,element in enumerate(edges):
+            graph.add_edges_from(element)
+        return graph
+
+    def get_locations(self,graph,bus,locations=[],x_locations_levels={},parent=None,level=0,visited_buses=[]):
+        #Add to the list of visited buses
+        if visited_buses:
+            visited_buses.append(bus)
+        else:
+            visited_buses=[bus]
+        #Obtain the buses connected to this one
+        connected_buses = list(graph.neighbors(bus))
+        #Explore downstream levels
+        x_downstream_locations=[]
+        for downstream_bus in connected_buses:
+            #Remove the terminal from the bus nmae
+            downstream_bus=self.remove_terminal(downstream_bus)
+            #If the bus was already visited, remove from graph (if activated this would remove loops)
+            #if downstream_bus!=parent and downstream_bus in visited_buses and graph.has_edge(bus,downstream_bus) and b_remove_loops:
+            #Remove self loops (possible to happen because of terminals in buses)
+            if downstream_bus==bus:
+                graph.remove_edge(bus,downstream_bus)
+            else:
+                #Explore downstream the graph (recursive search)
+                if downstream_bus!=parent and not downstream_bus in visited_buses:
+                    x_loc,locations=self.get_locations(graph,downstream_bus,locations,x_locations_levels,bus,level+1,visited_buses)
+                    x_downstream_locations.append(x_loc)
+        #For the upper levels, it takes the average of the downstream buses
+        if x_downstream_locations:
+            loc=(sum(x_downstream_locations)/len(x_downstream_locations),-level);
+        else:
+            if x_locations_levels:
+                #Pick up location from this level or the previous ones                
+                #It is neccesary to sort it, to pick in the above for lev loop the x_next_location from the more downstream level
+                for lev in sorted(x_locations_levels):                    
+                    if lev<=level:
+                        x_next_location=x_locations_levels[lev]+1
+                #Assign location x, y
+                loc=(x_next_location,-level)
+            else: 
+                #Default position for first bus
+                loc=(1,-level)
+        #Assign x location of this level
+        x_locations_levels[level]=loc[0]
+        #update locations
+        if locations:
+            locations[bus]=loc
+        else:
+            locations={bus:loc}
+        #Return x location of this bus (all locations are provided in locations argument)
+        return loc[0],locations               
+
+        
+
+
+    def plot_graph(self,edges,v_dict_voltage,v_range,v_dict_loading,v_range_loading,dict_buses_element):
+        output_file_full_path_fig = self.folder + '/' + 'Network Violations' + '.png'
+        #output_file_full_path_fig = folder + '/' + type + '.png'
+        #Example
+        graph=nx.Graph()
+        #graph.add_edges_from([(1,2), (1,3), (1,4), (1,5), (1,2), (2,6), (6,7), (7,1)])
+        #discard,locations=self.get_locations(graph,1)
+        graph=self.get_graph(edges)
+        discard,locations=self.get_locations(graph,'st_mat')
+        #Obtain number of violations of each node
+        cmap = plt.cm.get_cmap('jet')
+        dic_num_violations_v={}
+        for node in graph:
+            #Truncate list to limits              
+            dic_num_violations_v[node]=0
+            for idx2,value in enumerate(v_dict_voltage[node]):  
+                if value<v_range[0] or value>=v_range[1]:
+                    dic_num_violations_v[node]=dic_num_violations_v[node]+1
+        #Make colormap
+        color_map_v=[]
+        max_violations_v=max(dic_num_violations_v.values())
+        for node in graph:
+            if max_violations_v==0:
+                intensity=0
+            else:
+                intensity=dic_num_violations_v[node]/max_violations_v
+            #color_map_v.append(cmap_nodes(intensity))
+            color_map_v.append(intensity)
+        #Obtain number of violations of each branch
+        dic_num_violations_l={}
+        for edge in graph.edges():
+            #Truncate list to limits              
+            dic_num_violations_l[edge]=0
+            #bus1to2=self.remove_terminal(edge[0])+'-->'+self.remove_terminal(edge[1])
+            #bus2to1=self.remove_terminal(edge[1])+'-->'+self.remove_terminal(edge[0])
+            bus1to2=self.remove_terminal(edge[0])+'-->'+self.remove_terminal(edge[1])
+            bus2to1=self.remove_terminal(edge[1])+'-->'+self.remove_terminal(edge[0])
+            if bus1to2 in dict_buses_element:
+                element=dict_buses_element[bus1to2]
+            else:
+                element=dict_buses_element[bus2to1]
+            for idx2,value in enumerate(v_dict_loading[element]):  
+                if value<v_range_loading[0] or value>=v_range_loading[1]:
+                    dic_num_violations_l[edge]=dic_num_violations_l[edge]+1
+        #Make colormap
+        color_map_l=[]
+        max_violations_l=max(dic_num_violations_l.values())
+        for edge in graph.edges():
+            if max_violations_l==0:
+                intensity=0
+            else:
+                intensity=dic_num_violations_l[edge]/max_violations_l
+            #color_map_v.append(cmap_nodes(intensity))
+            color_map_l.append(intensity)
+        #Obtain min and max of x locations
+        max_x=0
+        max_y=0
+        for idx,name in enumerate(locations):
+            if (max_x<locations[name][0]):
+                max_x=locations[name][0]
+            if (max_y<-locations[name][1]):
+                max_y=-locations[name][1]
+        #plt.figure(figsize=(max_x,max_y))
+        unitary_size=0.5
+        ratio=16/9
+        maximum=max(max_x,max_y)*unitary_size
+        plt.figure(figsize=(maximum*ratio,maximum))
+        nodes = nx.draw_networkx_nodes(graph, pos=locations, node_color=color_map_v, cmap=cmap)
+        edges=nx.draw_networkx_edges(graph,pos=locations, edge_color=color_map_l,width=4,edge_cmap=cmap)
+        nx.draw_networkx_labels(graph, pos=locations)
+        num_ticks_v=5
+        ticks_v = np.linspace(0, 1, num_ticks_v) 
+        labels_v = np.linspace(0, max_violations_v, num_ticks_v) 
+        cbar=plt.colorbar(nodes,ticks=ticks_v) 
+        cbar.ax.set_yticklabels(["{:4.2f}".format(i) for i in labels_v]) # add the labels
+        cbar.set_label("Voltage violations (h)", fontsize=10, y=0.5, rotation=90)
+        cbar.ax.yaxis.set_label_position('left')
+        num_ticks_l=5
+        ticks_l = np.linspace(0, 1, num_ticks_l) 
+        labels_l = np.linspace(0, max_violations_l, num_ticks_l) 
+        cbar=plt.colorbar(edges,ticks=ticks_l) 
+        cbar.ax.set_yticklabels(["{:4.2f}".format(i) for i in labels_l]) # add the labels
+        cbar.set_label("Thermal limit violations (h)", fontsize=10, y=0.5, rotation=90)
+        cbar.ax.yaxis.set_label_position('left')
+        plt.axis('off')
+        wm = plt.get_current_fig_manager()
+        wm.window.state('zoomed')
+        plt.savefig(output_file_full_path_fig, dpi=300)
+        plt.show()
+
+

data/lib/urbanopt/rnm/validation.rb

@@ -0,0 +1,75 @@
+# *********************************************************************************
+# URBANopt (tm), Copyright (c) 2019-2022, Alliance for Sustainable Energy, LLC, and other
+# contributors. All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+
+# Redistributions of source code must retain the above copyright notice, this list
+# of conditions and the following disclaimer.
+
+# Redistributions in binary form must reproduce the above copyright notice, this
+# list of conditions and the following disclaimer in the documentation and/or other
+# materials provided with the distribution.
+
+# Neither the name of the copyright holder nor the names of its contributors may be
+# used to endorse or promote products derived from this software without specific
+# prior written permission.
+
+# Redistribution of this software, without modification, must refer to the software
+# by the same designation. Redistribution of a modified version of this software
+# (i) may not refer to the modified version by the same designation, or by any
+# confusingly similar designation, and (ii) must refer to the underlying software
+# originally provided by Alliance as "URBANopt". Except to comply with the foregoing,
+# the term "URBANopt", or any confusingly similar designation may not be used to
+# refer to any modified version of this software or any modified version of the
+# underlying software originally provided by Alliance without the prior written
+# consent of Alliance.
+
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+# INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+# OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+# OF THE POSSIBILITY OF SUCH DAMAGE.
+# *********************************************************************************
+
+require 'urbanopt/rnm/logger'
+
+module URBANopt
+  module RNM
+    # Class for OpenDSS validation (runs python script)
+    class Validation
+      ##
+      # Initialize attributes: ++run directory+ 
+      ##
+      # [parameters:]
+      # * +rnm_dirname+ - _String_ - name of RNM-US directory that will contain the input files (within the scenario directory)
+      def initialize(rnm_full_path)
+        # absolute path
+        @rnm_full_path = rnm_full_path
+        @opendss_full_path=File.join(@rnm_full_path,'results/OpenDSS')
+        if !Dir.exist?(@opendss_full_path)
+            puts 'Error: folder does not exist'+@rnm_full_path
+        end
+      end
+
+
+      ##
+      # Run validation
+      ##
+      def run_validation()
+        puts "Initating OpenDSS validation in folder"
+        puts @opendss_full_path
+        puts "This can take some minutes"
+        #puts `python ./lib/urbanopt/rnm/validation/main_validation.py #{@rnm_full_path}`
+        log=`python ./lib/urbanopt/rnm/validation/main_validation.py #{@opendss_full_path}`
+        puts log
+      end
+    end
+  end
+end