urbanopt-cli 0.8.3 → 0.9.0

data/example_files/scripts/convert_urbanopt_to_disco.py

@@ -0,0 +1,130 @@
+import pandas as pd
+import json
+
+def extract_lines(input_data):
+    """
+        Parameters
+        ----------
+        input_data: dict 
+            The json file representing the input data.
+            i.e. The urbanopt extended catalog that we're parsing
+
+        Returns
+        -------
+        line_attributes: pd.DataFrame
+            The dataframe of the lines in the format of the DISCO cost database
+
+    """
+
+    line_attributes= pd.DataFrame(columns=['Description','phases','voltage_kV','ampere_rating','line_placement','cost_per_m','cost_units'])
+    
+    
+    all_wires = {}
+    for wire in input_data['WIRES']['WIRES CATALOG']:
+        all_wires[wire['nameclass']] = wire
+    
+    all_lines = input_data['LINES']
+    count = 0
+    for zone in all_lines:
+        if not type(zone) == dict:
+            continue
+        for zone_name in zone:
+            for line in zone[zone_name]:
+                wires = line['Line geometry']
+                first_wire_name = wires[0]['wire']
+    
+                Description = line['Name']
+                phases = line['Nphases']
+                voltage_kV = line['Voltage(kV)']
+                wire_type = all_wires[first_wire_name]['type']
+                ampere_rating = all_wires[first_wire_name]['ampacity (A)']
+                if wire_type.startswith('OH'):
+                    line_placement = 'overhead'
+                elif wire_type.startswith('UG'):
+                    line_placement = 'underground'
+                else:
+                    raise ValueError("Unexpected wire type in catalog")
+                cost_per_m = float(line['Investment Cost (dolars/km)'])/1000
+                cost_units = 'USD'
+    
+                line_attributes.loc[count] = [Description,phases,voltage_kV,ampere_rating,line_placement,cost_per_m,cost_units]
+                count+=1
+    
+    return line_attributes
+
+def extract_transformers(input_data):
+    """
+        Parameters
+        ----------
+        input_data: dict 
+            The json file representing the input data.
+            i.e. The urbanopt extended catalog that we're parsing
+
+        Returns
+        -------
+        transformer_attributes: pd.DataFrame
+            The dataframe of the transformers in the format of the DISCO cost database
+
+    """
+
+    transformer_attributes= pd.DataFrame(columns=['phases','primary_kV','secondary_kV','num_windings','primary_connection_type','secondary_connection_type','rated_kVA','cost','cost_units'])
+
+    all_transformers = input_data['SUBSTATIONS AND DISTRIBUTION TRANSFORMERS']
+    count = 0
+    for zone in all_transformers:
+        if not type(zone) == dict:
+            continue
+        for zone_name in zone:
+            for transformer in zone[zone_name]:
+                phases = transformer['Nphases']
+                primary_kV = transformer['Primary Voltage (kV)']
+                secondary_kv = transformer['Secondary Voltage (kV)']
+                if transformer['Centertap']:
+                    num_windings = '3'
+                else:
+                    num_windings = '2'
+                connection_sp = transformer['connection'].split('-')
+                primary_connection_type = connection_sp[0].lower()
+                secondary_connection_type = connection_sp[1].lower()
+                if 'Installed Power(kVA)' in transformer:
+                    rated_kVA = transformer['Installed Power(kVA)']
+                elif 'Installed Power(MVA)' in transformer:
+                    rated_kVA = 1000*float(transformer['Installed Power(MVA)'])
+                else:
+                    raise ValueError("Transformer Rating not found")
+                cost = transformer['Investment Cost (dolars)']
+                cost_units = 'USD/unit'
+
+                transformer_attributes.loc[count] = [phases,primary_kV,secondary_kv,num_windings,primary_connection_type,secondary_connection_type,rated_kVA,cost,cost_units]
+                count+=1
+    return transformer_attributes
+
+
+
+if __name__ == '__main__':
+    input_file = 'extended_catalog.json'
+    output_file = 'cost_database.xlsx'
+
+    input_data = None
+    with open(input_file) as fp:
+        input_data = json.load(fp)
+    
+    output_sheets = ['lines','transformers','control_changes','voltage_regulators','misc','notes']
+
+    print('extracting lines...')
+    lines = extract_lines(input_data)
+    print('extracting transformers...')
+    transformers = extract_transformers(input_data)
+    print('copying control changes...')
+    control_changes = pd.read_csv('default_control_changes.csv',header=0)
+    print('copying voltage regulators...')
+    voltage_regulators = pd.read_csv('default_voltage_regulators.csv',header=0)
+
+    with pd.ExcelWriter(output_file) as writer:
+        lines.to_excel(writer,sheet_name = 'lines',index=False)
+        transformers.to_excel(writer,sheet_name = 'transformers',index=False)
+        control_changes.to_excel(writer,sheet_name = 'control_changes',index=False)
+        voltage_regulators.to_excel(writer,sheet_name = 'voltage_regulators',index=False)
+
+
+

