urbanopt-rnm-us 0.4.0 → 0.5.0

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

@@ -1,188 +1,477 @@
 import opendssdirect as dss       
 import pandas as pd
+#import matplotlib
 import matplotlib.pyplot as plt
 import numpy as np
 import sys as sys
 import math
 import networkx as nx
 import opendss_interface
+import seaborn as sns
+import plotly.graph_objects as go
+from shapely.geometry import LineString
+from shapely.geometry import Point
+import geopandas as gpd
+
 
 class Plot_Lib:
-    def __init__(self, folder):
-        self.folder = folder
+    def __init__(self, folder,b_numeric_ids):
+        """Initialices the folder variables"""
+        self.main_folder = folder
+        self.folder=folder+'/Validation'
+        self.b_numeric_ids=b_numeric_ids
 
     def remove_terminal(self,bus):
-        myopendss_io=opendss_interface.OpenDSS_Interface(self.folder)
+        """Removes the terminal from the bus name"""
+        myopendss_io=opendss_interface.OpenDSS_Interface(self.folder,self.b_numeric_ids)
         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
+    def plot_hist(self,subfolder,type,v_value,v_value_period,v_range,num_periods,num_bins,v_months):
+        """Plots an histogram"""
+        # Path and file name
+        output_file_full_path_fig = self.folder + '/' + subfolder + '/Figures/' + type +  ' Histogram (p.u.).png'
+        output_file_full_path_csv = self.folder + '/' + subfolder + '/CSV/' + type + ' Histogram (p.u.).csv'
+        # New figure
+        # plt.figure
+        plt.clf()
+        # Activate figure grid
         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)
-
+        # Evaluate number of valid periods
+        num_valid_periods=0
+        for j in v_months:
+            #If data in the month
+            if not j==[]:
+                num_valid_periods=num_valid_periods+1
+        # Init variables
+        v_legend=["" for _ in range(num_valid_periods+1)]
+        matrix=np.empty((num_bins,num_valid_periods+1)) #Matrix for writting to file (index+periods+yearly)
+        # Set xlim
+        if v_range['display_range']:
+            plt.xlim(v_range['display_range'])
+        # Incremental index for months with data
+        i=0        
+        # For each month
+        for j in v_months:
+            #If data in the month
+            if not j==[]:
+                # Set the weight variable
+                v_weights = np.ones_like(v_value_period[j]) / len(v_value_period[j])
+                # Calculate the histogram of each month
+                counts, bins = np.histogram(v_value_period[j], range=v_range['display_range'], bins=num_bins, weights=v_weights)
+                # Update matrix and legend
+                # In subsequent iterations
+                matrix[:,i]=counts
+                v_legend[i]="M"+str(j+1)
+                # Plot the month
+                plt.plot(bins[:-1]+(bins[1]-bins[0])*0.5, counts)
+                # Increment index if data
+                i=i+1
+        # Set the weight variable
         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'
+        # Calculate the yearly histogram
+        counts, bins = np.histogram(v_value, range=v_range['display_range'], bins=num_bins, weights=v_weights)
+        # Update matrix and legend
+        matrix[:,i]=counts
+        v_legend[i]='Yearly'
+        # Plot histogram
         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.)')
+        # Plot legend
+        #plt.legend(v_legend[1:num_periods+2:])
+        plt.legend(v_legend)
+        # Write line with the limits
+        for j in range(len(v_range['limits'])):
+            h = plt.axvline(v_range['limits'][j], color='r', linestyle='--')
+        # x,y lables
+        plt.xlabel(type)
         plt.ylabel('Frequency (p.u.)')
+        # Save to file
         plt.savefig(output_file_full_path_fig, dpi=300)
