honeybee-openstudio 2.31.7 → 2.31.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f0fdea0e04fa8570b9c3e7d7ba69921a653aa31c5ed7662591ee41e414a3d607
-  data.tar.gz: f7a212b274413d1250813154a4c8e8a578a99f30ac70f632e4268744b6d36e80
+  metadata.gz: 68e54c322a55fb8dcd87429be85e573fac7de1a66f7b01acb798efaa27ce5a63
+  data.tar.gz: d80b9e57fee33f88ef05ae16412cbc57334d37623eae28e7e1d97d39d8a58fc4
 SHA512:
-  metadata.gz: f28c6c37158cd493e94fdbdfe9f1be70d064e6fd30980ea2ea0a1d1146bfbf7df3bfdba33d4dac355bd77c00f68129ef7125f317840d20157d210e173d279ee5
-  data.tar.gz: f37d5a509a78684c849ec5a237b629bfdf85302327b3cad08f7ff8ab866f2cf4a575e9add323cd9f7109bb1a42c58fed8e99626a0a9a700bc7ee30890abe3b43
+  metadata.gz: e036f52b5fa2be11caec2a56db9c60d913901cf00be345dddaf932c5fe340128981fe28999bf0cbba1bf9a3d73fc0dce756050dab0675d18eacc9e68c982ee6f
+  data.tar.gz: 83e6a415c18c5f0062498358fee7ac5b04d11b414c536dd9b129eb9bb505183fa5efa52c9d00009269fe574b21b05a9111ae0b6e033a85a4e00ac7e01543aabc

data/honeybee-openstudio.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = 'honeybee-openstudio'
-  spec.version       = '2.31.7'
+  spec.version       = '2.31.10'
   spec.authors       = ['Tanushree Charan', 'Dan Macumber', 'Chris Mackey', 'Mostapha Sadeghipour Roudsari']
   spec.email         = ['tanushree.charan@nrel.gov', 'chris@ladybug.tools']
 

data/lib/files/urbanopt_Gemfile

@@ -9,7 +9,7 @@ if allow_local && File.exist?('../openstudio-common-measures-gem')
 elsif allow_local
   gem 'openstudio-common-measures', github: 'NREL/openstudio-common-measures-gem', branch: 'develop'
 else
-  gem 'openstudio-common-measures', '~> 0.5.0'
+  gem 'openstudio-common-measures', '~> 0.6.0'
 end
 
 if allow_local && File.exist?('../openstudio-model-articulation-gem')
@@ -17,7 +17,7 @@ if allow_local && File.exist?('../openstudio-model-articulation-gem')
 elsif allow_local
   gem 'openstudio-model-articulation', github: 'NREL/openstudio-model-articulation-gem', branch: 'develop'
 else
-  gem 'openstudio-model-articulation', '0.5.0'
+  gem 'openstudio-model-articulation', '0.6.1'
 end
 
 if allow_local && File.exist?('../urbanopt-geojson-gem')
@@ -25,7 +25,7 @@ if allow_local && File.exist?('../urbanopt-geojson-gem')
 elsif allow_local
   gem 'urbanopt-geojson', github: 'URBANopt/urbanopt-geojson-gem', branch: 'develop'
 else
-  gem 'urbanopt-geojson', '~> 0.7.0'
+  gem 'urbanopt-geojson', '~> 0.8.0'
 end
 
 if allow_local && File.exist?('../urbanopt-reporting-gem')
@@ -33,8 +33,8 @@ if allow_local && File.exist?('../urbanopt-reporting-gem')
 elsif allow_local
   gem 'urbanopt-reporting', github: 'URBANopt/urbanopt-reporting-gem', branch: 'develop'
 else
-  gem 'urbanopt-reporting', '~> 0.5.0'
+  gem 'urbanopt-reporting', '~> 0.6.0'
 end
 
 # include the honeybee-openstudio-gem
-gem 'honeybee-openstudio', '2.28.4'
+gem 'honeybee-openstudio', '2.31.7'

data/lib/from_openstudio/geometry/room.rb

@@ -201,6 +201,17 @@ module Honeybee
       thermal_zone = space.thermalZone
       unless thermal_zone.empty?
         thermal_zone = space.thermalZone.get
+        # Create ideal_air_system if present
+        unless thermal_zone.equipment.nil?
+          thermal_zone.equipment.each do |equipment|
+            if equipment.to_ZoneHVACIdealLoadsAirSystem.is_initialized
+              ideal_air_hash = Honeybee::IdealAirSystemAbridged.from_hvac(
+                equipment.to_ZoneHVACIdealLoadsAirSystem.get)
+              $hvacs << ideal_air_hash
+              hash[:hvac] = ideal_air_hash[:identifier]
+            end
+          end
+        end
         unless thermal_zone.thermostatSetpointDualSetpoint.empty?
           hash[:setpoint] = {}
           hash[:setpoint][:type] = 'SetpointAbridged'

data/lib/from_openstudio/hvac/ideal_air.rb

@@ -0,0 +1,75 @@
+# *******************************************************************************
+# 4ju0 d/zf 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 'honeybee/hvac/ideal_air'
+require 'to_openstudio/model_object'
+
+module Honeybee
+    class IdealAirSystemAbridged
+
+        def self.from_hvac(hvac)
+            # create an empty hash
+            hash = {}
+            hash[:type] = 'IdealAirSystemAbridged'
+            hash[:identifier] = clean_name(hvac.nameString)
+            unless hvac.displayName.empty?
+                hash[:display_name] = (hvac.displayName.get).force_encoding("UTF-8")
+            end
+            hash[:economizer_type] = hvac.outdoorAirEconomizerType
+            if hvac.demandControlledVentilationType.downcase == 'none'
+                hash[:demand_controlled_ventilation] = false
+            else
+                hash[:demand_controlled_ventilation] = true
+            end
+            hash[:sensible_heat_recovery] = hvac.sensibleHeatRecoveryEffectiveness
+            hash[:latent_heat_recovery] = hvac.latentHeatRecoveryEffectiveness
+            hash[:heating_air_temperature] = hvac.maximumHeatingSupplyAirTemperature
+            hash[:cooling_air_temperature] = hvac.minimumCoolingSupplyAirTemperature
+            if hvac.heatingLimit == 'NoLimit'
+                hash[:heating_limit] = hvac.heatingLimit
+            end
+            if hvac.coolingLimit == 'NoLimit'
+                hash[:cooling_limit] = hvac.coolingLimit
+            end
+            unless hvac.heatingAvailabilitySchedule.empty?
+                schedule = hvac.heatingAvailabilitySchedule.get
+                hash[:heating_availability] = schedule.nameString
+            end
+            unless hvac.coolingAvailabilitySchedule.empty?
+                schedule = hvac.coolingAvailabilitySchedule.get
+                hash[:coolingAvailabilitySchedule]
+            end
+            
+            hash
+        end
+
+    end #IdealAirSystemAbridged
+end #Honeybee

data/lib/from_openstudio/load/electric_equipment.rb

@@ -61,4 +61,4 @@ module Honeybee
 
 
     end #ElectricEquipmentAbridged
-end #Honeybee
+end #Honeybee

data/lib/from_openstudio/model.rb

@@ -51,6 +51,7 @@ module Honeybee
       $opaque_constructions = {}
       $window_constructions = {}
       $shade_constructions = {}
+      $hvacs = []
 
       hash[:properties] = properties_from_model(openstudio_model)
 
@@ -126,6 +127,7 @@ module Honeybee
       hash[:schedule_type_limits] = schedtypelimits_from_model(openstudio_model)
       hash[:schedules] = schedules_from_model(openstudio_model)
       hash[:program_types] = programtype_from_model(openstudio_model)
+      hash[:hvacs] = $hvacs
 
       hash
     end

data/lib/from_openstudio/schedule/ruleset.rb

