openstudio-standards 0.4.0 → 0.5.0.rc1

data/lib/openstudio-standards/qaqc/envelope.rb

@@ -0,0 +1,399 @@
+# Module to apply QAQC checks to a model
+module OpenstudioStandards
+  module QAQC
+    # @!group Envelope
+
+    # Check the envelope conductance against a standard
+    #
+    # @param category [String] category to bin this check into
+    # @param target_standard [String] standard template, e.g. '90.1-2013'
+    # @param min_pass_pct [Double] threshold for throwing an error for percent difference
+    # @param max_pass_pct [Double] threshold for throwing an error for percent difference
+    # @param name_only [Boolean] If true, only return the name of this check
+    # @return [OpenStudio::Attribute] OpenStudio Attribute object containing check results
+    # @todo unique tolerance ranges for conductance, reflectance, and shgc
+    def self.check_envelope_conductance(category, target_standard, min_pass_pct: 0.2, max_pass_pct: 0.2, name_only: false)
+      # summary of the check
+      check_elems = OpenStudio::AttributeVector.new
+      check_elems << OpenStudio::Attribute.new('name', 'Envelope R-Value')
+      check_elems << OpenStudio::Attribute.new('category', category)
+      if target_standard == 'ICC IECC 2015'
+        dislay_standard = target_standard
+        check_elems << OpenStudio::Attribute.new('description', "Check envelope against Table R402.1.2 and R402.1.4 in #{dislay_standard} Residential Provisions.")
+      elsif target_standard.include?('90.1-2013')
+        display_standard = "ASHRAE #{target_standard}"
+        check_elems << OpenStudio::Attribute.new('description', "Check envelope against #{display_standard} Table 5.5.2, Table G2.1.5 b,c,d,e, Section 5.5.3.1.1a. Roof reflectance of 55%, wall reflectance of 30%.")
+      else
+        # @todo could add more elsifs if want to dsiplay tables and sections for additional 90.1 standards
+        if target_standard.include?('90.1')
+          display_standard = "ASHRAE #{target_standard}"
+        else
+          display_standard = target_standard
+        end
+        check_elems << OpenStudio::Attribute.new('description', "Check envelope against #{display_standard}. Roof reflectance of 55%, wall reflectance of 30%.")
+      end
+
+      # stop here if only name is requested this is used to populate display name for arguments
+      if name_only == true
+        results = []
+        check_elems.each do |elem|
+          results << elem.valueAsString
+        end
+        return results
+      end
+
+      std = Standard.build(target_standard)
+
+      # list of surface types to identify for each space type for surfaces and sub-surfaces
+      construction_type_array = []
+      construction_type_array << ['ExteriorWall', 'SteelFramed']
+      construction_type_array << ['ExteriorRoof', 'IEAD']
+      construction_type_array << ['ExteriorFloor', 'Mass']
+      construction_type_array << ['ExteriorDoor', 'Swinging']
+      construction_type_array << ['ExteriorWindow', 'Metal framing (all other)']
+      construction_type_array << ['Skylight', 'Glass with Curb']
+      # overhead door doesn't show in list, or glass door
+
+      begin
+        # loop through all space types used in the model
+        @model.getSpaceTypes.sort.each do |space_type|
+          next if space_type.floorArea <= 0
+
+          space_type_const_properties = {}
+          construction_type_array.each do |const_type|
+            # gather data for exterior wall
+            intended_surface_type = const_type[0]
+            standards_construction_type = const_type[1]
+            space_type_const_properties[intended_surface_type] = {}
+            data = std.space_type_get_construction_properties(space_type, intended_surface_type, standards_construction_type)
+            if data.nil?
+              puts "lookup for #{target_standard},#{intended_surface_type},#{standards_construction_type}"
+              check_elems << OpenStudio::Attribute.new('flag', "Didn't find construction for #{standards_construction_type} #{intended_surface_type} for #{space_type.name}.")
+            elsif intended_surface_type.include? 'ExteriorWall' || 'ExteriorFloor' || 'ExteriorDoor'
+              space_type_const_properties[intended_surface_type]['u_value'] = data['assembly_maximum_u_value']
+              space_type_const_properties[intended_surface_type]['reflectance'] = 0.30 # hard coded value
+            elsif intended_surface_type.include? 'ExteriorRoof'
+              space_type_const_properties[intended_surface_type]['u_value'] = data['assembly_maximum_u_value']
+              space_type_const_properties[intended_surface_type]['reflectance'] = 0.55 # hard coded value
+            else
+              space_type_const_properties[intended_surface_type]['u_value'] = data['assembly_maximum_u_value']
+              space_type_const_properties[intended_surface_type]['shgc'] = data['assembly_maximum_solar_heat_gain_coefficient']
+            end
+          end
+
+          # make array of construction details for surfaces
+          surface_details = []
+          missing_surface_constructions = []
+          sub_surface_details = []
+          missing_sub_surface_constructions = []
+
+          # loop through spaces
+          space_type.spaces.each do |space|
+            space.surfaces.each do |surface|
+              next if surface.outsideBoundaryCondition != 'Outdoors'
+
+              if surface.construction.is_initialized
+                surface_details << { boundary_condition: surface.outsideBoundaryCondition, surface_type: surface.surfaceType, construction: surface.construction.get }
+              else
+                missing_surface_constructions << surface.name.get
+              end
+
+              # make array of construction details for sub_surfaces
+              surface.subSurfaces.each do |sub_surface|
+                if sub_surface.construction.is_initialized
+                  sub_surface_details << { boundary_condition: sub_surface.outsideBoundaryCondition, surface_type: sub_surface.subSurfaceType, construction: sub_surface.construction.get }
+                else
+                  missing_sub_surface_constructions << sub_surface.name.get
+                end
+              end
+            end
+          end
+
+          if !missing_surface_constructions.empty?
+            check_elems << OpenStudio::Attribute.new('flag', "#{missing_surface_constructions.size} surfaces are missing constructions in #{space_type.name}. Spaces and can't be checked.")
+          end
+
+          if !missing_sub_surface_constructions.empty?
+            check_elems << OpenStudio::Attribute.new('flag', "#{missing_sub_surface_constructions.size} sub surfaces are missing constructions in #{space_type.name}. Spaces and can't be checked.")
+          end
+
+          # gather target values for this space type
+          # @todo address support for other surface types e.g. overhead door glass door
+          target_r_value_ip = {}
+          target_reflectance = {}
+          target_u_value_ip = {}
+          target_shgc = {}
+          target_r_value_ip['Wall'] = 1.0 / space_type_const_properties['ExteriorWall']['u_value'].to_f
+          target_reflectance['Wall'] = space_type_const_properties['ExteriorWall']['reflectance'].to_f
+          target_r_value_ip['RoofCeiling'] = 1.0 / space_type_const_properties['ExteriorRoof']['u_value'].to_f
+          target_reflectance['RoofCeiling'] = space_type_const_properties['ExteriorRoof']['reflectance'].to_f
+          target_r_value_ip['Floor'] = 1.0 / space_type_const_properties['ExteriorFloor']['u_value'].to_f
+          target_reflectance['Floor'] = space_type_const_properties['ExteriorFloor']['reflectance'].to_f
+          target_r_value_ip['Door'] = 1.0 / space_type_const_properties['ExteriorDoor']['u_value'].to_f
+          target_reflectance['Door'] = space_type_const_properties['ExteriorDoor']['reflectance'].to_f
+          target_u_value_ip['FixedWindow'] = space_type_const_properties['ExteriorWindow']['u_value'].to_f
+          target_shgc['FixedWindow'] = space_type_const_properties['ExteriorWindow']['shgc'].to_f
+          target_u_value_ip['OperableWindow'] = space_type_const_properties['ExteriorWindow']['u_value'].to_f
+          target_shgc['OperableWindow'] = space_type_const_properties['ExteriorWindow']['shgc'].to_f
+          target_u_value_ip['Skylight'] = space_type_const_properties['Skylight']['u_value'].to_f
+          target_shgc['Skylight'] = space_type_const_properties['Skylight']['shgc'].to_f
+
+          # loop through unique construction array combinations
+          surface_details.uniq.each do |surface_detail|
+            if surface_detail[:construction].thermalConductance.is_initialized
+
+              # don't use intended surface type of construction, look map based on surface type and boundary condition
+              boundary_condition = surface_detail[:boundary_condition]
+              surface_type = surface_detail[:surface_type]
+              intended_surface_type = ''
+              if boundary_condition.to_s == 'Outdoors'
+                case surface_type.to_s
+                when 'Wall'
+                  intended_surface_type = 'ExteriorWall'
+                when 'RoofCeiling'
+                  intended_surface_type = 'ExteriorRoof'
+                when 'Floor'
+                  intended_surface_type = 'ExteriorFloor'
+                end
+              else
+                # currently only used for surfaces with outdoor boundary condition
+              end
+              film_coefficients_r_value = std.film_coefficients_r_value(intended_surface_type, includes_int_film = true, includes_ext_film = true)
+              thermal_conductance = surface_detail[:construction].thermalConductance.get
+              r_value_with_film = 1 / thermal_conductance + film_coefficients_r_value
+              source_units = 'm^2*K/W'
+              target_units = 'ft^2*h*R/Btu'
+              r_value_ip = OpenStudio.convert(r_value_with_film, source_units, target_units).get
+              solar_reflectance = surface_detail[:construction].to_LayeredConstruction.get.layers[0].to_OpaqueMaterial.get.solarReflectance.get
+              # @todo check with exterior air wall
+
+              # stop if didn't find values (0 or infinity)
+              next if target_r_value_ip[surface_detail[:surface_type]] == 0.0
+              next if target_r_value_ip[surface_detail[:surface_type]] == Float::INFINITY
+
+              # check r avlues
+              if r_value_ip < target_r_value_ip[surface_detail[:surface_type]] * (1.0 - min_pass_pct)
+                check_elems << OpenStudio::Attribute.new('flag', "R value of #{r_value_ip.round(2)} (#{target_units}) for #{surface_detail[:construction].name} in #{space_type.name} is more than #{min_pass_pct * 100} % below the expected value of #{target_r_value_ip[surface_detail[:surface_type]].round(2)} (#{target_units}) for #{display_standard}.")
+              elsif r_value_ip > target_r_value_ip[surface_detail[:surface_type]] * (1.0 + max_pass_pct)
+                check_elems << OpenStudio::Attribute.new('flag', "R value of #{r_value_ip.round(2)} (#{target_units}) for #{surface_detail[:construction].name} in #{space_type.name} is more than #{max_pass_pct * 100} % above the expected value of #{target_r_value_ip[surface_detail[:surface_type]].round(2)} (#{target_units}) for #{display_standard}.")
+              end
+
+              # check solar reflectance
+              if (solar_reflectance < target_reflectance[surface_detail[:surface_type]] * (1.0 - min_pass_pct)) && (target_standard != 'ICC IECC 2015')
+                check_elems << OpenStudio::Attribute.new('flag', "Solar Reflectance of #{(solar_reflectance * 100).round} % for #{surface_detail[:construction].name} in #{space_type.name} is more than #{min_pass_pct * 100} % below the expected value of #{(target_reflectance[surface_detail[:surface_type]] * 100).round} %.")
+              elsif (solar_reflectance > target_reflectance[surface_detail[:surface_type]] * (1.0 + max_pass_pct)) && (target_standard != 'ICC IECC 2015')
+                check_elems << OpenStudio::Attribute.new('flag', "Solar Reflectance of #{(solar_reflectance * 100).round} % for #{surface_detail[:construction].name} in #{space_type.name} is more than #{max_pass_pct * 100} % above the expected value of #{(target_reflectance[surface_detail[:surface_type]] * 100).round} %.")
+              end
+
+            else
+              check_elems << OpenStudio::Attribute.new('flag', "Can't calculate R value for #{surface_detail[:construction].name}.")
+            end
+          end
+
+          # loop through unique construction array combinations
+          sub_surface_details.uniq.each do |sub_surface_detail|
+            if sub_surface_detail[:surface_type] == 'FixedWindow' || sub_surface_detail[:surface_type] == 'OperableWindow' || sub_surface_detail[:surface_type] == 'Skylight'
+              # check for non opaque sub surfaces
+              source_units = 'W/m^2*K'
+              target_units = 'Btu/ft^2*h*R'
+              u_factor_si = std.construction_calculated_u_factor(sub_surface_detail[:construction].to_LayeredConstruction.get.to_Construction.get)
+              u_factor_ip = OpenStudio.convert(u_factor_si, source_units, target_units).get
+              shgc = std.construction_calculated_solar_heat_gain_coefficient(sub_surface_detail[:construction].to_LayeredConstruction.get.to_Construction.get)
+
+              # stop if didn't find values (0 or infinity)
+              next if target_u_value_ip[sub_surface_detail[:surface_type]] == 0.0
+              next if target_u_value_ip[sub_surface_detail[:surface_type]] == Float::INFINITY
+
+              # check u avlues
+              if u_factor_ip < target_u_value_ip[sub_surface_detail[:surface_type]] * (1.0 - min_pass_pct)
+                check_elems << OpenStudio::Attribute.new('flag', "U value of #{u_factor_ip.round(2)} (#{target_units}) for #{sub_surface_detail[:construction].name} in #{space_type.name} is more than #{min_pass_pct * 100} % below the expected value of #{target_u_value_ip[sub_surface_detail[:surface_type]].round(2)} (#{target_units}) for #{display_standard}.")
+              elsif u_factor_ip > target_u_value_ip[sub_surface_detail[:surface_type]] * (1.0 + max_pass_pct)
+                check_elems << OpenStudio::Attribute.new('flag', "U value of #{u_factor_ip.round(2)} (#{target_units}) for #{sub_surface_detail[:construction].name} in #{space_type.name} is more than #{max_pass_pct * 100} % above the expected value of #{target_u_value_ip[sub_surface_detail[:surface_type]].round(2)} (#{target_units}) for #{display_standard}.")
+              end
+
+              # check shgc
+              if shgc < target_shgc[sub_surface_detail[:surface_type]] * (1.0 - min_pass_pct)
+                check_elems << OpenStudio::Attribute.new('flag', "SHGC of #{shgc.round(2)} % for #{sub_surface_detail[:construction].name} in #{space_type.name} is more than #{min_pass_pct * 100} % below the expected value of #{target_shgc[sub_surface_detail[:surface_type]].round(2)} %.")
+              elsif shgc > target_shgc[sub_surface_detail[:surface_type]] * (1.0 + max_pass_pct)
+                check_elems << OpenStudio::Attribute.new('flag', "SHGC of #{shgc.round(2)} % for #{sub_surface_detail[:construction].name} in #{space_type.name} is more than #{max_pass_pct * 100} % above the expected value of #{target_shgc[sub_surface_detail[:surface_type]].round(2)} %.")
+              end
+
+            else
+              # check for opaque sub surfaces
+              if sub_surface_detail[:construction].thermalConductance.is_initialized
+
+                # don't use intended surface type of construction, look map based on surface type and boundary condition
+                boundary_condition = sub_surface_detail[:boundary_condition]
+                surface_type = sub_surface_detail[:surface_type]
+                intended_surface_type = ''
+                if boundary_condition.to_s == 'Outdoors'
+                  # @todo add additional intended surface types
+                  if surface_type.to_s == 'Door' then intended_surface_type = 'ExteriorDoor' end
+                else
+                  # currently only used for surfaces with outdoor boundary condition
+                end
+                film_coefficients_r_value = std.film_coefficients_r_value(intended_surface_type, includes_int_film = true, includes_ext_film = true)
+
+                thermal_conductance = sub_surface_detail[:construction].thermalConductance.get
+                r_value_with_film = 1 / thermal_conductance + film_coefficients_r_value
+                source_units = 'm^2*K/W'
+                target_units = 'ft^2*h*R/Btu'
+                r_value_ip = OpenStudio.convert(r_value_with_film, source_units, target_units).get
+                solar_reflectance = sub_surface_detail[:construction].to_LayeredConstruction.get.layers[0].to_OpaqueMaterial.get.solarReflectance.get
+                # @todo check what happens with exterior air wall
+
+                # stop if didn't find values (0 or infinity)
+                next if target_r_value_ip[sub_surface_detail[:surface_type]] == 0.0
+                next if target_r_value_ip[sub_surface_detail[:surface_type]] == Float::INFINITY
+
+                # check r avlues
+                if r_value_ip < target_r_value_ip[sub_surface_detail[:surface_type]] * (1.0 - min_pass_pct)
+                  check_elems << OpenStudio::Attribute.new('flag', "R value of #{r_value_ip.round(2)} (#{target_units}) for #{sub_surface_detail[:construction].name} in #{space_type.name} is more than #{min_pass_pct * 100} % below the expected value of #{target_r_value_ip[sub_surface_detail[:surface_type]].round(2)} (#{target_units}) for #{display_standard}.")
+                elsif r_value_ip > target_r_value_ip[sub_surface_detail[:surface_type]] * (1.0 + max_pass_pct)
+                  check_elems << OpenStudio::Attribute.new('flag', "R value of #{r_value_ip.round(2)} (#{target_units}) for #{sub_surface_detail[:construction].name} in #{space_type.name} is more than #{max_pass_pct * 100} % above the expected value of #{target_r_value_ip[sub_surface_detail[:surface_type]].round(2)} (#{target_units}) for #{display_standard}.")
+                end
+
+                # check solar reflectance
+                if (solar_reflectance < target_reflectance[sub_surface_detail[:surface_type]] * (1.0 - min_pass_pct)) && (target_standard != 'ICC IECC 2015')
+                  check_elems << OpenStudio::Attribute.new('flag', "Solar Reflectance of #{(solar_reflectance * 100).round} % for #{sub_surface_detail[:construction].name} in #{space_type.name} is more than #{min_pass_pct * 100} % below the expected value of #{(target_reflectance[sub_surface_detail[:surface_type]] * 100).round} %.")
+                elsif (solar_reflectance > target_reflectance[sub_surface_detail[:surface_type]] * (1.0 + max_pass_pct)) && (target_standard != 'ICC IECC 2015')
+                  check_elems << OpenStudio::Attribute.new('flag', "Solar Reflectance of #{(solar_reflectance * 100).round} % for #{sub_surface_detail[:construction].name} in #{space_type.name} is more than #{max_pass_pct * 100} % above the expected value of #{(target_reflectance[sub_surface_detail[:surface_type]] * 100).round} %.")
+                end
+
+              else
+                check_elems << OpenStudio::Attribute.new('flag', "Can't calculate R value for #{sub_surface_detail[:construction].name}.")
+              end
+
+            end
+          end
+        end
+
+        # check spaces without space types against Nonresidential for this climate zone
+        @model.getSpaces.sort.each do |space|
+          unless space.spaceType.is_initialized
+
+            # make array of construction details for surfaces
+            surface_details = []
+            missing_surface_constructions = []
+            sub_surface_details = []
+            missing_sub_surface_constructions = []
+
+            space.surfaces.each do |surface|
+              next if surface.outsideBoundaryCondition != 'Outdoors'
+
+              if surface.construction.is_initialized
+                surface_details << { boundary_condition: surface.outsideBoundaryCondition, surface_type: surface.surfaceType, construction: surface.construction.get }
+              else
+                missing_surface_constructions << surface.name.get
+              end
+
+              # make array of construction details for sub_surfaces
+              surface.subSurfaces.each do |sub_surface|
+                if sub_surface.construction.is_initialized
+                  sub_surface_details << { boundary_condition: sub_surface.outsideBoundaryCondition, surface_type: sub_surface.subSurfaceType, construction: sub_surface.construction.get }
+                else
+                  missing_sub_surface_constructions << sub_surface.name.get
+                end
+              end
+            end
+
+            unless missing_surface_constructions.empty?
+              check_elems << OpenStudio::Attribute.new('flag', "#{missing_surface_constructions.size} surfaces are missing constructions in #{space_type.name}. Spaces and can't be checked.")
+              end
+
+            unless missing_sub_surface_constructions.empty?
+              check_elems << OpenStudio::Attribute.new('flag', "#{missing_sub_surface_constructions.size} sub surfaces are missing constructions in #{space_type.name}. Spaces and can't be checked.")
+              end
+
+            surface_details.uniq.each do |surface_detail|
+              if surface_detail[:construction].thermalConductance.is_initialized
+                # don't use intended surface type of construction, look map based on surface type and boundary condition
+                boundary_condition = surface_detail[:boundary_condition]
+                surface_type = surface_detail[:surface_type]
+                intended_surface_type = ''
+                if boundary_condition.to_s == 'Outdoors'
+                  case surface_type.to_s
+                  when 'Wall'
+                    intended_surface_type = 'ExteriorWall'
+                    standards_construction_type = 'SteelFramed'
+                  when 'RoofCeiling'
+                    intended_surface_type = 'ExteriorRoof'
+                    standards_construction_type = 'IEAD'
+                  when 'Floor'
+                    intended_surface_type = 'ExteriorFloor'
+                    standards_construction_type = 'Mass'
+                    end
+                  # currently only used for surfaces with outdoor boundary condition
+                end
+                film_coefficients_r_value = std.film_coefficients_r_value(intended_surface_type, includes_int_film = true, includes_ext_film = true)
+                thermal_conductance = surface_detail[:construction].thermalConductance.get
+                r_value_with_film = 1 / thermal_conductance + film_coefficients_r_value
+                source_units = 'm^2*K/W'
+                target_units = 'ft^2*h*R/Btu'
+                r_value_ip = OpenStudio.convert(r_value_with_film, source_units, target_units).get
+                solar_reflectance = surface_detail[:construction].to_LayeredConstruction.get.layers[0].to_OpaqueMaterial.get.solarReflectance.get
+                # @todo check what happens with exterior air wall
+
+                # calculate target_r_value_ip
+                target_reflectance = nil
+                data = std.model_get_construction_properties(@model, intended_surface_type, standards_construction_type)
+
+                if data.nil?
+                  check_elems << OpenStudio::Attribute.new('flag', "Didn't find construction for #{standards_construction_type} #{intended_surface_type} for #{space.name}.")
+                  next
+                elsif intended_surface_type.include? 'ExteriorWall' || 'ExteriorFloor' || 'ExteriorDoor'
+                  assembly_maximum_u_value = data['assembly_maximum_u_value']
+                  target_reflectance = 0.30
+                elsif intended_surface_type.include? 'ExteriorRoof'
+                  assembly_maximum_u_value = data['assembly_maximum_u_value']
+                  target_reflectance = 0.55
+                else
+                  assembly_maximum_u_value = data['assembly_maximum_u_value']
+                  assembly_maximum_solar_heat_gain_coefficient = data['assembly_maximum_solar_heat_gain_coefficient']
+                end
+                assembly_maximum_r_value_ip = 1 / assembly_maximum_u_value
+
+                # stop if didn't find values (0 or infinity)
+                next if assembly_maximum_r_value_ip == 0.0
+                next if assembly_maximum_r_value_ip == Float::INFINITY
+
+                # check r avlues
+                if r_value_ip < assembly_maximum_r_value_ip * (1.0 - min_pass_pct)
+                  check_elems << OpenStudio::Attribute.new('flag', "R value of #{r_value_ip.round(2)} (#{target_units}) for #{surface_detail[:construction].name} in #{space.name} is more than #{min_pass_pct * 100} % below the expected value of #{assembly_maximum_r_value_ip.round(2)} (#{target_units}) for #{display_standard}.")
+                elsif r_value_ip > assembly_maximum_r_value_ip * (1.0 + max_pass_pct)
+                  check_elems << OpenStudio::Attribute.new('flag', "R value of #{r_value_ip.round(2)} (#{target_units}) for #{surface_detail[:construction].name} in #{space.name} is more than #{max_pass_pct * 100} % above the expected value of #{assembly_maximum_r_value_ip.round(2)} (#{target_units}) for #{display_standard}.")
+                end
+
+                # check solar reflectance
+                if (solar_reflectance < target_reflectance * (1.0 - min_pass_pct)) && (target_standard != 'ICC IECC 2015')
+                  check_elems << OpenStudio::Attribute.new('flag', "Solar Reflectance of #{(solar_reflectance * 100).round} % for #{surface_detail[:construction].name} in #{space.name} is more than #{min_pass_pct * 100} % below the expected value of #{(target_reflectance * 100).round} %.")
+                elsif (solar_reflectance > target_reflectance * (1.0 + max_pass_pct)) && (target_standard != 'ICC IECC 2015')
+                  check_elems << OpenStudio::Attribute.new('flag', "Solar Reflectance of #{(solar_reflectance * 100).round} % for #{surface_detail[:construction].name} in #{space.name} is more than #{max_pass_pct * 100} % above the expected value of #{(target_reflectance * 100).round} %.")
+                end
+              else
+                check_elems << OpenStudio::Attribute.new('flag', "Can't calculate R value for #{surface_detail[:construction].name}.")
+              end
+            end
+
+            sub_surface_details.uniq.each do |sub_surface_detail|
+              # @todo update this so it works for doors and windows
+              check_elems << OpenStudio::Attribute.new('flag', "Not setup to check sub-surfaces of spaces without space types. Can't check properties for #{sub_surface_detail[:construction].name}.")
+            end
+
+          end
+        end
+      rescue StandardError => e
+        # brief description of ruby error
+        check_elems << OpenStudio::Attribute.new('flag', "Error prevented QAQC check from running (#{e}).")
+
+        # backtrace of ruby error for diagnostic use
+        if @error_backtrace then check_elems << OpenStudio::Attribute.new('flag', e.backtrace.join("\n").to_s) end
+      end
+
+      # add check_elms to new attribute
+      check_elem = OpenStudio::Attribute.new('check', check_elems)
+
+      return check_elem
+    end
+  end
+end