-        plt.show()
-        #Save to file
+        # Display
+        # plt.show()
+        # Save data 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'])
+            np.savetxt(fp, matrix, '%.7f', ',')
+
+    def plot_violin(self,subfolder,type,v_value,v_range):
+        """Make a figure with a violin plot"""
+        # Path and file name
+        output_file_full_path_fig = self.folder + '/' + subfolder + '/' + type +  ' Violin Plot.png'
+        # New figure
+        # plt.figure
+        plt.clf()
+        # Write line with the limits
+        for j in range(len(v_range['limits'])):
+            h = plt.axhline(v_range['limits'][j], color='r', linestyle='--')
+        # Plot violtin
+        sns.violinplot(y=v_value, cut=0, color='orange')
+        # Strip plot (display points)
+        sns.stripplot(y=v_value, color='blue')
+        # y label
+        plt.ylabel(type)
+        # y limit
+        if v_range['display_range']:
+            plt.ylim(v_range['display_range'])
+        # Save figure to file
+        plt.savefig(output_file_full_path_fig, dpi=300)
+        # Display
+        # plt.show()
+
+    def plot_violin_two_vars(self,subfolder, type,v_value1,v_value2,v_range):
+        """Make a figure with a violin plot of two variables (kW/kVAr)"""
+        # Path and file name
+        output_file_full_path_fig = self.folder + '/' + subfolder + '/' + type +  ' Violin Plot.png'
+        # New figure
+        # plt.figure
+        plt.clf()
+        # Init variables
+        v_data=[]
+        v_type=[]
+        # Write line with the limits
+        for j in range(len(v_range['limits'])):
+            h = plt.axhline(v_range['limits'][j], color='r', linestyle='--')
+        # Extend lists for yearly var1
+        l_type=['kW' for _ in v_value1]
+        v_data.extend(v_value1)
+        v_type.extend(l_type)
+        # Extend lists for yearly var2
+        l_type=['kVAr' for _ in v_value2]
+        v_data.extend(v_value2)
+        v_type.extend(l_type)
+        # Display violin plot
+        sns.violinplot(y=v_data, hue=v_type, cut=0, split=True, palette = {'kW':'blue','kVAr':'orange'})
+        # Set y label
+        plt.ylabel(type)
+        # Set y limit
+        if v_range['display_range']:
+            plt.ylim(v_range['display_range'])
+        # Save figure to file
+        plt.savefig(output_file_full_path_fig, dpi=300)
+        # Display
+        # plt.show()
+
+
+    def plot_violin_monthly(self,subfolder, type,v_value,v_value_period,v_range,num_periods,v_months):
+        """Make a violin plot with the monthly variation"""
+        # Path and file name
+        output_file_full_path_fig = self.folder + '/' + subfolder + '/' + type +  ' Violin Plot.png'
+        # New figure
+        # plt.figure
+        plt.clf()
+        # Init variables
+        v_data=[]
+        v_month=[]
+        v_yearly=[]
+        # Write line with the limits
+        for j in range(len(v_range['limits'])):
+            h = plt.axhline(v_range['limits'][j], color='r', linestyle='--')
+        # Incremental index for valid months
+        i=0
+        # For each month
+        for j in v_months:
+            # If data in the month
+            if not j==[]:
+                # Extend lists for monthly
+                l_month=["M"+str(j+1) for _ in v_value_period[j]]
+                l_yearly=['Monthly' for _ in v_value_period[j]]
+                v_data.extend(v_value_period[j])
+                v_month.extend(l_month)
+                v_yearly.extend(l_yearly)
+                # Extend lists for yearly
+                l_month=["M"+str(j+1) for _ in v_value]
+                l_yearly=['Yearly' for _ in v_value]
+                v_data.extend(v_value)
+                v_month.extend(l_month)
+                v_yearly.extend(l_yearly)
+                #Increment auto-index if there is data
+                i=i+1
+        # Display violin plot
+        sns.violinplot(x=v_month, y=v_data, hue=v_yearly, cut=0, split=True)
+        # Set y label
+        plt.ylabel(type)
+        # Set y limit
+        if v_range['display_range']:
+            plt.ylim(v_range['display_range'])
+        # Save figure to file
+        plt.savefig(output_file_full_path_fig, dpi=300)
+        # Display
+        # plt.show()
+
+    def plot_violin_monthly_two_vars(self,subfolder, type,v_value1,v_value1_period,v_value2,v_value2_period,v_range,num_periods,v_months):
+        """Make a violin plot for two variables (kW/kVAr) with the monthly variation"""
+        # Path and file name
+        output_file_full_path_fig = self.folder + '/' + subfolder + '/' + type +  ' Violin Plot.png'
+        # New figure
+        # plt.figure
+        plt.clf()
+        # Init variables
+        v_data=[]
+        v_month=[]
+        v_type=[]
+        # Incremental index for valid months
+        i=0
+        for j in v_months:
+            #If there is data
+            if not j==[]:
+                # Extend lists for monthly var1
+                l_month=["M"+str(j+1) for _ in v_value1_period[j]]
+                l_type=['kW' for _ in v_value1_period[j]]
+                v_data.extend(v_value1_period[j])
+                v_month.extend(l_month)
+                v_type.extend(l_type)
+                # Extend lists for monthly var2
+                l_month=["M"+str(j+1) for _ in v_value2_period[j]]
+                l_type=['kVAr' for _ in v_value2_period[j]]
+                v_data.extend(v_value2_period[j])
+                v_month.extend(l_month)
+                v_type.extend(l_type)
+                #Increment auto-index if there is data
+                i=i+1
+        # Extend lists for yearly var1
+        l_month=['Yearly' for _ in v_value1]
+        l_type=['kW' for _ in v_value1]
+        v_data.extend(v_value1)
+        v_month.extend(l_month)
+        v_type.extend(l_type)
+        # Extend lists for yearly var2
+        l_month=['Yearly' for _ in v_value2]
+        l_type=['kVAr' for _ in v_value2]
+        v_data.extend(v_value2)
+        v_month.extend(l_month)
+        v_type.extend(l_type)
+        # Show violin plot
+        sns.violinplot(x=v_month, y=v_data, hue=v_type, cut=0, split=True)
+        # Show stripplot (points) (disabled because there are too many points)
+        # sns.stripplot(x=v_month, y=v_data, hue=v_type, color="k", alpha=0.8)
+        # Set x,y lables
+        plt.xlabel('Month')
+        plt.ylabel(type)
+        # Set y limit
+        if v_range['display_range']:
+            plt.ylim(v_range['display_range'])
+        # Save figure to file
+        plt.savefig(output_file_full_path_fig, dpi=300)
+        # Display
+        # plt.show()        
+
+    def plot_duration_curve(self,subfolder, v1_yearly,v2_yearly,b_losses,v_hours):
+        """Make a figure with the duration curve (yearly losses or load)"""
+        # New figure
+        # plt.figure
+        plt.clf()
+        # Display variable 1
+        plt.plot(v_hours,sorted(v1_yearly,reverse=True))
+        # Display variable 1
+        plt.plot(v_hours,sorted(v2_yearly,reverse=True))
+        # If displaying losses
+        if b_losses:
+            # Plot the added curve (lines + transformers)
+            plt.plot(v_hours,sorted(np.add(v1_yearly,v2_yearly),reverse=True))
+            # Set file path + name
+            output_file_full_path_fig = self.folder + '/' + subfolder + '/' + 'Losses' + '.png'
+            # Set legend
+            plt.legend(['Substation losses','Line losses','Total losses'])
+            # Set y label
+            plt.ylabel('Losses (kWh)')
+        else: # If displaying load
+            # Set file path + name
+            output_file_full_path_fig = self.folder + '/' + subfolder + '/' + 'Load' + '.png'
+            # Set legend
+            plt.legend(['kW','kVAr'])
+            # Set y label
+            plt.ylabel('Load')
+        # Set x label    
         plt.xlabel('Hour (h)')
