urbanopt-rnm-us 0.4.0 → 0.5.0

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

@@ -5,67 +5,307 @@ import numpy as np
 import sys as sys
 import math
 import networkx as nx
+from datetime import datetime
 
 class OpenDSS_Interface:
-    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):
+        """Removes the terminal from the bus name"""
         if isinstance(bus,str):
-            return bus.split('.')[0]
+            return bus.split('.')[0] #(everything to the right of point ".")
         else:
             return bus
 
+    def is_to_be_analyzed(self,name):
+        """Determines if an element has to be analyzed"""
+        b_analyzed=False
+        if name.startswith('Line.padswitch'): #RNM specific #We only condider power lines and tarnsformers as branches
+            b_analyzed=False
+        elif name.startswith('Line.breaker'): #RNM specific
+            b_analyzed=False
+        elif name.startswith('Line.fuse'): #RNM specific
+            b_analyzed=False
+        elif name.startswith('Capacitor'):
+            b_analyzed=False
+        elif name.startswith('Line.l'): #RNM specific
+            b_analyzed=True
+        elif name.startswith('Transformer'):
+            b_analyzed=True
+        else:
+            print("Component type was not explicitly consiered in the validation module. It is not analyzed.")
+            print(name)
+        return b_analyzed
 
-    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
+
+
+    def extract_period(self,v_value_i,v_value_period,i,end_index,num_periods,month):
+        """#Assign v_value_i to the corresponding month"""        
+        v_value_period[month-1].extend(v_value_i)
         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])
+    def add_to_dictionary(self,dict_all,dict_i):
+        """Adds dict_i to the dictonary dict_all"""
+        for idx,name in enumerate(dict_i):
+            if name in dict_all: #if not empty
+                dict_all[name].append(dict_i[name])
             else:
-                v_dict_voltage[name]=[dict_voltage_i[name]]
+                dict_all[name]=[dict_i[name]]
 
     def dss_run_command(self,command):
+        """Runs an OpenDSS Direct command"""
+        #Run command
         output=dss.run_command(command)
+        #If it has any output, print it
         if (len(output)>0):
             print(output)
 
 
+    def get_time_stamp(self):
+        """Read the timestamps and obtain the raw and the formatted version"""
+        #Select file
+        timestamp_file = self.main_folder + '/profiles/' + 'timestamps.csv'
+        #Read file
+        timestamps = []
+        with open(timestamp_file) as csv_data_file:
+            for row in csv_data_file:
+                timestamps.append(row.strip())
+        #remove the header
+        timestamps.pop(0)  
+        #Define date time format 
+        dt_format = '%Y/%m/%d %H:%M:%S'
+        #Convert to datetime structure
+        timestamps_datetime= [datetime.strptime(i,dt_format) for i in timestamps]
+        return timestamps,timestamps_datetime
+
+
     def get_all_voltage(self):
         """Computes over and under voltages for all buses"""
+        #Get bus names
         bus_names = dss.Circuit.AllBusNames()
+        #Init variables
         dict_voltage = {}
         v_voltage = [0 for _ in range(len(bus_names))]
+        #For each bus
         for idx,b in enumerate(bus_names):
+            #Set it as active bus
             dss.Circuit.SetActiveBus(b)
+            #Get voltage and angle
             vang = dss.Bus.puVmagAngle()
+            #Get voltage magnitude
             if len(vang[::2]) > 0:
-                vmag = sum(vang[::2])/(len(vang)/2)
+                #Average of the voltages in all the phases, discarding the angles
+                vmag = sum(vang[::2])/(len(vang)/2)  
             else:
                 vmag = 0
+            #Add voltage magnitude to dictionary and to list of voltages
             dict_voltage[b] = vmag
             v_voltage[idx]=vmag
 
         return dict_voltage,v_voltage
 
