openstudio-standards 0.2.16.rc2 → 0.2.17.rc1

data/lib/openstudio-standards/standards/Standards.SpaceType.rb

@@ -31,6 +31,30 @@ class Standard
     return space_type_properties
   end
 
+  def interior_lighting_get_prm_data(space_type)
+    standards_space_type = if space_type.is_a? String
+                             space_type
+                           elsif space_type.standardsSpaceType.is_initialized
+                             space_type.standardsSpaceType.get
+                           end
+
+    # populate search hash
+    search_criteria = {
+      'template' => template,
+      'lpd_space_type' => standards_space_type
+    }
+
+    # lookup space type properties
+    interior_lighting_properties = model_find_object(standards_data['prm_interior_lighting'], search_criteria)
+
+    if interior_lighting_properties.nil?
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.SpaceType', "Interior lighting PRM properties lookup failed: #{search_criteria}.")
+      interior_lighting_properties = {}
+    end
+
+    return interior_lighting_properties
+  end
+
   # Sets the color for the space types as shown in the SketchUp plugin using render by space type.
   #
   # @param space_type [OpenStudio::Model::SpaceType] space type object
@@ -194,8 +218,7 @@ class Standard
     lights_frac_high_bay = space_type_properties['lpd_fraction_high_bay']
     lights_frac_specialty_lighting = space_type_properties['lpd_fraction_specialty_lighting']
     lights_frac_exit_lighting = space_type_properties['lpd_fraction_exit_lighting']
-    lights_have_info = true unless lighting_per_area.zero?
-    lights_have_info = true unless lighting_per_person.zero?
+    lights_have_info = true unless lighting_per_area.zero? && lighting_per_person.zero?
 
     if set_lights && lights_have_info
 
@@ -451,6 +474,121 @@ class Standard
     end
   end
 
+  # Sets the internal loads for Appendix G PRM for 2016 and later
+  # Initially, only lighting power density will be set
+  # Possibly infiltration will also be set from here
+  #
+  # @param model [OpenStudio::Model::SpaceType] OpenStudio space type object
+  # @param model [OpenStudio::Model::Model] OpenStudio model object
+  def space_type_apply_int_loads_prm(space_type, model)
+    # Skip plenums
+    # Check if the space type name
+    # contains the word plenum.
+    if space_type.name.get.to_s.downcase.include?('plenum')
+      return false
+    end
+
+    if space_type.standardsSpaceType.is_initialized
+      if space_type.standardsSpaceType.get.downcase.include?('plenum')
+        return false
+      end
+    end
+
+    # Get the standards data
+    space_type_properties = interior_lighting_get_prm_data(space_type)
+
+    # Need to add a check, or it'll crash on space_type_properties['occupancy_per_area'].to_f below
+    if space_type_properties.nil?
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "#{space_type.name} was not found in the standards data.")
+      return false
+    end
+
+    # Lights
+    lights_have_info = false
+    lighting_per_area = space_type_properties['w/ft^2'].to_f
+    lighting_per_length = space_type_properties['w/ft'].to_f
+    lights_have_info = true unless lighting_per_area.zero? && lighting_per_length.zero?
+    multiple_lpd_value_check = false
+
+    if lighting_per_length > 0
+      if space_type.spaces.size == 1
+        # Space height
+        space = space_type.spaces[0]
+        space_volume = space.volume
+        space_area = space.floorArea
+        space_height = space_volume / space_area
+        # New lpd value
+        lighting_per_area += lighting_per_length * space_height
+      else
+        lighting_per_area_hash = {}
+        multiple_lpd_value_check = true
+        space_type.spaces.each do |space|
+          # Space height
+          space_volume = space.volume
+          space_area = space.floorArea
+          space_height = space_volume / space_area
+          # New lpd values
+          lighting_per_area_new = lighting_per_area + lighting_per_length * space_height
+          lighting_per_area_hash[space.name.to_s] = lighting_per_area_new
+        end
+      end
+    end
+
+    if lights_have_info
+      # Remove all but the first instance
+      instances = space_type.lights.sort
+      if instances.size.zero?
+        definition = OpenStudio::Model::LightsDefinition.new(space_type.model)
+        definition.setName("#{space_type.name} Lights Definition")
+        instance = OpenStudio::Model::Lights.new(definition)
+        instance.setName("#{space_type.name} Lights")
+        instance.setSpaceType(space_type)
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "#{space_type.name} had no lights, one has been created.")
+        instances << instance
+      elsif instances.size > 1
+        instances.each_with_index do |inst, i|
+          next if i.zero?
+
+          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "Removed #{inst.name} from #{space_type.name}.")
+          inst.remove
+        end
+      end
+      # Modify the definition of the instance
+      if multiple_lpd_value_check == false
+        space_type.lights.sort.each do |inst|
+          definition = inst.lightsDefinition
+          unless lighting_per_area.zero?
+            occ_sens_lpd_factor = 1.0
+            definition.setWattsperSpaceFloorArea(OpenStudio.convert(lighting_per_area.to_f * occ_sens_lpd_factor, 'W/ft^2', 'W/m^2').get)
+            OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "#{space_type.name} set LPD to #{lighting_per_area} W/ft^2.")
+          end
+        end
+      else
+        space_type.spaces.each do |space|
+          new_space_type = space_type.clone.to_SpaceType.get
+          space.setSpaceType(new_space_type)
+          lighting_per_area = lighting_per_area_hash[space.name.to_s]
+          new_space_type.lights.sort.each do |inst|
+            definition = inst.lightsDefinition
+            unless lighting_per_area.zero?
+              occ_sens_lpd_factor = 1.0
+              definition.setWattsperSpaceFloorArea(OpenStudio.convert(lighting_per_area.to_f * occ_sens_lpd_factor, 'W/ft^2', 'W/m^2').get)
+              OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "#{space_type.name} set LPD to #{lighting_per_area} W/ft^2.")
+            end
+          end
+        end
+        space_type.remove
+      end
+    end
+  end
+
+  # Modify the lighting schedules for Appendix G PRM for 2016 and later
+  #
+  # @param model [OpenStudio::Model::Model] OpenStudio model object
+  def space_type_light_sch_change(model)
+    return true
+  end
+
   # Sets the schedules for the selected internal loads to typical schedules.
   # Get the default schedule set for this space type if one exists or make
   # one if none exists. For each category that is selected, add the typical