-        plt.ylabel('Losses (kWh)')
+        # Save figure to file
         plt.savefig(output_file_full_path_fig)
-        plt.show()
+        # Display
+        # plt.show()
 
 
-    def get_graph(self,edges):
-        graph=nx.Graph()
+    def add_edges(self,graph,edges):
+        """Add edges to the graph"""
+        # Populate it with the edges
         for idx,element in enumerate(edges):
-            graph.add_edges_from(element)
+            graph.add_edges_from([(element[0],element[1])])
         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
+    def get_locations(self,graph,bus,locations=[],x_location_max_prev=0,parent=None,level=0,visited_buses=[]):
+        """Get the locations of the buses in the graph"""
+        # 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
+        # Obtain the buses connected to this one
         connected_buses = list(graph.neighbors(bus))
-        #Explore downstream levels
+        # Explore downstream levels
         x_downstream_locations=[]
         for downstream_bus in connected_buses:
-            #Remove the terminal from the bus nmae
+            # Remove the terminal from the bus name
             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 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)
+                # 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_loc,locations,x_location_max_prev=self.get_locations(graph,downstream_bus,locations,x_location_max_prev,bus,level+1,visited_buses)
                     x_downstream_locations.append(x_loc)
-        #For the upper levels, it takes the average of the downstream buses
+        # 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
+            if x_location_max_prev:
+                # 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
+                x_next_location=x_location_max_prev+1
+                # Assign location x, y
                 loc=(x_next_location,-level)
             else: 
-                #Default position for first bus
+                # Default position for first bus
                 loc=(1,-level)
-        #Assign x location of this level
-        x_locations_levels[level]=loc[0]
-        #update locations
+        # Assign x location of this level
+        if x_location_max_prev<loc[0]:
+            x_location_max_prev=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')
+        # Return x location of this bus (all locations are provided in locations argument)
+        return loc[0],locations,x_location_max_prev               
+
+
+    def get_dict_num_violations_v(self,graph,v_dict_voltage,v_range,v_dict_ids_buses):
+        """It obtains number (hours) of voltage violations of each bus"""
+        myopendss_io=opendss_interface.OpenDSS_Interface(self.folder,self.b_numeric_ids)
+        # Init dict
         dic_num_violations_v={}