+
+    def get_all_unbalance(self):
+        """Computes voltage unbalance for all buses"""
+        # Based on  IEEE standard 141-1993 https://www.sciencedirect.com/science/article/pii/S0378779620304594
+        #Get bus names
+        bus_names = dss.Circuit.AllBusNames()
+        #Init variables
+        dict_voltage = {}
+        v_voltage = [0 for _ in range(len(bus_names))]
+        #For each bus
+        for idx,b in enumerate(bus_names):
+            dss.Circuit.SetActiveBus(b)
+            #Set it as active bus
+            #Get voltage and angle
+            vang = dss.Bus.puVmagAngle()
+            #Evaluate the unbalance
+            if len(vang[::2]) ==3: #if three-phase
+                vmedio = sum(vang[::2])/(len(vang)/2) #Average of the voltages in all the phases, discarding the angles
+                va=vang[0]  #Phase A
+                vb=vang[2]  #Phase B
+                vc=vang[4]  #Phase C
+                vmax=max(abs(va-vmedio),abs(vb-vmedio),abs(vc-vmedio)) #Phase Voltage Unbalance Rate (PVUR)  (based on IEEE)
+            elif len(vang[::2]) ==2: #If two phase
+                vmedio = sum(vang[::2])/(len(vang)/2) #Average of the voltages in all the phases, discarding the angles
+                va=vang[0]  #Phase A
+                vb=vang[2]  #Phase B
+                vmax=max(abs(va-vmedio),abs(vb-vmedio)) #Phase Voltage Unbalance Rate (PVUR)  
+            elif len(vang[::2]) ==1: #If single-phase
+                vmax = 0    #No unblance
+            else: #Not other cases are considered
+                print("Value: "+str(vang)+"Lend: "+str(len(vang)))
+                raise Exception("Voltage is not single-, two- or three-phase")
+            #Add unbalance to dictionary and to list of unbalances
+            dict_voltage[b] = vmax
+            v_voltage[idx]=vmax
+        return dict_voltage,v_voltage
+
+
+    def get_all_loads(self):
+        """Get all loads peak kW and kVAr"""
+        #Init variables
+        dict_loads = {}        
+        myrange=range(0,dss.Loads.Count())
+        v_loads_kw = [0 for _ in myrange]
+        v_loads_kvar = [0 for _ in myrange]
+        #For each load
+        for idx in myrange:
+            #Set load index
+            dss.Loads.Idx(idx+1)
+            #Get kW of the load
+            kw = dss.Loads.kW()
+            #Get kVAr of the load
+            kvar = dss.Loads.kvar()
+            #Get load name
+            name = 'LOAD.'+dss.Loads.Name()
+            #Add load to dictionary and to list of load kW/kVAr
+            dict_loads[name] = kw
+            v_loads_kw[idx]=kw
+            v_loads_kvar[idx]=kvar
+        return dict_loads,v_loads_kw,v_loads_kvar
+
+    def get_all_loadshapes(self,i):
+        """Get all loadshapes"""
+        dict_loads = {}
+        #Init variables
+        myrange=range(0,dss.LoadShape.Count())
+        v_loads_kw = [0 for _ in myrange]
+        v_loads_kvar = [0 for _ in myrange]
+        #For each loadshape
+        for idx in myrange:
+            #Set loadshape index
+            dss.LoadShape.Idx(idx+1)
+            #Get hourly kW
+            kw = dss.LoadShape.PMult()
+            #Get hourly kVAr
+            kvar = dss.LoadShape.QMult()
+            #Get load name
+            name = 'LOAD.'+dss.LoadShape.Name()
+            #If not default load (discard it)
+            if not(name=='LOAD.default'):
+                if len(kw)>1:
+                    #Add load to dictionary and to list of load kW
+                    dict_loads[name] = kw[i]
+                    v_loads_kw[idx]=kw[i]
+                if len(kvar)>1:
+                    #Add to list of load kW
+                    v_loads_kvar[idx]=kvar[i]
+
+        return dict_loads,v_loads_kw,v_loads_kvar
+
+
+    def get_all_buses_loads(self,i):
+        """Get the load of all the buses"""
+        #Get data from load shapes
+        dict_loads,v_loads_kw,v_loads_kvar=self.get_all_loadshapes(i)
+        #Get all bus names
+        bus_names = dss.Circuit.AllBusNames()
+        #Init dict
+        dict_buses_loads = {}
+        #For each bus
+        for idx,b in enumerate(bus_names):
+            #Set it to the active bus
+            dss.Circuit.SetActiveBus(b)
+            #Get its loads
+            loads = dss.Bus.LoadList()
+            #Init its load to zero
+            load_bus=0
+            #For each load in the bus
+            for l in loads:
+                #Assign it the load in the loadshape
+                load_bus=load_bus+dict_loads[l+"_profile"] #RNM-US specific (the load shapes names are the name of the laods + "_profile")
+            #Add to dictionary
+            dict_buses_loads[b] = load_bus
+        return dict_buses_loads,v_loads_kw,v_loads_kvar
+
+
+    def get_all_buses_ids(self):
+        """Get the load of all the buses"""
+        #Get all bus names
+        bus_names = dss.Circuit.AllBusNames()
+        #Init dict
+        dict_buses_ids = {}
+        dict_ids_buses = {}
+        #Init numeric identifier
+        num_id=1
+        #For each bus
+        for idx,b in enumerate(bus_names):
+            if b=='st_mat': #RNM-US specific (st_mat is the slack bus)
+                dict_buses_ids[b] = str(0)
+                dict_ids_buses[str(0)] = b
+            else:
+                dict_buses_ids[b] = str(num_id)
+                dict_ids_buses[str(num_id)] = b
+                num_id=num_id+1
+        return dict_buses_ids,dict_ids_buses
+
+    def get_all_lines(self):
+        """Gets the normal ampacity of power lines"""
+        #Init variables
+        dict_lines = {}
+        myrange=range(0,dss.Lines.Count())
+        v_lines_norm_amps = []
+        #For each power line
+        for idx in myrange:
+            #Set power line index
+            dss.Lines.Idx(idx+1)
+            #Get the normal amapcity
+            normal_amps = dss.Lines.NormAmps()
+            #Get the power line name
+            name = 'Line.'+dss.Lines.Name()
+            #If it is a power line
+            if name.startswith("Line.l("): #RNM-US specific (all power lines start with "Line.l("). This discards for example fuses, switches, ....
+                #Add to dictionary and to list
+                dict_lines[name] = normal_amps
+                v_lines_norm_amps.append(normal_amps)
+
+        return dict_lines,v_lines_norm_amps
+
+    def get_all_transformers(self):
+        """Gets the size of transformers"""
+        #Init variables
+        dict_transformers = {}
+        myrange=range(0,dss.Transformers.Count())        
+        v_transformers_kva = []
+        #For each transformer
+        for idx in myrange:
+            #Set the transformer index
+            dss.Transformers.Idx(idx+1)
+            #Get the transformer size in kVA
+            kva = dss.Transformers.kVA()
+            #Get the transformer size
+            name = 'Transformer.'+dss.Transformers.Name()
+            #If it is a distribution transformer
+            if name.startswith("Transformer.tr("): #Distribution transformer, RNM-US specific (all distribution transformers start with "Transformer.tr("). This discards for example transformers in primary substations
+                #Add to dictionary and to list
+                dict_transformers[name] = kva
+                v_transformers_kva.append(kva)
+        return dict_transformers,v_transformers_kva
+
+
     def get_all_power(self):