@@ -584,7 +722,7 @@ class Standard
                         end
 
     # get climate_zone_set
-    climate_zone = model_get_building_climate_zone_and_building_type(space_type.model)['climate_zone']
+    climate_zone = model_get_building_properties(space_type.model)['climate_zone']
     climate_zone_set = model_find_climate_zone_set(space_type.model, climate_zone)
 
     # populate search hash
@@ -605,7 +743,6 @@ class Standard
       construction_properties = model_find_object(standards_data['construction_properties'], search_criteria)
     end
 
-
     return construction_properties
   end
 end

data/lib/openstudio-standards/standards/Standards.SubSurface.rb

@@ -80,7 +80,8 @@ class Standard
   # @param percent_reduction [Double] the fractional amount to reduce the area
   # @return [Bool] returns true if successful, false if not
   def sub_surface_reduce_area_by_percent_by_shrinking_toward_centroid(sub_surface, percent_reduction)
-    mult = 1 - percent_reduction
+    # if percent_reduction > 1=> percent increase instead of reduction
+    mult = percent_reduction <= 1 ? 1 - percent_reduction : percent_reduction
     scale_factor = mult**0.5
 
     # Get the centroid (Point3d)

data/lib/openstudio-standards/standards/Standards.Surface.rb

@@ -379,6 +379,70 @@ class Standard
     return roof_cent
   end
 
