openstudio-standards 0.2.16 → 0.2.17.rc1

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

@@ -0,0 +1,194 @@
+class ASHRAE901PRM < Standard
+  # @!group CoilHeatingDXSingleSpeed
+
+  include ASHRAEPRMCoilDX
+
+  # Finds capacity in W. This is the cooling capacity of the paired DX cooling coil.
+  #
+  # @param coil_heating_dx_single_speed [OpenStudio::Model::CoilHeatingDXSingleSpeed] coil heating dx single speed object
+  # @param sys_type [String] HVAC system type
+  # @return [Double] capacity in W to be used for find object
+  def coil_heating_dx_single_speed_find_capacity(coil_heating_dx_single_speed, sys_type)
+    capacity_w = nil
+
+    # Get the paired cooling coil
+    clg_coil = nil
+
+    # Unitary and zone equipment
+    if coil_heating_dx_single_speed.airLoopHVAC.empty?
+      if coil_heating_dx_single_speed.containingHVACComponent.is_initialized
+        containing_comp = coil_heating_dx_single_speed.containingHVACComponent.get
+        if containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAir.is_initialized
+          clg_coil = containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAir.get.coolingCoil
+        elsif containing_comp.to_AirLoopHVACUnitarySystem.is_initialized
+          unitary = containing_comp.to_AirLoopHVACUnitarySystem.get
+          if unitary.coolingCoil.is_initialized
+            clg_coil = unitary.coolingCoil.get
+          end
+        end
+      elsif coil_heating_dx_single_speed.containingZoneHVACComponent.is_initialized
+        containing_comp = coil_heating_dx_single_speed.containingZoneHVACComponent.get
+        # PTHP
+        if containing_comp.to_ZoneHVACPackagedTerminalHeatPump.is_initialized
+          pthp = containing_comp.to_ZoneHVACPackagedTerminalHeatPump.get
+          clg_coil = containing_comp.to_ZoneHVACPackagedTerminalHeatPump.get.coolingCoil
+        end
+      end
+    end
+
+    # On AirLoop directly
+    if coil_heating_dx_single_speed.airLoopHVAC.is_initialized
+      air_loop = coil_heating_dx_single_speed.airLoopHVAC.get
+      # Check for the presence of any other type of cooling coil
+      clg_types = ['OS:Coil:Cooling:DX:SingleSpeed',
+                   'OS:Coil:Cooling:DX:TwoSpeed']
+      clg_types.each do |ct|
+        coils = air_loop.supplyComponents(ct.to_IddObjectType)
+        next if coils.empty?
+
+        clg_coil = coils[0]
+        break # Stop on first DX cooling coil found
+      end
+    end
+
+    # If no paired cooling coil was found, throw an error and fall back to the heating capacity of the DX heating coil
+    if clg_coil.nil?
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{coil_heating_dx_single_speed.name}, the paired DX cooling coil could not be found to determine capacity. Efficiency will incorrectly be based on DX coil's heating capacity.")
+      if coil_heating_dx_single_speed.ratedTotalHeatingCapacity.is_initialized
+        capacity_w = coil_heating_dx_single_speed.ratedTotalHeatingCapacity.get
+      elsif coil_heating_dx_single_speed.autosizedRatedTotalHeatingCapacity.is_initialized
+        capacity_w = coil_heating_dx_single_speed.autosizedRatedTotalHeatingCapacity.get
+      else
+        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{coil_heating_dx_single_speed.name} capacity is not available, cannot apply efficiency standard to paired DX heating coil.")
+        return 0.0
+      end
+      return capacity_w
+    end
+
+    # If a coil was found, cast to the correct type
+    if clg_coil.to_CoilCoolingDXSingleSpeed.is_initialized
+      clg_coil = clg_coil.to_CoilCoolingDXSingleSpeed.get
+      capacity_w = coil_cooling_dx_single_speed_find_capacity(clg_coil, sys_type)
+    elsif clg_coil.to_CoilCoolingDXTwoSpeed.is_initialized
+      clg_coil = clg_coil.to_CoilCoolingDXTwoSpeed.get
+      capacity_w = coil_cooling_dx_two_speed_find_capacity(clg_coil, sys_type)
+    end
+
+    # Check for user data that indicates multiple systems per thermal zone
+    # This could be true for a data center where this is common practice
+    # Or it could be for a thermal zone that represents multiple real building zones
+    mult = 1
+    thermal_zone = nil
+    comp = coil_heating_dx_single_speed.containingHVACComponent
+    if comp.is_initialized
+      if comp.get.to_AirLoopHVACUnitarySystem.is_initialized
+        unitary = comp.get.to_AirLoopHVACUnitarySystem.get
+        thermal_zone = unitary.controllingZoneorThermostatLocation.get
+      end
+    end
+    # meth = comp.methods
+    comp = coil_heating_dx_single_speed.containingZoneHVACComponent
+    if comp.is_initialized
+      if comp.get.thermalZone.is_initialized
+        thermal_zone = comp.get.thermalZone.get
+      end
+    end
+
+    if !thermal_zone.nil?
+      if standards_data.key?('userdata_thermal_zone')
+        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['number_of_systems'].to_s.upcase.strip != ''
+            mult = row['number_of_systems'].to_s
+            if mult.to_i.to_s == mult
+              mult = mult.to_i
+              capacity_w /= mult
+            else
+              OpenStudio.logFree(OpenStudio::Error, 'prm.log', 'In userdata_thermalzone, number_of_systems requires integer input.')
+            end
+            break
+          end
+        end
+      end
+    end
+
+    # If it's a PTAC or PTHP System, we need to divide the capacity by the potential zone multiplier
+    # because the COP is dependent on capacity, and the capacity should be the capacity of a single zone, not all the zones
+    if sys_type == 'PTHP'
+      mult = 1
+      comp = coil_heating_dx_single_speed.containingZoneHVACComponent
+      if comp.is_initialized
+        if comp.get.thermalZone.is_initialized
+          mult = comp.get.thermalZone.get.multiplier
+          if mult > 1
+            total_cap = capacity_w
+            capacity_w /= mult
+            OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{coil_heating_dx_single_speed.name}, total capacity of #{OpenStudio.convert(total_cap, 'W', 'kBtu/hr').get.round(2)}kBTU/hr was divided by the zone multiplier of #{mult} to give #{capacity_kbtu_per_hr = OpenStudio.convert(capacity_w, 'W', 'kBtu/hr').get.round(2)}kBTU/hr.")
+          end
+        end
+      end
+    end
+
+    return capacity_w
+  end
+
+  # Finds lookup object in standards and return efficiency
+  #
+  # @param coil_heating_dx_single_speed [OpenStudio::Model::CoilHeatingDXSingleSpeed] coil heating dx single speed object
+  # @param sys_type [String] HVAC system type
+  # @param rename [Bool] if true, object will be renamed to include capacity and efficiency level
+  # @return [Double] full load efficiency (COP)
+  def coil_heating_dx_single_speed_standard_minimum_cop(coil_heating_dx_single_speed, sys_type, rename = false)
+    # find ac properties
+    capacity_w = coil_heating_dx_single_speed_find_capacity(coil_heating_dx_single_speed, sys_type)
+    capacity_btu_per_hr = OpenStudio.convert(capacity_w, 'W', 'Btu/hr').get
+    search_criteria = coil_dx_find_search_criteria(coil_heating_dx_single_speed, capacity_btu_per_hr, sys_type)
+
+    # find object
+    ac_props = nil
+    ac_props = model_find_object(standards_data['heat_pumps_heating'], search_criteria, capacity_btu_per_hr, Date.today)
+    # Get the minimum efficiency standards
+    cop = nil
+
+    # Check to make sure properties were found
+    if ac_props.nil?
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{coil_heating_dx_single_speed.name}, cannot find efficiency info using #{search_criteria}, cannot apply efficiency standard.")
+      return cop # value of nil
+    end
+
+    cop = ac_props['copnfcooling']
+    new_comp_name = "#{coil_heating_dx_single_speed.name} #{capacity_btu_per_hr.round}Btu/hr #{cop}COP"
+
+    # Rename
+    if rename
+      coil_heating_dx_single_speed.setName(new_comp_name)
+    end
+
+    return cop
+  end
+
+  # Applies the standard efficiency ratings and typical performance curves to this object.
+  #
+  # @param coil_heating_dx_single_speed [OpenStudio::Model::CoilHeatingDXSingleSpeed] coil heating dx single speed object
+  # @param sql_db_vars_map [Hash] hash map
+  # @param sys_type [String] HVAC system type
+  # @return [Hash] hash of coil objects
+  def coil_heating_dx_single_speed_apply_efficiency_and_curves(coil_heating_dx_single_speed, sql_db_vars_map, sys_type)
+    # Preserve the original name
+    orig_name = coil_heating_dx_single_speed.name.to_s
+
+    # Find the minimum COP and rename with efficiency rating
+    cop = coil_heating_dx_single_speed_standard_minimum_cop(coil_heating_dx_single_speed, sys_type, false)
+
+    # Map the original name to the new name
+    sql_db_vars_map[coil_heating_dx_single_speed.name.to_s] = orig_name
+
+    # Set the efficiency values
+    unless cop.nil?
+      coil_heating_dx_single_speed.setRatedCOP(cop)
+    end
+
+    return sql_db_vars_map
+  end
+end

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

