honeybee-openstudio 2.2.0 → 2.5.0

data/lib/from_honeybee/hvac/ideal_air.rb

@@ -100,7 +100,7 @@ module FromHoneybee
       end
 
       # assign limits to the system's heating capacity
-      if @hash[:heating_limit] == {'type': 'NoLimit'}
+      if @hash[:heating_limit] == {:type => 'NoLimit'}
         os_ideal_air.setHeatingLimit('NoLimit')
       else
         os_ideal_air.setHeatingLimit('LimitCapacity')
@@ -112,7 +112,7 @@ module FromHoneybee
       end
 
       # assign limits to the system's cooling capacity
-      if @hash[:cooling_limit] == {'type': 'NoLimit'}
+      if @hash[:cooling_limit] == {:type => 'NoLimit'}
         os_ideal_air.setCoolingLimit('NoLimit')
       else
         os_ideal_air.setCoolingLimit('LimitFlowRateAndCapacity')

data/lib/from_honeybee/hvac/template.rb

@@ -0,0 +1,198 @@
+# *******************************************************************************
+# Honeybee OpenStudio Gem, Copyright (c) 2020, Alliance for Sustainable 
+# Energy, LLC, Ladybug Tools LLC and other contributors. All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# (1) Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+#
+# (2) Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation
+# and/or other materials provided with the distribution.
+#
+# (3) Neither the name of the copyright holder nor the names of any contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission from the respective party.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S), ANY CONTRIBUTORS, THE
+# UNITED STATES GOVERNMENT, OR THE UNITED STATES DEPARTMENT OF ENERGY, NOR ANY OF
+# THEIR EMPLOYEES, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+# OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+# *******************************************************************************
+
+require 'openstudio-standards'
+require_relative 'Model.hvac'
+
+require 'from_honeybee/extension'
+require 'from_honeybee/model_object'
+
+module FromHoneybee
+  class TemplateHVAC < ModelObject
+    attr_reader :errors, :warnings
+
+    @@all_air_types = ['VAV', 'PVAV', 'PSZ', 'PTAC', 'ForcedAirFurnace']
+    @@doas_types = ['FCUwithDOAS', 'WSHPwithDOAS', 'VRFwithDOAS']
+    @@heat_cool_types = ['FCU', 'WSHP', 'VRF', 'Baseboard',  'EvaporativeCooler',
+                         'Residential', 'WindowAC', 'GasUnitHeater']
+    @@types = @@all_air_types + @@doas_types + @@heat_cool_types
+
+    def initialize(hash = {})
+      super(hash)
+    end
+
+    def self.types
+      # array of all supported template HVAC systems
+      @@types
+    end
+
+    def self.all_air_types
+      # array of the All Air HVAC types
+      @@all_air_types
+    end
+
+    def self.doas_types
+      # array of the DOAS HVAC types
+      @@doas_types
+    end
+
+    def self.heat_cool_types
+      # array of the system types providing heating and cooling only
+      @@heat_cool_types
+    end
+  
+    def defaults(system_type)
+      @@schema[:components][:schemas][system_type.to_sym][:properties]
+    end
+
+    def to_openstudio(openstudio_model, room_ids)
+      # get the defaults for the specific system type
+      hvac_defaults = defaults(@hash[:type])
+
+      # make the standard applier
+      if @hash[:vintage]
+        standard = Standard.build(@hash[:vintage])
+      else
+        standard = Standard.build(hvac_defaults[:vintage][:default])
+      end
+
+      # get the default equipment type
+      if @hash[:equipment_type]
+        equipment_type = @hash[:equipment_type]
+      else
+        equipment_type = hvac_defaults[:equipment_type][:default]
+      end
+
+      # get all of the thermal zones from the Model using the room identifiers
+      zones = []
+      room_ids.each do |room_id|
+        zone_get = openstudio_model.getThermalZoneByName(room_id)
+        unless zone_get.empty?
+          os_thermal_zone = zone_get.get
+          zones << os_thermal_zone
+        end
+      end
+
+      # create the HVAC system and assign the identifier to the air loop name if it exists
+      os_hvac = openstudio_model.add_cbecs_hvac_system(standard, equipment_type, zones)
+      os_air_loop = nil
+      air_loops = openstudio_model.getAirLoopHVACs
+      unless air_loops.length == 0
+        os_air_loop = air_loops[-1]
+        loop_name = os_air_loop.name
+        unless loop_name.empty?
+            os_air_loop.setName(@hash[:identifier] + ' - ' + loop_name.get)
+        end
+      end
+
+      # TODO: consider adding the ability to decentralize the plant by changing loop names
+      #os_hvac.each do |hvac_loop|
+      #  loop_name = hvac_loop.name
+      #  unless loop_name.empty?
+      #    hvac_loop.setName(@hash[:identifier] + ' - ' + loop_name.get)
+      #  end
+      #end
+
+      # assign the economizer type if there's an air loop and the economizer is specified
+      if @hash[:economizer_type] && @hash[:economizer_type] != 'Inferred' && os_air_loop
+        oasys = os_air_loop.airLoopHVACOutdoorAirSystem
+        unless oasys.empty?
+            os_oasys = oasys.get
+            oactrl = os_oasys.getControllerOutdoorAir
+            oactrl.setEconomizerControlType(@hash[:economizer_type])
+        end
+      end
+
+      # set the sensible heat recovery if there's an air loop and the heat recovery is specified
+      if @hash[:sensible_heat_recovery] && @hash[:sensible_heat_recovery] != {:type => 'Autosize'} && os_air_loop
+        erv = get_existing_erv(os_air_loop)
+        unless erv
+          erv = create_erv(openstudio_model, os_air_loop)
+        end
+        eff_at_max = @hash[:sensible_heat_recovery] * (0.76 / 0.81)  # taken from OpenStudio defaults
+        erv.setSensibleEffectivenessat100CoolingAirFlow(eff_at_max)
+        erv.setSensibleEffectivenessat100HeatingAirFlow(eff_at_max)
+        erv.setSensibleEffectivenessat75CoolingAirFlow(@hash[:sensible_heat_recovery])
+        erv.setSensibleEffectivenessat75HeatingAirFlow(@hash[:sensible_heat_recovery])
+      end
+
+      # set the latent heat recovery if there's an air loop and the heat recovery is specified
+      if @hash[:latent_heat_recovery] && @hash[:latent_heat_recovery] != {:type => 'Autosize'} && os_air_loop
+        erv = get_existing_erv(os_air_loop)
+        unless erv
+          erv = create_erv(openstudio_model, os_air_loop)
+        end
+        eff_at_max = @hash[:latent_heat_recovery] * (0.68 / 0.73)  # taken from OpenStudio defaults
+        erv.setLatentEffectivenessat100CoolingAirFlow(eff_at_max)
+        erv.setLatentEffectivenessat100HeatingAirFlow(eff_at_max)
+        erv.setLatentEffectivenessat75CoolingAirFlow(@hash[:latent_heat_recovery])
+        erv.setLatentEffectivenessat75HeatingAirFlow(@hash[:latent_heat_recovery])
+      end
+
+      os_hvac
+    end
+
+    def get_existing_erv(os_air_loop)
+      # get an existing heat ecovery unit from an air loop; will be nil if there is none
+      os_air_loop.oaComponents.each do |supply_component|
+        if not supply_component.to_HeatExchangerAirToAirSensibleAndLatent.empty?
+          erv = supply_component.to_HeatExchangerAirToAirSensibleAndLatent.get
+          return erv
+        end
+      end
+      nil
+    end
+
+    def create_erv(model, os_air_loop)
+      # create a heat recovery unit with default zero efficiencies
+      heat_ex = OpenStudio::Model::HeatExchangerAirToAirSensibleAndLatent.new(model)
+      heat_ex.setEconomizerLockout(false)
+      heat_ex.setName(@hash[:identifier] + '_Heat Recovery Unit')
+      heat_ex.setSensibleEffectivenessat100CoolingAirFlow(0)
+      heat_ex.setSensibleEffectivenessat100HeatingAirFlow(0)
+      heat_ex.setSensibleEffectivenessat75CoolingAirFlow(0)
+      heat_ex.setSensibleEffectivenessat75HeatingAirFlow(0)
+      heat_ex.setLatentEffectivenessat100CoolingAirFlow(0)
+      heat_ex.setLatentEffectivenessat100HeatingAirFlow(0)
+      heat_ex.setLatentEffectivenessat75CoolingAirFlow(0)
+      heat_ex.setLatentEffectivenessat75HeatingAirFlow(0)
+
+      # add the heat exchanger to the air loop
+      outdoor_node = os_air_loop.reliefAirNode
+      unless outdoor_node.empty?
+        os_outdoor_node = outdoor_node.get
+        heat_ex.addToNode(os_outdoor_node)
+      end
+      heat_ex
+    end
+
+  end #TemplateHVAC
+end #FromHoneybee

