city_retrofit/city_model_structure/building.py

"""
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

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 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