@@ -0,0 +1,120 @@
+class ASHRAE901PRM < Standard
+  # @!group BoilerHotWater
+
+  # find search criteria
+  #
+  # @param coil_heating_gas [OpenStudio::Model::CoilHeatingGas] coil heating gas object
+  # @param sys_type [String] HVAC system type
+  # @return [Hash] used for standards_lookup_table(model)
+  def coil_heating_gas_find_search_criteria(coil_heating_gas, sys_type)
+    # Define the criteria to find the furnace properties
+    # in the hvac standards data set.
+    search_criteria = {}
+    search_criteria['fuel_type'] = 'Gas'
+    if sys_type == 'PSZ_AC'
+      search_criteria['subcategory'] = 'Furnace'
+    elsif sys_type == 'Gas_Furnace'
+      search_criteria['subcategory'] = 'Unit Heater'
+    else
+      search_criteria['subcategory'] = 'Furnace'
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingGas', "#{coil_heating_gas.name} is not for a PSZ-AC or Gas Furnace and cannot apply efficiency standard.")
+    end
+
+    return search_criteria
+  end
+
+  # find furnace capacity
+  #
+  # @param coil_heating_gas [OpenStudio::Model::CoilHeatingGas] coil heating gas object
+  # @return [Double] capacity in W to be used for find object
+  def coil_heating_gas_find_capacity(coil_heating_gas)
+    # Get the coil capacity
+    capacity_w = nil
+    if coil_heating_gas.nominalCapacity.is_initialized
+      capacity_w = coil_heating_gas.nominalCapacity.get
+    elsif coil_heating_gas.autosizedNominalCapacity.is_initialized
+      capacity_w = coil_heating_gas.autosizedNominalCapacity.get
+    else
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingGas', "For #{coil_heating_gas.name} capacity is not available, cannot apply efficiency standard.")
+      successfully_set_all_properties = false
+      return successfully_set_all_properties
+    end
+
+    return capacity_w
+  end
+
+  # Finds lookup object in standards and return minimum thermal efficiency
+  #
+  # @param coil_heating_gas [OpenStudio::Model::CoilHeatingGas] coil heating gas object
+  # @param sys_type [String] HVAC system type
+  # @param rename [Bool] if true, object will be renamed to include capacity and efficiency level
+  # @return [Double] minimum thermal efficiency
+  def coil_heating_gas_standard_minimum_thermal_efficiency(coil_heating_gas, sys_type, rename = false)
+    # Get the coil properties
+    search_criteria = coil_heating_gas_find_search_criteria(coil_heating_gas, sys_type)
+    capacity_w = coil_heating_gas_find_capacity(coil_heating_gas)
+    capacity_btu_per_hr = OpenStudio.convert(capacity_w, 'W', 'Btu/hr').get
+    capacity_kbtu_per_hr = OpenStudio.convert(capacity_w, 'W', 'kBtu/hr').get
+
+    # Get the minimum efficiency standards
+    thermal_eff = nil
+
+    # Get the coil properties
+    coil_table = @standards_data['furnaces']
+    coil_props = model_find_object(coil_table, search_criteria, [capacity_btu_per_hr, 0.001].max)
+
+    # Check to make sure properties were found
+    if coil_props.nil?
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingGas', "For #{coil_heating_gas.name}, cannot find efficiency info using #{search_criteria}, cannot apply efficiency standard.")
+      successfully_set_all_properties = false
+      return successfully_set_all_properties
+    end
+
+    # New name initial value
+    new_comp_name = coil_heating_gas.name
+
+    # If specified as thermal efficiency
+    unless coil_props['minimum_thermal_efficiency'].nil?
+      thermal_eff = coil_props['minimum_thermal_efficiency']
+      new_comp_name = "#{coil_heating_gas.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{thermal_eff} Thermal Eff"
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilHeatingGas', "For #{template}: #{coil_heating_gas.name}: Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; Thermal Efficiency = #{thermal_eff}")
+    end
+
+    # If specified as combustion efficiency
+    unless coil_props['minimum_combustion_efficiency'].nil?
+      min_comb_eff = coil_props['minimum_combustion_efficiency']
+      thermal_eff = combustion_eff_to_thermal_eff(min_comb_eff)
+      new_comp_name = "#{coil_heating_gas.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_comb_eff} Combustion Eff"
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilHeatingGas', "For #{template}: #{coil_heating_gas.name}: Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; Combustion Efficiency = #{min_comb_eff}")
+    end
+
+    unless thermal_eff
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingGas', "For #{CoilHeatingGas.name}, cannot find coil efficiency, cannot apply efficiency standard.")
+      successfully_set_all_properties = false
+      return successfully_set_all_properties
+    end
+
+    # Rename
+    if rename
+      coil_heating_gas.setName(new_comp_name)
+    end
+
+    return thermal_eff
+  end
+
+  # Applies the standard efficiency ratings and typical performance curves to this object.
+  #
+  # @param coil_heating_gas [OpenStudio::Model::CoilHeatingGas] coil heating gas object
+  # @param sql_db_vars_map [Hash] hash map
+  # @param sys_type [String] HVAC system type
+  # @return [Hash] hash of coil objects
+  def coil_heating_gas_apply_efficiency_and_curves(coil_heating_gas, sql_db_vars_map, sys_type)
+    # Thermal efficiency
+    thermal_eff = coil_heating_gas_standard_minimum_thermal_efficiency(coil_heating_gas, sys_type)
+
+    # Set the efficiency values
+    coil_heating_gas.setGasBurnerEfficiency(thermal_eff.to_f)
+
+    return sql_db_vars_map
+  end
+end

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