data/lib/from_honeybee/model.rb

@@ -46,6 +46,7 @@ require 'from_honeybee/geometry/room'
 
 # import the HVAC objects
 require 'from_honeybee/hvac/ideal_air'
+require 'from_honeybee/hvac/template'
 
 # import the construction objects
 require 'from_honeybee/construction/opaque'
@@ -95,12 +96,12 @@ module FromHoneybee
       # initialize class variable @@extension only once
       @@extension ||= Extension.new
       @@schema ||= @@extension.schema
+      @@standards ||= @@extension.standards
 
       @hash = hash
       @type = @hash[:type]
       raise 'Unknown model type' if @type.nil?
       raise "Incorrect model type '#{@type}'" unless @type == 'Model'
-
     end
 
     # check if the model is valid
@@ -157,34 +158,58 @@ module FromHoneybee
       building = @openstudio_model.getBuilding
       building.setStandardsBuildingType('MediumOffice')
 
+      # initialize global hashes for various model properties
+      $gas_gap_hash = Hash.new  # hash to track gas gaps in case they are split by shades
+      $air_boundary_hash = Hash.new  # hash to track any air boundary constructions
+      $window_shade_hash = Hash.new  # hash to track any window constructions with shade
+      $programtype_setpoint_hash = Hash.new  # hash to track Setpoint objects
+
       # create all of the non-geometric model elements
       if log_report
         puts 'Translating Materials'
       end