@@ -81,6 +81,15 @@ module Honeybee
         hash[:day_schedules] << ScheduleRulesetAbridged.from_day_schedule(schedule_day)
       end
 
+      # remove the bogus default day schedule that OpenStudio adds upon import from IDF
+      if hash[:default_day_schedule].start_with?('Schedule Day ')
+        if hash[:day_schedules][0][:values] == [0] && hash[:schedule_rules].length() > 0
+          hash[:default_day_schedule] = hash[:schedule_rules][0][:schedule_day]
+          hash[:schedule_rules].pop(0)
+          hash[:day_schedules].pop(0)
+        end
+      end
+
       # assing any schedule type limits if they exist
       unless schedule_ruleset.scheduleTypeLimits.empty?
         typ_lim = schedule_ruleset.scheduleTypeLimits.get

data/lib/from_openstudio.rb

@@ -44,6 +44,9 @@ require 'from_openstudio/geometry/face'
 require 'from_openstudio/geometry/room'
 require 'from_openstudio/geometry/shade'
 
+# extend the hvac objects
+require 'from_openstudio/hvac/ideal_air'
+
 # extend the construction objects
 require 'from_openstudio/construction/opaque'
 require 'from_openstudio/construction/window'

data/lib/to_openstudio/geometry/aperture.rb

@@ -118,7 +118,7 @@ module Honeybee
         end
 
         # assign the construction if it exists
-        if @hash[:properties][:energy][:construction]
+        if @hash[:properties].key?(:energy) && @hash[:properties][:energy][:construction]
           construction_identifier = @hash[:properties][:energy][:construction]
           construction = openstudio_model.getConstructionByName(construction_identifier)
           if !construction.empty?
@@ -182,7 +182,7 @@ module Honeybee
 
       # get the approriate construction id
       construction_id = nil
-      if @hash[:properties][:energy][:construction]
+      if @hash[:properties].key?(:energy) && @hash[:properties][:energy][:construction]
         construction_id = @hash[:properties][:energy][:construction]
       else
         construction_id = 'Generic Double Pane'

data/lib/to_openstudio/geometry/door.rb

@@ -118,7 +118,7 @@ module Honeybee
         end
 
         # assign the construction if it exists
-        if @hash[:properties][:energy][:construction]
+        if @hash[:properties].key?(:energy) && @hash[:properties][:energy][:construction]
           construction_identifier = @hash[:properties][:energy][:construction]
           construction = openstudio_model.getConstructionByName(construction_identifier)
           if !construction.empty?
@@ -176,7 +176,7 @@ module Honeybee
 
     # get the approriate construction id
     construction_id = nil
-    if @hash[:properties][:energy][:construction]
+    if @hash[:properties].key?(:energy) && @hash[:properties][:energy][:construction]
       construction_id = @hash[:properties][:energy][:construction]
     elsif @hash[:is_glass] == true
       construction_id = 'Generic Double Pane'

data/lib/to_openstudio/geometry/face.rb

@@ -64,39 +64,41 @@ module Honeybee
       end
       os_surface.setSurfaceType(@hash[:face_type])
 
-      # assign the construction if it is present
-      if @hash[:properties][:energy][:construction]
-        construction_identifier = @hash[:properties][:energy][:construction]
-        construction = openstudio_model.getConstructionByName(construction_identifier)
-        unless construction.empty?
-          os_construction = construction.get
-          os_surface.setConstruction(os_construction)
+      if @hash[:properties].key?(:energy)
+        # assign the construction if it is present
+        if @hash[:properties][:energy][:construction]
+          construction_identifier = @hash[:properties][:energy][:construction]
+          construction = openstudio_model.getConstructionByName(construction_identifier)
+          unless construction.empty?
+            os_construction = construction.get
+            os_surface.setConstruction(os_construction)
+          end
         end
-      end
-
-      # assign the AFN crack if it's specified and we are not using simple infiltration
-      if !$use_simple_vent && @hash[:properties][:energy][:vent_crack]
-        unless $interior_afn_srf_hash[@hash[:identifier]]  # interior crack that's been accounted for
-          vent_crack = @hash[:properties][:energy][:vent_crack]
-          # create the crack object for using default values
-          flow_exponent = crack_defaults[:flow_exponent][:default].to_f
-          os_crack = OpenStudio::Model::AirflowNetworkCrack.new(
-            openstudio_model, vent_crack[:flow_coefficient], flow_exponent,
-            $afn_reference_crack)
 
-          # assign the flow exponent if it's specified
-          if vent_crack[:flow_exponent]
-            os_crack.setAirMassFlowExponent(vent_crack[:flow_exponent])
-          end
+        # assign the AFN crack if it's specified and we are not using simple infiltration
+        if !$use_simple_vent && @hash[:properties][:energy][:vent_crack]
+          unless $interior_afn_srf_hash[@hash[:identifier]]  # interior crack that's been accounted for
+            vent_crack = @hash[:properties][:energy][:vent_crack]
+            # create the crack object for using default values
+            flow_exponent = crack_defaults[:flow_exponent][:default].to_f
+            os_crack = OpenStudio::Model::AirflowNetworkCrack.new(
+              openstudio_model, vent_crack[:flow_coefficient], flow_exponent,
+              $afn_reference_crack)
+
+            # assign the flow exponent if it's specified
+            if vent_crack[:flow_exponent]
+              os_crack.setAirMassFlowExponent(vent_crack[:flow_exponent])
+            end
 
-          # if it's a Surface boundary condition ensure the neighbor is not written as a duplicate
-          if @hash[:boundary_condition][:type] == 'Surface'
-            $interior_afn_srf_hash[@hash[:boundary_condition][:boundary_condition_objects][0]] = true
-          end
+            # if it's a Surface boundary condition ensure the neighbor is not written as a duplicate
+            if @hash[:boundary_condition][:type] == 'Surface'
+              $interior_afn_srf_hash[@hash[:boundary_condition][:boundary_condition_objects][0]] = true
+            end
 
-          # create the AirflowNetworkSurface
-          os_afn_srf = os_surface.getAirflowNetworkSurface(os_crack)
+            # create the AirflowNetworkSurface
+            os_afn_srf = os_surface.getAirflowNetworkSurface(os_crack)
 
+          end
         end
       end
 
@@ -206,7 +208,7 @@ module Honeybee
 
       # get the approriate construction id
       construction_id = nil
-      if @hash[:properties][:energy][:construction]
+      if @hash[:properties].key?(:energy) && @hash[:properties][:energy][:construction]
         construction_id = @hash[:properties][:energy][:construction]
       elsif @hash[:face_type] == 'Wall'
         construction_id = 'Generic Exterior Wall'

data/lib/to_openstudio/geometry/room.rb

@@ -84,26 +84,6 @@ module Honeybee
         os_thermal_zone.setDisplayName(@hash[:display_name])
       end
 
-      # assign the programtype
-      if @hash[:properties][:energy][:program_type]
-        space_type = openstudio_model.getSpaceTypeByName(@hash[:properties][:energy][:program_type])
-        unless space_type.empty?
-          space_type_object = space_type.get
-          os_space.setSpaceType(space_type_object)
-        end
-      end
-
-      # assign the constructionset
-      if @hash[:properties][:energy][:construction_set]
-        construction_set_identifier = @hash[:properties][:energy][:construction_set]
-        # gets default construction set assigned to room from openstudio_model
-        construction_set = openstudio_model.getDefaultConstructionSetByName(construction_set_identifier)
-        unless construction_set.empty?
-          default_construction_set = construction_set.get
-          os_space.setDefaultConstructionSet(default_construction_set)
-        end
-      end
-
       # assign the multiplier
       if @hash[:multiplier] and @hash[:multiplier] != 1
         os_thermal_zone.setMultiplier(@hash[:multiplier])
@@ -142,6 +122,28 @@ module Honeybee
       end
       os_space.setBuildingStory(story)
 