@@ -0,0 +1,110 @@
+# A variety of cooling tower methods that are the same regardless of type.
+# These methods are available to CoolingTowerSingleSpeed, CoolingTowerTwoSpeed, and CoolingTowerVariableSpeed
+module ASHRAEPRMCoolingTower
+  # @!group CoolingTower
+
+  # Set the cooling tower fan power such that the tower
+  # hits the minimum performance (gpm/hp) specified by the standard.
+  # Note that in this case hp is motor nameplate hp, per 90.1.
+  # This method assumes that the fan brake horsepower is 90%
+  # of the motor nameplate hp.
+  # This method determines the minimum motor efficiency
+  # for the nameplate motor hp and sets the actual
+  # fan power by multiplying the brake horsepower
+  # by the efficiency.  Thus the fan power used as
+  # an input to the simulation divided by the design flow
+  # rate will not (and should not)
+  # exactly equal the minimum tower performance.
+  #
+  # @param cooling_tower [OpenStudio::Model::StraightComponent] cooling tower object, allowable types:
+  #   CoolingTowerSingleSpeed, CoolingTowerTwoSpeed, and CoolingTowerVariableSpeed
+  # @return [Bool] returns true if successful, false if not
+  def cooling_tower_apply_minimum_power_per_flow(cooling_tower)
+    # Get the design water flow rate
+    design_water_flow_m3_per_s = nil
+    if cooling_tower.designWaterFlowRate.is_initialized
+      design_water_flow_m3_per_s = cooling_tower.designWaterFlowRate.get
+    elsif cooling_tower.autosizedDesignWaterFlowRate.is_initialized
+      design_water_flow_m3_per_s = cooling_tower.autosizedDesignWaterFlowRate.get
+    else
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoolingTower', "For #{cooling_tower.name} design water flow rate is not available, cannot apply efficiency standard.")
+      return false
+    end
+    design_water_flow_gpm = OpenStudio.convert(design_water_flow_m3_per_s, 'm^3/s', 'gal/min').get
+
+    # Get the table of cooling tower efficiencies
+    heat_rejection = standards_data['heat_rejection']
+
+    # Define the criteria to find the cooling tower properties
+    # in the hvac standards data set.
+    search_criteria = {}
+    search_criteria['template'] = template
+
+    # By definition cooling towers in E+ are open.
+    # Closed cooling towers are the fluidcooler objects.
+    search_criteria['equipment_type'] = 'Open Cooling Tower'
+
+    # Define the criteria to find the fan type
+    search_criteria['fan_type'] = 'Axial'
+
+    # Get the cooling tower properties
+    ct_props = model_find_object(heat_rejection, search_criteria)
+    unless ct_props
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoolingTower', "For #{cooling_tower.name}, cannot find heat rejection properties, cannot apply standard efficiencies or curves.")
+      return false
+    end
+
+    # Get cooling tower efficiency
+    min_gpm_per_hp = ct_props['minimum_performance']
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoolingTower', "For #{cooling_tower.name}, design water flow = #{design_water_flow_gpm.round} gpm, minimum performance = #{min_gpm_per_hp} gpm/hp (nameplate).")
+
+    # Calculate the allowed fan brake horsepower
+    # per method used in PNNL prototype buildings.
+    # Assumes that the fan brake horsepower is 90%
+    # of the fan nameplate rated motor power.
+    fan_motor_nameplate_hp = design_water_flow_gpm / min_gpm_per_hp
+    fan_bhp = 0.9 * fan_motor_nameplate_hp
+
+    # Lookup the minimum motor efficiency
+    fan_motor_eff = 0.85
+    motors = standards_data['motors']
+
+    # Assuming all fan motors are 4-pole Enclosed
+    search_criteria = {
+      'template' => template,
+      'number_of_poles' => 'Any',
+      'type' => 'Any'
+    }
+
+    motor_properties = model_find_object(motors, search_criteria, fan_motor_nameplate_hp)
+    if motor_properties.nil?
+      OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.CoolingTower', "For #{cooling_tower.name}, could not find motor properties using search criteria: #{search_criteria}, motor_hp = #{fan_motor_nameplate_hp} hp.")
+      return false
+    end
+
+    fan_motor_eff = motor_properties['nominal_full_load_efficiency']
+    nominal_hp = motor_properties['maximum_capacity'].to_f.round(1)
+    # Round to nearest whole HP for niceness
+    if nominal_hp >= 2
+      nominal_hp = nominal_hp.round
+    end
+
+    # Calculate the fan motor power
+    fan_motor_actual_power_hp = fan_bhp / fan_motor_eff
+    # Convert to W
+    fan_motor_actual_power_w = fan_motor_actual_power_hp * 745.7 # 745.7 W/HP
+
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoolingTower', "For #{cooling_tower.name}, allowed fan motor nameplate hp = #{fan_motor_nameplate_hp.round(1)} hp, fan brake horsepower = #{fan_bhp.round(1)}, and fan motor actual power = #{fan_motor_actual_power_hp.round(1)} hp (#{fan_motor_actual_power_w.round} W) at #{fan_motor_eff} motor efficiency.")
+
+    # Append the efficiency to the name
+    cooling_tower.setName("#{cooling_tower.name} #{min_gpm_per_hp.round(1)} gpm/hp")
+
+    # Hard size the design fan power.
+    # Leave the water flow and air flow autosized.
+    if cooling_tower.to_CoolingTowerVariableSpeed.is_initialized
+      cooling_tower.setDesignFanPower(fan_motor_actual_power_w)
+    end
+
+    return true
+  end
+end

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