-      create_materials
+      if @hash[:properties][:energy][:materials]
+        create_materials(@hash[:properties][:energy][:materials])
+      end
 
       if log_report
         puts 'Translating Constructions'
       end
-      create_constructions
+      if @hash[:properties][:energy][:constructions]
+        create_constructions(@hash[:properties][:energy][:constructions])
+      end
       
       if log_report
         puts 'Translating ConstructionSets'
       end
-      create_construction_set
-      create_global_construction_set
+      if @hash[:properties][:energy][:construction_sets]
+        create_construction_sets(@hash[:properties][:energy][:construction_sets])
+      end
 
       if log_report
         puts 'Translating Schedules'
       end
-      create_schedule_type_limits
-      create_schedules
+      if @hash[:properties][:energy][:schedule_type_limits]
+        create_schedule_type_limits(@hash[:properties][:energy][:schedule_type_limits])
+      end
+      if @hash[:properties][:energy][:schedules]
+        create_schedules(@hash[:properties][:energy][:schedules])
+      end
 
       if log_report
         puts 'Translating ProgramTypes'
       end
-      create_program_types
+      if @hash[:properties][:energy][:program_types]
+        create_program_types(@hash[:properties][:energy][:program_types])
+      end
+
+      # create the default construction set to catch any cases of unassigned constructions
+      if log_report
+        puts 'Translating Default ConstructionSet'
+      end
+      create_default_construction_set
 
+      # create the geometry and add any extra properties to it
       if log_report
         puts 'Translating Room Geometry'
       end
@@ -211,103 +236,139 @@ module FromHoneybee
       create_orphaned_doors
     end
 
