openstudio-standards 0.7.1 → 0.8.0.rc1

data/lib/openstudio-standards/standards/ashrae_90_1_prm/ashrae_90_1_prm.CoilDX.rb

@@ -30,7 +30,7 @@ module ASHRAEPRMCoilDX
       when 'PTHP'
         sub_category = 'PTHP'
       when 'PTAC'
-        sub_category = 'PTAC'
+        sub_category = nil
       when 'PSZ_HP'
         if capacity < 65000
           sub_category = 'Single Package'
@@ -38,7 +38,7 @@ module ASHRAEPRMCoilDX
           sub_category = 'Split-system and single package'
         end
       else
-        sub_category = 'Split-system and single package'
+        sub_category = 'Single Package'
       end
     end
 
@@ -64,7 +64,13 @@ module ASHRAEPRMCoilDX
     end
 
     if coil_dx.iddObjectType.valueName.to_s != 'OS_Coil_Heating_DX_SingleSpeed'
-      search_criteria['heating_type'] = 'All Other'
+      search_criteria['heating_type'] = 'Any'
+    end
+
+    if sys_type == 'PTAC'
+      search_criteria['equipment_type'] = sys_type
+    elsif sys_type == 'PSZ_AC'
+      search_criteria['equipment_type'] = 'Air Conditioners'
     end
 
     return search_criteria

data/lib/openstudio-standards/standards/ashrae_90_1_prm/ashrae_90_1_prm.Fan.rb

@@ -3,7 +3,7 @@
 module ASHRAE901PRMFan
   # Determines the minimum fan motor efficiency and nominal size for a given motor bhp.
   # This should be the total brake horsepower with any desired safety factor already included.
-  # This method picks the next nominal motor catgory larger than the required brake horsepower,
+  # This method picks the next nominal motor category larger than the required brake horsepower,
   # and the efficiency is based on that size.
   # For example, if the bhp = 6.3, the nominal size will be 7.5HP and the efficiency
   # for 90.1-2010 will be 91.7% from Table 10.8B.
@@ -15,7 +15,6 @@ module ASHRAE901PRMFan
   # @return [Array<Double>] minimum motor efficiency (0.0 to 1.0), nominal horsepower
   def fan_standard_minimum_motor_efficiency_and_size(fan, motor_bhp)
     fan_motor_eff = 0.85
-    nominal_hp = motor_bhp
 
     # Don't attempt to look up motor efficiency
     # for zero-hp fans, which may occur when there is no
@@ -26,47 +25,14 @@ module ASHRAE901PRMFan
 
     # Lookup the minimum motor efficiency
     motors = standards_data['motors']
-
-    # Assuming all fan motors are 4-pole ODP
-    search_criteria = {
-      'template' => template,
-      'number_of_poles' => 4.0,
-      'type' => 'Enclosed'
-    }
-
-    # Exception for small fans, including
-    # zone exhaust, fan coil, and fan powered terminals.
-    # In this case, use the 0.5 HP for the lookup.
-    if fan_small_fan?(fan)
-      nominal_hp = 0.5
-    else
-      motor_properties = model_find_object(motors, search_criteria, capacity = nil, date = nil, area = nil, num_floors = nil, fan_motor_bhp = motor_bhp)
-      if motor_properties.nil?
-        OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Fan', "For #{fan.name}, could not find motor properties using search criteria: #{search_criteria}, motor_bhp = #{motor_bhp} hp.")
-        return [fan_motor_eff, nominal_hp]
-      end
-
-      # If the biggest fan motor size is hit, use the highest category efficiency
-      if nominal_hp > 9998.0
-        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.Fan', "For #{fan.name}, there is no greater nominal HP.  Use the efficiency of the largest motor category.")
-        nominal_hp = motor_bhp
-      end
-
-      # Round to nearest whole HP for niceness
-      if nominal_hp >= 2
-        nominal_hp = nominal_hp.round
-      end
-    end
-
-    # Get the efficiency based on the nominal horsepower
-    motor_properties = model_find_object(motors, search_criteria, fan_motor_bhp = motor_bhp)
-
+    motor_properties = model_find_object(motors, {}, capacity = nil, date = nil, area = nil, num_floors = nil, fan_motor_bhp = motor_bhp)
     if motor_properties.nil?
