openstudio-standards 0.2.16.rc2 → 0.2.17.rc1

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

@@ -0,0 +1,10 @@
+class ASHRAE901PRM < Standard
+  # @!group AirTerminalSingleDuctParallelPIUReheat
+
+  # Return the fan on flow fraction for a parallel PIU terminal
+  #
+  # @return [Float] returns nil or a float representing the fraction
+  def air_terminal_single_duct_parallel_piu_reheat_fan_on_flow_fraction
+    return 0.0 # will make the secondary fans run for heating loads
+  end
+end

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

@@ -0,0 +1,31 @@
+class ASHRAE901PRM < Standard
+  # @!group AirTerminalSingleDuctVAVReheat
+
+  # Set the minimum damper position based on OA rate of the space and the template.
+  # Zones with low OA per area get lower initial guesses.
+  # Final position will be adjusted upward as necessary by Standards.AirLoopHVAC.adjust_minimum_vav_damper_positions
+  #
+  # @param air_terminal_single_duct_vav_reheat [OpenStudio::Model::AirTerminalSingleDuctVAVReheat] the air terminal object
+  # @param zone_min_oa [Double] the zone outdoor air flow rate, in m^3/s.
+  #   If supplied, this will be set as a minimum limit in addition to the minimum
+  #   damper position.  EnergyPlus will use the larger of the two values during sizing.
+  # @param has_ddc [Bool] whether or not there is DDC control of the VAV terminal,
+  #   which impacts the minimum damper position requirement.
+  # @return [Bool] returns true if successful, false if not
+  # @todo remove exception where older vintages don't have minimum positions adjusted.
+  def air_terminal_single_duct_vav_reheat_apply_minimum_damper_position(air_terminal_single_duct_vav_reheat, zone_min_oa = nil, has_ddc = true)
+    # Minimum damper position
+    min_damper_position = air_terminal_single_duct_vav_reheat_minimum_damper_position(air_terminal_single_duct_vav_reheat, has_ddc)
+    air_terminal_single_duct_vav_reheat.setConstantMinimumAirFlowFraction(min_damper_position)
+    OpenStudio.logFree(OpenStudio::Debug, 'openstudio.standards.AirTerminalSingleDuctVAVReheat', "For #{air_terminal_single_duct_vav_reheat.name}: set minimum damper position to #{min_damper_position}.")
+
+    # Minimum OA flow rate
+    # If specified, set the MDP as the larger of the two
+    unless zone_min_oa.nil?
+      min_oa_damp_position = [zone_min_oa / air_terminal_single_duct_vav_reheat.autosizedMaximumAirFlowRate.get, min_damper_position].max
+      air_terminal_single_duct_vav_reheat.setConstantMinimumAirFlowFraction(min_oa_damp_position)
+    end
+
+    return true
+  end
+end

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