-    def create_materials
-      $gas_gap_hash = Hash.new  # hash to track gas gaps in case they are split by shades
+    def create_materials(material_dicts, check_existing=false)
+      material_dicts.each do |material|
+        # check if there's already a material in the model with the identifier
+        add_obj = true
+        if check_existing
+          object = @openstudio_model.getMaterialByName(material[:identifier])
+          if object.is_initialized
+            add_obj = false
+          end
+        end
 
-      @hash[:properties][:energy][:materials].each do |material|
-        material_type = material[:type]
-
-        case material_type
-        when 'EnergyMaterial'
-          material_object = EnergyMaterial.new(material)
-        when 'EnergyMaterialNoMass'
-          material_object = EnergyMaterialNoMass.new(material)
-        when 'EnergyWindowMaterialGas'
-          material_object = EnergyWindowMaterialGas.new(material)
-          $gas_gap_hash[material[:identifier]] = material_object
-        when 'EnergyWindowMaterialGasMixture'
-          material_object = EnergyWindowMaterialGasMixture.new(material)
-          $gas_gap_hash[material[:identifier]] = material_object
-        when 'EnergyWindowMaterialGasCustom'
-          material_object = EnergyWindowMaterialGasCustom.new(material)
-          $gas_gap_hash[material[:identifier]] = material_object
-        when 'EnergyWindowMaterialSimpleGlazSys'
-          material_object = EnergyWindowMaterialSimpleGlazSys.new(material)
-        when 'EnergyWindowMaterialBlind'
-          material_object = EnergyWindowMaterialBlind.new(material)
-        when 'EnergyWindowMaterialGlazing'
-          material_object = EnergyWindowMaterialGlazing.new(material)
-        when 'EnergyWindowMaterialShade'
-          material_object = EnergyWindowMaterialShade.new(material)
-        else
-          raise "Unknown material type #{material_type}"
+        # add the material object to the Model
+        if add_obj
+          material_type = material[:type]
+          case material_type
+          when 'EnergyMaterial'
+            material_object = EnergyMaterial.new(material)
+          when 'EnergyMaterialNoMass'
+            material_object = EnergyMaterialNoMass.new(material)
+          when 'EnergyWindowMaterialGas'
+            material_object = EnergyWindowMaterialGas.new(material)
+            $gas_gap_hash[material[:identifier]] = material_object
+          when 'EnergyWindowMaterialGasMixture'
+            material_object = EnergyWindowMaterialGasMixture.new(material)
+            $gas_gap_hash[material[:identifier]] = material_object
+          when 'EnergyWindowMaterialGasCustom'
+            material_object = EnergyWindowMaterialGasCustom.new(material)
+            $gas_gap_hash[material[:identifier]] = material_object
+          when 'EnergyWindowMaterialSimpleGlazSys'
+            material_object = EnergyWindowMaterialSimpleGlazSys.new(material)
+          when 'EnergyWindowMaterialBlind'
+            material_object = EnergyWindowMaterialBlind.new(material)
+          when 'EnergyWindowMaterialGlazing'
+            material_object = EnergyWindowMaterialGlazing.new(material)
+          when 'EnergyWindowMaterialShade'
+            material_object = EnergyWindowMaterialShade.new(material)
+          else
+            raise "Unknown material type #{material_type}"
+          end
+          material_object.to_openstudio(@openstudio_model)
         end
-        material_object.to_openstudio(@openstudio_model)
       end
     end
 
-    def create_constructions
-      $air_boundary_hash = Hash.new  # hash to track any air boundary constructions
-      $window_shade_hash = Hash.new  # hash to track any window constructions with shade
+    def create_constructions(construction_dicts, check_existing=false)
+      construction_dicts.each do |construction|
+        # check if there's already a construction in the model with the identifier
+        add_obj = true
+        if check_existing
+          object = @openstudio_model.getConstructionByName(construction[:identifier])
+          if object.is_initialized
+            add_obj = false
+          end
+        end
 