@@ -0,0 +1,5 @@
+class ASHRAE901PRM < Standard
+  # @!group CoolingTowerVariableSpeed
+
+  include ASHRAEPRMCoolingTower
+end

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

@@ -0,0 +1,73 @@
+# A variety of fan calculation methods that are the same regardless of fan type.
+# These methods are available to FanConstantVolume, FanOnOff, FanVariableVolume, and FanZoneExhaust
+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,
+  # 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.
+  # This method assumes 4-pole, 1800rpm totally-enclosed fan-cooled motors.
+  #
+  # @param fan [OpenStudio::Model::StraightComponent] fan object, allowable types:
+  #   FanConstantVolume, FanOnOff, FanVariableVolume, and FanZoneExhaust
+  # @param motor_bhp [Double] motor brake horsepower (hp)
+  # @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
+    # airflow required for a particular system, typically
+    # heated-only spaces with high internal gains
+    # and no OA requirements such as elevator shafts.
+    return [fan_motor_eff, 0] if motor_bhp == 0.0
+
+    # 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 == 9999.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)
+
+    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]
+    end
+    fan_motor_eff = motor_properties['nominal_full_load_efficiency']
+    nominal_hp = motor_properties['maximum_capacity'].round(1)
+
+    return [fan_motor_eff, nominal_hp]
+  end
+end

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