@@ -0,0 +1,91 @@
+class ASHRAE901PRM < Standard
+  # @!group BoilerHotWater
+
+  # find search criteria
+  #
+  # @param boiler_hot_water [OpenStudio::Model::BoilerHotWater] hot water boiler object
+  # @return [Hash] used for standards_lookup_table(model)
+  def boiler_hot_water_find_search_criteria(boiler_hot_water)
+    # Define the criteria to find the boiler properties
+    # in the hvac standards data set.
+    search_criteria = {}
+    search_criteria['template'] = template
+
+    # Get fuel type
+    search_criteria['fuel_type'] = 'Gas'
+
+    # Get the fluid type
+    search_criteria['fluid_type'] = 'Hot Water'
+
+    return search_criteria
+  end
+
+  # Finds lookup object in standards and return minimum thermal efficiency
+  #
+  # @param boiler_hot_water [OpenStudio::Model::BoilerHotWater] hot water boiler object
+  # @param rename [Bool] returns true if successful, false if not
+  # @return [Double] minimum thermal efficiency
+  def boiler_hot_water_standard_minimum_thermal_efficiency(boiler_hot_water, rename = false)
+    # Get the boiler properties
+    search_criteria = boiler_hot_water_find_search_criteria(boiler_hot_water)
+    capacity_w = boiler_hot_water_find_capacity(boiler_hot_water)
+    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 boiler properties
+    blr_props = model_find_object(standards_data['boilers'], search_criteria, capacity_btu_per_hr)
+    unless blr_props
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.BoilerHotWater', "For #{boiler_hot_water.name}, cannot find boiler properties, cannot apply efficiency standard.")
+      successfully_set_all_properties = false
+      return successfully_set_all_properties
+    end
+
+    # If specified as AFUE
+    unless blr_props['minimum_annual_fuel_utilization_efficiency'].nil?
+      min_afue = blr_props['minimum_annual_fuel_utilization_efficiency']
+      thermal_eff = afue_to_thermal_eff(min_afue)
+      new_comp_name = "#{boiler_hot_water.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_afue} AFUE"
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.BoilerHotWater', "For #{template}: #{boiler_hot_water.name}: Gas Hot Water Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; AFUE = #{min_afue}")
+    end
+
+    # If specified as thermal efficiency
+    unless blr_props['minimum_thermal_efficiency'].nil?
+      thermal_eff = blr_props['minimum_thermal_efficiency']
+      new_comp_name = "#{boiler_hot_water.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{thermal_eff} Thermal Eff"
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.BoilerHotWater', "For #{template}: #{boiler_hot_water.name}: Gas Hot Water Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; Thermal Efficiency = #{thermal_eff}")
+    end
+
+    # If specified as combustion efficiency
+    unless blr_props['minimum_combustion_efficiency'].nil?
+      min_comb_eff = blr_props['minimum_combustion_efficiency']
+      thermal_eff = combustion_eff_to_thermal_eff(min_comb_eff)
+      new_comp_name = "#{boiler_hot_water.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_comb_eff} Combustion Eff"
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.BoilerHotWater', "For #{template}: #{boiler_hot_water.name}: Gas Hot Water Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; Combustion Efficiency = #{min_comb_eff}")
+    end
+
+    # Rename
+    if rename
+      boiler_hot_water.setName(new_comp_name)
+    end
+
+    return thermal_eff
+  end
+
+  # Applies the standard efficiency ratings to this object.
+  #
+  # @param boiler_hot_water [OpenStudio::Model::BoilerHotWater] hot water boiler object
+  # @return [Bool] true if successful, false if not
+  def boiler_hot_water_apply_efficiency_and_curves(boiler_hot_water)
+    # Get the minimum efficiency standards
+    thermal_eff = boiler_hot_water_standard_minimum_thermal_efficiency(boiler_hot_water)
+
+    # Set the efficiency values
+    unless thermal_eff.nil?
+      boiler_hot_water.setNominalThermalEfficiency(thermal_eff)
+    end
+    return true
+  end
+end

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