-        """Computes power in all circuits"""
+        """Computes power in all circuits (not used, loading is measured instead)"""
+        #Get all element names
         circuit_names = dss.Circuit.AllElementNames()
+        #Init variables
         dict_power = {}
         v_power = [0 for _ in range(len(circuit_names))]
+        #For each circuit
         for idx,b in enumerate(circuit_names):
+            #Set the active element
             dss.Circuit.SetActiveElement(b)
+            #Calculates the power through the circuit
             power = dss.CktElement.Powers()
             if len(power[::2]) > 0:
                 poweravg = sum(power[::2])/(len(power)/2)
             else:
                 poweravg = 0
+            #Add to dictionary and to list
             dict_power[b] = poweravg
             v_power[idx]=poweravg
 
@@ -74,66 +314,77 @@ class OpenDSS_Interface:
 
     def get_all_loading(self):
         """Computes loading in all circuits"""
+        #Get all element names
         circuit_names = dss.Circuit.AllElementNames()
+        #Init variables
         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 each circuit
         for idx,element in enumerate(circuit_names):
+            #Set the active element
             dss.Circuit.SetActiveElement(element)
-            #only if it is a branch (two buses)
+            #Get the buses in the elment
             buses = dss.CktElement.BusNames()
+            #Evaluate only if it is a branch (two buses)
             if (len(buses)>=2): 
