def CreateRegXfmr(self, model, node1, node2, reg_data, reg_type_data):
print(reg_type_data)
tr = PowerTransformer(model)
tr.name = "xfmr_" + reg_data["name"]
tr.substation_name = ("" if not isinstance(reg_data["substation"], str)
else reg_data["substation"])
tr.feeder_name = ("" if not isinstance(reg_data["feeder"], str) else
reg_data["feeder"])
tr.from_element = node1
tr.to_element = node2
tr.normhkva = (float(reg_data["kv"][0]) *
float(reg_type_data.iloc[-1]["Ampacity"]) * 3)
tr.loadloss = float(1)
tr.noload_loss = float(0.1) # TODO fix the noload losses here
tr.install_type = "PADMOUNT"
tr.reactances.append([10.0])
tr.phase_shift = 0
tr.is_center_tap = False
# Set transformer position
node_pos = Position(model)
node_pos.long = float(self.nxGraph.node[node2]["x"])
node_pos.lat = float(self.nxGraph.node[node2]["y"])
tr.positions.append(node_pos)
for i in range(2):
nPhases = len(reg_data["phases"])
wdg = Winding(model)
kV = float(self.nxGraph[node1][node2]["kv"][0]) * 1000
wdg.resistance = 0.5
wdg.nominal_voltage = kV if nPhases == 1 else 1.732 * kV
wdg.connection_type = self.nxGraph[node1][node2]["conn"][i]
wdg.rated_power = (float(reg_data["kv"][0]) *
float(reg_type_data.iloc[-1]["Ampacity"]) *
1000)
wdg.voltage_type = 0 if i == 0 else 2
phases = reg_data["phases"]
LDCr = reg_data["LDCr"]
LDCx = reg_data["LDCx"]
Vset = reg_data["Vpu"]
Vub = reg_data["fhhp"]
Vlb = reg_data["fhlp"]
for j, ZippedData in enumerate(
zip(phases, LDCr, LDCx, Vlb, Vub, Vset)):
phase, r, x, vu, vl, vs = ZippedData
nSteps = 33
vPerStep = (float(vu) - float(vl)) / nSteps
Tap = int((float(vs) - 1) / vPerStep)
print("Tap: ", Tap)
phswdg = PhaseWinding(model)
ix = self.phase_2_index[phase][0]
phswdg.phase = phase
phswdg.tap_position = float(Tap)
phswdg.compensator_r = float(r)
phswdg.compensator_x = float(x)
wdg.phase_windings.append(phswdg)
tr.windings.append(wdg)
return tr.name
def parse_transformers(self, model):
xfmrs = self.filter_edges_by_class('transformer')
xfmr_types = self.nxGraph.graph['Transformer']
for xfmr in xfmrs:
node1, node2 = xfmr
# Get the transformer type
tr_types = set(self.nxGraph[node1][node2]['equipment'])
tr_types.discard('NONE')
if tr_types:
# tr data from library
tr_type = list(tr_types)[0]
winding_data = xfmr_types[xfmr_types['Equipment Identifier'] ==
tr_type]
# create transformer
phases = self.nxGraph[node1][node2]['phases']
nPhases = len(phases)
nwdgs = 2 if np.isnan(
self.nxGraph[node1][node2]['hasTertiary']) else 3
X_R_ratio = float(winding_data['X/R Ratio- Phase A'].iloc[0])
Zpercentage = float(
winding_data['Percent Impedance- Zps'].iloc[0])
r_percent = np.sqrt(Zpercentage**2 / (X_R_ratio**2 + 1))
x_percent = np.sqrt(Zpercentage**2 - r_percent**2)
tr = PowerTransformer(model)
tr.name = node2.replace('node_', 'tr_')
tr.substation_name = '' if not isinstance(self.nxGraph[node1][node2]['substation'], str) else \
self.nxGraph[node1][node2]['substation']
tr.feeder_name = '' if not isinstance(self.nxGraph[node1][node2]['feeder'], str) else \
self.nxGraph[node1][node2]['feeder']
tr.from_element = node1
tr.to_element = node2
tr.normhkva = sum([
float(winding_data['Single Phase Base kVA- Zps'].iloc[0]),
float(winding_data['Single Phase Base kVA- Zpt'].iloc[0]),
float(winding_data['Single Phase Base kVA- Zst'].iloc[0])
])
tr.noload_loss = float(
winding_data['No-Load Loss- Zps'].iloc[0]) / float(
winding_data['Single Phase Base kVA- Zps'].iloc[0])
tr.install_type = 'PADMOUNT' if bool(
winding_data['Is Pad Mounted Transformer'].iloc[0]
) else 'POLEMOUNT'
tr.reactances.append(float(x_percent))
tr.phase_shift = 0
tr.is_center_tap = int(
self.nxGraph[node1][node2]['is center tapped'])
# Set transformer position
node_pos = Position(model)
node_pos.long = float(self.nxGraph.node[node2]['x'])
node_pos.lat = float(self.nxGraph.node[node2]['y'])
tr.positions.append(node_pos)
for i in range(nwdgs):
wdg = Winding(model)
wdg.resistance = r_percent / nwdgs
kV = float(self.nxGraph[node1][node2]['kv'][i]) * 1000
wdg.nominal_voltage = kV if nPhases == 1 else 1.732 * kV
wdg.connection_type = self.nxGraph[node1][node2]['conn'][i]
wdg.rated_power = float(
winding_data['Single Phase Rated kVA- Zps']) * 1000
wdg.voltage_type = 0 if i == 0 else 2
for j, phase in enumerate(phases):
phswdg = PhaseWinding(model)
ix = self.phase_2_index[phase][0]
phswdg.phase = phase
phswdg.tap_position = 1.0 #self.nxGraph[node1][node2]['kv'][i]
phswdg.compensator_r = 0
phswdg.compensator_x = 0
wdg.phase_windings.append(phswdg)
tr.windings.append(wdg)
def parse_transformers(self, model):
xfmrs = self.filter_edges_by_class("transformer")
xfmr_types = self.nxGraph.graph["Transformer"]
for xfmr in xfmrs:
node1, node2 = xfmr
# Get the transformer type
tr_types = set(self.nxGraph[node1][node2]["equipment"])
tr_types.discard("NONE")
if tr_types:
# tr data from library
tr_type = list(tr_types)[0]
winding_data = xfmr_types[xfmr_types["Equipment Identifier"] ==
tr_type]
# create transformer
phases = self.nxGraph[node1][node2]["phases"]
nPhases = len(phases)
nwdgs = 2 if np.isnan(
self.nxGraph[node1][node2]["hasTertiary"]) else 3
X_R_ratio = float(winding_data["X/R Ratio- Phase A"].iloc[0])
Zpercentage = float(
winding_data["Percent Impedance- Zps"].iloc[0])
r_percent = np.sqrt(Zpercentage**2 / (X_R_ratio**2 + 1))
x_percent = np.sqrt(Zpercentage**2 - r_percent**2)
tr = PowerTransformer(model)
tr.name = node2.replace("node_", "tr_")
tr.substation_name = ("" if not isinstance(
self.nxGraph[node1][node2]["substation"], str) else
self.nxGraph[node1][node2]["substation"])
tr.feeder_name = ("" if not isinstance(
self.nxGraph[node1][node2]["feeder"], str) else
self.nxGraph[node1][node2]["feeder"])
tr.from_element = node1
tr.to_element = node2
tr.normhkva = sum([
float(winding_data["Single Phase Base kVA- Zps"].iloc[0]),
float(winding_data["Single Phase Base kVA- Zpt"].iloc[0]),
float(winding_data["Single Phase Base kVA- Zst"].iloc[0]),
])
tr.noload_loss = float(
winding_data["No-Load Loss- Zps"].iloc[0]) / float(
winding_data["Single Phase Base kVA- Zps"].iloc[0])
tr.install_type = ("PADMOUNT" if bool(
winding_data["Is Pad Mounted Transformer"].iloc[0]) else
"POLEMOUNT")
tr.reactances.append(float(x_percent))
tr.phase_shift = 0
tr.is_center_tap = int(
self.nxGraph[node1][node2]["is center tapped"])
# Set transformer position
node_pos = Position(model)
node_pos.long = float(self.nxGraph.node[node2]["x"])
node_pos.lat = float(self.nxGraph.node[node2]["y"])
tr.positions.append(node_pos)
for i in range(nwdgs):
wdg = Winding(model)
wdg.resistance = r_percent / nwdgs
kV = float(self.nxGraph[node1][node2]["kv"][i]) * 1000
wdg.nominal_voltage = kV if nPhases == 1 else 1.732 * kV
wdg.connection_type = self.nxGraph[node1][node2]["conn"][i]
wdg.rated_power = (
float(winding_data["Single Phase Rated kVA- Zps"]) *
1000)
wdg.voltage_type = 0 if i == 0 else 2
for j, phase in enumerate(phases):
phswdg = PhaseWinding(model)
ix = self.phase_2_index[phase][0]
phswdg.phase = phase
phswdg.tap_position = 1.0 # self.nxGraph[node1][node2]['kv'][i]
phswdg.compensator_r = 0
phswdg.compensator_x = 0
wdg.phase_windings.append(phswdg)
tr.windings.append(wdg)
def parse_transformers(self, model, **kwargs):
"""Transformer parser.
:param model: DiTTo model
:type model: DiTTo model
:returns: 1 for success, -1 for failure
:rtype: int
"""
# Assume that each transformer has one from node and one to node.
connection_map = {'Delta':'D','Wye':'Y'}
transformer_panel_map = {}
for element in self.geojson_content["features"]:
if 'properties' in element and 'DSId' in element['properties'] and 'id' in element['properties']:
if element['properties']['DSId'] in transformer_panel_map:
transformer_panel_map[element['properties']['DSId']].append(element['properties']['id'])
else:
transformer_panel_map[element['properties']['DSId']] = [element['properties']['id']]
for element in self.geojson_content["features"]:
if 'properties' in element and 'district_system_type' in element['properties'] and element['properties']['district_system_type'] == 'Transformer':
transformer_id = element['properties']['id']
transformer = PowerTransformer(model)
if transformer_id in transformer_panel_map:
if len(transformer_panel_map[transformer_id]) <2:
print("No from and to elements found tor transformer")
if len(transformer_panel_map[transformer_id]) >2:
print("Warning - the transformer "+transformer_id+" should have a from and to element - "+str(len(transformer_panel_map[transformer_id]))+" junctions on the transformer")
if len(transformer_panel_map[transformer_id]) >=2:
for db_transformer in self.equipment_data['transformer_properties']:
if element['properties']['equipment'][0] == db_transformer['nameclass']:
transformer.from_element = transformer_panel_map[transformer_id][0]
transformer.to_element = transformer_panel_map[transformer_id][1] #NOTE: Need to figure out correct from and to directions here.
transformer.name = transformer_id
transformer.reactances = [float(db_transformer['reactance'])]
transformer.is_center_tap = db_transformer['is_center_tap']
windings = [Winding(model),Winding(model)]
connections = db_transformer['connection'].split('-')
if transformer.is_center_tap:
windings.append(Winding(model))
transformer.reactances.append(float(db_transformer['reactance']))
transformer.reactances.append(float(db_transformer['reactance'])) #TODO: map reactance values correctly for center-taps
for i in range(len(windings)):
phase_windings = []
for phase in db_transformer['phases']:
pw = PhaseWinding(model)
pw.phase = phase
phase_windings.append(pw)
windings[i].phase_windings = phase_windings
windings[i].rated_power = float(db_transformer['kva'])*1000
if i<1:
windings[i].nominal_voltage = float(db_transformer['high_voltage'])*1000
windings[i].connection_type = connection_map[connections[0]]
windings[i].voltage_type = 0
windings[i].resistance = float(db_transformer['resistance'])
else:
windings[i].nominal_voltage = float(db_transformer['low_voltage'])*1000
windings[i].connection_type = connection_map[connections[1]]
windings[i].voltage_type = 1
windings[i].resistance = float(db_transformer['resistance'])
transformer.windings = windings
return 1