+  # Returns the surface and subsurface UA product
+  #
+  # @param [OpenStudio::Model::Surface] OpenStudio model surface object
+  #
+  # @retrun [Double] UA product in W/K
+  def surface_subsurface_ua(surface)
+    # Compute the surface UA product
+    if surface.outsideBoundaryCondition.to_s == 'GroundFCfactorMethod' && surface.construction.is_initialized
+      cons = surface.construction.get
+      fc_obj_type = cons.iddObjectType.valueName.to_s
+      case fc_obj_type
+        when 'OS_Construction_FfactorGroundFloor'
+          cons = surface.construction.get.to_FFactorGroundFloorConstruction.get
+          ffac = cons.fFactor
+          area = cons.area
+          peri = cons.perimeterExposed
+          ua = ffac * peri * surface.netArea / area
+        when 'OS_Construction_CfactorUndergroundWall'
+          cons = surface.construction.get.to_CFactorUndergroundWallConstruction.get
+          cfac = cons.cFactor
+          heig = cons.height
+
+          # From 90.1-2019 Section A.9.4.1: Interior vertical surfaces (SI units)
+          r_inside_film = 0.1197548
+          r_outside_film = 0.0
+
+          # EnergyPlus Engineering Manual equation 3.195
+          r_soil = 0.0607 + 0.3479 * heig
+
+          r_eff = 1 / cfac + r_soil
+          u_eff = 1 / (r_eff + r_inside_film + r_outside_film)
+
+          ua = u_eff * surface.netArea
+      end
+    else
+      ua = surface.uFactor.get * surface.netArea
+    end
+
+    surface.subSurfaces.sort.each do |subsurface|
+      if subsurface.construction.get.to_Construction.get.layers[0].to_Material.get.to_SimpleGlazing.empty?
+        # the uFactor() method does not work for complex glazing inputs
+        # For this case the U-Factor is retrieved from previous sizing run
+        u_factor = construction_calculated_fenestration_u_factor_w_frame(subsurface.construction.get)
+      else
+        # replace with direct query: u_factor = subsurface.uFactor.get
+        glass_u_factor_query = "SELECT Value
+                  FROM tabulardatawithstrings
+                  WHERE ReportName='EnvelopeSummary'
+                  AND ReportForString='Entire Facility'
+                  AND TableName='Exterior Fenestration'
+                  AND ColumnName='Glass U-Factor'
+                  AND RowName='#{subsurface.name.get.upcase}'"
+        sql = surface.model.sqlFile.get
+
+        glass_u_factor_w_per_m2_k = sql.execAndReturnFirstDouble(glass_u_factor_query)
+        u_factor = glass_u_factor_w_per_m2_k.is_initialized ? glass_u_factor_w_per_m2_k.get : 0.0
+      end
+      # u_factor = subsurface.uFactor.is_initialized ? (subsurface.uFactor.get) : (construction_calculated_fenestration_u_factor_w_frame(subsurface.construction.get))
+      ua += u_factor * subsurface.netArea
+    end
+
+    return ua
+  end
+
   # Calculate a surface's absolute azimuth
   # source: https://github.com/NREL/openstudio-extension-gem/blob/e354355054b83ffc26e3b69befa20d6baf5ef242/lib/openstudio/extension/core/os_lib_geometry.rb#L913
   #
@@ -422,4 +486,57 @@ class Standard
       return 'W'
     end
   end
+
+  # Calculate the wwr of a surface
+  #
+  # @param surface [OpenStudio::Model::Surface]
+  # @return [Float] window to wall ratio of a surface
+  def surface_get_wwr_of_a_surface(surface)
+    surface_area = surface.grossArea
+    surface_fene_area = 0.0
+    surface.subSurfaces.sort.each do |ss|
+      next unless ss.subSurfaceType == 'FixedWindow' || ss.subSurfaceType == 'OperableWindow' || ss.subSurfaceType == 'GlassDoor'
+
+      surface_fene_area += ss.netArea
+    end
+    return surface_fene_area / surface_area
+  end
+
+  # Adjust the fenestration area to the values specified by the reduction value in a surface
+  #
+  # @param surface [OpenStudio::Model:Surface] openstudio surface object
+  # @param reduction [Float] ratio of adjustments
+  # @param model [OpenStudio::Model::Model] openstudio model
+  # @return [Bool] return true if successful, false if not
+  def surface_adjust_fenestration_in_a_surface(surface, reduction, model)
+    # Subsurfaces in this surface
+    # Default case only handles reduction
+    if reduction < 1.0
+      surface.subSurfaces.sort.each do |ss|
+        next unless ss.subSurfaceType == 'FixedWindow' || ss.subSurfaceType == 'OperableWindow' || ss.subSurfaceType == 'GlassDoor'
+
+        if sub_surface_vertical_rectangle?(ss)
+          sub_surface_reduce_area_by_percent_by_raising_sill(ss, reduction)
+        else
+          sub_surface_reduce_area_by_percent_by_shrinking_toward_centroid(ss, reduction)
+        end
+      end
+    end
+    return true
+  end
+
+  # Calculate the door ratio of a surface
+  #
+  # @param surface [OpenStudio::Model::Surface]
+  # @return [Float] window to wall ratio of a surface
+  def surface_get_door_ratio_of_a_surface(surface)
+    surface_area = surface.grossArea
+    surface_door_area = 0.0
+    surface.subSurfaces.sort.each do |ss|
+      next unless ss.subSurfaceType == 'Door'
+
+      surface_door_area += ss.netArea
+    end
+    return surface_door_area / surface_area
+  end
 end