data/example_files/scripts/default_control_changes.csv

@@ -0,0 +1,8 @@
+Type,cost,cost_units
+Change LTC settings,500,USD/unit
+Add new LTC controller,15000,USD/unit
+Change voltage regulator controller settings,500,USD/unit
+Add new voltage regulator controller,15000,USD/unit
+Replace voltage regulator controller,3500,USD/unit
+Change capacitor controller settings,2000,USD/unit
+Replace capacitor controller,3500,USD/unit

data/example_files/scripts/default_voltage_regulators.csv

@@ -0,0 +1,3 @@
+Type,phases,primary_kV,secondary_kV,num_windings,primary_connection_type,secondary_connection_type,rated_kVA,cost,cost_units
+Add new voltage regulator transformer,3,25,25,2,wye,wye,10000,220000,USD/unit
+Add new voltage regulator transformer,3,12.47,12.47,2,wye,wye,10000,150000,USD/unit

data/example_files/scripts/read_data.py

@@ -0,0 +1,331 @@
+import shutil
+import math
+import pandas as pd
+import opendssdirect as dss
+import json
+from ditto.models.line import Line
+from ditto.models.phase_winding import PhaseWinding
+from ditto.models.winding import Winding
+from ditto.models.powertransformer import PowerTransformer
+from ditto.models.wire import Wire
+from ditto.store import Store
+from ditto.writers.opendss.write import Writer
+
+def update_line_format(input_matrix):
+    print(input_matrix)
+    size = math.sqrt(len(input_matrix))
+    if int(size) != size:
+        raise "input matrix is not square"
+    size = int(size)
+    result = ""
+    for i in range(size):
+        for j in range(i+1):
+            result += str(input_matrix[j+i*size])
+            result += " "
+        if i != size-1:
+            result+= "|"
+    return [result.strip()]
+
+def get_lines():
+    line_flag = dss.Lines.First()
+    pdelement_flag = dss.PDElements.First()
+    dss.Circuit.SetActiveClass('Line')
+    data = []
+    while line_flag:
+        data_dump = dss.utils.class_to_dataframe('Line')
+        datum = {}
+        datum['name'] = dss.Lines.Name()
+        datum['rmatrix'] = update_line_format(dss.Lines.RMatrix() )
+        datum['xmatrix'] = update_line_format(dss.Lines.XMatrix() )
+        datum['cmatrix'] = update_line_format(dss.Lines.CMatrix() )
+        datum['Rg'] = dss.Lines.Rg()
+        datum['Xg'] = dss.Lines.Xg()
+        datum['r1'] = dss.Lines.R1()
+        datum['x1'] = dss.Lines.X1()
+#        datum['c1'] = dss.Lines.C1()
+        #datum['B1'] = dss.Lines.B1()
+        datum['r0'] = dss.Lines.R0()
+        datum['x0'] = dss.Lines.X0()
+#        datum['c0'] = dss.Lines.C0()
+        #datum['B0'] = dss.Lines.B0()
+        datum['rho'] = dss.Lines.Rho()
+        datum['emergamps'] = dss.Lines.EmergAmps()
+        datum['normamps'] = dss.Lines.NormAmps()
+        datum['phases'] = dss.Lines.Phases()
+        datum['Switch'] = dss.Lines.IsSwitch()
+        if datum['Switch']:
+            datum['Switch'] = "Yes"
+        else:
+            datum['Switch'] = "No"
+        datum['linecode'] = dss.Lines.LineCode()
+
+
+        datum['Ratings'] = data_dump['Ratings'].iloc[0]
+        datum['units'] = data_dump['units'].iloc[0]
+        datum['Seasons'] = data_dump['Seasons'].iloc[0]
+        datum['EarthModel'] = data_dump['EarthModel'].iloc[0]
+        datum['B0'] = data_dump['B0'].iloc[0]
+        datum['B1'] = data_dump['B1'].iloc[0]
+        datum['geometry'] = "" #data_dump['geometry'].iloc[0]
+        datum['linecode'] = data_dump['linecode'].iloc[0]
+        datum['tscables'] = data_dump['tscables'].iloc[0]
+        datum['cncables'] = data_dump['cncables'].iloc[0]
+        datum['wires'] = data_dump['wires'].iloc[0]
+
+        datum['faultrate'] = dss.PDElements.FaultRate()
+        datum['pctperm'] = dss.PDElements.PctPermanent()
+        datum['repair'] = dss.PDElements.RepairTime()
+
+        sources_flag = dss.Vsources.First()
+        datum['basefreq'] = dss.Vsources.Frequency()
+
+        for key in datum:
+            print(key,datum[key])
+        line_flag = dss.Lines.Next()
+        pdelement_flag = dss.PDElements.Next()
+        data.append(datum)
+    return data
+
+
+def get_transformers():
+    transformer_flag = dss.Transformers.First()
+    pdelement_flag = dss.PDElements.First()
+    dss.Circuit.SetActiveClass('Transformer')
+    data = []
+    while transformer_flag:
+        data_dump = dss.utils.class_to_dataframe('Transformer')
+        datum = {}
+        datum['name'] = dss.Transformers.Name()
+        datum['windings'] = dss.Transformers.NumWindings()
+        datum['wdg'] = dss.Transformers.NumWindings()
+        if dss.Transformers.IsDelta():
+            datum['conn'] = 'delta'
+        else:
+            datum['conn'] = 'wye'
+        datum['kV'] = dss.Transformers.kV()
+        datum['kVA'] = dss.Transformers.kVA()
+        datum['tap'] = dss.Transformers.Tap()
+        datum['%R'] = dss.Transformers.R()
+        datum['Rneut'] = dss.Transformers.Rneut()
+        datum['Xneut'] = dss.Transformers.Xneut()
+        datum['XHL'] = dss.Transformers.Xhl()
+        datum['XHT'] = dss.Transformers.Xht()
+        datum['XLT'] = dss.Transformers.Xlt()
+        datum['X12'] = dss.Transformers.Xhl()
+        datum['X13'] = dss.Transformers.Xht()
+        datum['X23'] = dss.Transformers.Xlt()
+        datum['MaxTap'] = dss.Transformers.MaxTap()
+        datum['MinTap'] = dss.Transformers.MinTap()
+        datum['NumTaps'] = dss.Transformers.NumTaps()
+        datum['emergamps'] = dss.CktElement.EmergAmps()
+
+        datum['ppm_antifloat'] = data_dump['ppm_antifloat'].iloc[0]
+        datum['Core'] = data_dump['Core'].iloc[0]
+        datum['LeadLag'] = data_dump['LeadLag'].iloc[0]
+        datum['thermal'] = data_dump['thermal'].iloc[0]
+        datum['hsrise'] = data_dump['hsrise'].iloc[0]
+        datum['flrise'] = data_dump['flrise'].iloc[0]
+        datum['normamps'] = data_dump['normamps'].iloc[0]
+        datum['kVs'] = data_dump['kVs'].iloc[0]
+        datum['kVAs'] = data_dump['kVAs'].iloc[0]
+        datum['conns'] = data_dump['conns'].iloc[0]
+        datum['taps'] = data_dump['taps'].iloc[0]
+        datum['Xscarray'] = data_dump['Xscarray'].iloc[0]
+        datum['Xscarray'] = [ i for i in datum['Xscarray'][0].split()]
+        datum['m'] = data_dump['m'].iloc[0]
+        datum['n'] = data_dump['n'].iloc[0]
+        datum['phases'] = data_dump['phases'].iloc[0]
+        datum['%loadloss'] = data_dump['%loadloss'].iloc[0]
+        datum['RdcOhms'] = data_dump['RdcOhms'].iloc[0]
+        datum['%imag'] = data_dump['%imag'].iloc[0]
+        datum['Ratings'] = data_dump['Ratings'].iloc[0]
+        datum['Seasons'] = data_dump['Seasons'].iloc[0]
+        datum['XRConst'] = data_dump['XRConst'].iloc[0]
+        datum['emerghkVA'] = data_dump['emerghkVA'].iloc[0]
+        datum['normhkVA'] = data_dump['normhkVA'].iloc[0]
+        datum['%Rs'] = data_dump['%Rs'].iloc[0]
+        # taken from here: https://github.com/NREL/disco/blob/main/disco/extensions/upgrade_simulation/upgrades/common_functions.py#L867
+        if datum['phases'] == 1:
+            datum['amp_limit_per_phase'] = float(datum['kVAs'][0]) / float(datum['kVs'][0])
+        else:
+            datum['amp_limit_per_phase'] = float(datum['kVAs'][0]) / (float(datum['kVs'][0]) * math.sqrt(3))
+
+        datum['faultrate'] = dss.PDElements.FaultRate()
+        datum['pctperm'] = dss.PDElements.PctPermanent()
+        datum['repair'] = dss.PDElements.RepairTime()
+
+        sources_flag = dss.Vsources.First()
+        datum['basefreq'] = dss.Vsources.Frequency()
+        for key in datum:
+            print(key,datum[key])
+        transformer_flag = dss.Transformers.Next()
+        pdelement_flag = dss.PDElements.Next()
+        data.append(datum)
+    return data
+
+with open('extended_catalog.json','r') as f:
+    catalog = json.load(f)
+
+technical_catalog = {'line':[], 'transformer': [] }
+
+all_lines = catalog["LINES"][1]["#Interurban Zone A:"]
+all_transformers = catalog["SUBSTATIONS AND DISTRIBUTION TRANSFORMERS"]
+all_wires = {}
+for wire in catalog["WIRES"]["WIRES CATALOG"]:
+    all_wires[wire['nameclass']] = wire
+
+
+for line in all_lines:
+    model = Store()
+    ditto_line = Line(model)
+    ditto_line.name = line['Name']
+    ditto_line.nomial_voltage = float(line["Voltage(kV)"])*1000/math.sqrt(3)
+    ditto_line.from_element = 'DummyFrom'
+    ditto_line.to_element = 'DummyTo'
+    ditto_line.length = 1
+    wires = []
+    height = 0 #Set to last wire
+    for wire in line['Line geometry']:
+        ditto_wire = Wire(model)
+        ditto_wire.nameclass = wire['wire'].replace(" ","_")
+        ditto_wire.X = wire['x (m)']
+        ditto_wire.Y = wire['height (m)']
+        ditto_wire.phase = wire['phase']
+        height = wire['height (m)']
+        if ditto_wire.phase == 'S1':
+            ditto_wire.phase = 'A'
+        if ditto_wire.phase == 'S2':
+            ditto_wire.phase = 'B'
+
+        wire_data = all_wires[wire['wire']]
+        ditto_wire.diameter = wire_data['diameter (mm)']*0.001
+        ditto_wire.ampacity = wire_data['ampacity (A)']
+        ditto_wire.gmr = wire_data['gmr (mm)']*0.001
+        ditto_wire.resistance = wire_data['resistance (ohm/km)']/1000
+
+        if '# concentric neutral strands' in wire_data:
+            ditto_wire.concentric_neutral_nstrand = wire_data['# concentric neutral strands']
+            ditto_wire.concentric_neutral_resistance = wire_data['resistance neutral (ohm/km)']
+            ditto_wire.concentric_neutral_diameter = wire_data['concentric diameter neutral strand (mm)']*0.001
+            ditto_wire.concentric_neutral_outside_diameter = wire_data['concentric neutral outside diameter (mm)']*0.001
+            ditto_wire.concentric_neutral_gmr = wire_data['gmr neutral (mm)']*0.001
+            ditto_wire.insulation_thickness = 10*0.001 #no insulation thickness provided so use 10mm
+        wires.append(ditto_wire)
+    ditto_line.wires = wires
+    if height > 0:
+        ditto_line.line_type = 'overhead'
+    else:
+        ditto_line.line_type = 'underground'
+
+
+    writer = Writer(output_path='test_output')
+    writer.write(model)
+    result = dss.run_command("redirect test_output/Master.dss")
+    print(result)
+    #import pdb;pdb.set_trace()
+    data = get_lines()
+    if len(data) !=1:
+        raise("too many lines")
+    data = data[0]
+    data['kV'] = float(line["Voltage(kV)"])
+    if data['kV'] >= 0.47:
+        data['kV'] = data['kV']/math.sqrt(3)
+    data['h'] = height
+    data["line_definition_type"] =  "line_definition"
+    if height > 0:
+        data['line_placement'] = 'overhead'
+    else:
+        data['line_placement'] = 'underground'
+    technical_catalog['line'].append(data)
+    shutil.rmtree('test_output')
+
+for region in all_transformers:
+    for key in region:
+        for transformer in region[key]:
+            model = Store()
+            ditto_transformer = PowerTransformer(model)
+            ditto_transformer.name = transformer['Name']
+            ditto_transformer.noload_loss = float(transformer['No load losses(kW)'])
+            ditto_transformer.from_element = 'Dummy1'
+            ditto_transformer.to_element  = 'Dummy2'
+            ditto_transformer.is_center_tap = transformer['Centertap']
+            if 'Installed Power(MVA)' in transformer:
+                ditto_transformer.normhkva = float(transformer['Installed Power(MVA)']) *1000
+            else:
+                ditto_transformer.normhkva = float(transformer['Installed Power(kVA)'])
+            
+            if ditto_transformer.is_center_tap:
+                ditto_transformer.reactances = [float(transformer['Reactance (p.u. transf)']),float(transformer['Reactance (p.u. transf)']),float(transformer['Reactance (p.u. transf)'])]
+            else:
+                ditto_transformer.reactances = [float(transformer['Reactance (p.u. transf)'])]
+
+            windings = []
+            winding1 = Winding(model)
+            connection = transformer['connection'].split('-')[0].lower()
+            if connection == 'delta':
+                winding1.connection_type = 'D'
+            if connection == 'wye':
+                winding1.connection_type = 'Y'
+            winding1.voltage_type = 0
+            winding1.nominal_voltage = float(transformer['Primary Voltage (kV)']) *1000
+            phase_windings1 = []
+            for phase in range(int(transformer['Nphases'])):
+                phase_winding = PhaseWinding(model)
+                phase_winding.phase = chr(ord('A')+phase)
+                phase_windings1.append(phase_winding)
+            winding1.phase_windings = phase_windings1
+            windings.append(winding1)
+
+            winding2 = Winding(model)
+            connection = transformer['connection'].split('-')[1].lower()
+            if connection == 'delta':
+                winding2.connection_type = 'D'
+            if connection == 'wye':
+                winding2.connection_type = 'Y'
+            winding2.voltage_type = 1
+            winding2.nominal_voltage = float(transformer['Secondary Voltage (kV)']) *1000
+            phase_windings2 = []
+            for phase in range(int(transformer['Nphases'])):
+                phase_winding = PhaseWinding(model)
+                phase_winding.phase = chr(ord('A')+phase)
+                phase_windings2.append(phase_winding)
+            winding2.phase_windings = phase_windings2
+            windings.append(winding2)
+
+            if ditto_transformer.is_center_tap:
+                winding3 = Winding(model)
+                connection = transformer['connection'].split('-')[1].lower()
+                if connection == 'delta':
+                    winding3.connection_type = 'D'
+                if connection == 'wye':
+                    winding3.connection_type = 'Y'
+                winding3.voltage_type = 1
+                winding3.nominal_voltage = float(transformer['Secondary Voltage (kV)']) *1000
+                phase_windings3 = []
+                for phase in range(int(transformer['Nphases'])):
+                    phase_winding = PhaseWinding(model)
+                    phase_winding.phase = chr(ord('A')+phase)
+                    phase_windings3.append(phase_winding)
+                winding3.phase_windings = phase_windings3
+                windings.append(winding3)
+            ditto_transformer.windings = windings
+
+            writer = Writer(output_path='test_output')
+            writer.write(model)
+            result = dss.run_command("redirect test_output/Master.dss")
+            print(result)
+            data = get_transformers()
+            if len(data) !=1:
+                raise("too many lines")
+            data = data[0]
+            data['%noloadloss'] = float(transformer['No load losses(kW)'])
+            if transformer['Voltage level'] == 'HV-MV':
+                data['sub'] = "y"
+            else:
+                data['sub'] = "n"
+
+            technical_catalog['transformer'].append(data)
+            shutil.rmtree('test_output')
+
+with open('technical_catalog.json','w') as f:
+    json.dump(technical_catalog, f, indent=4)