@@ -0,0 +1,5 @@
+class ASHRAE901PRM
+  # @!group FanConstantVolume
+
+  include ASHRAE901PRMFan
+  end

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

@@ -0,0 +1,5 @@
+class ASHRAE901PRM
+  # @!group FanOnOff
+
+  include ASHRAE901PRMFan
+  end

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

@@ -0,0 +1,24 @@
+class ASHRAE901PRM
+  # @!group FanVariableVolume
+
+  include ASHRAE901PRMFan
+
+  # Determines whether there is a requirement to have a VSD or some other method to reduce fan power at low part load ratios.
+  # Required for all VAV fans for stable baseline
+  # @param fan_variable_volume [OpenStudio::Model::FanVariableVolume] variable volume fan object
+  # @return [Bool] returns true if required, false if not
+  def fan_variable_volume_part_load_fan_power_limitation?(fan_variable_volume)
+    part_load_control_required = true
+    return part_load_control_required
+  end
+
+  # The threhold horsepower below which part load control is not required.
+  # always required for stable baseline, so threshold is zero
+  #
+  # @param fan_variable_volume [OpenStudio::Model::FanVariableVolume] variable volume fan object
+  # @return [Double] the limit, in horsepower. Return zero for no limit by default.
+  def fan_variable_volume_part_load_fan_power_limitation_hp_limit(fan_variable_volume)
+    hp_limit = 0
+    return hp_limit
+  end
+end

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