data/lib/openstudio-standards/standards/Standards.ThermalZone.rb

@@ -625,6 +625,14 @@ class Standard
     return is_fossil
   end
 
+  # for 2013 and prior, baseline fuel = proposed fuel
+  # @param themal_zone
+  # @return [string] with applicable DistrictHeating and/or DistrictCooling
+  def thermal_zone_get_zone_fuels_for_occ_and_fuel_type(zone)
+    zone_fuels = thermal_zone_fossil_or_electric_type(zone, '')
+    return zone_fuels
+  end
+
   # Determine if the thermal zone's fuel type category.
   # Options are:
   #   fossil, electric, unconditioned
@@ -1217,6 +1225,8 @@ class Standard
           end
         end
       end
+    elsif tstat.to_ThermostatSetpointSingleHeating
+      cld = false
     end
 
     return cld
@@ -1273,11 +1283,14 @@ class Standard
   end
 
   # Determines whether the zone is conditioned per 90.1, which is based on heating and cooling loads.
+  # Logic to detect indirectly-conditioned spaces cannot be implemented
+  # as part of this measure as it would need to call itself.
+  # It is implemented as part of space_conditioning_category().
+  # TODO: Add addendum db rules to 90.1-2019 for 90.1-2022 (use stable baseline value for zones designated as semiheated using proposed sizing run)
   #
   # @param thermal_zone [OpenStudio::Model::ThermalZone] thermal zone
   # @param climate_zone [String] ASHRAE climate zone, e.g. 'ASHRAE 169-2013-4A'
   # @return [String] NonResConditioned, ResConditioned, Semiheated, Unconditioned
-  # @todo add logic to detect indirectly-conditioned spaces
   def thermal_zone_conditioning_category(thermal_zone, climate_zone)
     # Get the heating load
     htg_load_btu_per_ft2 = 0.0
@@ -1296,58 +1309,48 @@ class Standard
     # Determine the heating limit based on climate zone
     # From Table 3.1 Heated Space Criteria
     htg_lim_btu_per_ft2 = 0.0
-    case climate_zone
-    when 'ASHRAE 169-2006-0A',
-        'ASHRAE 169-2006-0B',
-        'ASHRAE 169-2006-1A',
-        'ASHRAE 169-2006-1B',
-        'ASHRAE 169-2006-2A',
-        'ASHRAE 169-2006-2B',
-        'ASHRAE 169-2013-0A',
-        'ASHRAE 169-2013-0B',
-        'ASHRAE 169-2013-1A',
-        'ASHRAE 169-2013-1B',
-        'ASHRAE 169-2013-2A',
-        'ASHRAE 169-2013-2B'
+    climate_zone_code = climate_zone.split('-')[-1]
+    if ['0A', '0B', '1A', '1B', '2A', '2B'].include? climate_zone_code
       htg_lim_btu_per_ft2 = 5
-    when 'ASHRAE 169-2006-3A',
-        'ASHRAE 169-2006-3B',
-        'ASHRAE 169-2006-3C',
-        'ASHRAE 169-2013-3A',
-        'ASHRAE 169-2013-3B',
-        'ASHRAE 169-2013-3C'
+      stable_htg_lim_btu_per_ft2 = 5
+    elsif ['3A', '3B'].include? climate_zone_code
+      htg_lim_btu_per_ft2 = 9
+      stable_htg_lim_btu_per_ft2 = 10
+    elsif climate_zone_code == '3C'
+      htg_lim_btu_per_ft2 = 7
+      stable_htg_lim_btu_per_ft2 = 10
+    elsif ['4A', '4B'].include? climate_zone_code
       htg_lim_btu_per_ft2 = 10