-      OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Fan', "For #{fan.name}, could not find nominal motor properties using search criteria: #{search_criteria}, motor_hp = #{nominal_hp} hp.")
-      return [fan_motor_eff, nominal_hp]
+      OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Fan', "For #{fan.name}, could not find motor properties using search criteria: motor_bhp = #{motor_bhp} bhp. Use #{fan_motor_eff} as a placeholder.")
+      return [fan_motor_eff, motor_bhp.round]
     end
+
+    nominal_hp = motor_properties['maximum_capacity'].round
     fan_motor_eff = motor_properties['nominal_full_load_efficiency']
-    nominal_hp = motor_properties['maximum_capacity'].round(1)
 
     return [fan_motor_eff, nominal_hp]
   end

data/lib/openstudio-standards/standards/ashrae_90_1_prm/ashrae_90_1_prm.Model.rb

@@ -1,6 +1,12 @@
 class ASHRAE901PRM < Standard
   # @!group Model
 
+  # Returns the PRM building envelope infiltration rate at a pressure differential of 75 Pa in cfm per ft^2
+  # @return [Double] infiltration rate in cfm per ft^2 at 75 Pa
+  def prm_building_envelope_infiltration_rate
+    return 1.0
+  end
+
   # Determines which system number is used for the baseline system.
   # @param model [OpenStudio::Model::Model] OpenStudio model object
   # @param climate_zone [String] ASHRAE climate zone, e.g. 'ASHRAE 169-2013-4A'
@@ -104,36 +110,11 @@ class ASHRAE901PRM < Standard
     return fan_type
   end
 
-  # Calculate the building envelope area according to the 90.1 definition
-  #
-  # @param model [OpenStudio::Model::Model] OpenStudio model object
-  # @return [Double] Building envelope area in m2
-  def model_building_envelope_area(model)
-    # Get the space building envelope area
-    # According to the 90.1 definition, building envelope include:
-    # - "the elements of a building that separate conditioned spaces from the exterior"
-    # - "the elements of a building that separate conditioned space from unconditioned
-    #    space or that enclose semiheated spaces through which thermal energy may be
-    #    transferred to or from the exterior, to or from unconditioned spaces or to or
-    #    from conditioned spaces."
-    building_envelope_area_m2 = 0
-    model.getSpaces.each do |space|
-      building_envelope_area_m2 += OpenstudioStandards::Geometry.space_get_envelope_area(space)
-    end
-    if building_envelope_area_m2 < 0.01
-      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.Model', 'Calculated building envelope area is 0 m2, no infiltration will be added.')
-      return 0.0
-    end
-
-    return building_envelope_area_m2
-  end
-
-  # This method creates customized infiltration objects for each
-  # space and removes the SpaceType-level infiltration objects.
+  # This method creates customized infiltration objects for each space and removes the SpaceType-level infiltration objects.
   # @param model [OpenStudio::Model::Model] openstudio model
-  # @param specific_space_infiltration_rate_75_pa [Double] space infiltration rate at a pressure differential of 75 Pa
+  # @param infiltration_rate [Double] space infiltration rate at a pressure differential of 75 Pa in cfm per ft^2
   # @return [Boolean] true if successful, false if not
-  def model_apply_standard_infiltration(model, specific_space_infiltration_rate_75_pa = nil)
+  def model_apply_standard_infiltration(model, infiltration_rate: prm_building_envelope_infiltration_rate)
     # Model shouldn't use SpaceInfiltrationEffectiveLeakageArea
     # Excerpt from the EnergyPlus Input/Output reference manual:
     #     "This model is based on work by Sherman and Grimsrud (1980)
@@ -148,16 +129,15 @@ class ASHRAE901PRM < Standard
     end
 
     # Get the space building envelope area