+        # For each node
         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
+            # Get dict of violations
+            if (self.b_numeric_ids):
+                dic_num_violations_v[node]=myopendss_io.get_num_violations(v_dict_voltage[v_dict_ids_buses[node]],v_range,node,None)
+            else:
+                dic_num_violations_v[node]=myopendss_io.get_num_violations(v_dict_voltage[node],v_range,node,None)
+        return dic_num_violations_v
+
+
+    def get_dict_num_violations_l(self,graph,dict_buses_element,v_dict_loading,v_range_loading,v_dict_ids_buses):
+        """It obtains number (hours) of violations of each branch"""
+        # Obtain number of violations (hours) of each branch
+        myopendss_io=opendss_interface.OpenDSS_Interface(self.folder,self.b_numeric_ids)
+        # Init dict
+        dic_num_violations_l={}
+        # For each granch
+        for edge in graph.edges():
+            # Obtain name from bus1 to bus2
+            if not self.b_numeric_ids:
+                bus1to2=self.remove_terminal(edge[0])+'-->'+self.remove_terminal(edge[1])
+            else:
+                bus1to2=self.remove_terminal(v_dict_ids_buses[edge[0]])+'-->'+self.remove_terminal(v_dict_ids_buses[edge[1]])
+            # Obtain name from bus2 to bus1
+            if not self.b_numeric_ids:
+                bus2to1=self.remove_terminal(edge[1])+'-->'+self.remove_terminal(edge[0])
+            else:
+                bus2to1=self.remove_terminal(v_dict_ids_buses[edge[1]])+'-->'+self.remove_terminal(v_dict_ids_buses[edge[0]])
+            # If bus1 to bus2 is the one that exists in the dictionary
+            if bus1to2 in dict_buses_element:
+                # Set element name
+                element=dict_buses_element[bus1to2]
+                # Evaluate number of violations
+                dic_num_violations_l[edge]=myopendss_io.get_num_violations(v_dict_loading[element],v_range_loading,element,None)
+            elif bus2to1 in dict_buses_element: #If bus2 to bus1 is the one that exists in the dictionary
+                # Set element name
+                element=dict_buses_element[bus2to1]
+                # Evaluate number of violations
+                dic_num_violations_l[edge]=myopendss_io.get_num_violations(v_dict_loading[element],v_range_loading,element,None)
+            else: # If the element does not exist in the dictionary, set number of violations to zero
+                dic_num_violations_l[edge]=0
+        return dic_num_violations_l
+
+
+
+    def plot_graph(self,subfolder,my_closed_edges,my_open_edges,v_dict_voltage,v_range,v_dict_loading,v_range_loading,dict_buses_element,v_dict_buses_ids,v_dict_ids_buses):
+        """Plot a graph with the hierarchical representation of the network"""
+        # Path and file name
+        output_file_full_path_fig = self.folder + '/' + subfolder + '/' + 'Network Violations' + '.png'
+        # New figure
+        # plt.figure
+        plt.clf()
+        # Close the previous fig
+        plt.close()
+        # Create empty graph
+        mygraph=nx.Graph()
+        # Commented graph example
+        # mygraph.add_edges_from([(1,2), (1,3), (1,4), (1,5), (1,2), (2,6), (6,7), (7,1)])
+        # discard,locations=self.get_locations(mygraph,1)
+        # Populate the graph with the closed edges
+        mygraph=self.add_edges(mygraph,my_closed_edges)
+        mygraph_only_closed_edges=mygraph.copy()
+        # Populate the graph with the open edges
+        mygraph=self.add_edges(mygraph,my_open_edges)
+        # Get the locations of the buses
+        # WARNING: Locations are extracter from closed edges. This requires that there are no disconnected buses (e.g. two open switches in series)
+        if self.b_numeric_ids:
+            discard,locations,x_location_max_prev=self.get_locations(mygraph_only_closed_edges,str(0)) #function get_all_buses_ids sets slack bus to str(0)
+        else:
+            discard,locations,x_location_max_prev=self.get_locations(mygraph_only_closed_edges,'st_mat') #RNM-US specific (the slack bus of the distribution system is always "st_mat")
+        # Create colormap
+        cmap = plt.cm.get_cmap('jet')
+        # Take subset of colormap to avoid dark colors (with overlap with text)
+        cmap = cmap.from_list('trunc({n},{a:.3f},{b:.3f})'.format(n=cmap.name, a=0.15, b=0.75),cmap(np.linspace(0.25, 0.75, 120)))
+        # Init colormap variable
         color_map_v=[]
