honeybee-openstudio 2.4.0 → 2.6.0

data/lib/from_honeybee/hvac/ideal_air.rb

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

data/lib/from_honeybee/hvac/template.rb

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

data/lib/from_honeybee/model.rb

@@ -46,6 +46,7 @@ require 'from_honeybee/geometry/room'
 
 # import the HVAC objects
 require 'from_honeybee/hvac/ideal_air'
+require 'from_honeybee/hvac/template'
 
 # import the construction objects
 require 'from_honeybee/construction/opaque'
@@ -74,6 +75,9 @@ require 'from_honeybee/schedule/ruleset'
 require 'from_honeybee/load/setpoint_thermostat'
 require 'from_honeybee/load/setpoint_humidistat'
 
+# import the ventilative cooling objects
+require 'from_honeybee/ventcool/simulation'
+
 require 'openstudio'
 
 
@@ -157,11 +161,23 @@ module FromHoneybee
       building = @openstudio_model.getBuilding
       building.setStandardsBuildingType('MediumOffice')
 
+      # 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]
+        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
+          vsim_cntrl = VentilationSimulationControl.new(vent_sim_control)
+          $afn_reference_crack = vsim_cntrl.to_openstudio(@openstudio_model)
+        end
+      end
+
       # initialize global hashes for various model properties
       $gas_gap_hash = Hash.new  # hash to track gas gaps in case they are split by shades
       $air_boundary_hash = Hash.new  # hash to track any air boundary constructions
       $window_shade_hash = Hash.new  # hash to track any window constructions with shade
       $programtype_setpoint_hash = Hash.new  # hash to track Setpoint objects
+      $interior_afn_srf_hash = Hash.new  # track whether an adjacent surface is already in the AFN
 
       # create all of the non-geometric model elements
       if log_report
@@ -497,13 +513,14 @@ module FromHoneybee
 
     def create_hvacs
       if @hash[:properties][:energy][:hvacs]
+        $air_loop_count = 0  # track the total number of air loops in the model
         # gather all of the hashes of the HVACs
         hvac_hashes = Hash.new
         @hash[:properties][:energy][:hvacs].each do |hvac|
           hvac_hashes[hvac[:identifier]] = hvac
           hvac_hashes[hvac[:identifier]]['rooms'] = []
         end
-        # loop through the rooms and trach which are assigned to each HVAC
+        # loop through the rooms and track which are assigned to each HVAC
         if @hash[:rooms]
           @hash[:rooms].each do |room|
             if room[:properties][:energy][:hvac]
@@ -514,8 +531,7 @@ module FromHoneybee
 
         hvac_hashes.each_value do |hvac|
           system_type = hvac[:type]
-          case system_type
-          when 'IdealAirSystemAbridged'
+          if system_type == 'IdealAirSystemAbridged'
             ideal_air_system = IdealAirSystemAbridged.new(hvac)
             os_ideal_air_system = ideal_air_system.to_openstudio(@openstudio_model)
             hvac['rooms'].each do |room_id|
@@ -525,6 +541,9 @@ module FromHoneybee
                 os_ideal_air_system.addToThermalZone(os_thermal_zone)
               end
             end
+          elsif TemplateHVAC.types.include?(system_type)
+            template_system = TemplateHVAC.new(hvac)
+            os_template_system = template_system.to_openstudio(@openstudio_model, hvac['rooms'])
           end
         end
       end

data/lib/from_honeybee/program_type.rb

@@ -94,14 +94,14 @@ module FromHoneybee
         os_gas_equipment = gas_equipment.to_openstudio(openstudio_model)
         os_gas_equipment.setSpaceType(os_space_type)
       end
-        
+
       # assign infiltration
-      if @hash[:infiltration]
+      if @hash[:infiltration] && $use_simple_vent  # only use infiltration with simple ventilation
         infiltration = InfiltrationAbridged.new(@hash[:infiltration])
         os_infiltration = infiltration.to_openstudio(openstudio_model)
         os_infiltration.setSpaceType(os_space_type)
       end