+      if @hash[:properties].key?(:energy)
+        # assign the programtype
+        if @hash[:properties][:energy][:program_type]
+          space_type = openstudio_model.getSpaceTypeByName(@hash[:properties][:energy][:program_type])
+          unless space_type.empty?
+            space_type_object = space_type.get
+            os_space.setSpaceType(space_type_object)
+          end
+        end
+  
+        # assign the constructionset
+        if @hash[:properties][:energy][:construction_set]
+          construction_set_identifier = @hash[:properties][:energy][:construction_set]
+          # gets default construction set assigned to room from openstudio_model
+          construction_set = openstudio_model.getDefaultConstructionSetByName(construction_set_identifier)
+          unless construction_set.empty?
+            default_construction_set = construction_set.get
+            os_space.setDefaultConstructionSet(default_construction_set)
+          end
+        end
+      end
+
       # keep track of all window ventilation objects
       window_vent = {}
 
@@ -162,9 +164,11 @@ module Honeybee
         # assign aperture-level shades if they exist
         if face[:apertures]
           face[:apertures].each do |aperture|
-            if aperture[:properties][:energy][:vent_opening]
-              window_vent[aperture[:identifier]] = \
-                [aperture[:properties][:energy][:vent_opening], aperture[:boundary_condition][:type]]
+            if aperture[:properties].key?(:energy)
+              if aperture[:properties][:energy][:vent_opening]
+                window_vent[aperture[:identifier]] = \
+                  [aperture[:properties][:energy][:vent_opening], aperture[:boundary_condition][:type]]
+              end
             end
             if aperture[:outdoor_shades]
               unless os_shd_group
@@ -180,9 +184,11 @@ module Honeybee
         # assign door-level shades if they exist
         if face[:doors]
           face[:doors].each do |door|
-            if door[:properties][:energy][:vent_opening]
-              window_vent[door[:identifier]] = \
-                [door[:properties][:energy][:vent_opening], door[:boundary_condition][:type]]
+            if door[:properties].key?(:energy)
+              if door[:properties][:energy][:vent_opening]
+                window_vent[door[:identifier]] = \
+                  [door[:properties][:energy][:vent_opening], door[:boundary_condition][:type]]
+              end
             end
             if door[:outdoor_shades]
               unless os_shd_group
@@ -196,7 +202,7 @@ module Honeybee
         end
 
         # assign interior constructions for adiabatic Faces
-        if !face[:properties][:energy][:construction]
+        if face[:properties].key?(:energy) && !face[:properties][:energy][:construction]
           if face[:boundary_condition][:type] == 'Adiabatic'
             # assign default interior construction for Adiabatic Faces
             if face[:face_type] != 'Wall'
@@ -212,7 +218,7 @@ module Honeybee
         if face[:face_type] == 'AirBoundary'
           # assign default air boundary construction for AirBoundary face types
           air_construction = closest_air_construction(openstudio_model, os_space)
-          if !face[:properties][:energy][:construction]
+          if face[:properties].key?(:energy) && !face[:properties][:energy][:construction]
             unless air_construction.nil?
               os_surface.setConstruction(air_construction)
             end
@@ -256,164 +262,166 @@ module Honeybee
       end
 
       #check whether there are any load objects on the room overriding the programtype
-      if @hash[:properties][:energy][:people]
-        unique_program = get_unique_space_type(openstudio_model, os_space)
-        unique_program_ppl = unique_program.people
-        unless unique_program_ppl.empty?  # remove the previous load definition
-          unique_program_ppl[0].remove()
+      if @hash[:properties].key?(:energy)
+        if @hash[:properties][:energy][:people]
+          unique_program = get_unique_space_type(openstudio_model, os_space)
+          unique_program_ppl = unique_program.people
+          unless unique_program_ppl.empty?  # remove the previous load definition
+            unique_program_ppl[0].remove()
+          end
+          custom_people = PeopleAbridged.new(@hash[:properties][:energy][:people])
+          os_custom_people = custom_people.to_openstudio(openstudio_model)
+          os_custom_people.setSpaceType(unique_program)  # assign the new load definition
         end
-        custom_people = PeopleAbridged.new(@hash[:properties][:energy][:people])
-        os_custom_people = custom_people.to_openstudio(openstudio_model)
-        os_custom_people.setSpaceType(unique_program)  # assign the new load definition
-      end
 
-      # assign lighting if it exists
-      if @hash[:properties][:energy][:lighting]
-        unique_program = get_unique_space_type(openstudio_model, os_space)
-        unique_program_lght = unique_program.lights
-        unless unique_program_lght.empty?  # remove the previous load definition
-          unique_program_lght[0].remove()
+        # assign lighting if it exists
+        if @hash[:properties][:energy][:lighting]
+          unique_program = get_unique_space_type(openstudio_model, os_space)
+          unique_program_lght = unique_program.lights
+          unless unique_program_lght.empty?  # remove the previous load definition
+            unique_program_lght[0].remove()
+          end
+          custom_lighting = LightingAbridged.new(@hash[:properties][:energy][:lighting])
+          os_custom_lighting = custom_lighting.to_openstudio(openstudio_model)
+          os_custom_lighting.setSpaceType(unique_program)  # assign the new load definition
         end
-        custom_lighting = LightingAbridged.new(@hash[:properties][:energy][:lighting])
-        os_custom_lighting = custom_lighting.to_openstudio(openstudio_model)
-        os_custom_lighting.setSpaceType(unique_program)  # assign the new load definition
-      end
 
-      # assign electric equipment if it exists
-      if @hash[:properties][:energy][:electric_equipment]
-        unique_program = get_unique_space_type(openstudio_model, os_space)
-        unique_program_ele = unique_program.electricEquipment
-        unless unique_program_ele.empty?  # remove the previous load definition
-          unique_program_ele[0].remove()
+        # assign electric equipment if it exists
+        if @hash[:properties][:energy][:electric_equipment]
+          unique_program = get_unique_space_type(openstudio_model, os_space)
+          unique_program_ele = unique_program.electricEquipment
+          unless unique_program_ele.empty?  # remove the previous load definition
+            unique_program_ele[0].remove()
+          end
+          custom_electric_equipment = ElectricEquipmentAbridged.new(@hash[:properties][:energy][:electric_equipment])
+          os_custom_electric_equipment = custom_electric_equipment.to_openstudio(openstudio_model)
+          os_custom_electric_equipment.setSpaceType(unique_program)  # assign the new load definition
         end
-        custom_electric_equipment = ElectricEquipmentAbridged.new(@hash[:properties][:energy][:electric_equipment])
-        os_custom_electric_equipment = custom_electric_equipment.to_openstudio(openstudio_model)
-        os_custom_electric_equipment.setSpaceType(unique_program)  # assign the new load definition
-      end
 
-      # assign gas equipment if it exists
-      if @hash[:properties][:energy][:gas_equipment]
-        unique_program = get_unique_space_type(openstudio_model, os_space)
-        unique_program_gas = unique_program.gasEquipment
-        unless unique_program_gas.empty?  # remove the previous load definition
-          unique_program_gas[0].remove()
+        # assign gas equipment if it exists
+        if @hash[:properties][:energy][:gas_equipment]
+          unique_program = get_unique_space_type(openstudio_model, os_space)
+          unique_program_gas = unique_program.gasEquipment
+          unless unique_program_gas.empty?  # remove the previous load definition
+            unique_program_gas[0].remove()
+          end
+          custom_gas_equipment = GasEquipmentAbridged.new(@hash[:properties][:energy][:gas_equipment])
+          os_custom_gas_equipment = custom_gas_equipment.to_openstudio(openstudio_model)
+          os_custom_gas_equipment.setSpaceType(unique_program)  # assign the new load definition
         end
-        custom_gas_equipment = GasEquipmentAbridged.new(@hash[:properties][:energy][:gas_equipment])
-        os_custom_gas_equipment = custom_gas_equipment.to_openstudio(openstudio_model)
-        os_custom_gas_equipment.setSpaceType(unique_program)  # assign the new load definition
-      end
 
