def dssToGridLab(args):
''' Convert dss file to gridlab. '''
m = Store()
reader = OReader(master_file=args.infile, buscoordinates_file=args.buscoords)
writer = Writer(output_path='.')
reader.parse(m)
writer.write(m)
print ("GRIDLAB-D FILE WRITTEN")
def main():
'''
Conversion example of a relatively large test system: the EPRI J1 feeder.
OpenDSS ---> CYME example.
This example uses the dss files located in tests/data/big_cases/opendss/epri_j1
'''
#Path settings (assuming it is run from examples folder)
#Change this if you wish to use another system
path = '../tests/data/big_cases/opendss/epri_j1'
###############################
# STEP 1: READ FROM OPENDSS #
###############################
#
#Create a Store object
print('>>> Creating empty model...')
model = Store()
#Instanciate a Reader object
r = Reader(master_file=os.path.join(path, 'master.dss'),
buscoordinates_file=os.path.join(path, 'buscoords.dss'))
#Parse (can take some time for large systems...)
print('>>> Reading from OpenDSS...')
start = time.time() #basic timer
r.parse(model)
end = time.time()
print('...Done (in {} seconds'.format(end - start))
###########################
# STEP 2: WRITE TO CYME #
###########################
#
#Instanciate a Writer object
w = Writer(output_path='./')
#Write to CYME (can also take some time for large systems...)
print('>>> Writing to CYME...')
start = time.time() #basic timer
w.write(model)
end = time.time()
print('...Done (in {} seconds'.format(end - start))
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_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 create_output_dir(tests_dir):
"""Reading the input from every reader for each test case and creating the Opendss output."""
# Creating output directory
current_dir = os.path.realpath(os.path.dirname(__file__))
validation_dir = os.path.join(current_dir, "validation_outputs")
if os.path.exists(validation_dir):
shutil.rmtree(validation_dir)
for each in os.listdir(tests_dir):
if each == "cim" or each == "demo":
continue
for dirname in os.listdir(os.path.join(tests_dir, each)):
if dirname == "storage_test":
continue
output_dir = os.path.join(validation_dir, dirname,
each + "_output")
test_path = os.path.join(tests_dir, each, dirname)
m = Store()
if each == "opendss":
r1 = OpenDSS_Reader(
master_file=os.path.join(test_path, "master.dss"))
elif each == "synergi":
if dirname == "ieee_4node":
r1 = Synergi_Reader(
input_file=os.path.join(test_path, "network.mdb"))
elif each == "cyme":
r1 = Cyme_Reader(data_folder_path=os.path.join(test_path))
elif each == "gridlabd":
r1 = Gridlabd_Reader(
input_file=os.path.join(test_path, "node.glm"))
r1.parse(m)
w1 = OpenDSS_Writer(output_path=output_dir)
w1.write(m, separate_feeders=True)
return validation_dir
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_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"])
# 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 main():
'''
Conversion example of the IEEE 123 node system.
Gridlab-D ---> OpenDSS example.
This example uses the glm file located in tests/data/big_cases/gridlabd/ieee_123node
'''
#Path settings (assuming it is run from examples folder)
#Change this if you wish to use another system
path = r'C:\Users\rjain\Desktop\BoxSync\NMG\ditto_ODO\ditto\tests\IEEE_13_nodes_origin'
#################################
# STEP 1: READ FROM GRIDLAB-D #
#################################
#
#Create a Store object
# print('>>> Creating empty model...')
# model = Store()
#
# #Instanciate a GridLab-D Reader object
# r = Reader_glab(input_file = os.path.join(path, 'The-1069-node-system.glm'))
#
# #Parse (can take some time for large systems...)
# print('>>> Reading from Gridlab-D...')
# start = time.time() #basic timer
# r.parse(model)
# end = time.time()
# print('...Done (in {} seconds'.format(end-start))
#
# ##############################
# # STEP 2: WRITE TO OpenDSS #
# ##############################
# #
# #Instanciate a Writer object
# #w = Writer(output_path = './')
#
# #Write to OpenDSS (can also take some time for large systems...)
# w = Writer_dss(output_path = './tests/IEEE_13_nodes_out/glab_out')
#
# print('>>> Writing to OpenDSS...')
# start = time.time() #basic timer
# w.write(model)
# end = time.time()
# print('...Done (in {} seconds'.format(end-start))
#Create a Store object
print('>>> Creating empty model...')
m = Store()
#Instanciate a OpenDSS Reader object
r_dss = Reader_dss(
master_file='./tests/IEEE_13_nodes_out/glab_out/Master.dss',
bus_coordinates_file='./IEEE_13_nodes_origin/ReducedModel/BusCoords.dss'
)
print('>>> Reading from OpenDSS...')
start = time.time() #basic timer
r_dss.parse(m, verbose=True)
end = time.time()
print('...Done (in {} seconds'.format(end - start))
print('>>> Writing to ODO...')
start = time.time() #basic timer
baseMVA = 10
basekV = 13.8
odo_writer = Writer_odo(linecodes_flag=True,
output_path='./IEEE_13_nodes_out',
basekV=basekV,
baseMVA=baseMVA)
network = odo_writer.write(m, verbose=True)
# network = odo_writer.write(model, verbose=True)
end = time.time()
#network['baseKV'] = 4.16
#network['baseMVA'] = 10.0
network['baseKV'] = basekV
network['baseMVA'] = baseMVA
network['per_unit'] = bool(1)
network['multinetwork'] = bool(0)
with open('network_glabd.json', 'w') as f:
f.write(
json_tricks.dumps(network,
allow_nan=True,
sort_keys=True,
indent=4))
Modeldss = OpenDSS.OpenDSS()
Modeldss.disable_forms(
) # Turns off the window dialog boxes for progress bars and errors
# compile and solve the given model file
Modeldss.compile(
r'C:\Users\rjain\Desktop\BoxSync\NMG\ditto_ODO\ditto\tests\IEEE_13_nodes_origin\master.dss'
)
#Modeldss.compile(r'C:\Users\rjain\Desktop\BoxSync\NMG\ditto_ODO\ditto\tests\IEEE_13_nodes_origin\ReducedModel\Master.DSS')
Modeldss.solve()
# Get the bus dictionary from OpenDSS_function
busV = Modeldss.get_buses()
## Parsing the bus voltages into a usable format
busV_dict = {}
for bus in range(len(busV)):
bus_id = busV[bus]["name"]
nodes = busV[bus]["nodes"]
voltages = busV[bus]["voltages"]
puVmag = busV[bus]["puVmag"]
busV_dict[bus_id] = {}
temp_varr = [0, 0, 0]
temp_thetaarr = [0, 0, 0]
temp_vminarr = [-1, -1, -1]
theta = []
# Calculate angles in radians as atan(Q/P)
for elem in range(len(nodes)):
theta.append(math.atan(voltages[2 * elem + 1] /
voltages[2 * elem]))
# Finalizing the respective vm, va, vmin values given the nodes present
node_count = 0
for node in nodes:
temp_thetaarr[node - 1] = theta[node_count]
temp_varr[node - 1] = puVmag[node_count]
temp_vminarr[node - 1] = 0.95
node_count += 1
busV_dict[bus_id]["nodes"] = nodes
busV_dict[bus_id]["vmag"] = temp_varr
busV_dict[bus_id]["vang"] = temp_thetaarr
busV_dict[bus_id]["vmin"] = temp_vminarr
for bus in network['bus'].keys():
temp_bus = network['bus'][bus]["name"]
network['bus'][bus]["vm"] = busV_dict[temp_bus]["vmag"]
network['bus'][bus]["va"] = busV_dict[temp_bus]["vang"]
network['bus'][bus]["vmin"] = busV_dict[temp_bus]["vmin"]
## Getting the P, Q Solution
circuit = Modeldss.engine.ActiveCircuit
circuit.SetActiveElement("Vsource.SOURCE")
PQsoln = circuit.ActiveElement.Powers
PSoln = [
-1 * PQsoln[0] / (1000 * network['baseMVA']),
-1 * PQsoln[2] / (1000 * network['baseMVA']),
-1 * PQsoln[4] / (1000 * network['baseMVA'])
]
QSoln = [
-1 * PQsoln[1] / (1000 * network['baseMVA']),
-1 * PQsoln[3] / (1000 * network['baseMVA']),
-1 * PQsoln[5] / (1000 * network['baseMVA'])
]
for source in network['generator'].keys():
if network['generator'][source]["name"] == "Vsource.source":
network['generator'][source]["pg"] = PSoln
network['generator'][source]["qg"] = QSoln
break
with open('network_13bus.json', 'w') as f:
f.write(
json_tricks.dumps(network,
allow_nan=True,
sort_keys=True,
indent=4))
with open('network_glabd.json', 'w') as f:
f.write(
json_tricks.dumps(network,
allow_nan=True,
sort_keys=True,
indent=4))
print('...Done (in {} seconds'.format(end - start))
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]
from ditto.readers.opendss.read import Reader as Reader_opendss
from ditto.readers.cyme.read import Reader as Reader_cyme
from ditto.writers.json.write import Writer
from ditto.store import Store
import logging
import json_tricks
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:
def test_line_connectivity():
from ditto.store import Store
from ditto.readers.opendss.read import Reader
# test on the test_line_connectivity.dss
m = Store()
r = Reader(
master_file=os.path.join(current_directory, "test_line_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()
# Line1 connects sourcebus to bus1 and should have 3 wires: A, B, C
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"].name == "line1"
assert m["line1"].nominal_voltage == float(4.16) * 10 ** 3
assert m["line1"].line_type is None
assert m["line1"].length == 100
assert m["line1"].from_element == "sourcebus"
assert m["line1"].to_element == "bus1"
assert m["line1"].is_fuse is None
assert m["line1"].is_switch is None
assert m["line1"].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
diag = round(diag.real, 8) + round(diag.imag, 4) * 1j
rem = (z0 - z1) / 3
rem = round(rem.real, 8) + 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["line1"].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
c_diag = round(c_diag.real, 4) + c_diag.imag * 1j
c_rem = (c0 - c1) / 3
c_rem = round(c_rem.real, 4) + 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
assert m["line1"].nameclass == ""
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 == 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
# Line2 connects bus1 to bus2 and should have 3 wires: A, B, C
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.16) * 10 ** 3
assert m["line2"].line_type is None
assert m["line2"].length == 200
assert m["line2"].from_element == "bus1"
assert m["line2"].to_element == "bus2"
assert m["line2"].is_fuse is None
assert m["line2"].is_switch is None
assert m["line2"].faultrate == parsed_values["Line"]["faultrate"]
assert (
m["line2"].impedance_matrix == imp_matrix
) # Copying the matrix from Line1 as it has 3 wires
assert (
m["line2"].capacitance_matrix == cap_matrix
) # Copying the matrix from Line1 as it has 3 wires
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.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
# Line3 connects bus2 to bus3 and should have 2 wires: A, B
assert len(m["line3"].wires) == 2
# Phases of the different wires
assert set([w.phase for w in m["line3"].wires]) == set(["A", "B"])
assert m["line3"].name == "line3"
assert m["line3"].nominal_voltage == float(4.16) * 10 ** 3
assert m["line3"].line_type is None
assert m["line3"].length == 50
assert m["line3"].from_element == "bus2"
assert m["line3"].to_element == "bus3"
assert m["line3"].is_fuse is None
assert m["line3"].is_switch is None
assert m["line3"].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
diag = round(diag.real, 8) + round(diag.imag, 4) * 1j
rem = (z0 - z1) / 3
rem = round(rem.real, 8) + rem.imag * 1j
imp_matrix = np.zeros((2, 2), 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
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
c_diag = round(c_diag.real, 4) + c_diag.imag * 1j
c_rem = (c0 - c1) / 3
c_rem = round(c_rem.real, 4) + c_rem.imag * 1j
cap_matrix = np.zeros((2, 2), dtype=np.complex_)
cap_matrix.fill(c_rem)
np.fill_diagonal(cap_matrix, c_diag)
cap_matrix = cap_matrix.tolist()
assert m["line3"].capacitance_matrix == cap_matrix
assert m["line3"].feeder_name == "sourcebus_src"
assert m["line3"].is_recloser is None
assert m["line3"].is_breaker is None
assert m["line3"].nameclass == ""
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 == 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
# Line4 connects bus3 to bus4 and should have 1 wire: B
assert len(m["line4"].wires) == 1
# Phases of the different wires
assert set([w.phase for w in m["line4"].wires]) == set(["B"])
assert m["line4"].name == "line4"
assert m["line4"].nominal_voltage == float(4.16) * 10 ** 3
assert m["line4"].line_type is None
assert m["line4"].length == 25
assert m["line4"].from_element == "bus3"
assert m["line4"].to_element == "bus4"
assert m["line4"].is_fuse is None
assert m["line4"].is_switch is None
assert m["line4"].faultrate == parsed_values["Line"]["faultrate"]
imp_matrix = complex(parsed_values["Line"]["R1"], parsed_values["Line"]["X1"])
imp_matrix = round(imp_matrix.real, 9) + imp_matrix.imag * 1j
assert m["line4"].impedance_matrix == [[imp_matrix]]
cap_matrix = complex(parsed_values["Line"]["C1"], 0)
assert m["line4"].capacitance_matrix == [[cap_matrix]]
assert m["line4"].feeder_name == "sourcebus_src"
assert m["line4"].is_recloser is None
assert m["line4"].is_breaker is None
assert m["line4"].nameclass == ""
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
# Line5 connects bus1 to bus5 and should have 2 wires: A, C
assert len(m["line5"].wires) == 2
# Phases of the different wires
assert set(w.phase for w in m["line5"].wires) == set(["A", "C"])
assert m["line5"].name == "line5"
assert m["line5"].nominal_voltage == float(4.16) * 10 ** 3
assert m["line5"].line_type is None
assert m["line5"].length == float(1500 * 0.3048) # units = ft
assert m["line5"].from_element == "bus1"
assert m["line5"].to_element == "bus5"
assert m["line5"].is_fuse is None
assert m["line5"].is_switch is None
assert m["line5"].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
# import pdb;pdb.set_trace()
diag = ((2 * z1 + z0) / 3) / 0.3048 # Units = ft
diag = round(diag.real, 11) + round(diag.imag, 10) * 1j
rem = ((z0 - z1) / 3) / 0.3048 # Units = ft
rem = round(rem.real, 11) + rem.imag * 1j
imp_matrix = np.zeros((2, 2), dtype=np.complex_)
imp_matrix.fill(rem)
np.fill_diagonal(imp_matrix, diag)
imp_matrix = imp_matrix.tolist()
# assert m["line5"].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.3048 # Units = ft
c_diag = c_diag.real + c_diag.imag * 1j
c_rem = ((c0 - c1) / 3) / 0.3048 # Units = ft
c_rem = c_rem.real + c_rem.imag * 1j
cap_matrix = np.zeros((2, 2), 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["line5"].capacitance_matrix, cap_matrix)
assert m["line5"].feeder_name == "sourcebus_src"
assert m["line5"].is_recloser is None
assert m["line5"].is_breaker is None
assert m["line5"].nameclass == ""
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
# Line6 connects bus4 to bus6 and should have 2 wires: B, C
assert len(m["line6"].wires) == 2
# Phases of the different wires
assert set([w.phase for w in m["line6"].wires]) == set(["B", "C"])
assert m["line6"].name == "line6"
assert m["line6"].nominal_voltage == float(4.16) * 10 ** 3
assert m["line6"].line_type is None
assert m["line6"].length == 110
assert m["line6"].from_element == "bus4"
assert m["line6"].to_element == "bus6"
assert m["line6"].is_fuse is None
assert m["line6"].is_switch is None
assert m["line6"].faultrate == parsed_values["Line"]["faultrate"]
assert m["line6"].impedance_matrix == [
[(0.09813333 + 0.2153j), (0.04013333 + 0.0947j)],
[(0.04013333 + 0.0947j), (0.09813333 + 0.2153j)],
]
assert m["line6"].capacitance_matrix == [
[(2.8 + 0j), (-0.6 + 0j)],
[(-0.6 + 0j), (2.8 + 0j)],
]
assert m["line6"].feeder_name == "sourcebus_src"
assert m["line6"].is_recloser is None
assert m["line6"].is_breaker is None
assert m["line6"].nameclass == ""
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.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
# Line7
assert len(m["line7"].wires) == 2
# Phases of the different wires
assert set([w.phase for w in m["line7"].wires]) == set(["B", "C"])
assert m["line7"].name == "line7"
assert m["line7"].nominal_voltage == float(4.16) * 10 ** 3
assert m["line7"].line_type is None
assert m["line7"].length == 100
assert m["line7"].from_element == "bus1"
assert m["line7"].to_element == "bus2"
assert m["line7"].is_fuse is None
assert m["line7"].is_switch is None
assert m["line7"].faultrate == parsed_values["Line"]["faultrate"]
assert m["line7"].impedance_matrix == [
[(0.09813333 + 0.2153j), (0.04013333 + 0.0947j)],
[(0.04013333 + 0.0947j), (0.09813333 + 0.2153j)],
]
assert m["line7"].capacitance_matrix == [
[(2.8 + 0j), (-0.6 + 0j)],
[(-0.6 + 0j), (2.8 + 0j)],
]
assert m["line7"].feeder_name == "sourcebus_src"
assert m["line7"].is_recloser is None
assert m["line7"].is_breaker is None
assert m["line7"].nameclass == ""
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 == 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
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
def test_line_length():
from ditto.store import Store
from ditto.readers.opendss.read import Reader
from ditto.readers.json.read import Reader as json_reader
from ditto.default_values.default_values_json import Default_Values
m = Store()
r = Reader(
master_file=os.path.join(current_directory, "test_line_length.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 is a 100 meters 3 phase line
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"].name == "line1"
assert m["line1"].nominal_voltage == float(4.16) * 10**3
assert m["line1"].line_type == None
assert m["line1"].length == float(100) # Units = meters
assert m["line1"].from_element == "sourcebus"
assert m["line1"].to_element == "bus1"
assert m["line1"].is_fuse is None
assert m["line1"].is_switch is None
assert m["line1"].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
diag = round(diag.real, 8) + round(diag.imag, 4) * 1j
rem = (z0 - z1) / 3
rem = round(rem.real, 8) + 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["line1"].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
c_diag = round(c_diag.real, 10) + c_diag.imag * 1j
c_rem = (c0 - c1) / 3
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["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
assert m["line1"].nameclass == ""
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 == 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 2 is a 83.47 kilo-feet 3 phase line
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.16) * 10**3
assert m["line2"].line_type == None
assert m["line2"].length == float(83.47 * 304.8) # units = kft
assert m["line2"].from_element == "bus1"
assert m["line2"].to_element == "bus2"
assert m["line2"].is_fuse is None
assert m["line2"].is_switch is None
assert m["line2"].faultrate == parsed_values["Line"]["faultrate"]
diag = ((2 * z1 + z0) / 3) / 304.8 # Units = kft
diag = diag.real + diag.imag * 1j
rem = ((z0 - z1) / 3) / 304.8 # Units = kft
rem = rem.real + 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["line2"].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) / 304.8 # Units = kft
c_diag = c_diag.real + c_diag.imag * 1j
c_rem = ((c0 - c1) / 3) / 304.8 # Units = kft
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()
# 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
assert m["line2"].nameclass == ""
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 == 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 3 is a 200 feet 2 phases line
assert len(m["line3"].wires) == 2
# Phases of the different wires
assert set([w.phase for w in m["line3"].wires]) == set(["A", "C"])
assert m["line3"].name == "line3"
assert m["line3"].nominal_voltage == float(4.16) * 10**3
assert m["line3"].line_type == None
assert m["line3"].length == float(200 * 0.3048) # units = ft
assert m["line3"].from_element == "bus2"
assert m["line3"].to_element == "bus3"
assert m["line3"].is_fuse is None
assert m["line3"].is_switch is None
assert m["line3"].faultrate == parsed_values["Line"]["faultrate"]
diag = ((2 * z1 + z0) / 3) / 0.3048 # Units = ft
diag = diag.real + diag.imag * 1j
rem = ((z0 - z1) / 3) / 0.3048 # Units = ft
rem = rem.real + rem.imag * 1j
imp_matrix = np.zeros((2, 2), 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
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.3048 # Units = ft
c_diag = c_diag.real + c_diag.imag * 1j
c_rem = ((c0 - c1) / 3) / 0.3048 # Units = ft
c_rem = c_rem.real + c_rem.imag * 1j
cap_matrix = np.zeros((2, 2), dtype=np.complex_)
cap_matrix.fill(c_rem)
np.fill_diagonal(cap_matrix, c_diag)
cap_matrix = cap_matrix.tolist()
# assert m["line3"].capacitance_matrix == cap_matrix
assert m["line3"].feeder_name == "sourcebus_src"
assert m["line3"].is_recloser is None
assert m["line3"].is_breaker is None
assert m["line3"].nameclass == ""
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 == 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 4 is a 1.01 miles 1 phase line
assert len(m["line4"].wires) == 1
# Phases of the different wires
assert m["line4"].wires[0].phase == "B"
assert m["line4"].name == "line4"
assert m["line4"].nominal_voltage == float(4.16) * 10**3
assert m["line4"].line_type == None
assert m["line4"].length == float(1.01 * 1609.34) # units = mi
assert m["line4"].from_element == "bus2"
assert m["line4"].to_element == "bus4"
assert m["line4"].is_fuse is None
assert m["line4"].is_switch is None
assert m["line4"].faultrate == parsed_values["Line"]["faultrate"]
imp_matrix = (
complex(parsed_values["Line"]["R1"], parsed_values["Line"]["X1"]) /
1609.34) # Units = mi
imp_matrix = imp_matrix.real + imp_matrix.imag * 1j
assert m["line4"].impedance_matrix == [[imp_matrix]]
cap_matrix = complex(parsed_values["Line"]["C1"],
0) / 1609.34 # Units = mi
assert m["line4"].capacitance_matrix == [[cap_matrix]]
assert m["line4"].feeder_name == "sourcebus_src"
assert m["line4"].is_recloser is None
assert m["line4"].is_breaker is None
assert m["line4"].nameclass == ""
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 is a 2040.12 centimeters 3 phase line
assert len(m["line5"].wires) == 3
# Phases of the different wires
assert set([w.phase for w in m["line5"].wires]) == set(["A", "B", "C"])
assert m["line5"].name == "line5"
assert m["line5"].nominal_voltage == float(4.16) * 10**3
assert m["line5"].line_type == None
assert m["line5"].length == float(2040.12 * 0.01) # units = cm
assert m["line5"].from_element == "bus2"
assert m["line5"].to_element == "bus5"
assert m["line5"].is_fuse is None
assert m["line5"].is_switch is None
assert m["line5"].faultrate == parsed_values["Line"]["faultrate"]
diag = ((2 * z1 + z0) / 3) / 0.01 # Units = cm
diag = round(diag.real, 6) + diag.imag * 1j
rem = ((z0 - z1) / 3) / 0.01 # Units = cm
rem = round(rem.real, 6) + 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["line5"].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.01 # Units = cm
c_diag = c_diag.real + c_diag.imag * 1j
c_rem = ((c0 - c1) / 3) / 0.01 # Units = cm
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()
# assert m["line5"].capacitance_matrix == cap_matrix
assert m["line5"].feeder_name == "sourcebus_src"
assert m["line5"].is_recloser is None
assert m["line5"].is_breaker is None
assert m["line5"].nameclass == ""
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 is a 1666.87 inches 1 phase line
assert len(m["line6"].wires) == 1
# Phases of the different wires
assert m["line6"].wires[0].phase == "A"
assert m["line6"].name == "line6"
assert m["line6"].nominal_voltage == float(4.16) * 10**3
assert m["line6"].line_type == None
assert m["line6"].length == float(1666.87 * 0.0254) # units = in
assert m["line6"].from_element == "bus2"
assert m["line6"].to_element == "bus6"
assert m["line6"].is_fuse is None
assert m["line6"].is_switch is None
assert m["line6"].faultrate == parsed_values["Line"]["faultrate"]
imp_matrix = (
complex(parsed_values["Line"]["R1"], parsed_values["Line"]["X1"]) /
0.0254) # Units = in
imp_matrix = imp_matrix.real + imp_matrix.imag * 1j
assert m["line6"].impedance_matrix == [[imp_matrix]]
cap_matrix = complex(parsed_values["Line"]["C1"], 0) / 0.0254 # Units = in
assert m["line6"].capacitance_matrix == [[cap_matrix]]
assert m["line6"].feeder_name == "sourcebus_src"
assert m["line6"].is_recloser is None
assert m["line6"].is_breaker is None
assert m["line6"].nameclass == ""
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.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["line9"].wires) == 3
# Phases of the different wires
assert set([w.phase for w in m["line9"].wires]) == set(["A", "B", "C"])
assert m["line9"].name == "line9"
assert m["line9"].nominal_voltage == float(4.16) * 10**3
assert m["line9"].line_type == None
assert m["line9"].length == 1.01 * 1609.34 # units = mi
assert m["line9"].from_element == "bus2"
assert m["line9"].to_element == "bus9"
assert m["line9"].is_fuse is None
assert m["line9"].is_switch is None
assert m["line9"].faultrate == 0
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) / 1609.34 # Units = mi
diag = diag.real + diag.imag * 1j
rem = ((z0 - z1) / 3) / 1609.34 # Units = mi
rem = rem.real + 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["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) / 1609.34 # Units = mi
c_diag = round(c_diag.real, 18) + c_diag.imag * 1j
c_rem = ((c0 - c1) / 3) / 1609.34 # Units = mi
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()
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
assert m["line9"].nameclass == ""
for w in m["line9"].wires:
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["line10"].wires) == 3
# Phases of the different wires
assert set([w.phase for w in m["line1"].wires]) == set(["A", "B", "C"])
assert m["line10"].name == "line10"
assert m["line10"].nominal_voltage == float(4.16) * 10**3
assert m["line10"].line_type == None
assert m["line10"].length == 1.01 * 1609.34 # units = mi
assert m["line10"].from_element == "bus2"
assert m["line10"].to_element == "bus10"
assert m["line10"].is_fuse is None
assert m["line10"].is_switch is None
assert m["line10"].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) / 1609.34 # Units = mi
diag = diag.real + diag.imag * 1j
rem = ((z0 - z1) / 3) / 1609.34 # Units = mi
rem = rem.real + 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["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) / 1609.34 # Units = mi
c_diag = round(c_diag.real, 18) + c_diag.imag * 1j
c_rem = ((c0 - c1) / 3) / 1609.34 # Units = mi
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()
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
assert m["line10"].nameclass == ""
for w in m["line10"].wires:
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["line11"].wires) == 3
# Phases of the different wires
assert set([w.phase for w in m["line1"].wires]) == set(["A", "B", "C"])
assert m["line11"].name == "line11"
assert m["line11"].nominal_voltage == float(4.16) * 10**3
assert m["line11"].line_type == None
assert m["line11"].length == 1.01 * 1609.34 # units = mi
assert m["line11"].from_element == "bus2"
assert m["line11"].to_element == "bus11"
assert m["line11"].is_fuse is None
assert m["line11"].is_switch is None
assert m["line11"].faultrate == 1.0
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) / 1609.34 # Units = mi
diag = diag.real + diag.imag * 1j
rem = ((z0 - z1) / 3) / 1609.34 # Units = mi
rem = rem.real + 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["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) / 1609.34 # Units = mi
c_diag = round(c_diag.real, 18) + c_diag.imag * 1j
c_rem = ((c0 - c1) / 3) / 1609.34 # Units = mi
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()
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
assert m["line11"].nameclass == ""
for w in m["line11"].wires:
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
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
"""
Tests:
+ Check if the system has any loops (once open switches are removed)
+ Check if there is a path from each load to the head node
+ Check that the phases on the high and low side of the transformer match
+ Check if there's a unique path from load to the source
(transformer_phase_path does all of these):
+ Check that only zero or one transformers are on the path to the head node (excluding regulators)
+ Check that the number of phases increases from the transformer to the substation
+ Check that the number of phases increases from a three phase load to the substation
+ Check that the number of phases is the same from the load to the transformer
"""
model = Store()
r = Reader(master_file = test_system_master,buscoords_file = test_system_coords)
r.parse(model)
for i in model.models:
if isinstance(i,PowerTransformer):
i.is_substation = True #Only for 13 node system. Need to fix in readers
print('Pass loops check:',flush=True)
loops_res = check_loops(model,verbose=True)
print(loops_res)
print()
print('Pass loads connected check:',flush=True)
loads_connected_res = check_loads_connected(model,verbose=True)
print(loads_connected_res)
print()