+                #Obtain the current through the element
                 current = dss.CktElement.CurrentsMagAng()
+                #Obtain the number of terminals
                 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
+                #Obtain the current magnitude (first terminal only, because in transformers NormalAmps gives the normal ampacity of the first winding) (to compare the same magnitudes)
                 currentmag = current[0]
+                #Obtain the normal amapcity
                 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;
+                #in particular line code: AmpRatings[i] := 1.1 * kVARatings[i] / Fnphases / Vfactor;
+                #Remove (do not use) the 1.1 margin set in the library to the nominal current
                 if (element.startswith("Transformer")):
-                    nominal_current=nominal_current/1.1
-                if (nominal_current>0):
+                    nominal_current=nominal_current/1.1 
+                #If the element is to be analyzed and has a nominal current (this discards vsources)
+                if (nominal_current>0  and self.is_to_be_analyzed(element)):
+                    #Add to dictionaries and to vector
                     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"""
+        #Get all element names
         circuit_names = dss.Circuit.AllElementNames()
+        #Init variables
         dict_losses = {}
         v_losses = [0 for _ in range(len(circuit_names))]
         total_losses=0
+        #For each element
         for idx,element in enumerate(circuit_names):
+            #Set it as active element
             dss.Circuit.SetActiveElement(element)
-            #only if it is a branch (two buses)
+            #Get buses names in element
             buses = dss.CktElement.BusNames()
+            #only if it is a branch (two buses)
             if (len(buses)>=2): 
-                #next if check discards vsources
+                #Get nominal current
                 nominal_current = dss.CktElement.NormalAmps()
+                #If it has nominal current (this discards vsources)
                 if (nominal_current>0):
+                    #Get hte losses
                     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
+                        lossesavg = (losses[0]) #[0] to take active losses
                     else:
-                        print("error - not correctly reading losses")
+                        print("Error - not correctly reading losses")
                         lossesavg=0          
-                    #Convert to kW. This function is the exeption that return losses in W  
+                    #Convert to kW (becase CktElement.Losses is the exeption that return losses in W)
                     lossesavg=lossesavg/1000 
-                    dict_losses[element] = lossesavg
-                    v_losses[idx]=lossesavg
-        
+                    #If element is to be analized
+                    if self.is_to_be_analyzed(element):
+                        #Add to dictionary an to list
+                        dict_losses[element] = lossesavg
+                        v_losses[idx]=lossesavg        
         return dict_losses,total_losses
 
     def get_total_subs_losses(self):
@@ -141,81 +392,191 @@ class OpenDSS_Interface:
         return dss.Circuit.SubstationLosses()[0]  #Real part
 
     def get_total_line_losses(self):
-        """Computes total line losses"""
+        """Computes total power line losses"""
         return dss.Circuit.LineLosses()[0] #Real part
 
-    def get_edges(self):
-        edges=[]
+    def get_edges(self,v_dict_buses_ids):
+        """Gets the edges of the distribution system (to obtain the graph of the network)"""
+        #Get all element names
         circuit_names = dss.Circuit.AllElementNames()
+        #Init variable
+        closed_edges=[]
+        open_edges=[]
+        #For all elements
         for idx,element in enumerate(circuit_names):
+            #Set it as active element
             dss.Circuit.SetActiveElement(element)
+            #Get the bus names
             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
+                #Avoid cases bus1=bus2 (after removing terminals)
+                if (self.remove_terminal(buses[0])!=self.remove_terminal(buses[1])):
+                    #Identify if enabled #RNM-US specific (open loops are modelled with enabled=n)                
+                    b_enabled=dss.CktElement.Enabled()
+                    #if Enabled (i.e. it it is closed)
+                    if (b_enabled):
+                        #Add to edges
+                        #remove terminal from the bus name (everything to the right of point)
+                        #closed_edges.append([(self.remove_terminal(buses[0]),self.remove_terminal(buses[1]))])                
+                        if (self.b_numeric_ids):
+                            closed_edges.append((v_dict_buses_ids[self.remove_terminal(buses[0])],v_dict_buses_ids[self.remove_terminal(buses[1])]))                
+                        else:
+                            closed_edges.append((self.remove_terminal(buses[0]),self.remove_terminal(buses[1])))                
+                    elif (not b_enabled): #if not Enabled (i.e. it it is open)
+                        #open_edges.append([(self.remove_terminal(buses[0]),self.remove_terminal(buses[1]))])                
+                        if (self.b_numeric_ids):
+                            open_edges.append((v_dict_buses_ids[self.remove_terminal(buses[0])],v_dict_buses_ids[self.remove_terminal(buses[1])]))                
+                        else:
+                            open_edges.append((self.remove_terminal(buses[0]),self.remove_terminal(buses[1])))                
+        return closed_edges,open_edges
+
+
+
+    def is_violation(self,value,v_range):
+        """Obtain number of violations (hours) of a bus"""
+        #Init to zero
+        num=0
+        #If out of range
+        if value<v_range['allowed_range'][0] or value>=v_range['allowed_range'][1]:
+            num=1 #Number of violations=1        
+        else: #Else
+            num=0 #Number of violations=0        
+        return num
 
-    def write_dict(self,v_dict,v_range,type,component):
-        output_file_full_path = self.folder + '/' + type + '_' + component + '.csv'
+
+
+    def get_num_violations(self,v_value,v_range,name,dict_loads):
+        """"Obtain number of violations (hours) of a bus"""
+        #Init to zero
+        num_violations=0
+        #For each value
+        for idx2,value in enumerate(v_value):  
+            #If no dict of loads, add 1 if there is a violation in that value (if it is outside of the allowed range)
+            if (dict_loads is None):
+                num_violations=num_violations+self.is_violation(value,v_range)
+            #If there is a dict of loads
+            elif (name in dict_loads):
+                if (dict_loads[name][idx2]>0): #only compute if there is load
+                    #If there is a vioaltion, add the load (to compute the energy delivered with violations)
+                    num_violations=num_violations+self.is_violation(value,v_range)*dict_loads[name][idx2]
+        return num_violations
+
+
+    def write_dict(self,subfolder,v_dict,v_range,type,component,v_dict_buses_ids,timestamps,v_hours):
+        """Writes the dictionary to a file"""
+        #Path and file name
+        output_file_full_path = self.folder + '/' + subfolder + '/' + 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)
+            #Header: ID, hours 
             for idx,name in enumerate(v_dict):