-      # assign service hot water if it exists
-      if @hash[:properties][:energy][:service_hot_water]
-        shw_space = ServiceHotWaterAbridged.new(@hash[:properties][:energy][:service_hot_water])
-        os_shw_space = shw_space.to_openstudio(
-          openstudio_model, os_space, @hash[:properties][:energy][:shw])
-        $shw_for_plant = shw_space
-      end
+        # assign service hot water if it exists
+        if @hash[:properties][:energy][:service_hot_water]
+          shw_space = ServiceHotWaterAbridged.new(@hash[:properties][:energy][:service_hot_water])
+          os_shw_space = shw_space.to_openstudio(
+            openstudio_model, os_space, @hash[:properties][:energy][:shw])
+          $shw_for_plant = shw_space
+        end
 
-      # assign infiltration if it exists
-      if @hash[:properties][:energy][:infiltration] && $use_simple_vent  # only use infiltration with simple ventilation
-        unique_program = get_unique_space_type(openstudio_model, os_space)
-        unique_program_inf = unique_program.spaceInfiltrationDesignFlowRates
-        unless unique_program_inf.empty?  # remove the previous load definition
-          unique_program_inf[0].remove()
+        # assign infiltration if it exists
+        if @hash[:properties][:energy][:infiltration] && $use_simple_vent  # only use infiltration with simple ventilation
+          unique_program = get_unique_space_type(openstudio_model, os_space)
+          unique_program_inf = unique_program.spaceInfiltrationDesignFlowRates
+          unless unique_program_inf.empty?  # remove the previous load definition
+            unique_program_inf[0].remove()
+          end
+          custom_infiltration = InfiltrationAbridged.new(@hash[:properties][:energy][:infiltration])
+          os_custom_infiltration = custom_infiltration.to_openstudio(openstudio_model)
+          os_custom_infiltration.setSpaceType(unique_program)  # assign the new load definition
         end
-        custom_infiltration = InfiltrationAbridged.new(@hash[:properties][:energy][:infiltration])
-        os_custom_infiltration = custom_infiltration.to_openstudio(openstudio_model)
-        os_custom_infiltration.setSpaceType(unique_program)  # assign the new load definition
-      end
 
-      # assign ventilation if it exists
-      if @hash[:properties][:energy][:ventilation]
-        unique_program = get_unique_space_type(openstudio_model, os_space)
-        unique_program.resetDesignSpecificationOutdoorAir()
-        custom_ventilation = VentilationAbridged.new(@hash[:properties][:energy][:ventilation])
-        os_custom_ventilation = custom_ventilation.to_openstudio(openstudio_model)
-        unique_program.setDesignSpecificationOutdoorAir(os_custom_ventilation)
-      end
+        # assign ventilation if it exists
+        if @hash[:properties][:energy][:ventilation]
+          unique_program = get_unique_space_type(openstudio_model, os_space)
+          unique_program.resetDesignSpecificationOutdoorAir()
+          custom_ventilation = VentilationAbridged.new(@hash[:properties][:energy][:ventilation])
+          os_custom_ventilation = custom_ventilation.to_openstudio(openstudio_model)
+          unique_program.setDesignSpecificationOutdoorAir(os_custom_ventilation)
+        end
 
-      # assign setpoint if it exists
-      if @hash[:properties][:energy][:setpoint]
-        # thermostat object is created because heating and cooling schedule are required
-        setpoint_thermostat_space = SetpointThermostat.new(@hash[:properties][:energy][:setpoint])
-        os_setpoint_thermostat_space = setpoint_thermostat_space.to_openstudio(openstudio_model)
-        #set thermostat to thermal zone
-        os_thermal_zone.setThermostatSetpointDualSetpoint(os_setpoint_thermostat_space)
-        # humidistat object is created if humidifying or dehumidifying schedule is specified
-        if @hash[:properties][:energy][:setpoint][:humidifying_schedule] or @hash[:properties][:energy][:setpoint][:dehumidifying_schedule]
-          setpoint_humidistat_space = SetpointHumidistat.new(@hash[:properties][:energy][:setpoint])
-          os_setpoint_humidistat_space = setpoint_humidistat_space.to_openstudio(openstudio_model)
-          os_thermal_zone.setZoneControlHumidistat(os_setpoint_humidistat_space)
+        # assign setpoint if it exists
+        if @hash[:properties][:energy][:setpoint]
+          # thermostat object is created because heating and cooling schedule are required
+          setpoint_thermostat_space = SetpointThermostat.new(@hash[:properties][:energy][:setpoint])
+          os_setpoint_thermostat_space = setpoint_thermostat_space.to_openstudio(openstudio_model)
+          #set thermostat to thermal zone
+          os_thermal_zone.setThermostatSetpointDualSetpoint(os_setpoint_thermostat_space)
+          # humidistat object is created if humidifying or dehumidifying schedule is specified
+          if @hash[:properties][:energy][:setpoint][:humidifying_schedule] or @hash[:properties][:energy][:setpoint][:dehumidifying_schedule]
+            setpoint_humidistat_space = SetpointHumidistat.new(@hash[:properties][:energy][:setpoint])
+            os_setpoint_humidistat_space = setpoint_humidistat_space.to_openstudio(openstudio_model)
+            os_thermal_zone.setZoneControlHumidistat(os_setpoint_humidistat_space)
+          end
         end
-      end
 
-      # assign daylight control if it exists
-      if @hash[:properties][:energy][:daylighting_control]
-        dl_control = DaylightingControl.new(@hash[:properties][:energy][:daylighting_control])
-        os_dl_control = dl_control.to_openstudio(openstudio_model, os_thermal_zone, os_space)
-      end
+        # assign daylight control if it exists
+        if @hash[:properties][:energy][:daylighting_control]
+          dl_control = DaylightingControl.new(@hash[:properties][:energy][:daylighting_control])
+          os_dl_control = dl_control.to_openstudio(openstudio_model, os_thermal_zone, os_space)
+        end
 
-      # assign window ventilation objects if they exist
-      if $use_simple_vent && !window_vent.empty?  # write simple WindAndStack ventilation
-        window_vent.each do |sub_f_id, open_prop|
-          opening = open_prop[0]
-          bc = open_prop[1]
-          if bc == 'Outdoors'
+        # assign window ventilation objects if they exist
+        if $use_simple_vent && !window_vent.empty?  # write simple WindAndStack ventilation
+          window_vent.each do |sub_f_id, open_prop|
+            opening = open_prop[0]
+            bc = open_prop[1]
+            if bc == 'Outdoors'
+              opt_sub_f = openstudio_model.getSubSurfaceByName(sub_f_id)
+              unless opt_sub_f.empty?
+                sub_f = opt_sub_f.get
+                vent_open = VentilationOpening.new(opening)
+                os_vent_open = vent_open.to_openstudio(
+                  openstudio_model, sub_f, @hash[:properties][:energy][:window_vent_control])
+                os_vent_open.addToThermalZone(os_thermal_zone)
+              end
+            end
+          end
+        elsif !$use_simple_vent  # we're using the AFN!
+          # write an AirflowNetworkZone object in for the Room
+          os_afn_room_node = os_thermal_zone.getAirflowNetworkZone
+          os_afn_room_node.setVentilationControlMode('NoVent')
+          # write the opening objects for each Aperture / Door
+          operable_subfs = []  # collect the sub-face objects for the EMS
+          opening_factors = []  # collect the maximum opening factors for the EMS
+          window_vent.each do |sub_f_id, open_prop|
+            opening = open_prop[0]
             opt_sub_f = openstudio_model.getSubSurfaceByName(sub_f_id)
             unless opt_sub_f.empty?
               sub_f = opt_sub_f.get
