hub/exports/building_energy/cerc_idf.py

@@ -8,8 +8,6 @@ Code contributors: Pilar Monsalvete Alvarez de Uribarri pilar.monsalvete@concord
 """
 import copy
 import os
-import shutil
-import subprocess
 from datetime import datetime
 
 import hub.exports.building_energy.idf_helper as idf_cte
@@ -43,12 +41,11 @@ class CercIdf(IdfBase):
 
   _schedules_added_to_idf = {}
   _materials_added_to_idf = {}
-  _windows_added_to_idf = {}
+  _windows_added_to_idf = {'glazing_index': 0}
   _constructions_added_to_idf = {}
   _thermostat_added_to_idf = {}
 
   def __init__(self, city, output_path, idf_file_path, idd_file_path, epw_file_path, target_buildings=None):
-    self._start = datetime.now()
     super().__init__(city, output_path, idf_file_path, idd_file_path, epw_file_path, target_buildings)
     self._add_surfaces = IdfSurfaces.add
     self._add_file_schedule = IdfFileSchedule.add
@@ -69,18 +66,15 @@ class CercIdf(IdfBase):
     self._add_shading = IdfShading.add
     self._add_windows = IdfWindow.add
 
-    with open(self._idf_file_path, 'r', encoding='UTF-8') as base_idf:
+    with open(self._idf_file_path, 'r') as base_idf:
       lines = base_idf.readlines()
-    # Change city name
+
-    comment = f'    !- Name'
+    with open(self._output_file_path, 'w') as self._idf_file:
-    field = f'    Buildings in {self._city.name},'.ljust(26, ' ')
-    lines[15] = f'{field}{comment}\n'
-    with open(self._output_file_path, 'w', encoding='UTF-8') as self._idf_file:
       self._idf_file.writelines(lines)
       self._export()
 
   def _create_geometry_rules(self):
-    file = self._files['constructions']
+    file = self._files['zones']
     self._write_to_idf_format(file, idf_cte.GLOBAL_GEOMETRY_RULES)
     self._write_to_idf_format(file, 'UpperLeftCorner', 'Starting Vertex Position')
     self._write_to_idf_format(file, 'CounterClockWise', 'Vertex Entry Direction')
@@ -90,14 +84,14 @@ class CercIdf(IdfBase):
     for file in self._files.values():
       file.close()
     for path in self._file_paths.values():
-      with open(path, 'r', encoding='UTF-8') as file:
+      with open(path, 'r') as file:
         lines = file.readlines()
       self._idf_file.writelines(lines)
     for path in self._file_paths.values():
       os.unlink(path)
 
   def _add_outputs(self):
-    with open(self._outputs_file_path, 'r', encoding='UTF-8') as base_idf:
+    with open(self._outputs_file_path, 'r') as base_idf:
       lines = base_idf.readlines()
     self._idf_file.writelines(lines)
 
@@ -163,7 +157,7 @@ class CercIdf(IdfBase):
     return [_schedule]
 
   def _export(self):
-
+    start = datetime.now()
     for building in self._city.buildings:
       is_target = building.name in self._target_buildings or building.name in self._adjacent_buildings
       for internal_zone in building.internal_zones:
@@ -204,8 +198,8 @@ class CercIdf(IdfBase):
               self._add_material(self, thermal_boundary)
               self._add_construction(self, thermal_boundary)
               for thermal_opening in thermal_boundary.thermal_openings:
-                self._add_windows_material(self, thermal_boundary, thermal_opening)
+                self._add_windows_material(self, thermal_opening)
-                self._add_windows_constructions(self, thermal_boundary)
+                self._add_windows_constructions(self)
             self._add_zone(self, thermal_zone, building.name)
             self._add_occupancy(self, thermal_zone, building.name)
             self._add_lighting(self, thermal_zone, building.name)
@@ -217,7 +211,7 @@ class CercIdf(IdfBase):
             self._add_dhw(self, thermal_zone, building.name)
       if is_target:
         self._add_surfaces(self, building, building.name)
-        self._add_windows(self, building)
+        self._add_windows(self, building, building.name)
       else:
         self._add_shading(self, building)
 
@@ -229,20 +223,4 @@ class CercIdf(IdfBase):
     # Merge files
     self._merge_files()
     self._add_outputs()
-    print(f'{len(self._city.buildings)} buildings export completed in: {datetime.now() - self._start}')
+    print(f'Export completed in: {datetime.now() - start}')
-
-  @property
-  def _energy_plus(self):
-    return shutil.which('energyplus')
-
-  def run(self):
-    cmd = [self._energy_plus,
-           '--weather', self._epw_file_path,
-           '--output-directory', self._output_path,
-           '--idd', self._idd_file_path,
-           '--expandobjects',
-           '--readvars',
-           '--output-prefix', f'{self._city.name}_',
-           self._output_file_path]
-    print(cmd)
-    subprocess.run(cmd, cwd=self._output_path)

hub/exports/building_energy/idf.py

@@ -501,7 +501,7 @@ class Idf:
                            )
 
   def _rename_building(self, city_name):
-    name = str(city_name.encode("utf-8"))
+    name = str(str(city_name.encode("utf-8")))
     for building in self._idf.idfobjects[self._BUILDING]:
       building.Name = f'Buildings in {name}'
       building['Solar_Distribution'] = 'FullExterior'
@@ -586,7 +586,8 @@ class Idf:
       if self._export_type == "Surfaces":
         if is_target:
           if building.thermal_zones_from_internal_zones is not None:
-            self._add_surfaces(building, building.name)
+            pass
+            # self._add_surfaces(building, building.name)
           else:
             self._add_pure_geometry(building, building.name)
         else:
@@ -732,8 +733,13 @@ class Idf:
       self._idf.set_wwr(wwr)
 
   def _add_surfaces(self, building, zone_name):
+    start = datetime.datetime.now()
+    print(f'thermal_zones {len(building.thermal_zones_from_internal_zones)}')
     for thermal_zone in building.thermal_zones_from_internal_zones:
+      print(f'thermal zone: {datetime.datetime.now() - start}')
       for index, boundary in enumerate(thermal_zone.thermal_boundaries):
+        print(f'{index} boundary: {datetime.datetime.now() - start}')
+
         idf_surface_type = self.idf_surfaces[boundary.parent_surface.type]
         outside_boundary_condition = 'Outdoors'
         sun_exposure = 'SunExposed'
@@ -762,9 +768,13 @@ class Idf:
         _kwargs['Construction_Name'] = construction_name
         start = datetime.datetime.now()
         surface = self._idf.newidfobject(self._SURFACE, **_kwargs)
+        print(f'create surface: {datetime.datetime.now() - start}')
         coordinates = self._matrix_to_list(boundary.parent_surface.solid_polygon.coordinates,
                                            self._city.lower_corner)
+
         surface.setcoords(coordinates)
+        print(f'set coords surface: {datetime.datetime.now() - start}')
+
     if self._lod >= 3:
       for internal_zone in building.internal_zones:
         for thermal_zone in internal_zone.thermal_zones_from_internal_zones:
@@ -776,7 +786,7 @@ class Idf:
       for surface in building.surfaces:
         if surface.type == cte.WALL:
           wwr = surface.associated_thermal_boundaries[0].window_ratio
-      #self._idf.set_wwr(wwr, construction='window_construction_1')
+      self._idf.set_wwr(wwr, construction='window_construction_1')
 
   def _add_windows_by_vertices(self, boundary):
     raise NotImplementedError

hub/exports/building_energy/idf_files/base.idf

@@ -13,7 +13,7 @@ SimulationControl,
     1;                        !- Maximum Number of HVAC Sizing Simulation Passes
 
 Building,
-    Buildings in #CITY#,    !- Name
+    Buildings in b'Montreal',    !- Name
     0,                        !- North Axis
     Suburbs,                  !- Terrain
     0.04,                     !- Loads Convergence Tolerance Value

hub/exports/building_energy/idf_helper/__init__.py

@@ -1,7 +1,6 @@
 import hub.helpers.constants as cte
 
 BUILDING_SURFACE = '\nBUILDINGSURFACE:DETAILED,\n'
-WINDOW_SURFACE = '\nFENESTRATIONSURFACE:DETAILED,\n'
 COMPACT_SCHEDULE = '\nSCHEDULE:COMPACT,\n'
 FILE_SCHEDULE = '\nSCHEDULE:FILE,\n'
 NOMASS_MATERIAL = '\nMATERIAL:NOMASS,\n'

hub/exports/building_energy/idf_helper/idf_base.py

@@ -18,11 +18,10 @@ class IdfBase:
       'window_materials': str((output_path / 'window_materials.idf').resolve()),
       'constructions': str((output_path / 'constructions.idf').resolve()),
       'zones': str((output_path / 'zones.idf').resolve()),
-      'surfaces': str((output_path / 'surfaces.idf').resolve()),
-      'fenestration': str((output_path / 'fenestration.idf').resolve()),
       'occupancy': str((output_path / 'occupancy.idf').resolve()),
       'lighting': str((output_path / 'lights.idf').resolve()),
       'appliances': str((output_path / 'appliances.idf').resolve()),
+      'surfaces': str((output_path / 'surfaces.idf').resolve()),
       'shading': str((output_path / 'shading.idf').resolve()),
       'infiltration': str((output_path / 'infiltration.idf').resolve()),
       'ventilation': str((output_path / 'ventilation.idf').resolve()),
@@ -32,7 +31,7 @@ class IdfBase:
     }
     self._files = {}
     for key, value in self._file_paths.items():
-      self._files[key] = open(value, 'w', encoding='UTF-8')
+      self._files[key] = open(value, 'w')
 
     self._idd_file_path = str(idd_file_path)
     self._idf_file_path = str(idf_file_path)

hub/exports/building_energy/idf_helper/idf_file_schedule.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-import hub.helpers.constants as cte
+
 import hub.exports.building_energy.idf_helper as idf_cte
 from hub.exports.building_energy.idf_helper.idf_base import IdfBase
 
@@ -14,8 +14,8 @@ class IdfFileSchedule(IdfBase):
         file_name = str(
           (Path(self._output_path) / f'{schedule_type} schedules {usage.replace("/", "_")}.csv').resolve())
         with open(file_name, 'w', encoding='utf8') as file:
-          for value in schedule.values[0]:
+          for value in schedule.values:
-            file.write(f'{value},\n')
+            file.write(f'{str(value)},\n')
         file = self._files['file_schedules']
         self._write_to_idf_format(file, idf_cte.FILE_SCHEDULE)
         self._write_to_idf_format(file, schedule_name, 'Name')

hub/exports/building_energy/idf_helper/idf_surfaces.py

@@ -6,6 +6,7 @@ from hub.exports.building_energy.idf_helper.idf_base import IdfBase
 class IdfSurfaces(IdfBase):
   @staticmethod
   def add(self, building, zone_name):
+    # Verify if create building surfaces "by hand" it's faster wwr it's missing
     zone_name = f'{zone_name}'
     file = self._files['surfaces']
     for thermal_zone in building.thermal_zones_from_internal_zones:

hub/exports/building_energy/idf_helper/idf_window.py

@@ -1,64 +1,9 @@
-import logging
-
 import hub.exports.building_energy.idf_helper as idf_cte
 import hub.helpers.constants as cte
 from hub.exports.building_energy.idf_helper.idf_base import IdfBase
 
 
 class IdfWindow(IdfBase):
-
   @staticmethod
-  def _to_window_surface(self, surface):
+  def add(self, building, zone_name):
-    window_ratio = surface.associated_thermal_boundaries[0].window_ratio
+    pass
-    x = 0
-    y = 1
-    z = 2
-    coordinates = self._matrix_to_list(surface.solid_polygon.coordinates, self._city.lower_corner)
-    min_z = surface.lower_corner[z]
-    max_z = surface.upper_corner[z]
-    middle = (max_z - min_z) / 2
-    distance = (max_z - min_z) * window_ratio
-    new_max_z = middle + distance / 2
-    new_min_z = middle - distance / 2
-    for index, coordinate in enumerate(coordinates):
-      if coordinate[z] == max_z:
-        coordinates[index] = (coordinate[x], coordinate[y], new_max_z)
-      elif coordinate[z] == min_z:
-        coordinates[index] = (coordinate[x], coordinate[y], new_min_z)
-      else:
-         logging.warning('Z coordinate not in top or bottom during window creation')
-    return coordinates
-
-  @staticmethod
-  def add(self, building):
-    file = self._files['fenestration']
-    for thermal_zone in building.thermal_zones_from_internal_zones:
-      for index, boundary in enumerate(thermal_zone.thermal_boundaries):
-        building_surface_name = f'Building_{building.name}_surface_{index}'
-        is_exposed = boundary.parent_surface.type == cte.WALL
-        if boundary.parent_surface.percentage_shared is not None and boundary.parent_surface.percentage_shared > 0.5 or boundary.window_ratio == 0:
-          is_exposed = False
-        if not is_exposed:
-          continue
-        name = f'Building_{building.name}_window_{index}'
-        construction_name = f'{boundary.construction_name}_window_construction'
-        self._write_to_idf_format(file, idf_cte.WINDOW_SURFACE)
-        self._write_to_idf_format(file, name, 'Name')
-        self._write_to_idf_format(file, 'Window', 'Surface Type')
-        self._write_to_idf_format(file, construction_name, 'Construction Name')
-        self._write_to_idf_format(file, building_surface_name, 'Building Surface Name')
-        self._write_to_idf_format(file, idf_cte.EMPTY, 'Outside Boundary Condition Object')
-        self._write_to_idf_format(file, idf_cte.AUTOCALCULATE, 'View Factor to Ground')
-        self._write_to_idf_format(file, idf_cte.EMPTY, 'Frame and Divider Name')
-        self._write_to_idf_format(file, '1.0', 'Multiplier')
-        self._write_to_idf_format(file, idf_cte.AUTOCALCULATE, 'Number of Vertices')
-        coordinates = IdfWindow._to_window_surface(self, boundary.parent_surface)
-        eol = ','
-        coordinates_length = len(coordinates)
-        for i, coordinate in enumerate(coordinates):
-          vertex = i + 1
-          if vertex == coordinates_length:
-            eol = ';'
-          self._write_to_idf_format(file, coordinate[0], f'Vertex {vertex} Xcoordinate')
-          self._write_to_idf_format(file, coordinate[1], f'Vertex {vertex} Ycoordinate')
-          self._write_to_idf_format(file, coordinate[2], f'Vertex {vertex} Zcoordinate', eol)

hub/exports/building_energy/idf_helper/idf_windows_constructions.py

@@ -4,14 +4,14 @@ from hub.exports.building_energy.idf_helper.idf_base import IdfBase
 
 class IdfWindowsConstructions(IdfBase):
   @staticmethod
-  def add(self, thermal_boundary):
+  def add(self):
-    name = f'{thermal_boundary.construction_name}_window'
+    glazing_index = self._windows_added_to_idf['glazing_index'] + 1
-    if name not in self._windows_added_to_idf:
+    for i in range(1, glazing_index):
-      return  # Material not added or already assigned to construction
+      construction_name = f'window_construction_{i}'
-    construction_name = f'{thermal_boundary.construction_name}_window_construction'
+      material_name = f'glazing_{i}'
       if construction_name not in self._constructions_added_to_idf:
         self._constructions_added_to_idf[construction_name] = True
         file = self._files['constructions']
         self._write_to_idf_format(file, idf_cte.CONSTRUCTION)
         self._write_to_idf_format(file, construction_name, 'Name')
-      self._write_to_idf_format(file, name, 'Outside Layer', ';')
+        self._write_to_idf_format(file, material_name, 'Outside Layer', ';')

hub/exports/building_energy/idf_helper/idf_windows_material.py

@@ -4,12 +4,14 @@ from hub.exports.building_energy.idf_helper.idf_base import IdfBase
 
 class IdfWindowsMaterial(IdfBase):
   @staticmethod
-  def add(self, thermal_boundary, thermal_opening):
+  def add(self, thermal_opening):
-    name = f'{thermal_boundary.construction_name}_window'
+    name = f'{thermal_opening.overall_u_value}_{thermal_opening.g_value}'
     if name not in self._windows_added_to_idf:
+      glazing_index = self._windows_added_to_idf['glazing_index'] + 1
       self._windows_added_to_idf[name] = True
+      self._windows_added_to_idf['glazing_index'] = glazing_index  # increase the count
       file = self._files['window_materials']
       self._write_to_idf_format(file, idf_cte.WINDOW_MATERIAL)
-      self._write_to_idf_format(file, name, 'Name')
+      self._write_to_idf_format(file, f'glazing_{glazing_index}', 'Name')
       self._write_to_idf_format(file, thermal_opening.overall_u_value, 'UFactor')
       self._write_to_idf_format(file, thermal_opening.g_value, 'Solar Heat Gain Coefficient', ';')

tests/test_exports.py

@@ -128,31 +128,15 @@ class TestExports(TestCase):
     """
     export to IDF
     """
-    file = '1588_v1.geojson'
+    file = 'test.geojson'
-    # file = 'test.geojson'
     file_path = (self._example_path / file).resolve()
-    """
     city = GeometryFactory('geojson',
                            path=file_path,
                            height_field='citygml_me',
                            year_of_construction_field='ANNEE_CONS',
                            function_field='CODE_UTILI',
                            function_to_hub=Dictionaries().montreal_function_to_hub_function).city
-    """
+
-    """=-043
-    "name": "01043081",
-        "address": "avenue de l' H\u00f4tel-de-Ville (MTL) 3751",
-        "function": "6911",
-        "height": 21,
-        "year_of_construction": 1964,
-    """
-    city = GeometryFactory('geojson',
-                           path=file_path,
-                           height_field='height',
-                           year_of_construction_field='year_of_construction',
-                           function_field='function',
-                           function_to_hub=Dictionaries().montreal_function_to_hub_function).city
-    # """
     self.assertIsNotNone(city, 'city is none')
      #EnergyBuildingsExportsFactory('idf', city, self._output_path).export()
     ConstructionFactory('nrcan', city).enrich()
@@ -160,8 +144,7 @@ class TestExports(TestCase):
     UsageFactory('nrcan', city).enrich()
     WeatherFactory('epw', city).enrich()
     try:
-      idf = EnergyBuildingsExportsFactory('cerc_idf', city, self._output_path).export()
+      EnergyBuildingsExportsFactory('cerc_idf', city, self._output_path)._cerc_idf
-      idf.run()
 
     except Exception:
       self.fail("Idf ExportsFactory raised ExceptionType unexpectedly!")