-    when 'ASHRAE 169-2006-4A',
-        'ASHRAE 169-2006-4B',
-        'ASHRAE 169-2006-4C',
-        'ASHRAE 169-2006-5A',
-        'ASHRAE 169-2006-5B',
-        'ASHRAE 169-2006-5C',
-        'ASHRAE 169-2013-4A',
-        'ASHRAE 169-2013-4B',
-        'ASHRAE 169-2013-4C',
-        'ASHRAE 169-2013-5A',
-        'ASHRAE 169-2013-5B',
-        'ASHRAE 169-2013-5C'
-      htg_lim_btu_per_ft2 = 15
-    when 'ASHRAE 169-2006-6A',
-        'ASHRAE 169-2006-6B',
-        'ASHRAE 169-2006-7A',
-        'ASHRAE 169-2006-7B',
-        'ASHRAE 169-2013-6A',
-        'ASHRAE 169-2013-6B',
-        'ASHRAE 169-2013-7A',
-        'ASHRAE 169-2013-7B'
-      htg_lim_btu_per_ft2 = 20
-    when 'ASHRAE 169-2006-8A',
-        'ASHRAE 169-2006-8B',
-        'ASHRAE 169-2013-8A',
-        'ASHRAE 169-2013-8B'
-      htg_lim_btu_per_ft2 = 25
+      stable_htg_lim_btu_per_ft2 = 15
+    elsif climate_zone_code == '4C'
+      htg_lim_btu_per_ft2 = 8
+      stable_htg_lim_btu_per_ft2 = 15
+    elsif ['5A', '5B', '5C'].include? climate_zone_code
+      htg_lim_btu_per_ft2 = 12
+      stable_htg_lim_btu_per_ft2 = 15
+    elsif ['6A', '6B'].include? climate_zone_code
+      htg_lim_btu_per_ft2 = 14
+      stable_htg_lim_btu_per_ft2 = 20
+    elsif ['7A', '7B'].include? climate_zone_code
+      htg_lim_btu_per_ft2 = 16
+      stable_htg_lim_btu_per_ft2 = 20
+    elsif ['8A', '8B'].include? climate_zone_code
+      htg_lim_btu_per_ft2 = 19
+      stable_htg_lim_btu_per_ft2 = 25
+    end
+
+    # for older code versions use stable baseline value as primary target
+    if ['90.1-2004', '90.1-2007', '90.1-2010', '90.1-2013'].include? template
+      htg_lim_btu_per_ft2 = stable_htg_lim_btu_per_ft2
     end
 
     # Cooling limit is climate-independent
-    clg_lim_btu_per_ft2 = 5
+    case template
+    when '90.1-2016', '90.1-PRM-2019'
+      clg_lim_btu_per_ft2 = 3.4
+    else
+      clg_lim_btu_per_ft2 = 5
+    end
 
     # Semiheated limit is climate-independent
     semihtd_lim_btu_per_ft2 = 3.4
@@ -1388,6 +1391,11 @@ class Standard
   # @return [Double] the design heating supply temperature, in degrees Celsius
   # @todo Exception: 17F delta-T for labs
   def thermal_zone_prm_baseline_heating_design_supply_temperature(thermal_zone)
+    unit_heater_sup_temp = thermal_zone_prm_unitheater_design_supply_temperature(thermal_zone)
+    unless unit_heater_sup_temp.nil?
+      return unit_heater_sup_temp
+    end
+
     setpoint_c = nil
 
     # Setpoint schedule
@@ -1431,6 +1439,12 @@ class Standard
 
     # Add 20F delta-T
     delta_t_r = 20
+
+    new_delta_t = thermal_zone_prm_lab_delta_t(thermal_zone)
+    unless new_delta_t.nil?
+      delta_t_r = new_delta_t
+    end
+
     delta_t_k = OpenStudio.convert(delta_t_r, 'R', 'K').get
 
     sat_c = setpoint_c + delta_t_k # Add for heating
@@ -1488,6 +1502,16 @@ class Standard
 
     # Subtract 20F delta-T
     delta_t_r = 20
+    if /prm/i =~ template # avoid affecting previous PRM tests
+      # For labs, substract 17 delta-T; otherwise, substract 20 delta-T
+      thermal_zone.spaces.each do |space|
+        space_std_type = space.spaceType.get.standardsSpaceType.get
+        if space_std_type == 'laboratory'
+          delta_t_r = 17
+        end
+      end
+    end
+
     delta_t_k = OpenStudio.convert(delta_t_r, 'R', 'K').get
 
     sat_c = setpoint_c - delta_t_k # Subtract for cooling
@@ -1572,6 +1596,93 @@ class Standard
     return load_w
   end
 