@@ -0,0 +1,84 @@
+class ASHRAE901PRM < Standard
+  # @!group ChillerElectricEIR
+
+  # Finds the search criteria
+  #
+  # @param chiller_electric_eir [OpenStudio::Model::ChillerElectricEIR] chiller object
+  # @return [hash] has for search criteria to be used for find object
+  def chiller_electric_eir_find_search_criteria(chiller_electric_eir)
+    search_criteria = {}
+    search_criteria['template'] = template
+
+    # In AppG prm models, all scenarios are WaterCooled for cooling type.
+    cooling_type = 'WaterCooled'
+
+    search_criteria['cooling_type'] = cooling_type
+
+    # TODO: Standards replace this with a mechanism to store this
+    # data in the chiller object itself.
+    # For now, retrieve the condenser type from the name
+    name = chiller_electric_eir.name.get
+    condenser_type = nil
+    compressor_type = nil
+    if chiller_electric_eir.additionalProperties.hasFeature('compressor_type')
+      compressor_type = chiller_electric_eir.additionalProperties.getFeatureAsString('compressor_type').get
+    end
+    unless condenser_type.nil?
+      search_criteria['condenser_type'] = condenser_type
+    end
+    unless compressor_type.nil?
+      search_criteria['compressor_type'] = compressor_type
+    end
+
+    return search_criteria
+  end
+
+  # Finds lookup object in standards and return full load efficiency
+  #
+  # @param chiller_electric_eir [OpenStudio::Model::ChillerElectricEIR] chiller object
+  # @return [Double] full load efficiency (COP), [Double] capacity in tons, [Double] kw/ton
+  def chiller_electric_eir_standard_minimum_full_load_efficiency(chiller_electric_eir)
+    # Get the chiller properties
+    search_criteria = chiller_electric_eir_find_search_criteria(chiller_electric_eir)
+    capacity_w = chiller_electric_eir_find_capacity(chiller_electric_eir)
+    unless capacity_w
+      return nil
+    end
+
+    capacity_tons = OpenStudio.convert(capacity_w, 'W', 'ton').get
+    chlr_props = model_find_object(standards_data['chillers'], search_criteria, capacity_tons, Date.today)
+
+    if chlr_props.nil? || !chlr_props['minimum_full_load_efficiency']
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.ChillerElectricEIR', "For #{chiller_electric_eir.name}, cannot find minimum full load efficiency.")
+      return nil
+    else
+      # lookup the efficiency value
+      kw_per_ton = chlr_props['minimum_full_load_efficiency']
+      cop = kw_per_ton_to_cop(kw_per_ton)
+    end
+
+    return cop, capacity_tons, kw_per_ton
+  end
+
+  # Applies the standard efficiency ratings to this object.
+  #
+  # @param chiller_electric_eir [OpenStudio::Model::ChillerElectricEIR] chiller object
+  # @return [Bool] true if successful, false if not
+  def chiller_electric_eir_apply_efficiency_and_curves(chiller_electric_eir)
+    # Set the efficiency value
+    cop, capacity_tons, kw_per_ton = chiller_electric_eir_standard_minimum_full_load_efficiency(chiller_electric_eir)
+    if cop.nil?
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.ChillerElectricEIR', "For #{chiller_electric_eir.name}, cannot find minimum full load efficiency, will not be set.")
+      successfully_set_all_properties = false
+    else
+      chiller_electric_eir.setReferenceCOP(cop)
+      successfully_set_all_properties = true
+    end
+
+    # Append the name with size and kw/ton
+    chiller_electric_eir.setName("#{chiller_electric_eir.name} #{capacity_tons.round}tons #{kw_per_ton.round(1)}kW/ton")
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ChillerElectricEIR', "For #{template}: #{chiller_electric_eir.name}: Capacity = #{capacity_tons.round}tons; COP = #{cop.round(1)} (#{kw_per_ton.round(1)}kW/ton)")
+
+    return successfully_set_all_properties
+  end
+end

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

@@ -0,0 +1,145 @@
+class ASHRAE901PRM < Standard
+  # @!group CoilCoolingDXSingleSpeed
+
+  include ASHRAEPRMCoilDX
+
+  # Finds capacity in W
+  #
+  # @param coil_cooling_dx_single_speed [OpenStudio::Model::CoilCoolingDXSingleSpeed] coil cooling dx single speed object
+  # @param sys_type [String] HVAC system type
+  # @return [Double] capacity in W to be used for find object
+  def coil_cooling_dx_single_speed_find_capacity(coil_cooling_dx_single_speed, sys_type)
+    capacity_w = nil
+    if coil_cooling_dx_single_speed.ratedTotalCoolingCapacity.is_initialized
+      capacity_w = coil_cooling_dx_single_speed.ratedTotalCoolingCapacity.get
+    elsif coil_cooling_dx_single_speed.autosizedRatedTotalCoolingCapacity.is_initialized
+      capacity_w = coil_cooling_dx_single_speed.autosizedRatedTotalCoolingCapacity.get
+    else
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXSingleSpeed', "For #{coil_cooling_dx_single_speed.name} capacity is not available, cannot apply efficiency standard.")
+      return 0.0
+    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_cooling_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_cooling_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 == 'PTAC' || sys_type == 'PTHP'
+      mult = 1
+      comp = coil_cooling_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.CoilCoolingDXSingleSpeed', "For #{coil_cooling_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_cooling_dx_single_speed [OpenStudio::Model::CoilCoolingDXSingleSpeed] coil cooling 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_cooling_dx_single_speed_standard_minimum_cop(coil_cooling_dx_single_speed, sys_type, rename = false)
+    # find properties
+    capacity_w = coil_cooling_dx_single_speed_find_capacity(coil_cooling_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_cooling_dx_single_speed, capacity_btu_per_hr, sys_type)
+
+    # Lookup efficiencies depending on whether it is a unitary AC or a heat pump
+    ac_props = nil
+    ac_props = if sys_type == 'PSZ_HP' || sys_type == 'PTHP'
+                 model_find_object(standards_data['heat_pumps'], search_criteria, capacity_btu_per_hr, Date.today)
+               else
+                 model_find_object(standards_data['unitary_acs'], search_criteria, capacity_btu_per_hr, Date.today)
+               end
+
+    # Get the minimum efficiency standards
+    cop = nil
+
+    # Check to make sure properties were found
+    if ac_props.nil?
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXSingleSpeed', "For #{coil_cooling_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_cooling_dx_single_speed.name} #{capacity_btu_per_hr.round}Btu/hr #{cop}COP"
+
+    # Rename
+    if rename
+      coil_cooling_dx_single_speed.setName(new_comp_name)
+    end
+
+    return cop
+  end
+
+  # Applies the standard efficiency ratings to this object.
+  #
+  # @param coil_cooling_dx_single_speed [OpenStudio::Model::CoilCoolingDXSingleSpeed] coil cooling 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_cooling_dx_single_speed_apply_efficiency_and_curves(coil_cooling_dx_single_speed, sql_db_vars_map, sys_type)
+    # Preserve the original name
+    orig_name = coil_cooling_dx_single_speed.name.to_s
+
+    # Find the minimum COP and rename with efficiency rating
+    # Set last argument to false to avoid renaming coil, since that complicates lookup of HP heating coil efficiency later
+    cop = coil_cooling_dx_single_speed_standard_minimum_cop(coil_cooling_dx_single_speed, sys_type, false)
+
+    # Map the original name to the new name
+    sql_db_vars_map[coil_cooling_dx_single_speed.name.to_s] = orig_name
+
+    # Set the efficiency values
+    unless cop.nil?
+      coil_cooling_dx_single_speed.setRatedCOP(OpenStudio::OptionalDouble.new(cop))
+    end
+
+    return sql_db_vars_map
+  end
+end

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