-    building_envelope_area_m2 = model_building_envelope_area(model)
+    building_envelope_area_m2 = OpenstudioStandards::Geometry.model_get_envelope_area(model)
     prm_raise(building_envelope_area_m2 > 0.0, @sizing_run_dir, 'Calculated building envelope area is 0 m2, Please check model inputs.')
 
     # Calculate current model air leakage rate @ 75 Pa and report it
     curr_tot_infil_m3_per_s_per_envelope_area = model_current_building_envelope_infiltration_at_75pa(model, building_envelope_area_m2)
     OpenStudio.logFree(OpenStudio::Info, 'prm.log', "The model's I_75Pa is estimated to be #{curr_tot_infil_m3_per_s_per_envelope_area} m3/s per m2 of total building envelope.")
 
-    # Calculate building adjusted building envelope
-    # air infiltration following the 90.1 PRM rules
-    tot_infil_m3_per_s = model_adjusted_building_envelope_infiltration(building_envelope_area_m2, specific_space_infiltration_rate_75_pa)
+    # Calculate building adjusted building envelope air infiltration following the 90.1 PRM rules
+    tot_infil_m3_per_s = model_adjusted_building_envelope_infiltration(building_envelope_area_m2, infiltration_rate: infiltration_rate)
 
     # Find infiltration method used in the model, if any.
     #
@@ -193,7 +173,7 @@ class ASHRAE901PRM < Standard
       unless space.spaceInfiltrationDesignFlowRates.empty?
         old_infil = space.spaceInfiltrationDesignFlowRates[0]
         old_infil_method = old_infil.designFlowRateCalculationMethod.to_s
-        # Return flow per space floor area if method is inconsisten in proposed model
+        # Return flow per space floor area if method is inconsistent in proposed model
         return 'Flow/Area' if infil_method != old_infil_method && !infil_method.nil?
 
         infil_method = old_infil_method
@@ -236,7 +216,7 @@ class ASHRAE901PRM < Standard
         vel = old_infil.velocityTermCoefficient
         vel_2 = old_infil.velocitySquaredTermCoefficient
         old_infil_coeffs = [cst, temp, vel, vel_2] if !(cst.nil? && temp.nil? && vel.nil? && vel_2.nil?)
