def apply(cls, stack, *args, **kwargs): if 'base_dir' in kwargs: base_dir = kwargs['base_dir'] else: base_dir = './' #if not os.path.exists(os.path.join(base_dir,cyme_location)): # raise ValueError("No folder exists at {}".format(os.path.join(base_dir,cyme_location))) if 'network_filename' in kwargs: network_filename = kwargs['network_filename'] else: network_filename = 'network.txt' #Default if 'equipment_filename' in kwargs: equipment_filename = kwargs['equipment_filename'] else: equipment_filename = 'equipment.txt' #Default if 'load_filename' in kwargs: load_filename = kwargs['load_filename'] else: load_filename = 'load.txt' #Default base_model = Store() reader = CymeReader(data_folder_path=base_dir, network_filename=network_filename, equipment_filename=equipment_filename, load_filename=load_filename) reader.parse(base_model) base_model.set_names() stack.model = base_model return True
def test_opendss_to_json(): """Test the JSON writer with OpenDSS models as input.""" from ditto.readers.opendss.read import Reader from ditto.store import Store from ditto.writers.json.write import Writer opendss_models = [ f for f in os.listdir( os.path.join(current_directory, "data/small_cases/opendss/")) if not f.startswith(".") ] for model in opendss_models: m = Store() r = Reader( master_file=os.path.join( current_directory, "data/small_cases/opendss/{model}/master.dss".format( model=model), ), buscoordinates_file=os.path.join( current_directory, "data/small_cases/opendss/{model}/buscoord.dss".format( model=model), ), ) r.parse(m) m.set_names() output_path = tempfile.TemporaryDirectory() w = Writer(output_path=output_path.name) w.write(m)
def test_lines_write(): m = Store() r = Reader( master_file=os.path.join( current_directory, "../../../readers/opendss/Lines/test_linegeometries.dss" ) ) r.parse(m) m.set_names() output_path = tempfile.gettempdir() jw = Json_Writer(output_path=output_path) jw.write(m) w = Writer(output_path=output_path) w.write(m) # Check that the OpenDSS writer created a Master file assert os.path.exists(os.path.join(output_path, "Master.dss")) r_w = Reader(master_file=os.path.join(output_path, "Master.dss")) r_w.parse(m) m.set_names() jw = Json_Writer(output_path="./") jw.write(m) with open(os.path.join(output_path, "Model.json"), "r") as f1: reader_json = json.load(f1) with open("./Model.json", "r") as f2: writer_json = json.load(f2) assert reader_json["model"] == writer_json["model"]
def test_opendss_to_ephasor(): ''' Test the OpenDSS to Ephasor conversion. ''' from ditto.readers.opendss.read import Reader from ditto.store import Store from ditto.writers.ephasor.write import Writer opendss_models=[f for f in os.listdir(os.path.join(current_directory, 'data/small_cases/opendss/')) if not f.startswith('.')] for model in opendss_models: m = Store() r = Reader( master_file=os.path.join(current_directory, 'data/small_cases/opendss/{model}/master.dss'.format(model=model)), buscoordinates_file=os.path.join(current_directory, 'data/small_cases/opendss/{model}/buscoord.dss'.format(model=model)) ) r.parse(m) m.set_names() m.build_networkx() m.direct_from_source() m.set_node_voltages() #TODO: Log properly print('>OpenDSS model {model} red...'.format(model=model)) output_path = tempfile.TemporaryDirectory() w = Writer(output_path=output_path) w.write(m) #TODO: Log properly print('>...and written to Ephasor.\n')
def test_opendss_to_gridlabd(): ''' Test the OpenDSS to GridlabD conversion. ''' from ditto.readers.opendss.read import Reader from ditto.store import Store from ditto.writers.gridlabd.write import Writer opendss_models = [ f for f in os.listdir( os.path.join(current_directory, 'data/small_cases/opendss/')) if not f.startswith('.') ] for model in opendss_models: m = Store() r = Reader(master_file=os.path.join( current_directory, 'data/small_cases/opendss/{model}/master.dss'.format(model=model)), buscoordinates_file=os.path.join( current_directory, 'data/small_cases/opendss/{model}/buscoord.dss'.format( model=model))) r.parse(m) m.set_names() #TODO: Log properly print('>OpenDSS model {model} red...'.format(model=model)) t = tempfile.TemporaryDirectory() w = Writer(output_path=t.name) w.write(m) #TODO: Log properly print('>...and written to GridLabD.\n')
def test_remove_opendss_default_values(): m = Store() r = Reader( master_file=os.path.join(current_directory, "test_default_values.dss"), remove_opendss_default_values_flag=True, ) r.parse(m) m.set_names() assert m["line1"].faultrate == None assert m["line1"].impedance_matrix == None assert m["line1"].capacitance_matrix == None assert m["cap1"].connection_type == None assert m["cap1"].low == None assert m["cap1"].high == None assert m["cap1"].delay == None assert m["cap1"].pt_ratio == None assert m["cap1"].ct_ratio == None assert m["cap1"].pt_phase == None assert m["reg1"].reactances == None assert m["regulator_reg1"].ct_prim == None assert m["regulator_reg1"].delay == None assert m["regulator_reg1"].highstep == None assert m["regulator_reg1"].pt_ratio == None assert m["regulator_reg1"].bandwidth == None assert m["regulator_reg1"].bandcenter == None assert m["load_load1"].connection_type == None assert m["load_load1"].vmin == None assert m["load_load1"].vmax == None
def test_nodes(): from ditto.store import Store from ditto.readers.opendss.read import Reader # test on the test_nodes.dss m = Store() r = Reader( master_file=os.path.join(current_directory, "test_nodes.dss"), buscoordinates_file=os.path.join(current_directory, "buscoord.dss"), ) r.parse(m) m.set_names() assert (m["bus1"].name) == "bus1" assert (m["bus1"].nominal_voltage) == None assert (m["bus1"].positions[0].long) == float(300) assert (m["bus1"].positions[0].lat) == float(400) assert (m["bus1"].positions[0].elevation) == 0 assert (m["bus1"].feeder_name) == "sourcebus_src" assert (m["sourcebus"].name) == "sourcebus" assert (m["sourcebus"].nominal_voltage) == None assert (m["sourcebus"].positions[0].long) == float(1674346.56814483) assert (m["sourcebus"].positions[0].lat) == float(12272927.0644858) assert (m["sourcebus"].positions[0].elevation) == 0 assert (m["sourcebus"].feeder_name) == "sourcebus_src" assert (m["b1"].name) == "b1" assert (m["b1"].nominal_voltage) == None assert (m["b1"].positions[0].long) == float(1578139) assert (m["b1"].positions[0].lat) == float(14291312) assert (m["b1"].positions[0].elevation) == 0 assert (m["b1"].feeder_name) == "sourcebus_src"
def test_load_p_and_q(): m = Store() r = Reader(master_file=os.path.join(current_directory, "test_load_p_and_q.dss")) r.parse(m) m.set_names() # P and Q values should be equally divided accross phase loads # Here we sum P and Q and check that the obtained values match the values in the DSS file # precision = 0.001 assert len(m["load_load1"].phase_loads) == 3 # Load1 is a three phase load assert sum( [phase_load.p for phase_load in m["load_load1"].phase_loads] ) == pytest.approx(5400 * 10 ** 3, precision) assert sum( [phase_load.q for phase_load in m["load_load1"].phase_loads] ) == pytest.approx(4285 * 10 ** 3, precision) assert len(m["load_load2"].phase_loads) == 3 # Load2 is a three phase load assert sum( [phase_load.p for phase_load in m["load_load2"].phase_loads] ) == pytest.approx(3466 * 10 ** 3, precision) assert sum( [phase_load.q for phase_load in m["load_load2"].phase_loads] ) == pytest.approx(3466.0 * math.sqrt(1.0 / 0.9 ** 2 - 1) * 10 ** 3, precision) assert len(m["load_load3"].phase_loads) == 2 # Load3 is a two phase load assert sum( [phase_load.p for phase_load in m["load_load3"].phase_loads] ) == pytest.approx(1600 * 10 ** 3, precision) assert sum( [phase_load.q for phase_load in m["load_load3"].phase_loads] ) == pytest.approx(980 * 10 ** 3, precision) assert len(m["load_load4"].phase_loads) == 2 # Load4 is a two phase load assert sum( [phase_load.p for phase_load in m["load_load4"].phase_loads] ) == pytest.approx(1555 * 10 ** 3, precision) assert sum( [phase_load.q for phase_load in m["load_load4"].phase_loads] ) == pytest.approx(1555.0 * math.sqrt(1.0 / 0.95 ** 2 - 1) * 10 ** 3, precision) assert len(m["load_load5"].phase_loads) == 1 # Load5 is a one phase load assert sum( [phase_load.p for phase_load in m["load_load5"].phase_loads] ) == pytest.approx(650 * 10 ** 3, precision) assert sum( [phase_load.q for phase_load in m["load_load5"].phase_loads] ) == pytest.approx(500.5 * 10 ** 3, precision) assert len(m["load_load6"].phase_loads) == 1 # Load6 is a one phase load assert sum( [phase_load.p for phase_load in m["load_load6"].phase_loads] ) == pytest.approx(623.21 * 10 ** 3, precision) assert sum( [phase_load.q for phase_load in m["load_load6"].phase_loads] ) == pytest.approx(623.21 * math.sqrt(1.0 / 0.85 ** 2 - 1) * 10 ** 3, precision)
def test_metric_extraction(): """ This test reads all small OpenDSS test cases, set the nominal voltages using a system_structure_modifier object and compute all metrics using a network analyzer object. Finally, it exports the metrics to excel and Json formats. """ from ditto.readers.opendss.read import Reader from ditto.store import Store from ditto.modify.system_structure import system_structure_modifier from ditto.metrics.network_analysis import NetworkAnalyzer as network_analyzer opendss_models = [ f for f in os.listdir( os.path.join(current_directory, "data/small_cases/opendss/")) if not f.startswith(".") ] opendss_models.remove("storage_test") for model in opendss_models: m = Store() r = Reader( master_file=os.path.join( current_directory, "data/small_cases/opendss/{model}/master.dss".format( model=model), ), buscoordinates_file=os.path.join( current_directory, "data/small_cases/opendss/{model}/buscoord.dss".format( model=model), ), ) r.parse(m) m.set_names() # Create a modifier object modifier = system_structure_modifier(m) # And set the nominal voltages of the elements since we don't have it from OpenDSS modifier.set_nominal_voltages_recur() modifier.set_nominal_voltages_recur_line() # Create a Network analyszer object with the modified model net = network_analyzer(modifier.model, True, "sourcebus") net.model.set_names() # Compute all the available metrics net.compute_all_metrics() output_path = tempfile.gettempdir() # Export them to excel net.export(os.path.join(output_path, "metrics.xlsx")) # Export them to JSON net.export_json(os.path.join(output_path, "metrics.json"))
def dssToGridLab(inFilePath, outFilePath, busCoords=None): ''' Convert dss file to gridlab. ''' model = Store() #TODO: do something about busCoords: dss_reader = dReader(master_file = inFilePath) dss_reader.parse(model) model.set_names() glm_writer = gWriter(output_path=".") # TODO: no way to specify output filename, so move and rename. glm_writer.write(model)
def gridLabToDSS(inFilePath, outFilePath): ''' Convert gridlab file to dss. ''' model = Store() # HACK: the gridlab reader can't handle brace syntax that ditto itself writes... # command = 'sed -i -E "s/{/ {/" ' + inFilePath # os.system(command) gld_reader = gReader(input_file = inFilePath) gld_reader.parse(model) model.set_names() dss_writer = dWriter(output_path=".") # TODO: no way to specify output filename, so move and rename. dss_writer.write(model)
def test_default_values(): m = Store() r = Reader( master_file=os.path.join(current_directory, "test_default_values.dss"), default_values_file=os.path.join(current_directory, "test_default_values.json"), ) r.parse(m) m.set_names() assert m["line1"].faultrate == 0.2 assert m["line1"].impedance_matrix == [ [(0.00113148 + 0.000884886j), (0.000142066 + 0.000366115j)], [(0.000142066 + 0.000366115j), (0.00113362 + 0.000882239j)], ] assert m["line1"].capacitance_matrix == [ [(0.00733718 + 0j), (-0.00239809 + 0j)], [(-0.00239809 + 0j), (0.00733718 + 0j)], ] phased_wires = {} for wire in m["line1"].wires: phased_wires[wire.phase] = wire # Ampacity for p in ["A", "B", "C"]: assert phased_wires[p].ampacity == 200 assert phased_wires[p].emergency_ampacity == 400 assert m["cap1"].connection_type == "Y" assert m["cap1"].low == 114 assert m["cap1"].high == 125 assert m["cap1"].delay == 10 assert m["cap1"].pt_ratio == 50 assert m["cap1"].ct_ratio == 50 assert m["cap1"].pt_phase == "A" assert m["reg1"].reactances == [6] assert m["regulator_reg1"].ct_prim == 300 assert m["regulator_reg1"].delay == 16 assert m["regulator_reg1"].highstep == 15 assert m["regulator_reg1"].pt_ratio == 60 assert m["regulator_reg1"].bandwidth == 3 assert m["regulator_reg1"].bandcenter == 130 assert m["load_load1"].connection_type == "Y" assert m["load_load1"].vmin == 0.95 assert m["load_load1"].vmax == 1.05
def test_linegeometries(): m = Store() r = Reader(master_file=os.path.join(current_directory, "test_linegeometries.dss")) r.parse(m) m.set_names() # Number of wires assert len(m["line1"].wires) == 4 # Line1 should have 4 wires # Phases of the different wires assert set([w.phase for w in m["line1"].wires]) == set(["A", "B", "C", "N"]) phased_wires = {} for wire in m["line1"].wires: phased_wires[wire.phase] = wire # Nameclass for p in ["A", "B", "C"]: assert phased_wires[p].nameclass == "ACSR336" assert phased_wires["N"].nameclass == "ACSR1/0" # Positions of the wires assert (phased_wires["A"].X, phased_wires["A"].Y) == (-1.2909, 13.716) assert (phased_wires["B"].X, phased_wires["B"].Y) == ( -0.1530096 * 0.3048, 4.1806368 * 0.3048, ) assert (phased_wires["C"].X, phased_wires["C"].Y) == (0.5737, 13.716) assert (phased_wires["N"].X, phased_wires["N"].Y) == (0.0, 14.648) # GMR for p in ["A", "B", "C"]: assert phased_wires[p].gmr == 0.0255 * 0.3048 assert phased_wires["N"].gmr == 0.00446 * 0.3048 # Diameter for p in ["A", "B", "C"]: assert phased_wires[p].diameter == 0.741 * 0.0254 assert phased_wires["N"].diameter == 0.398 * 0.0254 # Resistance # TODO: Change this once the resistance of a Wire object will no longer be the total # resistance, but the per meter resistance... # for p in ["A", "B", "C"]: assert phased_wires[p].resistance == pytest.approx( 0.306 * 0.000621371 * 300 * 0.3048, 0.00001 ) assert phased_wires["N"].resistance == pytest.approx( 1.12 * 0.000621371 * 300 * 0.3048, 0.00001 )
def apply(cls, stack, *args, **kwargs): if 'base_dir' in kwargs: base_dir = kwargs['base_dir'] else: base_dir = './' if 'input_filename' in kwargs: input_filename = kwargs['input_filename'] else: input_filename = 'full_model.json' #Default base_model = Store() reader = JsonReader(input_file = os.path.join(base_dir,input_filename)) reader.parse(base_model) base_model.set_names() stack.model = base_model return True
def test_opendss_transformer(): opendss_test_data = """ Clear new circuit.IEEE13 ~ basekv=4.16 pu=1.0000 phases=3 bus1=SourceBus ~ Angle=0 ~ MVAsc3=200000 MVASC1=200000 ! stiffen the source to approximate inf source New Transformer.reg Phases=3 Windings=2 XHL=0.01 ~ wdg=1 bus=Sourcebus.1.2.3.0 conn=Wye kv=4.16 kva=5000 %r=0.000498 XHT=.00498 ~ wdg=2 bus=651.1.2.3 conn=Wye kv=4.16 kva=5000 %r=0.000498 XLT=.00498 New Transformer.XFM1 Phases=3 Windings=2 XHL=2 ~ wdg=1 bus=633.1.2.3.0 conn=Wye kv=4.16 kva=500 %r=.55 XHT=1 ~ wdg=2 bus=634.1.2.3 conn=Wye kv=0.480 kva=500 %r=.55 XLT=1 """ master_file = os.path.join(tempfile.gettempdir(), os.urandom(24).hex()) # TODO: figure out why named temporary file doesn't work as expected on windows # master_file = tempfile.NamedTemporaryFile(mode="w") with open(master_file, "w") as f: f.write(opendss_test_data) m = Store() r = Reader(master_file=master_file, ) r.parse(m) m.set_names() for t in m.iter_models(type=PowerTransformer): assert len(t.windings) == 2 assert t.windings[0].is_grounded is True assert t.windings[1].is_grounded is False output_path = tempfile.TemporaryDirectory() w = Writer(output_path=output_path.name) w.write(m) with open(os.path.join(output_path.name, "Transformers.dss")) as f: string = f.read() assert "sourcebus.1.2.3.0" in string assert "651.1.2.3.0" not in string assert "651.1.2.3" in string assert "633.1.2.3.0" in string assert "634.1.2.3.0" not in string assert "634.1.2.3" in string
def test_opendss_center_transformer(): opendss_test_data = """ Clear new circuit.IEEE13 ~ basekv=4.16 pu=1.0000 phases=3 bus1=SourceBus ~ Angle=0 ~ MVAsc3=200000 MVASC1=200000 ! stiffen the source to approximate inf source New Transformer.Example1-ph phases=1 Windings=3 ~ Xhl=2.04 Xht=2.04 Xlt=1.36 %noloadloss=.2 ~ Buses=[bus1.1.2 bus2.1.0 bus2.0.2] ! mid-point of secondary is grounded ~ kVs=[12.47 .12 .12] ! ratings of windings ~ kVAs=[25 25 25] ~ %Rs = [0.6 1.2 1.2] ~ conns=[delta wye wye] """ master_file = os.path.join(tempfile.gettempdir(), os.urandom(24).hex()) # TODO: figure out why named temporary file doesn't work as expected on windows # master_file = tempfile.NamedTemporaryFile(mode="w") with open(master_file, "w") as f: f.write(opendss_test_data) m = Store() r = Reader(master_file=master_file) r.parse(m) m.set_names() for t in m.iter_models(type=PowerTransformer): assert len(t.windings) == 3 assert t.windings[0].is_grounded is False assert t.windings[1].is_grounded is False assert t.windings[2].is_grounded is False output_path = tempfile.TemporaryDirectory() w = Writer(output_path=output_path.name) w.write(m) with open(os.path.join(output_path.name, "Transformers.dss")) as f: string = f.read() assert "bus1.1.2 " in string assert "bus2.1.0 " in string assert "bus2.0.2 " in string
def test_json_serialize_deserialize(): """Write a model to JSON, read it back in, and test that both models match.""" from ditto.readers.opendss.read import Reader from ditto.store import Store from ditto.writers.json.write import Writer from ditto.readers.json.read import Reader as json_reader opendss_models = [ f for f in os.listdir( os.path.join(current_directory, "data/small_cases/opendss/")) if not f.startswith(".") ] opendss_models.remove("storage_test") for model in opendss_models: m = Store() r = Reader( master_file=os.path.join( current_directory, "data/small_cases/opendss/{model}/master.dss".format( model=model), ), buscoordinates_file=os.path.join( current_directory, "data/small_cases/opendss/{model}/buscoord.dss".format( model=model), ), ) r.parse(m) m.set_names() w = Writer(output_path="./") w.write(m) jr = json_reader(input_file="./Model.json") jr.parse(m) jr.model.set_names() for obj in m.models: if hasattr(obj, "name"): json_obj = jr.model[obj.name] assert compare(obj, json_obj) for json_obj in jr.model.models: if hasattr(json_obj, "name"): obj = m[json_obj.name] assert compare(json_obj, obj) os.remove("./Model.json")
def test_capacitor_kvar(): m = Store() r = Reader( master_file=os.path.join(current_directory, "test_capacitor_kvar.dss")) r.parse(m) m.set_names() assert len( m["cap1"].phase_capacitors) == 3 # Cap1 is a three phase capacitor assert sum([ phase_capacitor.var for phase_capacitor in m["cap1"].phase_capacitors ]) == pytest.approx(600 * 10**3, 0.0001) assert len( m["cap2"].phase_capacitors) == 1 # Cap2 is a one phase capacitor assert m["cap2"].phase_capacitors[0].var == 100 * 10**3 assert len( m["cap3"].phase_capacitors) == 1 # Cap3 is a one phase capacitor assert m["cap3"].phase_capacitors[0].var == 200.37 * 10**3
def test_cyme_to_json(): """Test the JSON writer with CYME models as input.""" from ditto.readers.cyme.read import Reader from ditto.store import Store from ditto.writers.json.write import Writer cyme_models = [ f for f in os.listdir( os.path.join(current_directory, "data/small_cases/cyme/")) if not f.startswith(".") ] for model in cyme_models: m = Store() r = Reader(data_folder_path=os.path.join( current_directory, "data/small_cases/cyme", model)) r.parse(m) m.set_names() output_path = tempfile.TemporaryDirectory() w = Writer(output_path=output_path.name) w.write(m)
def test_demo_to_gridlabd(): from ditto.readers.demo.read import Reader from ditto.store import Store from ditto.writers.gridlabd.write import Writer demo_models = [ f for f in os.listdir( os.path.join(current_directory, 'data/small_cases/demo/')) if not f.startswith('.') ] for model in demo_models: m = Store() r = Reader(input_file=os.path.join(current_directory, 'data/small_cases/demo', model)) r.parse(m) m.set_names() print('>Demo model {model} read...'.format(model=os.path.join( current_directory, 'data/small_cases/demo', model))) output_path = tempfile.TemporaryDirectory() w = Writer(output_path=output_path.name, log_path=output_path) w.write(m) print('>...and written to Gridlab-D.\n')
def test_gridlabd_to_ephasor(): from ditto.readers.gridlabd.read import Reader from ditto.store import Store from ditto.writers.ephasor.write import Writer gridlabd_models = [ f for f in os.listdir( os.path.join(current_directory, 'data/small_cases/gridlabd/')) if not f.startswith('.') ] for model in gridlabd_models: m = Store() r = Reader() r.parse(m) m.set_names() #TODO: Log properly print('>Gridlab-D model {model} read...'.format(model=model)) output_path = tempfile.TemporaryDirectory() w = Writer(output_path=output_path.name, log_path=output_path) w.write(m) #TODO: Log properly print('>...and written to Ephasorsim.\n')
def test_transformer_kv(): m = Store() r = Reader(master_file=os.path.join(current_directory, "test_transformer_kv.dss")) r.parse(m) m.set_names() # Substation is a 115kV/4.16kV step-down two windings transformer assert ( len(m["substation"].windings) == 2 ) # Transformer substation should have 2 Windings assert m["substation"].windings[0].nominal_voltage == 115 * 10 ** 3 assert m["substation"].windings[1].nominal_voltage == 4.16 * 10 ** 3 # reg1 is a 4.16kV/4.16kV two windings regulator assert len(m["reg1"].windings) == 2 # Transformer reg1 should have 2 Windings assert m["reg1"].windings[0].nominal_voltage == 4.16 * 10 ** 3 assert m["reg1"].windings[1].nominal_voltage == 4.16 * 10 ** 3 # xfm1 is a 4.16kV/0.48kV two windings distribution transformer assert len(m["xfm1"].windings) == 2 # Transformer xfm1 should have 2 Windings assert m["xfm1"].windings[0].nominal_voltage == 4.16 * 10 ** 3 assert m["xfm1"].windings[1].nominal_voltage == 0.48 * 10 ** 3
def test_loads(): m = Store() r = Reader(master_file=os.path.join(current_directory, "test_loads.dss")) r.parse(m) m.set_names() # Reading OpenDSS default values d_v = Default_Values( os.path.join( current_directory, "../../../../ditto/default_values/opendss_default_values.json", )) parsed_values = d_v.parse() precision = 0.001 assert m["load_zipv"].name == "load_zipv" assert m["load_zipv"].connection_type == parsed_values["Load"][ "connection_type"] assert m["load_zipv"].vmin == 0.0 assert m["load_zipv"].vmax == 1.2 assert m["load_zipv"].connecting_element == "load" assert m["load_zipv"].nominal_voltage == 1 * 10**3 assert m["load_zipv"].feeder_name == "src_src" assert m["load_zipv"].peak_coincident_p == None assert m["load_zipv"].peak_coincident_q == None assert len(m["load_zipv"].phase_loads) == 1 # Load is a one phase load assert m["load_zipv"].phase_loads[0].phase == "A" assert m["load_zipv"].phase_loads[0].p == 1 * 10**3 assert m["load_zipv"].phase_loads[0].q == pytest.approx( 1.0 * math.sqrt(1.0 / 0.88**2 - 1) * 10**3, precision) assert m["load_zipv"].phase_loads[0].model == 8 assert m["load_zipv"].phase_loads[0].use_zip == 1 assert m["load_zipv"].phase_loads[0].ppercentcurrent == -0.9855 * 100 assert m["load_zipv"].phase_loads[0].qpercentcurrent == -2.963 * 100 assert m["load_zipv"].phase_loads[0].ppercentpower == 1.1305 * 100 assert m["load_zipv"].phase_loads[0].qpercentpower == 1.404 * 100 assert m["load_zipv"].phase_loads[0].ppercentimpedance == 0.855 * 100 assert m["load_zipv"].phase_loads[0].qpercentimpedance == 2.559 * 100
def test_switches(): from ditto.store import Store from ditto.readers.opendss.read import Reader from ditto.default_values.default_values_json import Default_Values m = Store() r = Reader( master_file=os.path.join(current_directory, "test_switches.dss")) r.parse(m) m.set_names() # Reading OpenDSS default values d_v = Default_Values( os.path.join( current_directory, "../../../../ditto/default_values/opendss_default_values.json", )) parsed_values = d_v.parse() assert len(m["origin"].wires) == 3 # Phases of the different wires assert set([w.phase for w in m["origin"].wires]) == set(["A", "B", "C"]) assert m["origin"].name == "origin" assert m["origin"].nominal_voltage == float(12.47) * 10**3 assert m["origin"].line_type is None assert m["origin"].length == 0.001 * 1000 # units = km assert m["origin"].from_element == "sourcebus" assert m["origin"].to_element == "node1" assert m["origin"].is_fuse is None assert m["origin"].is_switch is None assert m["origin"].faultrate == parsed_values["Line"]["faultrate"] z1 = complex( parsed_values["Line"]["R1"], parsed_values["Line"]["X1"]) # r1,x1 taken from default values z0 = complex( parsed_values["Line"]["R0"], parsed_values["Line"]["X0"]) # r0,x0 taken from default values diag = ((2 * z1 + z0) / 3) * 0.001 # Units = km diag = round(diag.real, 11) + round(diag.imag, 10) * 1j rem = ((z0 - z1) / 3) * 0.001 # Units = km rem = round(rem.real, 11) + rem.imag * 1j imp_matrix = np.zeros((3, 3), dtype=np.complex_) imp_matrix.fill(rem) np.fill_diagonal(imp_matrix, diag) imp_matrix = imp_matrix.tolist() assert m["origin"].impedance_matrix == imp_matrix c1 = complex(parsed_values["Line"]["C1"], 0) # c1 taken from default values c0 = complex(parsed_values["Line"]["C0"], 0) # c0 taken from default values c_diag = ((2 * c1 + c0) / 3) * 0.001 # Units = km c_diag = round(c_diag.real, 10) + c_diag.imag * 1j c_rem = ((c0 - c1) / 3) * 0.001 # Units = km c_rem = round(c_rem.real, 10) + c_rem.imag * 1j cap_matrix = np.zeros((3, 3), dtype=np.complex_) cap_matrix.fill(c_rem) np.fill_diagonal(cap_matrix, c_diag) cap_matrix = cap_matrix.tolist() assert m["origin"].capacitance_matrix == cap_matrix assert m["origin"].feeder_name == "sourcebus_src" assert m["origin"].is_recloser is None assert m["origin"].is_breaker is None assert m["origin"].nameclass == "" for w in m["origin"].wires: assert w.nameclass == "" assert w.X is None assert w.Y is None assert w.diameter is None assert w.gmr is None assert w.ampacity == parsed_values["Wire"]["ampacity"] assert w.emergency_ampacity == parsed_values["Wire"][ "emergency_ampacity"] assert w.resistance is None assert w.insulation_thickness == parsed_values["Wire"][ "insulation_thickness"] assert w.is_open is None assert w.concentric_neutral_gmr is None assert w.concentric_neutral_resistance is None assert w.concentric_neutral_diameter is None assert w.concentric_neutral_outside_diameter is None assert w.concentric_neutral_nstrand is None assert len(m["switch1"].wires) == 3 # Number of wires # Phases of the different wires assert set([w.phase for w in m["switch1"].wires]) == set(["A", "B", "C"]) assert m["switch1"].name == "switch1" assert m["switch1"].nominal_voltage == float(12.47) * 10**3 assert m["switch1"].line_type is None assert m["switch1"].length == 0.001 * 1000 assert m["switch1"].from_element == "node1" assert m["switch1"].to_element == "node2" assert m["switch1"].is_fuse is None assert m["switch1"].is_switch == 1 assert m["switch1"].faultrate == parsed_values["Line"]["faultrate"] assert m["switch1"].impedance_matrix == [ [(0.001 + 0.001j), 0j, 0j], [0j, (0.001 + 0.001j), 0j], [0j, 0j, (0.001 + 0.001j)], ] c1 = complex(1.1, 0) c0 = complex(1, 0) c_diag = ((2 * c1 + c0) / 3) * 0.001 # Units = km c_diag = round(c_diag.real, 9) + c_diag.imag * 1j c_rem = ((c0 - c1) / 3) * 0.001 # Units = km c_rem = c_rem.real + c_rem.imag * 1j cap_matrix = np.zeros((3, 3), dtype=np.complex_) cap_matrix.fill(c_rem) np.fill_diagonal(cap_matrix, c_diag) cap_matrix = cap_matrix.tolist() np.testing.assert_array_almost_equal(m["switch1"].capacitance_matrix, cap_matrix) assert m["switch1"].feeder_name == "sourcebus_src" assert m["switch1"].is_recloser is None assert m["switch1"].is_breaker is None assert m["switch1"].nameclass == "switch1" for w in m["switch1"].wires: assert w.nameclass == "" assert w.X is None assert w.Y is None assert w.diameter is None assert w.gmr is None assert w.ampacity == 3000 assert w.emergency_ampacity == 4000 assert w.resistance is None assert w.insulation_thickness == parsed_values["Wire"][ "insulation_thickness"] assert w.is_open == 0 assert w.concentric_neutral_gmr is None assert w.concentric_neutral_resistance is None assert w.concentric_neutral_diameter is None assert w.concentric_neutral_outside_diameter is None assert w.concentric_neutral_nstrand is None assert len(m["switch2"].wires) == 3 # Number of wires # Phases of the different wires assert set([w.phase for w in m["switch2"].wires]) == set(["A", "B", "C"]) assert m["switch2"].name == "switch2" assert m["switch2"].nominal_voltage == float(12.47) * 10**3 assert m["switch2"].line_type is None assert m["switch2"].length == 0.001 * 1000 assert m["switch2"].from_element == "node1" assert m["switch2"].to_element == "node3" assert m["switch2"].is_fuse is None assert m["switch2"].is_switch == 1 assert m["switch2"].faultrate == parsed_values["Line"]["faultrate"] assert m["switch2"].impedance_matrix == [ [(0.001 + 0.001j), 0j, 0j], [0j, (0.001 + 0.001j), 0j], [0j, 0j, (0.001 + 0.001j)], ] assert m["switch2"].capacitance_matrix == [ [ (0.001066667 + 0j), (-3.3333330000000004e-05 + 0j), (-3.3333330000000004e-05 + 0j), ], [ (-3.3333330000000004e-05 + 0j), (0.001066667 + 0j), (-3.3333330000000004e-05 + 0j), ], [ (-3.3333330000000004e-05 + 0j), (-3.3333330000000004e-05 + 0j), (0.001066667 + 0j), ], ] assert m["switch2"].feeder_name == "sourcebus_src" assert m["switch2"].is_recloser is None assert m["switch2"].is_breaker is None assert m["switch2"].nameclass == "switch2" for w in m["switch2"].wires: assert w.nameclass == "" assert w.X is None assert w.Y is None assert w.diameter is None assert w.gmr is None assert w.ampacity == 3000 assert w.emergency_ampacity == 4000 assert w.resistance is None assert w.insulation_thickness == parsed_values["Wire"][ "insulation_thickness"] assert w.is_open == 1 assert w.concentric_neutral_gmr is None assert w.concentric_neutral_resistance is None assert w.concentric_neutral_diameter is None assert w.concentric_neutral_outside_diameter is None assert w.concentric_neutral_nstrand is None assert len(m["switch3"].wires) == 3 # Number of wires # Phases of the different wires assert set([w.phase for w in m["switch3"].wires]) == set(["A", "B", "C"]) assert m["switch3"].name == "switch3" assert m["switch3"].nominal_voltage == float(12.47) * 10**3 assert m["switch3"].line_type is None assert m["switch3"].length == 0.001 * 1000 assert m["switch3"].from_element == "node1" assert m["switch3"].to_element == "node4" assert m["switch3"].is_fuse is None assert m["switch3"].is_switch == 1 assert m["switch3"].faultrate == parsed_values["Line"]["faultrate"] assert m["switch3"].impedance_matrix == [ [(0.001 + 0.001j), 0j, 0j], [0j, (0.001 + 0.001j), 0j], [0j, 0j, (0.001 + 0.001j)], ] assert m["switch3"].capacitance_matrix == [ [ (0.001066667 + 0j), (-3.3333330000000004e-05 + 0j), (-3.3333330000000004e-05 + 0j), ], [ (-3.3333330000000004e-05 + 0j), (0.001066667 + 0j), (-3.3333330000000004e-05 + 0j), ], [ (-3.3333330000000004e-05 + 0j), (-3.3333330000000004e-05 + 0j), (0.001066667 + 0j), ], ] assert m["switch3"].feeder_name == "sourcebus_src" assert m["switch3"].is_recloser is None assert m["switch3"].is_breaker is None assert m["switch3"].nameclass == "switch3" for w in m["switch3"].wires: assert w.nameclass == "" assert w.X is None assert w.Y is None assert w.diameter is None assert w.gmr is None assert w.ampacity == 3000 assert w.emergency_ampacity == 4000 assert w.resistance is None assert w.insulation_thickness == parsed_values["Wire"][ "insulation_thickness"] assert w.is_open == 1 assert w.concentric_neutral_gmr is None assert w.concentric_neutral_resistance is None assert w.concentric_neutral_diameter is None assert w.concentric_neutral_outside_diameter is None assert w.concentric_neutral_nstrand is None assert len(m["switch4"].wires) == 3 # Number of wires # Phases of the different wires assert set([w.phase for w in m["switch4"].wires]) == set(["A", "B", "C"]) assert m["switch4"].name == "switch4" assert m["switch4"].nominal_voltage == float(12.47) * 10**3 assert m["switch4"].line_type is None assert m["switch4"].length == 0.001 * 1000 assert m["switch4"].from_element == "node1" assert m["switch4"].to_element == "node5" assert m["switch4"].is_fuse is None assert m["switch4"].is_switch == 1 assert m["switch4"].faultrate == parsed_values["Line"]["faultrate"] assert m["switch4"].impedance_matrix == [ [(0.001 + 0.001j), 0j, 0j], [0j, (0.001 + 0.001j), 0j], [0j, 0j, (0.001 + 0.001j)], ] assert m["switch4"].capacitance_matrix == [ [ (0.001066667 + 0j), (-3.3333330000000004e-05 + 0j), (-3.3333330000000004e-05 + 0j), ], [ (-3.3333330000000004e-05 + 0j), (0.001066667 + 0j), (-3.3333330000000004e-05 + 0j), ], [ (-3.3333330000000004e-05 + 0j), (-3.3333330000000004e-05 + 0j), (0.001066667 + 0j), ], ] assert m["switch4"].feeder_name == "sourcebus_src" assert m["switch4"].is_recloser is None assert m["switch4"].is_breaker is None assert m["switch4"].nameclass == "switch4" for w in m["switch4"].wires: assert w.nameclass == "" assert w.X is None assert w.Y is None assert w.diameter is None assert w.gmr is None assert w.ampacity == 3000 assert w.emergency_ampacity == 4000 assert w.resistance is None assert w.insulation_thickness == parsed_values["Wire"][ "insulation_thickness"] assert w.is_open == 0 assert w.concentric_neutral_gmr is None assert w.concentric_neutral_resistance is None assert w.concentric_neutral_diameter is None assert w.concentric_neutral_outside_diameter is None assert w.concentric_neutral_nstrand is None assert len(m["switch5"].wires) == 1 # Phases of the different wires assert m["switch5"].wires[0].phase == "A" assert m["switch5"].name == "switch5" assert m["switch5"].nominal_voltage == float(12.47) * 10**3 assert m["switch5"].line_type is None assert m["switch5"].length == 0.001 * 1000 assert m["switch5"].from_element == "node1" assert m["switch5"].to_element == "node6" assert m["switch5"].is_fuse is None assert m["switch5"].is_switch == 1 assert m["switch5"].faultrate == parsed_values["Line"]["faultrate"] assert m["switch5"].impedance_matrix == [[(0.001 + 0.001j)]] assert m["switch5"].capacitance_matrix == [[(0.0011 + 0j)]] assert m["switch5"].feeder_name == "sourcebus_src" assert m["switch5"].is_recloser is None assert m["switch5"].is_breaker is None assert m["switch5"].nameclass == "switch5" for w in m["switch5"].wires: assert w.nameclass == "" assert w.X is None assert w.Y is None assert w.diameter is None assert w.gmr is None assert w.ampacity == 3000 assert w.emergency_ampacity == 4000 assert w.resistance is None assert w.insulation_thickness == parsed_values["Wire"][ "insulation_thickness"] assert w.is_open == 0 assert w.concentric_neutral_gmr is None assert w.concentric_neutral_resistance is None assert w.concentric_neutral_diameter is None assert w.concentric_neutral_outside_diameter is None assert w.concentric_neutral_nstrand is None assert len(m["switch6"].wires) == 1 # Phases of the different wires assert m["switch6"].wires[0].phase == "C" assert m["switch6"].name == "switch6" assert m["switch6"].nominal_voltage == float(12.47) * 10**3 assert m["switch6"].line_type is None assert m["switch6"].length == 0.001 * 1000 assert m["switch6"].from_element == "node1" assert m["switch6"].to_element == "node7" assert m["switch6"].is_fuse is None assert m["switch6"].is_switch == 1 assert m["switch6"].faultrate == parsed_values["Line"]["faultrate"] assert m["switch6"].impedance_matrix == [[(0.001 + 0.001j)]] assert m["switch6"].capacitance_matrix == [[(0.0011 + 0j)]] assert m["switch6"].feeder_name == "sourcebus_src" assert m["switch6"].is_recloser is None assert m["switch6"].is_breaker is None assert m["switch6"].nameclass == "switch6" for w in m["switch6"].wires: assert w.nameclass == "" assert w.X is None assert w.Y is None assert w.diameter is None assert w.gmr is None assert w.ampacity == 3000 assert w.emergency_ampacity == 4000 assert w.resistance is None assert w.is_open == 1 assert w.concentric_neutral_gmr is None assert w.concentric_neutral_resistance is None assert w.concentric_neutral_diameter is None assert w.concentric_neutral_outside_diameter is None assert w.concentric_neutral_nstrand is None assert len(m["switch7"].wires) == 2 # Phases of the different wires assert set([w.phase for w in m["switch7"].wires]) == set(["B", "C"]) assert m["switch7"].name == "switch7" assert m["switch7"].nominal_voltage == float(12.47) * 10**3 assert m["switch7"].line_type is None assert m["switch7"].length == 0.001 * 1000 assert m["switch7"].from_element == "node1" assert m["switch7"].to_element == "node8" assert m["switch7"].is_fuse is None assert m["switch7"].is_switch == 1 assert m["switch7"].faultrate == parsed_values["Line"]["faultrate"] assert m["switch7"].impedance_matrix == [ [(0.001 + 0.001j), 0j], [0j, (0.001 + 0.001j)], ] assert m["switch7"].capacitance_matrix == [ [(0.001066667 + 0j), (-3.3333330000000004e-05 + 0j)], [(-3.3333330000000004e-05 + 0j), (0.001066667 + 0j)], ] assert m["switch7"].feeder_name == "sourcebus_src" assert m["switch7"].is_recloser is None assert m["switch7"].is_breaker is None assert m["switch7"].nameclass == "switch7" for w in m["switch7"].wires: assert w.nameclass == "" assert w.X is None assert w.Y is None assert w.diameter is None assert w.gmr is None assert w.ampacity == 3000 assert w.emergency_ampacity == 4000 assert w.resistance is None assert w.insulation_thickness == parsed_values["Wire"][ "insulation_thickness"] assert w.is_open == 1 assert w.concentric_neutral_gmr is None assert w.concentric_neutral_resistance is None assert w.concentric_neutral_diameter is None assert w.concentric_neutral_outside_diameter is None assert w.concentric_neutral_nstrand is None assert len(m["switch8"].wires) == 2 # Phases of the different wires assert set(w.phase for w in m["switch8"].wires) == set(["A", "B"]) assert m["switch8"].name == "switch8" assert m["switch8"].nominal_voltage == float(12.47) * 10**3 assert m["switch8"].line_type is None assert m["switch8"].length == 0.001 * 1000 assert m["switch8"].from_element == "node1" assert m["switch8"].to_element == "node9" assert m["switch8"].is_fuse is None assert m["switch8"].is_switch == 1 assert m["switch8"].faultrate == parsed_values["Line"]["faultrate"] assert m["switch8"].impedance_matrix == [ [(0.001 + 0.001j), 0j], [0j, (0.001 + 0.001j)], ] assert m["switch8"].capacitance_matrix == [ [(0.001066667 + 0j), (-3.3333330000000004e-05 + 0j)], [(-3.3333330000000004e-05 + 0j), (0.001066667 + 0j)], ] assert m["switch8"].feeder_name == "sourcebus_src" assert m["switch8"].is_recloser is None assert m["switch8"].is_breaker is None assert m["switch8"].nameclass == "switch8" for w in m["switch8"].wires: assert w.nameclass == "" assert w.X is None assert w.Y is None assert w.diameter is None assert w.gmr is None assert w.ampacity == 3000 assert w.emergency_ampacity == 4000 assert w.resistance is None assert w.is_open == 0 assert w.concentric_neutral_gmr is None assert w.concentric_neutral_resistance is None assert w.concentric_neutral_diameter is None assert w.concentric_neutral_outside_diameter is None assert w.concentric_neutral_nstrand is None
logger = logging.getLogger(__name__) test_list = os.walk('data') for (dirpath, dirname, files) in test_list: if files != []: reader_type = dirpath.split('\\')[2] m = Store() if reader_type == 'opendss': reader = Reader_opendss( master_file=os.path.join('..', dirpath, 'master.dss'), buscoordinates_file=os.path.join('..', dirpath, 'buscoord.dss')) elif reader_type == 'cyme': reader = Reader_cyme(data_folder_path=os.path.join('..', dirpath)) else: #Update with other tests if they get added to the persistence tests continue reader.parse(m) m.set_names() output_path = tempfile.TemporaryDirectory() w = Writer(output_path=output_path.name, log_path=output_path) w.write(m) original = json_tricks.load(open(os.path.join(dirpath, files[0]), 'r')) update = json_tricks.load( open(os.path.join(output_path.name, 'Model.json'), 'r')) try: assert update["model"] == original["model"] except AssertionError as e: logger.error("Model differs for usecase {loc}".format(loc=dirpath)) e.args += ("Model differs for usecase {loc}".format(loc=dirpath), ) raise
def test_ephasor_writer(): from ditto.writers.ephasor.write import Writer from ditto.models.node import Node from ditto.models.line import Line from ditto.models.load import Load from ditto.models.regulator import Regulator from ditto.models.wire import Wire from ditto.models.capacitor import Capacitor from ditto.models.powertransformer import PowerTransformer from ditto.models.winding import Winding from ditto.models.phase_winding import PhaseWinding from ditto.store import Store from ditto.models.base import Unicode from ditto.models.power_source import PowerSource from ditto.models.feeder_metadata import Feeder_metadata m = Store() src = PowerSource( m, name="f1_src", phases=[Unicode("A"), Unicode("B"), Unicode("C")], nominal_voltage=12470, connecting_element="n1", is_sourcebus=True, ) meta = Feeder_metadata(m, name="f1", nominal_voltage=12470, headnode="f1_src", substation="f1_src") node1 = Node(m, name="n1", feeder_name="f1") node2 = Node(m, name="n2", feeder_name="f1") node3 = Node(m, name="n3", feeder_name="f1") wirea = Wire(m, gmr=1.3, X=2, Y=20) wiren = Wire(m, gmr=1.2, X=2, Y=20) line1 = Line( m, name="l1", wires=[wirea, wiren], from_element="n1", to_element="n2", feeder_name="f1", ) load1 = Load(m, name="load1", feeder_name="f1") phase_winding = PhaseWinding(m, phase=u"A") winding1 = Winding( m, phase_windings=[phase_winding], connection_type="Y", nominal_voltage=12.47, rated_power=25, resistance=10, ) winding2 = Winding( m, phase_windings=[phase_winding], connection_type="Y", nominal_voltage=6.16, rated_power=25, resistance=10, ) transformer1 = PowerTransformer( m, name="t1", from_element="n2", to_element="n3", windings=[winding1, winding2], feeder_name="f1", ) transformer1.reactances.append(6) # reg1 = Regulator(m, name='t1_reg', connected_transformer='t1', connected_winding=2, pt_ratio=60, delay=2) # cap1 = Capacitor(m, name='cap1', connecting_element='n2', num_phases=3, nominal_voltage=7.2, var=300, connection_type='Y') m.set_names() t = tempfile.TemporaryDirectory() writer = Writer(output_path=t.name, log_path="./") writer.write(m)
def test_linegeometries(): m = Store() r = Reader(master_file=os.path.join(current_directory, "test_linegeometries.dss")) r.parse(m) m.set_names() # Reading OpenDSS default values d_v = Default_Values( os.path.join( current_directory, "../../../../ditto/default_values/opendss_default_values.json", ) ) parsed_values = d_v.parse() # Number of wires assert len(m["line1"].wires) == 4 # Line1 should have 4 wires # Phases of the different wires assert set([w.phase for w in m["line1"].wires]) == set(["A", "B", "C", "N"]) assert m["line1"].name == "line1" assert m["line1"].nominal_voltage == float(4.8) * 10 ** 3 assert m["line1"].line_type == "overhead" assert m["line1"].length == 300 * 0.3048 # units = ft assert m["line1"].from_element == "bus1" assert m["line1"].to_element == "bus2" assert m["line1"].is_fuse is None assert m["line1"].is_switch is None z1 = complex( parsed_values["Line"]["R1"], parsed_values["Line"]["X1"] ) # r1,x1 taken from default values z0 = complex( parsed_values["Line"]["R0"], parsed_values["Line"]["X0"] ) # r0,x0 taken from default values diag = ((2 * z1 + z0) / 3) * 0.001 # Units = km diag = round(diag.real, 11) + round(diag.imag, 10) * 1j rem = ((z0 - z1) / 3) * 0.001 # Units = km rem = round(rem.real, 11) + rem.imag * 1j imp_matrix = np.zeros((4, 4), dtype=np.complex_) imp_matrix.fill(rem) np.fill_diagonal(imp_matrix, diag) imp_matrix = imp_matrix.tolist() assert m["line1"].faultrate == parsed_values["Line"]["faultrate"] np.testing.assert_array_almost_equal( m["line1"].impedance_matrix, [ [ (0.00024738133202099736 + 0.0008769514435695538j), (5.810587270341207e-05 + 0.00031932618110236215j), (5.723612204724409e-05 + 0.0004637522965879265j), (5.717280183727034e-05 + 0.0004757309711286089j), ], [ (5.810587270341207e-05 + 0.00031932618110236215j), (0.0002491671587926509 + 0.0008750521653543306j), (5.810603674540682e-05 + 0.0003196077099737533j), (5.803946850393701e-05 + 0.0003143254593175853j), ], [ (5.723612204724409e-05 + 0.0004637522965879265j), (5.810603674540682e-05 + 0.0003196077099737533j), (0.00024738133202099736 + 0.0008769514435695538j), (5.717296587926509e-05 + 0.0005039963910761155j), ], [ (5.717280183727034e-05 + 0.0004757309711286089j), (5.803946850393701e-05 + 0.0003143254593175853j), (5.717296587926509e-05 + 0.0005039963910761155j), (0.0007530643044619422 + 0.0010085508530183727j), ], ], ) np.testing.assert_array_almost_equal( m["line1"].capacitance_matrix, [ [ (0.008384708005249344 + 0j), (-0.0001470299868766404 + 0j), (-0.0019942040682414696 + 0j), (-0.0020357719816272964 + 0j), ], [ (-0.0001470299868766404 + 0j), (0.00994426837270341 + 0j), (-0.00014228366141732281 + 0j), (-9.78384186351706e-05 + 0j), ], [ (-0.0019942040682414696 + 0j), (-0.00014228366141732281 + 0j), (0.008713290682414698 + 0j), (-0.002607346128608924 + 0j), ], [ (-0.0020357719816272964 + 0j), (-9.78384186351706e-05 + 0j), (-0.002607346128608924 + 0j), (0.008078645013123359 + 0j), ], ], ) assert m["line1"].feeder_name == "sourcebus_src" assert m["line1"].is_recloser is None assert m["line1"].is_breaker is None assert m["line1"].nameclass == "" for w in m["line1"].wires: assert w.emergency_ampacity == 795 assert w.insulation_thickness == parsed_values["Wire"]["insulation_thickness"] assert w.is_open is None assert w.concentric_neutral_gmr is None assert w.concentric_neutral_resistance is None assert w.concentric_neutral_diameter is None assert w.concentric_neutral_outside_diameter is None assert w.concentric_neutral_nstrand is None phased_wires = {} for wire in m["line1"].wires: phased_wires[wire.phase] = wire # Nameclass for p in ["A", "B", "C"]: assert phased_wires[p].ampacity == 530 assert phased_wires[p].nameclass == "wire1" assert phased_wires["N"].ampacity == 230 assert phased_wires["N"].nameclass == "wire2" # Positions of the wires assert (phased_wires["A"].X, phased_wires["A"].Y) == (-1.2909, 13.716) assert (phased_wires["B"].X, phased_wires["B"].Y) == ( -0.1530096 * 0.3048, 4.1806368 * 0.3048, ) assert (phased_wires["C"].X, phased_wires["C"].Y) == (0.5737, 13.716) assert (phased_wires["N"].X, phased_wires["N"].Y) == (0.0, 14.648) # GMR for p in ["A", "B", "C"]: assert phased_wires[p].gmr == 0.0255 * 0.3048 assert phased_wires["N"].gmr == 0.00446 * 0.3048 # Diameter for p in ["A", "B", "C"]: assert phased_wires[p].diameter == 0.741 * 0.0254 assert phased_wires["N"].diameter == 0.398 * 0.0254 # Resistance # TODO: Change this once the resistance of a Wire object will no longer be the total # resistance, but the per meter resistance... # for p in ["A", "B", "C"]: assert phased_wires[p].resistance == pytest.approx( 0.306 * 0.000621371 * 300 * 0.3048, 0.00001 ) assert phased_wires["N"].resistance == pytest.approx( 1.12 * 0.000621371 * 300 * 0.3048, 0.00001 ) # Number of wires assert len(m["line2"].wires) == 3 # Phases of the different wires assert set([w.phase for w in m["line2"].wires]) == set(["A", "B", "C"]) assert m["line2"].name == "line2" assert m["line2"].nominal_voltage == float(4.8) * 10 ** 3 assert m["line2"].line_type == "underground" assert m["line2"].length == 1 * 1609.34 # units = mi assert m["line2"].from_element == "bus2" assert m["line2"].to_element == "bus3" assert m["line2"].is_fuse is None assert m["line2"].is_switch is None assert m["line2"].faultrate == parsed_values["Line"]["faultrate"] np.testing.assert_array_almost_equal( m["line2"].impedance_matrix, [ [ (0.0005010314787428386 + 0.00026819845402463124j), (0.00020170349335752545 + 1.1288596567537003e-05j), (0.00017933407483813242 - 1.766354530428623e-05j), ], [ (0.00020170349335752545 + 1.1288596567537003e-05j), (0.0004946492350901612 + 0.00024160345234692485j), (0.00020170349335752545 + 1.1288596567537003e-05j), ], [ (0.00017933407483813242 - 1.766354530428623e-05j), (0.00020170349335752545 + 1.1288596567537003e-05j), (0.0005010314787428386 + 0.00026819845402463124j), ], ], ) np.testing.assert_array_almost_equal( m["line2"].capacitance_matrix, [ [(0.23857494376576735 + 0j), 0j, 0j], [0j, (0.23857494376576735 + 0j), 0j], [0j, 0j, (0.23857494376576735 + 0j)], ], ) assert m["line2"].feeder_name == "sourcebus_src" assert m["line2"].is_recloser is None assert m["line2"].is_breaker is None assert m["line2"].nameclass == "" for w in m["line2"].wires: assert w.emergency_ampacity is None assert w.insulation_thickness == 0.005588 assert w.is_open is None assert w.concentric_neutral_gmr == 0.0508 assert w.concentric_neutral_resistance == 858.5200001016 assert w.concentric_neutral_diameter == 0.0016256 assert w.concentric_neutral_outside_diameter == 0.029463999999999997 assert w.concentric_neutral_nstrand == 13 phased_wires = {} for wire in m["line2"].wires: phased_wires[wire.phase] = wire # Nameclass for p in ["A", "B", "C"]: assert phased_wires[p].ampacity is None assert phased_wires[p].nameclass == "cndata1" # Positions of the wires assert (phased_wires["A"].X, phased_wires["A"].Y) == (-0.5 * 0.3048, -4 * 0.3048) assert (phased_wires["B"].X, phased_wires["B"].Y) == (0, -4 * 0.3048) assert (phased_wires["C"].X, phased_wires["C"].Y) == (0.5 * 0.3048, -4 * 0.3048) # GMR for p in ["A", "B", "C"]: assert phased_wires[p].gmr == 0.20568 * 0.0254 # Diameter for p in ["A", "B", "C"]: assert phased_wires[p].diameter == 0.573 * 0.0254 for p in ["A", "B", "C"]: assert phased_wires[p].resistance == pytest.approx( 0.076705 * 1609.34 * 0.00328084, 0.00001 )
def test_capacitor_connectivity(): m = Store() r = Reader(master_file=os.path.join(current_directory, "test_capacitor_connectivity.dss")) r.parse(m) m.set_names() # Reading OpenDSS default values d_v = Default_Values( os.path.join( current_directory, "../../../../ditto/default_values/opendss_default_values.json", )) parsed_values = d_v.parse() # Capacitor Cap1 should be a three phase capacitor (3 PhaseCapacitor objects) connected to bus1 assert len( m["cap1"].phase_capacitors) == 3 # Cap1 is a three phase capacitor assert sum([ phase_capacitor.var for phase_capacitor in m["cap1"].phase_capacitors ]) == pytest.approx(600 * 10**3, 0.0001) assert m["cap1"].name == "cap1" assert m["cap1"].nominal_voltage == float(4.16) * 10**3 assert m["cap1"].connection_type == parsed_values["Capacitor"][ "connection_type"] assert m["cap1"].delay is None assert m["cap1"].mode is None assert m["cap1"].low is None assert m["cap1"].high is None assert m["cap1"].resistance == 0.0 assert m["cap1"].reactance == 0.0 assert m["cap1"].susceptance is None assert m["cap1"].conductance is None assert m["cap1"].pt_ratio is None assert m["cap1"].ct_ratio is None assert m["cap1"].pt_phase is None assert m["cap1"].connecting_element == "bus1" assert m["cap1"].measuring_element is None assert m["cap1"].feeder_name == "sourcebus_src" assert set([pc.phase for pc in m["cap1"].phase_capacitors]) == set(["A", "B", "C"]) assert [ phase_capacitor.switch for phase_capacitor in m["cap1"].phase_capacitors ] == [None, None, None] assert [ phase_capacitor.sections for phase_capacitor in m["cap1"].phase_capacitors ] == [None, None, None] assert [ phase_capacitor.normalsections for phase_capacitor in m["cap1"].phase_capacitors ] == [None, None, None] # Capacitor Cap2 should be a one phase capacitor (1 PhaseCapacitor object) connected to bus2 on phase C assert len( m["cap2"].phase_capacitors) == 1 # Cap2 is a one phase capacitor assert m["cap2"].phase_capacitors[0].var == 100 * 10**3 assert m["cap2"].name == "cap2" assert m["cap2"].nominal_voltage == float(2.4) * 10**3 assert m["cap2"].connection_type == parsed_values["Capacitor"][ "connection_type"] assert m["cap2"].delay is None assert m["cap2"].mode is None assert m["cap2"].low is None assert m["cap2"].high is None assert m["cap2"].resistance == 0.0 assert m["cap2"].reactance == 0.0 assert m["cap2"].susceptance is None assert m["cap2"].conductance is None assert m["cap2"].pt_ratio is None assert m["cap2"].ct_ratio is None assert m["cap2"].pt_phase is None assert m["cap2"].connecting_element == "bus2" assert m["cap2"].measuring_element is None assert m["cap2"].feeder_name == "sourcebus_src" assert m["cap2"].phase_capacitors[0].phase == "C" assert m["cap2"].phase_capacitors[0].switch == None assert m["cap2"].phase_capacitors[0].sections == None assert m["cap2"].phase_capacitors[0].normalsections == None # Capacitor Cap3 should be a one phase capacitor (1 PhaseCapacitor object) connected to bus3 on phase A assert len( m["cap3"].phase_capacitors) == 1 # Cap3 is a one phase capacitor assert m["cap3"].phase_capacitors[0].var == 200.37 * 10**3 assert m["cap3"].name == "cap3" assert m["cap3"].nominal_voltage == float(2.4) * 10**3 assert m["cap3"].connection_type == parsed_values["Capacitor"][ "connection_type"] assert m["cap3"].delay is None assert m["cap3"].mode is None assert m["cap3"].low is None assert m["cap3"].high is None assert m["cap3"].resistance == 0.0 assert m["cap3"].reactance == 0.0 assert m["cap3"].susceptance is None assert m["cap3"].conductance is None assert m["cap3"].pt_ratio is None assert m["cap3"].ct_ratio is None assert m["cap3"].pt_phase is None assert m["cap3"].connecting_element == "bus3" assert m["cap3"].measuring_element is None assert m["cap3"].feeder_name == "sourcebus_src" assert m["cap3"].phase_capacitors[0].phase == "A" assert m["cap3"].phase_capacitors[0].switch == None assert m["cap3"].phase_capacitors[0].sections == None assert m["cap3"].phase_capacitors[0].normalsections == None # Capacitor Cap4 should be a two phase capacitor (2 PhaseCapacitor objects) connected to bus4 on phase A and C assert len( m["cap4"].phase_capacitors) == 2 # Cap4 is a two phase capacitor assert sum([ phase_capacitor.var for phase_capacitor in m["cap4"].phase_capacitors ]) == pytest.approx(400 * 10**3, 0.0001) assert m["cap4"].name == "cap4" assert m["cap4"].nominal_voltage == float(2.4) * 10**3 assert m["cap4"].connection_type == parsed_values["Capacitor"][ "connection_type"] assert m["cap4"].delay is None assert m["cap4"].mode is None assert m["cap4"].low is None assert m["cap4"].high is None assert m["cap4"].resistance == 0.0 assert m["cap4"].reactance == 0.0 assert m["cap4"].susceptance is None assert m["cap4"].conductance is None assert m["cap4"].pt_ratio is None assert m["cap4"].ct_ratio is None assert m["cap4"].pt_phase is None assert m["cap4"].connecting_element == "bus4" assert m["cap4"].measuring_element is None assert m["cap4"].feeder_name == "sourcebus_src" assert set([pc.phase for pc in m["cap4"].phase_capacitors]) == set(["A", "C"]) assert [ phase_capacitor.switch for phase_capacitor in m["cap4"].phase_capacitors ] == [None, None] assert [ phase_capacitor.sections for phase_capacitor in m["cap4"].phase_capacitors ] == [None, None] assert [ phase_capacitor.normalsections for phase_capacitor in m["cap4"].phase_capacitors ] == [None, None] # Capacitors from epri_j1 assert len(m["b4909-1"].phase_capacitors ) == 3 # b4909-1 is a three phase capacitor assert sum([ phase_capacitor.var for phase_capacitor in m["b4909-1"].phase_capacitors ]) == pytest.approx(900 * 10**3, 0.0001) assert m["b4909-1"].name == "b4909-1" assert m["b4909-1"].nominal_voltage == float(12.47) * 10**3 assert m["b4909-1"].connection_type == parsed_values["Capacitor"][ "connection_type"] assert m["b4909-1"].delay == 30 assert m["b4909-1"].mode == "voltage" assert m["b4909-1"].low == parsed_values["Capacitor"]["low"] assert m["b4909-1"].high == parsed_values["Capacitor"]["high"] assert m["b4909-1"].resistance == 0.0 assert m["b4909-1"].reactance == 0.0 assert m["b4909-1"].susceptance is None assert m["b4909-1"].conductance is None assert m["b4909-1"].pt_ratio == parsed_values["Capacitor"]["pt_ratio"] assert m["b4909-1"].ct_ratio == parsed_values["Capacitor"]["ct_ratio"] assert m["b4909-1"].pt_phase == "B" assert m["b4909-1"].connecting_element == "b4909" assert m["b4909-1"].measuring_element == "Line.OH_B4904" assert m["b4909-1"].feeder_name == "sourcebus_src" assert set([pc.phase for pc in m["b4909-1"].phase_capacitors ]) == set(["A", "B", "C"]) assert [ phase_capacitor.switch for phase_capacitor in m["b4909-1"].phase_capacitors ] == [None, None, None] assert [ phase_capacitor.sections for phase_capacitor in m["b4909-1"].phase_capacitors ] == [None, None, None] assert [ phase_capacitor.normalsections for phase_capacitor in m["b4909-1"].phase_capacitors ] == [None, None, None] assert len(m["b4909-2"].phase_capacitors ) == 3 # b4909-2 is a three phase capacitor assert sum([ phase_capacitor.var for phase_capacitor in m["b4909-2"].phase_capacitors ]) == pytest.approx(900 * 10**3, 0.0001) assert m["b4909-2"].name == "b4909-2" assert m["b4909-2"].nominal_voltage == float(12.47) * 10**3 assert m["b4909-2"].connection_type == parsed_values["Capacitor"][ "connection_type"] assert m["b4909-2"].delay == 30 assert m["b4909-2"].mode == "voltage" assert m["b4909-2"].low == 120.5 assert m["b4909-2"].high == 125 assert m["b4909-2"].resistance == 0.0 assert m["b4909-2"].reactance == 0.0 assert m["b4909-2"].susceptance is None assert m["b4909-2"].conductance is None assert m["b4909-2"].pt_ratio == parsed_values["Capacitor"]["pt_ratio"] assert m["b4909-2"].ct_ratio == parsed_values["Capacitor"]["ct_ratio"] assert m["b4909-2"].pt_phase == "B" assert m["b4909-2"].connecting_element == "b4909" assert m["b4909-2"].measuring_element == "Line.OH_B4904" assert m["b4909-2"].feeder_name == "sourcebus_src" assert set([pc.phase for pc in m["b4909-2"].phase_capacitors ]) == set(["A", "B", "C"]) assert [ phase_capacitor.switch for phase_capacitor in m["b4909-2"].phase_capacitors ] == [None, None, None] assert [ phase_capacitor.sections for phase_capacitor in m["b4909-2"].phase_capacitors ] == [None, None, None] assert [ phase_capacitor.normalsections for phase_capacitor in m["b4909-2"].phase_capacitors ] == [None, None, None] # oh_b4904 assert len(m["oh_b4904"].wires) == 3 # Phases of the different wires assert set([w.phase for w in m["oh_b4904"].wires]) == set(["A", "B", "C"]) assert m["oh_b4904"].name == "oh_b4904" assert (m["oh_b4904"].nameclass == "OH-3X_477AAC_4/0AAACN" ) # Linecode is OH-3X_477AAC_4/0AAACN assert m["oh_b4904"].line_type == "overhead" # OH in lincecode assert m["oh_b4904"].from_element == "b4909" assert m["oh_b4904"].to_element == "b4904" assert m["oh_b4904"].length == pytest.approx(161.84879) assert m["oh_b4904"].nominal_voltage == float(4.16) * 10**3 assert m["oh_b4904"].is_fuse is None assert m["oh_b4904"].is_switch is None assert m["oh_b4904"].faultrate == parsed_values["Line"]["faultrate"] assert m["oh_b4904"].impedance_matrix == [ [ (0.0001931617 + 0.0006880528j), (7.075159e-05 + 0.0002931119j), (7.075159e-05 + 0.0002931119j), ], [ (7.075159e-05 + 0.0002931119j), (0.0001931617 + 0.0006880528j), (7.075159e-05 + 0.0002931119j), ], [ (7.075159e-05 + 0.0002931119j), (7.075159e-05 + 0.0002931119j), (0.0001931617 + 0.0006880528j), ], ] assert m["oh_b4904"].capacitance_matrix == [ [(0.009067833 + 0j), (-0.002129467 + 0j), (-0.002129467 + 0j)], [(-0.002129467 + 0j), (0.009067833 + 0j), (-0.002129467 + 0j)], [(-0.002129467 + 0j), (-0.002129467 + 0j), (0.009067833 + 0j)], ] assert m["oh_b4904"].feeder_name == "sourcebus_src" assert m["oh_b4904"].is_recloser is None assert m["oh_b4904"].is_breaker is None for w in m["oh_b4904"].wires: assert w.nameclass == "4/0AAACN" assert w.X is None assert w.Y is None assert w.diameter is None assert w.gmr is None assert w.ampacity == float(732) assert w.emergency_ampacity == float(871) assert w.resistance is None assert w.insulation_thickness == 0.0 assert w.is_open is None assert w.concentric_neutral_gmr is None assert w.concentric_neutral_resistance is None assert w.concentric_neutral_diameter is None assert w.concentric_neutral_outside_diameter is None assert w.concentric_neutral_nstrand is None assert (len(m["b18944-1"].phase_capacitors) == 3 ) # b18944-1 is a three phase capacitor assert sum([ phase_capacitor.var for phase_capacitor in m["b18944-1"].phase_capacitors ]) == pytest.approx(1200 * 10**3, 0.0001) assert m["b18944-1"].name == "b18944-1" assert m["b18944-1"].nominal_voltage == float(12.47) * 10**3 assert (m["b18944-1"].connection_type == parsed_values["Capacitor"] ["connection_type"]) assert m["b18944-1"].delay == 31 assert m["b18944-1"].mode == "voltage" assert m["b18944-1"].low == parsed_values["Capacitor"]["low"] assert m["b18944-1"].high == parsed_values["Capacitor"]["high"] assert m["b18944-1"].resistance == 0.0 assert m["b18944-1"].reactance == 0.0 assert m["b18944-1"].susceptance is None assert m["b18944-1"].conductance is None assert m["b18944-1"].pt_ratio == parsed_values["Capacitor"]["pt_ratio"] assert m["b18944-1"].ct_ratio == parsed_values["Capacitor"]["ct_ratio"] assert m["b18944-1"].pt_phase == "A" assert m["b18944-1"].connecting_element == "b18941" assert m["b18944-1"].measuring_element == "Line.OH_B18944" assert m["b18944-1"].feeder_name == "sourcebus_src" assert set([pc.phase for pc in m["b18944-1"].phase_capacitors ]) == set(["A", "B", "C"]) assert [ phase_capacitor.switch for phase_capacitor in m["b18944-1"].phase_capacitors ] == [None, None, None] assert [ phase_capacitor.sections for phase_capacitor in m["b18944-1"].phase_capacitors ] == [None, None, None] assert [ phase_capacitor.normalsections for phase_capacitor in m["b18944-1"].phase_capacitors ] == [None, None, None] assert (len(m["b18944-2"].phase_capacitors) == 3 ) # b18944-2 is a three phase capacitor assert sum([ phase_capacitor.var for phase_capacitor in m["b18944-2"].phase_capacitors ]) == pytest.approx(1200 * 10**3, 0.0001) assert m["b18944-2"].name == "b18944-2" assert m["b18944-2"].nominal_voltage == float(12.47) * 10**3 assert (m["b18944-2"].connection_type == parsed_values["Capacitor"] ["connection_type"]) assert m["b18944-2"].delay == 31 assert m["b18944-2"].mode == "voltage" assert m["b18944-2"].low == 118 assert m["b18944-2"].high == 124 assert m["b18944-2"].resistance == 0.0 assert m["b18944-2"].reactance == 0.0 assert m["b18944-2"].susceptance is None assert m["b18944-2"].conductance is None assert m["b18944-2"].pt_ratio == parsed_values["Capacitor"]["pt_ratio"] assert m["b18944-2"].ct_ratio == parsed_values["Capacitor"]["ct_ratio"] assert m["b18944-2"].pt_phase == "A" assert m["b18944-2"].connecting_element == "b18941" assert m["b18944-2"].measuring_element == "Line.OH_B18944" assert m["b18944-2"].feeder_name == "sourcebus_src" assert set([pc.phase for pc in m["b18944-2"].phase_capacitors ]) == set(["A", "B", "C"]) assert [ phase_capacitor.switch for phase_capacitor in m["b18944-2"].phase_capacitors ] == [None, None, None] assert [ phase_capacitor.sections for phase_capacitor in m["b18944-2"].phase_capacitors ] == [None, None, None] assert [ phase_capacitor.normalsections for phase_capacitor in m["b18944-2"].phase_capacitors ] == [None, None, None] # oh_b18944 assert len(m["oh_b18944"].wires) == 3 # Number of wires # Phases of the different wires assert set([w.phase for w in m["oh_b18944"].wires]) == set(["A", "B", "C"]) assert m["oh_b18944"].name == "oh_b18944" assert m[ "oh_b18944"].nameclass == "OH-3X_4CU_4CUN" # Linecode is OH-3X_4CU_4CUN assert m["oh_b18944"].line_type == "overhead" # OH in lincecode assert m["oh_b18944"].from_element == "b18941" assert m["oh_b18944"].to_element == "b18944" assert m["oh_b18944"].length == pytest.approx(141.1224) assert m["oh_b18944"].nominal_voltage == float(4.16) * 10**3 assert m["oh_b18944"].is_fuse is None assert m["oh_b18944"].is_switch is None assert m["oh_b18944"].faultrate == parsed_values["Line"]["faultrate"] assert m["oh_b18944"].impedance_matrix == [ [ (0.0009792434 + 0.0008488938j), (0.0001254797 + 0.0003540439j), (0.0001254797 + 0.0003540439j), ], [ (0.0001254797 + 0.0003540439j), (0.0009792434 + 0.0008488938j), (0.0001254797 + 0.0003540439j), ], [ (0.0001254797 + 0.0003540439j), (0.0001254797 + 0.0003540439j), (0.0009792434 + 0.0008488938j), ], ] assert m["oh_b18944"].capacitance_matrix == [ [(0.007276067 + 0j), (-0.001514233 + 0j), (-0.001514233 + 0j)], [(-0.001514233 + 0j), (0.007276067 + 0j), (-0.001514233 + 0j)], [(-0.001514233 + 0j), (-0.001514233 + 0j), (0.007276067 + 0j)], ] assert m["oh_b18944"].feeder_name == "sourcebus_src" assert m["oh_b18944"].is_recloser is None assert m["oh_b18944"].is_breaker is None for w in m["oh_b18944"].wires: assert w.nameclass == "4CUN" assert w.X is None assert w.Y is None assert w.diameter is None assert w.gmr is None assert w.ampacity == float(142) assert w.emergency_ampacity == float(142) assert w.resistance is None assert w.insulation_thickness == 0.0 assert w.is_open is None assert w.concentric_neutral_gmr is None assert w.concentric_neutral_resistance is None assert w.concentric_neutral_diameter is None assert w.concentric_neutral_outside_diameter is None assert w.concentric_neutral_nstrand is None # Capacitors from ieee 8500-node test feeder assert (len(m["capbank0a"].phase_capacitors) == 1 ) # capbank0a is a single phase capacitor assert m["capbank0a"].phase_capacitors[0].var == 400 * 10**3 assert m["capbank0a"].name == "capbank0a" assert m["capbank0a"].nominal_voltage == float(7.2) * 10**3 assert (m["capbank0a"].connection_type == parsed_values["Capacitor"] ["connection_type"]) assert m["capbank0a"].delay == None assert m["capbank0a"].mode == None assert m["capbank0a"].low is None assert m["capbank0a"].high is None assert m["capbank0a"].resistance == 0.0 assert m["capbank0a"].reactance == 0.0 assert m["capbank0a"].susceptance is None assert m["capbank0a"].conductance is None assert m["capbank0a"].pt_ratio == None assert m["capbank0a"].ct_ratio is None assert m["capbank0a"].pt_phase == None assert m["capbank0a"].connecting_element == "r42246" assert m["capbank0a"].measuring_element == None assert m["capbank0a"].feeder_name == "sourcebus_src" assert m["capbank0a"].phase_capacitors[0].phase == "A" assert m["capbank0a"].phase_capacitors[0].switch == None assert m["capbank0a"].phase_capacitors[0].sections == None assert m["capbank0a"].phase_capacitors[0].normalsections == None assert (len(m["capbank0b"].phase_capacitors) == 1 ) # capbank0b is a single phase capacitor assert m["capbank0b"].phase_capacitors[0].var == 400 * 10**3 assert m["capbank0b"].name == "capbank0b" assert m["capbank0b"].nominal_voltage == float(7.2) * 10**3 assert (m["capbank0b"].connection_type == parsed_values["Capacitor"] ["connection_type"]) assert m["capbank0b"].delay == None assert m["capbank0b"].mode == None assert m["capbank0b"].low is None assert m["capbank0b"].high is None assert m["capbank0b"].resistance == 0.0 assert m["capbank0b"].reactance == 0.0 assert m["capbank0b"].susceptance is None assert m["capbank0b"].conductance is None assert m["capbank0b"].pt_ratio == None assert m["capbank0b"].ct_ratio is None assert m["capbank0b"].pt_phase == None assert m["capbank0b"].connecting_element == "r42246" assert m["capbank0b"].measuring_element == None assert m["capbank0b"].feeder_name == "sourcebus_src" assert m["capbank0b"].phase_capacitors[0].phase == "B" assert m["capbank0b"].phase_capacitors[0].switch == None assert m["capbank0b"].phase_capacitors[0].sections == None assert m["capbank0b"].phase_capacitors[0].normalsections == None assert (len(m["capbank0c"].phase_capacitors) == 1 ) # capbank0c is a single phase capacitor assert m["capbank0c"].phase_capacitors[0].var == 400 * 10**3 assert m["capbank0c"].name == "capbank0c" assert m["capbank0c"].nominal_voltage == float(7.2) * 10**3 assert (m["capbank0c"].connection_type == parsed_values["Capacitor"] ["connection_type"]) assert m["capbank0c"].delay == None assert m["capbank0c"].mode == None assert m["capbank0c"].low is None assert m["capbank0c"].high is None assert m["capbank0c"].resistance == 0.0 assert m["capbank0c"].reactance == 0.0 assert m["capbank0c"].susceptance is None assert m["capbank0c"].conductance is None assert m["capbank0c"].pt_ratio == None assert m["capbank0c"].ct_ratio is None assert m["capbank0c"].pt_phase == None assert m["capbank0c"].connecting_element == "r42246" assert m["capbank0c"].measuring_element == None assert m["capbank0c"].feeder_name == "sourcebus_src" assert m["capbank0c"].phase_capacitors[0].phase == "C" assert m["capbank0c"].phase_capacitors[0].switch == None assert m["capbank0c"].phase_capacitors[0].sections == None assert m["capbank0c"].phase_capacitors[0].normalsections == None # This is a 3-phase capacitor bank assert (len(m["capbank3"].phase_capacitors) == 3 ) # capbank3 is a three phase capacitor assert sum([ phase_capacitor.var for phase_capacitor in m["capbank3"].phase_capacitors ]) == pytest.approx(900 * 10**3, 0.0001) assert m["capbank3"].name == "capbank3" assert m["capbank3"].nominal_voltage == float(12.47112) * 10**3 assert (m["capbank3"].connection_type == parsed_values["Capacitor"] ["connection_type"]) assert m["capbank3"].delay == None assert m["capbank3"].mode == None assert m["capbank3"].low is None assert m["capbank3"].high is None assert m["capbank3"].resistance == 0.0 assert m["capbank3"].reactance == 0.0 assert m["capbank3"].susceptance is None assert m["capbank3"].conductance is None assert m["capbank3"].pt_ratio == None assert m["capbank3"].ct_ratio is None assert m["capbank3"].pt_phase == None assert m["capbank3"].connecting_element == "r18242" assert m["capbank3"].measuring_element == None assert m["capbank3"].feeder_name == "sourcebus_src" assert set([pc.phase for pc in m["capbank3"].phase_capacitors ]) == set(["A", "B", "C"]) assert [ phase_capacitor.switch for phase_capacitor in m["capbank3"].phase_capacitors ] == [None, None, None] assert [ phase_capacitor.sections for phase_capacitor in m["capbank3"].phase_capacitors ] == [None, None, None] assert [ phase_capacitor.normalsections for phase_capacitor in m["capbank3"].phase_capacitors ] == [None, None, None] # 3-phase capacitor with number of phases mentioned assert (len(m["capbank3-1"].phase_capacitors) == 3 ) # capbank3-1 is a three phase capacitor assert sum([ phase_capacitor.var for phase_capacitor in m["capbank3-1"].phase_capacitors ]) == pytest.approx(900 * 10**3, 0.0001) assert m["capbank3-1"].nominal_voltage == float(12.47112) * 10**3 assert m["capbank3-1"].name == "capbank3-1" assert (m["capbank3-1"].connection_type == parsed_values["Capacitor"] ["connection_type"]) assert m["capbank3-1"].delay == None assert m["capbank3-1"].mode == None assert m["capbank3-1"].low is None assert m["capbank3-1"].high is None assert m["capbank3-1"].resistance == 0.0 assert m["capbank3-1"].reactance == 0.0 assert m["capbank3-1"].susceptance is None assert m["capbank3-1"].conductance is None assert m["capbank3-1"].pt_ratio == None assert m["capbank3-1"].ct_ratio is None assert m["capbank3-1"].pt_phase == None assert m["capbank3-1"].connecting_element == "r18242" assert m["capbank3-1"].measuring_element == None assert m["capbank3-1"].feeder_name == "sourcebus_src" assert set([pc.phase for pc in m["capbank3-1"].phase_capacitors ]) == set(["A", "B", "C"]) assert [ phase_capacitor.switch for phase_capacitor in m["capbank3-1"].phase_capacitors ] == [None, None, None] assert [ phase_capacitor.sections for phase_capacitor in m["capbank3-1"].phase_capacitors ] == [None, None, None] assert [ phase_capacitor.normalsections for phase_capacitor in m["capbank3-1"].phase_capacitors ] == [None, None, None]
def test_capacitor_connectivity(): m = Store() r = Reader(master_file=os.path.join(current_directory, "test_capacitor_connectivity.dss")) r.parse(m) m.set_names() # Reading OpenDSS default values d_v = Default_Values( os.path.join( current_directory, "../../../../ditto/default_values/opendss_default_values.json", )) parsed_values = d_v.parse() # Capacitor Cap1 should be a three phase capacitor (3 PhaseCapacitor objects) connected to bus1 assert len( m["cap1"].phase_capacitors) == 3 # Cap1 is a three phase capacitor assert sum([ phase_capacitor.var for phase_capacitor in m["cap1"].phase_capacitors ]) == pytest.approx(600 * 10**3, 0.0001) assert m["cap1"].name == "cap1" assert m["cap1"].nominal_voltage == float(4.16) * 10**3 assert m["cap1"].connection_type == parsed_values["Capacitor"][ "connection_type"] assert m["cap1"].delay is None assert m["cap1"].mode is None assert m["cap1"].low is None assert m["cap1"].high is None assert m["cap1"].resistance == 0.0 assert m["cap1"].reactance == 0.0 assert m["cap1"].susceptance is None assert m["cap1"].conductance is None assert m["cap1"].pt_ratio is None assert m["cap1"].ct_ratio is None assert m["cap1"].pt_phase is None assert m["cap1"].connecting_element == "bus1" assert m["cap1"].measuring_element is None assert m["cap1"].feeder_name == "sourcebus_src" assert set([pc.phase for pc in m["cap1"].phase_capacitors]) == set(["A", "B", "C"]) # Capacitor Cap2 should be a one phase capacitor (1 PhaseCapacitor object) connected to bus2 on phase C assert len( m["cap2"].phase_capacitors) == 1 # Cap2 is a one phase capacitor assert m["cap2"].phase_capacitors[0].var == 100 * 10**3 assert m["cap2"].name == "cap2" assert m["cap2"].nominal_voltage == float(2.4) * 10**3 assert m["cap2"].connection_type == parsed_values["Capacitor"][ "connection_type"] assert m["cap2"].delay is None assert m["cap2"].mode is None assert m["cap2"].low is None assert m["cap2"].high is None assert m["cap2"].resistance == 0.0 assert m["cap2"].reactance == 0.0 assert m["cap2"].susceptance is None assert m["cap2"].conductance is None assert m["cap2"].pt_ratio is None assert m["cap2"].ct_ratio is None assert m["cap2"].pt_phase is None assert m["cap2"].connecting_element == "bus2" assert m["cap2"].measuring_element is None assert m["cap2"].feeder_name == "sourcebus_src" assert m["cap2"].phase_capacitors[0].phase == "C" # Capacitor Cap3 should be a one phase capacitor (1 PhaseCapacitor object) connected to bus3 on phase A assert len( m["cap3"].phase_capacitors) == 1 # Cap3 is a one phase capacitor assert m["cap3"].phase_capacitors[0].var == 200.37 * 10**3 assert m["cap3"].name == "cap3" assert m["cap3"].nominal_voltage == float(2.4) * 10**3 assert m["cap3"].connection_type == parsed_values["Capacitor"][ "connection_type"] assert m["cap3"].delay is None assert m["cap3"].mode is None assert m["cap3"].low is None assert m["cap3"].high is None assert m["cap3"].resistance == 0.0 assert m["cap3"].reactance == 0.0 assert m["cap3"].susceptance is None assert m["cap3"].conductance is None assert m["cap3"].pt_ratio is None assert m["cap3"].ct_ratio is None assert m["cap3"].pt_phase is None assert m["cap3"].connecting_element == "bus3" assert m["cap3"].measuring_element is None assert m["cap3"].feeder_name == "sourcebus_src" assert m["cap3"].phase_capacitors[0].phase == "A" # Capacitor Cap4 should be a two phase capacitor (2 PhaseCapacitor objects) connected to bus4 on phase A and C assert len( m["cap4"].phase_capacitors) == 2 # Cap4 is a two phase capacitor assert sum([ phase_capacitor.var for phase_capacitor in m["cap4"].phase_capacitors ]) == pytest.approx(400 * 10**3, 0.0001) assert m["cap4"].name == "cap4" assert m["cap4"].nominal_voltage == float(2.4) * 10**3 assert m["cap4"].connection_type == parsed_values["Capacitor"][ "connection_type"] assert m["cap4"].delay is None assert m["cap4"].mode is None assert m["cap4"].low is None assert m["cap4"].high is None assert m["cap4"].resistance == 0.0 assert m["cap4"].reactance == 0.0 assert m["cap4"].susceptance is None assert m["cap4"].conductance is None assert m["cap4"].pt_ratio is None assert m["cap4"].ct_ratio is None assert m["cap4"].pt_phase is None assert m["cap4"].connecting_element == "bus4" assert m["cap4"].measuring_element is None assert m["cap4"].feeder_name == "sourcebus_src" assert set([pc.phase for pc in m["cap4"].phase_capacitors]) == set(["A", "C"]) # Capacitors from epri_j1 assert len(m["b4909-1"].phase_capacitors ) == 3 # b4909-1 is a three phase capacitor assert sum([ phase_capacitor.var for phase_capacitor in m["b4909-1"].phase_capacitors ]) == pytest.approx(900 * 10**3, 0.0001) assert m["b4909-1"].name == "b4909-1" assert m["b4909-1"].nominal_voltage == float(12.47) * 10**3 assert m["b4909-1"].connection_type == parsed_values["Capacitor"][ "connection_type"] assert m["b4909-1"].delay == 30 assert m["b4909-1"].mode == "voltage" assert m["b4909-1"].low == parsed_values["Capacitor"]["low"] assert m["b4909-1"].high == parsed_values["Capacitor"]["high"] assert m["b4909-1"].resistance == 0.0 assert m["b4909-1"].reactance == 0.0 assert m["b4909-1"].susceptance is None assert m["b4909-1"].conductance is None assert m["b4909-1"].pt_ratio == parsed_values["Capacitor"]["pt_ratio"] assert m["b4909-1"].ct_ratio == parsed_values["Capacitor"]["ct_ratio"] assert m["b4909-1"].pt_phase == "B" assert m["b4909-1"].connecting_element == "b4909" assert m["b4909-1"].measuring_element == "Line.OH_B4904" assert m["b4909-1"].feeder_name == "sourcebus_src" assert set([pc.phase for pc in m["b4909-1"].phase_capacitors ]) == set(["A", "B", "C"]) assert len(m["b4909-2"].phase_capacitors ) == 3 # b4909-2 is a three phase capacitor assert sum([ phase_capacitor.var for phase_capacitor in m["b4909-2"].phase_capacitors ]) == pytest.approx(900 * 10**3, 0.0001) assert m["b4909-2"].name == "b4909-2" assert m["b4909-2"].nominal_voltage == float(12.47) * 10**3 assert m["b4909-2"].connection_type == parsed_values["Capacitor"][ "connection_type"] assert m["b4909-2"].delay == 30 assert m["b4909-2"].mode == "voltage" assert m["b4909-2"].low == 120.5 assert m["b4909-2"].high == 125 assert m["b4909-2"].resistance == 0.0 assert m["b4909-2"].reactance == 0.0 assert m["b4909-2"].susceptance is None assert m["b4909-2"].conductance is None assert m["b4909-2"].pt_ratio == parsed_values["Capacitor"]["pt_ratio"] assert m["b4909-2"].ct_ratio == parsed_values["Capacitor"]["ct_ratio"] assert m["b4909-2"].pt_phase == "B" assert m["b4909-2"].connecting_element == "b4909" assert m["b4909-2"].measuring_element == "Line.OH_B4904" assert m["b4909-2"].feeder_name == "sourcebus_src" assert set([pc.phase for pc in m["b4909-2"].phase_capacitors ]) == set(["A", "B", "C"]) # oh_b4904 assert len(m["oh_b4904"].wires) == 3 # Phases of the different wires assert set([w.phase for w in m["oh_b4904"].wires]) == set(["A", "B", "C"]) assert m["oh_b4904"].name == "oh_b4904" assert (m["oh_b4904"].nameclass == "OH-3X_477AAC_4/0AAACN" ) # Linecode is OH-3X_477AAC_4/0AAACN assert m["oh_b4904"].line_type == None assert m["oh_b4904"].from_element == "b4909" assert m["oh_b4904"].to_element == "b4904" assert m["oh_b4904"].length == pytest.approx(161.84879) assert m["oh_b4904"].nominal_voltage == float(4.16) * 10**3 assert m["oh_b4904"].is_fuse is None assert m["oh_b4904"].is_switch is None assert m["oh_b4904"].faultrate == parsed_values["Line"]["faultrate"] z1 = complex(0.12241009, 0.39494091) # Specified in the dss input z0 = complex(0.33466485, 1.2742766) # Specified in the dss input diag = ((2 * z1 + z0) / 3) * 0.001 # Units = km diag = round(diag.real, 10) + round(diag.imag, 10) * 1j rem = ((z0 - z1) / 3) * 0.001 # Units =km rem = round(rem.real, 11) + round(rem.imag, 10) * 1j imp_matrix = np.zeros((3, 3), dtype=np.complex_) imp_matrix.fill(rem) np.fill_diagonal(imp_matrix, diag) imp_matrix = imp_matrix.tolist() assert m["oh_b4904"].impedance_matrix == imp_matrix c1 = complex(11.1973, 0) # Specified in the dss input c0 = complex(4.8089, 0) # Specified in the dss input c_diag = ((2 * c1 + c0) / 3) * 0.001 # Units = km c_diag = round(c_diag.real, 9) + c_diag.imag * 1j c_rem = ((c0 - c1) / 3) * 0.001 # Units = km c_rem = round(c_rem.real, 9) + c_rem.imag * 1j cap_matrix = np.zeros((3, 3), dtype=np.complex_) cap_matrix.fill(c_rem) np.fill_diagonal(cap_matrix, c_diag) cap_matrix = cap_matrix.tolist() assert m["oh_b4904"].capacitance_matrix == cap_matrix assert m["oh_b4904"].feeder_name == "sourcebus_src" assert m["oh_b4904"].is_recloser is None assert m["oh_b4904"].is_breaker is None for w in m["oh_b4904"].wires: assert w.nameclass == "" assert w.X is None assert w.Y is None assert w.diameter is None assert w.gmr is None assert w.ampacity == float(732) assert w.emergency_ampacity == float(871) assert w.resistance is None assert w.insulation_thickness == 0.0 assert w.is_open is None assert w.concentric_neutral_gmr is None assert w.concentric_neutral_resistance is None assert w.concentric_neutral_diameter is None assert w.concentric_neutral_outside_diameter is None assert w.concentric_neutral_nstrand is None assert (len(m["b18944-1"].phase_capacitors) == 3 ) # b18944-1 is a three phase capacitor assert sum([ phase_capacitor.var for phase_capacitor in m["b18944-1"].phase_capacitors ]) == pytest.approx(1200 * 10**3, 0.0001) assert m["b18944-1"].name == "b18944-1" assert m["b18944-1"].nominal_voltage == float(12.47) * 10**3 assert (m["b18944-1"].connection_type == parsed_values["Capacitor"] ["connection_type"]) assert m["b18944-1"].delay == 31 assert m["b18944-1"].mode == "voltage" assert m["b18944-1"].low == parsed_values["Capacitor"]["low"] assert m["b18944-1"].high == parsed_values["Capacitor"]["high"] assert m["b18944-1"].resistance == 0.0 assert m["b18944-1"].reactance == 0.0 assert m["b18944-1"].susceptance is None assert m["b18944-1"].conductance is None assert m["b18944-1"].pt_ratio == parsed_values["Capacitor"]["pt_ratio"] assert m["b18944-1"].ct_ratio == parsed_values["Capacitor"]["ct_ratio"] assert m["b18944-1"].pt_phase == "A" assert m["b18944-1"].connecting_element == "b18941" assert m["b18944-1"].measuring_element == "Line.OH_B18944" assert m["b18944-1"].feeder_name == "sourcebus_src" assert set([pc.phase for pc in m["b18944-1"].phase_capacitors ]) == set(["A", "B", "C"]) assert (len(m["b18944-2"].phase_capacitors) == 3 ) # b18944-2 is a three phase capacitor assert sum([ phase_capacitor.var for phase_capacitor in m["b18944-2"].phase_capacitors ]) == pytest.approx(1200 * 10**3, 0.0001) assert m["b18944-2"].name == "b18944-2" assert m["b18944-2"].nominal_voltage == float(12.47) * 10**3 assert (m["b18944-2"].connection_type == parsed_values["Capacitor"] ["connection_type"]) assert m["b18944-2"].delay == 31 assert m["b18944-2"].mode == "voltage" assert m["b18944-2"].low == 118 assert m["b18944-2"].high == 124 assert m["b18944-2"].resistance == 0.0 assert m["b18944-2"].reactance == 0.0 assert m["b18944-2"].susceptance is None assert m["b18944-2"].conductance is None assert m["b18944-2"].pt_ratio == parsed_values["Capacitor"]["pt_ratio"] assert m["b18944-2"].ct_ratio == parsed_values["Capacitor"]["ct_ratio"] assert m["b18944-2"].pt_phase == "A" assert m["b18944-2"].connecting_element == "b18941" assert m["b18944-2"].measuring_element == "Line.OH_B18944" assert m["b18944-2"].feeder_name == "sourcebus_src" assert set([pc.phase for pc in m["b18944-2"].phase_capacitors ]) == set(["A", "B", "C"]) # oh_b18944 assert len(m["oh_b18944"].wires) == 3 # Number of wires # Phases of the different wires assert set([w.phase for w in m["oh_b18944"].wires]) == set(["A", "B", "C"]) assert m["oh_b18944"].name == "oh_b18944" assert m[ "oh_b18944"].nameclass == "OH-3X_4CU_4CUN" # Linecode is OH-3X_4CU_4CUN assert m["oh_b18944"].line_type == None assert m["oh_b18944"].from_element == "b18941" assert m["oh_b18944"].to_element == "b18944" assert m["oh_b18944"].length == pytest.approx(141.1224) assert m["oh_b18944"].nominal_voltage == float(4.16) * 10**3 assert m["oh_b18944"].is_fuse is None assert m["oh_b18944"].is_switch is None assert m["oh_b18944"].faultrate == parsed_values["Line"]["faultrate"] z1 = complex(0.85376372, 0.49484991) # Specified in the dss input z0 = complex(1.2302027, 1.5569817) # Specified in the dss input diag = ((2 * z1 + z0) / 3) * 0.001 # Units = km diag = round(diag.real, 10) + round(diag.imag, 10) * 1j rem = ((z0 - z1) / 3) * 0.001 # Units =km rem = round(rem.real, 10) + round(rem.imag, 10) * 1j imp_matrix = np.zeros((3, 3), dtype=np.complex_) imp_matrix.fill(rem) np.fill_diagonal(imp_matrix, diag) imp_matrix = imp_matrix.tolist() assert m["oh_b18944"].impedance_matrix == imp_matrix c1 = complex(8.7903, 0) # Specified in the dss input c0 = complex(4.2476, 0) # Specified in the dss input c_diag = ((2 * c1 + c0) / 3) * 0.001 # Units = km c_diag = round(c_diag.real, 9) + c_diag.imag * 1j c_rem = ((c0 - c1) / 3) * 0.001 # Units = km c_rem = round(c_rem.real, 9) + c_rem.imag * 1j cap_matrix = np.zeros((3, 3), dtype=np.complex_) cap_matrix.fill(c_rem) np.fill_diagonal(cap_matrix, c_diag) cap_matrix = cap_matrix.tolist() assert m["oh_b18944"].capacitance_matrix == cap_matrix assert m["oh_b18944"].feeder_name == "sourcebus_src" assert m["oh_b18944"].is_recloser is None assert m["oh_b18944"].is_breaker is None for w in m["oh_b18944"].wires: assert w.nameclass == "" assert w.X is None assert w.Y is None assert w.diameter is None assert w.gmr is None assert w.ampacity == float(142) assert w.emergency_ampacity == float(142) assert w.resistance is None assert w.insulation_thickness == 0.0 assert w.is_open is None assert w.concentric_neutral_gmr is None assert w.concentric_neutral_resistance is None assert w.concentric_neutral_diameter is None assert w.concentric_neutral_outside_diameter is None assert w.concentric_neutral_nstrand is None # Capacitors from ieee 8500-node test feeder assert (len(m["capbank0a"].phase_capacitors) == 1 ) # capbank0a is a single phase capacitor assert m["capbank0a"].phase_capacitors[0].var == 400 * 10**3 assert m["capbank0a"].name == "capbank0a" assert m["capbank0a"].nominal_voltage == float(7.2) * 10**3 assert (m["capbank0a"].connection_type == parsed_values["Capacitor"] ["connection_type"]) assert m["capbank0a"].delay == None assert m["capbank0a"].mode == None assert m["capbank0a"].low is None assert m["capbank0a"].high is None assert m["capbank0a"].resistance == 0.0 assert m["capbank0a"].reactance == 0.0 assert m["capbank0a"].susceptance is None assert m["capbank0a"].conductance is None assert m["capbank0a"].pt_ratio == None assert m["capbank0a"].ct_ratio is None assert m["capbank0a"].pt_phase == None assert m["capbank0a"].connecting_element == "r42246" assert m["capbank0a"].measuring_element == None assert m["capbank0a"].feeder_name == "sourcebus_src" assert m["capbank0a"].phase_capacitors[0].phase == "A" assert (len(m["capbank0b"].phase_capacitors) == 1 ) # capbank0b is a single phase capacitor assert m["capbank0b"].phase_capacitors[0].var == 400 * 10**3 assert m["capbank0b"].name == "capbank0b" assert m["capbank0b"].nominal_voltage == float(7.2) * 10**3 assert (m["capbank0b"].connection_type == parsed_values["Capacitor"] ["connection_type"]) assert m["capbank0b"].delay == None assert m["capbank0b"].mode == None assert m["capbank0b"].low is None assert m["capbank0b"].high is None assert m["capbank0b"].resistance == 0.0 assert m["capbank0b"].reactance == 0.0 assert m["capbank0b"].susceptance is None assert m["capbank0b"].conductance is None assert m["capbank0b"].pt_ratio == None assert m["capbank0b"].ct_ratio is None assert m["capbank0b"].pt_phase == None assert m["capbank0b"].connecting_element == "r42246" assert m["capbank0b"].measuring_element == None assert m["capbank0b"].feeder_name == "sourcebus_src" assert m["capbank0b"].phase_capacitors[0].phase == "B" assert (len(m["capbank0c"].phase_capacitors) == 1 ) # capbank0c is a single phase capacitor assert m["capbank0c"].phase_capacitors[0].var == 400 * 10**3 assert m["capbank0c"].name == "capbank0c" assert m["capbank0c"].nominal_voltage == float(7.2) * 10**3 assert (m["capbank0c"].connection_type == parsed_values["Capacitor"] ["connection_type"]) assert m["capbank0c"].delay == None assert m["capbank0c"].mode == None assert m["capbank0c"].low is None assert m["capbank0c"].high is None assert m["capbank0c"].resistance == 0.0 assert m["capbank0c"].reactance == 0.0 assert m["capbank0c"].susceptance is None assert m["capbank0c"].conductance is None assert m["capbank0c"].pt_ratio == None assert m["capbank0c"].ct_ratio is None assert m["capbank0c"].pt_phase == None assert m["capbank0c"].connecting_element == "r42246" assert m["capbank0c"].measuring_element == None assert m["capbank0c"].feeder_name == "sourcebus_src" assert m["capbank0c"].phase_capacitors[0].phase == "C" # This is a 3-phase capacitor bank assert (len(m["capbank3"].phase_capacitors) == 3 ) # capbank3 is a three phase capacitor assert sum([ phase_capacitor.var for phase_capacitor in m["capbank3"].phase_capacitors ]) == pytest.approx(900 * 10**3, 0.0001) assert m["capbank3"].name == "capbank3" assert m["capbank3"].nominal_voltage == float(12.47112) * 10**3 assert (m["capbank3"].connection_type == parsed_values["Capacitor"] ["connection_type"]) assert m["capbank3"].delay == None assert m["capbank3"].mode == None assert m["capbank3"].low is None assert m["capbank3"].high is None assert m["capbank3"].resistance == 0.0 assert m["capbank3"].reactance == 0.0 assert m["capbank3"].susceptance is None assert m["capbank3"].conductance is None assert m["capbank3"].pt_ratio == None assert m["capbank3"].ct_ratio is None assert m["capbank3"].pt_phase == None assert m["capbank3"].connecting_element == "r18242" assert m["capbank3"].measuring_element == None assert m["capbank3"].feeder_name == "sourcebus_src" assert set([pc.phase for pc in m["capbank3"].phase_capacitors ]) == set(["A", "B", "C"]) # 3-phase capacitor with number of phases mentioned assert (len(m["capbank3-1"].phase_capacitors) == 3 ) # capbank3-1 is a three phase capacitor assert sum([ phase_capacitor.var for phase_capacitor in m["capbank3-1"].phase_capacitors ]) == pytest.approx(900 * 10**3, 0.0001) assert m["capbank3-1"].nominal_voltage == float(12.47112) * 10**3 assert m["capbank3-1"].name == "capbank3-1" assert (m["capbank3-1"].connection_type == parsed_values["Capacitor"] ["connection_type"]) assert m["capbank3-1"].delay == None assert m["capbank3-1"].mode == None assert m["capbank3-1"].low is None assert m["capbank3-1"].high is None assert m["capbank3-1"].resistance == 0.0 assert m["capbank3-1"].reactance == 0.0 assert m["capbank3-1"].susceptance is None assert m["capbank3-1"].conductance is None assert m["capbank3-1"].pt_ratio == None assert m["capbank3-1"].ct_ratio is None assert m["capbank3-1"].pt_phase == None assert m["capbank3-1"].connecting_element == "r18242" assert m["capbank3-1"].measuring_element == None assert m["capbank3-1"].feeder_name == "sourcebus_src" assert set([pc.phase for pc in m["capbank3-1"].phase_capacitors ]) == set(["A", "B", "C"])
def test_linecodes(): """Tests if linecodes are read correctly.""" from ditto.store import Store from ditto.readers.opendss.read import Reader # test on the test_linecodes.dss m = Store() r = Reader( master_file=os.path.join(current_directory, "test_linecodes.dss")) r.parse(m) m.set_names() # Reading OpenDSS default values d_v = Default_Values( os.path.join( current_directory, "../../../../ditto/default_values/opendss_default_values.json", )) parsed_values = d_v.parse() # Line 1 assert len(m["line1"].wires) == 3 # Phases of the different wires assert set([w.phase for w in m["line1"].wires]) == set(["A", "B", "C"]) assert m[ "line1"].nameclass == "3-1/0C_2/0CN_T" # Linecode is 3-1/0C_2/0CN_T assert m["line1"].line_type == None assert m["line1"].from_element == "bus1" assert m["line1"].to_element == "bus2" assert m["line1"].length == 10 assert m["line1"].nominal_voltage == float(12.47) * 10**3 assert m["line1"].is_fuse is None assert m["line1"].is_switch is None assert m["line1"].faultrate == parsed_values["Line"]["faultrate"] z1 = complex(0.3489, 0.426198) # r1,x1 values from linecode z0 = complex(0.588811, 1.29612) # r0,x0 values from linecode diag = ((2 * z1 + z0) / 3) * 0.001 # Units = km diag = round(diag.real, 10) + diag.imag * 1j rem = ((z0 - z1) / 3) * 0.001 # Units = km rem = round(rem.real, 11) + round(rem.imag, 10) * 1j imp_matrix = np.zeros((3, 3), dtype=np.complex_) imp_matrix.fill(rem) np.fill_diagonal(imp_matrix, diag) imp_matrix = imp_matrix.tolist() assert m["line1"].impedance_matrix == imp_matrix c1 = complex(10.4308823411236, 0) # Value in Linecode c0 = complex(4.48501282215346, 0) # Value in Linecode c_diag = ((2 * c1 + c0) / 3) * 0.001 # Units = km c_diag = round(c_diag.real, 9) + c_diag.imag * 1j c_rem = ((c0 - c1) / 3) * 0.001 # Units = km c_rem = round(c_rem.real, 9) + c_rem.imag * 1j cap_matrix = np.zeros((3, 3), dtype=np.complex_) cap_matrix.fill(c_rem) np.fill_diagonal(cap_matrix, c_diag) cap_matrix = cap_matrix.tolist() assert m["line1"].capacitance_matrix == cap_matrix assert m["line1"].feeder_name == "sourcebus_src" assert m["line1"].is_recloser is None assert m["line1"].is_breaker is None for w in m["line1"].wires: assert w.nameclass == "" assert w.X is None assert w.Y is None assert w.diameter is None assert w.gmr is None assert w.ampacity == float(310) assert w.emergency_ampacity == float(310) assert w.resistance is None assert w.is_open is None assert w.concentric_neutral_gmr is None assert w.concentric_neutral_resistance is None assert w.concentric_neutral_diameter is None assert w.concentric_neutral_outside_diameter is None assert w.concentric_neutral_nstrand is None # Line 2 assert len(m["line2"].wires) == 3 # Phases of the different wires assert set([w.phase for w in m["line2"].wires]) == set(["C", "N"]) assert m["line2"].nameclass == "1P_#8CU_#8N" # Linecode is 1P_#8CU_#8N assert m["line2"].line_type == None assert m["line2"].from_element == "bus2" assert m["line2"].to_element == "bus3" assert m["line2"].length == 10 assert m["line2"].nominal_voltage == float(12.47) * 10**3 assert m["line2"].is_fuse is None assert m["line2"].is_switch is None assert m["line2"].faultrate == parsed_values["Line"]["faultrate"] z1 = complex(2.15622, 0.539412) # r1,x1 values from linecode z0 = complex(2.5511, 1.78041) # r0,x0 values from linecode diag = ((2 * z1 + z0) / 3) * 0.001 # Units = km diag = round(diag.real, 9) + diag.imag * 1j rem = ((z0 - z1) / 3) * 0.001 # Units = km rem = round(rem.real, 10) + round(rem.imag, 10) * 1j imp_matrix = np.zeros((3, 3), dtype=np.complex_) imp_matrix.fill(rem) np.fill_diagonal(imp_matrix, diag) imp_matrix = imp_matrix.tolist() assert m["line2"].impedance_matrix == imp_matrix c1 = complex(8.05740467479414, 0) # Value in Linecode c0 = complex(4.52209592389387, 0) # Value in Linecode c_diag = ((2 * c1 + c0) / 3) * 0.001 # Units = km c_diag = round(c_diag.real, 9) + c_diag.imag * 1j c_rem = ((c0 - c1) / 3) * 0.001 # Units = km c_rem = round(c_rem.real, 9) + c_rem.imag * 1j cap_matrix = np.zeros((3, 3), dtype=np.complex_) cap_matrix.fill(c_rem) np.fill_diagonal(cap_matrix, c_diag) cap_matrix = cap_matrix.tolist() assert m["line2"].capacitance_matrix == cap_matrix assert m["line2"].feeder_name == "sourcebus_src" assert m["line2"].is_recloser is None assert m["line2"].is_breaker is None for w in m["line2"].wires: assert w.nameclass == "" assert w.X is None assert w.Y is None assert w.diameter is None assert w.gmr is None assert w.ampacity == float(1) assert w.emergency_ampacity == float(1) assert w.resistance is None assert w.insulation_thickness == parsed_values["Wire"][ "insulation_thickness"] assert w.is_open is None assert w.concentric_neutral_gmr is None assert w.concentric_neutral_resistance is None assert w.concentric_neutral_diameter is None assert w.concentric_neutral_outside_diameter is None assert w.concentric_neutral_nstrand is None # Line 3 assert len(m["line3"].wires) == 3 # Number of wires # Phases of the different wires assert set([w.phase for w in m["line3"].wires]) == set(["A", "B", "C"]) assert (m["line3"].nameclass == "3P_3#500_AL_EPR_CD" ) # Linecode is 3P_3#500_AL_EPR_CD assert m["line3"].line_type == None assert m["line3"].from_element == "bus2" assert m["line3"].to_element == "bus4" assert m["line3"].length == 10 assert m["line3"].nominal_voltage == float(12.47) * 10**3 assert m["line3"].is_fuse is None assert m["line3"].is_switch is None assert m["line3"].faultrate == parsed_values["Line"]["faultrate"] z1 = complex(0.072514, 0.001056) # r1,x1 values from linecode z0 = complex(0.140678, -0.043807) # r0,x0 values from linecode diag = ((2 * z1 + z0) / 3) * 0.001 # Units = km diag = round(diag.real, 11) + round(diag.imag, 11) * 1j rem = ((z0 - z1) / 3) * 0.001 # Units = km rem = round(rem.real, 11) + round(rem.imag, 11) * 1j imp_matrix = np.zeros((3, 3), dtype=np.complex_) imp_matrix.fill(rem) np.fill_diagonal(imp_matrix, diag) imp_matrix = imp_matrix.tolist() assert m["line3"].impedance_matrix == imp_matrix assert m["line3"].capacitance_matrix == [[0j, 0j, 0j], [0j, 0j, 0j], [0j, 0j, 0j]] assert m["line3"].feeder_name == "sourcebus_src" assert m["line3"].is_recloser is None assert m["line3"].is_breaker is None for w in m["line3"].wires: assert w.nameclass == "" assert w.X is None assert w.Y is None assert w.diameter is None assert w.gmr is None assert w.ampacity == float(1110) assert w.emergency_ampacity == float(1110) assert w.resistance is None assert w.insulation_thickness == parsed_values["Wire"][ "insulation_thickness"] assert w.is_open is None assert w.concentric_neutral_gmr is None assert w.concentric_neutral_resistance is None assert w.concentric_neutral_diameter is None assert w.concentric_neutral_outside_diameter is None assert w.concentric_neutral_nstrand is None # Line 4 assert len(m["line4"].wires) == 3 # Number of wires # Phases of the different wires assert set([w.phase for w in m["line4"].wires]) == set(["A", "B", "C"]) assert (m["line4"].nameclass == "3ph_h-397_acsr397_acsr397_acsr2/0_acsr" ) # Linecode is 3ph_h-397_acsr397_acsr397_acsr2/0_acsr assert m["line4"].line_type == None assert m["line4"].from_element == "bus4" assert m["line4"].to_element == "bus5" assert m["line4"].length == 10 assert m["line4"].nominal_voltage == float(12.47) * 10**3 assert m["line4"].is_fuse is None assert m["line4"].is_switch is None assert m["line4"].faultrate == parsed_values["Line"]["faultrate"] actual_impedance_matrix = [ [ (0.000270019 + 0.000695974j), (0.000109951 + 0.00033351j), (0.000113538 + 0.000308271j), ], [ (0.000109951 + 0.00033351j), (0.000264634 + 0.000708729j), (0.000110747 + 0.000350259j), ], [ (0.000113538 + 0.000308271j), (0.000110747 + 0.000350259j), (0.000271698 + 0.000692021j), ], ] assert m["line4"].impedance_matrix == actual_impedance_matrix assert m["line4"].capacitance_matrix == [ [(0.00913606 + 0j), (-0.00266777 + 0j), (-0.00217646 + 0j)], [(-0.00266777 + 0j), (0.00962226 + 0j), (-0.00315664 + 0j)], [(-0.00217646 + 0j), (-0.00315664 + 0j), (0.00943197 + 0j)], ] assert m["line4"].feeder_name == "sourcebus_src" assert m["line4"].is_recloser is None assert m["line4"].is_breaker is None for w in m["line4"].wires: assert w.nameclass == "" assert w.X is None assert w.Y is None assert w.diameter is None assert w.gmr is None assert w.ampacity == parsed_values["Wire"]["ampacity"] assert w.emergency_ampacity == parsed_values["Wire"][ "emergency_ampacity"] assert w.resistance is None assert w.insulation_thickness == parsed_values["Wire"][ "insulation_thickness"] assert w.is_open is None assert w.concentric_neutral_gmr is None assert w.concentric_neutral_resistance is None assert w.concentric_neutral_diameter is None assert w.concentric_neutral_outside_diameter is None assert w.concentric_neutral_nstrand is None # Line 5 assert len(m["line5"].wires) == 1 # Number of wires # Phases of the different wires assert set([w.phase for w in m["line5"].wires]) == set(["B"]) assert (m["line5"].nameclass == "1ph-2_acsrxx4_acsr" ) # Linecode is 1ph-2_acsrxx4_acsr assert m["line5"].line_type == None assert m["line5"].from_element == "bus5" assert m["line5"].to_element == "bus6" assert m["line5"].length == 10 assert m["line5"].nominal_voltage == float(12.47) * 10**3 assert m["line5"].is_fuse is None assert m["line5"].is_switch is None assert m["line5"].faultrate == parsed_values["Line"]["faultrate"] actual_impedance_matrix = [[(0.00112339 + 0.000937794j)]] assert m["line5"].impedance_matrix == actual_impedance_matrix assert m["line5"].capacitance_matrix == [[(0.00649582 + 0j)]] assert m["line5"].feeder_name == "sourcebus_src" assert m["line5"].is_recloser is None assert m["line5"].is_breaker is None for w in m["line5"].wires: assert w.nameclass == "" assert w.X is None assert w.Y is None assert w.diameter is None assert w.gmr is None assert w.ampacity == parsed_values["Wire"]["ampacity"] assert w.emergency_ampacity == parsed_values["Wire"][ "emergency_ampacity"] assert w.resistance is None assert w.insulation_thickness == parsed_values["Wire"][ "insulation_thickness"] assert w.is_open is None assert w.concentric_neutral_gmr is None assert w.concentric_neutral_resistance is None assert w.concentric_neutral_diameter is None assert w.concentric_neutral_outside_diameter is None assert w.concentric_neutral_nstrand is None # Line 6 assert len(m["line6"].wires) == 2 # Number of wires # Phases of the different wires assert set([w.phase for w in m["line6"].wires]) == set(["A", "C"]) assert (m["line6"].nameclass == "2ph_h-2_acsrx2_acsr2_acsr" ) # Linecode is 2ph_h-2_acsrx2_acsr2_acsr assert m["line6"].line_type == None assert m["line6"].from_element == "bus5" assert m["line6"].to_element == "bus7" assert m["line6"].length == 10 assert m["line6"].nominal_voltage == float(12.47) * 10**3 assert m["line6"].is_fuse is None assert m["line6"].is_switch is None assert m["line6"].faultrate == parsed_values["Line"]["faultrate"] actual_impedance_matrix = [ [(0.00113148 + 0.000884886j), (0.000142066 + 0.000366115j)], [(0.000142066 + 0.000366115j), (0.00113362 + 0.000882239j)], ] assert m["line6"].impedance_matrix == actual_impedance_matrix assert m["line6"].capacitance_matrix == [ [(0.00733718 + 0j), (-0.00239809 + 0j)], [(-0.00239809 + 0j), (0.00733718 + 0j)], ] assert m["line6"].feeder_name == "sourcebus_src" assert m["line6"].is_recloser is None assert m["line6"].is_breaker is None for w in m["line6"].wires: assert w.nameclass == "" assert w.X is None assert w.Y is None assert w.diameter is None assert w.gmr is None assert w.ampacity == parsed_values["Wire"]["ampacity"] assert w.emergency_ampacity == parsed_values["Wire"][ "emergency_ampacity"] assert w.resistance is None assert w.insulation_thickness == parsed_values["Wire"][ "insulation_thickness"] assert w.is_open is None assert w.interrupting_rating is None assert w.concentric_neutral_gmr is None assert w.concentric_neutral_resistance is None assert w.concentric_neutral_diameter is None assert w.concentric_neutral_outside_diameter is None assert w.concentric_neutral_nstrand is None # Line 7 assert len(m["line7"].wires) == 2 # Number of wires # Phases of the different wires assert set([w.phase for w in m["line7"].wires]) == set(["A", "B"]) assert m["line7"].nameclass == "750_Triplex" # Linecode is 750_Triplex assert m["line7"].line_type == None assert m["line7"].from_element == "bus5" assert m["line7"].to_element == "bus8" assert m["line7"].length == 10 assert m["line7"].nominal_voltage == float(12.47) * 10**3 assert m["line7"].is_fuse is None assert m["line7"].is_switch is None assert m["line7"].faultrate == parsed_values["Line"]["faultrate"] actual_impedance_matrix = [ [(0.000163213 + 9.128727e-05j), (7.684242e-05 + 2.19643e-05j)], [(7.684242e-05 + 2.19643e-05j), (0.000163213 + 9.128727e-05j)], ] # Converted from meters to kft assert m["line7"].impedance_matrix == actual_impedance_matrix assert m["line7"].capacitance_matrix == [ [(0.00984252 + 0j), (-0.007874016 + 0j)], [(-0.007874016 + 0j), (0.00984252 + 0j)], ] # Converted from meters to kft assert m["line7"].feeder_name == "sourcebus_src" assert m["line7"].is_recloser is None assert m["line7"].is_breaker is None for w in m["line7"].wires: assert w.nameclass == "" assert w.X is None assert w.Y is None assert w.diameter is None assert w.gmr is None assert w.ampacity == float(580) assert w.emergency_ampacity == float(580 * 1.25) assert w.resistance is None assert w.insulation_thickness == parsed_values["Wire"][ "insulation_thickness"] assert w.is_open is None assert w.interrupting_rating is None assert w.concentric_neutral_gmr is None assert w.concentric_neutral_resistance is None assert w.concentric_neutral_diameter is None assert w.concentric_neutral_outside_diameter is None assert w.concentric_neutral_nstrand is None # Line 8 assert len(m["line8"].wires) == 2 # Number of wires # Phases of the different wires assert set([w.phase for w in m["line8"].wires]) == set(["B", "C"]) assert m["line8"].nameclass == "4/0Triplex" # Linecode is 4/0Triplex assert m["line8"].line_type == None assert m["line8"].from_element == "bus5" assert m["line8"].to_element == "bus9" assert m["line8"].length == 10 assert m["line8"].nominal_voltage == float(12.47) * 10**3 assert m["line8"].is_fuse is None assert m["line8"].is_switch is None assert m["line8"].faultrate == parsed_values["Line"]["faultrate"] actual_impedance_matrix = [ [(0.001344984 + 0.0005473038j), (0.0003874511 + 0.0004186106j)], [(0.0003874511 + 0.0004186106j), (0.001344984 + 0.0005473038j)], ] # Converted from meters to kft assert m["line8"].impedance_matrix == actual_impedance_matrix assert m["line8"].capacitance_matrix == [ [(0.00984252 + 0j), (-0.007874016 + 0j)], [(-0.007874016 + 0j), (0.00984252 + 0j)], ] # Converted from meters to kft assert m["line8"].feeder_name == "sourcebus_src" assert m["line8"].is_recloser is None assert m["line8"].is_breaker is None for w in m["line8"].wires: assert w.nameclass == "" assert w.X is None assert w.Y is None assert w.diameter is None assert w.gmr is None assert w.ampacity == float(156) assert w.emergency_ampacity == float(156 * 1.25) assert w.resistance is None assert w.insulation_thickness == parsed_values["Wire"][ "insulation_thickness"] assert w.is_open is None assert w.concentric_neutral_gmr is None assert w.concentric_neutral_resistance is None assert w.concentric_neutral_diameter is None assert w.concentric_neutral_outside_diameter is None assert w.concentric_neutral_nstrand is None # Line 9 assert len(m["line9"].wires) == 3 # Number of wires # Phases of the different wires assert set([w.phase for w in m["line9"].wires]) == set(["A", "B", "C"]) assert m["line9"].nameclass == "empty" # Linecode is empty assert m["line9"].line_type == None assert m["line9"].from_element == "bus4" assert m["line9"].to_element == "bus10" assert m["line9"].length == 10 assert m["line9"].nominal_voltage == float(12.47) * 10**3 assert m["line9"].is_fuse is None assert m["line9"].is_switch is None assert m["line9"].faultrate == parsed_values["Line"]["faultrate"] z1 = complex( parsed_values["Line"]["R1"], parsed_values["Line"]["X1"]) # r1,x1 taken from default values z0 = complex( parsed_values["Line"]["R0"], parsed_values["Line"]["X0"]) # r0,x0 taken from default values diag = ((2 * z1 + z0) / 3) * 0.001 # Units = km diag = round(diag.real, 11) + round(diag.imag, 10) * 1j rem = ((z0 - z1) / 3) * 0.001 # Units = km rem = round(rem.real, 11) + round(rem.imag, 10) * 1j imp_matrix = np.zeros((3, 3), dtype=np.complex_) imp_matrix.fill(rem) np.fill_diagonal(imp_matrix, diag) imp_matrix = imp_matrix.tolist() assert m["line9"].impedance_matrix == imp_matrix c1 = complex(parsed_values["Line"]["C1"], 0) # c1 taken from default values c0 = complex(parsed_values["Line"]["C0"], 0) # c0 taken from default values c_diag = ((2 * c1 + c0) / 3) * 0.001 # Units = km c_diag = round(c_diag.real, 10) + c_diag.imag * 1j c_rem = ((c0 - c1) / 3) * 0.001 # Units = km c_rem = round(c_rem.real, 10) + c_rem.imag * 1j cap_matrix = np.zeros((3, 3), dtype=np.complex_) cap_matrix.fill(c_rem) np.fill_diagonal(cap_matrix, c_diag) cap_matrix = cap_matrix.tolist() assert m["line9"].capacitance_matrix == cap_matrix assert m["line9"].feeder_name == "sourcebus_src" assert m["line9"].is_recloser is None assert m["line9"].is_breaker is None for w in m["line9"].wires: assert w.nameclass == "" assert w.X is None assert w.Y is None assert w.diameter is None assert w.gmr is None assert w.ampacity == parsed_values["Wire"]["ampacity"] assert w.emergency_ampacity == parsed_values["Wire"][ "emergency_ampacity"] assert w.resistance is None assert w.insulation_thickness == parsed_values["Wire"][ "insulation_thickness"] assert w.is_open is None assert w.concentric_neutral_gmr is None assert w.concentric_neutral_resistance is None assert w.concentric_neutral_diameter is None assert w.concentric_neutral_outside_diameter is None assert w.concentric_neutral_nstrand is None # Line 10 assert len(m["line10"].wires) == 3 # Number of wires # Phases of the different wires assert set([w.phase for w in m["line10"].wires]) == set(["A", "B", "C"]) assert m["line10"].nameclass == "r1_only" # Linecode is r1_only assert m["line10"].line_type == None assert m["line10"].from_element == "bus10" assert m["line10"].to_element == "bus11" assert m["line10"].length == 10 assert m["line10"].nominal_voltage == float(12.47) * 10**3 assert m["line10"].is_fuse is None assert m["line10"].is_switch is None assert m["line10"].faultrate == parsed_values["Line"]["faultrate"] z1 = complex( 0.3489, parsed_values["Line"] ["X1"]) # r1 taken from linecode, x1 taken from default values z0 = complex( parsed_values["Line"]["R0"], parsed_values["Line"]["X0"]) # r0,x0 taken from default values diag = ((2 * z1 + z0) / 3) * 0.001 # Units = km diag = round(diag.real, 10) + round(diag.imag, 10) * 1j rem = ((z0 - z1) / 3) * 0.001 # Units = km rem = round(rem.real, 11) + round(rem.imag, 10) * 1j imp_matrix = np.zeros((3, 3), dtype=np.complex_) imp_matrix.fill(rem) np.fill_diagonal(imp_matrix, diag) imp_matrix = imp_matrix.tolist() assert m["line10"].impedance_matrix == imp_matrix c1 = complex(parsed_values["Line"]["C1"], 0) # c1 taken from default values c0 = complex(parsed_values["Line"]["C0"], 0) # c0 taken from default values c_diag = ((2 * c1 + c0) / 3) * 0.001 # Units = km c_diag = round(c_diag.real, 10) + c_diag.imag * 1j c_rem = ((c0 - c1) / 3) * 0.001 # Units = km c_rem = round(c_rem.real, 10) + c_rem.imag * 1j cap_matrix = np.zeros((3, 3), dtype=np.complex_) cap_matrix.fill(c_rem) np.fill_diagonal(cap_matrix, c_diag) cap_matrix = cap_matrix.tolist() assert m["line10"].capacitance_matrix == cap_matrix assert m["line10"].feeder_name == "sourcebus_src" assert m["line10"].is_recloser is None assert m["line10"].is_breaker is None for w in m["line10"].wires: assert w.nameclass == "" assert w.X is None assert w.Y is None assert w.diameter is None assert w.gmr is None assert w.ampacity == parsed_values["Wire"]["ampacity"] assert w.emergency_ampacity == parsed_values["Wire"][ "emergency_ampacity"] assert w.resistance is None assert w.insulation_thickness == parsed_values["Wire"][ "insulation_thickness"] assert w.is_open is None assert w.concentric_neutral_gmr is None assert w.concentric_neutral_resistance is None assert w.concentric_neutral_diameter is None assert w.concentric_neutral_outside_diameter is None assert w.concentric_neutral_nstrand is None # Line 11 assert len(m["line11"].wires) == 3 # Number of wires # Phases of the different wires assert set([w.phase for w in m["line11"].wires]) == set(["A", "B", "C"]) assert m["line11"].nameclass == "r0_only" # Linecode is r0_only assert m["line11"].line_type == None assert m["line11"].from_element == "bus11" assert m["line11"].to_element == "bus12" assert m["line11"].length == 10 assert m["line11"].nominal_voltage == float(12.47) * 10**3 assert m["line11"].is_fuse is None assert m["line11"].is_switch is None assert m["line11"].faultrate == parsed_values["Line"]["faultrate"] z1 = complex( parsed_values["Line"]["R1"], parsed_values["Line"]["X1"]) # r1,x1 taken from default values z0 = complex(0.588811, parsed_values["Line"] ["X0"]) # r0 taken from linecode,x0 taken from default values diag = ((2 * z1 + z0) / 3) * 0.001 # Units = km diag = round(diag.real, 10) + round(diag.imag, 10) * 1j rem = ((z0 - z1) / 3) * 0.001 # Units = km rem = round(rem.real, 11) + round(rem.imag, 10) * 1j imp_matrix = np.zeros((3, 3), dtype=np.complex_) imp_matrix.fill(rem) np.fill_diagonal(imp_matrix, diag) imp_matrix = imp_matrix.tolist() assert m["line11"].impedance_matrix == imp_matrix c1 = complex(parsed_values["Line"]["C1"], 0) # c1 taken from default values c0 = complex(parsed_values["Line"]["C0"], 0) # c0 taken from default values c_diag = ((2 * c1 + c0) / 3) * 0.001 # Units = km c_diag = round(c_diag.real, 10) + c_diag.imag * 1j c_rem = ((c0 - c1) / 3) * 0.001 # Units = km c_rem = round(c_rem.real, 10) + c_rem.imag * 1j cap_matrix = np.zeros((3, 3), dtype=np.complex_) cap_matrix.fill(c_rem) np.fill_diagonal(cap_matrix, c_diag) cap_matrix = cap_matrix.tolist() assert m["line11"].capacitance_matrix == cap_matrix assert m["line11"].feeder_name == "sourcebus_src" assert m["line11"].is_recloser is None assert m["line11"].is_breaker is None for w in m["line11"].wires: assert w.nameclass == "" assert w.X is None assert w.Y is None assert w.diameter is None assert w.gmr is None assert w.ampacity == parsed_values["Wire"]["ampacity"] assert w.emergency_ampacity == parsed_values["Wire"][ "emergency_ampacity"] assert w.resistance is None assert w.insulation_thickness == parsed_values["Wire"][ "insulation_thickness"] assert w.is_open is None assert w.concentric_neutral_gmr is None assert w.concentric_neutral_resistance is None assert w.concentric_neutral_diameter is None assert w.concentric_neutral_outside_diameter is None assert w.concentric_neutral_nstrand is None # Line 12 assert len(m["line12"].wires) == 3 # Number of wires # Phases of the different wires assert set([w.phase for w in m["line12"].wires]) == set(["A", "B", "C"]) assert m["line12"].nameclass == "x1_only" # Linecode is x1_only assert m["line12"].line_type == None assert m["line12"].from_element == "bus12" assert m["line12"].to_element == "bus13" assert m["line12"].length == 10 assert m["line12"].nominal_voltage == float(12.47) * 10**3 assert m["line12"].is_fuse is None assert m["line12"].is_switch is None assert m["line12"].faultrate == parsed_values["Line"]["faultrate"] z1 = complex( parsed_values["Line"]["R1"], 0.426198) # r1 taken from default values, x1 taken from linecode z0 = complex( parsed_values["Line"]["R0"], parsed_values["Line"]["X0"]) # r0,x0 taken from default values diag = ((2 * z1 + z0) / 3) * 0.001 # Units = km diag = round(diag.real, 11) + round(diag.imag, 10) * 1j rem = ((z0 - z1) / 3) * 0.001 # Units = km rem = round(rem.real, 11) + round(rem.imag, 10) * 1j imp_matrix = np.zeros((3, 3), dtype=np.complex_) imp_matrix.fill(rem) np.fill_diagonal(imp_matrix, diag) imp_matrix = imp_matrix.tolist() assert m["line12"].impedance_matrix == imp_matrix c1 = complex(parsed_values["Line"]["C1"], 0) # c1 taken from default values c0 = complex(parsed_values["Line"]["C0"], 0) # c0 taken from default values c_diag = ((2 * c1 + c0) / 3) * 0.001 # Units = km c_diag = round(c_diag.real, 10) + c_diag.imag * 1j c_rem = ((c0 - c1) / 3) * 0.001 # Units = km c_rem = round(c_rem.real, 10) + c_rem.imag * 1j cap_matrix = np.zeros((3, 3), dtype=np.complex_) cap_matrix.fill(c_rem) np.fill_diagonal(cap_matrix, c_diag) cap_matrix = cap_matrix.tolist() assert m["line12"].capacitance_matrix == cap_matrix assert m["line12"].feeder_name == "sourcebus_src" assert m["line12"].is_recloser is None assert m["line12"].is_breaker is None for w in m["line12"].wires: assert w.nameclass == "" assert w.X is None assert w.Y is None assert w.diameter is None assert w.gmr is None assert w.ampacity == parsed_values["Wire"]["ampacity"] assert w.emergency_ampacity == parsed_values["Wire"][ "emergency_ampacity"] assert w.resistance is None assert w.insulation_thickness == parsed_values["Wire"][ "insulation_thickness"] assert w.is_open is None assert w.concentric_neutral_gmr is None assert w.concentric_neutral_resistance is None assert w.concentric_neutral_diameter is None assert w.concentric_neutral_outside_diameter is None assert w.concentric_neutral_nstrand is None # Line 13 assert len(m["line13"].wires) == 3 # Number of wires # Phases of the different wires assert set([w.phase for w in m["line13"].wires]) == set(["A", "B", "C"]) assert m["line13"].nameclass == "x0_only" # Linecode is x0_only assert m["line13"].line_type == None assert m["line13"].from_element == "bus13" assert m["line13"].to_element == "bus14" assert m["line13"].length == 10 assert m["line13"].nominal_voltage == float(12.47) * 10**3 assert m["line13"].is_fuse is None assert m["line13"].is_switch is None assert m["line13"].faultrate == parsed_values["Line"]["faultrate"] z1 = complex( parsed_values["Line"]["R1"], parsed_values["Line"]["X1"]) # r1,x1 taken from default values z0 = complex( parsed_values["Line"]["R0"], 1.29612) # r0 taken from default values, x0 taken from linecode diag = ((2 * z1 + z0) / 3) * 0.001 # Units = km diag = round(diag.real, 11) + round(diag.imag, 10) * 1j rem = ((z0 - z1) / 3) * 0.001 # Units = km rem = round(rem.real, 11) + round(rem.imag, 10) * 1j imp_matrix = np.zeros((3, 3), dtype=np.complex_) imp_matrix.fill(rem) np.fill_diagonal(imp_matrix, diag) imp_matrix = imp_matrix.tolist() assert m["line13"].impedance_matrix == imp_matrix assert m["line13"].capacitance_matrix == cap_matrix assert m["line13"].feeder_name == "sourcebus_src" assert m["line13"].is_recloser is None assert m["line13"].is_breaker is None for w in m["line13"].wires: assert w.nameclass == "" assert w.X is None assert w.Y is None assert w.diameter is None assert w.gmr is None assert w.ampacity == parsed_values["Wire"]["ampacity"] assert w.emergency_ampacity == parsed_values["Wire"][ "emergency_ampacity"] assert w.resistance is None assert w.insulation_thickness == parsed_values["Wire"][ "insulation_thickness"] assert w.is_open is None assert w.concentric_neutral_gmr is None assert w.concentric_neutral_resistance is None assert w.concentric_neutral_diameter is None assert w.concentric_neutral_outside_diameter is None assert w.concentric_neutral_nstrand is None # Line 14 assert len(m["line14"].wires) == 3 # Number of wires # Phases of the different wires assert set([w.phase for w in m["line14"].wires]) == set(["A", "B", "C"]) assert m["line14"].nameclass == "c1_only" # Linecode is c1_only assert m["line14"].line_type == None assert m["line14"].from_element == "bus14" assert m["line14"].to_element == "bus15" assert m["line14"].length == 10 assert m["line14"].nominal_voltage == float(12.47) * 10**3 assert m["line14"].is_fuse is None assert m["line14"].is_switch is None assert m["line14"].faultrate == parsed_values["Line"]["faultrate"] z1 = complex( parsed_values["Line"]["R1"], parsed_values["Line"]["X1"]) # r1,x1 taken from default values z0 = complex( parsed_values["Line"]["R0"], parsed_values["Line"]["X0"]) # r0,x0 taken from default values diag = ((2 * z1 + z0) / 3) * 0.001 # Units = km diag = round(diag.real, 11) + round(diag.imag, 10) * 1j rem = ((z0 - z1) / 3) * 0.001 # Units = km rem = round(rem.real, 11) + round(rem.imag, 10) * 1j imp_matrix = np.zeros((3, 3), dtype=np.complex_) imp_matrix.fill(rem) np.fill_diagonal(imp_matrix, diag) imp_matrix = imp_matrix.tolist() assert m["line14"].impedance_matrix == imp_matrix c1 = complex(10.4308823411236, 0) # c1 taken from linecode c0 = complex(parsed_values["Line"]["C0"], 0) # c0 taken from default values c_diag = ((2 * c1 + c0) / 3) * 0.001 # Units = km c_diag = round(c_diag.real, 9) + c_diag.imag * 1j c_rem = ((c0 - c1) / 3) * 0.001 # Units = km c_rem = round(c_rem.real, 9) + c_rem.imag * 1j cap_matrix = np.zeros((3, 3), dtype=np.complex_) cap_matrix.fill(c_rem) np.fill_diagonal(cap_matrix, c_diag) cap_matrix = cap_matrix.tolist() assert m["line14"].capacitance_matrix == cap_matrix assert m["line14"].feeder_name == "sourcebus_src" assert m["line14"].is_recloser is None assert m["line14"].is_breaker is None for w in m["line14"].wires: assert w.nameclass == "" assert w.X is None assert w.Y is None assert w.diameter is None assert w.gmr is None assert w.ampacity == parsed_values["Wire"]["ampacity"] assert w.emergency_ampacity == parsed_values["Wire"][ "emergency_ampacity"] assert w.resistance is None assert w.insulation_thickness == parsed_values["Wire"][ "insulation_thickness"] assert w.is_open is None assert w.concentric_neutral_gmr is None assert w.concentric_neutral_resistance is None assert w.concentric_neutral_diameter is None assert w.concentric_neutral_outside_diameter is None assert w.concentric_neutral_nstrand is None # Line 15 assert len(m["line15"].wires) == 3 # Number of wires # Phases of the different wires assert set([w.phase for w in m["line15"].wires]) == set(["A", "B", "C"]) assert m["line15"].nameclass == "c0_only" # Linecode is c0_only assert m["line15"].line_type == None assert m["line15"].from_element == "bus15" assert m["line15"].to_element == "bus16" assert m["line15"].length == 10 assert m["line15"].nominal_voltage == float(12.47) * 10**3 assert m["line15"].is_fuse is None assert m["line15"].is_switch is None assert m["line15"].faultrate == parsed_values["Line"]["faultrate"] z1 = complex( parsed_values["Line"]["R1"], parsed_values["Line"]["X1"]) # r1,x1 taken from default values z0 = complex( parsed_values["Line"]["R0"], parsed_values["Line"]["X0"]) # r0,x0 taken from default values diag = ((2 * z1 + z0) / 3) * 0.001 # Units = km diag = round(diag.real, 11) + round(diag.imag, 10) * 1j rem = ((z0 - z1) / 3) * 0.001 # Units = km rem = round(rem.real, 11) + round(rem.imag, 10) * 1j imp_matrix = np.zeros((3, 3), dtype=np.complex_) imp_matrix.fill(rem) np.fill_diagonal(imp_matrix, diag) imp_matrix = imp_matrix.tolist() assert m["line15"].impedance_matrix == imp_matrix c1 = complex(parsed_values["Line"]["C1"], 0) # c1 taken from default values c0 = complex(4.38501282215346, 0) # c0 taken from linecode c_diag = ((2 * c1 + c0) / 3) * 0.001 # Units = km c_diag = round(c_diag.real, 9) + c_diag.imag * 1j c_rem = ((c0 - c1) / 3) * 0.001 # Units = km c_rem = round(c_rem.real, 10) + c_rem.imag * 1j cap_matrix = np.zeros((3, 3), dtype=np.complex_) cap_matrix.fill(c_rem) np.fill_diagonal(cap_matrix, c_diag) cap_matrix = cap_matrix.tolist() assert m["line15"].capacitance_matrix == cap_matrix assert m["line15"].feeder_name == "sourcebus_src" assert m["line15"].is_recloser is None assert m["line15"].is_breaker is None for w in m["line15"].wires: assert w.nameclass == "" assert w.X is None assert w.Y is None assert w.diameter is None assert w.gmr is None assert w.ampacity == parsed_values["Wire"]["ampacity"] assert w.emergency_ampacity == parsed_values["Wire"][ "emergency_ampacity"] assert w.resistance is None assert w.insulation_thickness == parsed_values["Wire"][ "insulation_thickness"] assert w.is_open is None assert w.concentric_neutral_gmr is None assert w.concentric_neutral_resistance is None assert w.concentric_neutral_diameter is None assert w.concentric_neutral_outside_diameter is None assert w.concentric_neutral_nstrand is None