-      @hash[:properties][:energy][:constructions].each do |construction|
-        identifier = construction[:identifier]
-        construction_type = construction[:type]
-        
-        case construction_type
-        when 'OpaqueConstructionAbridged'
-          construction_object = OpaqueConstructionAbridged.new(construction)
-        when 'WindowConstructionAbridged'
-          construction_object = WindowConstructionAbridged.new(construction)
-        when 'WindowConstructionShadeAbridged'
-          construction_object = WindowConstructionShadeAbridged.new(construction)
-          $window_shade_hash[construction[:identifier]] = construction_object
-        when 'ShadeConstruction'
-          construction_object = ShadeConstruction.new(construction)
-        when 'AirBoundaryConstructionAbridged'
-          construction_object = AirBoundaryConstructionAbridged.new(construction)
-          $air_boundary_hash[construction[:identifier]] = construction
-        else
-          raise "Unknown construction type #{construction_type}."
+        # add the construction object to the Model
+        if add_obj
+          construction_type = construction[:type]
+          case construction_type
+          when 'OpaqueConstructionAbridged'
+            construction_object = OpaqueConstructionAbridged.new(construction)
+          when 'WindowConstructionAbridged'
+            construction_object = WindowConstructionAbridged.new(construction)
+          when 'WindowConstructionShadeAbridged'
+            construction_object = WindowConstructionShadeAbridged.new(construction)
+            $window_shade_hash[construction[:identifier]] = construction_object
+          when 'ShadeConstruction'
+            construction_object = ShadeConstruction.new(construction)
+          when 'AirBoundaryConstructionAbridged'
+            construction_object = AirBoundaryConstructionAbridged.new(construction)
+            $air_boundary_hash[construction[:identifier]] = construction
+          else
+            raise "Unknown construction type #{construction_type}."
+          end
+          construction_object.to_openstudio(@openstudio_model)
         end
-        construction_object.to_openstudio(@openstudio_model)
       end
     end
 
-    def create_construction_set
-      if @hash[:properties][:energy][:construction_sets]
-        @hash[:properties][:energy][:construction_sets].each do |construction_set|
-        construction_set_object = ConstructionSetAbridged.new(construction_set)
-        construction_set_object.to_openstudio(@openstudio_model)
+    def create_construction_sets(construction_set_dicts, check_existing=false)
+      construction_set_dicts.each do |construction_set|
+        # check if there's already a construction set in the model with the identifier
+        add_obj = true
+        if check_existing
+          object = @openstudio_model.getDefaultConstructionSetByName(
+            construction_set[:identifier])
+          if object.is_initialized
+            add_obj = false
+          end
         end
-      end
-    end
 
-    def create_global_construction_set
-      if @hash[:properties][:energy][:global_construction_set]
-        construction_id = @hash[:properties][:energy][:global_construction_set]
-        construction = @openstudio_model.getDefaultConstructionSetByName(construction_id)
-        unless construction.empty?
-          openstudio_construction = construction.get
+        # add the construction set object to the Model
+        if add_obj
+          construction_set_object = ConstructionSetAbridged.new(construction_set)
+          construction_set_object.to_openstudio(@openstudio_model)
         end
-        @openstudio_model.getBuilding.setDefaultConstructionSet(openstudio_construction)
       end
     end
 
-    def create_schedule_type_limits
-      if @hash[:properties][:energy][:schedule_type_limits]
-        @hash[:properties][:energy][:schedule_type_limits].each do |schedule_type_limit|
+    def create_schedule_type_limits(stl_dicts, check_existing=false)
+      stl_dicts.each do |schedule_type_limit|
+        # check if there's already a schedule type limit in the model with the identifier
+        add_obj = true
+        if check_existing
+          object = @openstudio_model.getScheduleTypeLimitsByName(
+            schedule_type_limit[:identifier])
+          if object.is_initialized
+            add_obj = false
+          end
+        end
+
+        # add the schedule type limit object to the Model
+        if add_obj
           schedule_type_limit_object = ScheduleTypeLimit.new(schedule_type_limit)
           schedule_type_limit_object.to_openstudio(@openstudio_model)
         end
       end
     end
 
