diff --git a/PYGUIDE.md b/PYGUIDE.md index 48f2a54a..41f70c81 100644 --- a/PYGUIDE.md +++ b/PYGUIDE.md @@ -114,7 +114,7 @@ All public classes, properties, and methods must have code comments. @property def object_attribute(self): """ - My class object attribute + My class object attributes :return: int """ return self._object_attribute diff --git a/city_model_structure/building.py b/city_model_structure/building.py index 26ffd559..ef85eb66 100644 --- a/city_model_structure/building.py +++ b/city_model_structure/building.py @@ -12,11 +12,12 @@ 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.surface import Surface -from city_model_structure.thermal_boundary import ThermalBoundary -from city_model_structure.thermal_zone import ThermalZone -from city_model_structure.usage_zone import UsageZone +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 @@ -40,10 +41,15 @@ class Building(CityObject): self._usage_zones = [] self._building_units = [] self._type = 'building' - self._monthly_heating = pd.DataFrame() - self._monthly_cooling = pd.DataFrame() - self._hourly_heating = pd.DataFrame() - self._hourly_cooling = pd.DataFrame() + self._m_heating = pd.DataFrame() + self._h_heating = pd.DataFrame() + self._heating = pd.DataFrame() + self._m_cooling = pd.DataFrame() + self._h_cooling = pd.DataFrame() + self._cooling = pd.DataFrame() + self._m_external_temperature = pd.DataFrame() + self._h_external_temperature = pd.DataFrame() + self._external_temperature = pd.DataFrame() # ToDo: Check this for LOD4 self._thermal_zones = [] @@ -276,77 +282,157 @@ class Building(CityObject): self._building_units = value @property - def monthly_heating(self) -> pd.DataFrame: + def _monthly_heating(self) -> pd.DataFrame: """ building monthly heating values in Watts-hour :return: DataFrame with 12 values and a header with the source of those """ - return self._monthly_heating + return self._m_heating - @monthly_heating.setter - def monthly_heating(self, value): + @_monthly_heating.setter + def _monthly_heating(self, value): """ building monthly heating values in Watts-hour and a header with the source :param value: DataFrame(heating demand) """ - if self._monthly_heating.empty: - self._monthly_heating = value + if self._m_heating.empty: + self._m_heating = value else: - self._monthly_heating = pd.concat([self._monthly_heating, value], axis=1) + self._m_heating = pd.concat([self._m_heating, value], axis=1) @property - def monthly_cooling(self) -> pd.DataFrame: - """ - building monthly cooling values in Watts-hour - :return: DataFrame with 12 values and a header with the source of those - """ - return self._monthly_cooling - - @monthly_cooling.setter - def monthly_cooling(self, value): - """ - building monthly cooling values in Watts-hour and a header with the source - :param value: DataFrame(cooling demand) - """ - if self._monthly_cooling.empty: - self._monthly_cooling = value - else: - self._monthly_cooling = pd.concat([self._monthly_cooling, value], axis=1) - - @property - def hourly_heating(self) -> pd.DataFrame: + def _hourly_heating(self) -> pd.DataFrame: """ building hourly heating values in Watts-hour :return: DataFrame with 8760 values and a header with the source of those """ - return self._hourly_heating + return self._h_heating - @hourly_heating.setter - def hourly_heating(self, value): + @_hourly_heating.setter + def _hourly_heating(self, value): """ building hourly heating values in Watts-hour and a header with the source :param value: DataFrame(heating demand) """ - if self._hourly_heating.empty: - self._hourly_heating = value + if self._h_heating.empty: + self._h_heating = value else: - self._hourly_heating = pd.concat([self._hourly_heating, value], axis=1) + self._h_heating = pd.concat([self._h_heating, value], axis=1) + + def heating(self, time_scale): + """ + Get heating demand in Wh in a defined time_scale + :param time_scale: string. + :return: DataFrame(float) + """ + if time_scale == cte.time_scale['hour']: + self._heating = self._hourly_heating + elif time_scale == cte.time_scale['month']: + self._heating = self._monthly_heating + else: + raise NotImplementedError + return self._heating @property - def hourly_cooling(self) -> pd.DataFrame: + def _monthly_cooling(self) -> pd.DataFrame: + """ + building monthly cooling values in Watts-hour + :return: DataFrame with 12 values and a header with the source of those + """ + return self._m_cooling + + @_monthly_cooling.setter + def _monthly_cooling(self, value): + """ + building monthly cooling values in Watts-hour and a header with the source + :param value: DataFrame(cooling demand) + """ + if self._m_cooling.empty: + self._m_cooling = value + else: + self._m_cooling = pd.concat([self._m_cooling, value], axis=1) + + @property + def _hourly_cooling(self) -> pd.DataFrame: """ building hourly cooling values in Watts-hour :return: DataFrame with 8760 values and a header with the source of those """ - return self._hourly_cooling + return self._h_cooling - @hourly_cooling.setter - def hourly_cooling(self, value): + @_hourly_cooling.setter + def _hourly_cooling(self, value): """ building hourly cooling values in Watts-hour and a header with the source :param value: DataFrame(cooling demand) """ - if self._hourly_cooling.empty: - self._hourly_cooling = value + if self._h_cooling.empty: + self._h_cooling = value else: - self._hourly_cooling = pd.concat([self._hourly_cooling, value], axis=1) + self._h_cooling = pd.concat([self._h_cooling, value], axis=1) + + def cooling(self, time_scale): + """ + Get cooling demand in Wh in a defined time_scale + :param time_scale: string. + :return: DataFrame(float) + """ + if time_scale == cte.time_scale['hour']: + self._cooling = self._hourly_cooling + elif time_scale == cte.time_scale['month']: + self._cooling = self._monthly_cooling + else: + raise NotImplementedError + return self._cooling + + @property + def _monthly_external_temperature(self) -> pd.DataFrame: + """ + external temperature surrounding the building in grads Celsius monthly based + :return: DataFrame with 12 values and a header with the source of those + """ + return self._m_external_temperature + + @_monthly_external_temperature.setter + def _monthly_external_temperature(self, value): + """ + external temperature surrounding the building in grads Celsius monthly based + :param value: DataFrame(external temperature) + """ + if self._m_external_temperature.empty: + self._m_external_temperature = value + else: + self._m_external_temperature = pd.concat([self._m_external_temperature, value], axis=1) + + @property + def _hourly_external_temperature(self) -> pd.DataFrame: + """ + external temperature surrounding the building in grads Celsius hourly based + :return: DataFrame with 8760 values and a header with the source of those + """ + return self._h_external_temperature + + @_hourly_external_temperature.setter + def _hourly_external_temperature(self, value): + """ + external temperature surrounding the building in grads Celsius hourly based + :param value: DataFrame(external temperature) + """ + if self._h_external_temperature.empty: + self._h_external_temperature = value + else: + self._h_external_temperature = pd.concat([self._h_external_temperature, value], axis=1) + + def external_temperature(self, time_scale) -> pd.DataFrame: + """ + Get cooling demand in Wh in a defined time_scale + :param time_scale: string. + :return: DataFrame(float) + """ + if time_scale == cte.time_scale['hour']: + self._external_temperature = self._hourly_external_temperature + elif time_scale == cte.time_scale['month']: + self._external_temperature = self._monthly_external_temperature + else: + raise NotImplementedError + return self._external_temperature diff --git a/city_model_structure/city_object.py b/city_model_structure/city_object.py index ffc6d85f..f9216cc4 100644 --- a/city_model_structure/city_object.py +++ b/city_model_structure/city_object.py @@ -5,9 +5,9 @@ Copyright © 2020 Project Author Guille Gutierrez guillermo.gutierrezmorote@conc """ from pathlib import Path from typing import List, Union -from city_model_structure.surface import Surface +from city_model_structure.attributes.surface import Surface from helpers.geometry_helper import GeometryHelper -from city_model_structure.polyhedron import Polyhedron +from city_model_structure.attributes.polyhedron import Polyhedron class CityObject: diff --git a/city_model_structure/dhw_facilities.py b/city_model_structure/dhw_facilities.py deleted file mode 100644 index 360d0518..00000000 --- a/city_model_structure/dhw_facilities.py +++ /dev/null @@ -1,52 +0,0 @@ -""" -Building module -SPDX - License - Identifier: LGPL - 3.0 - or -later -Copyright © 2020 Project Author Sanam Dabirian sanam.dabirian@mail.concordia.ca -""" - -class domestic_hot_water: - """ - Domestic Hot Water facilities class - """ - - def __init__(self, number_of_baths, number_of_showers, number_of_basin, water_storage_volume): - """ - Constructor - """ - - self._number_of_baths = number_of_baths - self._number_of_showers = number_of_showers - self._number_of_basin = number_of_basin - self._water_storage_volume = water_storage_volume - - @property - def number_of_baths(self): - """ - Get number of baths of a building unit - :return: number of baths - """ - return self._number_of_baths - - @property - def number_of_showers(self): - """ - Get number of showers of a building unit - :return: number of showers - """ - return self._number_of_showers - - @property - def number_of_basin(self): - """ - Get number of wash basins of a building unit - :return: number of wash basins - """ - return self._number_of_basin - - @property - def water_storage_volume(self): - """ - Get the volume of water storage - :return: volume of water storage - """ - return self._water_storage_volume diff --git a/city_model_structure/electric_appliances_facilities.py b/city_model_structure/electric_appliances_facilities.py deleted file mode 100644 index 357968bd..00000000 --- a/city_model_structure/electric_appliances_facilities.py +++ /dev/null @@ -1,26 +0,0 @@ -""" -Building module -SPDX - License - Identifier: LGPL - 3.0 - or -later -Copyright © 2020 Project Author Sanam Dabirian sanam.dabirian@mail.concordia.ca -""" - - -class appliances_facilities: - """ - Electric appliance facilities class - """ - - def __init__(self, appliance_electric_power): - """ - Constructor - """ - - self._appliance_electric_power = appliance_electric_power - - @property - def appliance_electric_power(self): - """ - Get appliances electric power - :return: appliances electric power - """ - return self._appliance_electric_power diff --git a/city_model_structure/facility.py b/city_model_structure/facility.py deleted file mode 100644 index 186d8dfe..00000000 --- a/city_model_structure/facility.py +++ /dev/null @@ -1,59 +0,0 @@ -""" -Building module -SPDX - License - Identifier: LGPL - 3.0 - or -later -Copyright © 2020 Project Author Sanam Dabirian sanam.dabirian@mail.concordia.ca -""" - - -class Facility: - """ - facilities class - """ - - def __init__(self, operation_schedules, convective_fraction, latent_fraction, - radiant_fraction, total_value_of_heat_dissipation): - self._operation_schedules = operation_schedules - self._convective_fraction = convective_fraction - self._latent_fraction = latent_fraction - self._radiant_fraction = radiant_fraction - self._total_value_of_heat_dissipation = total_value_of_heat_dissipation - - @property - def operation_schedules(self): - """ - Get operation schedules of the facilities - :return: operation schedules - """ - return self._operation_schedules - - @property - def convective_fraction(self): - """ - Get convective fraction value - :return: convective fraction - """ - return self._convective_fraction - - @property - def latent_fraction(self): - """ - Get latent fraction value - :return: latent fraction - """ - return self._latent_fraction - - @property - def radiant_fraction(self): - """ - Get radiant fraction value - :return: radiant fraction - """ - return self._radiant_fraction - - @property - def total_value_of_heat_dissipation(self): - """ - Get heat dissipation value - :return: heat dissipation - """ - return self._total_value_of_heat_dissipation diff --git a/city_model_structure/household.py b/city_model_structure/household.py deleted file mode 100644 index 81f9a19b..00000000 --- a/city_model_structure/household.py +++ /dev/null @@ -1,36 +0,0 @@ -""" -Building module -SPDX - License - Identifier: LGPL - 3.0 - or -later -Copyright © 2020 Project Author Sanam Dabirian sanam.dabirian@mail.concordia.ca -""" - - -class household: - """ - Household class - """ - - def __init__(self, resident_type, household_type): - """ - Constructor - """ - - self._resident_type = resident_type - self._household_type = household_type - - - @property - def resident_type(self): - """ - Get resident type - :return: resident type - """ - return self._resident_type - - @property - def household_type(self): - """ - Get household type - :return: household type - """ - return self._household_type \ No newline at end of file diff --git a/city_model_structure/hvac_facility.py b/city_model_structure/hvac_facility.py deleted file mode 100644 index 9bde3160..00000000 --- a/city_model_structure/hvac_facility.py +++ /dev/null @@ -1,36 +0,0 @@ -""" -Building module -SPDX - License - Identifier: LGPL - 3.0 - or -later -Copyright © 2020 Project Author Sanam Dabirian sanam.dabirian@mail.concordia.ca -""" - - -class HvacFacility: - """ - HVAC facilities class - """ - - def __init__(self, temperature_setpoints, hvac_schedules): - """ - Constructor - """ - - self._temperature_setpoints = temperature_setpoints - self._hvac_schedules = hvac_schedules - - @property - def temperature_setpoints(self): - """ - Get temperature setpoints - :return: temperature setpoints - """ - return self._temperature_setpoints - - @property - def hvac_schedules(self): - """ - Get HVAC schedules - :return: HVAC schedules - """ - return self._hvac_schedules - diff --git a/city_model_structure/internal_gains.py b/city_model_structure/internal_gains.py deleted file mode 100644 index 4f4b1696..00000000 --- a/city_model_structure/internal_gains.py +++ /dev/null @@ -1,84 +0,0 @@ -""" -InternalGains module -SPDX - License - Identifier: LGPL - 3.0 - or -later -Copyright © 2020 Project Author Guille Gutierrez guillermo.gutierrezmorote@concordia.ca -""" - - -class InternalGains: - """ - InternalGains class - """ - def __init__(self): - self._average_internal_gain = None - self._convective_fraction = None - self._radiative_fraction = None - self._latent_fraction = None - - @property - def average_internal_gain(self): - """ - Get internal gains average internal gain in w/m2 - :return: float - """ - return self._average_internal_gain - - @average_internal_gain.setter - def average_internal_gain(self, value): - """ - Set internal gains average internal gain in w/m2 - :param value: float - :return: None - """ - self._average_internal_gain = value - - @property - def convective_fraction(self): - """ - Get internal gains convective fraction - :return: float - """ - return self._convective_fraction - - @convective_fraction.setter - def convective_fraction(self, value): - """ - Set internal gains convective fraction - :param value: float - :return: None - """ - self._convective_fraction = value - - @property - def radiative_fraction(self): - """ - Get internal gains radiative fraction - :return: float - """ - return self._radiative_fraction - - @radiative_fraction.setter - def radiative_fraction(self, value): - """ - Set internal gains convective fraction - :param value: float - :return: None - """ - self._radiative_fraction = value - - @property - def latent_fraction(self): - """ - Get internal gains latent fraction - :return: float - """ - return self._latent_fraction - - @latent_fraction.setter - def latent_fraction(self, value): - """ - Set internal gains latent fraction - :param value: float - :return: None - """ - self._latent_fraction = value diff --git a/city_model_structure/layer.py b/city_model_structure/layer.py deleted file mode 100644 index 550502de..00000000 --- a/city_model_structure/layer.py +++ /dev/null @@ -1,49 +0,0 @@ -""" -Layers module -SPDX - License - Identifier: LGPL - 3.0 - or -later -Copyright © 2020 Project Author Guille Gutierrez guillermo.gutierrezmorote@concordia.ca -""" -from city_model_structure.material import Material - - -class Layer: - """ - Layer class - """ - def __init__(self): - self._material = None - self._thickness = None - - @property - def material(self) -> Material: - """ - Get layer material - :return: Material - """ - return self._material - - @material.setter - def material(self, value): - """ - Set layer material - :param value: Material - :return: None - """ - self._material = value - - @property - def thickness(self): - """ - Get layer thickness in meters - :return: float - """ - return self._thickness - - @thickness.setter - def thickness(self, value): - """ - Get layer thickness in meters - :param value: float - :return: None - """ - self._thickness = value diff --git a/city_model_structure/lighting_facilities.py b/city_model_structure/lighting_facilities.py deleted file mode 100644 index 62a84a04..00000000 --- a/city_model_structure/lighting_facilities.py +++ /dev/null @@ -1,26 +0,0 @@ -""" -Building module -SPDX - License - Identifier: LGPL - 3.0 - or -later -Copyright © 2020 Project Author Sanam Dabirian sanam.dabirian@mail.concordia.ca -""" - - -class lighting_facilities: - """ - Lighting facilities class - """ - - def __init__(self, electric_power): - """ - Constructor - """ - - self._electric_power = electric_power - - @property - def electric_power(self): - """ - Get lighting electric power - :return: lighting electric power - """ - return self._electric_power diff --git a/city_model_structure/material.py b/city_model_structure/material.py deleted file mode 100644 index ddb23ba9..00000000 --- a/city_model_structure/material.py +++ /dev/null @@ -1,156 +0,0 @@ -""" -Material module -SPDX - License - Identifier: LGPL - 3.0 - or -later -Copyright © 2020 Project Author Guille Gutierrez guillermo.gutierrezmorote@concordia.ca -""" - - -class Material: - """ - Material class - """ - def __init__(self): - self._conductivity = None - self._specific_heat = None - self._density = None - self._solar_absorptance = None - self._thermal_absorptance = None - self._visible_absorptance = None - self._no_mass = False - self._thermal_resistance = None - - @property - def conductivity(self): - """ - Get material conductivity in W/mK - :return: float - """ - return self._conductivity - - @conductivity.setter - def conductivity(self, value): - """ - Set material conductivity in W/mK - :param value: float - :return: None - """ - self._conductivity = value - - @property - def specific_heat(self): - """ - Get material conductivity in J/kgK - :return: float - """ - return self._specific_heat - - @specific_heat.setter - def specific_heat(self, value): - """ - Get material conductivity in J/kgK - :param value: float - :return: None - """ - self._specific_heat = value - - @property - def density(self): - """ - Get material density in kg/m3 - :return: float - """ - return self._density - - @density.setter - def density(self, value): - """ - Set material density in kg/m3 - :param value: float - :return: None - """ - self._density = value - - @property - def solar_absorptance(self): - """ - Get material solar absorptance - :return: float - """ - return self._solar_absorptance - - @solar_absorptance.setter - def solar_absorptance(self, value): - """ - Set material solar absorptance - :param value: float - :return: None - """ - self._solar_absorptance = value - - @property - def thermal_absorptance(self): - """ - Get material thermal absorptance - :return: float - """ - return self._thermal_absorptance - - @thermal_absorptance.setter - def thermal_absorptance(self, value): - """ - Set material thermal absorptance - :param value: float - :return: None - """ - self._thermal_absorptance = value - - @property - def visible_absorptance(self): - """ - Get material visible absorptance - :return: float - """ - return self._visible_absorptance - - @visible_absorptance.setter - def visible_absorptance(self, value): - """ - Set material visible absorptance - :param value: float - :return: None - """ - self._visible_absorptance = value - - @property - def no_mass(self): - """ - Get material no mass flag - :return: Boolean - """ - return self._no_mass - - @no_mass.setter - def no_mass(self, value): - """ - Set material no mass flag - :param value: Boolean - :return: None - """ - self._no_mass = value - - @property - def thermal_resistance(self): - """ - Get material thermal resistance in m2K/W - :return: float - """ - return self._thermal_resistance - - @thermal_resistance.setter - def thermal_resistance(self, value): - """ - Set material thermal resistance in m2K/W - :param value: float - :return: None - """ - self._thermal_resistance = value diff --git a/city_model_structure/occupancy.py b/city_model_structure/occupancy.py deleted file mode 100644 index 6560e302..00000000 --- a/city_model_structure/occupancy.py +++ /dev/null @@ -1,127 +0,0 @@ -""" -Building module -SPDX - License - Identifier: LGPL - 3.0 - or -later -Copyright © 2020 Project Author Sanam Dabirian sanam.dabirian@mail.concordia.ca -""" - - -class Occupancy: - """ - Occupancy class - """ - - def __init__(self, internal_heat_gain, heat_dissipation, occupant_rate, occupant_type, occupant_zone, - number_of_occupants, arrival_time=None, departure_time=None, break_time=None, day_of_week=None, - pd_of_meetings_duration=None, occupant_schedule=None): - """ - Constructor - """ - - self._internal_heat_gain = internal_heat_gain - self._heat_dissipation = heat_dissipation - self._occupant_rate = occupant_rate - self._occupant_type = occupant_type - self._occupant_zone = occupant_zone - self._occupant_schedule = occupant_schedule - self._number_of_occupants = number_of_occupants - self._arrival_time = arrival_time - self._departure_time = departure_time - self._break_time = break_time - self._day_of_week = day_of_week - self._pd_of_meetings_duration = pd_of_meetings_duration - - @property - def internal_heat_gain(self): - """ - Get internal heat gain of occupants - :return: occupant heat gain - """ - return self._internal_heat_gain - - @property - def heat_dissipation(self): - """ - Get heat dissipation of occupants - :return: heat dissipation - """ - return self._heat_dissipation - - @property - def occupant_rate(self): - """ - Get rate of occupancy - :return: rate of occupancy - """ - return self._occupant_rate - - @property - def occupant_type(self): - """ - Get type of occupancy - :return: type of occupancy - """ - return self._occupant_type - - @property - def occupant_zone(self): - """ - Get the zone that occupant is in it - :return: occupant zone - """ - return self._occupant_zone - - @property - def occupant_schedule(self): - """ - Get the schedule when an occupant is in a zone - :return: occupant schedule - """ - return self._occupant_schedule - - @property - def number_of_occupants(self): - """ - Get the number of occupants - :return: number of occupants - """ - return self._number_of_occupants - - @property - def arrival_time(self): - """ - Get the arrival time of the occupant (for office building) - :return: arrival time - """ - return self._arrival_time - - @property - def departure_time(self): - """ - Get the departure time of the occupant (for office building) - :return: departure time - """ - return self._departure_time - - @property - def break_time(self): - """ - Get the lunch or break time of the occupant (for office building) - :return: break time - """ - return self._break_time - - @property - def day_of_week(self): - """ - Get the day of the week - :return: day of the week - """ - return self._day_of_week - - @property - def pd_of_meetings_duration(self): - """ - Get the probability distribution of the meeting duration - :return: probability distribution of the meeting duration - """ - return self._pd_of_meetings_duration diff --git a/city_model_structure/polyhedron.py b/city_model_structure/polyhedron.py deleted file mode 100644 index a3ba84db..00000000 --- a/city_model_structure/polyhedron.py +++ /dev/null @@ -1,116 +0,0 @@ -""" -Polyhedron module -SPDX - License - Identifier: LGPL - 3.0 - or -later -Copyright © 2020 Project Author Guille Gutierrez guillermo.gutierrezmorote@concordia.ca -""" -import numpy as np -from trimesh import Trimesh - -from helpers.geometry_helper import GeometryHelper - - -class Polyhedron: - """ - Polyhedron class - """ - def __init__(self, surfaces): - self._surfaces = list(surfaces) - self._polygons = [s.polygon for s in surfaces] - self._polyhedron = None - self._volume = None - self._faces = None - self._vertices = None - self._mesh = None - self._centroid = None - self._max_z = None - self._geometry = GeometryHelper() - - def _position_of(self, point): - vertices = self.vertices - for i in range(len(vertices)): - if self._geometry.almost_equal(vertices[i], point): - return i - return -1 - - @property - def vertices(self) -> np.ndarray: - """ - Polyhedron vertices - :return: np.ndarray(int) - """ - if self._vertices is None: - vertices, self._vertices = [], [] - _ = [vertices.extend(s.points) for s in self._surfaces] - for vertex_1 in vertices: - found = False - for vertex_2 in self._vertices: - found = False - if self._geometry.almost_equal(vertex_1, vertex_2): - found = True - break - if not found: - self._vertices.append(vertex_1) - self._vertices = np.asarray(self._vertices) - return self._vertices - - @property - def faces(self) -> np.ndarray: - """ - Polyhedron faces - :return: np.ndarray([int]) - """ - if self._faces is None: - self._faces = [] - for surface in self._surfaces: - face = [] - points = surface.points - for point in points: - face.append(self._position_of(point)) - self._faces.append(face) - return self._faces - - @property - def _polyhedron_mesh(self): - if self._mesh is None: - self._mesh = Trimesh(vertices=self.vertices, faces=self.faces) - return self._mesh - - @property - def volume(self): - """ - Polyhedron volume in cubic meters - :return: float - """ - if self._volume is None: - if not self._polyhedron_mesh.is_volume: - print('The geometry is not a closed volume') - self._volume = np.inf - else: - self._volume = self._polyhedron_mesh.volume - return self._volume - - @property - def max_z(self): - """ - Polyhedron maximal z value - :return: float - """ - bounds = self._polyhedron_mesh.bounds - z_max = max(bounds[:, 2]) - return z_max - - @property - def centroid(self): - """ - Polyhedron centroid - :return: [x,y,z] - """ - return self._polyhedron_mesh.centroid - - def export(self, full_path): - """ - Export the polyhedron to stl given file - :param full_path: str - :return: None - """ - self._polyhedron_mesh.export(full_path) diff --git a/city_model_structure/schedule_value.py b/city_model_structure/schedule_value.py deleted file mode 100644 index c949bdaa..00000000 --- a/city_model_structure/schedule_value.py +++ /dev/null @@ -1,34 +0,0 @@ -""" -Building module -SPDX - License - Identifier: LGPL - 3.0 - or -later -Copyright © 2020 Project Author Sanam Dabirian sanam.dabirian@mail.concordia.ca -""" - - -class ScheduleValue: - """ - Schedule Values class - """ - - def __init__(self, hour, probability): - """ - Constructor - """ - self._hour = hour - self._probability = probability - - @property - def hour(self): - """ - Get hours - :return: hour of a day - """ - return self._hour - - @property - def probability(self): - """ - Get probabilities of occupants' presence - :return: occupants' presence probabilities - """ - return self._probability \ No newline at end of file diff --git a/city_model_structure/surface.py b/city_model_structure/surface.py deleted file mode 100644 index de206820..00000000 --- a/city_model_structure/surface.py +++ /dev/null @@ -1,443 +0,0 @@ -""" -Surface module -SPDX - License - Identifier: LGPL - 3.0 - or -later -Copyright © 2020 Project Author Guille Gutierrez guillermo.gutierrezmorote@concordia.ca -""" -from __future__ import annotations -from typing import Union - -import numpy as np -import pyny3d.geoms as pn -import pandas as pd -import helpers.constants as cte - -from helpers.geometry_helper import GeometryHelper - - -class Surface: - """ - Surface class - """ - def __init__(self, coordinates, surface_type=None, name=None, swr='0.2', remove_last=True, is_projected=False): - self._coordinates = coordinates - self._type = surface_type - self._name = name - self._swr = swr - self._remove_last = remove_last - self._is_projected = is_projected - self._geometry_helper = GeometryHelper() - self._polygon = None - self._ground_polygon = None - self._area = None - self._points = None - self._ground_points = None - self._points_list = None - self._normal = None - self._azimuth = None - self._inclination = None - self._area_above_ground = None - self._area_below_ground = None - self._parent = None - self._shapely = None - self._projected_surface = None - self._min_x = None - self._min_y = None - self._min_z = None - self._shared_surfaces = [] - self._global_irradiance = pd.DataFrame() - self._global_irradiance_hour = np.zeros(8760) - self._global_irradiance_month = np.zeros(12) - self._ground_coordinates = (self.min_x, self.min_y, self.min_z) - - def parent(self, parent, surface_id): - """ - Assign a city object as surface parent and a surface id - :param parent: CityObject - :param surface_id: str - :return: None - """ - self._parent = parent - self._name = str(surface_id) - - @property - def name(self): - """ - Surface name - :return: str - """ - if self._name is None: - raise Exception('surface has no name') - return self._name - - @property - def swr(self): - """ - Get surface short wave reflectance - :return: float - """ - return self._swr - - @swr.setter - def swr(self, value): - """ - Set surface short wave reflectance - :param value: float - :return: None - """ - self._swr = value - - @property - def points(self) -> np.ndarray: - """ - Surface point matrix - :return: np.ndarray - """ - if self._points is None: - self._points = np.fromstring(self._coordinates, dtype=float, sep=' ') - self._points = GeometryHelper.to_points_matrix(self._points, self._remove_last) - return self._points - - def _min_coord(self, axis): - if axis == 'x': - axis = 0 - elif axis == 'y': - axis = 1 - else: - axis = 2 - min_coordinate = '' - for point in self.points: - if min_coordinate == '': - min_coordinate = point[axis] - elif min_coordinate > point[axis]: - min_coordinate = point[axis] - return min_coordinate - - @property - def min_x(self): - """ - Surface minimal x value - :return: float - """ - if self._min_x is None: - self._min_x = self._min_coord('x') - return self._min_x - - @property - def min_y(self): - """ - Surface minimal y value - :return: float - """ - if self._min_y is None: - self._min_y = self._min_coord('y') - return self._min_y - - @property - def min_z(self): - """ - Surface minimal z value - :return: float - """ - if self._min_z is None: - self._min_z = self._min_coord('z') - return self._min_z - - @property - def ground_points(self) -> np.ndarray: - """ - Surface grounded points matrix - :return: np.ndarray - """ - if self._ground_points is None: - coordinates = '' - for point in self.points: - x = point[0] - self._ground_coordinates[0] - y = point[1] - self._ground_coordinates[1] - z = point[2] - self._ground_coordinates[2] - if coordinates != '': - coordinates = coordinates + ' ' - coordinates = coordinates + str(x) + ' ' + str(y) + ' ' + str(z) - self._ground_points = np.fromstring(coordinates, dtype=float, sep=' ') - self._ground_points = GeometryHelper.to_points_matrix(self._ground_points, False) - return self._ground_points - - @property - def points_list(self) -> np.ndarray: - """ - Surface point list - :return: np.ndarray - """ - if self._points_list is None: - s = self.points - self._points_list = np.reshape(s, len(s) * 3) - return self._points_list - - @property - def polygon(self) -> Union[pn.Polygon, None]: - """ - Surface polygon - :return: None or pyny3d.Polygon - """ - if self._polygon is None: - try: - self._polygon = pn.Polygon(self.points) - except ValueError: - # is not really a polygon but a line so just return none - self._polygon = None - return self._polygon - - @property - def ground_polygon(self) -> Union[pn.Polygon, None]: - """ - Surface grounded polygon - :return: None or pyny3d.Polygon - """ - if self._ground_polygon is None: - try: - self._ground_polygon = pn.Polygon(self.ground_points) - except ValueError: - # is not really a polygon but a line so just return none - self._ground_polygon = None - return self._ground_polygon - - @property - def area(self): - """ - Surface area in square meters - :return: float - """ - if self._area is None: - self._area = self.polygon.get_area() - return self._area - - def _is_almost_same_terrain(self, terrain_points, ground_points): - equal = 0 - for terrain_point in terrain_points: - for ground_point in ground_points: - if self._geometry_helper.almost_equal(terrain_point, ground_point): - equal += 1 - return equal == len(terrain_points) - - @property - def _is_terrain(self): - for t_points in self._parent.terrains: - if len(t_points) == len(self.points) and self._is_almost_same_terrain(t_points, self.points): - return True - return False - - @property - def area_above_ground(self): - """ - Surface area above ground in square meters - :return: float - """ - if self._area_above_ground is None: - self._area_above_ground = self.area - self.area_below_ground - return self._area_above_ground - - @property - def area_below_ground(self): - """ - Surface area below ground in square meters - :return: float - """ - if self._area_below_ground is None: - self._area_below_ground = 0.0 - if self._is_terrain: - self._area_below_ground = self.area - return self._area_below_ground - - @property - def normal(self) -> np.ndarray: - """ - Surface normal vector - :return: np.ndarray - """ - if self._normal is None: - points = self.points - cross_product = np.cross(points[1] - points[0], points[2] - points[0]) - self._normal = cross_product / np.linalg.norm(cross_product) - return self._normal - - @property - def azimuth(self): - """ - Surface azimuth in radians - :return: float - """ - if self._azimuth is None: - normal = self.normal - self._azimuth = np.arctan2(normal[1], normal[0]) - return self._azimuth - - @property - def inclination(self): - """ - Surface inclination in radians - :return: float - """ - if self._inclination is None: - self._inclination = np.arccos(self.normal[2]) - return self._inclination - - @property - def type(self): - """ - Surface type Ground, Wall or Roof - :return: str - """ - if self._type is None: - grad = np.rad2deg(self.inclination) - if grad >= 170: - self._type = 'Ground' - elif 80 <= grad <= 100: - self._type = 'Wall' - else: - self._type = 'Roof' - return self._type - - def add_shared(self, surface, intersection_area): - """ - Add a given surface and shared area in percent to this surface. - :param surface: - :param intersection_area: - :return: - """ - percent = intersection_area / self.area - self._shared_surfaces.append((percent, surface)) - - def shared(self, surface): - """ - Check if given surface share some area with this surface - :param surface: Surface - :return: None - """ - if self.type != 'Wall' or surface.type != 'Wall': - return - if self._geometry_helper.is_almost_same_surface(self, surface): - intersection_area = self.intersect(surface).area - self.add_shared(surface, intersection_area) - surface.add_shared(self, intersection_area) - - @property - def global_irradiance_hour(self): - """ - Get surface global irradiance hour in Wh/m2 - :return: float - """ - return self._global_irradiance_hour - - @global_irradiance_hour.setter - def global_irradiance_hour(self, value): - """ - Set surface global irradiance per hour in Wh/m2 - :param value: float - :return: None - """ - self._global_irradiance_hour = value - - @property - def global_irradiance_month(self): - """ - Get surface global irradiance per month in Wh/m2 - :return: float - """ - return self._global_irradiance_month - - @global_irradiance_month.setter - def global_irradiance_month(self, value): - """ - Set surface global irradiance per month in Wh/m2 - :param value: float - :return: None - """ - self._global_irradiance_month = value - - def global_irradiance(self, time_scale): - """ - Get surface global irradiance in Wh/m2 in a defined time_scale - :param time_scale: string. - :return: DataFrame(float) - """ - if time_scale == cte.time_scale['hour']: - self._global_irradiance = self.global_irradiance_hour - elif time_scale == cte.time_scale['month']: - self._global_irradiance = self.global_irradiance_month - else: - raise NotImplementedError - return self._global_irradiance - - @property - def shapely(self) -> Union[None, pn.Polygon]: - """ - Surface shapely (Z projection) - :return: None or pyny3d.Polygon - """ - if self.polygon is None: - return None - if self._shapely is None: - self._shapely = self.polygon.get_shapely() - return self._shapely - - @staticmethod - def _polygon_to_surface(polygon) -> Surface: - coordinates = '' - for coordinate in polygon.exterior.coords: - if coordinates != '': - coordinates = coordinates + ' ' - coordinates = coordinates + str(coordinate[0]) + ' ' + str(coordinate[1]) + ' 0.0' - return Surface(coordinates, remove_last=False) - - @property - def projection(self) -> Surface: - """ - Projected surface (Z projection) - :return: Surface - """ - if self._is_projected: - return self - if self._projected_surface is None: - shapely = self.shapely - if shapely is not None: - self._projected_surface = self._polygon_to_surface(shapely) - return self._projected_surface - - def intersect(self, surface) -> Union[Surface, None]: - """ - Get the intersection surface, if any, between the given surface and this surface - :param surface: Surface - :return: None or Surface - """ - min_x = min(self.min_x, surface.min_x) - min_y = min(self.min_y, surface.min_y) - min_z = min(self.min_z, surface.min_z) - self._ground_coordinates = (min_x, min_y, min_z) - surface._ground_coordinates = (min_x, min_y, min_z) - origin = (0, 0, 0) - azimuth = self.azimuth - (np.pi / 2) - while azimuth < 0: - azimuth += (np.pi / 2) - inclination = self.inclination - np.pi - while inclination < 0: - inclination += np.pi - polygon1 = self.ground_polygon.rotate(azimuth, 'z', origin).rotate(inclination, 'x', origin) - polygon2 = surface.ground_polygon.rotate(azimuth, 'z', origin).rotate(inclination, 'x', origin) - try: - coordinates = '' - intersection = pn.Surface([polygon1]).intersect_with(polygon2) - if len(intersection) == 0: - return None - for coordinate in pn.Surface([polygon1]).intersect_with(polygon2)[0]: - if coordinates != '': - coordinates = coordinates + ' ' - coordinates = coordinates + str(coordinate[0]) + ' ' + str(coordinate[1]) + ' 0.0' - if coordinates == '': - return None - intersect_surface = Surface(coordinates, remove_last=False) - if intersect_surface.polygon is None: - return None - - return Surface(coordinates, remove_last=False) - except Exception as err: - print('Error', err) - return None diff --git a/city_model_structure/thermal_boundary.py b/city_model_structure/thermal_boundary.py deleted file mode 100644 index 94e8330c..00000000 --- a/city_model_structure/thermal_boundary.py +++ /dev/null @@ -1,242 +0,0 @@ -""" -ThermalBoundary module -SPDX - License - Identifier: LGPL - 3.0 - or -later -Copyright © 2020 Project Author Guille Gutierrez guillermo.gutierrezmorote@concordia.ca -""" -from typing import List - -from city_model_structure.layer import Layer -from city_model_structure.thermal_opening import ThermalOpening -from city_model_structure.thermal_zone import ThermalZone -from helpers.configuration_helper import ConfigurationHelper - - -class ThermalBoundary: - """ - ThermalBoundary class - """ - def __init__(self, surface, delimits): - self._surface = surface - self._delimits = delimits - # ToDo: up to at least LOD2 will be just one thermal opening per Thermal boundary, review for LOD3 and LOD4 - self._thermal_openings = [ThermalOpening()] - self._layers = None - self._outside_solar_absorptance = ConfigurationHelper().outside_solar_absorptance - self._outside_thermal_absorptance = None - self._outside_visible_absorptance = None - self._window_ratio = None - self._u_value = None - self._window_area = None - self._shortwave_reflectance = 1 - self._outside_solar_absorptance - - @property - def delimits(self) -> List[ThermalZone]: - """ - Get the thermal zones delimited by the thermal boundary - :return: [ThermalZone] - """ - return self._delimits - - @property - def azimuth(self): - """ - Thermal boundary azimuth in radians - :return: float - """ - return self._surface.azimuth - - @property - def inclination(self): - """ - Thermal boundary inclination in radians - :return: float - """ - return self._surface.inclination - - @property - def area(self): - """ - Thermal boundary area in square meters - :return: float - """ - return self._surface.area - - @property - def area_above_ground(self): - """ - Thermal boundary area above ground in square meters - :return: float - """ - return self._surface.area_above_ground - - @property - def area_below_ground(self): - """ - Thermal boundary area below ground in square meters - :return: float - """ - return self._surface.area_below_ground - - @property - def outside_solar_absorptance(self): - """ - Get thermal boundary outside solar absorptance - :return: float - """ - return self._outside_solar_absorptance - - @outside_solar_absorptance.setter - def outside_solar_absorptance(self, value): - """ - Set thermal boundary outside solar absorptance - :param value: float - :return: None - """ - self._outside_solar_absorptance = value - self._shortwave_reflectance = 1.0 - float(value) - - @property - def outside_thermal_absorptance(self): - """ - Get thermal boundary outside thermal absorptance - :return: float - """ - return self._outside_thermal_absorptance - - @outside_thermal_absorptance.setter - def outside_thermal_absorptance(self, value): - """ - Set thermal boundary outside thermal absorptance - :param value: float - :return: None - """ - self._outside_thermal_absorptance = value - - @property - def outside_visible_absorptance(self): - """ - Get thermal boundary outside visible absorptance - :return: float - """ - return self._outside_visible_absorptance - - @outside_visible_absorptance.setter - def outside_visible_absorptance(self, value): - """ - Set thermal boundary outside visible absorptance - :param value: float - :return: None - """ - self._outside_visible_absorptance = value - - @property - def thermal_openings(self) -> List[ThermalOpening]: - """ - Get thermal boundary thermal openings - :return: [ThermalOpening] - """ - return self._thermal_openings - - @thermal_openings.setter - def thermal_openings(self, value): - """ - Set thermal boundary thermal openings - :param value: [ThermalOpening] - :return: None - """ - self._thermal_openings = value - - @property - def layers(self) -> List[Layer]: - """ - Get thermal boundary layers - :return: [Layers] - """ - return self._layers - - @layers.setter - def layers(self, value): - """ - Set thermal boundary layers - :param value: [Layer] - :return: None - """ - self._layers = value - - @property - def type(self): - """ - Thermal boundary surface type - :return: str - """ - return self._surface.type - - @property - def window_ratio(self): - """ - Get thermal boundary window ratio - :return: float - """ - return self._window_ratio - - @window_ratio.setter - def window_ratio(self, value): - """ - Set thermal boundary window ratio - :param value: float - :return: None - """ - self._window_ratio = value - - @property - def window_area(self): - """ - Thermal boundary window area in square meters - :return: float - """ - if self._window_area is None: - try: - self._window_area = float(self._surface.area) * float(self.window_ratio) - except TypeError: - raise Exception('Window ratio is not defined or invalid surface area') - return self._window_area - - @property - def u_value(self): - """ - Thermal boundary u value in W/m2K - internal and external convective coefficient in W/m2K values, can be configured at configuration.ini - :return: float - """ - if self._u_value is None: - h_i = ConfigurationHelper().h_i - h_e = ConfigurationHelper().h_e - r_value = 1.0/h_i + 1.0/h_e - try: - for layer in self.layers: - if layer.material.no_mass: - r_value += float(layer.material.thermal_resistance) - else: - r_value = r_value + float(layer.material.conductivity) / float(layer.thickness) - self._u_value = 1.0/r_value - except TypeError: - raise Exception('Constructions layers are not initialized') - return self._u_value - - @property - def shortwave_reflectance(self): - """ - Get thermal boundary shortwave reflectance - :return: float - """ - return self._shortwave_reflectance - - @shortwave_reflectance.setter - def shortwave_reflectance(self, value): - """ - Set thermal boundary shortwave reflectance - :param value: float - :return: - """ - self._shortwave_reflectance = value - self._outside_solar_absorptance = 1.0 - float(value) diff --git a/city_model_structure/thermal_opening.py b/city_model_structure/thermal_opening.py deleted file mode 100644 index 3ed23816..00000000 --- a/city_model_structure/thermal_opening.py +++ /dev/null @@ -1,171 +0,0 @@ -""" -ThermalOpening module -SPDX - License - Identifier: LGPL - 3.0 - or -later -Copyright © 2020 Project Author Guille Gutierrez guillermo.gutierrezmorote@concordia.ca -""" -from helpers.configuration_helper import ConfigurationHelper - - -class ThermalOpening: - """ - ThermalOpening class - """ - def __init__(self): - self._openable_ratio = None - self._conductivity = None - self._frame_ratio = ConfigurationHelper().frame_ratio - self._g_value = None - self._thickness = None - self._front_side_solar_transmittance_at_normal_incidence = None - self._back_side_solar_transmittance_at_normal_incidence = None - self._overall_u_value = None - - @property - def openable_ratio(self): - """ - Get thermal opening openable ratio, NOT IMPLEMENTED - :return: Exception - """ - raise NotImplementedError() - - @openable_ratio.setter - def openable_ratio(self, value): - """ - Set thermal opening openable ratio, NOT IMPLEMENTED - :param value: Any - :return: Exception - """ - raise NotImplementedError() - - @property - def conductivity(self): - """ - Get thermal opening conductivity in W/mK - :return: float - """ - return self._conductivity - - @conductivity.setter - def conductivity(self, value): - """ - Get thermal opening conductivity in W/mK - :param value: float - :return: None - """ - # The code to calculate overall_u_value is duplicated here and in thickness_m. - # This ensures a more robust code that returns the overall_u_value regardless the order the parameters are read. - self._conductivity = value - if self._overall_u_value is None and self.thickness is not None: - h_i = ConfigurationHelper().h_i - h_e = ConfigurationHelper().h_e - r_value = 1 / h_i + 1 / h_e + float(self.conductivity) / float(self.thickness) - self._overall_u_value = 1 / r_value - - @property - def frame_ratio(self): - """ - Get thermal opening frame ratio - :return: float - """ - return self._frame_ratio - - @frame_ratio.setter - def frame_ratio(self, value): - """ - Set thermal opening frame ratio - :param value: float - :return: None - """ - self._frame_ratio = value - - @property - def g_value(self): - """ - Get thermal opening g value - :return: float - """ - return self._g_value - - @g_value.setter - def g_value(self, value): - """ - Set thermal opening g value - :param value: - :return: - """ - self._g_value = value - - @property - def thickness(self): - """ - Get thermal opening thickness in meters - :return: - """ - return self._thickness - - @thickness.setter - def thickness(self, value): - """ - Set thermal opening thickness in meters - :param value: float - :return: None - """ - # The code to calculate overall_u_value is duplicated here and in conductivity. - # This ensures a more robust code that returns the overall_u_value regardless the order the parameters are read. - self._thickness = value - if self._overall_u_value is None and self.conductivity is not None: - h_i = ConfigurationHelper().h_i - h_e = ConfigurationHelper().h_e - r_value = 1 / h_i + 1 / h_e + float(self.conductivity) / float(self.thickness) - self._overall_u_value = 1 / r_value - - @property - def front_side_solar_transmittance_at_normal_incidence(self): - """ - Get thermal opening front side solar transmittance at normal incidence - :return: float - """ - return self._front_side_solar_transmittance_at_normal_incidence - - @front_side_solar_transmittance_at_normal_incidence.setter - def front_side_solar_transmittance_at_normal_incidence(self, value): - """ - Set thermal opening front side solar transmittance at normal incidence - :param value: float - :return: None - """ - self._front_side_solar_transmittance_at_normal_incidence = value - - @property - def back_side_solar_transmittance_at_normal_incidence(self): - """ - Get thermal opening back side solar transmittance at normal incidence - :return: float - """ - return self._back_side_solar_transmittance_at_normal_incidence - - @back_side_solar_transmittance_at_normal_incidence.setter - def back_side_solar_transmittance_at_normal_incidence(self, value): - """ - Set thermal opening back side solar transmittance at normal incidence - :param value: float - :return: None - """ - self._back_side_solar_transmittance_at_normal_incidence = value - - @property - def overall_u_value(self): - """ - Get thermal opening overall u value in W/m2K - :return: float - """ - return self._overall_u_value - - @overall_u_value.setter - def overall_u_value(self, value): - """ - Get thermal opening overall u value in W/m2K - :param value: float - :return: None - """ - self._overall_u_value = value diff --git a/city_model_structure/thermal_zone.py b/city_model_structure/thermal_zone.py deleted file mode 100644 index 2dd67142..00000000 --- a/city_model_structure/thermal_zone.py +++ /dev/null @@ -1,187 +0,0 @@ -""" -ThermalZone module -SPDX - License - Identifier: LGPL - 3.0 - or -later -Copyright © 2020 Project Author Guille Gutierrez guillermo.gutierrezmorote@concordia.ca -""" -from typing import List, TypeVar - -from city_model_structure.surface import Surface -from city_model_structure.usage_zone import UsageZone -from helpers.configuration_helper import ConfigurationHelper - -ThermalBoundary = TypeVar('ThermalBoundary') - - -class ThermalZone: - """ - ThermalZone class - """ - def __init__(self, surfaces): - self._surfaces = surfaces - self._floor_area = None - self._bounded = None - self._heated = ConfigurationHelper().heated - self._cooled = ConfigurationHelper().cooled - self._additional_thermal_bridge_u_value = ConfigurationHelper().additional_thermal_bridge_u_value - self._effective_thermal_capacity = None - self._indirectly_heated_area_ratio = ConfigurationHelper().indirectly_heated_area_ratio - self._infiltration_rate_system_on = ConfigurationHelper().infiltration_rate_system_on - self._infiltration_rate_system_off = None - self._usage_zones = None - - @property - def heated(self): - """ - Get thermal zone heated flag - :return: Boolean - """ - return self._heated - - @property - def cooled(self): - """ - Get thermal zone cooled flag - :return: Boolean - """ - return self._cooled - - @property - def floor_area(self): - """ - Get thermal zone floor area in square meters - :return: float - """ - if self._floor_area is None: - self._floor_area = 0 - for s in self._surfaces: - if s.type == 'Ground': - self._floor_area += s.area - return self._floor_area - - @property - def bounded(self) -> List[ThermalBoundary]: - """ - Get thermal boundaries bounding with the thermal zone - :return: [ThermalBoundary] - """ - return self._bounded - - @bounded.setter - def bounded(self, value): - """ - Set thermal boundaries bounding with the thermal zone - :param value: [ThermalBoundary] - :return: None - """ - self._bounded = value - - @property - def surfaces(self) -> List[Surface]: - # todo: This property should be erased - """ - Get thermal zone surfaces - :return: [Surface] - """ - return self._surfaces - - @property - def additional_thermal_bridge_u_value(self): - """ - Get thermal zone additional thermal bridge u value W/m2K - :return: float - """ - return self._additional_thermal_bridge_u_value - - @additional_thermal_bridge_u_value.setter - def additional_thermal_bridge_u_value(self, value): - """ - Set thermal zone additional thermal bridge u value W/m2K - :param value: float - :return: None - """ - self._additional_thermal_bridge_u_value = value - - @property - def effective_thermal_capacity(self): - """ - Get thermal zone effective thermal capacity - :return: float - """ - return self._effective_thermal_capacity - - @effective_thermal_capacity.setter - def effective_thermal_capacity(self, value): - """ - Set thermal zone effective thermal capacity - :param value: float - :return: None - """ - self._effective_thermal_capacity = value - - @property - def indirectly_heated_area_ratio(self): - """ - Get thermal zone indirectly heated area ratio - :return: float - """ - return self._indirectly_heated_area_ratio - - @indirectly_heated_area_ratio.setter - def indirectly_heated_area_ratio(self, value): - """ - Set thermal zone indirectly heated area ratio - :param value: float - :return: None - """ - self._indirectly_heated_area_ratio = value - - @property - def infiltration_rate_system_on(self): - """ - Get thermal zone infiltration rate system on in air changes per hour - :return: float - """ - return self._infiltration_rate_system_on - - @infiltration_rate_system_on.setter - def infiltration_rate_system_on(self, value): - """ - Set thermal zone infiltration rate system on in air changes per hour - :param value: float - :return: None - """ - self._infiltration_rate_system_on = value - - @property - def infiltration_rate_system_off(self): - """ - Get thermal zone infiltration rate system off in air changes per hour - :return: float - """ - return self._infiltration_rate_system_off - - @infiltration_rate_system_off.setter - def infiltration_rate_system_off(self, value): - """ - Set thermal zone infiltration rate system on in air changes per hour - :param value: float - :return: None - """ - self._infiltration_rate_system_off = value - - @property - def usage_zones(self) -> List[UsageZone]: - """ - Get thermal zone usage zones - :return: [UsageZone] - """ - return self._usage_zones - - @usage_zones.setter - def usage_zones(self, values): - """ - Set thermal zone usage zones - :param values: [UsageZone] - :return: None - """ - self._usage_zones = values diff --git a/city_model_structure/usage_zone.py b/city_model_structure/usage_zone.py deleted file mode 100644 index 52801917..00000000 --- a/city_model_structure/usage_zone.py +++ /dev/null @@ -1,197 +0,0 @@ -""" -UsageZone module -SPDX - License - Identifier: LGPL - 3.0 - or -later -Copyright © 2020 Project Author Guille Gutierrez guillermo.gutierrezmorote@concordia.ca -""" -from typing import List -import pandas as pd - -from city_model_structure.internal_gains import InternalGains -from helpers.configuration_helper import ConfigurationHelper -from city_model_structure.occupancy import Occupancy - - -class UsageZone: - """ - UsageZone class - """ - def __init__(self): - self._usage = None - self._internal_gains = None - self._heating_setpoint = None - self._heating_setback = None - self._cooling_setpoint = None - self._hours_day = None - self._days_year = None - # todo: this must come from library, talk to Rabeeh - self._mechanical_air_change = ConfigurationHelper().min_air_change - self._occupancy = None - self._schedules = None - - @property - def internal_gains(self) -> List[InternalGains]: - """ - Get usage zone internal gains - :return: [InternalGains] - """ - return self._internal_gains - - @internal_gains.setter - def internal_gains(self, value): - """ - Set usage zone internal gains - :param value: [InternalGains] - :return: None - """ - self._internal_gains = value - - @property - def heating_setpoint(self): - """ - Get usage zone heating set point in celsius grads - :return: float - """ - return self._heating_setpoint - - @heating_setpoint.setter - def heating_setpoint(self, value): - """ - Set usage zone heating set point in celsius grads - :param value: float - :return: None - """ - self._heating_setpoint = value - - @property - def heating_setback(self): - """ - Get usage zone heating setback in celsius grads - :return: float - """ - return self._heating_setback - - @heating_setback.setter - def heating_setback(self, value): - """ - Set usage zone heating setback in celsius grads - :param value: float - :return: None - """ - self._heating_setback = value - - @property - def cooling_setpoint(self): - """ - Get usage zone cooling setpoint in celsius grads - :return: float - """ - return self._cooling_setpoint - - @cooling_setpoint.setter - def cooling_setpoint(self, value): - """ - Set usage zone cooling setpoint in celsius grads - :param value: float - :return: None - """ - self._cooling_setpoint = value - - @property - def hours_day(self): - """ - Get usage zone usage hours per day - :return: float - """ - return self._hours_day - - @hours_day.setter - def hours_day(self, value): - """ - Set usage zone usage hours per day - :param value: float - :return: float - """ - self._hours_day = value - - @property - def days_year(self): - """ - Get usage zone usage days per year - :return: float - """ - return self._days_year - - @days_year.setter - def days_year(self, value): - """ - Set usage zone usage days per year - :param value: float - :return: None - """ - self._days_year = value - - @property - def mechanical_air_change(self): - """ - Set usage zone mechanical air change in air change per hour - :return: float - """ - return self._mechanical_air_change - - @mechanical_air_change.setter - def mechanical_air_change(self, value): - """ - Get usage zone mechanical air change in air change per hour - :param value: float - :return: None - """ - self._mechanical_air_change = value - - @property - def usage(self): - """ - Get usage zone usage - :return: str - """ - return self._usage - - @usage.setter - def usage(self, value): - """ - Get usage zone usage - :param value: str - :return: None - """ - self._usage = value - - @property - def occupancy(self): - """ - Get occupancy data - :return: [Occupancy] - """ - return self._occupancy - - @occupancy.setter - def occupancy(self, values): - """ - Set occupancy - :param values: [Occupancy] - """ - self._occupancy = values - - @property - def schedules(self): - """ - Get schedule of Sundays - :return: [Sundays Schedule_Values] - """ - return self._schedules - - @schedules.setter - def schedules(self, value): - """ - occupancy schedules of Sundays - :param value: Sunday schedules - """ - self._schedules = value diff --git a/docs/build/html/_downloads/a6997596463e84fde618c07830426201/PYGUIDE.md b/docs/build/html/_downloads/a6997596463e84fde618c07830426201/PYGUIDE.md index 48f2a54a..41f70c81 100644 --- a/docs/build/html/_downloads/a6997596463e84fde618c07830426201/PYGUIDE.md +++ b/docs/build/html/_downloads/a6997596463e84fde618c07830426201/PYGUIDE.md @@ -114,7 +114,7 @@ All public classes, properties, and methods must have code comments. @property def object_attribute(self): """ - My class object attribute + My class object attributes :return: int """ return self._object_attribute diff --git a/geometry/geometry_factory.py b/factories/geometry/geometry_factory.py similarity index 89% rename from geometry/geometry_factory.py rename to factories/geometry/geometry_factory.py index d1aa1476..b1935c87 100644 --- a/geometry/geometry_factory.py +++ b/factories/geometry/geometry_factory.py @@ -5,8 +5,8 @@ Copyright © 2020 Project Author Guille Gutierrez guillermo.gutierrezmorote@conc """ from city_model_structure.city import City from city_model_structure.city_object import CityObject -from geometry.geometry_feeders.city_gml import CityGml -from geometry.geometry_feeders.osm_subway import OsmSubway +from factories.geometry.geometry_feeders.city_gml import CityGml +from factories.geometry.geometry_feeders.osm_subway import OsmSubway class GeometryFactory: diff --git a/geometry/geometry_feeders/city_gml.py b/factories/geometry/geometry_feeders/city_gml.py similarity index 99% rename from geometry/geometry_feeders/city_gml.py rename to factories/geometry/geometry_feeders/city_gml.py index ddd1e437..f9ac05b2 100644 --- a/geometry/geometry_feeders/city_gml.py +++ b/factories/geometry/geometry_feeders/city_gml.py @@ -8,7 +8,7 @@ import xmltodict from city_model_structure.city import City from city_model_structure.building import Building -from city_model_structure.surface import Surface +from city_model_structure.attributes.surface import Surface from helpers.geometry_helper import GeometryHelper diff --git a/geometry/geometry_feeders/osm_subway.py b/factories/geometry/geometry_feeders/osm_subway.py similarity index 100% rename from geometry/geometry_feeders/osm_subway.py rename to factories/geometry/geometry_feeders/osm_subway.py diff --git a/occupancy/occupancy_factory.py b/factories/occupancy/occupancy_factory.py similarity index 88% rename from occupancy/occupancy_factory.py rename to factories/occupancy/occupancy_factory.py index c200ef1b..b3a915ed 100644 --- a/occupancy/occupancy_factory.py +++ b/factories/occupancy/occupancy_factory.py @@ -5,7 +5,7 @@ Copyright © 2020 Project Author Guille Gutierrez guillermo.gutierrezmorote@conc """ from pathlib import Path -from occupancy.occupancy_feeders.demo_occupancy_parameters import DemoOccupancyParameters +from factories.occupancy.occupancy_feeders.demo_occupancy_parameters import DemoOccupancyParameters class OccupancyFactory: diff --git a/occupancy/occupancy_feeders/demo_occupancy_parameters.py b/factories/occupancy/occupancy_feeders/demo_occupancy_parameters.py similarity index 92% rename from occupancy/occupancy_feeders/demo_occupancy_parameters.py rename to factories/occupancy/occupancy_feeders/demo_occupancy_parameters.py index 7fdccf9c..eb3e8935 100644 --- a/occupancy/occupancy_feeders/demo_occupancy_parameters.py +++ b/factories/occupancy/occupancy_feeders/demo_occupancy_parameters.py @@ -4,7 +4,7 @@ SPDX - License - Identifier: LGPL - 3.0 - or -later Copyright © 2020 Project Author Guille Gutierrez guillermo.gutierrezmorote@concordia.ca """ import pandas as pd -from occupancy.occupancy_feeders.helpers.occupancy_helper import OccupancyHelper +from factories.occupancy.occupancy_feeders.helpers.occupancy_helper import OccupancyHelper class DemoOccupancyParameters: diff --git a/occupancy/occupancy_feeders/helpers/occupancy_helper.py b/factories/occupancy/occupancy_feeders/helpers/occupancy_helper.py similarity index 100% rename from occupancy/occupancy_feeders/helpers/occupancy_helper.py rename to factories/occupancy/occupancy_feeders/helpers/occupancy_helper.py diff --git a/physics/physics_factory.py b/factories/physics/physics_factory.py similarity index 83% rename from physics/physics_factory.py rename to factories/physics/physics_factory.py index 8e563eec..48fb623b 100644 --- a/physics/physics_factory.py +++ b/factories/physics/physics_factory.py @@ -3,8 +3,8 @@ PhysicsFactory retrieve the specific physics module for the given region SPDX - License - Identifier: LGPL - 3.0 - or -later Copyright © 2020 Project Author Guille Gutierrez guillermo.gutierrezmorote@concordia.ca """ -from physics.physics_feeders.us_new_york_city_physics_parameters import UsNewYorkCityPhysicsParameters -from physics.physics_feeders.us_physics_parameters import UsPhysicsParameters +from factories.physics.physics_feeders.us_new_york_city_physics_parameters import UsNewYorkCityPhysicsParameters +from factories.physics.physics_feeders.us_physics_parameters import UsPhysicsParameters from pathlib import Path diff --git a/physics/physics_feeders/helpers/us_pluto_to_function.py b/factories/physics/physics_feeders/helpers/us_pluto_to_function.py similarity index 100% rename from physics/physics_feeders/helpers/us_pluto_to_function.py rename to factories/physics/physics_feeders/helpers/us_pluto_to_function.py diff --git a/physics/physics_feeders/helpers/us_to_library_types.py b/factories/physics/physics_feeders/helpers/us_to_library_types.py similarity index 100% rename from physics/physics_feeders/helpers/us_to_library_types.py rename to factories/physics/physics_feeders/helpers/us_to_library_types.py diff --git a/physics/physics_feeders/us_base_physics_parameters.py b/factories/physics/physics_feeders/us_base_physics_parameters.py similarity index 96% rename from physics/physics_feeders/us_base_physics_parameters.py rename to factories/physics/physics_feeders/us_base_physics_parameters.py index f6e9ae19..c55a5d99 100644 --- a/physics/physics_feeders/us_base_physics_parameters.py +++ b/factories/physics/physics_feeders/us_base_physics_parameters.py @@ -6,9 +6,9 @@ Copyright © 2020 Project Author Guille Gutierrez guillermo.gutierrezmorote@conc """ import xmltodict -from city_model_structure.layer import Layer -from city_model_structure.material import Material -from physics.physics_feeders.helpers.us_to_library_types import UsToLibraryTypes +from city_model_structure.attributes.layer import Layer +from city_model_structure.attributes.material import Material +from factories.physics.physics_feeders.helpers.us_to_library_types import UsToLibraryTypes class UsBasePhysicsParameters: diff --git a/physics/physics_feeders/us_new_york_city_physics_parameters.py b/factories/physics/physics_feeders/us_new_york_city_physics_parameters.py similarity index 73% rename from physics/physics_feeders/us_new_york_city_physics_parameters.py rename to factories/physics/physics_feeders/us_new_york_city_physics_parameters.py index ed87f819..83b18055 100644 --- a/physics/physics_feeders/us_new_york_city_physics_parameters.py +++ b/factories/physics/physics_feeders/us_new_york_city_physics_parameters.py @@ -3,8 +3,8 @@ UsNewYorkCityPhysicsParameters import the construction and material information SPDX - License - Identifier: LGPL - 3.0 - or -later Copyright © 2020 Project Author Guille Gutierrez guillermo.gutierrezmorote@concordia.ca """ -from physics.physics_feeders.helpers.us_pluto_to_function import UsPlutoToFunction as Pf -from physics.physics_feeders.us_base_physics_parameters import UsBasePhysicsParameters +from factories.physics.physics_feeders.helpers.us_pluto_to_function import UsPlutoToFunction as Pf +from factories.physics.physics_feeders.us_base_physics_parameters import UsBasePhysicsParameters class UsNewYorkCityPhysicsParameters(UsBasePhysicsParameters): diff --git a/physics/physics_feeders/us_physics_parameters.py b/factories/physics/physics_feeders/us_physics_parameters.py similarity index 74% rename from physics/physics_feeders/us_physics_parameters.py rename to factories/physics/physics_feeders/us_physics_parameters.py index 3630eb30..955e4833 100644 --- a/physics/physics_feeders/us_physics_parameters.py +++ b/factories/physics/physics_feeders/us_physics_parameters.py @@ -3,8 +3,8 @@ UsPhysicsParameters import the construction and material information for US SPDX - License - Identifier: LGPL - 3.0 - or -later Copyright © 2020 Project Author Guille Gutierrez guillermo.gutierrezmorote@concordia.ca """ -from physics.physics_feeders.helpers.us_to_library_types import UsToLibraryTypes -from physics.physics_feeders.us_base_physics_parameters import UsBasePhysicsParameters +from factories.physics.physics_feeders.helpers.us_to_library_types import UsToLibraryTypes +from factories.physics.physics_feeders.us_base_physics_parameters import UsBasePhysicsParameters class UsPhysicsParameters(UsBasePhysicsParameters): diff --git a/usage/usage_factory.py b/factories/usage/usage_factory.py similarity index 81% rename from usage/usage_factory.py rename to factories/usage/usage_factory.py index 870b98af..e583cfe4 100644 --- a/usage/usage_factory.py +++ b/factories/usage/usage_factory.py @@ -3,8 +3,8 @@ UsageFactory retrieve the specific usage module for the given region SPDX - License - Identifier: LGPL - 3.0 - or -later Copyright © 2020 Project Author Guille Gutierrez guillermo.gutierrezmorote@concordia.ca """ -from usage.usage_feeders.de_usage_parameters import DeUsageParameters -from usage.usage_feeders.us_new_york_city_usage_parameters import UsNewYorkCityUsageParameters +from factories.usage.usage_feeders.de_usage_parameters import DeUsageParameters +from factories.usage.usage_feeders.us_new_york_city_usage_parameters import UsNewYorkCityUsageParameters class UsageFactory: diff --git a/usage/usage_feeders/de_usage_parameters.py b/factories/usage/usage_feeders/de_usage_parameters.py similarity index 87% rename from usage/usage_feeders/de_usage_parameters.py rename to factories/usage/usage_feeders/de_usage_parameters.py index 9da8d997..ec64aab1 100644 --- a/usage/usage_feeders/de_usage_parameters.py +++ b/factories/usage/usage_feeders/de_usage_parameters.py @@ -7,7 +7,7 @@ from pathlib import Path import xmltodict -from usage.usage_feeders.helpers.us_function_to_usage import UsFunctionToUsage +from factories.usage.usage_feeders.helpers.us_function_to_usage import UsFunctionToUsage class DeUsageParameters: diff --git a/usage/usage_feeders/helpers/us_function_to_usage.py b/factories/usage/usage_feeders/helpers/us_function_to_usage.py similarity index 100% rename from usage/usage_feeders/helpers/us_function_to_usage.py rename to factories/usage/usage_feeders/helpers/us_function_to_usage.py diff --git a/usage/usage_feeders/helpers/us_pluto_to_usage.py b/factories/usage/usage_feeders/helpers/us_pluto_to_usage.py similarity index 98% rename from usage/usage_feeders/helpers/us_pluto_to_usage.py rename to factories/usage/usage_feeders/helpers/us_pluto_to_usage.py index 4e860f24..39710250 100644 --- a/usage/usage_feeders/helpers/us_pluto_to_usage.py +++ b/factories/usage/usage_feeders/helpers/us_pluto_to_usage.py @@ -3,7 +3,7 @@ UsPlutoToUsage helper SPDX - License - Identifier: LGPL - 3.0 - or -later Copyright © 2020 Project Author Guille Gutierrez guillermo.gutierrezmorote@concordia.ca """ -from usage.usage_feeders.helpers.us_function_to_usage import UsFunctionToUsage +from factories.usage.usage_feeders.helpers.us_function_to_usage import UsFunctionToUsage class UsPlutoToUsage: diff --git a/usage/usage_feeders/us_base_usage_parameters.py b/factories/usage/usage_feeders/us_base_usage_parameters.py similarity index 97% rename from usage/usage_feeders/us_base_usage_parameters.py rename to factories/usage/usage_feeders/us_base_usage_parameters.py index 847dc74b..4c87a5e9 100644 --- a/usage/usage_feeders/us_base_usage_parameters.py +++ b/factories/usage/usage_feeders/us_base_usage_parameters.py @@ -7,8 +7,8 @@ from pathlib import Path import xmltodict -from city_model_structure.internal_gains import InternalGains -from city_model_structure.usage_zone import UsageZone +from city_model_structure.attributes.internal_gains import InternalGains +from city_model_structure.attributes.usage_zone import UsageZone class UsBaseUsageParameters: diff --git a/usage/usage_feeders/us_new_york_city_usage_parameters.py b/factories/usage/usage_feeders/us_new_york_city_usage_parameters.py similarity index 70% rename from usage/usage_feeders/us_new_york_city_usage_parameters.py rename to factories/usage/usage_feeders/us_new_york_city_usage_parameters.py index dcc39bc6..4dd0d92e 100644 --- a/usage/usage_feeders/us_new_york_city_usage_parameters.py +++ b/factories/usage/usage_feeders/us_new_york_city_usage_parameters.py @@ -3,8 +3,8 @@ UsNewYorkCityUsageParameters model the usage properties for a NYC building SPDX - License - Identifier: LGPL - 3.0 - or -later Copyright © 2020 Project Author Guille Gutierrez guillermo.gutierrezmorote@concordia.ca """ -from usage.usage_feeders.helpers.us_pluto_to_usage import UsPlutoToUsage as Pu -from usage.usage_feeders.us_base_usage_parameters import UsBaseUsageParameters +from factories.usage.usage_feeders.helpers.us_pluto_to_usage import UsPlutoToUsage as Pu +from factories.usage.usage_feeders.us_base_usage_parameters import UsBaseUsageParameters class UsNewYorkCityUsageParameters(UsBaseUsageParameters): diff --git a/usage/usage_feeders/us_usage_parameters.py b/factories/usage/usage_feeders/us_usage_parameters.py similarity index 68% rename from usage/usage_feeders/us_usage_parameters.py rename to factories/usage/usage_feeders/us_usage_parameters.py index de345098..bfa1c582 100644 --- a/usage/usage_feeders/us_usage_parameters.py +++ b/factories/usage/usage_feeders/us_usage_parameters.py @@ -3,8 +3,8 @@ UsUsageParameters model the usage properties for a Us building SPDX - License - Identifier: LGPL - 3.0 - or -later Copyright © 2020 Project Author Guille Gutierrez guillermo.gutierrezmorote@concordia.ca """ -from usage.usage_feeders.helpers.us_function_to_usage import UsFunctionToUsage -from usage.usage_feeders.us_base_usage_parameters import UsBaseUsageParameters +from factories.usage.usage_feeders.helpers.us_function_to_usage import UsFunctionToUsage +from factories.usage.usage_feeders.us_base_usage_parameters import UsBaseUsageParameters class UsUsageParameters(UsBaseUsageParameters): diff --git a/helpers/configuration_helper.py b/helpers/configuration_helper.py index 7e545906..9601a1c7 100644 --- a/helpers/configuration_helper.py +++ b/helpers/configuration_helper.py @@ -100,7 +100,8 @@ class ConfigurationHelper: @property def max_location_distance_for_shared_walls(self): """ - Configured maximal distance between buildings to consider that they may share walls in meters + Configured maximal distance between + attributes to consider that they may share walls in meters :return: float """ - return self._config.getfloat('buildings', 'max_location_distance_for_shared_walls') + return self._config.getfloat('attributes', 'max_location_distance_for_shared_walls') diff --git a/helpers/geometry_helper.py b/helpers/geometry_helper.py index 513baedf..a0df287a 100644 --- a/helpers/geometry_helper.py +++ b/helpers/geometry_helper.py @@ -23,7 +23,7 @@ class GeometryHelper: @staticmethod def adjacent_locations(location1, location2): """ - Determine when two buildings may be adjacent or not based in the dis + Determine when two attributes may be adjacent or not based in the dis :param location1: :param location2: :return: Boolean diff --git a/tests/test_geometry_factory.py b/tests/test_geometry_factory.py index 240b5075..ac7597b7 100644 --- a/tests/test_geometry_factory.py +++ b/tests/test_geometry_factory.py @@ -7,7 +7,7 @@ import os from pathlib import Path from unittest import TestCase -from geometry.geometry_factory import GeometryFactory +from factories.geometry.geometry_factory import GeometryFactory class TestGeometryFactory(TestCase): @@ -24,7 +24,7 @@ class TestGeometryFactory(TestCase): def _get_citygml(self): if self._city_gml is None: - file_path = (self._example_path / 'buildings.gml').resolve() + file_path = (self._example_path / 'attributes.gml').resolve() self._city_gml = GeometryFactory('citygml', file_path).city self.assertIsNotNone(self._city_gml, 'city is none') return self._city_gml diff --git a/tests/test_idf.py b/tests/test_idf.py index 21582dd6..29586aae 100644 --- a/tests/test_idf.py +++ b/tests/test_idf.py @@ -5,9 +5,9 @@ Copyright © 2020 Project Author Guille Gutierrez guillermo.gutierrezmorote@conc """ from pathlib import Path from unittest import TestCase -from geometry.geometry_factory import GeometryFactory -from physics.physics_factory import PhysicsFactory -from usage.usage_factory import UsageFactory +from factories.geometry.geometry_factory import GeometryFactory +from factories.physics.physics_factory import PhysicsFactory +from factories.usage.usage_factory import UsageFactory from helpers.idf_helper import IdfHelper from geomeppy import IDF @@ -27,7 +27,7 @@ class TestIdf(TestCase): def _get_city(self): if self._city_gml is None: - file_path = (self._example_path / 'buildings.gml').resolve() + file_path = (self._example_path / 'attributes.gml').resolve() self._city_gml = GeometryFactory('citygml', file_path).city PhysicsFactory('us_new_york', self._city_gml, base_path=self._example_path) UsageFactory('us_new_york', self._city_gml) diff --git a/tests/test_occupancy_factory.py b/tests/test_occupancy_factory.py index 79d7e8dc..ca9c964f 100644 --- a/tests/test_occupancy_factory.py +++ b/tests/test_occupancy_factory.py @@ -3,13 +3,12 @@ TestOccupancyFactory test and validate the city model structure occupancy parame SPDX - License - Identifier: LGPL - 3.0 - or -later Copyright © 2020 Project Author Guille Gutierrez guillermo.gutierrezmorote@concordia.ca """ -import os from pathlib import Path from unittest import TestCase -from geometry.geometry_factory import GeometryFactory -from usage.usage_factory import UsageFactory -from occupancy.occupancy_factory import OccupancyFactory +from factories.geometry.geometry_factory import GeometryFactory +from factories.usage.usage_factory import UsageFactory +from factories.occupancy.occupancy_factory import OccupancyFactory class TestOccupancyFactory(TestCase): @@ -34,7 +33,7 @@ class TestOccupancyFactory(TestCase): def _get_citygml_with_usage(self): if self._city_gml_with_usage is None: - file_path = (self._example_path / 'buildings.gml').resolve() + file_path = (self._example_path / 'attributes.gml').resolve() self._city_gml_with_usage = GeometryFactory('citygml', file_path).city self.assertIsNotNone(self._city_gml_with_usage, 'city is none') UsageFactory(self._handler, self._city_gml_with_usage) diff --git a/tests/test_physics_factory.py b/tests/test_physics_factory.py index 05bd87c0..3415cc15 100644 --- a/tests/test_physics_factory.py +++ b/tests/test_physics_factory.py @@ -6,8 +6,8 @@ Copyright © 2020 Project Author Guille Gutierrez guillermo.gutierrezmorote@conc from pathlib import Path from unittest import TestCase -from geometry.geometry_factory import GeometryFactory -from physics.physics_factory import PhysicsFactory +from factories.geometry.geometry_factory import GeometryFactory +from factories.physics.physics_factory import PhysicsFactory class TestPhysicsFactory(TestCase): @@ -25,7 +25,7 @@ class TestPhysicsFactory(TestCase): def _get_citygml(self): if self._city_gml is None: - file_path = (self._example_path / 'buildings.gml').resolve() + file_path = (self._example_path / 'attributes.gml').resolve() self._city_gml = GeometryFactory('citygml', file_path).city self.assertIsNotNone(self._city_gml, 'city is none') return self._city_gml