data/lib/openstudio-standards/qaqc/eui.rb

@@ -0,0 +1,213 @@
+# Module to apply QAQC checks to a model
+module OpenstudioStandards
+  module QAQC
+    # @!group Energy Use Intensity (EUI)
+
+    # Checks EUI for reasonableness
+    #
+    # @param category [String] category to bin this check into
+    # @param target_standard [String] standard template, e.g. '90.1-2013'
+    # @param min_pass_pct [Double] threshold for throwing an error for percent difference
+    # @param max_pass_pct [Double] threshold for throwing an error for percent difference
+    # @param name_only [Boolean] If true, only return the name of this check
+    # @return [OpenStudio::Attribute] OpenStudio Attribute object containing check results
+    def self.check_eui(category, target_standard, min_pass_pct: 0.1, max_pass_pct: 0.1, name_only: false)
+      # summary of the check
+      check_elems = OpenStudio::AttributeVector.new
+      check_elems << OpenStudio::Attribute.new('name', 'EUI Reasonableness')
+      check_elems << OpenStudio::Attribute.new('category', category)
+      check_elems << OpenStudio::Attribute.new('description', "Check EUI for model against #{target_standard} DOE prototype buildings.")
+
+      # stop here if only name is requested this is used to populate display name for arguments
+      if name_only == true
+        results = []
+        check_elems.each do |elem|
+          results << elem.valueAsString
+        end
+        return results
+      end
+
+      std = Standard.build(target_standard)
+
+      begin
+        # total building area
+        query = 'SELECT Value FROM tabulardatawithstrings WHERE '
+        query << "ReportName='AnnualBuildingUtilityPerformanceSummary' and "
+        query << "ReportForString='Entire Facility' and "
+        query << "TableName='Building Area' and "
+        query << "RowName='Total Building Area' and "
+        query << "ColumnName='Area' and "
+        query << "Units='m2';"
+        query_results = @sql.execAndReturnFirstDouble(query)
+        if query_results.empty?
+          check_elems << OpenStudio::Attribute.new('flag', "Can't calculate EUI, SQL query for building area failed.")
+          return OpenStudio::Attribute.new('check', check_elems)
+        else
+          energy_plus_area = query_results.get
+        end
+
+        # temp code to check OS vs. E+ area
+        open_studio_area = @model.getBuilding.floorArea
+        if (energy_plus_area - open_studio_area).abs >= 0.1
+          check_elems << OpenStudio::Attribute.new('flag', "EnergyPlus reported area is #{energy_plus_area} (m^2). OpenStudio reported area is #{@model.getBuilding.floorArea} (m^2).")
+        end
+
+        # EUI
+        source_units = 'GJ/m^2'
+        target_units = 'kBtu/ft^2'
+        if energy_plus_area > 0.0 # don't calculate EUI if building doesn't have any area
+          # todo -  netSiteEnergy deducts for renewable. May want to update this to show gross consumption vs. net consumption
+          eui = @sql.netSiteEnergy.get / energy_plus_area
+        else
+          check_elems << OpenStudio::Attribute.new('flag', "Can't calculate model EUI, building doesn't have any floor area.")
+          return OpenStudio::Attribute.new('check', check_elems)
+        end
+
+        # test using new method
+        std = Standard.build(target_standard)
+        target_eui = std.model_find_target_eui(@model)
+
+        # check model vs. target for user specified tolerance.
+        if !target_eui.nil?
+          eui_ip_neat = OpenStudio.toNeatString(OpenStudio.convert(eui, source_units, target_units).get, 1, true)
+          target_eui_ip_neat = OpenStudio.toNeatString(OpenStudio.convert(target_eui, source_units, target_units).get, 1, true)
+          if eui < target_eui * (1.0 - min_pass_pct)
+            check_elems << OpenStudio::Attribute.new('flag', "Model EUI of #{eui_ip_neat} (#{target_units}) is less than #{min_pass_pct * 100} % below the expected EUI of #{target_eui_ip_neat} (#{target_units}) for #{target_standard}.")
+          elsif eui > target_eui * (1.0 + max_pass_pct)
+            check_elems << OpenStudio::Attribute.new('flag', "Model EUI of #{eui_ip_neat} (#{target_units}) is more than #{max_pass_pct * 100} % above the expected EUI of #{target_eui_ip_neat} (#{target_units}) for #{target_standard}.")
+          end
+        else
+          check_elems << OpenStudio::Attribute.new('flag', "Can't calculate target EUI. Make sure model has expected climate zone and building type.")
+        end
+      rescue StandardError => e
+        # brief description of ruby error
+        check_elems << OpenStudio::Attribute.new('flag', "Error prevented QAQC check from running (#{e}).")
+
+        # backtrace of ruby error for diagnostic use
+        if @error_backtrace then check_elems << OpenStudio::Attribute.new('flag', e.backtrace.join("\n").to_s) end
+      end
+
+      # add check_elms to new attribute
+      check_elem = OpenStudio::Attribute.new('check', check_elems)
+
+      return check_elem
+    end
+
+    # Checks end use EUIs for reasonableness
+    #
+    # @param category [String] category to bin this check into
+    # @param target_standard [String] standard template, e.g. '90.1-2013'
+    # @param min_pass_pct [Double] threshold for throwing an error for percent difference
+    # @param max_pass_pct [Double] threshold for throwing an error for percent difference
+    # @param name_only [Boolean] If true, only return the name of this check
+    # @return [OpenStudio::Attribute] OpenStudio Attribute object containing check results
+    def self.check_eui_by_end_use(category, target_standard, min_pass_pct: 0.2, max_pass_pct: 0.2, name_only: false)
+      # summary of the check
+      check_elems = OpenStudio::AttributeVector.new
+      check_elems << OpenStudio::Attribute.new('name', 'End Use by Category')
+      check_elems << OpenStudio::Attribute.new('category', category)
+      check_elems << OpenStudio::Attribute.new('description', "Check end use by category against #{target_standard} DOE prototype buildings.")
+
+      # stop here if only name is requested this is used to populate display name for arguments
+      if name_only == true
+        results = []
+        check_elems.each do |elem|
+          results << elem.valueAsString
+        end
+        return results
+      end
+
+      std = Standard.build(target_standard)
+
+      begin
+        # total building area
+        query = 'SELECT Value FROM tabulardatawithstrings WHERE '
+        query << "ReportName='AnnualBuildingUtilityPerformanceSummary' and "
+        query << "ReportForString='Entire Facility' and "
+        query << "TableName='Building Area' and "
+        query << "RowName='Total Building Area' and "
+        query << "ColumnName='Area' and "
+        query << "Units='m2';"
+        query_results = @sql.execAndReturnFirstDouble(query)
+        if query_results.empty?
+          check_elems << OpenStudio::Attribute.new('flag', "Can't calculate EUI, SQL query for building area failed.")
+          return OpenStudio::Attribute.new('check', check_elems)
+        else
+          energy_plus_area = query_results.get
+        end
+
+        # temp code to check OS vs. E+ area
+        open_studio_area = @model.getBuilding.floorArea
+        if (energy_plus_area - open_studio_area).abs >= 0.1
+          check_elems << OpenStudio::Attribute.new('flag', "EnergyPlus reported area is #{energy_plus_area} (m^2). OpenStudio reported area is #{@model.getBuilding.floorArea} (m^2).")
+        end
+
+        # loop through end uses and gather consumption, normalized by floor area
+        actual_eui_by_end_use = {}
+        OpenStudio::EndUseCategoryType.getValues.each do |end_use|
+          # get end uses
+          end_use = OpenStudio::EndUseCategoryType.new(end_use).valueDescription
+          query_elec = "SELECT Value FROM tabulardatawithstrings WHERE ReportName='AnnualBuildingUtilityPerformanceSummary' and TableName='End Uses' and RowName= '#{end_use}' and ColumnName= 'Electricity'"
+          query_gas = "SELECT Value FROM tabulardatawithstrings WHERE ReportName='AnnualBuildingUtilityPerformanceSummary' and TableName='End Uses' and RowName= '#{end_use}' and ColumnName= 'Natural Gas'"
+          query_add = "SELECT Value FROM tabulardatawithstrings WHERE ReportName='AnnualBuildingUtilityPerformanceSummary' and TableName='End Uses' and RowName= '#{end_use}' and ColumnName= 'Additional Fuel'"
+          query_dc = "SELECT Value FROM tabulardatawithstrings WHERE ReportName='AnnualBuildingUtilityPerformanceSummary' and TableName='End Uses' and RowName= '#{end_use}' and ColumnName= 'District Cooling'"
+          query_dh = "SELECT Value FROM tabulardatawithstrings WHERE ReportName='AnnualBuildingUtilityPerformanceSummary' and TableName='End Uses' and RowName= '#{end_use}' and ColumnName= 'District Heating'"
+          results_elec = @sql.execAndReturnFirstDouble(query_elec).get
+          results_gas = @sql.execAndReturnFirstDouble(query_gas).get
+          results_add = @sql.execAndReturnFirstDouble(query_add).get
+          results_dc = @sql.execAndReturnFirstDouble(query_dc).get
+          results_dh = @sql.execAndReturnFirstDouble(query_dh).get
+          total_end_use = results_elec + results_gas + results_add + results_dc + results_dh
+
+          # populate hash for actual end use normalized by area
+          actual_eui_by_end_use[end_use] = total_end_use / energy_plus_area
+        end
+
+        # gather target end uses for given standard as hash
+        std = Standard.build(target_standard)
+        target_eui_by_end_use = std.model_find_target_eui_by_end_use(@model)
+
+        # units for flag display text and unit conversion
+        source_units = 'GJ/m^2'
+        target_units = 'kBtu/ft^2'
+
+        # check acutal vs. target against tolerance
+        if !target_eui_by_end_use.nil?
+          actual_eui_by_end_use.each do |end_use, value|
+            # this should have value of 0 in model. This page change in the future. It doesn't exist in target lookup
+            next if end_use == 'Exterior Equipment'
+
+            # perform check and issue flags as needed
+            target_value = target_eui_by_end_use[end_use]
+            eui_ip_neat = OpenStudio.toNeatString(OpenStudio.convert(value, source_units, target_units).get, 5, true)
+            target_eui_ip_neat = OpenStudio.toNeatString(OpenStudio.convert(target_value, source_units, target_units).get, 1, true)
+
+            # add in use case specific logic to skip checks when near 0 actual and target
+            skip = false
+            if (end_use == 'Heat Recovery') && (value < 0.05) && (target_value < 0.05) then skip = true end
+            if (end_use == 'Pumps') && (value < 0.05) && (target_value < 0.05) then skip = true end
+
+            if (value < target_value * (1.0 - min_pass_pct)) && !skip
+              check_elems << OpenStudio::Attribute.new('flag', "#{end_use} EUI of #{eui_ip_neat} (#{target_units}) is less than #{min_pass_pct * 100} % below the expected #{end_use} EUI of #{target_eui_ip_neat} (#{target_units}) for #{target_standard}.")
+            elsif (value > target_value * (1.0 + max_pass_pct)) && !skip
+              check_elems << OpenStudio::Attribute.new('flag', "#{end_use} EUI of #{eui_ip_neat} (#{target_units}) is more than #{max_pass_pct * 100} % above the expected #{end_use} EUI of #{target_eui_ip_neat} (#{target_units}) for #{target_standard}.")
+            end
+          end
+        else
+          check_elems << OpenStudio::Attribute.new('flag', "Can't calculate target end use EUIs. Make sure model has expected climate zone and building type.")
+        end
+      rescue StandardError => e
+        # brief description of ruby error
+        check_elems << OpenStudio::Attribute.new('flag', "Error prevented QAQC check from running (#{e}).")
+
+        # backtrace of ruby error for diagnostic use
+        if @error_backtrace then check_elems << OpenStudio::Attribute.new('flag', e.backtrace.join("\n").to_s) end
+      end
+
+      # add check_elms to new attribute
+      check_elem = OpenStudio::Attribute.new('check', check_elems)
+
+      return check_elem
+    end
+  end
+end