bug fix in result reading

hub/exports/energy_building_exports_factory.py

@@ -21,6 +21,7 @@ class EnergyBuildingsExportsFactory:
   """
   Energy Buildings exports factory class
   """
+
   def __init__(self, handler, city, path, custom_insel_block='d18599', target_buildings=None, weather_file=None):
     self._city = city
     self._export_type = '_' + handler.lower()
@@ -72,8 +73,7 @@ class EnergyBuildingsExportsFactory:
       with open(weather_path, 'wb') as epw_file:
         epw_file.write(requests.get(url, allow_redirects=True).content)
     return CercIdf(self._city, self._path, (idf_data_path / 'base.idf'), (idf_data_path / 'Energy+.idd'), weather_path,
-               target_buildings=self._target_buildings)
+                   target_buildings=self._target_buildings)
-
 
   @property
   def _insel_monthly_energy_balance(self):

hub/imports/results/energy_plus.py

@@ -48,10 +48,13 @@ class EnergyPlus:
     :return: None
     """
     for building in self._city.buildings:
-      building_energy_demands = self._building_energy_demands.copy()
+      _energy_demands = {}
       for header in self._building_energy_demands:
+        print(header)
         if header == 'Zone Ideal Loads Supply Air Total Heating Energy [J](Hourly)':
           field_name = f'{building.name} IDEAL LOADS AIR SYSTEM:{header}'
+        elif header == 'Zone Ideal Loads Supply Air Total Cooling Energy [J](Hourly)':
+          field_name = f'{building.name} IDEAL LOADS AIR SYSTEM:{header}'
         else:
           field_name = f'{building.name}:{header}'
         position = -1
@@ -60,22 +63,25 @@ class EnergyPlus:
         if position == -1:
           continue
         for line in self._lines:
-          building_energy_demands[header].append(line[position])
+          if header not in _energy_demands.keys():
+            _energy_demands[header] = []
+          _energy_demands[header].append(line[position])
       # print(building_energy_demands['Zone Ideal Loads Supply Air Total Heating Energy [J](Hourly)'])
-      EnergyPlus._set_building_demands(building, building_energy_demands)
+      EnergyPlus._set_building_demands(building, _energy_demands)
 
   @staticmethod
-  def _set_building_demands(building, building_energy_demands):
+  def _set_building_demands(building, energy_demands):
-    heating = [float(x) for x in building_energy_demands['Zone Ideal Loads Supply Air Total Heating Energy [J](Hourly)']]
+    print(energy_demands.keys())
-    cooling = [float(x) for x in building_energy_demands['Zone Ideal Loads Supply Air Total Cooling Energy [J](Hourly)']]
+    heating = [float(x) for x in energy_demands['Zone Ideal Loads Supply Air Total Heating Energy [J](Hourly)']]
-    dhw = [float(x) * cte.WATTS_HOUR_TO_JULES for x in building_energy_demands['Water Use Equipment Heating Rate [W](Hourly)']]
+    cooling = [float(x) for x in energy_demands['Zone Ideal Loads Supply Air Total Cooling Energy [J](Hourly)']]
-    appliances = [float(x) * cte.WATTS_HOUR_TO_JULES for x in building_energy_demands['Other Equipment Electricity Rate [W](Hourly)']]
+    dhw = [float(x) * cte.WATTS_HOUR_TO_JULES for x in energy_demands['Water Use Equipment Heating Rate [W](Hourly)']]
-    lighting = [float(x) * cte.WATTS_HOUR_TO_JULES for x in building_energy_demands['Zone Lights Electricity Rate [W](Hourly)']]
+    appliances = [float(x) * cte.WATTS_HOUR_TO_JULES for x in energy_demands['Other Equipment Electricity Rate [W](Hourly)']]
-    building.heating_demand[cte.HOUR] = heating.copy()
+    lighting = [float(x) * cte.WATTS_HOUR_TO_JULES for x in energy_demands['Zone Lights Electricity Rate [W](Hourly)']]
-    building.cooling_demand[cte.HOUR] = cooling.copy()
+    building.heating_demand[cte.HOUR] = heating
-    building.domestic_hot_water_heat_demand[cte.HOUR] = dhw.copy()
+    building.cooling_demand[cte.HOUR] = cooling
-    building.appliances_electrical_demand[cte.HOUR] = appliances.copy()
+    building.domestic_hot_water_heat_demand[cte.HOUR] = dhw
-    building.lighting_electrical_demand[cte.HOUR] = lighting.copy()
+    building.appliances_electrical_demand[cte.HOUR] = appliances
+    building.lighting_electrical_demand[cte.HOUR] = lighting
     building.heating_demand[cte.MONTH] = []
     building.cooling_demand[cte.MONTH] = []
     building.domestic_hot_water_heat_demand[cte.MONTH] = []
@@ -83,25 +89,17 @@ class EnergyPlus:
     building.lighting_electrical_demand[cte.MONTH] = []
 
     start = 0
-    """
+
     for hours in cte.HOURS_A_MONTH.values():
       end = hours + start