+        # Get number of voltage valiations
+        dic_num_violations_v=self.get_dict_num_violations_v(mygraph,v_dict_voltage,v_range,v_dict_ids_buses)
+        # Obtain the maximum number of voltage violations in a bus
         max_violations_v=max(dic_num_violations_v.values())
-        for node in graph:
+        # if no violations, use only one color in the colormap
+        if max_violations_v==0:
+            cmap_v = cmap.from_list('trunc({n},{a:.3f},{b:.3f})'.format(n=cmap.name, a=0, b=0),cmap(np.linspace(0, 0, 2)))
+        else:
+            cmap_v = cmap
+        # Creater a colormap (color_map_v) o colour the buses according to their number of violations
+        for node in mygraph:
+            # If there are no violations, set all intensities to zero
             if max_violations_v==0:
                 intensity=0
             else:
                 intensity=dic_num_violations_v[node]/max_violations_v
-            #color_map_v.append(cmap_nodes(intensity))
+            # Add the intensity of the bus to the colormap
             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=[]
+        # Init colormap variables
+        color_map_l_closed=[] 
+        color_map_l_open=[]
+        # Get number of loading valiations
+        dic_num_violations_l=self.get_dict_num_violations_l(mygraph,dict_buses_element,v_dict_loading,v_range_loading,v_dict_ids_buses)
+        # Obtain the maximum number of loading violations in a branch
         max_violations_l=max(dic_num_violations_l.values())
-        for edge in graph.edges():
+        # if no violations, use only one color in the colormap
+        if max_violations_l==0:
+            cmap_l = cmap.from_list('trunc({n},{a:.3f},{b:.3f})'.format(n=cmap.name, a=0, b=0.01),cmap(np.linspace(0, 0.01, 2)))
+        else:
+            cmap_l = cmap
+        # Creater a colormap (color_map_l) o colour the closed branches according to their number of violations
+        for edge in mygraph_only_closed_edges.edges():
+            # If there are no violations, set all intensities to zero
             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)
+            # Add the intensity of the branch to the colormap
+            color_map_l_closed.append(intensity)
+        # Creater a colormap for the open branches
+        for edge in mygraph.edges():
+            # Add the intensity of the branch to the colormap
+            if not edge in mygraph_only_closed_edges.edges():
+                color_map_l_open.append(0) #As it is a different graph, order may be different, but it does not matter because they are all zero
         #Obtain min and max of x locations
         max_x=0
         max_y=0
@@ -191,14 +480,22 @@ class Plot_Lib:
                 max_x=locations[name][0]
             if (max_y<-locations[name][1]):
                 max_y=-locations[name][1]
-        #plt.figure(figsize=(max_x,max_y))
+        # Define the size of the figure
         unitary_size=0.5
         ratio=16/9
         maximum=max(max_x,max_y)*unitary_size
+        if (maximum>40):
+            maximum=40
         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)
+        # Set transparency parameter
+        myalpha=0.6
+        # Draw the nodes
+        nodes = nx.draw_networkx_nodes(mygraph, pos=locations, node_color=color_map_v, cmap=cmap_v,alpha=myalpha)
+        # Draw the closed edges (solid lines)
+        edges=nx.draw_networkx_edges(mygraph_only_closed_edges,pos=locations, edge_color=color_map_l_closed,width=4,edge_cmap=cmap_l,alpha=myalpha)
+        # Show the buses names
+        nx.draw_networkx_labels(mygraph, pos=locations,font_size=8)        
+        # Make the ticks, lables, and colorbar
         num_ticks_v=5
         ticks_v = np.linspace(0, 1, num_ticks_v) 
         labels_v = np.linspace(0, max_violations_v, num_ticks_v) 
@@ -213,10 +510,19 @@ class Plot_Lib:
         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')
+        # Draw the open edges (dashed lines)
+        edges=nx.draw_networkx_edges(mygraph,edgelist=my_open_edges,pos=locations, edge_color=color_map_l_open,width=4,edge_cmap=cmap_l,style='--',alpha=myalpha)
+        # Don't display the axis in the figure
         plt.axis('off')
+        # Maximize figure
         wm = plt.get_current_fig_manager()
-        wm.window.state('zoomed')
+        backend_name = plt.get_backend()
+        # this won't work on mac but should work on windows?
+        # macosx does not have a "window" attribute
+        if backend_name.lower() != 'macosx':
+            wm.window.state('zoomed')
+
+        # Save the figure to file
         plt.savefig(output_file_full_path_fig, dpi=300)
+        # Display
         plt.show()
-
-