158 lines
6.3 KiB
Python
158 lines
6.3 KiB
Python
"""
|
|
Storeys generation helper
|
|
SPDX - License - Identifier: LGPL - 3.0 - or -later
|
|
Copyright © 2020 Project Author Pilar Monsalvete Alvarez de Uribarri pilar.monsalvete@concordia.ca
|
|
"""
|
|
import sys
|
|
import math
|
|
import numpy as np
|
|
|
|
from helpers import constants as cte
|
|
from city_model_structure.attributes.polygon import Polygon
|
|
from city_model_structure.attributes.point import Point
|
|
from city_model_structure.building_demand.storey import Storey
|
|
from city_model_structure.building_demand.surface import Surface
|
|
|
|
|
|
class StoreysGeneration:
|
|
"""
|
|
StoreysGeneration
|
|
"""
|
|
def __init__(self, building, divide_in_storeys=False):
|
|
self._building = building
|
|
self._divide_in_storeys = divide_in_storeys
|
|
self._storeys = None
|
|
|
|
@property
|
|
def storeys(self) -> [Storey]:
|
|
"""
|
|
Get subsections of building trimesh by storey in case of no interiors defined
|
|
:return: [Storey]
|
|
"""
|
|
number_of_storeys, height = self._calculate_number_storeys_and_height(self._building.average_storey_height,
|
|
self._building.eave_height,
|
|
self._building.storeys_above_ground)
|
|
number_of_storeys = 1
|
|
if not self._divide_in_storeys or number_of_storeys == 1:
|
|
return [Storey('storey_0', self._building.surfaces, [None, None], self._building.volume)]
|
|
|
|
if number_of_storeys == 0:
|
|
raise Exception('Number of storeys cannot be 0')
|
|
|
|
storeys = []
|
|
surfaces_child_last_storey = []
|
|
rest_surfaces = []
|
|
|
|
total_volume = 0
|
|
for i in range(0, number_of_storeys - 1):
|
|
name = 'storey_' + str(i)
|
|
surfaces_child = []
|
|
if i == 0:
|
|
neighbours = [None, 'storey_1']
|
|
for surface in self._building.surfaces:
|
|
if surface.type == cte.GROUND:
|
|
surfaces_child.append(surface)
|
|
else:
|
|
rest_surfaces.append(surface)
|
|
else:
|
|
neighbours = ['storey_' + str(i - 1), 'storey_' + str(i + 1)]
|
|
height_division = self._building.lower_corner[2] + height * (i + 1)
|
|
intersections = []
|
|
for surface in rest_surfaces:
|
|
if surface.type == cte.ROOF:
|
|
if height_division >= surface.upper_corner[2] > height_division - height:
|
|
surfaces_child.append(surface)
|
|
else:
|
|
surfaces_child_last_storey.append(surface)
|
|
else:
|
|
surface_child, rest_surface, intersection = surface.divide(height_division)
|
|
surfaces_child.append(surface_child)
|
|
intersections.extend(intersection)
|
|
if i == number_of_storeys - 2:
|
|
surfaces_child_last_storey.append(rest_surface)
|
|
points = []
|
|
for intersection in intersections:
|
|
points.append(intersection[1])
|
|
coordinates = self._intersections_to_coordinates(intersections)
|
|
polygon = Polygon(coordinates)
|
|
ceiling = Surface(polygon, polygon, surface_type=cte.INTERIOR_SLAB)
|
|
surfaces_child.append(ceiling)
|
|
volume = ceiling.area_above_ground * height
|
|
total_volume += volume
|
|
storeys.append(Storey(name, surfaces_child, neighbours, volume))
|
|
name = 'storey_' + str(number_of_storeys - 1)
|
|
neighbours = ['storey_' + str(number_of_storeys - 2), None]
|
|
volume = self._building.volume - total_volume
|
|
if volume < 0:
|
|
raise Exception('Error in storeys creation, volume of last storey cannot be lower that 0')
|
|
storeys.append(Storey(name, surfaces_child_last_storey, neighbours, volume))
|
|
return storeys
|
|
|
|
@staticmethod
|
|
def _calculate_number_storeys_and_height(average_storey_height, eave_height, storeys_above_ground):
|
|
if average_storey_height is None:
|
|
if storeys_above_ground is None or storeys_above_ground <= 0:
|
|
sys.stderr.write('Warning: not enough information to divide building into storeys, '
|
|
'either number of storeys or average storey height must be provided.\n')
|
|
return 0, 0
|
|
number_of_storeys = int(storeys_above_ground)
|
|
height = eave_height / number_of_storeys
|
|
else:
|
|
height = float(average_storey_height)
|
|
if storeys_above_ground is not None:
|
|
number_of_storeys = int(storeys_above_ground)
|
|
else:
|
|
number_of_storeys = math.floor(float(eave_height) / height) + 1
|
|
last_storey_height = float(eave_height) - height*(number_of_storeys-1)
|
|
if last_storey_height < 0.3*height:
|
|
number_of_storeys -= 1
|
|
return number_of_storeys, height
|
|
|
|
@staticmethod
|
|
def _intersections_to_coordinates(edges_list):
|
|
# todo: this method is not robust, the while loop needs to be improved
|
|
points = [Point(edges_list[0][0]), Point(edges_list[0][1])]
|
|
found_edges = []
|
|
j = 0
|
|
while j < len(points)-1:
|
|
for i in range(1, len(edges_list)):
|
|
if i not in found_edges:
|
|
point_2 = points[len(points) - 1]
|
|
point_1 = Point(edges_list[i][0])
|
|
found = False
|
|
if point_1.distance_to_point(point_2) <= 1e-10:
|
|
points.append(Point(edges_list[i][1]))
|
|
found_edges.append(i)
|
|
found = True
|
|
if not found:
|
|
point_1 = Point(edges_list[i][1])
|
|
if point_1.distance_to_point(point_2) <= 1e-10:
|
|
points.append(Point(edges_list[i][0]))
|
|
found_edges.append(i)
|
|
j += 1
|
|
|
|
points.remove(points[len(points)-1])
|
|
array_points = []
|
|
for point in points:
|
|
array_points.append(point.coordinates)
|
|
return np.array(array_points)
|
|
|
|
def assign_thermal_zones_delimited_by_thermal_boundaries(self):
|
|
"""
|
|
During storeys creation, the thermal boundaries and zones are also created.
|
|
It is afterwards needed to define which zones are delimited by each thermal boundary
|
|
"""
|
|
for storey in self._building.storeys:
|
|
for thermal_boundary in storey.thermal_boundaries:
|
|
if thermal_boundary.surface.type != cte.INTERIOR_WALL or thermal_boundary.surface.type != cte.INTERIOR_SLAB:
|
|
# external thermal boundary -> only one thermal zone
|
|
thermal_zones = [storey.thermal_zone]
|
|
else:
|
|
# internal thermal boundary -> two thermal zones
|
|
grad = np.rad2deg(thermal_boundary.surface.inclination)
|
|
if grad >= 170:
|
|
thermal_zones = [storey.thermal_zone, storey.neighbours[0]]
|
|
else:
|
|
thermal_zones = [storey.neighbours[1], storey.thermal_zone]
|
|
thermal_boundary.thermal_zones = thermal_zones
|