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