@@ -0,0 +1,106 @@
+class ASHRAE901PRM < Standard
+  # @!group CoilCoolingDXTwoSpeed
+
+  include ASHRAEPRMCoilDX
+
+  # Finds capacity in W
+  #
+  # @param coil_cooling_dx_two_speed [OpenStudio::Model::CoilCoolingDXTwoSpeed] coil cooling dx two speed object
+  # @param sys_type [String] HVAC system type
+  # @return [Double] capacity in W to be used for find object
+  def coil_cooling_dx_two_speed_find_capacity(coil_cooling_dx_two_speed, sys_type)
+    capacity_w = nil
+    if coil_cooling_dx_two_speed.ratedHighSpeedTotalCoolingCapacity.is_initialized
+      capacity_w = coil_cooling_dx_two_speed.ratedHighSpeedTotalCoolingCapacity.get
+    elsif coil_cooling_dx_two_speed.autosizedRatedHighSpeedTotalCoolingCapacity.is_initialized
+      capacity_w = coil_cooling_dx_two_speed.autosizedRatedHighSpeedTotalCoolingCapacity.get
+    else
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXTwoSpeed', "For #{coil_cooling_dx_two_speed.name} capacity is not available, cannot apply efficiency standard.")
+      return 0.0
+    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 == 'PTAC' || sys_type == 'PTHP'
+      mult = 1
+      comp = coil_cooling_dx_two_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.CoilCoolingDXTwoSpeed', "For #{coil_cooling_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_cooling_dx_two_speed [OpenStudio::Model::CoilCoolingDXTwoSpeed] coil cooling dx two 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_cooling_dx_two_speed_standard_minimum_cop(coil_cooling_dx_two_speed, sys_type, rename = false)
+    # find properties
+    capacity_w = coil_cooling_dx_two_speed_find_capacity(coil_cooling_dx_two_speed, sys_type)
+    capacity_btu_per_hr = OpenStudio.convert(capacity_w, 'W', 'Btu/hr').get
+    search_criteria = coil_dx_find_search_criteria(coil_cooling_dx_two_speed, capacity_btu_per_hr, sys_type)
+
+    # Lookup efficiencies depending on whether it is a unitary AC or a heat pump
+    ac_props = nil
+    ac_props = if sys_type == 'PSZ_HP' || sys_type == 'PTHP'
+                 model_find_object(standards_data['heat_pumps'], search_criteria, capacity_btu_per_hr, Date.today)
+               else
+                 model_find_object(standards_data['unitary_acs'], search_criteria, capacity_btu_per_hr, Date.today)
+               end
+
+    # Get the minimum efficiency standards
+    cop = nil
+
+    # Check to make sure properties were found
+    if ac_props.nil?
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXTwoSpeed', "For #{coil_cooling_dx_two_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_cooling_dx_two_speed.name} #{capacity_btu_per_hr.round}Btu/hr #{cop}COP"
+
+    # Rename
+    if rename
+      coil_cooling_dx_two_speed.setName(new_comp_name)
+    end
+
+    return cop
+  end
+
+  # Applies the standard efficiency ratings to this object.
+  #
+  # @param coil_cooling_dx_two_speed [OpenStudio::Model::CoilCoolingDXTwoSpeed] coil cooling dx two 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_cooling_dx_two_speed_apply_efficiency_and_curves(coil_cooling_dx_two_speed, sql_db_vars_map, sys_type)
+    # Preserve the original name
+    orig_name = coil_cooling_dx_two_speed.name.to_s
+
+    # Find the minimum COP and rename with efficiency rating
+    cop = coil_cooling_dx_two_speed_standard_minimum_cop(coil_cooling_dx_two_speed, sys_type, true)
+
+    # Map the original name to the new name
+    sql_db_vars_map[coil_cooling_dx_two_speed.name.to_s] = orig_name
+
+    # Set the efficiency values
+    unless cop.nil?
+      coil_cooling_dx_two_speed.setRatedHighSpeedCOP(cop)
+      coil_cooling_dx_two_speed.setRatedLowSpeedCOP(cop)
+    end
+
+    return sql_db_vars_map
+  end
+end

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