+  # Determine the peak internal load (W) for
+  # this zone without space multipliers.
+  # This includes People, Lights, and all equipment types
+  # in all spaces in this zone.
+  # @author Doug Maddox, PNNL
+  # @return [Double] the design internal load, in W
+  def thermal_zone_peak_internal_load(model, thermal_zone, use_noncoincident_value: true)
+    load_w = 0.0
+    load_hrs_sum = Array.new(8760, 0)
+
+    if !use_noncoincident_value
+      # Get array of coincident internal gain
+      thermal_zone.spaces.each do |space|
+        load_hrs = space_internal_load_annual_array(model, space, use_noncoincident_value)
+        (0..8759).each do |ihr|
+          load_hrs_sum[ihr] += load_hrs[ihr]
+        end
+      end
+      load_w = load_hrs_sum.max
+    else
+      # Get the non-coincident sum of peak internal gains
+      thermal_zone.spaces.each do |space|
+        load_w += space_internal_load_annual_array(model, space, use_noncoincident_value)
+      end
+    end
+
+    return load_w
+  end
+
+  # This is the operating hours for calulating EFLH which is used for determining whether a zone
+  # should be included in a multizone system or isolated to a separate PSZ system
+  # Based on the occupancy schedule for that zone
+  # @author Doug Maddox, PNNL
+  # @return [Array] 8760 array with 1 = operating, 0 = not operating
+  def thermal_zone_get_annual_operating_hours(model, zone, zone_fan_sched)
+    zone_ppl_sch = Array.new(8760, 0)     # merged people schedule for zone
+    zone_op_sch = Array.new(8760, 0)      # intersection of fan and people scheds
+
+    unoccupied_threshold = air_loop_hvac_unoccupied_threshold
+    # Need composite occupant schedule for spaces in the zone
+    zone.spaces.each do |space|
+      space_ppl_sch = space_occupancy_annual_array(model, space)
+      # If any space is occupied, make zone occupied
+      (0..8759).each do |ihr|
+        zone_ppl_sch[ihr] = 1 if space_ppl_sch[ihr] > 0
+      end
+    end
+
+    zone_op_sch = zone_ppl_sch
+
+    return zone_op_sch
+  end
+
+  # This is the EFLH for determining whether a zone should be included in a multizone system
+  # or isolated to a separate PSZ system
+  # Based on the intersection of the fan schedule for that zone and the occupancy schedule for that zone
+  # @author Doug Maddox, PNNL
+  # @return [Double] the design internal load, in W
+  def thermal_zone_occupancy_eflh(zone, zone_op_sch)
+    eflhs = [] # weekly array of eflh values
+
+    # Convert 8760 array to weekly eflh values
+    hr_of_yr = -1
+    (0..51).each do |iweek|
+      eflh = 0
+      (0..6).each do |iday|
+        (0..23).each do |ihr|
+          hr_of_yr += 1
+          eflh += zone_op_sch[hr_of_yr]
+        end
+      end
+      eflhs << eflh
+    end
+
+    # Choose the most used weekly schedule as the representative eflh
+    # This is the statistical mode of the array of values
+    eflh_mode_list = eflhs.mode
+
+    if eflh_mode_list.size > 1
+      # Mode is an array of multiple values, take the largest value
+      eflh = eflh_mode_list.max
+    else
+      eflh = eflh_mode_list[0]
+    end
+    return eflh
+  end
+
   # Returns the space type that represents a majority of the floor area.
   #
   # @param thermal_zone [OpenStudio::Model::ThermalZone] thermal zone
@@ -1889,7 +2000,6 @@ class Standard
   # @return [Bool] returns true if successful, false if not
   # @todo this method is currently empty
   def thermal_zone_add_exhaust_fan_dcv(thermal_zone, change_related_objects = true, zone_mixing_objects = [], transfer_air_source_zones = [])
-
     # set flow fraction schedule for all zone exhaust fans and then set zone mixing schedule to the intersection of exhaust availability and exhaust fractional schedule
 
     # are there associated zone mixing or dummy exhaust objects that need to change when this changes?
@@ -1897,4 +2007,42 @@ class Standard
     # If this is run directly after thermal_zone_add_exhaust(thermal_zone)  it will return a hash where each key is an exhaust object and hash is a hash of related zone mixing and dummy exhaust from the source zone
     return true
   end