-              vent_open = VentilationOpening.new(opening)
-              os_vent_open = vent_open.to_openstudio(
-                openstudio_model, sub_f, @hash[:properties][:energy][:window_vent_control])
-              os_vent_open.addToThermalZone(os_thermal_zone)
-            end
-          end
-        end
-      elsif !$use_simple_vent  # we're using the AFN!
-        # write an AirflowNetworkZone object in for the Room
-        os_afn_room_node = os_thermal_zone.getAirflowNetworkZone
-        os_afn_room_node.setVentilationControlMode('NoVent')
-        # write the opening objects for each Aperture / Door
-        operable_subfs = []  # collect the sub-face objects for the EMS
-        opening_factors = []  # collect the maximum opening factors for the EMS
-        window_vent.each do |sub_f_id, open_prop|
-          opening = open_prop[0]
-          opt_sub_f = openstudio_model.getSubSurfaceByName(sub_f_id)
-          unless opt_sub_f.empty?
-            sub_f = opt_sub_f.get
-            if sub_f.adjacentSubSurface.empty?  # not an interior window that's already in the AFN
-              vent_open = VentilationOpening.new(opening)
-              open_fac = vent_open.to_openstudio_afn(openstudio_model, sub_f)
-              unless open_fac.nil?  # nil is used for horizontal exterior skylights
-                operable_subfs << sub_f
-                opening_factors << open_fac
+              if sub_f.adjacentSubSurface.empty?  # not an interior window that's already in the AFN
+                vent_open = VentilationOpening.new(opening)
+                open_fac = vent_open.to_openstudio_afn(openstudio_model, sub_f)
+                unless open_fac.nil?  # nil is used for horizontal exterior skylights
+                  operable_subfs << sub_f
+                  opening_factors << open_fac
+                end
               end
             end
           end
+          # add the control startegy of the ventilation openings using the EMS
+          if @hash[:properties][:energy][:window_vent_control]
+            vent_control = VentilationControlAbridged.new(@hash[:properties][:energy][:window_vent_control])
+            vent_control.to_openstudio(
+              openstudio_model, os_thermal_zone, operable_subfs, opening_factors)
+          end
         end
-        # add the control startegy of the ventilation openings using the EMS
-        if @hash[:properties][:energy][:window_vent_control]
-          vent_control = VentilationControlAbridged.new(@hash[:properties][:energy][:window_vent_control])
-          vent_control.to_openstudio(
-            openstudio_model, os_thermal_zone, operable_subfs, opening_factors)
-        end
-      end
 
-      # assign any internal masses if specified
-      if @hash[:properties][:energy][:internal_masses]
-        @hash[:properties][:energy][:internal_masses].each do |int_mass|
-          hb_int_mass = InternalMassAbridged.new(int_mass)
-          os_int_mass = hb_int_mass.to_openstudio(openstudio_model, os_space)
-          os_int_mass.setSpace(os_space)
+        # assign any internal masses if specified
+        if @hash[:properties][:energy][:internal_masses]
+          @hash[:properties][:energy][:internal_masses].each do |int_mass|
+            hb_int_mass = InternalMassAbridged.new(int_mass)
+            os_int_mass = hb_int_mass.to_openstudio(openstudio_model, os_space)
+            os_int_mass.setSpace(os_space)
+          end
         end
-      end
 
-      # assign any process loads if specified
-      if @hash[:properties][:energy][:process_loads]
-        @hash[:properties][:energy][:process_loads].each do |p_load|
-          hb_p_load = ProcessAbridged.new(p_load)
-          os_p_load = hb_p_load.to_openstudio(openstudio_model)
-          os_p_load.setSpace(os_space)
+        # assign any process loads if specified
+        if @hash[:properties][:energy][:process_loads]
+          @hash[:properties][:energy][:process_loads].each do |p_load|
+            hb_p_load = ProcessAbridged.new(p_load)
+            os_p_load = hb_p_load.to_openstudio(openstudio_model)
+            os_p_load.setSpace(os_space)
+          end
         end
       end
 

data/lib/to_openstudio/geometry/shade.rb

@@ -61,23 +61,26 @@ module Honeybee
       unless @hash[:display_name].nil?
         os_shading_surface.setDisplayName(@hash[:display_name])
       end
-      # assign the construction if it exists
-      if @hash[:properties][:energy][:construction]
-        construction_identifier = @hash[:properties][:energy][:construction]
-        construction = openstudio_model.getConstructionByName(construction_identifier)
-        unless construction.empty?
-          os_construction = construction.get
-          os_shading_surface.setConstruction(os_construction)
+
+      if @hash[:properties].key?(:energy)
+        # assign the construction if it exists
+        if @hash[:properties][:energy][:construction]
+          construction_identifier = @hash[:properties][:energy][:construction]
+          construction = openstudio_model.getConstructionByName(construction_identifier)
+          unless construction.empty?
+            os_construction = construction.get
+            os_shading_surface.setConstruction(os_construction)
+          end
         end
-      end
 
-      # assign the transmittance schedule if it exists
-      if @hash[:properties][:energy][:transmittance_schedule]
-        schedule_identifier = @hash[:properties][:energy][:transmittance_schedule]
-        schedule = openstudio_model.getScheduleByName(schedule_identifier)
-        unless schedule.empty?
-          os_schedule = schedule.get
-          os_shading_surface.setTransmittanceSchedule(os_schedule)
+        # assign the transmittance schedule if it exists
+        if @hash[:properties][:energy][:transmittance_schedule]
+          schedule_identifier = @hash[:properties][:energy][:transmittance_schedule]
+          schedule = openstudio_model.getScheduleByName(schedule_identifier)
+          unless schedule.empty?
+            os_schedule = schedule.get
+            os_shading_surface.setTransmittanceSchedule(os_schedule)
+          end
         end
       end
 

data/lib/to_openstudio/hvac/radiant.rb

@@ -150,7 +150,7 @@ class OpenStudio::Model::Model
       if radiant_type == 'floorwithcarpet'
         radiant_type = 'floor'
         include_carpet = true
-      elsif radiant_type == 'ceilingmetalpanel'
+      elsif radiant_type == 'ceilingmetalpanel' || radiant_type == 'floorwithhardwood'
         control_strategy = 'default'
       end
     else
@@ -251,6 +251,7 @@ class OpenStudio::Model::Model
         end
       end
     end
+
     # if no values were set, just set the system to be on all of the time
     if start_hour == 12 or start_hour == 0
       start_hour = 1
@@ -282,15 +283,30 @@ class OpenStudio::Model::Model
     OpenStudio.logFree(OpenStudio::Warn, 'openstudio.Model.Model', "Replacing constructions with new radiant slab constructions.")
 
     # create materials
+    # concrete slab materials
     mat_concrete_3_5in = OpenStudio::Model::StandardOpaqueMaterial.new(self, 'MediumRough', 0.0889, 2.31, 2322, 832)
     mat_concrete_3_5in.setName('Radiant Slab Concrete - 3.5 in.')
     mat_concrete_1_5in = OpenStudio::Model::StandardOpaqueMaterial.new(self, 'MediumRough', 0.0381, 2.31, 2322, 832)
     mat_concrete_1_5in.setName('Radiant Slab Concrete - 1.5 in')
 