@@ -0,0 +1,71 @@
+# A variety of DX coil methods that are the same regardless of coil type.
+# These methods are available to:
+# CoilCoolingDXSingleSpeed, CoilCoolingDXTwoSpeed, CoilHeatingDXSingleSpeed
+module ASHRAEPRMCoilDX
+  # @!group CoilDX
+
+  # Finds the subcategory.
+  #
+  # @param coil_dx [OpenStudio::Model::StraightComponent] coil cooling object
+  # @param capacity [Double] capacity in btu/hr
+  # @param sys_type [String] HVAC system type
+  # @return [String] the coil_dx_subcategory(coil_dx)
+  def coil_dx_subcategory(coil_dx, capacity, sys_type)
+    sub_category = ''
+
+    # heating coil
+    if coil_dx.iddObjectType.valueName.to_s.include? 'OS_Coil_Heating_DX'
+      if sys_type == 'PTHP'
+        sub_category = 'PTHP'
+      elsif capacity < 65000
+        sub_category = 'Single Package'
+      else
+        sub_category = '47F db/43F wb outdoor air'
+      end
+    end
+
+    # cooling coil
+    if coil_dx.iddObjectType.valueName.to_s.include? 'OS_Coil_Cooling_DX'
+      if sys_type == 'PTHP'
+        sub_category = 'PTHP'
+      elsif sys_type == 'PTAC'
+        sub_category = 'PTAC'
+      elsif sys_type == 'PSZ_HP'
+        if capacity < 65000
+          sub_category = 'Single Package'
+        else
+          sub_category = 'Split-system and single package'
+        end
+      else
+        sub_category = 'Split-system and single package'
+      end
+    end
+
+    return sub_category
+  end
+
+  # Finds the search criteria
+  #
+  # @param coil_dx [OpenStudio::Model::StraightComponent] coil cooling object
+  # @param capacity [Double] capacity in btu/hr
+  # @param sys_type [String] HVAC system type
+  # @return [hash] has for search criteria to be used for find object
+  def coil_dx_find_search_criteria(coil_dx, capacity, sys_type)
+    search_criteria = {}
+    search_criteria['template'] = template
+
+    search_criteria['cooling_type'] = 'AirCooled'
+
+    # Get the coil_dx_subcategory(coil_dx)
+    subcategory = coil_dx_subcategory(coil_dx, capacity, sys_type)
+    if subcategory != ''
+      search_criteria['subcategory'] = subcategory
+    end
+
+    if coil_dx.iddObjectType.valueName.to_s != 'OS_Coil_Heating_DX_SingleSpeed'
+      search_criteria['heating_type'] = 'All Other'
+    end
+
+    return search_criteria
+  end
+end