def generateWeightedSegmentsLV_else(centers,searchRadius_LV, all_ready_checked, roi_years, cost_per_kwh, LV, demand_weight= 0, LVCostDict = None):
# this function determines the easiest to connect segments based on a ranking mechanism
#import ipdb; ipdb.set_trace()
segments = []
nodeCopy = centers.copy()
segID = 0
max_dist = 0
max_delta = -100000000000000000
for startNode in centers.values():
del nodeCopy[startNode.getID()]
for endNode in nodeCopy.values():
if [startNode.getID(), endNode.getID()] not in all_ready_checked:
dist = ((startNode.getX() - endNode.getX()) ** 2 +
(startNode.getY() - endNode.getY()) ** 2) ** (.5)
total_line_cost = (dist * LV) + LVCostDict[startNode.getID()] + LVCostDict[endNode.getID()]
total_demand = startNode.getDemand() + endNode.getDemand() # calculates the demand from both nodes
revenue = total_demand * roi_years * 12 * cost_per_kwh
delta = revenue - total_line_cost
#import ipdb; ipdb.set_trace()
# Location of the temporary transformer:
# Initializing with the nodes as centers
tempCenter1 = startNode; tempCenter2 = endNode
#Locating the centroid of the points
tempCenterX = (tempCenter1.getWeight() * tempCenter1.getX()
+ tempCenter2.getWeight() * tempCenter2.getX()) / (tempCenter2.getWeight() + tempCenter1.getWeight())
tempCenterY = (tempCenter1.getWeight() * tempCenter1.getY()
+ tempCenter2.getWeight() * tempCenter2.getY()) / (tempCenter2.getWeight() + tempCenter1.getWeight())
# The distance of nodes from the centroid:
distnode1fromT = ((startNode.getX() - tempCenterX) ** 2 +
(startNode.getY() - tempCenterY) ** 2) ** (.5)
distnode2fromT = ((endNode.getX() - tempCenterX) ** 2 +
(endNode.getY() - tempCenterY) ** 2) ** (.5)
# SearchRadius = distFromT in this case!
if (distnode1fromT < searchRadius_LV) & (distnode2fromT < searchRadius_LV):
#if dist < searchRadius: # Just put distFromT?
segments.append(network.Seg(segID, startNode, endNode, dist, delta))
segID += 1
if max_dist < dist:
max_dist = dist
if max_delta < delta:
max_delta = delta
# else:
# pass
#import ipdb;ipdb.set_trace()
segments_by_rank = []
# note you can do standardization instead of normalization
for seg in segments:
rank = (1.0 - (seg.getWeight()/max_dist)) * (1-demand_weight) + (seg.getDemand()/ max_delta) * demand_weight
segments_by_rank.append(network.Seg(seg.getID(), seg.getNode1(), seg.getNode2(), seg.getWeight(), rank))
# seg.setDemand(rank)
return segments_by_rank
def CMST_Caller(households, capacity, root):
household_data = [(h.getID(), h.getX(), h.getY(), h.getWeight())
for h in households]
household_data = np.array(household_data)
root_data = [root.getID(), root.getX(), root.getY(), root.getWeight()]
root_data = np.array(root_data)
connections = CMST_only_rewrite(household_data, capacity, root_data)
#print([(household_data[c[0],0],household_data[c[1],0]) for c in connections])
top_parents = set(range(len(household_data))) - set(
[child for (child, parent) in connections])
segments = [(int(household_data[child, 0]), int(household_data[parent, 0]))
for (child, parent) in connections]
segments += [(int(household_data[top_parent, 0]), root.getID())
for top_parent in top_parents]
# total_LV_length = 0
# for (child, parent) in connections:
# total_LV_length += np.linalg.norm(household_data[child, 1:3] - household_data[parent, 1:3])
# for child in top_parents:
# total_LV_length += np.linalg.norm(household_data[child, 1:3] - root_data[1:3])
# return segments, total_LV_length
#import ipdb
#ipdb.set_trace()
connections += [(child, -root.getID() - 100) for child in top_parents]
tree_segments = {}
total_LV_length = 0
#tmp_root =root
tmp_root = network.Node((-root.getID() - 100), root.getX(), root.getY(),
root.getWeight())
for seg_id, (child, parent) in enumerate(connections):
if parent < 0:
length = np.linalg.norm(household_data[child, 1:3] -
root_data[1:3])
tree_segments[(int(household_data[child, 0]),
parent)] = network.Seg(seg_id + int(1e7),
households[child], tmp_root,
length)
else:
length = np.linalg.norm(household_data[child, 1:3] -
household_data[parent, 1:3])
tree_segments[(int(household_data[child, 0]),
int(household_data[parent, 0]))] = network.Seg(
seg_id + int(1e7), households[child],
households[parent], length)
total_LV_length += length
return tree_segments, total_LV_length
def generateWeightedSegments(centers,
searchRadius,
roi_years,
cost_per_kwh,
LV,
demand_weight=0,
LVCostDict=None):
# this function determines the easiest to connect segments based on a ranking mechanism
segments = []
nodeCopy = centers.copy()
segID = 0
max_dist = 0
max_delta = -100000000000000000
for startNode in centers.values():
del nodeCopy[startNode.getID()]
for endNode in nodeCopy.values():
# if [startNode.getID(), endNode.getID()] not in all_ready_checked_list:
dist = ((startNode.getX() - endNode.getX())**2 +
(startNode.getY() - endNode.getY())**2)**(.5)
total_line_cost = (dist * LV) + LVCostDict[
startNode.getID()] + LVCostDict[endNode.getID()]
total_demand = startNode.getDemand() + endNode.getDemand(
) # calculates the demand from both nodes
revenue = total_demand * roi_years * 12 * cost_per_kwh
delta = revenue - total_line_cost
if dist < searchRadius:
segments.append(
network.Seg(segID, startNode, endNode, dist, delta))
segID += 1
if max_dist < dist:
max_dist = dist
if max_delta < delta:
max_delta = delta
# else:
# pass
# import ipdb;ipdb.set_trace()
segments_by_rank = []
# note you can do standardization instead of normalization
for seg in segments:
rank = (1.0 - (seg.getWeight() / max_dist)) * (1 - demand_weight) + (
seg.getDemand() / max_delta) * demand_weight
segments_by_rank.append(
network.Seg(seg.getID(), seg.getNode1(), seg.getNode2(),
seg.getWeight(), rank))
# seg.setDemand(rank)
return segments_by_rank
def readNetFromShp(shapefile):
'Reads segs and nodes from the given shapefile'
ds = ogr.Open(shapefile)
layer = ds.GetLayer(0)
net = network.Network()
feat = layer.GetNextFeature()
lengthField = "Length"
nodeWeightFields = ["pt1Weight", "pt2Weight"]
nodeIDFields = ["pt1", "pt2"]
while feat is not None:
geomRef = feat.GetGeometryRef()
length = feat.GetField(lengthField)
endPts = []
for n in xrange(2):
x, y = geomRef.GetX(n), geomRef.GetY(n)
try:
nodeWeight = feat.GetField(nodeWeightFields[n])
print "try nodefield", nodeWeight
except ValueError, msg:
print msg
print "ERROR: field \"" + nodeWeightFields[
n] + "\" doesn't exist"
nodeID = feat.GetField(nodeIDFields[n])
endPts.append(network.Node(nodeID, x, y, nodeWeight))
print "node weight", nodeWeight
newSeg = network.Seg(feat.GetFID(), endPts[0], endPts[1], length)
net.addSeg(newSeg)
feat = layer.GetNextFeature()
def generateSegmentsDemand_debug(centers, searchRadius,
all_ready_checked_list):
segments = []
nodeCopy = centers.copy()
multiplier = 1
segID = 0
for startNode in centers.values():
del nodeCopy[startNode.getID()]
for endNode in nodeCopy.values():
# if (startNode.getID() == 605) and (endNode.getID() == 606):
# import ipdb; ipdb.set_trace()
# if (startNode.getID() !=node1) & (endNode.getID()!=node2):
if [startNode.getID(),
endNode.getID()] not in all_ready_checked_list:
dist = ((startNode.getX() - endNode.getX())**2 +
(startNode.getY() - endNode.getY())**2)**(.5)
total_demand = startNode.getDemand() + endNode.getDemand(
) # calculates the demand from both nodes
if dist < searchRadius: # selects feasible segments
segments.append(
network.Seg(segID, startNode, endNode, dist,
total_demand))
segID += 1
else:
pass
return segments
def readNetFromShp(inputShapefile):
'Reads segs and nodes from the given shapefile'
rows = gp.searchCursor(inputShapefile)
desc = gp.describe(inputShapefile)
net = network.Network()
row = rows.next()
while row:
feat = row.GetValue(desc.ShapeFieldName)
ptIDs = [row.getValue("pt1"), row.getValue("pt2")]
ptWeights = [row.getValue("pt1Weight"), row.getValue("pt2Weight")]
length = row.getValue("Length")
FID = row.getValue("FID")
# read nodes
part = feat.getPart(0)
part.reset()
pt = part.next()
nodes = []
for n in xrange(2):
nodes.append(network.Node(ptIDs[n], pt.x, pt.y, ptWeights[n]))
pt = part.next()
row = rows.next()
net.addSeg(network.Seg(FID, nodes[0], nodes[1], length))
del rows # ensure cursor closes
return net
def generateSegmentsDemand(centers, searchRadius, all_ready_checked_list,
roi_years, cost_per_kwh, tcost, LV,
fraction_recovered):
segments = []
nodeCopy = centers.copy()
# multiplier = 1
segID = 0
for startNode in centers.values():
del nodeCopy[startNode.getID()]
for endNode in nodeCopy.values():
# if (startNode.getID() == 605) and (endNode.getID() == 606):
# import ipdb; ipdb.set_trace()
# if (startNode.getID() !=node1) & (endNode.getID()!=node2):
if [startNode.getID(),
endNode.getID()] not in all_ready_checked_list:
dist = ((startNode.getX() - endNode.getX())**2 +
(startNode.getY() - endNode.getY())**2)**(.5)
total_demand = startNode.getDemand() + endNode.getDemand(
) # calculates the demand from both nodes
revenue = total_demand * roi_years * 12 * cost_per_kwh
# tx_cost = tcost * ((total_demand * 1000 * 0.6) / (4.0 * 30.0)) * fraction_recovered
delta = revenue - tcost
if delta > 0:
searchRadius = delta / float(LV * fraction_recovered)
if dist < searchRadius: # selects feasible segments
segments.append(
network.Seg(segID, startNode, endNode, dist,
total_demand))
segID += 1
else:
pass
# print [startNode.getID(),endNode.getID()]
# check segments length
# while (len(segments) == 0) & (multiplier <=5) :
# segments = []
# nodeCopy = centers.copy()
# segID = 0
# for startNode in centers.values():
# del nodeCopy[startNode.getID()]
# for endNode in nodeCopy.values():
# dist = ((startNode.getX() - endNode.getX()) ** 2 +
# (startNode.getY() - endNode.getY()) ** 2) ** (.5)
# total_demand = startNode.getDemand() + endNode.getDemand() # calculates the demand from both nodes
# if dist < searchRadius*multiplier: #selects feasible segments
# segments.append(network.Seg(segID, startNode, endNode,dist,total_demand))
# segID += 1
# multiplier+=1
return segments
def generateSegments(centers, searchRadius):
segments = []
nodeCopy = centers.copy()
segID = 0
for startNode in centers.values():
del nodeCopy[startNode.getID()]
for endNode in nodeCopy.values():
dist = ((startNode.getX() - endNode.getX())**2 +
(startNode.getY() - endNode.getY())**2)**(.5)
if dist < searchRadius:
segments.append(network.Seg(segID, startNode, endNode, dist))
segID += 1
return segments
def addLVSeg(tree, centers, nodesByClusterID): # single points line from the root
SegID = 1000000
for centerID in centers.keys():
try:
netID = tree.getNetID(centers[centerID])
except:
netID = 0
tree._nodesByNetID[0] = []
tree._network[netID] = []
for node in nodesByClusterID[centerID]:
length = ((node.getX() - centers[centerID].getX()) ** 2 +
(node.getY() - centers[centerID].getY()) ** 2) ** (.5)
newSeg = network.Seg(SegID, node, centers[centerID], length)
tree._netIDByNode[node] = netID
tree._nodesByNetID[netID].append(node)
tree._network[netID].append(newSeg)
return tree
def generateSegmentsDemand2(centers, searchRadius, all_ready_checked_list_mv):
segments = []
nodeCopy = centers.copy()
segID = 0
# all_ready_checked_list_mv = set(all_ready_checked_list_mv)
for startNode in centers.values():
del nodeCopy[startNode.getID()]
for endNode in nodeCopy.values():
# if (startNode.getID() == 680) and (endNode.getID() ==683):
# import ipdb; ipdb.set_trace()
if [startNode.getID(),
endNode.getID()] not in all_ready_checked_list_mv:
dist = ((startNode.getX() - endNode.getX())**2 +
(startNode.getY() - endNode.getY())**2)**(.5)
total_demand = startNode.getDemand() + endNode.getDemand(
) # calculates the demand from both nodes
if (dist < searchRadius): # selects feasible segments
segments.append(
network.Seg(segID, startNode, endNode, dist,
total_demand))
segID += 1
else:
pass
return segments
def CMST(households,capacity,root):
#Connects hhs directly to the root first
treeSegments={}
distDict={}
households_Copy=copy.deepcopy(households)
SegID=10000000
root_Copy=copy.deepcopy(root)
newRootID=root_Copy.getID()*(-1)-100 #### not to be confused with the same nodeID
root_Copy.setID(newRootID)
maxTvalue=0
branchNodeByNode={}# which branch is the node on?
nodesByBranchNode=collections.defaultdict(list )# what are the nodes on a spesific branch?
for node in households_Copy:
length=((node.getX()-root_Copy.getX())**2+(node.getY()-root_Copy.getY())**2)**(.5)
treeSegments[(node.getID(),newRootID)]=network.Seg(SegID, node, root_Copy, length)
SegID+=1
node.setWeight(length)
branchNodeByNode[node]=node
nodesByBranchNode[node].append(node)
distDict[(newRootID,node.getID())]=length
distDict[(node.getID(),newRootID)]=length
for node1 in households_Copy:
for node2 in households_Copy:
if node1==node2:
continue
else:
distance=((node1.getX()-node2.getX())**2+(node1.getY()-node2.getY())**2)**(.5)
distDict[(node1.getID(), node2.getID())]=distance
Tvalue=treeSegments[(node1.getID(),newRootID)].getWeight()-distance
if ((node2.getWeight()+distance)<=capacity):
newT=T(node1,node1,node2,Tvalue)
if (newT.getValue()>=maxTvalue):
maxTObject=newT
maxTvalue=newT.getValue()
totalLVCost=0
for segment in treeSegments.values():
totalLVCost=totalLVCost+segment.getWeight()
while(maxTvalue>0):
maxTvalue=0
SegID+=1
node1=maxTObject.getAddedSegmentNode1() # node1 and node2 of new segment
#print "node1", node1
node1Weigth=node1.getWeight()
node2=maxTObject.getAddedSegmentNode2()
#print "node2", node2
#delete root segment of branch
del treeSegments[(maxTObject.getRemovedSegmentNode().getID(),newRootID)]
#if node1 is the first node in the branch
if node1==branchNodeByNode[node1]:
tempWeight=node1.getWeight() # I need this becouse node1 is updated first and it effects the others
for node in nodesByBranchNode[branchNodeByNode[node1]]:
node.setWeight(node.getWeight()-tempWeight+ node2.getWeight()+distDict[(node1.getID(),node2.getID())])# digerlerinin de set olmasi lazim
#if not things get complicated and we need dfs
else:
segList=buildAssocDict(treeSegments.values()) # daha efficient yapmak icin sadece update edebilirim
depthFirstSet(node1,node2,root_Copy,segList,distDict) # root (node1) hala icinde unutma
#tree updated after weights are set
treeSegments[(node1.getID(), node2.getID())]=network.Seg(SegID,node1, node2,distDict[(node1.getID(),node2.getID())])
# Update dictionaries
nodesByBranchNode[branchNodeByNode[node2]].extend(nodesByBranchNode.pop(branchNodeByNode[node1]))
for node in nodesByBranchNode[branchNodeByNode[node2]]:
branchNodeByNode[node]=branchNodeByNode[node2]
# Rebuilt TStore & select maxT object
for node1 in households_Copy: #
#print "node1", node1
for node2 in households_Copy:
if node1==node2 or branchNodeByNode[node1]==branchNodeByNode[node2]:
continue
else:
maxDistFromNode1=maxDistFromNode(node1,root_Copy,treeSegments,distDict)
#print "maaxx",maxDistFromNode1
if (node2.getWeight()+distDict[node1.getID(),node2.getID()]+maxDistFromNode1<=capacity): #1 2ye baslansa ne olur?
#print "TTTTT", Tvalue
Tvalue=treeSegments[(branchNodeByNode[node1].getID(),newRootID)].getWeight()-distDict[(node1.getID(),node2.getID())]
if Tvalue>=maxTvalue:
maxTvalue=Tvalue
maxTObject=T(branchNodeByNode[node1],node1,node2,Tvalue)
#print maxTvalue
#print maxTObject
totalLVCost=0
for segment in treeSegments.values():
totalLVCost=totalLVCost+segment.getWeight()
del root_Copy
gc.collect()
#print treeSegments.keys()
#print households_Copy
return treeSegments, totalLVCost
