honeybee-openstudio 2.31.8 → 2.31.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cebfc1cf27c7e5d2e9bbfed6ece32096ec1cb0eb2a442783b9a7caeeddd136bc
-  data.tar.gz: 8960a24e1240a7d5e5db87a09455343afde150294bdb5f3fccc7093a67c2d2cc
+  metadata.gz: f9cfa9e82e9efaedde24e6ccfe30c4d7fe6cbd4259a81d36de9b8a9936b8259b
+  data.tar.gz: 6c47a045cf0684fdc33521ca96b6bd1fe3f27a52658fe774a6f76165ab3c87b0
 SHA512:
-  metadata.gz: 8ede21274b85d427693c6ca495ce6e100206dfd7af3fba82044f81309e5af160a61aae97ee476afa6bf4bfa3166ccde32ead3dbcbe7a448b9772c17c4b098311
-  data.tar.gz: f408bfd525685fc1c1e61a7cdd0aa4d0646c6e34e3a68e565f2876b217d031e14cd47523ea5d58de595679ca7ed272631709706c459f3ce51496597fdff3f64e
+  metadata.gz: ceefaa71ad6fe18240c21b2738ddf5741fc9620dcf63088c67511a0fedb132f1ea063879527183624f88a196826f7a58bef62ac9211e605f815264ae3add17c4
+  data.tar.gz: 4b6e648afaa694daa0e2246f4f5f6cf6c5dadb714e4b4fa7681919447fa24a37cb9bba9e6edbbb77a216e04005a0d23b5da7c8f38df07c60ad2ed2543767ad7d

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.8'
+  spec.version       = '2.31.9'
   spec.authors       = ['Tanushree Charan', 'Dan Macumber', 'Chris Mackey', 'Mostapha Sadeghipour Roudsari']
   spec.email         = ['tanushree.charan@nrel.gov', 'chris@ladybug.tools']
 

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/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.8
+  version: 2.31.9
 platform: ruby
 authors:
 - Tanushree Charan
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-05-24 00:00:00.000000000 Z
+date: 2022-05-26 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