-    def create_schedules
-      if @hash[:properties][:energy][:schedules]
-        @hash[:properties][:energy][:schedules].each do |schedule|
-          schedule_type = schedule[:type]
+    def create_schedules(schedule_dicts, check_existing=false)
+      schedule_dicts.each do |schedule|
+        # check if there's already a schedule in the model with the identifier
+        add_obj = true
+        if check_existing
+          object = @openstudio_model.getScheduleByName(schedule[:identifier])
+          if object.is_initialized
+            add_obj = false
+          end
+        end
 
+        # add the schedule object to the Model
+        if add_obj
+          schedule_type = schedule[:type]
           case schedule_type
           when 'ScheduleRulesetAbridged'
             schedule_object = ScheduleRulesetAbridged.new(schedule)
@@ -317,21 +378,56 @@ module FromHoneybee
             raise("Unknown schedule type #{schedule_type}.")
           end
           schedule_object.to_openstudio(@openstudio_model)
-        
         end
       end
     end
 
-    def create_program_types
-      if @hash[:properties][:energy][:program_types]
-        $programtype_setpoint_hash = Hash.new  # hash to track Setpoint objects
-        @hash[:properties][:energy][:program_types].each do |space_type|
+    def create_program_types(program_dicts, check_existing=false)
+      program_dicts.each do |space_type|
+        # check if there's already a space type in the model with the identifier
+        add_obj = true
+        if check_existing
+          object = @openstudio_model.getSpaceTypeByName(space_type[:identifier])
+          if object.is_initialized
+            add_obj = false
+          end
+        end
+
+        # add the space type object to the Model
+        if add_obj
           space_type_object = ProgramTypeAbridged.new(space_type)
           space_type_object.to_openstudio(@openstudio_model)
         end
       end
     end
 
+    def create_default_construction_set
+      # create the materials, constructions and construction set
+      create_materials(@@standards[:materials], true)
+      create_constructions(@@standards[:constructions], true)
+      create_construction_sets(@@standards[:construction_sets], true)
+
+      # write the fractional schedule type and always on schedule if they are not there
+      @@standards[:schedule_type_limits].each do |sch_type_limit|
+        if sch_type_limit[:identifier] == 'Fractional'
+          create_schedule_type_limits([sch_type_limit], true)
+        end
+      end
+      @@standards[:schedules].each do |schedule|
+        if schedule[:identifier] == 'Always On'
+          create_schedules([schedule], true)
+        end
+      end
+
+      # set the default construction set to the building level of the Model
+      construction_id = 'Default Generic Construction Set'
+      construction = @openstudio_model.getDefaultConstructionSetByName(construction_id)
+      unless construction.empty?
+        os_constructionset = construction.get
+        @openstudio_model.getBuilding.setDefaultConstructionSet(os_constructionset)
+      end
+    end
+
     def create_rooms
       if @hash[:rooms]
         $air_mxing_array = []  # list to track any air mixing between Rooms
@@ -408,7 +504,7 @@ module FromHoneybee
           hvac_hashes[hvac[:identifier]] = hvac
           hvac_hashes[hvac[:identifier]]['rooms'] = []
         end
-        # loop through the rooms and trach which are assigned to each HVAC
+        # loop through the rooms and track which are assigned to each HVAC
         if @hash[:rooms]
           @hash[:rooms].each do |room|
             if room[:properties][:energy][:hvac]
@@ -419,8 +515,7 @@ module FromHoneybee
 
         hvac_hashes.each_value do |hvac|
           system_type = hvac[:type]
-          case system_type
-          when 'IdealAirSystemAbridged'
+          if system_type == 'IdealAirSystemAbridged'
             ideal_air_system = IdealAirSystemAbridged.new(hvac)
             os_ideal_air_system = ideal_air_system.to_openstudio(@openstudio_model)
             hvac['rooms'].each do |room_id|
@@ -430,6 +525,9 @@ module FromHoneybee
                 os_ideal_air_system.addToThermalZone(os_thermal_zone)
               end
             end
+          elsif TemplateHVAC.types.include?(system_type)
+            template_system = TemplateHVAC.new(hvac)
+            os_template_system = template_system.to_openstudio(@openstudio_model, hvac['rooms'])
           end
         end
       end