-    metal_mat = OpenStudio::Model::StandardOpaqueMaterial.new(self, 'MediumSmooth', 0.003175, 30, 7680, 418)
-    metal_mat.setName('Radiant Metal Layer - 0.125 in')
-    air_gap_map = OpenStudio::Model::MasslessOpaqueMaterial.new(self, 'Smooth', 0.004572)
-    air_gap_map.setName('Generic Ceiling Air Gap - R 0.025')
+    metal_mat = nil
+    air_gap_mat = nil
+    wood_mat = nil
+    wood_floor_insulation = nil
+    gypsum_ceiling_mat = nil
+    if radiant_type == 'ceilingmetalpanel'
+      metal_mat = OpenStudio::Model::StandardOpaqueMaterial.new(self, 'MediumSmooth', 0.003175, 30, 7680, 418)
+      metal_mat.setName('Radiant Metal Layer - 0.125 in')
+      air_gap_mat = OpenStudio::Model::MasslessOpaqueMaterial.new(self, 'Smooth', 0.004572)
+      air_gap_mat.setName('Generic Ceiling Air Gap - R 0.025')
+    elsif radiant_type == 'floorwithhardwood'
+      wood_mat = OpenStudio::Model::StandardOpaqueMaterial.new(self, 'MediumSmooth', 0.01905, 0.15, 608, 1629)
+      wood_mat.setName('Radiant Hardwood Flooring - 0.75 in')
+      wood_floor_insulation = OpenStudio::Model::StandardOpaqueMaterial.new(self, 'Rough', 0.0508, 0.02, 56.06, 1210)
+      wood_floor_insulation.setName('Radiant Subfloor Insulation - 4.0 in')
+      gypsum_ceiling_mat = OpenStudio::Model::StandardOpaqueMaterial.new(self, 'Smooth', 0.0127, 0.16, 800, 1089)
+      gypsum_ceiling_mat.setName('Gypsum Ceiling for Radiant Hardwood Flooring - 0.5 in')
+    end
 
     mat_refl_roof_membrane = self.getStandardOpaqueMaterialByName('Roof Membrane - Highly Reflective')
     if mat_refl_roof_membrane.is_initialized
@@ -331,83 +347,125 @@ class OpenStudio::Model::Model
     # create radiant internal source constructions
     OpenStudio.logFree(OpenStudio::Warn, 'openstudio.Model.Model', 'New constructions exclude the metal deck, as high thermal diffusivity materials cause errors in EnergyPlus internal source construction calculations.')
 