-    
+
       # assign ventilation
       if @hash[:ventilation]
         ventilation = VentilationAbridged.new(@hash[:ventilation])

data/lib/from_honeybee/schedule/type_limit.rb

@@ -59,11 +59,11 @@ module FromHoneybee
       os_type_limit = OpenStudio::Model::ScheduleTypeLimits.new(openstudio_model)
       os_type_limit.setName(@hash[:identifier])
 
-      if @hash[:lower_limit] != nil and @hash[:lower_limit] != {'type': 'NoLimit'}
+      if @hash[:lower_limit] != nil and @hash[:lower_limit] != {:type => 'NoLimit'}
         os_type_limit.setLowerLimitValue(@hash[:lower_limit])
       end
 
-      if @hash[:upper_limit] != nil and @hash[:upper_limit] != {'type': 'NoLimit'}
+      if @hash[:upper_limit] != nil and @hash[:upper_limit] != {:type => 'NoLimit'}
         os_type_limit.setUpperLimitValue(@hash[:upper_limit])
       end
 

data/lib/from_honeybee/ventcool/control.rb

@@ -0,0 +1,161 @@
+# *******************************************************************************
+# Honeybee OpenStudio Gem, Copyright (c) 2020, Alliance for Sustainable 
+# Energy, LLC, Ladybug Tools LLC and other contributors. All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# (1) Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+#
+# (2) Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation
+# and/or other materials provided with the distribution.
+#
+# (3) Neither the name of the copyright holder nor the names of any contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission from the respective party.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S), ANY CONTRIBUTORS, THE
+# UNITED STATES GOVERNMENT, OR THE UNITED STATES DEPARTMENT OF ENERGY, NOR ANY OF
+# THEIR EMPLOYEES, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+# OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+# *******************************************************************************
+
+require 'from_honeybee/model_object'
+
+require 'openstudio'
+
+module FromHoneybee
+  class VentilationControl < ModelObject
+    attr_reader :errors, :warnings
+    @@outdoor_node = nil
+    @@program_manager = nil
+
+    def initialize(hash = {})
+      super(hash)
+    end
+
+    def defaults
+      @@schema[:components][:schemas][:VentilationControlAbridged][:properties]
+    end
+
+    def get_outdoor_node(openstudio_model)
+      # get the EMS sensor for the outdoor node if it exists or generate it if it doesn't
+      if @@outdoor_node.nil?
+        out_var = OpenStudio::Model::OutputVariable.new(
+          'Site Outdoor Air Drybulb Temperature', openstudio_model)
+        out_var.setReportingFrequency('Timestep')
+        out_var.setKeyValue('Environment')
+        @@outdoor_node = OpenStudio::Model::EnergyManagementSystemSensor.new(
+          openstudio_model, out_var)
+        @@outdoor_node.setName('Outdoor_Sensor')
+      end
+      @@outdoor_node
+    end
+
+    def get_program_manager(openstudio_model)
+      # get the EMS Program Manager for all window opening if it exists or generate it if it doesn't
+      if @@program_manager.nil?
+        @@program_manager = OpenStudio::Model::EnergyManagementSystemProgramCallingManager.new(
+          openstudio_model)
+        @@program_manager.setName('Temperature_Controlled_Window_Opening')
+        @@program_manager.setCallingPoint('BeginTimestepBeforePredictor')
+      end
+      @@program_manager
+      end
+
+    def to_openstudio(openstudio_model, parent_zone, vent_opening_surfaces, vent_opening_factors)
+      # Get the outdoor temperature sensor and the room air temperature sensor
+      out_air_temp = get_outdoor_node(openstudio_model)
+      in_var = OpenStudio::Model::OutputVariable.new('Zone Air Temperature', openstudio_model)
+      in_var.setReportingFrequency('Timestep')
+      zone_name = parent_zone.name
+      os_zone_name = 'Indoor'
+      unless zone_name.empty?
+        os_zone_name = zone_name.get
+        in_var.setKeyValue(os_zone_name)
+      end
+      in_air_temp = OpenStudio::Model::EnergyManagementSystemSensor.new(openstudio_model, in_var)
+      in_sensor_name = os_zone_name.delete(' ').delete('.') + '_Sensor'
+      in_air_temp.setName(in_sensor_name)
+
+      # create the actuators for each of the operaable windows
+      actuator_names = []
+      vent_opening_surfaces.each do |vent_srf|
+        window_act = OpenStudio::Model::EnergyManagementSystemActuator.new(
+            vent_srf, 'AirFlow Network Window/Door Opening', 'Venting Opening Factor')
+        vent_srf_name = vent_srf.name
+        unless vent_srf_name.empty?
+          act_name = vent_srf_name.get.delete(' ').delete('.') + '_OpenFactor'
+          window_act.setName(act_name)
+          actuator_names << act_name
+        end
+      end
+
+      # create the first line of the EMS Program to open each window according to the control logic
+      logic_statements = []
+      # check the minimum indoor tempertaure for ventilation
+      min_in = @hash[:min_indoor_temperature]
+      if min_in && min_in != defaults[:min_indoor_temperature][:default]
+        logic_statements << '(' + in_sensor_name + ' > ' + min_in.to_s + ')'
+      end
+      # check the maximum indoor tempertaure for ventilation
+      max_in = @hash[:max_indoor_temperature]
+      if max_in && max_in != defaults[:max_indoor_temperature][:default]
+        logic_statements << '(' + in_sensor_name + ' < ' + max_in.to_s + ')'
+      end
+      # check the minimum outdoor tempertaure for ventilation
+      min_out = @hash[:min_outdoor_temperature]
+      if min_out && min_out != defaults[:min_outdoor_temperature][:default]
+        logic_statements << '(Outdoor_Sensor > ' + min_out.to_s + ')'
+      end
+      # check the maximum outdoor tempertaure for ventilation
+      max_out = @hash[:max_outdoor_temperature]
+      if max_out && max_out != defaults[:max_outdoor_temperature][:default]
+        logic_statements << '(Outdoor_Sensor < ' + max_out.to_s + ')'
+      end
+      # check the delta tempertaure for ventilation
+      delta_in_out = @hash[:delta_temperature]
+      if delta_in_out && delta_in_out != defaults[:delta_temperature][:default]
+        logic_statements << '((' + in_sensor_name + ' - Outdoor_Sensor) > ' + delta_in_out.to_s + ')'
+      end
+      # create the complete logic statement for opening windows
+      if logic_statements.empty?
+        complete_logic = 'IF (Outdoor_Sensor < 100)'  # no logic has been provided; always open windows
+      else
+        complete_logic = 'IF ' + logic_statements.join(' && ')
+      end
+
+      # initialize the program and add the complete logic
+      ems_program = OpenStudio::Model::EnergyManagementSystemProgram.new(openstudio_model)
+      ems_program.setName(os_zone_name.delete(' ').delete('.') + '_WindowOpening')
+      ems_program.addLine(complete_logic)
+
+      # loop through each of the actuators and open each window
+      actuator_names.zip(vent_opening_factors).each do |act_name, open_factor|
+        ems_program.addLine('SET ' + act_name + ' = ' + open_factor.to_s)
+      end
+      # loop through each of the actuators and close each window
+      ems_program.addLine('ELSE')
+      actuator_names.each do |act_name|
+        ems_program.addLine('SET ' + act_name + ' = 0')
+      end
+      ems_program.addLine('ENDIF')
+      
+      # add the program object the the global program manager for all window opening
+      prog_manager = get_program_manager(openstudio_model)
+      prog_manager.addProgram(ems_program)
+
+      ems_program
+    end
+
+    end #VentilationControl
+end #FromHoneybee