city_retrofit/hub/exports/building_energy/idf.py

"""
Idf exports one building to idf format
SPDX - License - Identifier: LGPL - 3.0 - or -later
Copyright © 2022 Concordia CERC group
Project Coder Guille Guillermo.GutierrezMorote@concordia.ca
Code contributors: Pilar Monsalvete Alvarez de Uribarri pilar.monsalvete@concordia.ca
                   Oriol Gavalda Torrellas oriol.gavalda@concordia.ca
"""
import copy
from pathlib import Path
from geomeppy import IDF
import hub.helpers.constants as cte
from hub.city_model_structure.attributes.schedule import Schedule
from hub.city_model_structure.building_demand.thermal_zone import ThermalZone
from hub.helpers.configuration_helper import ConfigurationHelper


class Idf:
  """
  Exports city to IDF
  """
  _BUILDING = 'BUILDING'
  _ZONE = 'ZONE'
  _LIGHTS = 'LIGHTS'
  _APPLIANCES = 'OTHEREQUIPMENT'
  _PEOPLE = 'PEOPLE'
  _DHW = 'WATERUSE:EQUIPMENT'
  _THERMOSTAT = 'HVACTEMPLATE:THERMOSTAT'
  _IDEAL_LOAD_AIR_SYSTEM = 'HVACTEMPLATE:ZONE:IDEALLOADSAIRSYSTEM'
  _SURFACE = 'BUILDINGSURFACE:DETAILED'
  _SHADING = 'SHADING:BUILDING:DETAILED'
  _SHADING_PROPERTY = 'SHADINGPROPERTY:REFLECTANCE'
  _BUILDING_SURFACE = 'BuildingSurfaceDetailed'
  _CONSTRUCTION = 'CONSTRUCTION'
  _MATERIAL = 'MATERIAL'
  _MATERIAL_NOMASS = 'MATERIAL:NOMASS'
  _MATERIAL_ROOFVEGETATION = 'MATERIAL:ROOFVEGETATION'

  _WINDOW = 'FENESTRATIONSURFACE:DETAILED'
  _WINDOW_MATERIAL_SIMPLE = 'WINDOWMATERIAL:SIMPLEGLAZINGSYSTEM'
  _ROUGHNESS = 'MediumRough'
  _INFILTRATION = 'ZONEINFILTRATION:DESIGNFLOWRATE'
  _VENTILATION = 'ZONEVENTILATION:DESIGNFLOWRATE'

  _HOURLY_SCHEDULE = 'SCHEDULE:DAY:HOURLY'
  _COMPACT_SCHEDULE = 'SCHEDULE:COMPACT'
  _FILE_SCHEDULE = 'SCHEDULE:FILE'
  _SCHEDULE_LIMIT = 'SCHEDULETYPELIMITS'
  _ON_OFF = 'On/Off'
  _FRACTION = 'Fraction'
  _ANY_NUMBER = 'Any Number'
  _CONTINUOUS = 'Continuous'
  _DISCRETE = 'Discrete'
  _SIZING_PERIODS = 'SIZINGPERIOD:DESIGNDAY'
  _LOCATION = 'SITE:LOCATION'
  _SIMPLE = 'Simple'

  idf_surfaces = {
    cte.WALL: 'wall',
    cte.GROUND: 'floor',
    cte.ROOF: 'roof'
  }
  idf_type_limits = {
    cte.ON_OFF: 'on/off',
    cte.FRACTION: 'Fraction',
    cte.ANY_NUMBER: 'Any Number',
    cte.CONTINUOUS: 'Continuous',
    cte.DISCRETE: 'Discrete'
  }
  idf_day_types = {
    cte.MONDAY: 'Monday',
    cte.TUESDAY: 'Tuesday',
    cte.WEDNESDAY: 'Wednesday',
    cte.THURSDAY: 'Thursday',
    cte.FRIDAY: 'Friday',
    cte.SATURDAY: 'Saturday',
    cte.SUNDAY: 'Sunday',
    cte.HOLIDAY: 'Holidays',
    cte.WINTER_DESIGN_DAY: 'WinterDesignDay',
    cte.SUMMER_DESIGN_DAY: 'SummerDesignDay'
  }

  def __init__(self, city, output_path, idf_file_path, idd_file_path, epw_file_path, export_type="Surfaces",
               target_buildings=None):
    self._city = city
    self._sanity_check()
    self._output_path = str(output_path.resolve())
    self._output_file = str((output_path / f'{city.name}.idf').resolve())
    self._export_type = export_type
    self._idd_file_path = str(idd_file_path)
    self._idf_file_path = str(idf_file_path)
    self._epw_file_path = str(epw_file_path)
    IDF.setiddname(self._idd_file_path)
    self._idf = IDF(self._idf_file_path, self._epw_file_path)
    self._idf.newidfobject(self._SCHEDULE_LIMIT, Name=self._ANY_NUMBER)
    self._idf.newidfobject(self._SCHEDULE_LIMIT, Name=self._FRACTION, Lower_Limit_Value=0.0, Upper_Limit_Value=1.0,
                           Numeric_Type=self._CONTINUOUS)
    self._idf.newidfobject(self._SCHEDULE_LIMIT, Name=self._ON_OFF, Lower_Limit_Value=0, Upper_Limit_Value=1,
                           Numeric_Type=self._DISCRETE)
    self._target_buildings = target_buildings
    self._adjacent_buildings = []
    if target_buildings is None:
      self._target_buildings = [building.name for building in self._city.buildings]
    else:
      for building_name in target_buildings:
        building = city.city_object(building_name)
        if building.neighbours is not None:
          self._adjacent_buildings += building.neighbours
    self._export()

  def _sanity_check(self):
    levels_of_detail = self._city.level_of_detail
    if levels_of_detail.geometry is None:
      raise AttributeError('Level of detail of geometry not assigned')
    if levels_of_detail.geometry < 1:
      raise AttributeError(f'Level of detail of geometry = {levels_of_detail.geometry}. Required minimum level 1')
    if levels_of_detail.construction is None:
      raise AttributeError('Level of detail of construction not assigned')
    if levels_of_detail.construction < 2:
      raise AttributeError(f'Level of detail of construction = {levels_of_detail.construction}. Required minimum level 2')
    if levels_of_detail.usage is None:
      raise AttributeError('Level of detail of usage not assigned')
    if levels_of_detail.usage < 2:
      raise AttributeError(f'Level of detail of usage = {levels_of_detail.usage}. Required minimum level 2')
    if levels_of_detail.weather is None:
      raise AttributeError('Level of detail of weather not assigned')
    if levels_of_detail.weather < 2:
      raise AttributeError(f'Level of detail of weather = {levels_of_detail.weather}. Required minimum level 2')

  @staticmethod
  def _matrix_to_list(points, lower_corner):
    lower_x = lower_corner[0]
    lower_y = lower_corner[1]
    lower_z = lower_corner[2]
    points_list = []
    for point in points:
      point_tuple = (point[0] - lower_x, point[1] - lower_y, point[2] - lower_z)
      points_list.append(point_tuple)
    return points_list

  @staticmethod
  def _matrix_to_2d_list(points):
    points_list = []
    for point in points:
      point_tuple = (point[0], point[1])
      points_list.append(point_tuple)
    return points_list

  def _add_material(self, layer):
    for material in self._idf.idfobjects[self._MATERIAL]:
      if material.Name == layer.material_name:
        return
    for material in self._idf.idfobjects[self._MATERIAL_NOMASS]:
      if material.Name == layer.material_name:
        return
    if layer.no_mass:
      self._idf.newidfobject(self._MATERIAL_NOMASS,
                             Name=layer.material_name,
                             Roughness=self._ROUGHNESS,
                             Thermal_Resistance=layer.thermal_resistance
                             )
    else:
      self._idf.newidfobject(self._MATERIAL,
                             Name=layer.material_name,
                             Roughness=self._ROUGHNESS,
                             Thickness=layer.thickness,
                             Conductivity=layer.conductivity,
                             Density=layer.density,
                             Specific_Heat=layer.specific_heat,
                             Thermal_Absorptance=layer.thermal_absorptance,
                             Solar_Absorptance=layer.solar_absorptance,
                             Visible_Absorptance=layer.visible_absorptance
                             )

  @staticmethod
  def _create_infiltration_schedules(thermal_zone):
    _infiltration_schedules = []
    if thermal_zone.thermal_control is None:
      return []
    for hvac_availability_schedule in thermal_zone.thermal_control.hvac_availability_schedules:
      _schedule = Schedule()
      _schedule.type = cte.INFILTRATION
      _schedule.data_type = cte.FRACTION
      _schedule.time_step = cte.HOUR
      _schedule.time_range = cte.DAY
      _schedule.day_types = copy.deepcopy(hvac_availability_schedule.day_types)
      _infiltration_values = []
      for hvac_value in hvac_availability_schedule.values:
        if hvac_value == 0:
          _infiltration_values.append(1.0)
        else:
          if thermal_zone.infiltration_rate_system_off == 0:
            _infiltration_values.append(0.0)
          else:
            _infiltration_values.append(
              thermal_zone.infiltration_rate_system_on / thermal_zone.infiltration_rate_system_off)
      _schedule.values = _infiltration_values
      _infiltration_schedules.append(_schedule)
    return _infiltration_schedules

  @staticmethod
  def _create_ventilation_schedules(thermal_zone):
    _ventilation_schedules = []
    if thermal_zone.thermal_control is None:
      return []
    for hvac_availability_schedule in thermal_zone.thermal_control.hvac_availability_schedules:
      _schedule = Schedule()
      _schedule.type = cte.VENTILATION
      _schedule.data_type = cte.FRACTION
      _schedule.time_step = cte.HOUR
      _schedule.time_range = cte.DAY
      _schedule.day_types = copy.deepcopy(hvac_availability_schedule.day_types)
      _ventilation_schedules = thermal_zone.thermal_control.hvac_availability_schedules
    return _ventilation_schedules

  @staticmethod
  def _create_yearly_values_schedules(schedule_type, values):
    _schedule = Schedule()
    _schedule.type = schedule_type
    _schedule.data_type = cte.ANY_NUMBER
    _schedule.time_step = cte.HOUR
    _schedule.time_range = cte.YEAR
    _schedule.day_types = ['monday',
                           'tuesday',
                           'wednesday',
                           'thursday',
                           'friday',
                           'saturday',
                           'sunday',
                           'holiday',
                           'winter_design_day',
                           'summer_design_day']
    _schedule.values = values
    return [_schedule]

  @staticmethod
  def _create_constant_value_schedules(schedule_type, value):
    _schedule = Schedule()
    _schedule.type = schedule_type
    _schedule.data_type = cte.ANY_NUMBER
    _schedule.time_step = cte.HOUR
    _schedule.time_range = cte.DAY
    _schedule.day_types = ['monday',
                           'tuesday',
                           'wednesday',
                           'thursday',
                           'friday',
                           'saturday',
                           'sunday',
                           'holiday',
                           'winter_design_day',
                           'summer_design_day']
    _schedule.values = [value for _ in range(0, 24)]
    return [_schedule]

  def _add_standard_compact_hourly_schedule(self, usage, schedule_type, schedules):
    for schedule in self._idf.idfobjects[self._COMPACT_SCHEDULE]:
      if schedule.Name == f'{schedule_type} schedules {usage}':
        return
    _kwargs = {'Name': f'{schedule_type} schedules {usage}',
               'Schedule_Type_Limits_Name': self.idf_type_limits[schedules[0].data_type],
               'Field_1': 'Through: 12/31'}
    counter = 1
    for j, schedule in enumerate(schedules):
      _val = schedule.values
      _new_field = ''
      for day_type in schedule.day_types:
        _new_field += f' {self.idf_day_types[day_type]}'
      _kwargs[f'Field_{j * 25 + 2}'] = f'For:{_new_field}'
      counter += 1
      for i, _ in enumerate(_val):
        _kwargs[f'Field_{j * 25 + 3 + i}'] = f'Until: {i + 1:02d}:00,{_val[i]}'
        counter += 1
    _kwargs[f'Field_{counter + 1}'] = 'For AllOtherDays'
    _kwargs[f'Field_{counter + 2}'] = 'Until: 24:00,0.0'
    self._idf.newidfobject(self._COMPACT_SCHEDULE, **_kwargs)

  def _write_schedules_file(self, usage, schedule):
    file_name = str((Path(self._output_path) / f'{schedule.type} schedules {usage}.csv').resolve())
    with open(file_name, 'w', encoding='utf8') as file:
      for value in schedule.values:
        file.write(f'{str(value)},\n')
    return Path(file_name).name

  def _add_file_schedule(self, usage, schedule, file_name):
    _schedule = self._idf.newidfobject(self._FILE_SCHEDULE, Name=f'{schedule.type} schedules {usage}')
    _schedule.Schedule_Type_Limits_Name = self.idf_type_limits[schedule.data_type]
    _schedule.File_Name = file_name
    _schedule.Column_Number = 1
    _schedule.Rows_to_Skip_at_Top = 0
    _schedule.Number_of_Hours_of_Data = 8760
    _schedule.Column_Separator = 'Comma'
    _schedule.Interpolate_to_Timestep = 'No'
    _schedule.Minutes_per_Item = 60

  def _add_schedules(self, usage, schedule_type, new_schedules):
    if len(new_schedules) < 1:
      return
    schedule_from_file = False
    for schedule in new_schedules:
      if len(schedule.values) > 168:  # Hours in one week
        schedule_from_file = True
    if schedule_from_file:
      for schedule in self._idf.idfobjects[self._FILE_SCHEDULE]:
        if schedule.Name == f'{schedule_type} schedules {usage}':
          return
      file_name = self._write_schedules_file(usage, new_schedules[0])
      self._add_file_schedule(usage, new_schedules[0], file_name)
      return

    for schedule in self._idf.idfobjects[self._HOURLY_SCHEDULE]:
      if schedule.Name == f'{schedule_type} schedules {usage}':
        return
    self._add_standard_compact_hourly_schedule(usage, schedule_type, new_schedules)
    return

  def _add_construction(self, thermal_boundary):
    for construction in self._idf.idfobjects[self._CONSTRUCTION]:
      if thermal_boundary.parent_surface.vegetation is not None:
        vegetation_name = f'{thermal_boundary.construction_name}_{thermal_boundary.parent_surface.vegetation.name}'
        if construction.Name == vegetation_name:
          return
      else:
        if construction.Name == thermal_boundary.construction_name:
          return
    if thermal_boundary.layers is None:
      for material in self._idf.idfobjects[self._MATERIAL]:
        if material.Name == "DefaultMaterial":
          return
      self._idf.set_default_constructions()
      return
    for layer in thermal_boundary.layers:
      self._add_material(layer)
    layers = thermal_boundary.layers
    # The constructions should have at least one layer
    if thermal_boundary.parent_surface.vegetation is not None:
      vegetation_name = f'{thermal_boundary.construction_name}_{thermal_boundary.parent_surface.vegetation.name}'
      _kwargs = {'Name': vegetation_name,
                 'Outside_Layer': thermal_boundary.parent_surface.vegetation.name}
      for i in range(0, len(layers) - 1):
        _kwargs[f'Layer_{i + 2}'] = layers[i].material_name
    else:
      _kwargs = {'Name': thermal_boundary.construction_name, 'Outside_Layer': layers[0].material_name}
      for i in range(1, len(layers) - 1):
        _kwargs[f'Layer_{i + 1}'] = layers[i].material_name
    self._idf.newidfobject(self._CONSTRUCTION, **_kwargs)

  def _add_window_construction_and_material(self, thermal_opening):
    for window_material in self._idf.idfobjects[self._WINDOW_MATERIAL_SIMPLE]:
      if window_material['UFactor'] == thermal_opening.overall_u_value and \
         window_material['Solar_Heat_Gain_Coefficient'] == thermal_opening.g_value:
        return

    order = str(len(self._idf.idfobjects[self._WINDOW_MATERIAL_SIMPLE]) + 1)
    material_name = 'glazing_' + order
    _kwargs = {'Name': material_name, 'UFactor': thermal_opening.overall_u_value,
               'Solar_Heat_Gain_Coefficient': thermal_opening.g_value}
    self._idf.newidfobject(self._WINDOW_MATERIAL_SIMPLE, **_kwargs)

    window_construction_name = 'window_construction_' + order
    _kwargs = {'Name': window_construction_name, 'Outside_Layer': material_name}
    self._idf.newidfobject(self._CONSTRUCTION, **_kwargs)

  def _add_zone(self, thermal_zone, name):
    for zone in self._idf.idfobjects['ZONE']:
      if zone.Name == name:
        return
    self._idf.newidfobject(self._ZONE, Name=name, Volume=thermal_zone.volume)
    self._add_heating_system(thermal_zone, name)

  def _add_thermostat(self, thermal_zone):
    thermostat_name = f'Thermostat {thermal_zone.usage_name}'
    for thermostat in self._idf.idfobjects[self._THERMOSTAT]:
      if thermostat.Name == thermostat_name:
        return thermostat
    return self._idf.newidfobject(
      self._THERMOSTAT,
      Name=thermostat_name,
      Heating_Setpoint_Schedule_Name=f'Heating thermostat schedules {thermal_zone.usage_name}',
      Cooling_Setpoint_Schedule_Name=f'Cooling thermostat schedules {thermal_zone.usage_name}'
    )

  def _add_heating_system(self, thermal_zone, zone_name):
    for air_system in self._idf.idfobjects[self._IDEAL_LOAD_AIR_SYSTEM]:
      if air_system.Zone_Name == zone_name:
        return
    thermostat = self._add_thermostat(thermal_zone)
    self._idf.newidfobject(self._IDEAL_LOAD_AIR_SYSTEM,
                           Zone_Name=zone_name,
                           System_Availability_Schedule_Name=f'HVAC AVAIL SCHEDULES {thermal_zone.usage_name}',
                           Heating_Availability_Schedule_Name=f'HVAC AVAIL SCHEDULES {thermal_zone.usage_name}',
                           Cooling_Availability_Schedule_Name=f'HVAC AVAIL SCHEDULES {thermal_zone.usage_name}',
                           Template_Thermostat_Name=thermostat.Name)

  def _add_occupancy(self, thermal_zone, zone_name):
    number_of_people = thermal_zone.occupancy.occupancy_density * thermal_zone.total_floor_area
    fraction_radiant = 0
    total_sensible = (
      thermal_zone.occupancy.sensible_radiative_internal_gain + thermal_zone.occupancy.sensible_convective_internal_gain
    )
    if total_sensible != 0:
      fraction_radiant = thermal_zone.occupancy.sensible_radiative_internal_gain / total_sensible

    self._idf.newidfobject(self._PEOPLE,
                           Name=f'{zone_name}_occupancy',
                           Zone_or_ZoneList_or_Space_or_SpaceList_Name=zone_name,
                           Number_of_People_Schedule_Name=f'Occupancy schedules {thermal_zone.usage_name}',
                           Number_of_People_Calculation_Method="People",
                           Number_of_People=number_of_people,
                           Fraction_Radiant=fraction_radiant,
                           Activity_Level_Schedule_Name=f'Activity Level schedules {thermal_zone.usage_name}'
                           )

  def _add_lighting(self, thermal_zone: ThermalZone, zone_name: str):
    fraction_radiant = thermal_zone.lighting.radiative_fraction
    method = 'Watts/Area'
    storeys_number = int(thermal_zone.total_floor_area / thermal_zone.footprint_area)
    watts_per_zone_floor_area = thermal_zone.lighting.density * storeys_number
    subcategory = f'ELECTRIC EQUIPMENT#{zone_name}#GeneralLights'

    self._idf.newidfobject(self._LIGHTS,
                           Name=f'{zone_name}_lights',
                           Zone_or_ZoneList_or_Space_or_SpaceList_Name=zone_name,
                           Schedule_Name=f'Lighting schedules {thermal_zone.usage_name}',
                           Design_Level_Calculation_Method=method,
                           Watts_per_Zone_Floor_Area=watts_per_zone_floor_area,
                           Fraction_Radiant=fraction_radiant,
                           EndUse_Subcategory=subcategory
                           )

  def _add_appliances(self, thermal_zone, zone_name):
    fuel_type = 'Electricity'
    fraction_radiant = thermal_zone.appliances.radiative_fraction
    fraction_latent = thermal_zone.appliances.latent_fraction
    method = 'Watts/Area'
    storeys_number = int(thermal_zone.total_floor_area / thermal_zone.footprint_area)
    watts_per_zone_floor_area = thermal_zone.appliances.density * storeys_number
    subcategory = f'ELECTRIC EQUIPMENT#{zone_name}#InteriorEquipment'
    self._idf.newidfobject(self._APPLIANCES,
                           Fuel_Type=fuel_type,
                           Name=f'{zone_name}_appliance',
                           Zone_or_ZoneList_or_Space_or_SpaceList_Name=zone_name,
                           Schedule_Name=f'Appliance schedules {thermal_zone.usage_name}',
                           Design_Level_Calculation_Method=method,
                           Power_per_Zone_Floor_Area=watts_per_zone_floor_area,
                           Fraction_Latent=fraction_latent,
                           Fraction_Radiant=fraction_radiant,
                           EndUse_Subcategory=subcategory
                           )

  def _add_infiltration(self, thermal_zone, zone_name):
    schedule = f'Infiltration schedules {thermal_zone.usage_name}'
    _infiltration = thermal_zone.infiltration_rate_system_off * cte.HOUR_TO_SECONDS
    self._idf.newidfobject(self._INFILTRATION,
                           Name=f'{zone_name}_infiltration',
                           Zone_or_ZoneList_or_Space_or_SpaceList_Name=zone_name,
                           Schedule_Name=schedule,
                           Design_Flow_Rate_Calculation_Method='AirChanges/Hour',
                           Air_Changes_per_Hour=_infiltration
                           )

  def _add_ventilation(self, thermal_zone, zone_name):
    schedule = f'Ventilation schedules {thermal_zone.usage_name}'
    _air_change = thermal_zone.mechanical_air_change * cte.HOUR_TO_SECONDS
    self._idf.newidfobject(self._VENTILATION,
                           Name=f'{zone_name}_ventilation',
                           Zone_or_ZoneList_or_Space_or_SpaceList_Name=zone_name,
                           Schedule_Name=schedule,
                           Design_Flow_Rate_Calculation_Method='AirChanges/Hour',
                           Air_Changes_per_Hour=_air_change
                           )

  def _add_dhw(self, thermal_zone, zone_name):
    peak_flow_rate = thermal_zone.domestic_hot_water.peak_flow * thermal_zone.total_floor_area
    self._idf.newidfobject(self._DHW,
                           Name=f'DHW {zone_name}',
                           Peak_Flow_Rate=peak_flow_rate,
                           Flow_Rate_Fraction_Schedule_Name=f'DHW_prof schedules {thermal_zone.usage_name}',
                           Target_Temperature_Schedule_Name=f'DHW_temp schedules {thermal_zone.usage_name}',
                           Hot_Water_Supply_Temperature_Schedule_Name=f'DHW_temp schedules {thermal_zone.usage_name}',
                           Cold_Water_Supply_Temperature_Schedule_Name=f'cold_temp schedules {zone_name}',
                           EndUse_Subcategory=f'DHW {zone_name}',
                           Zone_Name=zone_name
                           )

  def _rename_building(self, city_name):
    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'

  def _remove_sizing_periods(self):
    while len(self._idf.idfobjects[self._SIZING_PERIODS]) > 0:
      self._idf.popidfobject(self._SIZING_PERIODS, 0)

  def _remove_location(self):
    self._idf.popidfobject(self._LOCATION, 0)

  def _export(self):
    """
    Export the idf file into the given path.

    If buildings to calculate are provided, only those will appear in the output variables, otherwise all the city
    buildings will be calculated.
    If adjacent buildings are provided those buildings will be calculated, but will not appear in the output variables.

    export type = "Surfaces|Block"
    """

    self._remove_location()
    self._remove_sizing_periods()
    self._rename_building(self._city.name)
    self._lod = self._city.level_of_detail.geometry
    for building in self._city.buildings:
      for internal_zone in building.internal_zones:
        if internal_zone.thermal_zones_from_internal_zones is None:
          self._add_shading(building)  # if the building has not archetype use it as shadow object
          continue
        for thermal_zone in internal_zone.thermal_zones_from_internal_zones:
          for thermal_boundary in thermal_zone.thermal_boundaries:
            self._add_construction(thermal_boundary)
            if thermal_boundary.parent_surface.vegetation is not None:
              self._add_vegetation_material(thermal_boundary.parent_surface.vegetation)
            for thermal_opening in thermal_boundary.thermal_openings:
              self._add_window_construction_and_material(thermal_opening)
          usage = thermal_zone.usage_name
          if building.name in self._target_buildings or building.name in self._adjacent_buildings:
            _new_schedules = self._create_infiltration_schedules(thermal_zone)
            self._add_schedules(usage, 'Infiltration', _new_schedules)
            _new_schedules = self._create_ventilation_schedules(thermal_zone)
            self._add_schedules(usage, 'Ventilation', _new_schedules)
            self._add_schedules(usage, 'Occupancy', thermal_zone.occupancy.occupancy_schedules)
            self._add_schedules(usage, 'HVAC AVAIL', thermal_zone.thermal_control.hvac_availability_schedules)
            self._add_schedules(usage, 'Heating thermostat', thermal_zone.thermal_control.heating_set_point_schedules)
            self._add_schedules(usage, 'Cooling thermostat', thermal_zone.thermal_control.cooling_set_point_schedules)
            self._add_schedules(usage, 'Lighting', thermal_zone.lighting.schedules)
            self._add_schedules(usage, 'Appliance', thermal_zone.appliances.schedules)
            self._add_schedules(usage, 'DHW_prof', thermal_zone.domestic_hot_water.schedules)
            _new_schedules = self._create_yearly_values_schedules('cold_temp',
                                                                  building.cold_water_temperature[cte.HOUR])
            self._add_schedules(building.name, 'cold_temp', _new_schedules)
            value = thermal_zone.domestic_hot_water.service_temperature
            _new_schedules = self._create_constant_value_schedules('DHW_temp', value)
            self._add_schedules(usage, 'DHW_temp', _new_schedules)
            _occ = thermal_zone.occupancy
            if _occ.occupancy_density == 0:
              _total_heat = 0
            else:
              _total_heat = (_occ.sensible_convective_internal_gain + _occ.sensible_radiative_internal_gain
                             + _occ.latent_internal_gain) / _occ.occupancy_density
            _new_schedules = self._create_constant_value_schedules('Activity Level', _total_heat)
            self._add_schedules(usage, 'Activity Level', _new_schedules)
            self._add_zone(thermal_zone, building.name)
            self._add_heating_system(thermal_zone, building.name)
            self._add_infiltration(thermal_zone, building.name)
            self._add_ventilation(thermal_zone, building.name)
            self._add_occupancy(thermal_zone, building.name)
            self._add_lighting(thermal_zone, building.name)
            self._add_appliances(thermal_zone, building.name)
            self._add_dhw(thermal_zone, building.name)
      if self._export_type == "Surfaces":
        if building.name in self._target_buildings or building.name in self._adjacent_buildings:
          if building.thermal_zones_from_internal_zones is not None:
            self._add_surfaces(building, building.name)
          else:
            self._add_pure_geometry(building, building.name)
        else:
          self._add_shading(building)
      else:
        self._add_block(building)

    self._idf.newidfobject(
      "OUTPUT:VARIABLE",
      Variable_Name="Zone Ideal Loads Supply Air Total Heating Energy",
      Reporting_Frequency="Hourly",
    )

    self._idf.newidfobject(
      "OUTPUT:VARIABLE",
      Variable_Name="Zone Ideal Loads Supply Air Total Cooling Energy",
      Reporting_Frequency="Hourly",
    )

    self._idf.newidfobject(
      "OUTPUT:VARIABLE",
      Variable_Name="Water Use Equipment Heating Rate",
      Reporting_Frequency="Hourly",
    )

    self._idf.newidfobject(
      "OUTPUT:VARIABLE",
      Variable_Name="Zone Lights Electricity Rate",
      Reporting_Frequency="Hourly",
    )

    self._idf.newidfobject(
      "OUTPUT:VARIABLE",
      Variable_Name="Other Equipment Electricity Rate",
      Reporting_Frequency="Hourly",
    )

    # post-process to erase windows associated to adiabatic walls
    windows_list = []
    for window in self._idf.idfobjects[self._WINDOW]:
      found = False
      for surface in self._idf.idfobjects[self._SURFACE]:
        if window.Building_Surface_Name == surface.Name:
          found = True
      if not found:
        windows_list.append(window)
    for window in windows_list:
      self._idf.removeidfobject(window)

    self._idf.saveas(str(self._output_file))
    return self._idf

  def run(self):
    """
    Start the energy plus simulation
    """
    self._idf.run(expandobjects=False, readvars=True, output_directory=self._output_path,
                  output_prefix=f'{self._city.name}_')

  def _add_block(self, building):
    _points = self._matrix_to_2d_list(building.foot_print.coordinates)
    self._idf.add_block(name=building.name, coordinates=_points, height=building.max_height,
                        num_stories=int(building.storeys_above_ground))

    for surface in self._idf.idfobjects[self._SURFACE]:
      for thermal_zone in building.thermal_zones_from_internal_zones:
        for boundary in thermal_zone.thermal_boundaries:
          if surface.Type == self.idf_surfaces[boundary.surface.type]:
            surface.Construction_Name = boundary.construction_name
            break
        for usage in thermal_zone.usages:
          surface.Zone_Name = usage.id
          break
        break
    self._idf.intersect_match()

  def _add_shading(self, building):
    for i, surface in enumerate(building.surfaces):
      shading = self._idf.newidfobject(self._SHADING, Name=f'{building.name}_{i}')
      coordinates = self._matrix_to_list(surface.solid_polygon.coordinates,
                                         self._city.lower_corner)
      shading.setcoords(coordinates)
      solar_reflectance = surface.short_wave_reflectance
      if solar_reflectance is None:
        solar_reflectance = ConfigurationHelper().short_wave_reflectance
      self._idf.newidfobject(self._SHADING_PROPERTY,
                             Shading_Surface_Name=f'{building.name}_{i}',
                             Diffuse_Solar_Reflectance_of_Unglazed_Part_of_Shading_Surface=solar_reflectance,
                             Fraction_of_Shading_Surface_That_Is_Glazed=0)

  def _add_pure_geometry(self, building, zone_name):
    for index, surface in enumerate(building.surfaces):
      outside_boundary_condition = 'Outdoors'
      sun_exposure = 'SunExposed'
      wind_exposure = 'WindExposed'
      idf_surface_type = self.idf_surfaces[surface.type]
      _kwargs = {'Name': f'Building_{building.name}_surface_{index}',
                 'Surface_Type': idf_surface_type,
                 'Zone_Name': zone_name}
      if surface.type == cte.GROUND:
        outside_boundary_condition = 'Ground'
        sun_exposure = 'NoSun'
        wind_exposure = 'NoWind'
      if surface.percentage_shared is not None and surface.percentage_shared > 0.5:
        outside_boundary_condition = 'Surface'
        outside_boundary_condition_object = f'Building_{building.name}_surface_{index}'
        sun_exposure = 'NoSun'
        wind_exposure = 'NoWind'
        _kwargs['Outside_Boundary_Condition_Object'] = outside_boundary_condition_object

      _kwargs['Outside_Boundary_Condition'] = outside_boundary_condition
      _kwargs['Sun_Exposure'] = sun_exposure
      _kwargs['Wind_Exposure'] = wind_exposure
      idf_surface = self._idf.newidfobject(self._SURFACE, **_kwargs)

      coordinates = self._matrix_to_list(surface.solid_polygon.coordinates,
                                         self._city.lower_corner)
      idf_surface.setcoords(coordinates)
    if self._lod >= 3:
      for internal_zone in building.internal_zones:
        for thermal_zone in internal_zone.thermal_zones_from_internal_zones:
          for boundary in thermal_zone.thermal_boundaries:
            self._add_windows_by_vertices(boundary)
    else:
      # idf only allows setting wwr for external walls
      wwr = 0
      self._idf.set_wwr(wwr)

  def _add_surfaces(self, building, zone_name):
    for thermal_zone in building.thermal_zones_from_internal_zones:
      for index, boundary in enumerate(thermal_zone.thermal_boundaries):
        idf_surface_type = self.idf_surfaces[boundary.parent_surface.type]
        outside_boundary_condition = 'Outdoors'
        sun_exposure = 'SunExposed'
        wind_exposure = 'WindExposed'
        _kwargs = {'Name': f'Building_{building.name}_surface_{index}',
                   'Surface_Type': idf_surface_type,
                   'Zone_Name': zone_name}
        if boundary.parent_surface.type == cte.GROUND:
          outside_boundary_condition = 'Ground'
          sun_exposure = 'NoSun'
          wind_exposure = 'NoWind'
        if boundary.parent_surface.percentage_shared is not None and boundary.parent_surface.percentage_shared > 0.5:
          outside_boundary_condition = 'Surface'
          outside_boundary_condition_object = f'Building_{building.name}_surface_{index}'
          sun_exposure = 'NoSun'
          wind_exposure = 'NoWind'
          _kwargs['Outside_Boundary_Condition_Object'] = outside_boundary_condition_object
        _kwargs['Outside_Boundary_Condition'] = outside_boundary_condition
        _kwargs['Sun_Exposure'] = sun_exposure
        _kwargs['Wind_Exposure'] = wind_exposure

        if boundary.parent_surface.vegetation is not None:
          construction_name = f'{boundary.construction_name}_{boundary.parent_surface.vegetation.name}'
        else:
          construction_name = boundary.construction_name
        _kwargs['Construction_Name'] = construction_name

        surface = self._idf.newidfobject(self._SURFACE, **_kwargs)

        coordinates = self._matrix_to_list(boundary.parent_surface.solid_polygon.coordinates,
                                           self._city.lower_corner)
        surface.setcoords(coordinates)

    if self._lod >= 3:
      for internal_zone in building.internal_zones:
        for thermal_zone in internal_zone.thermal_zones_from_internal_zones:
          for boundary in thermal_zone.thermal_boundaries:
            self._add_windows_by_vertices(boundary)
    else:
      # idf only allows setting wwr for external walls
      wwr = 0
      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')

  def _add_windows_by_vertices(self, boundary):
    raise NotImplementedError

  def _compare_window_constructions(self, window_construction, opening):
    glazing = window_construction['Outside_Layer']
    for material in self._idf.idfobjects[self._WINDOW_MATERIAL_SIMPLE]:
      if material['Name'] == glazing:
        if material['UFactor'] == opening.overall_u_value and material[
          'Solar_Heat_Gain_Coefficient'] == opening.g_value:
          return True
    return False

  def _add_vegetation_material(self, vegetation):
    for vegetation_material in self._idf.idfobjects[self._MATERIAL_ROOFVEGETATION]:
      if vegetation_material.Name == vegetation.name:
        return
    soil = vegetation.soil
    height = 0
    leaf_area_index = 0
    leaf_reflectivity = 0
    leaf_emissivity = 0
    minimal_stomatal_resistance = 0
    for plant in vegetation.plants:
      height += plant.percentage * plant.height
      leaf_area_index += plant.percentage * plant.leaf_area_index
      leaf_reflectivity += plant.percentage * plant.leaf_reflectivity
      leaf_emissivity += plant.percentage * plant.leaf_emissivity
      minimal_stomatal_resistance += plant.percentage * plant.minimal_stomatal_resistance
    self._idf.newidfobject(
      self._MATERIAL_ROOFVEGETATION,
      Name=vegetation.name,
      Height_of_Plants=height,
      Leaf_Area_Index=leaf_area_index,
      Leaf_Reflectivity=leaf_reflectivity,
      Leaf_Emissivity=leaf_emissivity,
      Minimum_Stomatal_Resistance=minimal_stomatal_resistance,
      Soil_Layer_Name=soil.name,
      Roughness=soil.roughness,
      Thickness=vegetation.soil_thickness,
      Conductivity_of_Dry_Soil=soil.dry_conductivity,
      Density_of_Dry_Soil=soil.dry_density,
      Specific_Heat_of_Dry_Soil=soil.dry_specific_heat,
      Thermal_Absorptance=soil.thermal_absorptance,
      Solar_Absorptance=soil.solar_absorptance,
      Visible_Absorptance=soil.visible_absorptance,
      Saturation_Volumetric_Moisture_Content_of_the_Soil_Layer=soil.saturation_volumetric_moisture_content,
      Residual_Volumetric_Moisture_Content_of_the_Soil_Layer=soil.residual_volumetric_moisture_content,
      Initial_Volumetric_Moisture_Content_of_the_Soil_Layer=soil.initial_volumetric_moisture_content,
      Moisture_Diffusion_Calculation_Method=self._SIMPLE
    )