-                fp.write('Hour,'+','.join(str(idx2) for idx2,value in enumerate(v_dict[name])) + '\n')
+                if (self.b_numeric_ids and not component=='Branches'):
+                    fp.write(',/ '+'Date,'+','.join(str(value) for idx2,value in enumerate(timestamps)) + '\n')
+                    fp.write('Num. ID,bus / '+'Hour,'+','.join(str(value) for value in v_hours) + '\n')
+                else:
+                    fp.write('Date,'+','.join(str(value) for idx2,value in enumerate(timestamps)) + '\n')
+                    fp.write('Hour,'+','.join(str(value) for value in v_hours) + '\n')
                 break
             #Write matrix
             for idx,name in enumerate(v_dict):
-                #Truncate list to limits              
+                #Init list
                 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')
+                #For each one
+                for idx2,value in enumerate(v_dict[name]):                      
+                    #if it is outsie of the allowed range
+                    if not(v_range['allowed_range']) or value<v_range['allowed_range'][0] or value>=v_range['allowed_range'][1]:
+                        truncated_values.append("{:.7f}".format(value)) #Add the value
+                    else: #else
+                        truncated_values.append("")         #Fill with an empty variable
+                #Write to file
+                if v_dict_buses_ids is None or not self.b_numeric_ids:
+                    fp.write(name+','+','.join(truncated_values)+'\n')
+                else:
+                    fp.write(str(v_dict_buses_ids[name])+','+name+','+','.join(truncated_values)+'\n')
 
 
-    def solve_powerflow_iteratively(self,num_periods,start_index,end_index,location,v_range_voltage,v_range_loading):
-        #Por flow solving mode
+    def write_id_dict(self,subfolder,type,v_dict_buses_ids):
+        """Writes the dictionary to a file"""
+        #Path and file name
+        output_file_full_path = self.folder + '/' + subfolder + '/' + type + '.csv'
+        # Write directly as a CSV file with headers on first line
+        with open(output_file_full_path, 'w') as fp:
+            #Header: ID, bus
+            fp.write('Num. ID,bus' + '\n')
+            for idx,name in enumerate(v_dict_buses_ids):
+                fp.write(str(v_dict_buses_ids[name])+','+name+'\n')
+
+
+    def solve_powerflow_iteratively(self,num_periods,start_index,end_index,location,v_range_voltage,v_range_loading,v_range_unbalance):
+        """Solves the power flow iteratively"""
+        #Get timestamps
+        timestamps,timestamps_datetime=self.get_time_stamp()
+        if start_index is None or start_index<0:
+            start_index=0
+        if end_index is None or end_index>len(timestamps):
+            end_index=len(timestamps)
+        v_hours_sim=range(start_index,end_index,1)           #Hours to run OpenDSS
+        v_hours=range(start_index+1,end_index+1,1)           #Hours for outputting
+        #Por flow solving mode (hourly)
         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={}
