openstudio-extension 0.7.0 → 0.8.0

data/lib/openstudio/extension/core/check_envelope_conductance.rb

@@ -1,423 +0,0 @@
-# *******************************************************************************
-# OpenStudio(R), Copyright (c) Alliance for Sustainable Energy, LLC.
-# See also https://openstudio.net/license
-# *******************************************************************************
-
-module OsLib_QAQC
-  # include any general notes about QAQC method here
-
-  # checks the number of unmet hours in the model
-  # todo - do I need unique tolerance ranges for conductance, reflectance, and shgc
-  def check_envelope_conductance(category, target_standard, min_pass, max_pass, 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 relfectance 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 relfectance 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
-
-    # 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
-
-    # Versions of OpenStudio greater than 2.4.0 use a modified version of
-    # openstudio-standards with different method calls.  These methods
-    # require a "Standard" object instead of the standard being passed into method calls.
-    # This Standard object is used throughout the QAQC check.
-    if OpenStudio::VersionString.new(OpenStudio.openStudioVersion) < OpenStudio::VersionString.new('2.4.3')
-      use_old_gem_code = true
-    else
-      use_old_gem_code = false
-      std = Standard.build(target_standard)
-    end
-
-    begin
-      # loop through all space types used in the model
-      @model.getSpaceTypes.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] = {}
-          if use_old_gem_code
-            data = space_type.get_construction_properties(target_standard, intended_surface_type, standards_construction_type)
-          else
-            data = std.space_type_get_construction_properties(space_type, intended_surface_type, standards_construction_type)
-          end
-          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_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_constructions << sub_surface.name.get
-              end
-            end
-          end
-        end
-
-        if !missing_surface_constructions.empty?
-          check_elems << OpenStudio::Attribute.new('flag', "#{missing_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_constructions.size} sub surfaces are missing constructions in #{space_type.name}. Spaces and can't be checked.")
-        end
-
-        # gather targer 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 arary combinations
-        surface_details.uniq.each do |surface_detail|
-          if surface_detail[:construction].thermalConductance.is_initialized
-
-            # don't use intened 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'
-              if surface_type.to_s == 'Wall' then intended_surface_type = 'ExteriorWall' end
-              if surface_type == 'RoofCeiling' then intended_surface_type = 'ExteriorRoof' end
-              if surface_type == 'Floor' then intended_surface_type = 'ExteriorFloor' end
-            else
-              # currently only used for surfaces with outdoor boundary condition
-            end
-            if use_old_gem_code
-              film_coefficients_r_value = surface_detail[:construction].to_LayeredConstruction.get.to_Construction.get.film_coefficients_r_value(intended_surface_type)
-            else
-              film_coefficients_r_value = std.film_coefficients_r_value(intended_surface_type, includes_int_film = true, includes_ext_film = true)
-            end
-            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 optional first does what happens with ext. 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)
-              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 * 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)
-              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 * 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)) && (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 * 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)) && (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 * 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 arary 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'
-
-            if use_old_gem_code
-              u_factor_si = sub_surface_detail[:construction].to_LayeredConstruction.get.to_Construction.get.calculated_u_factor
-            else
-              u_factor_si = std.construction_calculated_u_factor(sub_surface_detail[:construction].to_LayeredConstruction.get.to_Construction.get)
-            end
-            u_factor_ip = OpenStudio.convert(u_factor_si, source_units, target_units).get
-            if use_old_gem_code
-              shgc = sub_surface_detail[:construction].to_LayeredConstruction.get.to_Construction.get.calculated_solar_heat_gain_coefficient
-            else
-              shgc = std.construction_calculated_solar_heat_gain_coefficient(sub_surface_detail[:construction].to_LayeredConstruction.get.to_Construction.get)
-            end
-
-            # 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)
-              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 * 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)
-              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 * 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)
-              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 * 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)
-              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 * 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 intened 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
-              if use_old_gem_code
-                film_coefficients_r_value = sub_surface_detail[:construction].to_LayeredConstruction.get.to_Construction.get.film_coefficients_r_value(intended_surface_type)
-              else
-                film_coefficients_r_value = std.film_coefficients_r_value(intended_surface_type, includes_int_film = true, includes_ext_film = true)
-              end
-
-              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 optional first does what happens with ext. 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)
-                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 * 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)
-                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 * 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)) && (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 * 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)) && (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 * 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.each do |space|
-        if !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_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_constructions << sub_surface.name.get
-              end
-            end
-          end
-
-          if !missing_surface_constructions.empty?
-            check_elems << OpenStudio::Attribute.new('flag', "#{missing_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_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 intened 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'
-                if surface_type.to_s == 'Wall'
-                  intended_surface_type = 'ExteriorWall'
-                  standards_construction_type = 'SteelFramed'
-                elsif surface_type == 'RoofCeiling'
-                  intended_surface_type = 'ExteriorRoof'
-                  standards_construction_type = 'IEAD'
-                else surface_type == 'Floor'
-                     intended_surface_type = 'ExteriorFloor'
-                     standards_construction_type = 'Mass'
-                end
-              else
-                # currently only used for surfaces with outdoor boundary condition
-              end
-              if use_old_gem_code
-                film_coefficients_r_value = surface_detail[:construction].to_LayeredConstruction.get.to_Construction.get.film_coefficients_r_value(intended_surface_type)
-              else
-                film_coefficients_r_value = std.film_coefficients_r_value(intended_surface_type, includes_int_film = true, includes_ext_film = true)
-              end
-
-              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 optional first does what happens with ext. air wall
-
-              # calculate target_r_value_ip
-              target_reflectance = nil
-              if use_old_gem_code
-                data = @model.get_construction_properties(target_standard, intended_surface_type, standards_construction_type)
-              else
-                data = std.model_get_construction_properties(@model, intended_surface_type, standards_construction_type)
-              end
-
-              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)
-                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 * 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)
-                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 * 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)) && (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 * 100} % below the expected value of #{(target_reflectance * 100).round} %.")
-              elsif (solar_reflectance > target_reflectance * (1.0 + max_pass)) && (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 * 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
-    # note: registerWarning and registerValue will be added for checks downstream using os_lib_reporting_qaqc.rb
-  end
-end

data/lib/openstudio/extension/core/check_eui_by_end_use.rb

@@ -1,132 +0,0 @@
-# *******************************************************************************
-# OpenStudio(R), Copyright (c) Alliance for Sustainable Energy, LLC.
-# See also https://openstudio.net/license
-# *******************************************************************************
-
-module OsLib_QAQC
-  # include any general notes about QAQC method here
-
-  # checks the number of unmet hours in the model
-  def check_eui_by_end_use(category, target_standard, min_pass, max_pass, 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
-
-    # Versions of OpenStudio greater than 2.4.0 use a modified version of
-    # openstudio-standards with different method calls.  These methods
-    # require a "Standard" object instead of the standard being passed into method calls.
-    # This Standard object is used throughout the QAQC check.
-    if OpenStudio::VersionString.new(OpenStudio.openStudioVersion) < OpenStudio::VersionString.new('2.4.3')
-      use_old_gem_code = true
-    else
-      use_old_gem_code = false
-      std = Standard.build(target_standard)
-    end
-
-    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
-      if use_old_gem_code
-        target_eui_by_end_use = @model.find_target_eui_by_end_use(target_standard)
-      else
-        std = Standard.build(target_standard)
-        target_eui_by_end_use = std.model_find_target_eui_by_end_use(@model)
-      end
-
-      # 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)) && !skip
-            check_elems << OpenStudio::Attribute.new('flag', "#{end_use} EUI of #{eui_ip_neat} (#{target_units}) is less than #{min_pass * 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)) && !skip
-            check_elems << OpenStudio::Attribute.new('flag', "#{end_use} EUI of #{eui_ip_neat} (#{target_units}) is more than #{max_pass * 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
-    # note: registerWarning and registerValue will be added for checks downstream using os_lib_reporting_qaqc.rb
-  end
-end