377 lines
9.4 KiB
Python
377 lines
9.4 KiB
Python
"""
|
|
Building module
|
|
SPDX - License - Identifier: LGPL - 3.0 - or -later
|
|
Copyright © 2020 Project Author Guille Gutierrez guillermo.gutierrezmorote@concordia.ca
|
|
contributors: Pilar Monsalvete pilar_monsalvete@yahoo.es
|
|
"""
|
|
|
|
from typing import List
|
|
|
|
import matplotlib.patches as patches
|
|
import numpy as np
|
|
from matplotlib import pylab
|
|
from shapely import ops
|
|
from shapely.geometry import MultiPolygon
|
|
import pandas as pd
|
|
import helpers.constants as cte
|
|
|
|
from city_model_structure.attributes.surface import Surface
|
|
from city_model_structure.attributes.thermal_boundary import ThermalBoundary
|
|
from city_model_structure.attributes.thermal_zone import ThermalZone
|
|
from city_model_structure.attributes.usage_zone import UsageZone
|
|
from city_model_structure.city_object import CityObject
|
|
from city_model_structure.building_unit import BuildingUnit
|
|
|
|
|
|
class Building(CityObject):
|
|
"""
|
|
Building(CityObject) class
|
|
"""
|
|
def __init__(self, name, lod, surfaces, terrains, year_of_construction, function, lower_corner, attic_heated=0,
|
|
basement_heated=0):
|
|
super().__init__(lod, surfaces, name)
|
|
self._basement_heated = basement_heated
|
|
self._attic_heated = attic_heated
|
|
self._terrains = terrains
|
|
self._year_of_construction = year_of_construction
|
|
self._function = function
|
|
self._lower_corner = lower_corner
|
|
self._average_storey_height = None
|
|
self._storeys_above_ground = None
|
|
self._foot_print = None
|
|
self._usage_zones = []
|
|
self._building_units = []
|
|
self._type = 'building'
|
|
self._heating = dict()
|
|
self._cooling = dict()
|
|
self._external_temperature = dict()
|
|
self._global_horizontal = dict()
|
|
self._diffuse = dict()
|
|
self._beam = dict()
|
|
|
|
# ToDo: Check this for LOD4
|
|
self._thermal_zones = []
|
|
if self.lod < 8:
|
|
# for lod under 4 is just one thermal zone
|
|
self._thermal_zones.append(ThermalZone(self.surfaces))
|
|
|
|
for t_zones in self._thermal_zones:
|
|
t_zones.bounded = [ThermalBoundary(s, [t_zones]) for s in t_zones.surfaces]
|
|
surface_id = 0
|
|
for surface in self._surfaces:
|
|
surface.lower_corner = self._lower_corner
|
|
surface.parent(self, surface_id)
|
|
surface_id += 1
|
|
|
|
@property
|
|
def usage_zones(self) -> List[UsageZone]:
|
|
"""
|
|
Get city object usage zones
|
|
:return: [UsageZone]
|
|
"""
|
|
return self._usage_zones
|
|
|
|
@usage_zones.setter
|
|
def usage_zones(self, values):
|
|
"""
|
|
Set city objects usage zones
|
|
:param values: [UsageZones]
|
|
:return: None
|
|
"""
|
|
# ToDo: this is only valid for one usage zone need to be revised for multiple usage zones.
|
|
self._usage_zones = values
|
|
for thermal_zone in self.thermal_zones:
|
|
thermal_zone.usage_zones = [(100, usage_zone) for usage_zone in values]
|
|
|
|
@property
|
|
def terrains(self) -> List[Surface]:
|
|
"""
|
|
Get city object terrain surfaces
|
|
:return: [Surface]
|
|
"""
|
|
return self._terrains
|
|
|
|
@property
|
|
def attic_heated(self):
|
|
"""
|
|
Get if the city object attic is heated
|
|
:return: Boolean
|
|
"""
|
|
return self._attic_heated
|
|
|
|
@attic_heated.setter
|
|
def attic_heated(self, value):
|
|
"""
|
|
Set if the city object attic is heated
|
|
:param value: Boolean
|
|
:return: None
|
|
"""
|
|
self._attic_heated = value
|
|
|
|
@property
|
|
def basement_heated(self):
|
|
"""
|
|
Get if the city object basement is heated
|
|
:return: Boolean
|
|
"""
|
|
return self._basement_heated
|
|
|
|
@basement_heated.setter
|
|
def basement_heated(self, value):
|
|
"""
|
|
Set if the city object basement is heated
|
|
:param value: Boolean
|
|
:return: None
|
|
"""
|
|
self._attic_heated = value
|
|
|
|
@property
|
|
def name(self):
|
|
"""
|
|
City object name
|
|
:return: str
|
|
"""
|
|
return self._name
|
|
|
|
@property
|
|
def thermal_zones(self) -> List[ThermalZone]:
|
|
"""
|
|
City object thermal zones
|
|
:return: [ThermalZone]
|
|
"""
|
|
return self._thermal_zones
|
|
|
|
@property
|
|
def heated_volume(self):
|
|
"""
|
|
City object heated volume in cubic meters
|
|
:return: float
|
|
"""
|
|
# ToDo: this need to be the calculated based on the basement and attic heated values
|
|
return self.volume
|
|
|
|
@property
|
|
def year_of_construction(self):
|
|
"""
|
|
City object year of construction
|
|
:return: int
|
|
"""
|
|
return self._year_of_construction
|
|
|
|
@property
|
|
def function(self):
|
|
"""
|
|
City object function
|
|
:return: str
|
|
"""
|
|
return self._function
|
|
|
|
@property
|
|
def average_storey_height(self):
|
|
"""
|
|
Get city object average storey height in meters
|
|
:return: float
|
|
"""
|
|
return self._average_storey_height
|
|
|
|
@average_storey_height.setter
|
|
def average_storey_height(self, value):
|
|
"""
|
|
Set city object average storey height in meters
|
|
:param value: float
|
|
:return: None
|
|
"""
|
|
self._average_storey_height = value
|
|
|
|
@property
|
|
def storeys_above_ground(self):
|
|
"""
|
|
Get city object storeys number above ground
|
|
:return: int
|
|
"""
|
|
return self._storeys_above_ground
|
|
|
|
@storeys_above_ground.setter
|
|
def storeys_above_ground(self, value):
|
|
"""
|
|
Set city object storeys number above ground
|
|
:param value: int
|
|
:return:
|
|
"""
|
|
self._storeys_above_ground = value
|
|
|
|
@staticmethod
|
|
def _tuple_to_point(xy_tuple):
|
|
return [xy_tuple[0], xy_tuple[1], 0.0]
|
|
|
|
def _plot(self, polygon):
|
|
points = ()
|
|
for point_tuple in polygon.exterior.coords:
|
|
almost_equal = False
|
|
for point in points:
|
|
point_1 = Building._tuple_to_point(point)
|
|
point_2 = Building._tuple_to_point(point_tuple)
|
|
if self._geometry.almost_equal(point_1, point_2):
|
|
almost_equal = True
|
|
break
|
|
if not almost_equal:
|
|
points = points + (point_tuple,)
|
|
points = points + (points[0],)
|
|
pylab.scatter([point[0] for point in points], [point[1] for point in points])
|
|
pylab.gca().add_patch(patches.Polygon(points, closed=True, fill=True))
|
|
pylab.grid()
|
|
pylab.show()
|
|
|
|
@property
|
|
def foot_print(self) -> Surface:
|
|
"""
|
|
City object foot print surface
|
|
:return: Surface
|
|
"""
|
|
if self._foot_print is None:
|
|
shapelys = []
|
|
union = None
|
|
for surface in self.surfaces:
|
|
if surface.shapely.is_empty or not surface.shapely.is_valid:
|
|
continue
|
|
shapelys.append(surface.shapely)
|
|
union = ops.unary_union(shapelys)
|
|
shapelys = [union]
|
|
if isinstance(union, MultiPolygon):
|
|
Exception('foot print returns a multipolygon')
|
|
points_list = []
|
|
for point_tuple in union.exterior.coords:
|
|
# ToDo: should be Z 0.0 or min Z?
|
|
point = Building._tuple_to_point(point_tuple)
|
|
almost_equal = False
|
|
for existing_point in points_list:
|
|
if self._geometry.almost_equal(point, existing_point):
|
|
almost_equal = True
|
|
break
|
|
if not almost_equal:
|
|
points_list.append(point)
|
|
points_list = np.reshape(points_list, len(points_list) * 3)
|
|
points = np.array_str(points_list).replace('[', '').replace(']', '')
|
|
self._foot_print = Surface(points, remove_last=False, is_projected=True)
|
|
return self._foot_print
|
|
|
|
@property
|
|
def type(self):
|
|
"""
|
|
building type
|
|
:return: str
|
|
"""
|
|
return self._type
|
|
|
|
@property
|
|
def building_units(self) -> [BuildingUnit]:
|
|
"""
|
|
Building units
|
|
:return:
|
|
"""
|
|
return self._building_units
|
|
|
|
@building_units.setter
|
|
def building_units(self, value):
|
|
"""
|
|
Building units
|
|
:param value: [BuildingUnit]
|
|
"""
|
|
self._building_units = value
|
|
|
|
@property
|
|
def heating(self) -> dict:
|
|
"""
|
|
heating demand in Wh
|
|
:return: dict{DataFrame(float)}
|
|
"""
|
|
return self._heating
|
|
|
|
@heating.setter
|
|
def heating(self, value):
|
|
"""
|
|
heating demand in Wh
|
|
:param value: dict{DataFrame(float)}
|
|
"""
|
|
self._heating = value
|
|
|
|
@property
|
|
def cooling(self) -> dict:
|
|
"""
|
|
cooling demand in Wh
|
|
:return: dict{DataFrame(float)}
|
|
"""
|
|
return self._cooling
|
|
|
|
@cooling.setter
|
|
def cooling(self, value):
|
|
"""
|
|
cooling demand in Wh
|
|
:param value: dict{DataFrame(float)}
|
|
"""
|
|
self._cooling = value
|
|
|
|
@property
|
|
def external_temperature(self) -> dict:
|
|
"""
|
|
external temperature surrounding the building in grads Celsius
|
|
:return: dict{DataFrame(float)}
|
|
"""
|
|
return self._external_temperature
|
|
|
|
@external_temperature.setter
|
|
def external_temperature(self, value):
|
|
"""
|
|
external temperature surrounding the building in grads Celsius
|
|
:param value: dict{DataFrame(float)}
|
|
"""
|
|
self._external_temperature = value
|
|
|
|
@property
|
|
def global_horizontal(self) -> dict:
|
|
"""
|
|
global horizontal radiation surrounding the building in W/m2
|
|
:return: dict{DataFrame(float)}
|
|
"""
|
|
return self._global_horizontal
|
|
|
|
@global_horizontal.setter
|
|
def global_horizontal(self, value):
|
|
"""
|
|
global horizontal radiation surrounding the building in W/m2
|
|
:param value: dict{DataFrame(float)}
|
|
"""
|
|
self._global_horizontal = value
|
|
|
|
@property
|
|
def diffuse(self) -> dict:
|
|
"""
|
|
diffuse radiation surrounding the building in W/m2
|
|
:return: dict{DataFrame(float)}
|
|
"""
|
|
return self._diffuse
|
|
|
|
@diffuse.setter
|
|
def diffuse(self, value):
|
|
"""
|
|
diffuse radiation surrounding the building in W/m2
|
|
:param value: dict{DataFrame(float)}
|
|
"""
|
|
self._diffuse = value
|
|
|
|
@property
|
|
def beam(self) -> dict:
|
|
"""
|
|
beam radiation surrounding the building in W/m2
|
|
:return: dict{DataFrame(float)}
|
|
"""
|
|
return self._beam
|
|
|
|
@beam.setter
|
|
def beam(self, value):
|
|
"""
|
|
beam radiation surrounding the building in W/m2
|
|
:param value: dict{DataFrame(float)}
|
|
"""
|
|
self._beam = value
|