def computeLineString(bounding_box, pos, long_lats):
bbx = box(bounding_box[0], bounding_box[1], bounding_box[2],
bounding_box[3])
basedist = point.Point(bounding_box[0], bounding_box[1]).distance(
point.Point(bounding_box[0], bounding_box[3])) * 1.2
start = pos
end = pos + 1
while (start > 0):
p = point.Point(long_lats[start][0], long_lats[start][1])
if (bbx.contains(p) or (basedist > bbx.distance(p))):
start -= 1
else:
break
while (end < len(long_lats)):
p = point.Point(long_lats[end][0], long_lats[end][1])
if (bbx.contains(p) or (basedist > bbx.distance(p))):
end += 1
else:
break
end += 1
if (end > len(long_lats)):
end = len(long_lats)
if (end - start == 1):
if (start > 0):
start -= 1
if (end < len(long_lats)):
end += 1
return linestring.LineString([(long_lats[i][0], long_lats[i][1])
for i in range(start, end)])
def create_citydist(create_environment, create_building):
"""
Pytest fixture function to generate city district with three
res. buildings (with demands) on positions (0, 0), (0, 10), (10, 10)
Parameters
----------
create_environment : object
Environment object (as fixture of pytest)
Returns
-------
create_citydistrict : object
CityDistrict object of PyCity
"""
create_citydist = citydist.CityDistrict()
# Add environment
create_empty_citydist.environment = create_environment
create_citydist.addEntity(entity=create_building,
position=point.Point(0, 0))
create_citydist.addEntity(entity=create_building,
position=point.Point(0, 10))
create_citydist.addEntity(entity=create_building,
position=point.Point(10, 10))
return create_citydist
def test_mutation(self):
dict_restr = {'boi': [1],
'tes': [2],
'chp': [3],
'hp_aw': [4],
'hp_ww': [5],
'eh': [6],
'bat': [8]}
b_dict = {'boi': 10,
'chp': 20,
'hp_aw': 0,
'hp_ww': 0,
'eh': 50,
'tes': 60,
'pv': 70,
'bat': 80}
ind = {1001: b_dict,
1002: copy.copy(b_dict),
1003: copy.copy(b_dict),
1008: copy.copy(b_dict),
'lhn': []}
dict_max_pv_area = {1001: 100,
1002: 100,
1003: 100,
1008: 100}
p1 = point.Point(0, 0)
p2 = point.Point(10, 0)
p3 = point.Point(20, 0)
p8 = point.Point(30, 0)
dict_pos = {1001: p1, 1002: p2, 1003: p3, 1008: p8}
dict_sh = {1001: 1, 1002: 1, 1003: 1, 1008: 1}
ind_new = mutate.do_mutate(ind=ind, prob_mut=1, prob_lhn=1,
dict_restr=dict_restr,
dict_max_pv_area=dict_max_pv_area,
pv_min=10,
dict_pos=dict_pos,
list_prob_lhn_and_esys=[0, 0, 1],
# Only esys mutation
list_prob_mute_type=[1, 0],
# Only attribute changes
list_prob_lhn_gen_mut=[0.3, 0.7],
# Not used, here
max_dist=None,
dict_sh=dict_sh,
dict_heatloads=dict_sh)
assert ind_new[1001]['boi'] == 1
assert ind_new[1001]['tes'] == 2
assert ind_new[1001]['chp'] == 3
assert ind_new[1001]['hp_aw'] == 0
assert ind_new[1001]['hp_ww'] == 0
assert ind_new[1001]['eh'] == 6
assert ind_new[1001]['pv'] > 0
assert ind_new[1001]['bat'] == 8
def test_add_lhn(self):
dict_restr = {
'boi': [1],
'tes': [2],
'chp': [3],
'hp_aw': [4],
'hp_ww': [5],
'eh': [6],
'pv': [7],
'bat': [8]
}
b_dict = {
'boi': 0,
'chp': 0,
'hp_aw': 20,
'hp_ww': 0,
'eh': 0,
'tes': 30,
'pv': 0,
'bat': 0
}
ind = {
1001: b_dict,
1002: copy.copy(b_dict),
1003: copy.copy(b_dict),
1008: copy.copy(b_dict),
'lhn': []
}
dict_max_pv_area = {1001: 10, 1002: 20, 1003: 30, 1008: 40}
p1 = point.Point(0, 0)
p2 = point.Point(10, 0)
p3 = point.Point(20, 0)
p8 = point.Point(30, 0)
dict_pos = {1001: p1, 1002: p2, 1003: p3, 1008: p8}
lhnchanges.add_lhn(ind=ind,
dict_restr=dict_restr,
pv_min=0,
dict_max_pv_area=dict_max_pv_area,
dict_pos=dict_pos,
list_prob_lhn=[1, 0],
prob_gen_method=[1, 0, 0])
assert len(ind['lhn'][0]) > 0
count_chp = 0
count_tes = 0
for i in [1001, 1002, 1003, 1008]:
if ind[i]['chp'] > 0:
count_chp += 1
if ind[i]['tes'] > 0:
count_tes += 1
assert count_chp > 0
assert count_tes > 0
def test_kmeans_clustering(self):
p1 = point.Point(0, 0)
p2 = point.Point(1, 0)
p3 = point.Point(12, 0)
p4 = point.Point(15, 3)
p5 = point.Point(10, 10)
p6 = point.Point(20, 20)
p7 = point.Point(24, 20)
p8 = point.Point(0, 10)
dict_pos = {
1001: p1,
1002: p2,
1003: p3,
1004: p4,
1005: p5,
1006: p6,
1007: p7,
1008: p8
}
list_av_ids = [1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008]
nb_clusters = 2
dict_clusters = clust.kmeans_clustering(dict_pos=dict_pos,
list_av_ids=list_av_ids,
nb_clusters=nb_clusters)
def test_mutation_loop(self):
dict_restr = {'boi': [1, 2],
'tes': [2, 3],
'chp': [3, 4],
'hp_aw': [4, 5],
'hp_ww': [5, 6],
'eh': [6, 7],
'bat': [8, 9]}
b_dict = {'boi': 10,
'chp': 20,
'hp_aw': 0,
'hp_ww': 0,
'eh': 0,
'tes': 60,
'pv': 70,
'bat': 80}
ind = {1001: b_dict,
1002: copy.copy(b_dict),
1003: copy.copy(b_dict),
1004: copy.copy(b_dict),
1005: copy.copy(b_dict),
1006: copy.copy(b_dict),
1007: copy.copy(b_dict),
1008: copy.copy(b_dict),
'lhn': [[1001, 1002, 1003, 1004]]}
dict_max_pv_area = {1001: 100,
1002: 100,
1003: 100,
1004: 100,
1005: 100,
1006: 100,
1007: 100,
1008: 100}
p1 = point.Point(0, 0)
p2 = point.Point(10, 0)
p3 = point.Point(20, 0)
p4 = point.Point(0, 10)
p5 = point.Point(10, 10)
p6 = point.Point(20, 10)
p7 = point.Point(30, 10)
p8 = point.Point(30, 20)
dict_pos = {1001: p1, 1002: p2, 1003: p3, 1004: p4,
1005: p5, 1006: p6, 1007: p7, 1008: p8}
dict_sh = {1001: 1, 1002: 1, 1003: 1, 1004: 1,
1005: 1, 1006: 1, 1007: 1, 1008: 1}
for i in range(500):
mutate.do_mutate(ind=ind, prob_mut=0.7, prob_lhn=0.7,
dict_restr=dict_restr,
dict_max_pv_area=dict_max_pv_area,
pv_min=10,
dict_pos=dict_pos, dict_sh=dict_sh,
dict_heatloads=dict_sh)
def test_add_multiple_entities(self, create_empty_citydist,
create_building):
# Create empty citydistrict
city = create_empty_citydist
# Create building
building = create_building
position_1 = point.Point(0, 0)
position_2 = point.Point(0, 10)
pos_list = [position_1, position_2]
# Add entity
city.addMultipleEntities(entities=[building, building],
positions=pos_list)
assert len(city.nodelist_building) == 2
def calcAlignment(backPos, walls, wallProbVec, dR):
"""
calculating object alignment, currently only w.r.t. supporting wall
backPos - vector of objects' back position (numpy array)
walls - list of walls, each represented as a line (end points)
wallProbVec - probability vector of objects' to stand against the wall
dR - space diagonal (scalar)
"""
#
# ====> DIDNOT check direction, i.e. that object is parallel/perpendicular to wall
#
nW = len(walls)
nO = len(backPos)
wLines = []
for iW in range(nW):
wLines.append(sgls.LineString((walls[iW][0], walls[iW][1])))
wSum = 0
for iO in range(nO):
dP = np.array([])
for iW in range(nW):
# shortest distance to wall
dP = np.append(dP, wLines[iW].distance(spt.Point(backPos[iO])))
wSum += wallProbVec[iO] * min(dP)
wSum /= (nO * dR)
return wSum
def create_point(longitude_x, latitude_y) -> point:
"""
Returns a shapely point object containing the provided coordinates.
:param longitude_x: Longitude value
:param latitude_y: Latitude value
:return point:
"""
return point.Point(float(longitude_x), float(latitude_y))
def test_get_ids_sorted_by_dist(self):
id = 1001
p1 = point.Point(0, 0)
p4 = point.Point(10, 0)
p2 = point.Point(20, 0)
p3 = point.Point(30, 0)
p5 = point.Point(30, 10)
dict_pos = {1001: p1, 1002: p2, 1003: p3, 1004: p4, 1005: p5}
list_av = [1001, 1002, 1003, 1004, 1005]
list_sorted = analyse. \
get_ids_sorted_by_dist(id=id, dict_pos=dict_pos, list_av=list_av)
assert list_sorted == [1004, 1002, 1003, 1005]
def create_ellipse(center, lengths, angle=0):
"""
create a shapely ellipse. adapted from
https://gis.stackexchange.com/a/243462
"""
circ = shp.Point(center).buffer(1)
ell = sh.affinity.scale(circ, (lengths[0]), (lengths[1]))
ellr = sh.affinity.rotate(ell, angle)
return ellr
def getHexagonCoordsForPoint(self, x, y):
((minColumn, minRow),
(maxColumn,
maxRow)) = self.getHexagonCoordSpanForBoundingBox(x, y, x, y)
for xCol in range(minColumn, maxColumn + 1):
for yRow in range(minRow, maxRow + 1):
if self.getHexagon(xCol, yRow).contains(point.Point(x, y)):
return xCol, yRow
raise Exception(
"No Hexagon matched; possible edge case (point on hexagon boundary)"
)
def calcGoldenSec(objPos, roomRect, dR):
"""
calculating objects location w.r.t. golden section lines
objPos: objects' center position
roomRect: 4 points of room (or sub-area) rectangle
dR: room diagonal
"""
# make sure the vertices are ordered
tmpRect = sgp.Polygon(roomRect)
tmpRect = tmpRect.convex_hull
t_rect = tmpRect.exterior.coords[0:-1]
# creating golden lines. Assuming gsRatio = 13/21
# go over the 2 consecutive pair of vertices and generate the 4-lines, 2 in each side
gsr = 13.0 / 21.0
line1 = sgls.LineString((t_rect[0], t_rect[1]))
length = npla.norm(np.array(t_rect[0]) - np.array(t_rect[1]))
pt11 = line1.interpolate(length * (1.0 - gsr))
pt12 = line1.interpolate(length * gsr)
line3 = sgls.LineString((t_rect[2], t_rect[3]))
length = npla.norm(np.array(t_rect[2]) - np.array(t_rect[3]))
pt32 = line3.interpolate(length * (1.0 - gsr))
pt31 = line3.interpolate(length * gsr)
line2 = sgls.LineString((t_rect[1], t_rect[2]))
length = npla.norm(np.array(t_rect[1]) - np.array(t_rect[2]))
pt21 = line2.interpolate(length * (1.0 - gsr))
pt22 = line2.interpolate(length * gsr)
line4 = sgls.LineString((t_rect[3], t_rect[0]))
length = npla.norm(np.array(t_rect[3]) - np.array(t_rect[0]))
pt42 = line4.interpolate(length * (1.0 - gsr))
pt41 = line4.interpolate(length * gsr)
gsLines = []
gsLines.append(sgls.LineString((pt11, pt31)))
gsLines.append(sgls.LineString((pt12, pt32)))
gsLines.append(sgls.LineString((pt21, pt41)))
gsLines.append(sgls.LineString((pt22, pt42)))
dObjGs = []
for i in range(len(objPos)):
dd = []
for j in range(len(gsLines)):
dd.append(gsLines[j].distance(spt.Point(objPos[i])))
dObjGs.append(min(dd))
gP = np.sum(dObjGs)
gP /= (1.0 * dR * len(objPos))
return gP
def main():
surnames = read_surnames()
europe = Europe()
projection = crs.PlateCarree()
ax = pyplot.axes(projection=europe)
kosovo_geometry = None
for country in shapereader.Reader('ne_110m_admin_0_countries').records():
country_geometry = country.geometry
geometry = europe.project_geometry(
projection.project_geometry(country_geometry))
if geometry.is_empty:
continue
centroid = geometry.centroid
name = country.attributes['name_long']
if name == 'Russian Federation': # Workaround.
centroid = point.Point(3.6e6, 2.6e6)
elif name == 'Albania':
centroid = point.Point(centroid.x, centroid.y - 25e3)
elif name == 'Bosnia and Herzegovina':
centroid = point.Point(centroid.x, centroid.y - 67e3)
elif name == 'Croatia':
centroid = point.Point(centroid.x, centroid.y + 25e3)
elif name == 'Kosovo':
kosovo_geometry = country_geometry
continue
elif name == 'Macedonia':
centroid = point.Point(centroid.x + 100e3, centroid.y)
elif name == 'Montenegro':
centroid = point.Point(centroid.x - 100e3, centroid.y)
elif name == 'Serbia':
country_geometry = (country_geometry.union(kosovo_geometry),)
try:
surname = surnames[name]
ax.add_geometries(
country_geometry,
projection,
facecolor=COLORS[surname[1]],
edgecolor=BORDER_COLOR)
ax.text(
centroid.x,
centroid.y,
surname[0],
ha='center',
va='center',
size=10)
except KeyError:
ax.add_geometries(
country_geometry,
projection,
facecolor=DEFAULT_COLOR,
edgecolor=BORDER_COLOR)
# Workaround for Catalonia and Kosovo.
ax.text(1100e3, 800e3, '(Ferrer)', ha='center', va='center', size=9)
ax.text(2800e3, 850e3, '(Hoxha)', ha='center', va='center', size=9)
legend_handles = [
patches.Circle((0.5, 0.5), color=COLORS[k]) for k in COLORS]
pyplot.figlegend(legend_handles, COLORS.keys(), 'upper left', fontsize=10)
pyplot.savefig('surnames.png')
def circle_group_area(radiuses, positions):
circles = []
for i in range(len(radiuses)):
circles.append(
point.Point(positions[i][0], positions[i][1]).buffer(radiuses[i]))
union = ops.unary_union(circles)
result = [geom for geom in ops.polygonize(union)]
completeareas = [list(ops.polygonize(g.exterior))[0].area for g in result]
max_index = np.argmax(completeareas)
result_area = result[max_index].area
return result_area
def main():
p1 = point.Point(0, 0)
p2 = point.Point(1, 0)
p3 = point.Point(12, 0)
p4 = point.Point(15, 3)
p5 = point.Point(10, 10)
p6 = point.Point(20, 20)
p7 = point.Point(24, 20)
p8 = point.Point(0, 10)
dict_pos = {1001: p1,
1002: p2,
1003: p3,
1004: p4,
1005: p5,
1006: p6,
1007: p7,
1008: p8}
list_av_ids = [1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008]
nb_clusters = 3
dict_clusters = kmeans_clustering(dict_pos=dict_pos,
list_av_ids=list_av_ids,
nb_clusters=nb_clusters)
print('Results of kmeans clustering:')
print(dict_clusters)
print()
for key in dict_clusters.keys():
print('Key: ', key)
print('Values: ', dict_clusters[key])
print()
print('###########################################################')
dict_clusters = meanshift_clustering(dict_pos=dict_pos,
list_av_ids=list_av_ids)
print('Results of meanshift clustering:')
print(dict_clusters)
print()
for key in dict_clusters.keys():
print('Key: ', key)
print('Values: ', dict_clusters[key])
print()
print('###########################################################')
def compute_bounds():
border_points = REFERENCE_POINTS.get('+init=epsg:3857',
REFERENCE_POINTS['default'])
max_x = max_y = float("-infinity")
min_x = min_y = float("infinity")
for point in border_points:
point = shapelypoint.Point(*point)
# Project the border points following the projection system
point = shapelypoint.Point(p_wgs84_3857(point.x, point.y))
# Ignore the border points which cannot be projected
if point.x != float("infinity") or point.y != float("infinity"):
# Compute the smallest bounds containing the border points
min_x = min(point.x, min_x)
max_x = max(point.x, max_x)
min_y = min(point.y, min_y)
max_y = max(point.y, max_y)
return min_x, min_y, max_x, max_y
def test_add_entity_building(self, create_empty_citydist, create_building):
# Create empty citydistrict
city = create_empty_citydist
# Create building
building = create_building
position_1 = point.Point(0, 0)
# Add entity
node_nb = city.addEntity(entity=building, position=position_1)
assert city.node[node_nb]['entity']._kind == 'building'
assert city.node[node_nb]['position'] == position_1
# Check uesgraphs attribute
assert len(city.nodelist_building) == 1
def create_points(data):
"""
Create shapely geometry from list of dicts
"""
for row in data:
if row["x"] and row["y"]:
try:
row["geometry"] = point.Point(float(row["x"]),
float(row["y"]))
except:
row["geometry"] = None
else:
row["geometry"] = None
return data
def process_and_update_vic(**tweets):
for tweet in tweets:
geo = tweets[tweet].get('geo')
if not geo:
tweets[tweet]['zone'] = 'NoGeo'
else:
geo.sort(reverse=True)
for zone in vic_map:
if vic_map[zone].contains(point.Point(geo)):
tweets[tweet]['zone'] = zone
break
if not tweets[tweet]['zone']:
tweets[tweet]['zone'] = 'NotVic'
try:
resp = requests.post('http://172.26.38.1:8080/api/tweet/trained/zone/vic/', headers=headers, json=tweets)
except Exception:
return
def __new__(self, points=None):
if points is None:
# allow creation of empty multipoints, to support unpickling
# TODO better empty constructor
return shapely.from_wkt("MULTIPOINT EMPTY")
elif isinstance(points, MultiPoint):
return points
m = len(points)
subs = []
for i in range(m):
p = point.Point(points[i])
if p.is_empty:
raise EmptyPartError(
"Can't create MultiPoint with empty component")
subs.append(p)
if len(points) == 0:
return shapely.from_wkt("MULTIPOINT EMPTY")
return shapely.multipoints(subs)
def __new__(self, points=None):
"""
Parameters
----------
points : sequence
A sequence of (x, y [,z]) numeric coordinate pairs or triples or a
sequence of objects that implement the numpy array interface,
including instances of Point.
Example
-------
Construct a 2 point collection
>>> from shapely.geometry import Point
>>> ob = MultiPoint([[0.0, 0.0], [1.0, 2.0]])
>>> len(ob.geoms)
2
>>> type(ob.geoms[0]) == Point
True
"""
if points is None:
# allow creation of empty multipoints, to support unpickling
# TODO better empty constructor
return shapely.from_wkt("MULTIPOINT EMPTY")
elif isinstance(points, MultiPoint):
return points
m = len(points)
subs = []
for i in range(m):
p = point.Point(points[i])
if p.is_empty:
raise EmptyPartError(
"Can't create MultiPoint with empty component")
subs.append(p)
if len(points) == 0:
return shapely.from_wkt("MULTIPOINT EMPTY")
return shapely.multipoints(subs)
def PntGeoJSONToShp_WGS84(json_fp,
shp_fp=None): #点状GeoJSON文件转成SHP（火星坐标 转 WGS84）
import coordinate_conversion
from shapely.geometry import point
if not json_fp.endswith("json"): return False
if shp_fp is None:
shp_fp = "{}_wgs84.shp".format(json_fp[:-5])
elif not shp_fp.endswith("shp"):
return False
gdf = geopandas.read_file(json_fp)
# GCJ02转WGS84
for i in range(0, len(gdf)):
geom = gdf.geometry[i] # 获取空间属性，即GeoSeries
lng, lat = geom.x, geom.y # x=117.967657, y=24.472853
lng, lat = coordinate_conversion.gcj02towgs84(lng, lat)
gdf.geometry[i] = point.Point(lng, lat)
# 设置成WGS84，并保存
gdf.crs = {'init': 'epsg:4326'}
gdf.to_file(shp_fp, encoding="utf-8")
return shp_fp
def test_get_list_ids_sorted_by_dist_to_ref_list(self):
list_ref = [1001, 1002, 1003]
list_search = [1004, 1005, 1006]
p1 = point.Point(0, 0)
p2 = point.Point(10, 0)
p3 = point.Point(0, 10)
p4 = point.Point(0, 30)
p5 = point.Point(40, 0)
p6 = point.Point(0, -10)
dict_pos = {1001: p1, 1002: p2, 1003: p3, 1004: p4, 1005: p5, 1006: p6}
list_sorted = analyse. \
get_list_ids_sorted_by_dist_to_ref_list(list_ref=list_ref,
list_search=list_search,
dict_pos=dict_pos)
assert list_sorted == [(1006, 10), (1004, 20), (1005, 30)]
def test_get_ids_closest_dist_to_list_of_build(self):
list_ref = [1001, 1002, 1003]
list_search = [1004, 1005, 1006]
p1 = point.Point(0, 0)
p2 = point.Point(10, 0)
p3 = point.Point(0, 10)
p4 = point.Point(0, 30)
p5 = point.Point(40, 0)
p6 = point.Point(0, -10)
dict_pos = {1001: p1, 1002: p2, 1003: p3, 1004: p4, 1005: p5, 1006: p6}
dict_dist = analyse. \
get_ids_closest_dist_to_list_of_build(list_ref=list_ref,
list_search=list_search,
dict_pos=dict_pos)
assert dict_dist == {1004: 20, 1005: 30, 1006: 10}
def shape_factory(self, *args):
return point.Point(*args)
# Generate environment
environment = pycity_base.classes.Environment.Environment(timer, weather, prices)
#Network Specification
networksDictionary={}
networksDictionary['Electricity']={'busVoltage':1000,'diameter':0.2,'spConductance':1.68*10**-8}
networksDictionary['Gas']={'diameter':0.5,'gasDensity':0.8,'darcyFactor':0.03}
networksDictionary['Heat']={'diameter':0.5,'spConductance':0.591}
networksDictionary['Water']={'diameter':0.5,'waterDensity':1000,'darcyFactor':0.03}
#Generate city district object
cityDistrict = CityDistrict.CityDistrict(environment,networksDictionary)
# Generate shapely point positions
location = {}
location[1] = point.Point(-5000, -100) #Gas Source
location[2] = point.Point(0, 0) #District Heating CHP
location[3] = point.Point(100, 20) #Building3
location[4] = point.Point(120, 20) #Building4
location[5] = point.Point(160, 20) #Building5
location[6] = point.Point(200, 20) #Building6
location[7] = point.Point(160, -20) #Building7
location[8] = point.Point(200, -20) #Building8
location[9] = point.Point(1500, 50) #Building9
location[10]= point.Point(1600, 50) #Building10
location[11]= point.Point(1700, 50) #Building11
location[12]= point.Point(1800,50) #Building12
location[13]= point.Point(2000,180) #Wind Turbine
location[14]= point.Point(2000,100) #Power-to-Gas Converter
location[15]= point.Point(2000,95) #Power-to-Gas Storage
location[16]= point.Point(1500,-50) #Photovoltaic Farm
def run_city_generator(gen_mo=0, input_name='test_city_mixed_buildings.txt',
output_name=None, use_el_slp=True,
gen_dhw_profile=False):
"""
Function to generate and return city district object
Parameters
----------
gen_mo : int, optional
Generation mode number:
0 - Use data from input file (default)
input_name : str, optional
Name of input data file (default: 'test_city_only_buildings.txt')
output_name : str, optional
Name of output file (default: None)
If output_name is None, no output file is generated.
Else: Pickled output file is saved to output folder
use_el_slp : bool, optional
Boolean to define, how electrical load profile should be generated
(default: True)
True: Generate el. load profile via el. slp
False: Use stochastic profile generator (
only valid for residential buildings!)
gen_dhw_profile : bool, optional
Boolean to define, if domestic hot water profile should be generated
(default: False)
True: Generate dhw profile (valid for residential buildings!)
False: Do not generate dhw profile
Returns
-------
city_district : object
CityDistrict object of PyCity
"""
# Generate timer, weather and price objects
timer = pycity_base.classes.Timer.Timer()
weather = pycity_base.classes.Weather.Weather(timer)
prices = pycity_base.classes.Prices.Prices()
# Generate environment
environment = pycity_base.classes.Environment.Environment(timer, weather,
prices)
# Generate city district object
city_district = citydis.CityDistrict(environment)
# Current file path
curr_path = os.path.dirname(os.path.abspath(__file__))
# Choose city district generation method
if gen_mo == 0: # Load data from file
import_path = os.path.join(curr_path, 'input', input_name)
city_dist_pandas_dataframe = pandas.read_csv(import_path, sep='\t')
for index, row in city_dist_pandas_dataframe.iterrows():
curr_name = row['name'] # Building name
curr_x = row['x_coord / m'] # Building x coordinate in m
curr_y = row['y_coord / m'] # Building y coordinate in m
curr_area = row[
'living_area / m2']
# Net floor area (respectively living area) in m2
curr_th_spec_demand = row[
'specific_th_demand / kWh/m2a']
# Spec. thermal energy demand in kWh/m2a
curr_el_demand = row[
'an_el_demand / kWh/a']
# Annual electric energy demand in kWh/a
curr_th_slp = row['th_slp_profile_type'] # Thermal SLP type
curr_el_slp = row['el_slp_profile_type'] # Electrical SLP type
curr_total_nb_occupants = row[
'total_nb_occupants'] # Total number of occupants in building
# Assert input values
assert curr_area > 0
assert curr_th_spec_demand > 0
assert curr_el_demand > 0
print('Processing building', curr_name)
# Check if number of occupants is nan
# (for non residential buildings)
if math.isnan(curr_total_nb_occupants):
curr_total_nb_occupants = None # Replace nan with None
else: # If number of occupants is not nan, convert value
# to integer
curr_total_nb_occupants = int(curr_total_nb_occupants)
assert curr_total_nb_occupants >= 1
assert curr_total_nb_occupants <= 5
# Generate heat demand curve for space heating
heat_demand = \
SpaceHeating.SpaceHeating(environment,
method=1,
# Standard load profile
livingArea=curr_area,
specificDemand=curr_th_spec_demand,
profile_type=curr_th_slp)
if use_el_slp: # Use el. SLP
el_method = 1
occupancy_profile = [] # Dummy value
else: # Stochastic profile generator
# (only for residential buildings)
el_method = 2
# Generate stochastic occupancy profile
occupancy_object = \
occu.Occupancy(environment,
number_occupants=curr_total_nb_occupants)
occupancy_profile = occupancy_object.occupancy
# Generate electrical demand curve
el_demand = \
ElectricalDemand.ElectricalDemand(environment,
method=el_method,
annualDemand=curr_el_demand,
profileType=curr_el_slp,
singleFamilyHouse=True,
total_nb_occupants=curr_total_nb_occupants,
randomizeAppliances=True,
lightConfiguration=0,
occupancy=occupancy_profile)
# Generate apartment and add demand durves
apartment = Apartment.Apartment(environment)
apartment.addMultipleEntities([heat_demand, el_demand])
if gen_dhw_profile:
# Generate domestic hot water demand curve
dhw_annex42 = \
DomesticHotWater.DomesticHotWater(environment,
tFlow=60,
thermal=True,
method=1,
# Annex 42
dailyConsumption=70,
supplyTemperature=25)
apartment.addEntity(dhw_annex42)
# Generate heating curve
heatingCurve = HeatingCurve.HeatingCurve(environment)
# Generate building and add apartment and heating curve
building = Building.Building(environment)
entities = [apartment, heatingCurve]
building.addMultipleEntities(entities)
# Generate shapely point positions
position = point.Point(curr_x, curr_y)
# Add buildings to city district
city_district.addEntity(entity=building, position=position,
name=curr_name)
print('Added building', curr_name, ' to city district.')
# Save results as pickled file
if output_name is not None:
output_path = os.path.join(curr_path, 'output', output_name)
# Pickle and dump city objects
pickle.dump(city_district, open(output_path, 'wb'))
print('Pickled and dumped city object')
return city_district
def test_get_dict_usable_pv_areas(self):
# Create extended environment of pycity_calc
year = 2010
timestep = 3600 # Timestep in seconds
location = (51.529086, 6.944689) # (latitude, longitute) of Bottrop
altitude = 55 # Altitude of Bottrop
# Generate timer object
timer = time.TimerExtended(timestep=timestep, year=year)
# Generate weather object
weather = Weather.Weather(timer,
useTRY=True,
location=location,
altitude=altitude)
# Generate market object
market = germarkt.GermanMarket()
# Generate co2 emissions object
co2em = co2.Emissions(year=year)
# Generate environment
environment = env.EnvironmentExtended(timer,
weather,
prices=market,
location=location,
co2em=co2em)
# Generate city object
city_object = city.City(environment=environment)
use_pv_area_1 = 30
extended_building = build_ex. \
BuildingExtended(environment,
build_year=1962,
mod_year=2003,
build_type=0,
roof_usabl_pv_area=use_pv_area_1,
net_floor_area=150,
height_of_floors=3,
nb_of_floors=2,
neighbour_buildings=0,
residential_layout=0,
attic=0, cellar=1,
construction_type='heavy',
dormer=0)
position = point.Point(0, 0)
city_object.add_extended_building(extended_building=extended_building,
position=position)
use_pv_area_2 = 0
extended_building2 = build_ex. \
BuildingExtended(environment,
build_year=1962,
mod_year=2003,
build_type=0,
roof_usabl_pv_area=use_pv_area_2,
net_floor_area=150,
height_of_floors=3,
nb_of_floors=2,
neighbour_buildings=0,
residential_layout=0,
attic=0, cellar=1,
construction_type='heavy',
dormer=0)
position2 = point.Point(0, 50)
city_object.add_extended_building(extended_building=extended_building2,
position=position2)
dict_use_pv_area = pvareas.get_dict_usable_pv_areas(city=city_object)
assert sorted(dict_use_pv_area.keys()) == [1001, 1002]
assert dict_use_pv_area[1001] == use_pv_area_1
assert dict_use_pv_area[1002] == use_pv_area_2
def getShapelyPoint(self):
pt = SPoint.Point(self.x, self.y)
return pt