+        self.dss_run_command("Set mode=yearly stepsize=1h number="+str(start_index+1))
         #Additional initializations
-        my_range=range(start_index,end_index,1)
+        #Init vectors
+        v_months=[[] for _ in range(num_periods)]           #Months
+        v_voltage_yearly=[]                                 #Yearly votlage
+        v_voltage_period=[[] for _ in range(num_periods)]   #Montly voltage
+        v_unbalance_yearly=[]                               #Yearly unbalance
+        v_unbalance_period=[[] for _ in range(num_periods)] #Monthly unbalance
+        v_power_yearly=[]                                   #Yearly power
+        v_power_period=[[] for _ in range(num_periods)]     #Montly pwoer
+        v_loading_yearly=[]                                 #Yearly loading
+        v_loading_period=[[] for _ in range(num_periods)]   #Montly loading
+        v_subs_losses_yearly=[]                             #Yearly substation losses
+        v_line_losses_yearly=[]                             #Yearly power line losses
+        v_loads_kw_yearly=[]                                #Yearly kW of loads (for violing plots)
+        v_loads_kw_period=[[] for _ in range(num_periods)]  #Montly kW of loads (for violing plots)    
+        v_loads_kvar_yearly=[]                              #Yearly kVAr of loads (for violing plots)
+        v_loads_kvar_period=[[] for _ in range(num_periods)]#Montly kVAr of loads (for violing plots)
+        v_total_load_kw_yearly=[]                           #Yearly total kW of loads (for duration curve)
+        v_total_load_kvar_yearly=[]                         #Yearly total kVAr of loads (for duration curve)
+        v_dict_voltage={}                                   #Dict of voltages
+        v_dict_unbalance={}                                 #Dict of unbalances
+        v_dict_loading={}                                   #Dict of loading
+        v_dict_losses={}                                    #Dict of losses
+        v_dict_loads={}                                     #Dict of loads
         old_percentage_str="" #Variable for tracking progress
