honeybee-openstudio 2.5.1 → 2.6.2

data/lib/from_honeybee/geometry/face.rb

@@ -49,6 +49,10 @@ module FromHoneybee
       @@schema[:components][:schemas][:FaceEnergyPropertiesAbridged][:properties]
     end
 
+    def crack_defaults
+      @@schema[:components][:schemas][:AFNCrack][:properties]
+    end
+
     def find_existing_openstudio_object(openstudio_model)
       model_surf = openstudio_model.getSurfaceByName(@hash[:identifier])
       return model_surf.get unless model_surf.empty?
@@ -56,16 +60,18 @@ module FromHoneybee
     end
 
     def to_openstudio(openstudio_model)
-      # create the openstudio surface
+      # reorder the vertices to ensure they start from the upper-left corner
       os_vertices = OpenStudio::Point3dVector.new
       @hash[:geometry][:boundary].each do |vertex|
         os_vertices << OpenStudio::Point3d.new(vertex[0], vertex[1], vertex[2])
       end
       reordered_vertices = OpenStudio.reorderULC(os_vertices)
 
+      # create the openstudio surface and assign the type
       os_surface = OpenStudio::Model::Surface.new(reordered_vertices, openstudio_model)     
       os_surface.setName(@hash[:identifier])
       os_surface.setSurfaceType(@hash[:face_type])
+
       # assign the construction if it is present
       if @hash[:properties][:energy][:construction]
         construction_identifier = @hash[:properties][:energy][:construction]
@@ -76,6 +82,32 @@ module FromHoneybee
         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
+          
+          # 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)
+          
+        end
+      end
+
       # assign the boundary condition
       boundary_condition = (@hash[:boundary_condition][:type])
       case boundary_condition

data/lib/from_honeybee/geometry/room.rb

@@ -43,6 +43,7 @@ require 'from_honeybee/load/ventilation'
 require 'from_honeybee/load/setpoint_thermostat'
 require 'from_honeybee/load/setpoint_humidistat'
 require 'from_honeybee/ventcool/opening'
+require 'from_honeybee/ventcool/control'
 
 require 'openstudio'
 
@@ -139,7 +140,8 @@ module FromHoneybee
         if face[:apertures]
           face[:apertures].each do |aperture|
             if aperture[:properties][:energy][:vent_opening]
-              window_vent[aperture[:identifier]] = aperture[:properties][:energy][:vent_opening]
+              window_vent[aperture[:identifier]] = \
+                [aperture[:properties][:energy][:vent_opening], aperture[:boundary_condition][:type]]
             end
             if aperture[:outdoor_shades]
               unless os_shd_group
@@ -156,7 +158,8 @@ module FromHoneybee
         if face[:doors]
           face[:doors].each do |door|
             if door[:properties][:energy][:vent_opening]
-              window_vent[door[:identifier]] = door[:properties][:energy][:vent_opening]
+              window_vent[door[:identifier]] = \
+                [door[:properties][:energy][:vent_opening], door[:boundary_condition][:type]]
             end
             if door[:outdoor_shades]
               unless os_shd_group
@@ -185,17 +188,19 @@ module FromHoneybee
               os_surface.setConstruction(air_construction)
             end
             # add air mixing properties to the global list that tracks them
-            air_hash = $air_boundary_hash[air_construction.name.to_s]
-            if air_hash[:air_mixing_per_area]
-              air_mix_area = air_hash[:air_mixing_per_area]
-            else
-              air_default = @@schema[:components][:schemas][:AirBoundaryConstructionAbridged]
-              air_mix_area = air_default[:properties][:air_mixing_per_area][:default]
+            if $use_simple_vent  # only use air mixing objects when simple ventilation is requested
+              air_hash = $air_boundary_hash[air_construction.name.to_s]
+              if air_hash[:air_mixing_per_area]
+                air_mix_area = air_hash[:air_mixing_per_area]
+              else
+                air_default = @@schema[:components][:schemas][:AirBoundaryConstructionAbridged]
+                air_mix_area = air_default[:properties][:air_mixing_per_area][:default]
+              end
+              flow_rate = os_surface.netArea * air_mix_area
+              flow_sch_id = air_hash[:air_mixing_schedule]
+              adj_zone_id = face[:boundary_condition][:boundary_condition_objects][-1]
+              $air_mxing_array << [os_thermal_zone, flow_rate, flow_sch_id, adj_zone_id]
             end
-            flow_rate = os_surface.netArea * air_mix_area
-            flow_sch_id = air_hash[:air_mixing_schedule]
-            adj_zone_id = face[:boundary_condition][:boundary_condition_objects][-1]
-            $air_mxing_array << [os_thermal_zone, flow_rate, flow_sch_id, adj_zone_id]
           end
         end
       end
@@ -265,7 +270,7 @@ module FromHoneybee
       end
 
       # assign infiltration if it exists
-      if @hash[:properties][:energy][:infiltration]
+      if @hash[:properties][:energy][:infiltration] && $use_simple_vent  # only use infiltration with simple ventilation
         infiltration = openstudio_model.getSpaceInfiltrationDesignFlowRateByName(
           @hash[:properties][:energy][:infiltration][:identifier])
         unless infiltration.empty?
@@ -308,17 +313,47 @@ module FromHoneybee
       end
 
       # assign window ventilation objects if they exist