-        # Return flow per space floor area if method is inconsisten in proposed model
+        # Return flow per space floor area if method is inconsistent in proposed model
         return [0.0, 0.0, 0.224, 0.0] if infil_coeffs != old_infil_coeffs && !(infil_coeffs[0].nil? &&
                                                                                     infil_coeffs[1].nil? &&
                                                                                     infil_coeffs[2].nil? &&
@@ -246,7 +226,7 @@ class ASHRAE901PRM < Standard
       end
 
       # Infiltration at the space type level
-      if infil_coeffs == [nil, nil, nil, nil] && space.spaceType.is_initialized
+      if (infil_coeffs == [nil, nil, nil, nil]) && space.spaceType.is_initialized
         space_type = space.spaceType.get
         unless space_type.spaceInfiltrationDesignFlowRates.empty?
           old_infil = space_type.spaceInfiltrationDesignFlowRates[0]
@@ -255,7 +235,7 @@ class ASHRAE901PRM < Standard
           vel = old_infil.velocityTermCoefficient
           vel_2 = old_infil.velocitySquaredTermCoefficient
           old_infil_coeffs = [cst, temp, vel, vel_2] if !(cst.nil? && temp.nil? && vel.nil? && vel_2.nil?)
-          # Return flow per space floor area if method is inconsisten in proposed model
+          # Return flow per space floor area if method is inconsistent in proposed model
           return [0.0, 0.0, 0.224, 0.0] unless infil_coeffs != old_infil_coeffs && !(infil_coeffs[0].nil? &&
                                                                                       infil_coeffs[1].nil? &&
                                                                                       infil_coeffs[2].nil? &&
@@ -308,32 +288,22 @@ class ASHRAE901PRM < Standard
       bldg_air_leakage_rate += model_get_space_air_leakage(space)
     end
 
-    # adjust_infiltration_to_prototype_building_conditions(1) corresponds
-    # to the 0.112 shown in G3.1.1.4
+    # adjust_infiltration_to_prototype_building_conditions(1) corresponds to the 0.112 shown in G3.1.1.4
     curr_tot_infil_m3_per_s_per_envelope_area = bldg_air_leakage_rate / OpenstudioStandards::Infiltration.adjust_infiltration_to_prototype_building_conditions(1) / building_envelope_area_m2
     return curr_tot_infil_m3_per_s_per_envelope_area
   end
 
-  # This method calculates the building envelope infiltration,
-  # this approach uses the 90.1 PRM rules
+  # Determine the total building baseline infiltration rate in cfm per ft2 of the building envelope at 75 Pa per the 90.1 PRM rules.
   #
   # @param building_envelope_area_m2 [Double] Building envelope area as per 90.1 in m^2
-  # @param specific_space_infiltration_rate_75_pa [Double] Specific space infiltration rate at 75 pa
+  # @param infiltration_rate [Double] Specific space infiltration rate at 75 pa in cfm per ft2
   # @return [Double] building envelope infiltration
-  def model_adjusted_building_envelope_infiltration(building_envelope_area_m2, specific_space_infiltration_rate_75_pa = nil)
-    # Determine the total building baseline infiltration rate in cfm per ft2 of the building envelope at 75 Pa
-    if specific_space_infiltration_rate_75_pa.nil?
-      basic_infil_rate_cfm_per_ft2 = space_infiltration_rate_75_pa
-    else
-      basic_infil_rate_cfm_per_ft2 = specific_space_infiltration_rate_75_pa
-    end
-
+  def model_adjusted_building_envelope_infiltration(building_envelope_area_m2, infiltration_rate: prm_building_envelope_infiltration_rate)
     # Conversion factor
     conv_fact = OpenStudio.convert(1.0, 'm^3/s', 'ft^3/min').get / OpenStudio.convert(1.0, 'm^2', 'ft^2').get
 
     # Adjust the infiltration rate to the average pressure for the prototype buildings.
-    # adj_infil_rate_cfm_per_ft2 = 0.112 * basic_infil_rate_cfm_per_ft2
-    adj_infil_rate_cfm_per_ft2 = OpenstudioStandards::Infiltration.adjust_infiltration_to_prototype_building_conditions(basic_infil_rate_cfm_per_ft2)
+    adj_infil_rate_cfm_per_ft2 = OpenstudioStandards::Infiltration.adjust_infiltration_to_prototype_building_conditions(infiltration_rate)
     adj_infil_rate_m3_per_s_per_m2 = adj_infil_rate_cfm_per_ft2 / conv_fact
 
     # Calculate the total infiltration
@@ -342,286 +312,6 @@ class ASHRAE901PRM < Standard
     return tot_infil_m3_per_s
   end
 
-  # Apply the standard construction to each surface in the model, based on the construction type currently assigned.
-  #
-  # @param model [OpenStudio::Model::Model] OpenStudio model object
-  # @param climate_zone [String] ASHRAE climate zone, e.g. 'ASHRAE 169-2013-4A'
-  # @param wwr_building_type [String] building type used for defining window to wall ratio, e.g. 'Office > 50,000 sq ft'
-  # @param wwr_info [Hash] A map that maps each building area type to its correspondent wwr.
-  # @return [Boolean] returns true if successful, false if not
-  def model_apply_standard_constructions(model, climate_zone, wwr_building_type: nil, wwr_info: {})
-    types_to_modify = []
-
-    # Possible boundary conditions are
-    # Adiabatic
-    # Surface
-    # Outdoors
-    # Ground
-    # Foundation
-    # GroundFCfactorMethod
-    # OtherSideCoefficients
-    # OtherSideConditionsModel
-    # GroundSlabPreprocessorAverage
-    # GroundSlabPreprocessorCore
-    # GroundSlabPreprocessorPerimeter
-    # GroundBasementPreprocessorAverageWall
-    # GroundBasementPreprocessorAverageFloor
-    # GroundBasementPreprocessorUpperWall
-    # GroundBasementPreprocessorLowerWall
-
-    # Possible surface types are
-    # Floor
-    # Wall
-    # RoofCeiling
-    # FixedWindow
-    # OperableWindow
-    # Door
-    # GlassDoor
-    # OverheadDoor
-    # Skylight
-    # TubularDaylightDome
-    # TubularDaylightDiffuser
-
-    # Create an array of surface types
-    types_to_modify << ['Outdoors', 'Floor']
-    types_to_modify << ['Outdoors', 'Wall']
-    types_to_modify << ['Outdoors', 'RoofCeiling']
-    types_to_modify << ['Outdoors', 'FixedWindow']
-    types_to_modify << ['Outdoors', 'OperableWindow']
-    types_to_modify << ['Outdoors', 'Door']
-    types_to_modify << ['Outdoors', 'GlassDoor']
-    types_to_modify << ['Outdoors', 'OverheadDoor']
-    types_to_modify << ['Outdoors', 'Skylight']
-    types_to_modify << ['Surface', 'Floor']
-    types_to_modify << ['Surface', 'Wall']
-    types_to_modify << ['Surface', 'RoofCeiling']
-    types_to_modify << ['Surface', 'FixedWindow']
-    types_to_modify << ['Surface', 'OperableWindow']
-    types_to_modify << ['Surface', 'Door']
-    types_to_modify << ['Surface', 'GlassDoor']
-    types_to_modify << ['Surface', 'OverheadDoor']
-    types_to_modify << ['Ground', 'Floor']
-    types_to_modify << ['Ground', 'Wall']
-    types_to_modify << ['Foundation', 'Wall']
-    types_to_modify << ['GroundFCfactorMethod', 'Wall']
-    types_to_modify << ['OtherSideCoefficients', 'Wall']
-    types_to_modify << ['OtherSideConditionsModel', 'Wall']
-    types_to_modify << ['GroundBasementPreprocessorAverageWall', 'Wall']
-    types_to_modify << ['GroundBasementPreprocessorUpperWall', 'Wall']
-    types_to_modify << ['GroundBasementPreprocessorLowerWall', 'Wall']
-    types_to_modify << ['Foundation', 'Floor']
-    types_to_modify << ['GroundFCfactorMethod', 'Floor']
-    types_to_modify << ['OtherSideCoefficients', 'Floor']
-    types_to_modify << ['OtherSideConditionsModel', 'Floor']
-    types_to_modify << ['GroundSlabPreprocessorAverage', 'Floor']
-    types_to_modify << ['GroundSlabPreprocessorCore', 'Floor']
-    types_to_modify << ['GroundSlabPreprocessorPerimeter', 'Floor']
-
-    # Find just those surfaces
-    surfaces_to_modify = []
-    surface_category = {}
-    org_surface_boundary_conditions = {}
-    types_to_modify.each do |boundary_condition, surface_type|
-      # Surfaces
-      model.getSurfaces.sort.each do |surf|
-        next unless surf.outsideBoundaryCondition == boundary_condition
-        next unless surf.surfaceType == surface_type
-
-        # Check if surface is adjacent to an unenclosed or unconditioned space (e.g. attic or parking garage)
-        if surf.outsideBoundaryCondition == 'Surface'
-          adj_space = surf.adjacentSurface.get.space.get
-          adj_space_cond_type = space_conditioning_category(adj_space)
-          if adj_space_cond_type == 'Unconditioned'
-            # Get adjacent surface
-            adjacent_surf = surf.adjacentSurface.get
-
-            # Store original boundary condition type
-            org_surface_boundary_conditions[surf.name.to_s] = adjacent_surf
-
-            # Identify this surface as exterior
-            surface_category[surf] = 'ExteriorSurface'
-
-            # Temporary change the surface's boundary condition to 'Outdoors' so it can be assigned a baseline construction
-            surf.setOutsideBoundaryCondition('Outdoors')
-            adjacent_surf.setOutsideBoundaryCondition('Outdoors')
-          end
-        end
-
-        if boundary_condition == 'Outdoors'
-          surface_category[surf] = 'ExteriorSurface'
-        elsif ['Ground', 'Foundation', 'GroundFCfactorMethod', 'OtherSideCoefficients', 'OtherSideConditionsModel', 'GroundSlabPreprocessorAverage', 'GroundSlabPreprocessorCore', 'GroundSlabPreprocessorPerimeter', 'GroundBasementPreprocessorAverageWall', 'GroundBasementPreprocessorAverageFloor', 'GroundBasementPreprocessorUpperWall', 'GroundBasementPreprocessorLowerWall'].include?(boundary_condition)
-          surface_category[surf] = 'GroundSurface'
-        else
-          surface_category[surf] = 'NA'
-        end
-        surfaces_to_modify << surf
-      end
-
-      # SubSurfaces
-      model.getSubSurfaces.sort.each do |surf|
-        next unless surf.outsideBoundaryCondition == boundary_condition
-        next unless surf.subSurfaceType == surface_type
-
-        surface_category[surf] = 'ExteriorSubSurface'
-        surfaces_to_modify << surf
-      end
-    end
-
-    # Modify these surfaces
-    prev_created_consts = {}
-    surfaces_to_modify.sort.each do |surf|
-      # Get space conditioning
-      space = surf.space.get
-      space_cond_type = space_conditioning_category(space)
-
-      # Do not modify constructions for unconditioned spaces
-      prev_created_consts = planar_surface_apply_standard_construction(surf, climate_zone, prev_created_consts, wwr_building_type, wwr_info, surface_category[surf]) unless space_cond_type == 'Unconditioned'
-
-      # Reset boundary conditions to original if they were temporary modified
-      if org_surface_boundary_conditions.include?(surf.name.to_s)
-        surf.setAdjacentSurface(org_surface_boundary_conditions[surf.name.to_s])
-      end
-    end
-
-    # List the unique array of constructions
-    if prev_created_consts.empty?
-      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.Model', 'None of the constructions in your proposed model have both Intended Surface Type and Standards Construction Type')
-    else
-      prev_created_consts.each do |surf_type, construction|
-        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Model', "For #{surf_type.join(' ')}, applied #{construction.name}.")
-      end
-    end
-
-    return true
-  end
-
-  # Go through the default construction sets and hard-assigned constructions.
-  # Clone the existing constructions and set their intended surface type and standards construction type per the PRM.
-  # For some standards, this will involve making modifications.  For others, it will not.
-  # 90.1-2019
-  # @param model [OpenStudio::Model::Model] OpenStudio model object
-  # @return [Boolean] returns true if successful, false if not
-  def model_apply_prm_construction_types(model)
-    types_to_modify = []
-
-    # Possible boundary conditions are
-    # Adiabatic
-    # Surface
-    # Outdoors
-    # Ground
-    # Foundation
-    # GroundFCfactorMethod
-    # OtherSideCoefficients
-    # OtherSideConditionsModel
-    # GroundSlabPreprocessorAverage
-    # GroundSlabPreprocessorCore
-    # GroundSlabPreprocessorPerimeter
-    # GroundBasementPreprocessorAverageWall
-    # GroundBasementPreprocessorAverageFloor
-    # GroundBasementPreprocessorUpperWall
-    # GroundBasementPreprocessorLowerWall
-
-    # Possible surface types are
-    # AtticFloor
-    # AtticWall
-    # AtticRoof
-    # DemisingFloor
-    # DemisingWall
-    # DemisingRoof
-    # ExteriorFloor
-    # ExteriorWall
-    # ExteriorRoof
-    # ExteriorWindow
-    # ExteriorDoor
-    # GlassDoor
-    # GroundContactFloor
-    # GroundContactWall
-    # GroundContactRoof
-    # InteriorFloor
-    # InteriorWall
-    # InteriorCeiling
-    # InteriorPartition
-    # InteriorWindow
-    # InteriorDoor
-    # OverheadDoor
-    # Skylight
-    # TubularDaylightDome
-    # TubularDaylightDiffuser
-
-    # Possible standards construction types
-    # Mass
-    # SteelFramed
-    # WoodFramed
-    # IEAD
-    # View
-    # Daylight
-    # Swinging
-    # NonSwinging
-    # Heated
-    # Unheated
-    # RollUp
-    # Sliding
-    # Metal
-    # Nonmetal framing (all)
-    # Metal framing (curtainwall/storefront)
-    # Metal framing (entrance door)
-    # Metal framing (all other)
-    # Metal Building
-    # Attic and Other
-    # Glass with Curb
-    # Plastic with Curb
-    # Without Curb
-
-    # Create an array of types
-    types_to_modify << ['Outdoors', 'ExteriorWall', 'SteelFramed']
-    types_to_modify << ['Outdoors', 'ExteriorRoof', 'IEAD']
-    types_to_modify << ['Outdoors', 'ExteriorFloor', 'SteelFramed']
-    types_to_modify << ['Outdoors', 'ExteriorWindow', 'Any Vertical Glazing']
-    types_to_modify << ['Outdoors', 'GlassDoor', 'Any Vertical Glazing']
-    types_to_modify << ['Outdoors', 'ExteriorDoor', 'NonSwinging']
-    types_to_modify << ['Outdoors', 'ExteriorDoor', 'Swinging']
-    types_to_modify << ['Ground', 'GroundContactFloor', 'Unheated']
-    types_to_modify << ['Ground', 'GroundContactWall', 'Mass']
-
-    # Foundation
-    types_to_modify << ['Foundation', 'GroundContactFloor', 'Unheated']
-    types_to_modify << ['Foundation', 'GroundContactWall', 'Mass']
-
-    # F/C-Factor methods
-    types_to_modify << ['GroundFCfactorMethod', 'GroundContactFloor', 'Unheated']
-    types_to_modify << ['GroundFCfactorMethod', 'GroundContactWall', 'Mass']
-
-    # Other side coefficients
-    types_to_modify << ['OtherSideCoefficients', 'GroundContactFloor', 'Unheated']
-    types_to_modify << ['OtherSideConditionsModel', 'GroundContactFloor', 'Unheated']
-    types_to_modify << ['OtherSideCoefficients', 'GroundContactWall', 'Mass']
-    types_to_modify << ['OtherSideConditionsModel', 'GroundContactWall', 'Mass']
-
-    # Slab preprocessor
-    types_to_modify << ['GroundSlabPreprocessorAverage', 'GroundContactFloor', 'Unheated']
-    types_to_modify << ['GroundSlabPreprocessorCore', 'GroundContactFloor', 'Unheated']
-    types_to_modify << ['GroundSlabPreprocessorPerimeter', 'GroundContactFloor', 'Unheated']
-
-    # Basement preprocessor
-    types_to_modify << ['GroundBasementPreprocessorAverageWall', 'GroundContactWall', 'Mass']
-    types_to_modify << ['GroundBasementPreprocessorAverageFloor', 'GroundContactFloor', 'Unheated']
-    types_to_modify << ['GroundBasementPreprocessorUpperWall', 'GroundContactWall', 'Mass']
-    types_to_modify << ['GroundBasementPreprocessorLowerWall', 'GroundContactWall', 'Mass']
-
-    # Modify all constructions of each type
-    types_to_modify.each do |boundary_cond, surf_type, const_type|
-      constructions = OpenstudioStandards::Constructions.model_get_constructions(model, boundary_cond, surf_type)
-
-      constructions.sort.each do |const|
-        standards_info = const.standardsInformation
-        standards_info.setIntendedSurfaceType(surf_type)
-        standards_info.setStandardsConstructionType(const_type)
-      end
-    end
-
-    return true
-  end
-
   # Reduces the SRR to the values specified by the PRM. SRR reduction will be done by shrinking vertices toward the centroid.
   #
   # @param model [OpenStudio::Model::Model] OpenStudio model object
@@ -756,8 +446,7 @@ class ASHRAE901PRM < Standard
           elevator_counter_weight_of_car = elevator_weight_of_car + (0.4 * elevator_rated_load)
         end
         search_criteria = {
-          'template' => template,
-          'type' => 'Any'
+          'template' => template
         }
       end
       elevator_motor_bhp = (elevator_weight_of_car + elevator_rated_load - elevator_counter_weight_of_car) * elevator_speed_of_car / (33000 * elevator_mech_eff) # Lookup the minimum motor efficiency
@@ -1230,7 +919,7 @@ class ASHRAE901PRM < Standard
         standards_data['userdata_airloop_hvac'].each do |row|
           next unless row['name'].to_s.downcase.strip == air_loop_hvac.name.to_s.downcase.strip
 
-          if row['dcv_exception_airloop'].to_s.upcase.strip == 'TRUE'
+          if row['dcv_exception_airloop']
             dcv_airloop_user_exception = true
             break
           end
@@ -1251,7 +940,7 @@ class ASHRAE901PRM < Standard
         standards_data['userdata_thermal_zone'].each do |row|
           next unless row['name'].to_s.downcase.strip == thermal_zone.name.to_s.downcase.strip
 
-          if row['dcv_exception_thermal_zone'].to_s.upcase.strip == 'TRUE'
+          if row['dcv_exception_thermal_zone']
             dcv_zone_user_exception = true
             break
           end
@@ -2312,10 +2001,10 @@ class ASHRAE901PRM < Standard
                            'prm.log',
                            "User data in the userdata_building.csv indicate building #{building_name} is exempted from rotation. Update the run to a single orientation PRM generation.")
         # @todo need to use user data enums later.
-        run_orients_flag = user_buildings[user_building_index]['is_exempt_from_rotations'].casecmp('False') == 0
+        run_orients_flag = user_buildings[user_building_index]['is_exempt_from_rotations']
       end
     end
-    return run_orients_flag
+    run_orients_flag
   end
 
   # Function that extract the total fenestration area from a model by orientations.
@@ -3342,6 +3031,10 @@ class ASHRAE901PRM < Standard
     return heat_type_props['heat_type']
   end
 
+  def has_space_conditioning_category
+    true
+  end
+
   private
 
   # Check if the PRM process uses user data. The function returns a hash when

data/lib/openstudio-standards/standards/ashrae_90_1_prm/ashrae_90_1_prm.Space.rb

@@ -87,11 +87,10 @@ class ASHRAE901PRM < Standard
           infiltration.setFlowperSpaceFloorArea(adj_infil_flow_area.round(13)) if space.exteriorArea > 0
       end
       infiltration.setSchedule(infil_sch)
-      infiltration.setConstantTermCoefficient(infil_coefficients[0])
-      infiltration.setTemperatureTermCoefficient(infil_coefficients[1])
-      infiltration.setVelocityTermCoefficient(infil_coefficients[2])
-      infiltration.setVelocitySquaredTermCoefficient(infil_coefficients[3])
-
+      infiltration.setConstantTermCoefficient(infil_coefficients[0]) unless infil_coefficients[0].nil?
+      infiltration.setTemperatureTermCoefficient(infil_coefficients[1]) unless infil_coefficients[1].nil?
+      infiltration.setVelocityTermCoefficient(infil_coefficients[2]) unless infil_coefficients[2].nil?
+      infiltration.setVelocitySquaredTermCoefficient(infil_coefficients[3]) unless infil_coefficients[3].nil?
       infiltration.setSpace(space)
     end
 

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

@@ -17,9 +17,8 @@ class ASHRAE901PRM < Standard
   # @param set_electric_equipment [Boolean] if true, set the electric equipment density
   # @param set_gas_equipment [Boolean] if true, set the gas equipment density
   # @param set_ventilation [Boolean] if true, set the ventilation rates (per-person and per-area)
-  # @param set_infiltration [Boolean] if true, set the infiltration rates
   # @return [Boolean] returns true if successful, false if not
-  def space_type_apply_internal_loads(space_type, set_people, set_lights, set_electric_equipment, set_gas_equipment, set_ventilation, set_infiltration)
+  def space_type_apply_internal_loads(space_type, set_people, set_lights, set_electric_equipment, set_gas_equipment, set_ventilation)
     # Skip plenums
     # Check if the space type name
     # contains the word plenum.