+
+  # Specify supply air temperature setpoint for unit heaters based on 90.1 Appendix G G3.1.2.8.2 (implementation in PRM subclass)
+  def thermal_zone_prm_unitheater_design_supply_temperature(thermal_zone)
+    return nil
+  end
+
+  # Specify supply to room delta for laboratory spaces based on 90.1 Appendix G Exception to G3.1.2.8.1 (implementation in PRM subclass)
+  def thermal_zone_prm_lab_delta_t(thermal_zone)
+    return nil
+  end
+
+  # Determine the number of unmet load hours during occupancy for a thermal zone
+  #
+  # @param thermal_zone [OpenStudio::Model::ThermalZone] OpenStudio ThermalZone object
+  # @param umlh_type [String] Type of unmet load hours, either 'Cooling' or 'Heating'
+  def thermal_zone_get_unmet_load_hours(thermal_zone, umlh_type)
+    umlh = OpenStudio::OptionalDouble.new
+    sql = thermal_zone.model.sqlFile
+    if sql.is_initialized
+      sql = sql.get
+      query = "SELECT Value
+              FROM tabulardatawithstrings
+              WHERE ReportName='SystemSummary'
+              AND ReportForString='Entire Facility'
+              AND TableName='Time Setpoint Not Met'
+              AND ColumnName='During Occupied #{umlh_type.capitalize}'
+              AND RowName='#{thermal_zone.name.to_s.upcase}'
+              AND Units='hr'"
+      val = sql.execAndReturnFirstDouble(query)
+      if val.is_initialized
+        umlh = OpenStudio::OptionalDouble.new(val.get)
+      end
+    else
+      OpenStudio.logFree(OpenStudio::Error, 'openstudio.model.Model', 'Model has no sql file containing results, cannot lookup data.')
+    end
+
+    return umlh.to_f
+  end
 end

data/lib/openstudio-standards/standards/Standards.ZoneHVACComponent.rb

@@ -86,6 +86,47 @@ class Standard
     return true
   end
 
+  # Get the supply fan object for a zone equipment component
+  # @author Doug Maddox, PNNL
+  # @param zone_hvac_component [object]
+  # @return [object] supply fan of zone equipment component
+  def zone_hvac_get_fan_object(zone_hvac_component)
+    zone_hvac = nil
+    # Check for any zone equipment type that has a supply fan
+    # except EnergyRecoveryVentilator, which is not a primary conditioning system
+    zone_hvac = if zone_hvac_component.to_ZoneHVACFourPipeFanCoil.is_initialized
+                  zone_hvac_component.to_ZoneHVACFourPipeFanCoil.get
+                elsif zone_hvac_component.to_ZoneHVACPackagedTerminalAirConditioner.is_initialized
+                  zone_hvac_component.to_ZoneHVACPackagedTerminalAirConditioner.get
+                elsif zone_hvac_component.to_ZoneHVACPackagedTerminalHeatPump.is_initialized
+                  zone_hvac_component.to_ZoneHVACPackagedTerminalHeatPump.get
+                elsif zone_hvac_component.to_ZoneHVACTerminalUnitVariableRefrigerantFlow.is_initialized
+                  zone_hvac_component.to_ZoneHVACTerminalUnitVariableRefrigerantFlow.get
+                elsif zone_hvac_component.to_ZoneHVACUnitHeater.is_initialized
+                  zone_hvac_component.to_ZoneHVACUnitHeater.get
+                elsif zone_hvac_component.to_ZoneHVACUnitVentilator.is_initialized
+                  zone_hvac_component.to_ZoneHVACUnitVentilator.get
+                elsif zone_hvac_component.to_ZoneHVACWaterToAirHeatPump.is_initialized
+                  zone_hvac_component.to_ZoneHVACWaterToAirHeatPump.get
+                end
+
+    # Get the fan
+    if !zone_hvac.nil?
+      fan_obj = if zone_hvac.supplyAirFan.to_FanConstantVolume.is_initialized
+                  zone_hvac.supplyAirFan.to_FanConstantVolume.get
+                elsif zone_hvac.supplyAirFan.to_FanVariableVolume.is_initialized
+                  zone_hvac.supplyAirFan.to_FanVariableVolume.get
+                elsif zone_hvac.supplyAirFan.to_FanOnOff.is_initialized
+                  zone_hvac.supplyAirFan.to_FanOnOff.get
+                elsif zone_hvac.supplyAirFan.to_FanSystemModel.is_initialized
+                  zone_hvac.supplyAirFan.to_FanSystemModel.get
+                end
+      return fan_obj
+    else
+      return nil
+    end
+  end
+
   # Default occupancy fraction threshold for determining if the spaces served by the zone hvac are occupied
   #
   # @return [Double] unoccupied threshold