-    layers = []
-    layers << mat_slab_insulation
-    layers << mat_concrete_3_5in
-    layers << mat_concrete_1_5in
-    layers << mat_thin_carpet_tile if include_carpet
-    radiant_ground_slab_construction = OpenStudio::Model::ConstructionWithInternalSource.new(layers)
-    radiant_ground_slab_construction.setName('Radiant Ground Slab Construction')
-    radiant_ground_slab_construction.setSourcePresentAfterLayerNumber(2)
-    radiant_ground_slab_construction.setTemperatureCalculationRequestedAfterLayerNumber(3)
-    radiant_ground_slab_construction.setTubeSpacing(0.2286) # 9 inches
-
-    layers = []
-    layers << mat_ext_insulation
-    layers << mat_concrete_3_5in
-    layers << mat_concrete_1_5in
-    layers << mat_thin_carpet_tile if include_carpet
-    radiant_exterior_slab_construction = OpenStudio::Model::ConstructionWithInternalSource.new(layers)
-    radiant_exterior_slab_construction.setName('Radiant Exterior Slab Construction')
-    radiant_exterior_slab_construction.setSourcePresentAfterLayerNumber(2)
-    radiant_exterior_slab_construction.setTemperatureCalculationRequestedAfterLayerNumber(3)
-    radiant_exterior_slab_construction.setTubeSpacing(0.2286) # 9 inches
-
-    layers = []
-    layers << mat_concrete_3_5in
-    layers << mat_concrete_1_5in
-    layers << mat_thin_carpet_tile if include_carpet
-    radiant_interior_floor_slab_construction = OpenStudio::Model::ConstructionWithInternalSource.new(layers)
-    radiant_interior_floor_slab_construction.setName('Radiant Interior Floor Slab Construction')
-    radiant_interior_floor_slab_construction.setSourcePresentAfterLayerNumber(1)
-    radiant_interior_floor_slab_construction.setTemperatureCalculationRequestedAfterLayerNumber(2)
-    radiant_interior_floor_slab_construction.setTubeSpacing(0.2286) # 9 inches
-
-    layers = []
-    layers << mat_thin_carpet_tile if include_carpet
-    layers << mat_concrete_3_5in
-    layers << mat_concrete_1_5in
-    radiant_interior_ceiling_slab_construction = OpenStudio::Model::ConstructionWithInternalSource.new(layers)
-    radiant_interior_ceiling_slab_construction.setName('Radiant Interior Ceiling Slab Construction')
-    slab_src_loc = include_carpet ? 2 : 1
-    radiant_interior_ceiling_slab_construction.setSourcePresentAfterLayerNumber(slab_src_loc)
-    radiant_interior_ceiling_slab_construction.setTemperatureCalculationRequestedAfterLayerNumber(slab_src_loc + 1)
-    radiant_interior_ceiling_slab_construction.setTubeSpacing(0.2286) # 9 inches
-
-    layers = []
-    layers << mat_refl_roof_membrane
-    layers << mat_roof_insulation
-    layers << mat_concrete_3_5in
-    layers << mat_concrete_1_5in
-    radiant_ceiling_slab_construction = OpenStudio::Model::ConstructionWithInternalSource.new(layers)
-    radiant_ceiling_slab_construction.setName('Radiant Exterior Ceiling Slab Construction')
-    radiant_ceiling_slab_construction.setSourcePresentAfterLayerNumber(3)
-    radiant_ceiling_slab_construction.setTemperatureCalculationRequestedAfterLayerNumber(4)
-    radiant_ceiling_slab_construction.setTubeSpacing(0.2286) # 9 inches
-
-    layers = []
-    layers << mat_concrete_3_5in
-    layers << air_gap_map
-    layers << metal_mat
-    layers << metal_mat
-    radiant_interior_ceiling_metal_construction = OpenStudio::Model::ConstructionWithInternalSource.new(layers)
-    radiant_interior_ceiling_metal_construction.setName('Radiant Interior Ceiling Metal Construction')
-    radiant_interior_ceiling_metal_construction.setSourcePresentAfterLayerNumber(3)
-    radiant_interior_ceiling_metal_construction.setTemperatureCalculationRequestedAfterLayerNumber(4)
-    radiant_interior_ceiling_metal_construction.setTubeSpacing(0.1524) # 6 inches
-    
-    layers = []
-    layers << mat_refl_roof_membrane
-    layers << mat_roof_insulation
-    layers << mat_concrete_3_5in
-    layers << air_gap_map
-    layers << metal_mat
-    layers << metal_mat
-    radiant_ceiling_metal_construction = OpenStudio::Model::ConstructionWithInternalSource.new(layers)
-    radiant_ceiling_metal_construction.setName('Radiant Ceiling Metal Construction')
-    radiant_ceiling_metal_construction.setSourcePresentAfterLayerNumber(5)
-    radiant_ceiling_metal_construction.setTemperatureCalculationRequestedAfterLayerNumber(6)
-    radiant_ceiling_metal_construction.setTubeSpacing(0.1524) # 6 inches
+    radiant_ground_slab_construction = nil
+    radiant_exterior_slab_construction = nil
+    radiant_interior_floor_slab_construction = nil
+    radiant_interior_ceiling_slab_construction = nil
+    radiant_ceiling_slab_construction = nil
+    radiant_interior_ceiling_metal_construction = nil
+    radiant_ceiling_metal_construction = nil
+
+    if radiant_type == 'floor'
+      layers = []
+      layers << mat_slab_insulation
+      layers << mat_concrete_3_5in
+      layers << mat_concrete_1_5in
+      layers << mat_thin_carpet_tile if include_carpet
+      radiant_ground_slab_construction = OpenStudio::Model::ConstructionWithInternalSource.new(layers)
+      radiant_ground_slab_construction.setName('Radiant Ground Slab Construction')
+      radiant_ground_slab_construction.setSourcePresentAfterLayerNumber(2)
+      radiant_ground_slab_construction.setTemperatureCalculationRequestedAfterLayerNumber(3)
+      radiant_ground_slab_construction.setTubeSpacing(0.2286) # 9 inches
+
+      layers = []
+      layers << mat_ext_insulation
+      layers << mat_concrete_3_5in
+      layers << mat_concrete_1_5in
+      layers << mat_thin_carpet_tile if include_carpet
+      radiant_exterior_slab_construction = OpenStudio::Model::ConstructionWithInternalSource.new(layers)
+      radiant_exterior_slab_construction.setName('Radiant Exterior Slab Construction')
+      radiant_exterior_slab_construction.setSourcePresentAfterLayerNumber(2)
+      radiant_exterior_slab_construction.setTemperatureCalculationRequestedAfterLayerNumber(3)
+      radiant_exterior_slab_construction.setTubeSpacing(0.2286) # 9 inches
+
+      layers = []
+      layers << mat_concrete_3_5in
+      layers << mat_concrete_1_5in
+      layers << mat_thin_carpet_tile if include_carpet
+      radiant_interior_floor_slab_construction = OpenStudio::Model::ConstructionWithInternalSource.new(layers)
+      radiant_interior_floor_slab_construction.setName('Radiant Interior Floor Slab Construction')
+      radiant_interior_floor_slab_construction.setSourcePresentAfterLayerNumber(1)
+      radiant_interior_floor_slab_construction.setTemperatureCalculationRequestedAfterLayerNumber(2)
+      radiant_interior_floor_slab_construction.setTubeSpacing(0.2286) # 9 inches
+    elsif radiant_type == 'ceiling'
+      layers = []
+      layers << mat_thin_carpet_tile if include_carpet
+      layers << mat_concrete_3_5in
+      layers << mat_concrete_1_5in
+      radiant_interior_ceiling_slab_construction = OpenStudio::Model::ConstructionWithInternalSource.new(layers)
+      radiant_interior_ceiling_slab_construction.setName('Radiant Interior Ceiling Slab Construction')
+      slab_src_loc = include_carpet ? 2 : 1
+      radiant_interior_ceiling_slab_construction.setSourcePresentAfterLayerNumber(slab_src_loc)
+      radiant_interior_ceiling_slab_construction.setTemperatureCalculationRequestedAfterLayerNumber(slab_src_loc + 1)
+      radiant_interior_ceiling_slab_construction.setTubeSpacing(0.2286) # 9 inches
+
+      layers = []
+      layers << mat_refl_roof_membrane
+      layers << mat_roof_insulation
+      layers << mat_concrete_3_5in
+      layers << mat_concrete_1_5in
+      radiant_ceiling_slab_construction = OpenStudio::Model::ConstructionWithInternalSource.new(layers)
+      radiant_ceiling_slab_construction.setName('Radiant Exterior Ceiling Slab Construction')
+      radiant_ceiling_slab_construction.setSourcePresentAfterLayerNumber(3)
+      radiant_ceiling_slab_construction.setTemperatureCalculationRequestedAfterLayerNumber(4)
+      radiant_ceiling_slab_construction.setTubeSpacing(0.2286) # 9 inches
+    elsif radiant_type == 'ceilingmetalpanel'
+      layers = []
+      layers << mat_concrete_3_5in
+      layers << air_gap_mat
+      layers << metal_mat
+      layers << metal_mat
+      radiant_interior_ceiling_metal_construction = OpenStudio::Model::ConstructionWithInternalSource.new(layers)
+      radiant_interior_ceiling_metal_construction.setName('Radiant Interior Ceiling Metal Construction')
+      radiant_interior_ceiling_metal_construction.setSourcePresentAfterLayerNumber(3)
+      radiant_interior_ceiling_metal_construction.setTemperatureCalculationRequestedAfterLayerNumber(4)
+      radiant_interior_ceiling_metal_construction.setTubeSpacing(0.1524) # 6 inches
+      
+      layers = []
+      layers << mat_refl_roof_membrane
+      layers << mat_roof_insulation
+      layers << mat_concrete_3_5in
+      layers << air_gap_mat
+      layers << metal_mat
+      layers << metal_mat
+      radiant_ceiling_metal_construction = OpenStudio::Model::ConstructionWithInternalSource.new(layers)
+      radiant_ceiling_metal_construction.setName('Radiant Ceiling Metal Construction')
+      radiant_ceiling_metal_construction.setSourcePresentAfterLayerNumber(5)
+      radiant_ceiling_metal_construction.setTemperatureCalculationRequestedAfterLayerNumber(6)
+      radiant_ceiling_metal_construction.setTubeSpacing(0.1524) # 6 inches
+    elsif radiant_type == 'floorwithhardwood'
+      layers = []
+      layers << mat_slab_insulation
+      layers << mat_concrete_3_5in
+      layers << wood_mat
+      layers << mat_thin_carpet_tile if include_carpet
+      radiant_ground_wood_construction = OpenStudio::Model::ConstructionWithInternalSource.new(layers)
+      radiant_ground_wood_construction.setName('Radiant Ground Slab Wood Floor Construction')
+      radiant_ground_wood_construction.setSourcePresentAfterLayerNumber(2)
+      radiant_ground_wood_construction.setTemperatureCalculationRequestedAfterLayerNumber(3)
+      radiant_ground_wood_construction.setTubeSpacing(0.2286) # 9 inches
+
+      layers = []
+      layers << mat_ext_insulation
+      layers << wood_mat
+      layers << mat_thin_carpet_tile if include_carpet
+      radiant_exterior_wood_construction = OpenStudio::Model::ConstructionWithInternalSource.new(layers)
+      radiant_exterior_wood_construction.setName('Radiant Exterior Wood Floor Construction')
+      radiant_exterior_wood_construction.setSourcePresentAfterLayerNumber(1)
+      radiant_exterior_wood_construction.setTemperatureCalculationRequestedAfterLayerNumber(2)
+      radiant_exterior_wood_construction.setTubeSpacing(0.2286) # 9 inches
+
+      layers = []
+      layers << gypsum_ceiling_mat
+      layers << wood_floor_insulation
+      layers << wood_mat
+      layers << mat_thin_carpet_tile if include_carpet
+      radiant_interior_wood_floor_construction = OpenStudio::Model::ConstructionWithInternalSource.new(layers)
+      radiant_interior_wood_floor_construction.setName('Radiant Interior Wooden Floor Construction')
+      radiant_interior_wood_floor_construction.setSourcePresentAfterLayerNumber(2)
+      radiant_interior_wood_floor_construction.setTemperatureCalculationRequestedAfterLayerNumber(3)
+      radiant_interior_wood_floor_construction.setTubeSpacing(0.2286) # 9 inches
+    end
 
     # default temperature controls for radiant system
     zn_radiant_htg_dsgn_temp_f = 68.0
@@ -488,6 +546,16 @@ class OpenStudio::Model::Model
                 surface.setConstruction(radiant_interior_ceiling_metal_construction)
               end
             end
+          elsif radiant_type == 'floorwithhardwood'
+            if surface.surfaceType == 'Floor'
+              if surface.outsideBoundaryCondition == 'Ground'
+                surface.setConstruction(radiant_ground_wood_construction)
+              elsif surface.outsideBoundaryCondition == 'Outdoors'
+                surface.setConstruction(radiant_exterior_wood_construction)
+              else # interior floor
+                surface.setConstruction(radiant_interior_wood_floor_construction)
+              end
+            end
           end
         end
       end
@@ -500,6 +568,8 @@ class OpenStudio::Model::Model
         radiant_loop.setRadiantSurfaceType('Ceilings')
       elsif radiant_type == 'ceilingmetalpanel'
         radiant_loop.setRadiantSurfaceType('Ceilings')
+      elsif radiant_type == 'floorwithhardwood'
+        radiant_loop.setRadiantSurfaceType('Floors')
       end
 
       # radiant loop layout details

data/lib/to_openstudio/hvac/template.rb

@@ -260,6 +260,10 @@ module Honeybee
           h_stat = zone.zoneControlHumidistat
           unless h_stat.empty?
             humidistat_exists = true
