def apply(cls,
stack,
model,
random_percent=None,
scale_factor=None,
timeseries_path=None):
if timeseries_path is not None:
scale_factor_model = Store()
reader = CsvReader()
reader.parse(sc_factor_model, scaling_path)
modifier = Modifier()
intermediate_model = modifier.merge(model, scale_factor_model)
return intermediate_model
if random_percent == None:
random_percent = 100
if scale_factor is not None:
scale_factor_model = Store()
modifier = Modifier()
total_loads = 0
for obj_name in model.model_names:
if isinstance(model.model_names[obj_name], Load):
total_loads = total_loads + 1
num_selected = int(random_percent / 100.0 * total_loads)
to_select = [1 for i in range(num_selected)
] + [0 for i in range(total_loads - num_selected)]
shuffle(to_select)
load_cnt = 0
for obj_name in model.model_names:
if isinstance(model.model_names[obj_name],
Load) and to_select[load_cnt] == 1:
tmp_load = Load(scale_factor_model)
tmp_timeseries = Timeseries(scale_factor_model)
tmp_timeseries.scale_factor = scale_factor
tmp_load.name = obj_name
tmp_load.timeseries = [tmp_timeseries]
modifier.set_attributes(model, model.model_names[obj_name],
tmp_load)
model.set_names()
return model
else:
logger.warn('no scaling factor set')
return model
def test_center_tap_load_writing():
"""
Tests the writing of center tap loads.
"""
from ditto.models.load import Load
from ditto.models.phase_load import PhaseLoad
m = Store()
l = Load(m)
l.name = "load1"
l.is_center_tap = 1
l.center_tap_perct_1_N = .5
l.center_tap_perct_N_2 = .5
l.center_tap_perct_1_2 = 0
pl = PhaseLoad(m)
pl.p = 10
pl.q = 8
pl.phase = "C"
l.phase_loads.append(pl)
w = Writer(output_path=current_directory)
w.write(m)
with open(os.path.join(current_directory, "loads.txt"), "r") as fp:
lines = fp.readlines()
assert lines[
-1] == ",SPOT,0,C,,,0,PQ,50.0,50.0,0.005,0.004,0.005,0.004,0\n"
# Cleaning
os.remove(os.path.join(current_directory, "loads.txt"))
os.remove(os.path.join(current_directory, "equipment.txt"))
os.remove(os.path.join(current_directory, "network.txt"))
def parse_loads(self, model):
loadmixes = self.nxGraph.graph["Load Mix"]
for node in self.nxGraph.nodes():
if "loads" in self.nxGraph.node[node] and len(
list(self.nxGraph.edges([node]))):
node1, node2 = list(self.nxGraph.edges([node]))[0]
for load_name, load_properties in self.nxGraph.node[node][
"loads"].items():
if bool(load_properties["enabled"]):
loadmix = load_properties["load mix"]
if loadmix.upper().replace(" ", "") != "NONE":
lm = loadmixes[loadmixes["Equipment Identifier"] ==
loadmix]
Z = float(lm["Constant IMP"].iloc[0])
I = float(lm["Constant Current"].iloc[0])
P = float(lm["Constant kVA"].iloc[0])
useZIP = 1
conn = "Y" if lm["Connection Code"].iloc[
0] == "W" else "D"
else:
Z = 0
I = 0
P = 1
useZIP = 0
conn = "Y"
load = Load(model)
load.name = load_properties["name"].replace(
"node", "load")
# load.nominal_voltage = TODO: nominal voltage needs to be added
load.connection_type = conn
load.connecting_element = node
# TODO: Add loadshape attribute to the load object
load.feeder_name = ("" if not isinstance(
self.nxGraph[node1][node2]["feeder"],
str) else self.nxGraph[node1][node2]["feeder"])
load.substation_name = ("" if not isinstance(
self.nxGraph[node1][node2]["substation"],
str) else self.nxGraph[node1][node2]["substation"])
phases = load_properties["phases"]
phase_list = self.phase_2_index[phases]
for phase, phase_index in zip(phases, phase_list):
load_phase = PhaseLoad(model)
load_phase.phase = phase
load_phase.p = float(
load_properties["kw"][phase_index])
load_phase.q = float(
load_properties["kvar"][phase_index])
load_phase.use_zip = useZIP
load_phase.ppercentpower = P * 100
load_phase.qpercentpower = P * 100
load_phase.ppercentcurrent = I * 100
load_phase.qpercentcurrent = I * 100
load_phase.ppercentimpedance = Z * 100
load_phase.qpercentimpedance = Z * 100
load_phase.model = 1 if not useZIP else 8
load.phase_loads.append(load_phase)
if "x" in self.nxGraph.node[node]:
node_pos = Position(model)
node_pos.long = float(self.nxGraph.node[node]["x"])
node_pos.lat = float(self.nxGraph.node[node]["y"])
load.positions.append(node_pos)
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_opendss_writer():
from ditto.writers.opendss.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.model import Model
from ditto.store import Store
from ditto.models.storage import Storage
from ditto.models.phase_storage import PhaseStorage
from ditto.models.base import Unicode
from ditto.models.base import Float
from ditto.models.power_source import PowerSource
from ditto.models.phase_load import PhaseLoad
m = Store()
node1 = Node(m, name="n1")
node2 = Node(m, name="n2")
node3 = Node(m, name="n3")
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])
phase_load1 = PhaseLoad(m, p=5400, q=2615.3394)
load1 = Load(m, name="load1", phase_loads=[phase_load1])
winding1 = Winding(
m,
connection_type="W",
nominal_voltage=12.47,
rated_power=25,
)
winding2 = Winding(
m,
connection_type="W",
nominal_voltage=6.16,
rated_power=25,
)
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",
pt_ratio=60,
delay=2,
)
cap1 = Capacitor(
m,
name="cap1",
nominal_voltage=7.2,
connection_type="Y",
)
print(line1.impedance_matrix)
# Storage testing
phase_storage_A = PhaseStorage(m, phase="A", p=15.0, q=5.0)
phase_storage_B = PhaseStorage(m, phase="B", p=16.0, q=6.0)
storage = Storage(
m,
name="store1",
connecting_element="n3",
nominal_voltage=12470.0,
rated_power=10000.0,
rated_kWh=100.0,
stored_kWh=75.5,
reserve=20.0,
discharge_rate=25.0,
charge_rate=18.7,
charging_efficiency=15.3,
discharging_efficiency=22.0,
resistance=20,
reactance=10,
model_=1,
phase_storages=[phase_storage_A, phase_storage_B],
)
# PV systems testing
PV_system = PowerSource(
m,
name="PV1",
is_sourcebus=False,
nominal_voltage=12470,
phases=[Unicode("A"), Unicode("C")],
rated_power=20000.0,
connection_type="D",
cutout_percent=30.0,
cutin_percent=15.3,
resistance=14.0,
reactance=5.2,
v_max_pu=100,
v_min_pu=60,
power_factor=0.9,
)
t = tempfile.TemporaryDirectory()
writer = Writer(output_path=t.name)
# writer.write_wiredata(m)
# writer.write_linegeometry(m)
# writer.write_linecodes(m)
writer.write_storages(m)
writer.write_PVs(m)
writer.write_lines(m)
writer.write_loads(m)
writer.write_transformers(m)
writer.write_regulators(m)
writer.write_capacitors(m)
def parse_loads(self, model):
loadmixes = self.nxGraph.graph['Load Mix']
for node in self.nxGraph.nodes():
if 'loads' in self.nxGraph.node[node] and len(
list(self.nxGraph.edges([node]))):
node1, node2 = list(self.nxGraph.edges([node]))[0]
for load_name, load_properties in self.nxGraph.node[node][
'loads'].items():
if bool(load_properties['enabled']):
loadmix = load_properties['load mix']
if loadmix.upper().replace(' ', '') != 'NONE':
lm = loadmixes[loadmixes['Equipment Identifier'] ==
loadmix]
Z = float(lm['Constant IMP'].iloc[0])
I = float(lm['Constant Current'].iloc[0])
P = float(lm['Constant kVA'].iloc[0])
useZIP = 1
conn = 'Y' if lm['Connection Code'].iloc[
0] == 'W' else 'D'
else:
Z = 0
I = 0
P = 1
useZIP = 0
conn = 'Y'
load = Load(model)
load.name = load_properties['name'].replace(
'node', 'load')
#load.nominal_voltage = TODO: nominal voltage needs to be added
load.connection_type = conn
load.connecting_element = node
#TODO: Add loadshape attribute to the load object
load.feeder_name = '' if not isinstance(self.nxGraph[node1][node2]['feeder'], str) else \
self.nxGraph[node1][node2]['feeder']
load.substation_name = '' if not isinstance(self.nxGraph[node1][node2]['substation'], str) else \
self.nxGraph[node1][node2]['substation']
phases = load_properties['phases']
phase_list = self.phase_2_index[phases]
for phase, phase_index in zip(phases, phase_list):
load_phase = PhaseLoad(model)
load_phase.phase = phase
load_phase.p = float(
load_properties['kw'][phase_index])
load_phase.q = float(
load_properties['kvar'][phase_index])
load_phase.use_zip = useZIP
load_phase.ppercentpower = P * 100
load_phase.qpercentpower = P * 100
load_phase.ppercentcurrent = I * 100
load_phase.qpercentcurrent = I * 100
load_phase.ppercentimpedance = Z * 100
load_phase.qpercentimpedance = Z * 100
load_phase.model = 1 if not useZIP else 8
load.phase_loads.append(load_phase)
if 'x' in self.nxGraph.node[node]:
node_pos = Position(model)
node_pos.long = float(self.nxGraph.node[node]['x'])
node_pos.lat = float(self.nxGraph.node[node]['y'])
load.positions.append(node_pos)
def parse_loads(self, model, **kwargs):
"""Load parser.
:param model: DiTTo model
:type model: DiTTo model
:returns: 1 for success, -1 for failure
:rtype: int
"""
model.set_names()
network = Network()
network.build(model,source="source")
building_map = {}
for element in self.geojson_content["features"]:
if 'properties' in element and 'type' in element['properties'] and 'buildingId' in element['properties'] and element['properties']['type'] == 'ElectricalJunction':
building_map[element['properties']['buildingId']] = element['properties']['id']
for element in self.geojson_content["features"]:
if 'properties' in element and 'type' in element['properties'] and element['properties']['type'] == 'Building':
id_value = element['properties']['id']
connecting_element = building_map[id_value]
load = Load(model)
load.name = id_value
load.connecting_element = connecting_element
upstream_transformer = model[network.get_upstream_transformer(model,connecting_element)]
is_center_tap = upstream_transformer.is_center_tap
load.nominal_voltage = upstream_transformer.windings[1].nominal_voltage
load_path = os.path.join(self.load_folder,id_value,'feature_reports')
if os.path.exists(load_path): #We've found the load data
load_data = None
load_column = None
if self.use_reopt:
load_data = pd.read_csv(os.path.join(load_path,'feature_report_reopt.csv'),header=0)
load_column = 'REopt:Electricity:Load:Total(kw)'
else:
load_data = pd.read_csv(os.path.join(load_path,'default_feature_report.csv'),header=0)
load_column = 'Net Power(kW)'
max_load = max(load_data[load_column])
phases = []
for ph_wdg in upstream_transformer.windings[1].phase_windings:
phases.append(ph_wdg.phase)
if is_center_tap:
phases = ['A','B']
phase_loads = []
for phase in phases:
phase_load = PhaseLoad(model)
phase_load.phase = phase
power_factor = 0.95
phase_load.p = max_load/len(phases)
phase_load.q = phase_load.p * ((1/power_factor-1)**0.5)
phase_loads.append(phase_load)
load.phase_loads = phase_loads
if self.is_timeseries:
data = load_data[load_column]
timestamps = load_data['Datetime']
delta = datetime.datetime.strptime(timestamps.loc[1],'%Y/%m/%d %H:%M:%S') - datetime.datetime.strptime(timestamps.loc[0],'%Y/%m/%d %H:%M:%S')
data_pu = data/max_load
if not self.timeseries_location is None:
if not os.path.exists(self.timeseries_location):
os.makedirs(self.timeseries_location)
data.to_csv(os.path.join(self.timeseries_location,'load_'+id_value+'.csv'),header=False, index=False)
data_pu.to_csv(os.path.join(self.timeseries_location,'load_'+id_value+'_pu.csv'),header=False, index=False)
timestamps.to_csv(os.path.join(self.timeseries_location,'timestamps.csv'),header=True,index=False)
timeseries = Timeseries(model)
timeseries.feeder_name = load.feeder_name
timeseries.substation_name = load.substation_name
timeseries.interval = delta.seconds/3600.0 #assume 15 minute loads
timeseries.data_type = 'float'
timeseries.data_location = os.path.join(self.relative_timeseries_location,'load_'+id_value+'_pu.csv')
timeseries.data_label = 'feature_'+id_value
timeseries.scale_factor = 1
load.timeseries = [timeseries]
else:
print('Load information missing for '+id_value)
return 1