city_retrofit/unittests/test_geometry_factory.py

"""
TestGeometryFactory test and validate the city model structure geometric parameters
SPDX - License - Identifier: LGPL - 3.0 - or -later
Copyright © 2022 Concordia CERC group
Project Coder Pilar Monsalvete Alvarez de Uribarri pilar.monsalvete@concordia.ca
"""
from pathlib import Path
from unittest import TestCase

from numpy import inf

from imports.geometry_factory import GeometryFactory
from imports.construction_factory import ConstructionFactory


class TestGeometryFactory(TestCase):
  """
  Non-functional TestGeometryFactory
  Load testing
  """
  def setUp(self) -> None:
    """
    Test setup
    :return: None
    """
    self._city = None
    self._example_path = (Path(__file__).parent / 'tests_data').resolve()

  def _get_citygml(self, file):
    file_path = (self._example_path / file).resolve()
    self._city = GeometryFactory('citygml', path=file_path).city
    self.assertIsNotNone(self._city, 'city is none')
    return self._city

  def _get_geojson(self, file):
    file_path = (self._example_path / file).resolve()
    self._city = GeometryFactory('gpandas', path=file_path).city
    self.assertIsNotNone(self._city, 'city is none')
    return self._city

  def _get_obj(self, file):
    # todo: solve the incongruities between city and city_debug
    file_path = (self._example_path / file).resolve()
    self._city = GeometryFactory('obj', path=file_path).city
    self.assertIsNotNone(self._city, 'city is none')
    return self._city

  def _get_rhino(self, file):
    file_path = (self._example_path / file).resolve()
    self._city = GeometryFactory('rhino', path=file_path).city
    self.assertIsNotNone(self._city, 'city is none')
    return self._city

  def _check_buildings(self, city):
    for building in city.buildings:
      self.assertIsNotNone(building.name, 'building name is none')
      self.assertIsNotNone(building.lod, 'building lod is none')
      self.assertIsNotNone(building.type, 'building type is none')
      self.assertIsNotNone(building.volume, 'building volume is none')
      self.assertIsNotNone(building.detailed_polyhedron, 'building detailed polyhedron is none')
      self.assertIsNotNone(building.simplified_polyhedron, 'building simplified polyhedron is none')
      self.assertIsNotNone(building.surfaces, 'building surfaces is none')
      self.assertIsNotNone(building.centroid, 'building centroid is none')
      self.assertIsNotNone(building.max_height, 'building max_height is none')
      self.assertEqual(len(building.external_temperature), 0, 'building external temperature is calculated')
      self.assertEqual(len(building.global_horizontal), 0, 'building global horizontal is calculated')
      self.assertEqual(len(building.diffuse), 0, 'building diffuse is calculated')
      self.assertEqual(len(building.beam), 0, 'building beam is calculated')
      self.assertIsNotNone(building.lower_corner, 'building lower corner is none')
      self.assertEqual(len(building.sensors), 0, 'building sensors are assigned')
      self.assertIsNotNone(building.internal_zones, 'no internal zones created')
      self.assertIsNotNone(building.grounds, 'building grounds is none')
      self.assertIsNotNone(building.walls, 'building walls is none')
      self.assertIsNotNone(building.roofs, 'building roofs is none')
      self.assertIsNotNone(building.internal_zones, 'building internal zones is none')
      for internal_zone in building.internal_zones:
        self.assertIsNone(internal_zone.usage_zones, 'usage zones are defined')
        self.assertIsNone(internal_zone.thermal_zones, 'thermal zones are defined')
      self.assertIsNone(building.basement_heated, 'building basement_heated is not none')
      self.assertIsNone(building.attic_heated, 'building attic_heated is not none')
      self.assertIsNone(building.terrains, 'building terrains is not none')
      self.assertIsNotNone(building.year_of_construction, 'building year_of_construction is none')
      self.assertIsNotNone(building.function, 'building function is none')
      self.assertIsNone(building.average_storey_height, 'building average_storey_height is not none')
      self.assertIsNone(building.storeys_above_ground, 'building storeys_above_ground is not none')
      self.assertEqual(len(building.heating), 0, 'building heating is not none')
      self.assertEqual(len(building.cooling), 0, 'building cooling is not none')
      self.assertIsNotNone(building.eave_height, 'building eave height is none')
      self.assertIsNotNone(building.roof_type, 'building roof type is none')
      self.assertIsNotNone(building.floor_area, 'building floor_area is none')
      self.assertIsNone(building.households, 'building households is not none')
      self.assertFalse(building.is_conditioned, 'building is_conditioned is conditioned')

  def _check_surfaces(self, building):
    for surface in building.surfaces:
      self.assertIsNotNone(surface.name, 'surface name is none')
      self.assertIsNotNone(surface.id, 'surface id is none')
      self.assertIsNotNone(surface.lower_corner, 'surface envelope_lower_corner is none')
      self.assertIsNotNone(surface.upper_corner, 'surface envelope_upper_corner is none')
      self.assertIsNotNone(surface.perimeter_area, 'surface area_above_ground is none')
      self.assertIsNotNone(surface.azimuth, 'surface azimuth is none')
      self.assertIsNotNone(surface.inclination, 'surface inclination is none')
      self.assertIsNotNone(surface.type, 'surface type is none')
      self.assertEqual(len(surface.global_irradiance), 0, 'global irradiance is calculated')
      self.assertIsNotNone(surface.perimeter_polygon, 'surface perimeter_polygon is none')
      self.assertIsNone(surface.holes_polygons, 'surface hole_polygons is not none')
      self.assertIsNotNone(surface.solid_polygon, 'surface solid_polygon is none')
      self.assertIsNone(surface.short_wave_reflectance, 'surface short_wave_reflectance is not none')
      self.assertIsNone(surface.long_wave_emittance, 'surface long_wave_emittance is not none')
      self.assertIsNotNone(surface.inverse, 'surface inverse is none')
      self.assertEqual(len(surface.associated_thermal_boundaries), 0, 'associated_thermal_boundaries are assigned')
      self.assertIsNone(surface.vegetation, 'surface vegetation is not none')

  # citygml_classes
  def test_import_citygml(self):
    """
    Test city objects in the city
    :return: None
    """
    file = 'one_building_in_kelowna.gml'
    city = self._get_citygml(file)
    self.assertTrue(len(city.buildings) == 1)
    self._check_buildings(city)
    for building in city.buildings:
      self._check_surfaces(building)
      building.year_of_construction = 2006
      city = ConstructionFactory('nrel', city).enrich()

  # rhino
  def test_import_rhino(self):
    """
    Test rhino import
    """
    file = 'dompark.3dm'
    city = self._get_rhino(file)
    self.assertIsNotNone(city, 'city is none')
    self.assertTrue(len(city.buildings) == 36)
    i = 0
    for building in city.buildings:
      self.assertIsNot(building.volume, inf, 'open volume')
      i += 1

  # obj
  def test_import_obj(self):
    """
    Test obj import
    """
    file = 'kelowna.obj'
    city = self._get_obj(file)
    self.assertIsNotNone(city, 'city is none')
    self.assertTrue(len(city.buildings) == 1)
    self._check_buildings(city)
    for building in city.buildings:
      self._check_surfaces(building)

  def test_import_geopandas(self):
    """
    Test geopandas import
    """
    file = 'sample.geojson'
    city = self._get_geojson(file)
    self.assertIsNotNone(city, 'city is none')
    self.assertTrue(len(city.buildings) == 1)
    self._check_buildings(city)

    for building in city.buildings:
      self._check_surfaces(building)
      self.assertEqual(1912.0898135701814, building.volume)
      self.assertEqual(146.19493345171213, building.floor_area)