openstudio-standards 0.3.1.rc2 → 0.5.0.rc1

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

@@ -0,0 +1,568 @@
+# Module to apply QAQC checks to a model
+module OpenstudioStandards
+  module QAQC
+    # @!group Internal Loads
+
+    # Check the internal loads 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
+    def self.check_internal_loads(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', 'Internal Loads')
+      check_elems << OpenStudio::Attribute.new('category', category)
+      if target_standard == 'ICC IECC 2015'
+        check_elems << OpenStudio::Attribute.new('description', 'Check internal loads against Table R405.5.2(1) in ICC IECC 2015 Residential Provisions.')
+      else
+        if target_standard.include?('90.1')
+          display_standard = "ASHRAE #{target_standard}"
+        else
+          display_standard = target_standard
+        end
+        check_elems << OpenStudio::Attribute.new('description', "Check LPD, ventilation rates, occupant density, plug loads, and equipment loads against #{display_standard} and DOE Prototype buildings.")
+      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)
+
+      begin
+        if target_standard == 'ICC IECC 2015'
+
+          num_people = 0.0
+          @model.getSpaceTypes.each do |space_type|
+            next if !space_type.standardsSpaceType.is_initialized
+            next if space_type.standardsSpaceType.get != 'Apartment' # currently only supports midrise apt space type
+
+            space_type_floor_area = space_type.floorArea
+            space_type_num_people = space_type.getNumberOfPeople(space_type_floor_area)
+            num_people += space_type_num_people
+          end
+
+          # lookup iecc internal loads for the building
+          bedrooms_per_unit = 2.0 # assumption
+          num_units = num_people / 2.5 # Avg 2.5 units per person.
+          target_loads_hash = std.model_find_icc_iecc_2015_internal_loads(@model, num_units, bedrooms_per_unit)
+
+          # get model internal gains for lights, elec equipment, and gas equipment
+          model_internal_gains_si = 0.0
+          query_eleint_lights = "SELECT Value FROM tabulardatawithstrings WHERE ReportName='AnnualBuildingUtilityPerformanceSummary' and TableName='End Uses' and RowName= 'Interior Lighting' and ColumnName= 'Electricity'"
+          query_elec_equip = "SELECT Value FROM tabulardatawithstrings WHERE ReportName='AnnualBuildingUtilityPerformanceSummary' and TableName='End Uses' and RowName= 'Interior Equipment' and ColumnName= 'Electricity'"
+          query_gas_equip = "SELECT Value FROM tabulardatawithstrings WHERE ReportName='AnnualBuildingUtilityPerformanceSummary' and TableName='End Uses' and RowName= 'Interior Equipment' and ColumnName= 'Natural Gas'"
+          model_internal_gains_si += results_elec = @sql.execAndReturnFirstDouble(query_eleint_lights).get
+          model_internal_gains_si += results_elec = @sql.execAndReturnFirstDouble(query_elec_equip).get
+          model_internal_gains_si += results_elec = @sql.execAndReturnFirstDouble(query_gas_equip).get
+          model_internal_gains_si_kbtu_per_day = OpenStudio.convert(model_internal_gains_si, 'GJ', 'kBtu').get / 365.0 # assumes annual run
+
+          # get target internal loads
+          target_igain_btu_per_day = target_loads_hash['igain_btu_per_day']
+          target_igain_kbtu_per_day = OpenStudio.convert(target_igain_btu_per_day, 'Btu', 'kBtu').get
+
+          # check internal loads
+          if model_internal_gains_si_kbtu_per_day < target_igain_kbtu_per_day * (1.0 - min_pass_pct)
+            check_elems << OpenStudio::Attribute.new('flag', "The model average of #{OpenStudio.toNeatString(model_internal_gains_si_kbtu_per_day, 2, true)} (kBtu/day) is more than #{min_pass_pct * 100} % below the expected value of #{OpenStudio.toNeatString(target_igain_kbtu_per_day, 2, true)} (kBtu/day) for #{target_standard}.")
+          elsif model_internal_gains_si_kbtu_per_day > target_igain_kbtu_per_day * (1.0 + max_pass_pct)
+            check_elems << OpenStudio::Attribute.new('flag', "The model average of #{OpenStudio.toNeatString(model_internal_gains_si_kbtu_per_day, 2, true)} (kBtu/day) is more than #{max_pass_pct * 100} % above the expected value of #{OpenStudio.toNeatString(target_igain_kbtu_per_day, 2, true)} k(Btu/day) for #{target_standard}.")
+          end
+
+          # get target mech vent
+          target_mech_vent_cfm = target_loads_hash['mech_vent_cfm']
+
+          # get model mech vent
+          model_mech_vent_si = 0
+          @model.getSpaceTypes.each do |space_type|
+            next if space_type.floorArea <= 0
+
+            # get necessary space type information
+            floor_area = space_type.floorArea
+            num_people = space_type.getNumberOfPeople(floor_area)
+
+            # get volume for space type for use with ventilation and infiltration
+            space_type_volume = 0.0
+            space_type_exterior_area = 0.0
+            space_type_exterior_wall_area = 0.0
+            space_type.spaces.each do |space|
+              space_type_volume += space.volume * space.multiplier
+              space_type_exterior_area = space.exteriorArea * space.multiplier
+              space_type_exterior_wall_area = space.exteriorWallArea * space.multiplier
+            end
+
+            # get design spec OA object
+            if space_type.designSpecificationOutdoorAir.is_initialized
+              oa = space_type.designSpecificationOutdoorAir.get
+              oa_method = oa.outdoorAirMethod
+              oa_per_person = oa.outdoorAirFlowperPerson * num_people
+              oa_ach = oa.outdoorAirFlowAirChangesperHour * space_type_volume
+              oa_per_area = oa.outdoorAirFlowperFloorArea * floor_area
+              oa_flow_rate = oa.outdoorAirFlowRate
+              oa_space_type_total = oa_per_person + oa_ach + oa_per_area + oa_flow_rate
+
+              value_count = 0
+              if oa_per_person > 0 then value_count += 1 end
+              if oa_ach > 0 then value_count += 1 end
+              if oa_per_area > 0 then value_count += 1 end
+              if oa_flow_rate > 0 then value_count += 1 end
+              if (oa_method != 'Sum') && (value_count > 1)
+                check_elems << OpenStudio::Attribute.new('flag', "Outdoor Air Method for #{space_type.name} was #{oa_method}. Expected value was Sum.")
+              end
+            else
+              oa_space_type_total = 0.0
+            end
+            # add to building total oa
+            model_mech_vent_si += oa_space_type_total
+          end
+
+          # check oa
+          model_mech_vent_cfm = OpenStudio.convert(model_mech_vent_si, 'm^3/s', 'cfm').get
+          if model_mech_vent_cfm < target_mech_vent_cfm * (1.0 - min_pass_pct)
+            check_elems << OpenStudio::Attribute.new('flag', "The model mechanical ventilation of  #{OpenStudio.toNeatString(model_mech_vent_cfm, 2, true)} cfm is more than #{min_pass_pct * 100} % below the expected value of #{OpenStudio.toNeatString(target_mech_vent_cfm, 2, true)} cfm for #{target_standard}.")
+          elsif model_mech_vent_cfm > target_mech_vent_cfm * (1.0 + max_pass_pct)
+            check_elems << OpenStudio::Attribute.new('flag', "The model mechanical ventilation of #{OpenStudio.toNeatString(model_mech_vent_cfm, 2, true)} cfm is more than #{max_pass_pct * 100} % above the expected value of #{OpenStudio.toNeatString(target_mech_vent_cfm, 2, true)} cfm for #{target_standard}.")
+          end
+
+        else
+
+          # loop through all space types used in the model
+          @model.getSpaceTypes.sort.each do |space_type|
+            next if space_type.floorArea <= 0
+            next if space_type.name.to_s == 'Plenum'
+
+            # get necessary space type information
+            floor_area = space_type.floorArea
+            num_people = space_type.getNumberOfPeople(floor_area)
+
+            # load in standard info for this space type
+            data = std.space_type_get_standards_data(space_type)
+
+            if data.nil? || data.empty?
+
+              # skip if all spaces using this space type are plenums
+              all_spaces_plenums = true
+              space_type.spaces.each do |space|
+                unless std.space_plenum?(space)
+                  all_spaces_plenums = false
+                  next
+                end
+              end
+
+              unless all_spaces_plenums
+                check_elems << OpenStudio::Attribute.new('flag', "Unexpected standards type for #{space_type.name}, can't validate internal loads.")
+              end
+
+              next
+            end
+
+            # check lpd for space type
+            model_lights_si = space_type.getLightingPowerPerFloorArea(floor_area, num_people)
+            data['lighting_per_area'].nil? ? (target_lights_ip = 0.0) : (target_lights_ip = data['lighting_per_area'])
+            source_units = 'W/m^2'
+            target_units = 'W/ft^2'
+            load_type = 'Lighting Power Density'
+            model_ip = OpenStudio.convert(model_lights_si, source_units, target_units).get
+            target_ip = target_lights_ip.to_f
+            model_ip_neat = OpenStudio.toNeatString(model_ip, 2, true)
+            target_ip_neat = OpenStudio.toNeatString(target_ip, 2, true)
+            if model_ip < target_ip * (1.0 - min_pass_pct)
+              check_elems << OpenStudio::Attribute.new('flag', "#{load_type} of #{model_ip_neat} (#{target_units}) for #{space_type.name} is more than #{min_pass_pct * 100} % below the expected value of #{target_ip_neat} (#{target_units}) for #{display_standard}.")
+            elsif model_ip > target_ip * (1.0 + max_pass_pct)
+              check_elems << OpenStudio::Attribute.new('flag', "#{load_type} of #{model_ip_neat} (#{target_units}) for #{space_type.name} is more than #{max_pass_pct * 100} % above the expected value of #{target_ip_neat} (#{target_units}) for #{display_standard}.")
+            end
+
+            # check electric equipment
+            model_elec_si = space_type.getElectricEquipmentPowerPerFloorArea(floor_area, num_people)
+            data['electric_equipment_per_area'].nil? ? (target_elec_ip = 0.0) : (target_elec_ip = data['electric_equipment_per_area'])
+            source_units = 'W/m^2'
+            target_units = 'W/ft^2'
+            load_type = 'Electric Power Density'
+            model_ip = OpenStudio.convert(model_elec_si, source_units, target_units).get
+            target_ip = target_elec_ip.to_f
+            model_ip_neat = OpenStudio.toNeatString(model_ip, 2, true)
+            target_ip_neat = OpenStudio.toNeatString(target_ip, 2, true)
+            if model_ip < target_ip * (1.0 - min_pass_pct)
+              check_elems << OpenStudio::Attribute.new('flag', "#{load_type} of #{model_ip_neat} (#{target_units}) for #{space_type.name} is more than #{min_pass_pct * 100} % below the expected value of #{target_ip_neat} (#{target_units}) for #{display_standard}.")
+            elsif model_ip > target_ip * (1.0 + max_pass_pct)
+              check_elems << OpenStudio::Attribute.new('flag', "#{load_type} of #{model_ip_neat} (#{target_units}) for #{space_type.name} is more than #{max_pass_pct * 100} % above the expected value of #{target_ip_neat} (#{target_units}) for #{display_standard}.")
+            end
+
+            # check gas equipment
+            model_gas_si = space_type.getGasEquipmentPowerPerFloorArea(floor_area, num_people)
+            data['gas_equipment_per_area'].nil? ? (target_gas_ip = 0.0) : (target_gas_ip = data['gas_equipment_per_area'])
+            source_units = 'W/m^2'
+            target_units = 'Btu/hr*ft^2'
+            load_type = 'Gas Power Density'
+            model_ip = OpenStudio.convert(model_gas_si, source_units, target_units).get
+            target_ip = target_gas_ip.to_f
+            model_ip_neat = OpenStudio.toNeatString(model_ip, 2, true)
+            target_ip_neat = OpenStudio.toNeatString(target_ip, 2, true)
+            if model_ip < target_ip * (1.0 - min_pass_pct)
+              check_elems << OpenStudio::Attribute.new('flag', "#{load_type} of #{model_ip_neat} (#{target_units}) for #{space_type.name} is more than #{min_pass_pct * 100} % below the expected value of #{target_ip_neat} (#{target_units}) for #{display_standard}.")
+            elsif model_ip > target_ip * (1.0 + max_pass_pct)
+              check_elems << OpenStudio::Attribute.new('flag', "#{load_type} of #{model_ip_neat} (#{target_units}) for #{space_type.name} is more than #{max_pass_pct * 100} % above the expected value of #{target_ip_neat} (#{target_units}) for #{display_standard}.")
+            end
+
+            # check people
+            model_occ_si = space_type.getPeoplePerFloorArea(floor_area)
+            data['occupancy_per_area'].nil? ? (target_occ_ip = 0.0) : (target_occ_ip = data['occupancy_per_area'])
+            source_units = '1/m^2' # people/m^2
+            target_units = '1/ft^2' # people per ft^2 (can't add *1000) to the bottom, need to do later
+            load_type = 'Occupancy per Area'
+            model_ip = OpenStudio.convert(model_occ_si, source_units, target_units).get * 1000.0
+            target_ip = target_occ_ip.to_f
+            model_ip_neat = OpenStudio.toNeatString(model_ip, 2, true)
+            target_ip_neat = OpenStudio.toNeatString(target_ip, 2, true)
+            # for people need to update target units just for display. Can't be used for converstion.
+            target_units = 'People/1000 ft^2'
+            if model_ip < target_ip * (1.0 - min_pass_pct)
+              check_elems << OpenStudio::Attribute.new('flag', "#{load_type} of #{model_ip_neat} (#{target_units}) for #{space_type.name} is more than #{min_pass_pct * 100} % below the expected value of #{target_ip_neat} (#{target_units}) for #{display_standard}.")
+            elsif model_ip > target_ip * (1.0 + max_pass_pct)
+              check_elems << OpenStudio::Attribute.new('flag', "#{load_type} of #{model_ip_neat} (#{target_units}) for #{space_type.name} is more than #{max_pass_pct * 100} % above the expected value of #{target_ip_neat} (#{target_units}) for #{display_standard}.")
+            end
+
+            # get volume for space type for use with ventilation and infiltration
+            space_type_volume = 0.0
+            space_type_exterior_area = 0.0
+            space_type_exterior_wall_area = 0.0
+            space_type.spaces.each do |space|
+              space_type_volume += space.volume * space.multiplier
+              space_type_exterior_area = space.exteriorArea * space.multiplier
+              space_type_exterior_wall_area = space.exteriorWallArea * space.multiplier
+            end
+
+            # get design spec OA object
+            if space_type.designSpecificationOutdoorAir.is_initialized
+              oa = space_type.designSpecificationOutdoorAir.get
+              oa_method = oa.outdoorAirMethod
+              oa_per_person = oa.outdoorAirFlowperPerson
+              oa_ach = oa.outdoorAirFlowAirChangesperHour * space_type_volume
+              oa_per_area = oa.outdoorAirFlowperFloorArea * floor_area
+              oa_flow_rate = oa.outdoorAirFlowRate
+              oa_total = oa_ach + oa_per_area + oa_flow_rate
+
+              value_count = 0
+              if oa_per_person > 0 then value_count += 1 end
+              if oa_ach > 0 then value_count += 1 end
+              if oa_per_area > 0 then value_count += 1 end
+              if oa_flow_rate > 0 then value_count += 1 end
+              if (oa_method != 'Sum') && (value_count > 1)
+                check_elems << OpenStudio::Attribute.new('flag', "Outdoor Air Method for #{space_type.name} was #{oa_method}. Expected value was Sum.")
+              end
+            else
+              oa_per_person = 0.0
+            end
+
+            # get target values for OA
+            target_oa_per_person_ip = data['ventilation_per_person'].to_f # ft^3/min*person
+            target_oa_ach_ip = data['ventilation_air_changes'].to_f # ach
+            target_oa_per_area_ip = data['ventilation_per_area'].to_f # ft^3/min*ft^2
+            if target_oa_per_person_ip.nil?
+              target_oa_per_person_si = 0.0
+            else
+              target_oa_per_person_si = OpenStudio.convert(target_oa_per_person_ip, 'cfm', 'm^3/s').get
+            end
+            if target_oa_ach_ip.nil?
+              target_oa_ach_si = 0.0
+            else
+              target_oa_ach_si = target_oa_ach_ip * space_type_volume
+            end
+            if target_oa_per_area_ip.nil?
+              target_oa_per_area_si = 0.0
+            else
+              target_oa_per_area_si = OpenStudio.convert(target_oa_per_area_ip, 'cfm/ft^2', 'm^3/s*m^2').get * floor_area
+            end
+            target_oa_total = target_oa_ach_si + target_oa_per_area_si
+
+            # check oa per person
+            source_units = 'm^3/s'
+            target_units = 'cfm'
+            load_type = 'Outdoor Air Per Person'
+            model_ip_neat = OpenStudio.toNeatString(OpenStudio.convert(oa_per_person, source_units, target_units).get, 2, true)
+            target_ip_neat = OpenStudio.toNeatString(target_oa_per_person_ip, 2, true)
+            if oa_per_person < target_oa_per_person_si * (1.0 - min_pass_pct)
+              check_elems << OpenStudio::Attribute.new('flag', "#{load_type} of #{model_ip_neat} (#{target_units}) for #{space_type.name} is more than #{min_pass_pct * 100} % below the expected value of #{target_ip_neat} (#{target_units}) for #{display_standard}.")
+            elsif oa_per_person > target_oa_per_person_si * (1.0 + max_pass_pct)
+              check_elems << OpenStudio::Attribute.new('flag', "#{load_type} of #{model_ip_neat} (#{target_units}) for #{space_type.name} is more than #{max_pass_pct * 100} % above the expected value of #{target_ip_neat} (#{target_units}) for #{display_standard}.")
+            end
+
+            # check other oa
+            source_units = 'm^3/s'
+            target_units = 'cfm'
+            load_type = 'Outdoor Air (Excluding per Person Value)'
+            model_ip_neat = OpenStudio.toNeatString(OpenStudio.convert(oa_total, source_units, target_units).get, 2, true)
+            target_ip_neat = OpenStudio.toNeatString(OpenStudio.convert(target_oa_total, source_units, target_units).get, 2, true)
+            if oa_total < target_oa_total * (1.0 - min_pass_pct)
+              check_elems << OpenStudio::Attribute.new('flag', "#{load_type} of #{model_ip_neat} (#{target_units}) for #{space_type.name} is more than #{min_pass_pct * 100} % below the expected value of #{target_ip_neat} (#{target_units}) for #{display_standard}.")
+            elsif oa_total > target_oa_total * (1.0 + max_pass_pct)
+              check_elems << OpenStudio::Attribute.new('flag', "#{load_type} of #{model_ip_neat} (#{target_units}) for #{space_type.name} is more than #{max_pass_pct * 100} % above the expected value of #{target_ip_neat} (#{target_units}) for #{display_standard}.")
+            end
+          end
+
+          # warn if there are spaces in model that don't use space type unless they appear to be plenums
+          @model.getSpaces.sort.each do |space|
+            next if std.space_plenum?(space)
+
+            if !space.spaceType.is_initialized
+              check_elems << OpenStudio::Attribute.new('flag', "#{space.name} doesn't have a space type assigned, can't validate internal loads.")
+            end
+          end
+
+          # @todo need to address internal loads where fuel is variable like cooking and laundry
+          # @todo For now we are not going to loop through spaces looking for loads beyond what comes from space type
+          # @todo space infiltration
+
+        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
+
+    # Check the internal load schedules against template prototypes
+    #
+    # @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_internal_loads_schedules(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', 'Schedules')
+      check_elems << OpenStudio::Attribute.new('category', category)
+      check_elems << OpenStudio::Attribute.new('description', 'Check schedules for lighting, ventilation, occupant density, plug loads, and equipment based on DOE reference building schedules in terms of full load hours per year.')
+
+      # 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
+        # loop through all space types used in the model
+        @model.getSpaceTypes.each do |space_type|
+          next if space_type.floorArea <= 0
+
+          # load in standard info for this space type
+          data = std.space_type_get_standards_data(space_type)
+
+          if data.nil? || data.empty?
+
+            # skip if all spaces using this space type are plenums
+            all_spaces_plenums = true
+            space_type.spaces.each do |space|
+              unless std.space_plenum?(space)
+                all_spaces_plenums = false
+                break
+                end
+            end
+
+            unless all_spaces_plenums
+              check_elems << OpenStudio::Attribute.new('flag', "Unexpected standards type for #{space_type.name}, can't validate schedules.")
+              end
+
+            next
+          end
+
+          # temp model to hold schedules to check
+          model_temp = OpenStudio::Model::Model.new
+
+          # check lighting schedules
+          data['lighting_per_area'].nil? ? (target_ip = 0.0) : (target_ip = data['lighting_per_area'])
+          if target_ip.to_f > 0
+            schedule_target = std.model_add_schedule(model_temp, data['lighting_schedule'])
+            if !schedule_target
+              check_elems << OpenStudio::Attribute.new('flag', "Didn't find schedule named #{data['lighting_schedule']} in standards json.")
+            elsif !schedule_target.to_ScheduleRuleset.is_initialized
+              check_elems << OpenStudio::Attribute.new('flag', "Schedule named #{schedule_target.name} is a #{schedule_target.class}, not a ScheduleRuleset schedule.")
+            else
+              schedule_target = schedule_target.to_ScheduleRuleset.get
+              # loop through and test individual load instances
+              expected_hours = std.schedule_ruleset_annual_equivalent_full_load_hrs(schedule_target)
+              space_type.lights.each do |space_load_instance|
+                inst_sch_check = OpenstudioStandards::QAQC.space_load_instance_schedule_check(space_load_instance, expected_hours, std: std, min_pass_pct: min_pass_pct, max_pass_pct: max_pass_pct)
+                if inst_sch_check then check_elems << inst_sch_check end
+              end
+
+            end
+          end
+
+          # check electric equipment schedules
+          data['electric_equipment_per_area'].nil? ? (target_ip = 0.0) : (target_ip = data['electric_equipment_per_area'])
+          if target_ip.to_f > 0
+            schedule_target = std.model_add_schedule(model_temp, data['electric_equipment_schedule'])
+            if !schedule_target
+              check_elems << OpenStudio::Attribute.new('flag', "Didn't find schedule named #{data['electric_equipment_schedule']} in standards json.")
+            elsif !schedule_target.to_ScheduleRuleset.is_initialized
+              check_elems << OpenStudio::Attribute.new('flag', "Schedule named #{schedule_target.name} is a #{schedule_target.class}, not a ScheduleRuleset schedule.")
+            else
+              schedule_target = schedule_target.to_ScheduleRuleset.get
+              # loop through and test individual load instances
+              expected_hours = std.schedule_ruleset_annual_equivalent_full_load_hrs(schedule_target)
+
+              space_type.electricEquipment.each do |space_load_instance|
+                inst_sch_check = OpenstudioStandards::QAQC.space_load_instance_schedule_check(space_load_instance, expected_hours, std: std, min_pass_pct: min_pass_pct, max_pass_pct: max_pass_pct)
+                if inst_sch_check then check_elems << inst_sch_check end
+              end
+            end
+          end
+
+          # check gas equipment schedules
+          # @todo - update measure test to with space type to check this
+          data['gas_equipment_per_area'].nil? ? (target_ip = 0.0) : (target_ip = data['gas_equipment_per_area'])
+          if target_ip.to_f > 0
+            schedule_target = std.model_add_schedule(model_temp, data['gas_equipment_schedule'])
+            if !schedule_target
+              check_elems << OpenStudio::Attribute.new('flag', "Didn't find schedule named #{data['gas_equipment_schedule']} in standards json.")
+            elsif !schedule_target.to_ScheduleRuleset.is_initialized
+              check_elems << OpenStudio::Attribute.new('flag', "Schedule named #{schedule_target.name} is a #{schedule_target.class}, not a ScheduleRuleset schedule.")
+            else
+              schedule_target = schedule_target.to_ScheduleRuleset.get
+              # loop through and test individual load instances
+              expected_hours = std.schedule_ruleset_annual_equivalent_full_load_hrs(schedule_target)
+              space_type.gasEquipment.each do |space_load_instance|
+                inst_sch_check = OpenstudioStandards::QAQC.space_load_instance_schedule_check(space_load_instance, expected_hours, std: std, min_pass_pct: min_pass_pct, max_pass_pct: max_pass_pct)
+                if inst_sch_check then check_elems << inst_sch_check end
+              end
+            end
+          end
+
+          # check occupancy schedules
+          data['occupancy_per_area'].nil? ? (target_ip = 0.0) : (target_ip = data['occupancy_per_area'])
+          if target_ip.to_f > 0
+            schedule_target = std.model_add_schedule(model_temp, data['occupancy_schedule'])
+            if !schedule_target
+              check_elems << OpenStudio::Attribute.new('flag', "Didn't find schedule named #{data['occupancy_schedule']} in standards json.")
+            elsif !schedule_target.to_ScheduleRuleset.is_initialized
+              check_elems << OpenStudio::Attribute.new('flag', "Schedule named #{schedule_target.name} is a #{schedule_target.class}, not a ScheduleRuleset schedule.")
+            else
+              schedule_target = schedule_target.to_ScheduleRuleset.get
+              # loop through and test individual load instances
+              expected_hours = std.schedule_ruleset_annual_equivalent_full_load_hrs(schedule_target)
+              space_type.people.each do |space_load_instance|
+                inst_sch_check = OpenstudioStandards::QAQC.space_load_instance_schedule_check(space_load_instance, expected_hours, std: std, min_pass_pct: min_pass_pct, max_pass_pct: max_pass_pct)
+                if inst_sch_check then check_elems << inst_sch_check end
+              end
+
+            end
+          end
+
+          # @todo: check ventilation schedules
+          # if objects are in the model should they just be always on schedule, or have a 8760 annual equivalent value
+          # oa_schedule should not exist, or if it does shoudl be always on or have 8760 annual equivalent value
+          if space_type.designSpecificationOutdoorAir.is_initialized
+            oa = space_type.designSpecificationOutdoorAir.get
+            if oa.outdoorAirFlowRateFractionSchedule.is_initialized
+              # @todo: update measure test to check this
+              expected_hours = 8760
+              inst_sch_check = OpenstudioStandards::QAQC.space_load_instance_schedule_check(oa, expected_hours, std: std, min_pass_pct: min_pass_pct, max_pass_pct: max_pass_pct)
+              if inst_sch_check then check_elems << inst_sch_check end
+            end
+          end
+
+          # notes
+          # current logic only looks at 8760 values and not design days
+          # when multiple instances of a type currently check every schedule by itself. In future could do weighted avgerage merge
+          # not looking at infiltration schedules
+          # not looking at luminaires
+          # not looking at space loads, only loads at space type
+          # only checking schedules where standard shows non zero load value
+          # model load for space type where standards doesn't have one wont throw flag about mis-matched schedules
+        end
+
+        # warn if there are spaces in model that don't use space type unless they appear to be plenums
+        @model.getSpaces.sort.each do |space|
+          next if std.space_plenum?(space)
+
+          if !space.spaceType.is_initialized
+            check_elems << OpenStudio::Attribute.new('flag', "#{space.name} doesn't have a space type assigned, can't validate schedules.")
+          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
+
+    # Check the schedule for a space load instance
+    # will return false or a single attribute
+    #
+    # @param space_load_instance [OpenStudio::Model::SpaceLoadInstance] Openstudio SpaceLoadInstance object
+    # @param expected_hours [Double] expected number of equivalent full load hours
+    # @param std [String] openstudio-standards Standard Class
+    # @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
+    # @return [OpenStudio::Attribute, false] OpenStudio Attribute object containing check results, or false if no error
+    def self.space_load_instance_schedule_check(space_load_instance, expected_hours, std: nil, min_pass_pct: 0.2, max_pass_pct: 0.2)
+      if std.nil?
+        std = Standard.build('90.1-2013')
+      end
+
+      if space_load_instance.spaceType.is_initialized
+        space_type = space_load_instance
+      end
+
+      # get schedule
+      if (space_load_instance.class.to_s == 'OpenStudio::Model::People') && space_load_instance.numberofPeopleSchedule.is_initialized
+        schedule_inst = space_load_instance.numberofPeopleSchedule.get
+      elsif (space_load_instance.class.to_s == 'OpenStudio::Model::DesignSpecificationOutdoorAir') && space_load_instance.outdoorAirFlowRateFractionSchedule.is_initialized
+        schedule_inst = space_load_instance.outdoorAirFlowRateFractionSchedule .get
+      elsif space_load_instance.schedule.is_initialized
+        schedule_inst = space_load_instance.schedule.get
+      else
+        return OpenStudio::Attribute.new('flag', "#{space_load_instance.name} in #{space_type.name} doesn't have a schedule assigned.")
+      end
+
+      # get annual equiv for model schedule
+      if schedule_inst.to_ScheduleRuleset.is_initialized
+        inst_hrs = std.schedule_ruleset_annual_equivalent_full_load_hrs(schedule_inst.to_ScheduleRuleset.get)
+      elsif schedule_inst.to_ScheduleConstant.is_initialized
+        inst_hrs = std.schedule_constant_annual_equivalent_full_load_hrs(schedule_inst.to_ScheduleConstant.get)
+      else
+        return OpenStudio::Attribute.new('flag', "#{schedule_inst.name} isn't a Ruleset or Constant schedule. Can't calculate annual equivalent full load hours.")
+      end
+
+      # check instance against target
+      if inst_hrs < expected_hours * (1.0 - min_pass_pct)
+        return OpenStudio::Attribute.new('flag', "#{inst_hrs.round} annual equivalent full load hours for #{schedule_inst.name} in #{space_type.name} is more than #{min_pass_pct * 100} (%) below the typical value of #{expected_hours.round} hours from the DOE Prototype building.")
+      elsif inst_hrs > expected_hours * (1.0 + max_pass_pct)
+        return OpenStudio::Attribute.new('flag', "#{inst_hrs.round} annual equivalent full load hours for #{schedule_inst.name} in #{space_type.name}  is more than #{max_pass_pct * 100} (%) above the typical value of #{expected_hours.round} hours DOE Prototype building.")
+      end
+
+      # will get to this if no flag was thrown
+      return false
+    end
+  end
+end