+            if equipment_type.to_s.include? 'DOAS'
+              z_sizing = zone.sizingZone
+              z_sizing.setDedicatedOutdoorAirSystemControlStrategy('NeutralDehumidifiedSupplyAir')
+            end
           end
         end
         if humidistat_exists
@@ -269,12 +273,6 @@ module Honeybee
         end
       end
 
-      # set all plants to non-coincident sizing to avoid simualtion control issues on design days
-      openstudio_model.getPlantLoops.each do |loop|
-        sizing = loop.sizingPlant
-        sizing.setSizingOption('NonCoincident')
-      end
-
     end
 
   private

data/lib/to_openstudio/model.rb

@@ -109,7 +109,7 @@ module Honeybee
 
       # initialize a global variable for whether the AFN is used instead of simple ventilation
       $use_simple_vent = true
-      if @hash[:properties][:energy][:ventilation_simulation_control]
+      if @hash[:properties].key?(:energy) && @hash[:properties][:energy][:ventilation_simulation_control]
         vent_sim_control = @hash[:properties][:energy][:ventilation_simulation_control]
         if vent_sim_control[:vent_control_type] && vent_sim_control[:vent_control_type] != 'SingleZone'
           $use_simple_vent = false
@@ -129,42 +129,44 @@ module Honeybee
       $shw_for_plant = nil  # track whether a hot water plant is needed
 
       # create all of the non-geometric model elements
-      if log_report  # schedules are used by all other objects and come first
-        puts 'Translating Schedules'
-      end
-      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], false, true)
-      end
+      if @hash[:properties].key?(:energy)
+        if log_report  # schedules are used by all other objects and come first
+          puts 'Translating Schedules'
+        end
+        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], false, true)
+        end
 
-      if log_report
-        puts 'Translating Materials'
-      end
-      if @hash[:properties][:energy][:materials]
-        create_materials(@hash[:properties][:energy][:materials])
-      end
+        if log_report
+          puts 'Translating Materials'
+        end
+        if @hash[:properties][:energy][:materials]
+          create_materials(@hash[:properties][:energy][:materials])
+        end
 
-      if log_report
-        puts 'Translating Constructions'
-      end
-      if @hash[:properties][:energy][:constructions]
-        create_constructions(@hash[:properties][:energy][:constructions])
-      end
+        if log_report
+          puts 'Translating Constructions'
+        end
+        if @hash[:properties][:energy][:constructions]
+          create_constructions(@hash[:properties][:energy][:constructions])
+        end
 
-      if log_report
-        puts 'Translating ConstructionSets'
-      end
-      if @hash[:properties][:energy][:construction_sets]
-        create_construction_sets(@hash[:properties][:energy][:construction_sets])
-      end
+        if log_report
+          puts 'Translating ConstructionSets'
+        end
+        if @hash[:properties][:energy][:construction_sets]
+          create_construction_sets(@hash[:properties][:energy][:construction_sets])
+        end
 
-      if log_report
-        puts 'Translating ProgramTypes'
-      end
-      if @hash[:properties][:energy][:program_types]
-        create_program_types(@hash[:properties][:energy][:program_types])
+        if log_report
+          puts 'Translating ProgramTypes'
+        end
+        if @hash[:properties][:energy][:program_types]
+          create_program_types(@hash[:properties][:energy][:program_types])
+        end
       end
 
       # create the default construction set to catch any cases of unassigned constructions
@@ -196,8 +198,10 @@ module Honeybee
       if log_report
         puts 'Translating HVAC Systems'
       end
-      create_hvacs
-      create_hot_water_plant
+      if @hash[:properties].key?(:energy)
+        create_hvacs
+        create_hot_water_plant
+      end
 
       if log_report
         puts 'Translating Context Shade Geometry'
@@ -445,32 +449,34 @@ module Honeybee
           openstudio_room = room_object.to_openstudio(@openstudio_model)
 
           # for rooms with hot water objects definied in the ProgramType, make a new WaterUse:Equipment
-          if room[:properties][:energy][:program_type] && !room[:properties][:energy][:service_hot_water]
-            program_type_id = room[:properties][:energy][:program_type]
-            shw_hash = $programtype_shw_hash[program_type_id]
-            unless shw_hash.nil?
-              shw_object = ServiceHotWaterAbridged.new(shw_hash)
-              openstudio_shw = shw_object.to_openstudio(
-                @openstudio_model, openstudio_room, room[:properties][:energy][:shw])
-              $shw_for_plant = shw_object
+          if room[:properties].key?(:energy)
+            if room[:properties][:energy][:program_type] && !room[:properties][:energy][:service_hot_water]
+              program_type_id = room[:properties][:energy][:program_type]
+              shw_hash = $programtype_shw_hash[program_type_id]
+              unless shw_hash.nil?
+                shw_object = ServiceHotWaterAbridged.new(shw_hash)
+                openstudio_shw = shw_object.to_openstudio(
+                  @openstudio_model, openstudio_room, room[:properties][:energy][:shw])
+                $shw_for_plant = shw_object
+              end
             end
-          end
 
-          # for rooms with setpoint objects defined in the ProgramType, make a new thermostat
-          if room[:properties][:energy][:program_type] && !room[:properties][:energy][:setpoint]
-            thermal_zone = openstudio_room.thermalZone()
-            unless thermal_zone.empty?
-              thermal_zone_object = thermal_zone.get
-              program_type_id = room[:properties][:energy][:program_type]
-              setpoint_hash = $programtype_setpoint_hash[program_type_id]
-              unless setpoint_hash.nil?  # program type has no setpoint
-                thermostat_object = SetpointThermostat.new(setpoint_hash)
-                openstudio_thermostat = thermostat_object.to_openstudio(@openstudio_model)
-                thermal_zone_object.setThermostatSetpointDualSetpoint(openstudio_thermostat)
-                if setpoint_hash[:humidifying_schedule] or setpoint_hash[:dehumidifying_schedule]
-                  humidistat_object = SetpointHumidistat.new(setpoint_hash)
-                  openstudio_humidistat = humidistat_object.to_openstudio(@openstudio_model)
-                  thermal_zone_object.setZoneControlHumidistat(openstudio_humidistat)
+            # for rooms with setpoint objects defined in the ProgramType, make a new thermostat
+            if room[:properties][:energy][:program_type] && !room[:properties][:energy][:setpoint]
+              thermal_zone = openstudio_room.thermalZone()
+              unless thermal_zone.empty?
+                thermal_zone_object = thermal_zone.get
+                program_type_id = room[:properties][:energy][:program_type]
+                setpoint_hash = $programtype_setpoint_hash[program_type_id]
+                unless setpoint_hash.nil?  # program type has no setpoint
+                  thermostat_object = SetpointThermostat.new(setpoint_hash)
+                  openstudio_thermostat = thermostat_object.to_openstudio(@openstudio_model)
+                  thermal_zone_object.setThermostatSetpointDualSetpoint(openstudio_thermostat)
+                  if setpoint_hash[:humidifying_schedule] or setpoint_hash[:dehumidifying_schedule]
+                    humidistat_object = SetpointHumidistat.new(setpoint_hash)
+                    openstudio_humidistat = humidistat_object.to_openstudio(@openstudio_model)
+                    thermal_zone_object.setZoneControlHumidistat(openstudio_humidistat)
+                  end
                 end
               end
             end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: honeybee-openstudio
 version: !ruby/object:Gem::Version
-  version: 2.31.7
+  version: 2.31.10
 platform: ruby
 authors:
 - Tanushree Charan
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-05-18 00:00:00.000000000 Z
+date: 2022-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -177,6 +177,7 @@ files:
 - lib/from_openstudio/geometry/face.rb
 - lib/from_openstudio/geometry/room.rb
 - lib/from_openstudio/geometry/shade.rb
+- lib/from_openstudio/hvac/ideal_air.rb
 - lib/from_openstudio/load/daylight.rb
 - lib/from_openstudio/load/electric_equipment.rb
 - lib/from_openstudio/load/gas_equipment.rb