monthly energy balance exporter with unittest created

exports/formats/idf.py

@@ -51,7 +51,6 @@ class Idf:
   _LOCATION = 'SITE:LOCATION'
   _SIMPLE = 'Simple'
 
-
   idf_surfaces = {
     # todo: make an enum for all the surface types
     cte.WALL: 'wall',

exports/insel/insel.py

@@ -5,72 +5,39 @@ Copyright © 2022 Concordia CERC group
 Project Coder Pilar Monsalvete Alvarez de Uribarri pilar.monsalvete@concordia.ca
 """
 
+from abc import ABC
 import os
 from pathlib import Path
-from abc import ABC
 
 
 class Insel(ABC):
-  def __init__(self, path, name, new_content="", mode=1, keep_files=False):
+  def __init__(self, city, path, keep_files=False):
+    self._city = city
     self._path = path
-    self._name = name
-    self._full_path = None
-    self._content = None
     self._results = None
     self._keep_files = keep_files
-    self.add_content(new_content, mode)
-    self.save()
-    self.run()
-
-  def save(self):
-    with open(self.full_path, 'w') as insel_file:
-      insel_file.write(self.content)
-    return
-
-  @property
-  def full_path(self):
-    if self._full_path is None:
-      self._full_path = (Path(self._path) / 'tests/tmp' / self._name).resolve()
-      print(self._full_path)
-    return self._full_path
-
-  @property
-  def content(self):
-    if self._content is None:
-      if os.path.exists(self.full_path):
-        with open(self.full_path, 'r') as insel_file:
-          self._content = insel_file.read()
-      else:
-        self._content = ''
-    return self._content
 
   @staticmethod
-  def add_block(file, block_number, block_type, inputs='', parameters=''):
+  def _add_block(file, block_number, block_type, inputs='', parameters=''):
     file += "S " + str(block_number) + " " + block_type + "\n"
     for block_input in inputs:
-      file += block_input + "\n"
+      file += str(block_input) + "\n"
     if len(parameters) > 0:
       file += "P " + str(block_number) + "\n"
     for block_parameter in parameters:
-      file += block_parameter + "\n"
+      file += str(block_parameter) + "\n"
     return file
 
-  def add_content(self, new_content, mode):
-    # mode = 1: keep old content
-    if mode == 1:
-      self._content = self.content + '\n' + new_content
-    # mode = 2: over-write
-    elif mode == 2:
-      self._content = new_content
-    else:
-      raise Exception('Add content mode not supported')
-    return
-
-  def run(self):
-    finish = os.system('insel ' + str(self.full_path))
+  def run(self, insel_models):
+    for insel_model in insel_models:
+      finish = os.system('insel ' + str(Path(insel_model).resolve()))
       os.close(finish)
       if not self._keep_files:
-      os.remove(self.full_path)
+        os.remove((Path(self._path) / insel_model).resolve())
 
-  def results(self, path):
+  def results(self, insel_models):
     raise NotImplementedError
+
+  def _export(self):
+    raise NotImplementedError
+

exports/insel/templates/monthly_energy_balance.py

@@ -20,7 +20,31 @@ _CONSTRUCTION_CODE = {
 
 class MonthlyEnergyBalance(Insel):
 
-  def results(self, insel_outputs_path):
+  def __init__(self, city, path, radiation_calculation_method='sra', weather_format='epw'):
+    super().__init__(city, path, False)
+    self._radiation_calculation_method = radiation_calculation_method
+    self._weather_format = weather_format
+    self._contents = []
+    self._insel_files_paths = []
+    for building in city.buildings:
+      self._insel_files_paths.append(building.name + '.insel')
+      file_name_out = building.name + '.out'
+      output_path = Path(self._path / file_name_out).resolve()
+      self._contents.append(self.generate_meb_template(building, output_path, self._radiation_calculation_method,
+                                                       self._weather_format))
+    self._export()
+
+  def _export(self):
+    for i_file, content in enumerate(self._contents):
+      file_name = self._insel_files_paths[i_file]
+      with open(Path(self._path / file_name).resolve(), 'w') as insel_file:
+        insel_file.write(content)
+    return
+
+  def results(self, insel_outputs_paths):
+    monthly_heatings = []
+    monthly_coolings = []
+    for insel_outputs_path in insel_outputs_paths:
       heating = []
       cooling = []
       with open(Path(insel_outputs_path).resolve()) as csv_file:
@@ -33,16 +57,16 @@ class MonthlyEnergyBalance(Insel):
               demand[i] = str(aux)
           heating.append(demand[0])
           cooling.append(demand[1])
-    monthly_heating = pd.DataFrame(heating, columns=['INSEL'])
-    monthly_cooling = pd.DataFrame(cooling, columns=['INSEL'])
-    return monthly_heating, monthly_cooling
+      monthly_heatings.append(pd.DataFrame(heating, columns=['INSEL']))
+      monthly_coolings.append(pd.DataFrame(cooling, columns=['INSEL']))
+    return monthly_heatings, monthly_coolings
 
   @staticmethod
-  def generate_meb_template(building, insel_outputs_path, key):
+  def generate_meb_template(building, insel_outputs_path, radiation_calculation_method, weather_format):
     file = ""
     i_block = 1
     parameters = ["1", "12", "1"]
-    file = Insel.add_block(file, i_block, 'DO', parameters=parameters)
+    file = Insel._add_block(file, i_block, 'DO', parameters=parameters)
 
     i_block = 4
     inputs = ["1.1", "20.1", "21.1"]
@@ -63,7 +87,7 @@ class MonthlyEnergyBalance(Insel):
     thermal_zone = internal_zone.thermal_zones[0]
     parameters.append(f'{thermal_zone.indirectly_heated_area_ratio} % BP(6) Indirectly heated area ratio')
     parameters.append(f'{thermal_zone.effective_thermal_capacity} % BP(7) Effective heat capacity')
-    parameters.append(f'{thermal_zone.additional_thermal_bridge_u_value * thermal_zone.floor_area} '
+    parameters.append(f'{thermal_zone.additional_thermal_bridge_u_value * thermal_zone.total_floor_area} '
                       f'% BP(8) Additional U-value for heat bridge')
     parameters.append('0 % BP(9) Usage type (0=standard, 1=IWU)')
 
@@ -78,17 +102,17 @@ class MonthlyEnergyBalance(Insel):
         total_internal_gain += float(ig.average_internal_gain) * \
                                 (float(ig.convective_fraction) + float(ig.radiative_fraction))
       parameters.append(f'{total_internal_gain} % BP(12) #2 Internal gains of zone {i + 1}')
-      parameters.append(f'{usage_zone.heating_setpoint} % BP(13) #3 Heating setpoint temperature '
+      parameters.append(f'{usage_zone.thermal_control.mean_heating_set_point} % BP(13) #3 Heating setpoint temperature '
                         f'zone {i + 1} (tSetHeat)')
-      parameters.append(f'{usage_zone.heating_setback} % BP(14) #4 Heating setback temperature '
+      parameters.append(f'{usage_zone.thermal_control.heating_set_back} % BP(14) #4 Heating setback temperature '
                         f'zone {i + 1} (tSetbackHeat)')
-      parameters.append(f'{usage_zone.cooling_setpoint} % BP(15) #5 Cooling setpoint temperature '
+      parameters.append(f'{usage_zone.thermal_control.mean_cooling_set_point} % BP(15) #5 Cooling setpoint temperature '
                         f'zone {i + 1} (tSetCool)')
       parameters.append(f'{usage_zone.hours_day} %  BP(16) #6 Usage hours per day zone {i + 1}')
       parameters.append(f'{usage_zone.days_year} %  BP(17) #7 Usage days per year zone {i + 1}')
       parameters.append(f'{usage_zone.mechanical_air_change} % BP(18) #8 Minimum air change rate zone {i + 1} (h^-1)')
 
-    parameters.append(f'{len(surfaces)}  % Number of surfaces = BP(11+8z) \n'
+    parameters.append(f'{len(thermal_zone.thermal_boundaries)}  % Number of surfaces = BP(11+8z) \n'
                       f'% 1. Surface type (1=wall, 2=ground 3=roof, 4=flat roof)\n'
                       f'% 2. Areas above ground\n'
                       f'% 3. Areas below ground\n'
@@ -119,32 +143,33 @@ class MonthlyEnergyBalance(Insel):
         parameters.append(thermal_opening.frame_ratio)
         parameters.append(thermal_opening.overall_u_value)
         parameters.append(thermal_opening.g_value)
-      if thermal_boundary.parent_surface.short_wave_reflectance is not None:
-        parameters.append(thermal_boundary.shortwave_reflectance)
+      if thermal_boundary.type is not cte.GROUND:
+        parameters.append(thermal_boundary.parent_surface.short_wave_reflectance)
       else:
         parameters.append(0.0)
 
-    file = Insel.add_block(file, i_block, 'd18599', inputs=inputs, parameters=parameters)
+    file = Insel._add_block(file, i_block, 'd18599', inputs=inputs, parameters=parameters)
 
     i_block = 20
     inputs = ['1']
     parameters = ['12 % Monthly ambient temperature']
 
     external_temperature = building.external_temperature[cte.MONTH]
-    for i in range(0, len(external_temperature)):
-      parameters.append(f'{i + 1} {external_temperature.at[i, key]}')
 
-    file = Insel.add_block(file, i_block, 'polyg', inputs=inputs, parameters=parameters)
+    for i in range(0, len(external_temperature)):
+      parameters.append(f'{i + 1} {external_temperature.at[i, weather_format]}')
+
+    file = Insel._add_block(file, i_block, 'polyg', inputs=inputs, parameters=parameters)
 
     i_block = 21
     inputs = ['1']
     parameters = ['12 % Monthly sky temperature']
 
-    sky_temperature = Weather.sky_temperature(external_temperature[[key]].to_numpy().T[0])
+    sky_temperature = Weather.sky_temperature(external_temperature[[weather_format]].to_numpy().T[0])
     for i, temperature in enumerate(sky_temperature):
       parameters.append(f'{i + 1} {temperature}')
 
-    file = Insel.add_block(file, i_block, 'polyg', inputs=inputs, parameters=parameters)
+    file = Insel._add_block(file, i_block, 'polyg', inputs=inputs, parameters=parameters)
 
     for i, surface in enumerate(surfaces):
       i_block = 101 + i
@@ -154,20 +179,20 @@ class MonthlyEnergyBalance(Insel):
       if surface.type != 'Ground':
         global_irradiance = surface.global_irradiance[cte.MONTH]
         for j in range(0, len(global_irradiance)):
-          parameters.append(f'{j + 1} {global_irradiance.at[j, "sra"]}')
+          parameters.append(f'{j + 1} {global_irradiance.at[j, radiation_calculation_method]}')
       else:
         for j in range(0, 12):
           parameters.append(f'{j + 1} 0.0')
 
-      file = Insel.add_block(file, i_block, 'polyg', inputs=inputs, parameters=parameters)
+      file = Insel._add_block(file, i_block, 'polyg', inputs=inputs, parameters=parameters)
 
     i_block = 300
     inputs = ['4.1', '4.2']
-    file = Insel.add_block(file, i_block, 'cum', inputs=inputs)
+    file = Insel._add_block(file, i_block, 'cum', inputs=inputs)
 
     i_block = 303
     inputs = ['300.1', '300.2']
-    file = Insel.add_block(file, i_block, 'atend', inputs=inputs)
+    file = Insel._add_block(file, i_block, 'atend', inputs=inputs)
 
     i_block = 310
     inputs = ['4.1', '4.2']
@@ -175,6 +200,6 @@ class MonthlyEnergyBalance(Insel):
                   '0 % Suppress FNQ inputs',
                   f"'{str(insel_outputs_path)}' % File name",
                   "'*' % Fortran format"]
-    file = Insel.add_block(file, i_block, 'WRITE', inputs=inputs, parameters=parameters)
+    file = Insel._add_block(file, i_block, 'WRITE', inputs=inputs, parameters=parameters)
 
     return file

exports/insel_exports_factory.py

@@ -0,0 +1,43 @@
+"""
+InselExportsFactory export a city into several formats
+SPDX - License - Identifier: LGPL - 3.0 - or -later
+Copyright © 2022 Concordia CERC group
+Project Coder Pilar Monsalvete Alvarez de uribarri pilar.monsalvete@concordia.ca
+"""
+
+from pathlib import Path
+from exports.insel.templates.monthly_energy_balance import MonthlyEnergyBalance
+
+
+class InselExportsFactory:
+  """
+  Insel exports factory class
+  """
+  def __init__(self, export_type, city, path):
+    self._city = city
+    self._export_type = '_' + export_type.lower()
+    if isinstance(path, str):
+      path = Path(path)
+    self._path = path
+
+  @property
+  def _monthly_energy_balance(self):
+    """
+    Export to Insel MonthlyEnergyBalance
+    :return: None
+    """
+    return MonthlyEnergyBalance(self._city, self._path)
+
+  def export(self):
+    """
+    Export the city given to the class using the given export type handler
+    :return: None
+    """
+    return getattr(self, self._export_type, lambda: None)
+
+  def export_debug(self):
+    """
+    Export the city given to the class using the given export type handler
+    :return: None
+    """
+    return getattr(self, self._export_type)

helpers/monthly_values.py

@@ -0,0 +1,47 @@
+"""
+Monthly values
+SPDX - License - Identifier: LGPL - 3.0 - or -later
+Copyright © 2020 Project Author Pilar Monsalvete pilar_monsalvete@yahoo.es
+"""
+
+import pandas as pd
+import numpy as np
+import calendar as cal
+
+
+class MonthlyValues:
+  def __init__(self):
+    self._month_hour = None
+
+  def get_mean_values(self, values):
+    out = None
+    if values is not None:
+      if 'month' not in values.columns:
+        values = pd.concat([self.month_hour, pd.DataFrame(values)], axis=1)
+      out = values.groupby('month', as_index=False).mean()
+      del out['month']
+    return out
+
+  def get_total_month(self, values):
+    out = None
+    if values is not None:
+      if 'month' not in values.columns:
+        values = pd.concat([self.month_hour, pd.DataFrame(values)], axis=1)
+      out = pd.DataFrame(values).groupby('month', as_index=False).sum()
+      del out['month']
+    return out
+
+  @property
+  def month_hour(self):
+    """
+    returns a DataFrame that has x values of the month number (January = 1, February = 2...),
+    being x the number of hours of the corresponding month
+    :return: DataFrame(int)
+    """
+    array = []
+    for i in range(0, 12):
+      days_of_month = cal.monthrange(2015, i+1)[1]
+      total_hours = days_of_month * 24
+      array = np.concatenate((array, np.full(total_hours, i + 1)))
+    self._month_hour = pd.DataFrame(array, columns=['month'])
+    return self._month_hour

unittests/test_insel_exports.py

@@ -0,0 +1,149 @@
+"""
+TestInselExports test
+SPDX - License - Identifier: LGPL - 3.0 - or -later
+Copyright © 2022 Concordia CERC group
+Project Coder Pilar Monsalvete Alvarez de Uribarri pilar.monsalvete@concordia.ca
+"""
+
+from pathlib import Path
+from unittest import TestCase
+import pandas as pd
+import helpers.constants as cte
+from helpers.monthly_values import MonthlyValues
+from imports.geometry_factory import GeometryFactory
+from imports.construction_factory import ConstructionFactory
+from imports.usage_factory import UsageFactory
+from exports.insel_exports_factory import InselExportsFactory
+from imports.weather_factory import WeatherFactory
+
+
+class TestExports(TestCase):
+  """
+  TestExports class contains the unittest for export functionality
+  """
+  def setUp(self) -> None:
+    """
+    Test setup
+    :return: None
+    """
+    self._city = None
+    self._complete_city = None
+    self._example_path = (Path(__file__).parent / 'tests_data').resolve()
+    self._output_path = (Path(__file__).parent / 'tests_outputs').resolve()
+
+  def _get_citygml(self, file):
+    file_path = (self._example_path / file).resolve()
+    self._city = GeometryFactory('citygml', path=file_path).city
+    self.assertIsNotNone(self._city, 'city is none')
+    return self._city
+
+  @property
+  def _read_sra_file(self) -> []:
+    path = (self._example_path / "one_building_in_kelowna_sra_SW.out").resolve()
+    _results = pd.read_csv(path, sep='\s+', header=0)
+    id_building = ''
+    header_building = []
+    _radiation = []
+    for column in _results.columns.values:
+      if id_building != column.split(':')[1]:
+        id_building = column.split(':')[1]
+        if len(header_building) > 0:
+          _radiation.append(pd.concat([MonthlyValues().month_hour, _results[header_building]], axis=1))
+        header_building = [column]
+      else:
+        header_building.append(column)
+    _radiation.append(pd.concat([MonthlyValues().month_hour, _results[header_building]], axis=1))
+    return _radiation
+
+  def _set_irradiance_surfaces(self, city):
+    """
+    saves in building surfaces the correspondent irradiance at different time-scales depending on the mode
+    if building is None, it saves all buildings' surfaces in file, if building is specified, it saves only that
+    specific building values
+    :parameter city: city
+    :return: none
+    """
+    for radiation in self._read_sra_file:
+      city_object_name = radiation.columns.values.tolist()[1].split(':')[1]
+      building = city.city_object(city_object_name)
+      for column in radiation.columns.values:
+        if column == cte.MONTH:
+          continue
+        header_id = column
+        surface_id = header_id.split(':')[2]
+        surface = building.surface_by_id(surface_id)
+        new_value = pd.DataFrame(radiation[[header_id]].to_numpy(), columns=['sra'])
+        surface.global_irradiance[cte.HOUR] = new_value
+        month_new_value = MonthlyValues().get_mean_values(new_value)
+        surface.global_irradiance[cte.MONTH] = month_new_value
+
+  def test_monthly_energy_balance_export(self):
+    """
+    export to Insel MonthlyEnergyBalance
+    """
+    city = self._get_citygml('one_building_in_kelowna.gml')
+    WeatherFactory('epw', city, file_name='CAN_PQ_Montreal.Intl.AP.716270_CWEC.epw').enrich()
+    for building in city.buildings:
+      building.external_temperature[cte.MONTH] = MonthlyValues().\
+        get_mean_values(building.external_temperature[cte.HOUR][['epw']])
+    self._set_irradiance_surfaces(city)
+
+    for building in city.buildings:
+      self.assertIsNotNone(building.external_temperature[cte.MONTH], f'building {building.name} '
+                                                                     f'external_temperature is none')
+      for surface in building.surfaces:
+        if surface.type != 'Ground':
+          self.assertIsNotNone(surface.global_irradiance[cte.MONTH], f'surface in building {building.name} '
+                                                                     f'global_irradiance is none')
+
+    for building in city.buildings:
+      building.year_of_construction = 2006
+      if building.function is None:
+        building.function = 'large office'
+      building.attic_heated = False
+      building.basement_heated = False
+    ConstructionFactory('nrel', city).enrich()
+    UsageFactory('comnet', city).enrich()
+
+    # parameters written:
+    for building in city.buildings:
+      self.assertIsNotNone(building.volume, f'building {building.name} volume is none')
+      self.assertIsNotNone(building.average_storey_height, f'building {building.name} average_storey_height is none')
+      self.assertIsNotNone(building.storeys_above_ground, f'building {building.name} storeys_above_ground is none')
+      self.assertIsNotNone(building.attic_heated, f'building {building.name} attic_heated is none')
+      self.assertIsNotNone(building.basement_heated, f'building {building.name} basement_heated is none')
+      for internal_zone in building.internal_zones:
+        self.assertIsNotNone(internal_zone.area, f'internal zone {internal_zone.id} area is none')
+        for thermal_zone in internal_zone.thermal_zones:
+          self.assertIsNotNone(thermal_zone.indirectly_heated_area_ratio, f'thermal zone {thermal_zone.id} '
+                                                                          f'indirectly_heated_area_ratio is none')
+          self.assertIsNotNone(thermal_zone.effective_thermal_capacity, f'thermal zone {thermal_zone.id} '
+                                                                        f'effective_thermal_capacity is none')
+          self.assertIsNotNone(thermal_zone.additional_thermal_bridge_u_value, f'thermal zone {thermal_zone.id} '
+                                                                               f'additional_thermal_bridge_u_value '
+                                                                               f'is none')
+          self.assertIsNotNone(thermal_zone.total_floor_area, f'thermal zone {thermal_zone.id} '
+                                                              f'total_floor_area is none')
+          for thermal_boundary in thermal_zone.thermal_boundaries:
+            self.assertIsNotNone(thermal_boundary.type)
+            self.assertIsNotNone(thermal_boundary.opaque_area)
+            self.assertIsNotNone(thermal_boundary.window_ratio)
+            self.assertIsNotNone(thermal_boundary.u_value)
+            self.assertIsNotNone(thermal_boundary.thermal_openings)
+            if thermal_boundary.type is not cte.GROUND:
+              self.assertIsNotNone(thermal_boundary.parent_surface.short_wave_reflectance)
+
+        for usage_zone in internal_zone.usage_zones:
+          self.assertIsNotNone(usage_zone.percentage, f'usage zone {usage_zone.usage} percentage is none')
+          self.assertIsNotNone(usage_zone.internal_gains, f'usage zone {usage_zone.usage} internal_gains is none')
+          self.assertIsNotNone(usage_zone.thermal_control, f'usage zone {usage_zone.usage} thermal_control is none')
+          self.assertIsNotNone(usage_zone.hours_day, f'usage zone {usage_zone.usage} hours_day is none')
+          self.assertIsNotNone(usage_zone.days_year, f'usage zone {usage_zone.usage} days_year is none')
+          self.assertIsNotNone(usage_zone.mechanical_air_change, f'usage zone {usage_zone.usage} '
+                                                                 f'mechanical_air_change is none')
+
+    # export files
+    try:
+      InselExportsFactory('monthly_energy_balance', city, self._output_path).export_debug()
+    except Exception:
+      self.fail("Insel MonthlyEnergyBalance ExportsFactory raised ExceptionType unexpectedly!")