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 apply(cls, stack, model, *args, **kwargs):
cutoff_length = None
if 'cutoff_length' in kwargs:
cutoff_length = kwargs['cutoff_length']
if cutoff_length is None:
return model
from_element_cnt = {}
for i in model.models:
if isinstance(i,Line) and i.length is not None and i.length >cutoff_length and i.feeder_name is not None and i.feeder_name != 'subtransmission':
# Option 1: put a switch at one of the intermediate nodes 1/10 of the way down the line
if i.positions is not None and len(i.positions) >10:
node1 = Node(model)
node2 = Node(model)
pos = int(len(i.positions)/10)
node1.is_substation_connection = 0
node1.feeder_name = i.feeder_name
node1.substation_name = i.substation_name
node1.nominal_voltage = i.nominal_voltage
if i.from_element in from_element_cnt:
from_element_cnt[i.from_element]=from_element_cnt[i.from_element]+1
else:
from_element_cnt[i.from_element] = 1
node1.name = i.from_element+'_b1_'+str(from_element_cnt[i.from_element])
node1.positions = [i.positions[pos]]
node1_phases = []
for p in i.wires:
if p.phase is not None and p.phase in ['A','B','C','N']:
node1_phases.append(Unicode(p.phase))
node1.phases = node1_phases
node2.is_substation_connection = 0
node2.feeder_name = i.feeder_name
node2.substation_name = i.substation_name
node2.nominal_voltage = i.nominal_voltage
node2.name = i.from_element+'_b2_'+str(from_element_cnt[i.from_element])
node2.positions = [i.positions[pos+1]]
node2_phases = []
for p in i.wires:
if p.phase is not None and p.phase in ['A','B','C','N']:
node2_phases.append(Unicode(p.phase))
node2.phases = node2_phases
modifier = Modifier()
switch_break = modifier.copy(model,i)
switch_break.name = i.name+'_disconnect'
switch_break.length = 1 #1 meter
switch_break.positions = []
switch_break.from_element = node1.name
switch_break.to_element = node2.name
switch_break.is_switch = True
for wire in switch_break.wires:
wire.is_open=False
second_stretch = modifier.copy(model,i)
second_stretch.name = i.name+'_cont'
second_stretch.positions = i.positions[pos+2:]
second_stretch.from_element = node2.name
second_stretch.length = 9/10.0*i.length # rough estimate based on number of positions
i.to_element = node1.name
i.length = 1/10.0*i.length-1
if pos>0:
i.positions = i.positions[:pos-1]
else:
i.positions = []
return model
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_dg(self, model, **kwargs):
"""PV parser.
:param model: DiTTo model
:type model: DiTTo model
:returns: 1 for success, -1 for failure
:rtype: int
"""
if not self.use_reopt:
return 1
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]
feature_data = self.get_feature_data(os.path.join(self.load_folder,id_value,'feature_reports','feature_report_reopt.json'))
pv_kw = feature_data['distributed_generation']['total_solar_pv_kw']
upstream_transformer = model[network.get_upstream_transformer(model,connecting_element)]
is_center_tap = upstream_transformer.is_center_tap
if pv_kw >0:
pv = Photovoltaic(model)
pv.name = 'solar_'+id_value
pv.connecting_element = connecting_element
pv.nominal_voltage = upstream_transformer.windings[1].nominal_voltage
phases = []
for ph_wdg in upstream_transformer.windings[1].phase_windings:
phases.append(Unicode(ph_wdg.phase))
if is_center_tap:
phases = [Unicode('A'),Unicode('B')]
pv.phases = phases
pv.rated_power = pv_kw
pv.active_rating = 1.1*pv_kw # Should make this a parameter instead
pv.connection_type = upstream_transformer.windings[1].connection_type
if self.is_timeseries:
load_data = pd.read_csv(os.path.join(self.load_folder,id_value,'feature_reports','feature_report_reopt.csv'),header=0)
data = load_data['REopt:ElectricityProduced:PV:Total(kw)']
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/pv_kw
if not self.timeseries_location is None:
if not os.path.exists(self.timeseries_location): #Should have already been created for the loads
os.makedirs(self.timeseries_location)
data.to_csv(os.path.join(self.timeseries_location,'pv_'+id_value+'.csv'),header=False, index=False)
data_pu.to_csv(os.path.join(self.timeseries_location,'pv_'+id_value+'_pu.csv'),header=False, index=False)
timeseries = Timeseries(model)
timeseries.feeder_name = pv.feeder_name
timeseries.substation_name = pv.substation_name
timeseries.interval = delta.seconds/3600.0
timeseries.data_type = 'float'
timeseries.data_location = os.path.join(self.relative_timeseries_location,'pv_'+id_value+'_pu.csv')
timeseries.data_label = 'feature_'+id_value
timeseries.scale_factor = 1
pv.timeseries = [timeseries]
return 1