@@ -0,0 +1,5 @@
+class ASHRAE901PRM
+  # @!group FanZoneExhaust
+
+  include ASHRAE901PRMFan
+end

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

@@ -0,0 +1,55 @@
+class ASHRAE901PRM < Standard
+  # @!group HeatExchangerSensLat
+
+  # Defines the minimum sensible and latent effectiveness of the heat exchanger.
+  # Assumed to apply to sensible and latent effectiveness at all flow rates.
+  #
+  # @param heat_exchanger_air_to_air_sensible_and_latent [OpenStudio::Model::HeatExchangerAirToAirSensibleAndLatent] OpenStudio heat exchanger object
+  # @return [Array] List of full and part load heat exchanger effectiveness
+  def heat_exchanger_air_to_air_sensible_and_latent_minimum_effectiveness(heat_exchanger_air_to_air_sensible_and_latent)
+    # Get required ERR
+    enthalpy_recovery_ratio = heat_exchanger_air_to_air_sensible_and_latent_enthalpy_recovery_ratio(heat_exchanger_air_to_air_sensible_and_latent)
+
+    # Get design condition for climate zones
+    climate_zone = model_standards_climate_zone(heat_exchanger_air_to_air_sensible_and_latent.model)
+    design_conditions = heat_exchanger_air_to_air_sensible_and_latent_design_conditions(heat_exchanger_air_to_air_sensible_and_latent, climate_zone)
+
+    # Adjust, and convert ERR to Effectiveness for input to the model
+    enthalpy_recovery_ratio = enthalpy_recovery_ratio_design_to_typical_adjustment(enthalpy_recovery_ratio, climate_zone)
+    full_htg_sens_eff, full_htg_lat_eff, part_htg_sens_eff, part_htg_lat_eff, full_cool_sens_eff, full_cool_lat_eff, part_cool_sens_eff, part_cool_lat_eff = heat_exchanger_air_to_air_sensible_and_latent_enthalpy_recovery_ratio_to_effectiveness(enthalpy_recovery_ratio, design_conditions)
+
+    return full_htg_sens_eff, full_htg_lat_eff, part_htg_sens_eff, part_htg_lat_eff, full_cool_sens_eff, full_cool_lat_eff, part_cool_sens_eff, part_cool_lat_eff
+  end
+
+  # Determine the heat exchanger design conditions for a specific climate zones
+  #
+  # @param heat_exchanger_air_to_air_sensible_and_latent [OpenStudio::Model::HeatExchangerAirToAirSensibleAndLatent] OpenStudio heat exchanger object
+  # @param climate_zone [String] Climate zone used to generate the model
+  # @return [String] Heat exchanger design conditions
+  def heat_exchanger_air_to_air_sensible_and_latent_design_conditions(heat_exchanger_air_to_air_sensible_and_latent, climate_zone)
+    case climate_zone
+    when 'ASHRAE 169-2006-6B',
+      'ASHRAE 169-2013-6B',
+      'ASHRAE 169-2006-7A',
+      'ASHRAE 169-2013-7A',
+      'ASHRAE 169-2006-7B',
+      'ASHRAE 169-2013-7B',
+      'ASHRAE 169-2006-8A',
+      'ASHRAE 169-2013-8A',
+      'ASHRAE 169-2006-8B',
+      'ASHRAE 169-2013-8B'
+      design_conditions = 'heating'
+    else
+      design_conditions = 'cooling'
+    end
+    return design_conditions
+  end
+
+  # Determine the required enthalpy recovery ratio (ERR)
+  #
+  # @param heat_exchanger_air_to_air_sensible_and_latent [OpenStudio::Model::HeatExchangerAirToAirSensibleAndLatent] OpenStudio heat exchanger object
+  # @return [Float] ERR
+  def heat_exchanger_air_to_air_sensible_and_latent_enthalpy_recovery_ratio(heat_exchanger_air_to_air_sensible_and_latent)
+    return 0.5
+  end
+end