-      if end == 8760:
-        print(building.heating_demand[cte.HOUR][start: end])
       building.heating_demand[cte.MONTH].append(sum(building.heating_demand[cte.HOUR][start: end]))
       building.cooling_demand[cte.MONTH].append(sum(building.cooling_demand[cte.HOUR][start: end]))
       building.domestic_hot_water_heat_demand[cte.MONTH].append(sum(dhw[start: end]))
       building.appliances_electrical_demand[cte.MONTH].append(sum(appliances[start: end]))
       building.lighting_electrical_demand[cte.MONTH].append(sum(lighting[start: end]))
       start = end
-    """
     building.heating_demand[cte.YEAR] = [sum(building.heating_demand[cte.HOUR])]
     building.cooling_demand[cte.YEAR] = [sum(building.cooling_demand[cte.HOUR])]
     building.domestic_hot_water_heat_demand[cte.YEAR] = [sum(building.domestic_hot_water_heat_demand[cte.HOUR])]
     building.appliances_electrical_demand[cte.YEAR] = [sum(building.appliances_electrical_demand[cte.HOUR])]
     building.lighting_electrical_demand[cte.YEAR] = [sum(building.lighting_electrical_demand[cte.HOUR])]
-
-    #print(f'jan: {building.heating_demand[cte.MONTH][0]}, year {building.heating_demand[cte.YEAR]}')
-
-
-

tests/test_exports.py

@@ -129,7 +129,6 @@ class TestExports(TestCase):
     """
     export to IDF
     """
-    # file = '1588_v1.geojson'
     file = 'test.geojson'
     file_path = (self._example_path / file).resolve()
     city = GeometryFactory('geojson',
@@ -139,9 +138,30 @@ class TestExports(TestCase):
                            function_field='CODE_UTILI',
                            function_to_hub=Dictionaries().montreal_function_to_hub_function).city
     self.assertIsNotNone(city, 'city is none')
-     #EnergyBuildingsExportsFactory('idf', city, self._output_path).export()
+    EnergyBuildingsExportsFactory('idf', city, self._output_path).export()
+    ConstructionFactory('nrcan', city).enrich()
+    EnergyBuildingsExportsFactory('idf', city, self._output_path).export()
+    UsageFactory('nrcan', city).enrich()
+    WeatherFactory('epw', city).enrich()
+    try:
+      idf = EnergyBuildingsExportsFactory('idf', city, self._output_path).export()
+    except Exception:
+      self.fail("Idf ExportsFactory raised ExceptionType unexpectedly!")
+
+  def test_cerc_idf_export(self):
+    """
+    export to IDF
+    """
+    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
+    self.assertIsNotNone(city, 'city is none')
     ConstructionFactory('nrcan', city).enrich()
-    # EnergyBuildingsExportsFactory('idf', city, self._output_path).export()
     UsageFactory('nrcan', city).enrich()
     WeatherFactory('epw', city).enrich()
     try:
@@ -151,7 +171,6 @@ class TestExports(TestCase):
       ResultFactory('cerc_idf', city, csv_output_path).enrich()
       self.assertTrue(csv_output_path.is_file())
       for building in city.buildings:
-        print(building.name)
         self.assertIsNotNone(building.heating_demand)
         self.assertIsNotNone(building.cooling_demand)
         self.assertIsNotNone(building.domestic_hot_water_heat_demand)
@@ -159,8 +178,7 @@ class TestExports(TestCase):
         self.assertIsNotNone(building.appliances_electrical_demand)
         total_demand = sum(building.heating_demand[cte.HOUR])
         total_demand_month = sum(building.heating_demand[cte.MONTH])
-        print(building.heating_demand[cte.YEAR])
-        # print(building.heating_demand[cte.YEAR][0], total_demand_month, total_demand)
         self.assertAlmostEqual(total_demand, building.heating_demand[cte.YEAR][0], 2)
+        self.assertAlmostEqual(total_demand_month, building.heating_demand[cte.YEAR][0], 2)
     except Exception:
       self.fail("Idf ExportsFactory raised ExceptionType unexpectedly!")

tests/test_results_import.py

@@ -92,48 +92,3 @@ class TestResultsImport(TestCase):
       building.cooling_demand[cte.HOUR] = values
       self.assertIsNotNone(building.heating_peak_load)
       self.assertIsNotNone(building.cooling_peak_load)
-
-  def test_energy_plus_results_import(self):
-    # todo: this tests aren't actually testing the functionality
-    ResultFactory('energy_plus_single_building', self._city, self._example_path).enrich()
-    for building in self._city.buildings:
-      csv_output_name = f'{building.name}_out.csv'
-      csv_output_path = (self._example_path / csv_output_name).resolve()
-      if csv_output_path.is_file():
-        self.assertEqual(building.name, '12')
-        self.assertIsNotNone(building.heating_demand)
-        self.assertIsNotNone(building.cooling_demand)
-        self.assertIsNotNone(building.domestic_hot_water_heat_demand)
-        self.assertIsNotNone(building.lighting_electrical_demand)
-        self.assertIsNotNone(building.appliances_electrical_demand)
-        total_demand = sum(building.heating_demand[cte.HOUR])
-        self.assertAlmostEqual(total_demand, building.heating_demand[cte.YEAR][0], 3)
-        total_demand = sum(building.heating_demand[cte.MONTH])
-        self.assertEqual(total_demand, building.heating_demand[cte.YEAR][0], 3)
-      if building.name != '12':
-        self.assertDictEqual(building.heating_demand, {})
-        self.assertDictEqual(building.cooling_demand, {})
-        self.assertDictEqual(building.domestic_hot_water_heat_demand, {})
-        self.assertDictEqual(building.lighting_electrical_demand, {})
-        self.assertDictEqual(building.appliances_electrical_demand, {})
-
-  def test_energy_plus_multiple_buildings_results_import(self):
-    # todo: this tests aren't actually testing the functionality
-    ResultFactory('energy_plus_multiple_buildings', self._city, self._example_path).enrich()
-    csv_output_name = f'{self._city.name}_out.csv'
-    csv_output_path = (self._example_path / csv_output_name).resolve()
-    if csv_output_path.is_file():
-      for building in self._city.buildings:
-        self.assertIsNotNone(building.heating_demand)
-        self.assertIsNotNone(building.cooling_demand)
-        self.assertIsNotNone(building.domestic_hot_water_heat_demand)
-        self.assertIsNotNone(building.lighting_electrical_demand)
-        self.assertIsNotNone(building.appliances_electrical_demand)
-        total_demand = sum(building.heating_demand[cte.HOUR])
-        self.assertAlmostEqual(total_demand, building.heating_demand[cte.YEAR][0], 2)
-        total_demand = sum(building.heating_demand[cte.MONTH])
-        self.assertEqual(total_demand, building.heating_demand[cte.YEAR][0], 2)
-
-  def test_cerc_idf_results(self):
-    csv_output_path = (self._output_path / f'Montreal_out.csv').resolve()
-    ResultFactory('cerc_idf', self._city, csv_output_path).enrich()