-        for i in my_range:
-            #Solve power flow
+        #Get buses ids
+        v_dict_buses_ids,v_dict_ids_buses=self.get_all_buses_ids()
+        #For each hour
+        for i in v_hours_sim:
+            #Solve power flow in that hour
             self.dss_run_command("Solve")
+            #Build month vector
+            month=timestamps_datetime[i].month
+            if not month in v_months:
+                v_months[month-1]=month-1
             #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)
+            v_voltage_period=self.extract_period(v_voltage_i,v_voltage_period,i,end_index,num_periods,month)
+            #Get voltage unbalance
+            dict_unbalance_i, v_unbalance_i = self.get_all_unbalance()
+            self.add_to_dictionary(v_dict_unbalance,dict_unbalance_i)
+            v_unbalance_yearly.extend(v_unbalance_i)            
+            v_unbalance_period=self.extract_period(v_unbalance_i,v_unbalance_period,i,end_index,num_periods,month)
             #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)
+            v_power_period=self.extract_period(v_power_i,v_power_period,i,end_index,num_periods,month)
             #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)
+            v_loading_period=self.extract_period(v_loading_i,v_loading_period,i,end_index,num_periods,month)
             #Get dict losses
             dict_losses_i, v_losses_i = self.get_all_losses()
             self.add_to_dictionary(v_dict_losses,dict_losses_i)
@@ -224,11 +585,29 @@ class OpenDSS_Interface:
             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
+            #Get loads shapes
+            dict_loads_i, v_loads_kw_i, v_loads_kvar_i= self.get_all_buses_loads(i)
+            self.add_to_dictionary(v_dict_loads,dict_loads_i)
+            v_loads_kw_yearly.extend(v_loads_kw_i)            
+            v_loads_kw_period=self.extract_period(v_loads_kw_i,v_loads_kw_period,i,end_index,num_periods,month)
+            v_loads_kvar_yearly.extend(v_loads_kvar_i)            
+            v_loads_kvar_period=self.extract_period(v_loads_kvar_i,v_loads_kvar_period,i,end_index,num_periods,month)
+            #Get total peak load
+            v_total_load_kw_yearly.append(sum(v_loads_kw_i))
+            v_total_load_kvar_yearly.append(sum(v_loads_kvar_i))
+            #Print progress (disabled because the Ruby gem does not output the print messages)
             #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
+        #Get loads shapes
+        dict_loads, v_loads_kw, v_loads_kvar= self.get_all_buses_loads(i)
+        #Get lines normal amps
+        dict_lines,v_lines_norm_amps=self.get_all_lines()
+        #Get transformers size
+        dict_transformers,v_transformers_kva=self.get_all_transformers()
+        #Get only the timestamps simulated
+        timestamps=timestamps[start_index:end_index]
+        return v_dict_buses_ids,v_dict_ids_buses,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,v_dict_loads,v_loads_kw_yearly,v_loads_kw_period,v_loads_kvar_yearly,v_loads_kvar_period,v_total_load_kw_yearly,v_total_load_kvar_yearly, v_loads_kw, v_loads_kvar,v_dict_unbalance,v_unbalance_yearly,v_unbalance_period,dict_lines,v_lines_norm_amps,dict_transformers,v_transformers_kva,timestamps,v_months,v_hours