234 lines
14 KiB
Python
234 lines
14 KiB
Python
"""
|
|
TestConstructionFactory test and validate the city model structure construction parameters
|
|
SPDX - License - Identifier: LGPL - 3.0 - or -later
|
|
Copyright © 2022 Project Author Pilar Monsalvete Alvarez de Uribarri pilar.monsalvete@concordia.ca
|
|
"""
|
|
from pathlib import Path
|
|
from unittest import TestCase
|
|
|
|
import helpers.constants as cte
|
|
from imports.geometry_factory import GeometryFactory
|
|
from imports.construction_factory import ConstructionFactory
|
|
from imports.geometry.helpers.geometry_helper import GeometryHelper
|
|
|
|
|
|
class TestConstructionFactory(TestCase):
|
|
"""
|
|
TestConstructionFactory TestCase
|
|
"""
|
|
def setUp(self) -> None:
|
|
"""
|
|
Configure test environment
|
|
:return:
|
|
"""
|
|
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', 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')
|
|
for internal_zone in building.internal_zones:
|
|
self.assertIsNone(internal_zone.usage_zones, 'usage zones are defined')
|
|
self.assertTrue(len(internal_zone.thermal_zones) > 0, 'thermal zones are not 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.assertIsNotNone(building.average_storey_height, 'building average_storey_height is none')
|
|
self.assertIsNotNone(building.storeys_above_ground, 'building storeys_above_ground is 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')
|
|
|
|
def _check_thermal_zones(self, internal_zone):
|
|
for thermal_zone in internal_zone.thermal_zones:
|
|
self.assertIsNotNone(thermal_zone.id, 'thermal_zone id is none')
|
|
self.assertIsNotNone(thermal_zone.floor_area, 'thermal_zone floor area is none')
|
|
self.assertTrue(len(thermal_zone.thermal_boundaries) > 0, 'thermal_zone thermal_boundaries not defined')
|
|
self.assertIsNotNone(thermal_zone.additional_thermal_bridge_u_value, 'additional_thermal_bridge_u_value is none')
|
|
self.assertIsNotNone(thermal_zone.effective_thermal_capacity, 'thermal_zone effective_thermal_capacity is none')
|
|
self.assertIsNotNone(thermal_zone.indirectly_heated_area_ratio,
|
|
'thermal_zone indirectly_heated_area_ratio is none')
|
|
self.assertIsNotNone(thermal_zone.infiltration_rate_system_off,
|
|
'thermal_zone infiltration_rate_system_off is none')
|
|
self.assertIsNotNone(thermal_zone.infiltration_rate_system_on, 'thermal_zone infiltration_rate_system_on is none')
|
|
self.assertIsNotNone(thermal_zone.volume, 'thermal_zone volume is none')
|
|
self.assertIsNone(thermal_zone.ordinate_number, 'thermal_zone ordinate number is not none')
|
|
self.assertIsNotNone(thermal_zone.view_factors_matrix, 'thermal_zone view factors matrix is none')
|
|
self.assertIsNone(thermal_zone.usage_zones, 'thermal_zone usage_zones is not none')
|
|
self.assertIsNone(thermal_zone.thermal_control, 'thermal_zone thermal_control is not none')
|
|
self.assertIsNone(thermal_zone.hvac_system, 'thermal_zone hvac_system is not none')
|
|
|
|
def _check_thermal_boundaries(self, thermal_zone):
|
|
for thermal_boundary in thermal_zone.thermal_boundaries:
|
|
self.assertIsNotNone(thermal_boundary.id, 'thermal_boundary id is none')
|
|
self.assertIsNotNone(thermal_boundary.parent_surface, 'thermal_boundary surface is none')
|
|
self.assertIsNotNone(thermal_boundary.thermal_zones, 'thermal_boundary delimits no thermal zone')
|
|
self.assertIsNotNone(thermal_boundary.opaque_area, 'thermal_boundary area is none')
|
|
self.assertIsNotNone(thermal_boundary.azimuth, 'thermal_boundary azimuth is none')
|
|
self.assertIsNotNone(thermal_boundary.inclination, 'thermal_boundary inclination is none')
|
|
self.assertIsNotNone(thermal_boundary.thickness, 'thermal_boundary thickness is none')
|
|
self.assertIsNotNone(thermal_boundary.type, 'thermal_boundary type is none')
|
|
if thermal_boundary.type is not cte.GROUND:
|
|
self.assertIsNotNone(thermal_boundary.outside_solar_absorptance, 'outside_solar_absorptance is none')
|
|
self.assertIsNotNone(thermal_boundary.shortwave_reflectance, 'shortwave_reflectance is none')
|
|
else:
|
|
self.assertIsNone(thermal_boundary.outside_solar_absorptance, 'outside_solar_absorptance is not none')
|
|
self.assertIsNone(thermal_boundary.shortwave_reflectance, 'shortwave_reflectance is not none')
|
|
self.assertIsNotNone(thermal_boundary.thermal_openings, 'thermal_openings is none')
|
|
self.assertIsNotNone(thermal_boundary.construction_name, 'construction_name is none')
|
|
self.assertIsNotNone(thermal_boundary.window_ratio, 'window_ratio is none')
|
|
self.assertIsNone(thermal_boundary.windows_areas, 'windows_areas is not none')
|
|
self.assertIsNotNone(thermal_boundary.u_value, 'u_value is none')
|
|
self.assertIsNotNone(thermal_boundary.hi, 'hi is none')
|
|
self.assertIsNotNone(thermal_boundary.he, 'he is none')
|
|
self.assertIsNotNone(thermal_boundary.virtual_internal_surface, 'virtual_internal_surface is none')
|
|
self.assertIsNone(thermal_boundary.inside_emissivity, 'inside_emissivity is not none')
|
|
self.assertIsNone(thermal_boundary.alpha_coefficient, 'alpha_coefficient is not none')
|
|
self.assertIsNone(thermal_boundary.radiative_coefficient, 'radiative_coefficient is not none')
|
|
|
|
def _check_thermal_openings(self, thermal_boundary):
|
|
for thermal_opening in thermal_boundary.thermal_openings:
|
|
self.assertIsNotNone(thermal_opening.id, 'thermal opening id is not none')
|
|
self.assertIsNotNone(thermal_opening.area, 'thermal opening area is not none')
|
|
self.assertRaises(Exception, lambda: thermal_opening.openable_ratio,
|
|
'thermal_opening openable_ratio is not raising an exception')
|
|
self.assertIsNotNone(thermal_opening.frame_ratio, 'thermal opening frame_ratio is not none')
|
|
self.assertIsNotNone(thermal_opening.g_value, 'thermal opening g_value is not none')
|
|
self.assertIsNotNone(thermal_opening.overall_u_value, 'thermal opening overall_u_value is not none')
|
|
self.assertIsNotNone(thermal_opening.hi, 'thermal opening hi is not none')
|
|
self.assertIsNotNone(thermal_opening.he, 'thermal opening he is not none')
|
|
self.assertIsNone(thermal_opening.inside_emissivity, 'thermal opening inside_emissivity is not none')
|
|
self.assertIsNone(thermal_opening.alpha_coefficient, 'thermal opening alpha_coefficient is not none')
|
|
self.assertIsNone(thermal_opening.radiative_coefficient, 'thermal opening radiative_coefficient is not none')
|
|
|
|
def test_citygml_function(self):
|
|
"""
|
|
Test city objects' functions in the city
|
|
"""
|
|
# case 1: hft
|
|
file = 'one_building_in_kelowna.gml'
|
|
function_format = 'hft'
|
|
city = self._get_citygml(file)
|
|
for building in city.buildings:
|
|
building.function = self._internal_function(function_format, building.function)
|
|
self.assertEqual(building.function, 'residential', 'format hft')
|
|
|
|
# case 2: Pluto
|
|
file = 'pluto_building.gml'
|
|
function_format = 'pluto'
|
|
city = self._get_citygml(file)
|
|
for building in city.buildings:
|
|
building.function = self._internal_function(function_format, building.function)
|
|
self.assertEqual(building.function, 'secondary school', 'format pluto')
|
|
|
|
# case 3: Alkis
|
|
file = 'one_building_in_kelowna_alkis.gml'
|
|
function_format = 'alkis'
|
|
city = self._get_citygml(file)
|
|
for building in city.buildings:
|
|
self.assertRaises(Exception, lambda: self._internal_function(function_format, building.function))
|
|
|
|
def test_city_with_construction_reduced_library(self):
|
|
"""
|
|
Enrich the city with the construction reduced library and verify it
|
|
"""
|
|
file = 'one_building_in_kelowna.gml'
|
|
city = self._get_citygml(file)
|
|
for building in city.buildings:
|
|
building.function = GeometryHelper.libs_function_from_hft(building.function)
|
|
ConstructionFactory('nrcan', city).enrich()
|
|
|
|
self._check_buildings(city)
|
|
for building in city.buildings:
|
|
for internal_zone in building.internal_zones:
|
|
self._check_thermal_zones(internal_zone)
|
|
for thermal_zone in internal_zone.thermal_zones:
|
|
self._check_thermal_boundaries(thermal_zone)
|
|
for thermal_boundary in thermal_zone.thermal_boundaries:
|
|
self.assertIsNone(thermal_boundary.outside_thermal_absorptance, 'outside_thermal_absorptance is not none')
|
|
self.assertIsNone(thermal_boundary.outside_visible_absorptance, 'outside_visible_absorptance is not none')
|
|
self.assertIsNone(thermal_boundary.layers, 'layers is not none')
|
|
|
|
self._check_thermal_openings(thermal_boundary)
|
|
for thermal_opening in thermal_boundary.thermal_openings:
|
|
self.assertIsNone(thermal_opening.conductivity, 'thermal_opening conductivity is not none')
|
|
self.assertIsNone(thermal_opening.thickness, 'thermal opening thickness is not none')
|
|
self.assertIsNone(thermal_opening.front_side_solar_transmittance_at_normal_incidence,
|
|
'thermal opening front_side_solar_transmittance_at_normal_incidence is not none')
|
|
self.assertIsNone(thermal_opening.back_side_solar_transmittance_at_normal_incidence,
|
|
'thermal opening back_side_solar_transmittance_at_normal_incidence is not none')
|
|
|
|
def test_city_with_construction_extended_library(self):
|
|
"""
|
|
Enrich the city with the construction information and verify it
|
|
"""
|
|
file = 'pluto_building.gml'
|
|
city = self._get_citygml(file)
|
|
for building in city.buildings:
|
|
building.function = GeometryHelper.libs_function_from_pluto(building.function)
|
|
ConstructionFactory('nrel', city).enrich()
|
|
|
|
self._check_buildings(city)
|
|
for building in city.buildings:
|
|
for internal_zone in building.internal_zones:
|
|
self._check_thermal_zones(internal_zone)
|
|
for thermal_zone in internal_zone.thermal_zones:
|
|
self._check_thermal_boundaries(thermal_zone)
|
|
for thermal_boundary in thermal_zone.thermal_boundaries:
|
|
if thermal_boundary.type is not cte.GROUND:
|
|
self.assertIsNotNone(thermal_boundary.outside_thermal_absorptance, 'outside_thermal_absorptance is none')
|
|
self.assertIsNotNone(thermal_boundary.outside_visible_absorptance, 'outside_visible_absorptance is none')
|
|
else:
|
|
self.assertIsNone(thermal_boundary.outside_thermal_absorptance, 'outside_thermal_absorptance is not none')
|
|
self.assertIsNone(thermal_boundary.outside_visible_absorptance, 'outside_visible_absorptance is not none')
|
|
self.assertIsNotNone(thermal_boundary.layers, 'layers is none')
|
|
|
|
self._check_thermal_openings(thermal_boundary)
|
|
for thermal_opening in thermal_boundary.thermal_openings:
|
|
self.assertIsNotNone(thermal_opening.conductivity, 'thermal_opening conductivity is none')
|
|
self.assertIsNotNone(thermal_opening.thickness, 'thermal opening thickness is none')
|
|
self.assertIsNotNone(thermal_opening.front_side_solar_transmittance_at_normal_incidence,
|
|
'thermal opening front_side_solar_transmittance_at_normal_incidence is none')
|
|
self.assertIsNotNone(thermal_opening.back_side_solar_transmittance_at_normal_incidence,
|
|
'thermal opening back_side_solar_transmittance_at_normal_incidence is none')
|
|
|
|
@staticmethod
|
|
def _internal_function(function_format, original_function):
|
|
if function_format == 'hft':
|
|
new_function = GeometryHelper.libs_function_from_hft(original_function)
|
|
elif function_format == 'pluto':
|
|
new_function = GeometryHelper.libs_function_from_pluto(original_function)
|
|
else:
|
|
raise Exception('Function key not recognized. Implemented only "hft" and "pluto"')
|
|
return new_function
|