-      unless window_vent.empty?
-        window_vent.each do |sub_f_id, opening|
+      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
-            window_vent = VentilationOpening.new(opening)
-            os_window_vent = window_vent.to_openstudio(
-              openstudio_model, sub_f, @hash[:properties][:energy][:window_vent_control])
-            os_window_vent.addToThermalZone(os_thermal_zone)
+            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)
+              operable_subfs << sub_f
+              opening_factors << open_fac
+            end
           end
         end
+        # add the control startegy of the ventilation openings using the EMS
+        if @hash[:properties][:energy][:window_vent_control]
+          vent_control = VentilationControl.new(@hash[:properties][:energy][:window_vent_control])
+          vent_control.to_openstudio(
+            openstudio_model, os_thermal_zone, operable_subfs, opening_factors)
+        end
       end
 
       os_space

data/lib/from_honeybee/hvac/Model.hvac.rb

@@ -60,7 +60,7 @@ class OpenStudio::Model::Model
       standard.model_add_hvac_system(self, 'Baseboards', ht = 'NaturalGas', znht = nil, cl = nil, heated_zones)
 
     when 'Baseboard central air source heat pump'
-      standard.model_add_hvac_system(self, 'Baseboards', ht = 'AirSourceHeatPump', znht = nil, cl = nil, heated_only_zones)
+      standard.model_add_hvac_system(self, 'Baseboards', ht = 'AirSourceHeatPump', znht = nil, cl = nil, heated_zones)
 
     when 'Baseboard district hot water'
       standard.model_add_hvac_system(self, 'Baseboards', ht = 'DistrictHeating', znht = nil, cl = nil, heated_zones)

data/lib/from_honeybee/model.rb

@@ -75,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'
 
 
@@ -158,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

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/ventcool/control.rb

@@ -0,0 +1,176 @@
+# *******************************************************************************
+# 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
+    @@sensor_count = 1
+    @@actuator_count = 1
+    @@program_count = 1
+
+    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 replace_ems_special_characters(ems_variable_name)
+      # remove special characters from an name to be used as an EMS variable
+      new_name = ems_variable_name.to_s
+      new_name.gsub!(/[^A-Za-z]/, '')
+      new_name
+    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 = replace_ems_special_characters(os_zone_name) + '_Sensor' + @@sensor_count.to_s
+      @@sensor_count = @@sensor_count + 1
+      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 = replace_ems_special_characters(vent_srf_name.get) + \
+            '_OpenFactor' + @@actuator_count.to_s
+            @@actuator_count = @@actuator_count + 1
+          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)
+      prog_name = replace_ems_special_characters(os_zone_name) + '_WindowOpening' + @@program_count.to_s
+      @@program_count = @@program_count + 1
+      ems_program.setName(prog_name)
+      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

data/lib/from_honeybee/ventcool/opening.rb

@@ -46,8 +46,8 @@ module FromHoneybee
     end
 
     def defaults_control
-        @@schema[:components][:schemas][:VentilationControlAbridged][:properties]
-      end
+      @@schema[:components][:schemas][:VentilationControlAbridged][:properties]
+    end
 
     def to_openstudio(openstudio_model, parent, vent_control_hash)
       # create wind and stack object and set identifier
@@ -140,6 +140,48 @@ module FromHoneybee
       os_opening
     end
 
+    def to_openstudio_afn(openstudio_model, parent)
+      # process the flow_coefficient_closed and set it to a very small number if it's 0
+      if @hash[:flow_coefficient_closed] and @hash[:flow_coefficient_closed] != 0
+        flow_coefficient = @hash[:flow_coefficient_closed]
+      else
+        flow_coefficient = 1.0e-09  # set it to a very small number
+      end
+
+      # create the simple opening object for the Aperture or Door using default values
+      flow_exponent = defaults[:flow_exponent_closed][:default].to_f
+      two_way_thresh = defaults[:two_way_threshold][:default].to_f
+      discharge_coeff = defaults[:discharge_coefficient][:default].to_f
+      os_opening = OpenStudio::Model::AirflowNetworkSimpleOpening.new(
+        openstudio_model, flow_coefficient, flow_exponent, two_way_thresh, discharge_coeff)
+
+      # assign the flow exponent when the opening is closed
+      if @hash[:flow_exponent_closed]
+        os_opening.setAirMassFlowExponentWhenOpeningisClosed(@hash[:flow_exponent_closed])
+      end
+      # assign the minimum difference for two-way flow
+      if @hash[:two_way_threshold]
+        os_opening.setMinimumDensityDifferenceforTwoWayFlow(@hash[:two_way_threshold])
+      end
+      # assign the discharge coefficient
+      if @hash[:discharge_coefficient]
+        os_opening.setDischargeCoefficient(@hash[:discharge_coefficient])
+      end
+
+      # create the AirflowNetworkSurface 
+      os_afn_srf = parent.getAirflowNetworkSurface(os_opening)
+
+      # assign the opening area
+      if @hash[:fraction_area_operable]
+        open_fac = @hash[:fraction_area_operable]
+      else
+        open_fac = defaults[:fraction_area_operable][:default]
+      end
+      os_afn_srf.setWindowDoorOpeningFactorOrCrackFactor(open_fac)
+
+      open_fac
+    end
+
     def compute_height(surface)
       # derive the height (difference in z values) of a surface
       verts = surface.vertices
@@ -152,7 +194,8 @@ module FromHoneybee
           max_pt = v.z
         end
       end
-      max_pt - min_pt
+      # quarter the window height to get the height from midpoint of lower opening to neutral pressure level
+      (max_pt - min_pt) / 4
     end
 
   end #VentilationOpening