openstudio-standards 0.7.1 → 0.8.0.rc1

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

@@ -7,8 +7,9 @@ class Standard
   #
   # @param coil_cooling_dx_single_speed [OpenStudio::Model::CoilCoolingDXSingleSpeed] coil cooling dx single speed object
   # @param necb_ref_hp [Boolean] for compatability with NECB ruleset only.
+  # @param equipment_type [String] type of equipment that this coil object belongs to.
   # @return [Double] capacity in W to be used for find object
-  def coil_cooling_dx_single_speed_find_capacity(coil_cooling_dx_single_speed, necb_ref_hp = false)
+  def coil_cooling_dx_single_speed_find_capacity(coil_cooling_dx_single_speed, necb_ref_hp = false, equipment_type = nil)
     capacity_w = nil
     if coil_cooling_dx_single_speed.ratedTotalCoolingCapacity.is_initialized
       capacity_w = coil_cooling_dx_single_speed.ratedTotalCoolingCapacity.get
@@ -21,7 +22,7 @@ class Standard
 
     # 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 ['PTAC', 'PTHP'].include?(coil_dx_subcategory(coil_cooling_dx_single_speed))
+    if ['PTAC', 'PTHP'].include?(coil_dx_subcategory(coil_cooling_dx_single_speed)) || ['PTAC', 'PTHP'].include?(equipment_type)
       mult = 1
       comp = coil_cooling_dx_single_speed.containingZoneHVACComponent
       if comp.is_initialized && comp.get.thermalZone.is_initialized
@@ -42,24 +43,46 @@ class Standard
   # @param coil_cooling_dx_single_speed [OpenStudio::Model::CoilCoolingDXSingleSpeed] coil cooling dx single speed object
   # @param rename [Boolean] if true, object will be renamed to include capacity and efficiency level
   # @param necb_ref_hp [Boolean] for compatability with NECB ruleset only.
+  # @param equipment_type [Boolean] indicate that equipment_type should be in the search criteria.
   # @return [Double] full load efficiency (COP)
-  def coil_cooling_dx_single_speed_standard_minimum_cop(coil_cooling_dx_single_speed, rename = false, necb_ref_hp = false)
-    search_criteria = coil_dx_find_search_criteria(coil_cooling_dx_single_speed, necb_ref_hp)
+  def coil_cooling_dx_single_speed_standard_minimum_cop(coil_cooling_dx_single_speed, rename = false, necb_ref_hp = false, equipment_type = false)
+    search_criteria = coil_dx_find_search_criteria(coil_cooling_dx_single_speed, necb_ref_hp, equipment_type)
     cooling_type = search_criteria['cooling_type']
     heating_type = search_criteria['heating_type']
     sub_category = search_criteria['subcategory']
-    capacity_w = coil_cooling_dx_single_speed_find_capacity(coil_cooling_dx_single_speed, necb_ref_hp)
+    equipment_type = nil
+
+    # Define database
+    if coil_dx_heat_pump?(coil_cooling_dx_single_speed)
+      database = standards_data['heat_pumps']
+    else
+      database = standards_data['unitary_acs']
+    end
+
+    # Additional search criteria
+    if database[0].keys.include?('equipment_type') || ((template == 'NECB2011') || (template == 'NECB2015') || (template == 'NECB2017') || (template == 'NECB2020') || (template == 'BTAPPRE1980') ||
+      (template == 'BTAP1980TO2010'))
+      if search_criteria.keys.include?('equipment_type')
+        equipment_type = search_criteria['equipment_type']
+        if equipment_type == 'PTAC'
+          search_criteria['application'] = coil_dx_ptac_application(coil_cooling_dx_single_speed)
+        end
+      elsif !coil_dx_heat_pump?(coil_cooling_dx_single_speed)
+        search_criteria['equipment_type'] = 'Air Conditioners'
+      end
+    end
+    if database[0].keys.include?('region')
+      search_criteria['region'] = nil # non-nil values are currently used for residential products
+    end
+
+    capacity_w = coil_cooling_dx_single_speed_find_capacity(coil_cooling_dx_single_speed, necb_ref_hp, equipment_type)
     capacity_btu_per_hr = OpenStudio.convert(capacity_w, 'W', 'Btu/hr').get
     capacity_kbtu_per_hr = OpenStudio.convert(capacity_w, 'W', 'kBtu/hr').get
 
     # Look up the efficiency characteristics
     # Lookup efficiencies depending on whether it is a unitary AC or a heat pump
     ac_props = nil
-    ac_props = if coil_dx_heat_pump?(coil_cooling_dx_single_speed)
-                 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
+    ac_props = model_find_object(database, search_criteria, capacity_btu_per_hr, Date.today)
 
     # Check to make sure properties were found
     if ac_props.nil?
@@ -92,7 +115,7 @@ class Standard
     # If PTAC, use equations if coefficients are specified
     ptac_eer_coeff_1 = ac_props['ptac_eer_coefficient_1']
     ptac_eer_coeff_2 = ac_props['ptac_eer_coefficient_2']
-    if sub_category == 'PTAC' && !ptac_eer_coeff_1.nil? && !ptac_eer_coeff_2.nil?
+    if equipment_type == 'PTAC' && !ptac_eer_coeff_1.nil? && !ptac_eer_coeff_2.nil?
       # TABLE 6.8.1D
       # EER = ptac_eer_coeff_1 - (ptac_eer_coeff_2 * Cap / 1000)
       # Note c: Cap means the rated cooling capacity of the product in Btu/h.
@@ -135,6 +158,15 @@ class Standard
       OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilCoolingDXSingleSpeed', "For #{template}: #{coil_cooling_dx_single_speed.name}: #{cooling_type} #{heating_type} #{sub_category} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; SEER = #{min_seer}")
     end
 
+    # If specified as SEER2
+    # TODO: assumed to be the same as SEER for now
+    unless ac_props['minimum_seasonal_energy_efficiency_ratio_2'].nil?
+      min_seer = ac_props['minimum_seasonal_energy_efficiency_ratio_2']
+      cop = seer_to_cop_no_fan(min_seer)
+      new_comp_name = "#{coil_cooling_dx_single_speed.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_seer}SEER"
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilCoolingDXSingleSpeed', "For #{template}: #{coil_cooling_dx_single_speed.name}: #{cooling_type} #{heating_type} #{sub_category} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; SEER = #{min_seer}")
+    end
+
     # If specified as EER
     unless ac_props['minimum_energy_efficiency_ratio'].nil?
       min_eer = ac_props['minimum_energy_efficiency_ratio']
@@ -143,7 +175,24 @@ class Standard
       OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilCoolingDXSingleSpeed', "For #{template}: #{coil_cooling_dx_single_speed.name}: #{cooling_type} #{heating_type} #{sub_category} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; EER = #{min_eer}")
     end
 
-    # if specified as SEER (heat pump)
+    # If specified as EER2
+    # TODO: assumed to be the same as EER for now
+    unless ac_props['minimum_energy_efficiency_ratio_2'].nil?
+      min_eer = ac_props['minimum_energy_efficiency_ratio_2']
+      cop = eer_to_cop_no_fan(min_eer)
+      new_comp_name = "#{coil_cooling_dx_single_speed.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_eer}EER"
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilCoolingDXSingleSpeed', "For #{template}: #{coil_cooling_dx_single_speed.name}: #{cooling_type} #{heating_type} #{sub_category} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; EER = #{min_eer}")
+    end
+
+    # If specific as IEER
+    if !ac_props['minimum_integrated_energy_efficiency_ratio'].nil? && cop.nil?
+      min_ieer = ac_props['minimum_integrated_energy_efficiency_ratio']
+      cop = ieer_to_cop_no_fan(min_ieer)
+      new_comp_name = "#{coil_cooling_dx_single_speed.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_ieer}IEER"
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilCoolingDXTwoSpeed', "For #{template}: #{coil_cooling_dx_single_speed.name}: #{cooling_type} #{heating_type} #{sub_category} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; EER = #{min_eer}")
+    end
+
+    # If specified as SEER
     unless ac_props['minimum_seasonal_efficiency'].nil?
       min_seer = ac_props['minimum_seasonal_efficiency']
       cop = seer_to_cop_no_fan(min_seer)
@@ -176,21 +225,40 @@ class Standard
   def coil_cooling_dx_single_speed_apply_efficiency_and_curves(coil_cooling_dx_single_speed, sql_db_vars_map, necb_ref_hp = false)
     successfully_set_all_properties = true
 
-    # Get the search criteria.
-    search_criteria = coil_dx_find_search_criteria(coil_cooling_dx_single_speed, necb_ref_hp)
+    # Get efficiencies data depending on whether it is a unitary AC or a heat pump
+    coil_efficiency_data = if coil_dx_heat_pump?(coil_cooling_dx_single_speed)
+                             standards_data['heat_pumps']
+                           else
+                             standards_data['unitary_acs']
+                           end
+
+    # Get the search criteria
+    equipment_type = coil_efficiency_data[0].keys.include?('equipment_type') ? true : false
+    search_criteria = coil_dx_find_search_criteria(coil_cooling_dx_single_speed, necb_ref_hp, equipment_type)
+
+    # Additional search criteria
+    if coil_efficiency_data[0].keys.include?('equipment_type') || ((template == 'NECB2011') || (template == 'NECB2015') || (template == 'NECB2017') || (template == 'NECB2020') || (template == 'BTAPPRE1980') ||
+      (template == 'BTAP1980TO2010'))
+      if search_criteria.keys.include?('equipment_type')
+        equipment_type = search_criteria['equipment_type']
+        if equipment_type == 'PTAC'
+          search_criteria['application'] = coil_dx_ptac_application(coil_cooling_dx_single_speed)
+        end
+      elsif !coil_dx_heat_pump?(coil_cooling_dx_single_speed)
+        search_criteria['equipment_type'] = 'Air Conditioners'
+      end
+    end
+    if coil_efficiency_data[0].keys.include?('region')
+      search_criteria['region'] = nil # non-nil values are currently used for residential products
+    end
 
-    # Get the capacity.
-    capacity_w = coil_cooling_dx_single_speed_find_capacity(coil_cooling_dx_single_speed, necb_ref_hp)
+    # Get the capacity
+    capacity_w = coil_cooling_dx_single_speed_find_capacity(coil_cooling_dx_single_speed, necb_ref_hp, equipment_type)
     capacity_btu_per_hr = OpenStudio.convert(capacity_w, 'W', 'Btu/hr').get
     capacity_kbtu_per_hr = OpenStudio.convert(capacity_w, 'W', 'kBtu/hr').get
 
-    # Lookup efficiencies depending on whether it is a unitary AC or a heat pump
-    ac_props = nil
-    ac_props = if coil_dx_heat_pump?(coil_cooling_dx_single_speed)
-                 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
+    # Lookup efficiency
+    ac_props = model_find_object(coil_efficiency_data, search_criteria, capacity_btu_per_hr, Date.today)
 
     # Check to make sure properties were found
     if ac_props.nil?
@@ -199,8 +267,15 @@ class Standard
       return sql_db_vars_map
     end
 
+    equipment_type_field = search_criteria['equipment_type']
     # Make the COOL-CAP-FT curve
-    cool_cap_ft = model_add_curve(coil_cooling_dx_single_speed.model, ac_props['cool_cap_ft'])
+    cool_cap_ft = nil
+    if ac_props['cool_cap_ft']
+      cool_cap_ft = model_add_curve(coil_cooling_dx_single_speed.model, ac_props['cool_cap_ft'])
+    else
+      cool_cap_ft_curve_name = coil_dx_cap_ft(coil_cooling_dx_single_speed, equipment_type_field)
+      cool_cap_ft = model_add_curve(coil_cooling_dx_single_speed.model, cool_cap_ft_curve_name)
+    end
     if cool_cap_ft
       coil_cooling_dx_single_speed.setTotalCoolingCapacityFunctionOfTemperatureCurve(cool_cap_ft)
     else
@@ -209,7 +284,13 @@ class Standard
     end
 
     # Make the COOL-CAP-FFLOW curve
-    cool_cap_fflow = model_add_curve(coil_cooling_dx_single_speed.model, ac_props['cool_cap_fflow'])
+    cool_cap_fflow = nil
+    if ac_props['cool_cap_fflow']
+      cool_cap_fflow = model_add_curve(coil_cooling_dx_single_speed.model, ac_props['cool_cap_fflow'])
+    else
+      cool_cap_fflow_curve_name = coil_dx_cap_fff(coil_cooling_dx_single_speed, equipment_type_field)
+      cool_cap_fflow = model_add_curve(coil_cooling_dx_single_speed.model, cool_cap_fflow_curve_name)
+    end
     if cool_cap_fflow
       coil_cooling_dx_single_speed.setTotalCoolingCapacityFunctionOfFlowFractionCurve(cool_cap_fflow)
     else
@@ -218,7 +299,13 @@ class Standard
     end
 
     # Make the COOL-EIR-FT curve
-    cool_eir_ft = model_add_curve(coil_cooling_dx_single_speed.model, ac_props['cool_eir_ft'])
+    cool_eir_ft = nil
+    if ac_props['cool_eir_ft']
+      cool_eir_ft = model_add_curve(coil_cooling_dx_single_speed.model, ac_props['cool_eir_ft'])
+    else
+      cool_eir_ft_curve_name = coil_dx_eir_ft(coil_cooling_dx_single_speed, equipment_type_field)
+      cool_eir_ft = model_add_curve(coil_cooling_dx_single_speed.model, cool_eir_ft_curve_name)
+    end
     if cool_eir_ft
       coil_cooling_dx_single_speed.setEnergyInputRatioFunctionOfTemperatureCurve(cool_eir_ft)
     else
@@ -227,7 +314,13 @@ class Standard
     end
 
     # Make the COOL-EIR-FFLOW curve
-    cool_eir_fflow = model_add_curve(coil_cooling_dx_single_speed.model, ac_props['cool_eir_fflow'])
+    cool_eir_fflow = nil
+    if ac_props['cool_eir_fflow']
+      cool_eir_fflow = model_add_curve(coil_cooling_dx_single_speed.model, ac_props['cool_eir_fflow'])
+    else
+      cool_eir_fflow_curve_name = coil_dx_eir_fff(coil_cooling_dx_single_speed, equipment_type_field)
+      cool_eir_fflow = model_add_curve(coil_cooling_dx_single_speed.model, cool_eir_fflow_curve_name)
+    end
     if cool_eir_fflow
       coil_cooling_dx_single_speed.setEnergyInputRatioFunctionOfFlowFractionCurve(cool_eir_fflow)
     else
@@ -236,7 +329,13 @@ class Standard
     end
 
     # Make the COOL-PLF-FPLR curve
-    cool_plf_fplr = model_add_curve(coil_cooling_dx_single_speed.model, ac_props['cool_plf_fplr'])
+    cool_plf_fplr = nil
+    if ac_props['cool_plf_fplr']
+      cool_plf_fplr = model_add_curve(coil_cooling_dx_single_speed.model, ac_props['cool_plf_fplr'])
+    else
+      cool_plf_fplr_curve_name = coil_dx_plf_fplr(coil_cooling_dx_single_speed, equipment_type_field)
+      cool_plf_fplr = model_add_curve(coil_cooling_dx_single_speed.model, cool_plf_fplr_curve_name)
+    end
     if cool_plf_fplr
       coil_cooling_dx_single_speed.setPartLoadFractionCorrelationCurve(cool_plf_fplr)
     else
@@ -248,7 +347,7 @@ class Standard
     orig_name = coil_cooling_dx_single_speed.name.to_s
 
     # Find the minimum COP and rename with efficiency rating
-    cop = coil_cooling_dx_single_speed_standard_minimum_cop(coil_cooling_dx_single_speed, true, necb_ref_hp)
+    cop = coil_cooling_dx_single_speed_standard_minimum_cop(coil_cooling_dx_single_speed, true, necb_ref_hp, equipment_type)
 
     # Map the original name to the new name
     sql_db_vars_map[coil_cooling_dx_single_speed.name.to_s] = orig_name

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

@@ -35,13 +35,25 @@ class Standard
     capacity_btu_per_hr = OpenStudio.convert(capacity_w, 'W', 'Btu/hr').get
     capacity_kbtu_per_hr = OpenStudio.convert(capacity_w, 'W', 'kBtu/hr').get
 
+    # Define database
+    if coil_dx_heat_pump?(coil_cooling_dx_two_speed)
+      database = standards_data['heat_pumps']
+    else
+      database = standards_data['unitary_acs']
+    end
+
+    # Additional search criteria
+    if (database[0].keys.include?('equipment_type') || ((template == 'NECB2011') || (template == 'NECB2015') || (template == 'NECB2017') || (template == 'NECB2020') || (template == 'BTAPPRE1980') ||
+      (template == 'BTAP1980TO2010'))) && !coil_dx_heat_pump?(coil_cooling_dx_two_speed)
+      search_criteria['equipment_type'] = 'Air Conditioners'
+    end
+    if database[0].keys.include?('region')
+      search_criteria['region'] = nil # non-nil values are currently used for residential products
+    end
+
     # Lookup efficiencies depending on whether it is a unitary AC or a heat pump
     ac_props = nil
-    ac_props = if coil_dx_heat_pump?(coil_cooling_dx_two_speed)
-                 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
+    ac_props = model_find_object(database, search_criteria, capacity_btu_per_hr, Date.today)
 
     # Check to make sure properties were found
     if ac_props.nil?
@@ -67,6 +79,15 @@ class Standard
       OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilCoolingDXTwoSpeed', "For #{template}: #{coil_cooling_dx_two_speed.name}: #{cooling_type} #{heating_type} #{sub_category} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; SEER = #{min_seer}")
     end
 
+    # If specified as SEER2
+    # TODO: assumed to be the same as SEER for now
+    unless ac_props['minimum_seasonal_energy_efficiency_ratio_2'].nil?
+      min_seer = ac_props['minimum_seasonal_energy_efficiency_ratio_2']
+      cop = seer_to_cop_no_fan(min_seer)
+      new_comp_name = "#{coil_cooling_dx_two_speed.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_seer}SEER"
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilCoolingDXTwoSpeed', "For #{template}: #{coil_cooling_dx_two_speed.name}: #{cooling_type} #{heating_type} #{sub_category} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; SEER = #{min_seer}")
+    end
+
     # If specified as EER
     unless ac_props['minimum_energy_efficiency_ratio'].nil?
       min_eer = ac_props['minimum_energy_efficiency_ratio']
@@ -75,7 +96,24 @@ class Standard
       OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilCoolingDXTwoSpeed', "For #{template}: #{coil_cooling_dx_two_speed.name}: #{cooling_type} #{heating_type} #{sub_category} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; EER = #{min_eer}")
     end
 
-    # if specified as SEER (heat pump)
+    # If specified as EER2
+    # TODO: assumed to be the same as EER for now
+    unless ac_props['minimum_energy_efficiency_ratio_2'].nil?
+      min_eer = ac_props['minimum_energy_efficiency_ratio_2']
+      cop = eer_to_cop_no_fan(min_eer)
+      new_comp_name = "#{coil_cooling_dx_two_speed.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_eer}EER"
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilCoolingDXTwoSpeed', "For #{template}: #{coil_cooling_dx_two_speed.name}: #{cooling_type} #{heating_type} #{sub_category} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; EER = #{min_eer}")
+    end
+
+    # If specific as IEER
+    if !ac_props['minimum_integrated_energy_efficiency_ratio'].nil? && cop.nil?
+      min_ieer = ac_props['minimum_integrated_energy_efficiency_ratio']
+      cop = ieer_to_cop_no_fan(min_ieer)
+      new_comp_name = "#{coil_cooling_dx_two_speed.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_ieer}IEER"
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilCoolingDXTwoSpeed', "For #{template}: #{coil_cooling_dx_two_speed.name}: #{cooling_type} #{heating_type} #{sub_category} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; IEER = #{min_ieer}")
+    end
+
+    # If specified as SEER (heat pump)
     unless ac_props['minimum_seasonal_efficiency'].nil?
       min_seer = ac_props['minimum_seasonal_efficiency']
       cop = seer_to_cop_no_fan(min_seer)
@@ -115,13 +153,26 @@ class Standard
     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 efficiencies data depending on whether it is a unitary AC or a heat pump
+    coil_efficiency_data = if coil_dx_heat_pump?(coil_cooling_dx_two_speed)
+                             standards_data['heat_pumps']
+                           else
+                             standards_data['unitary_acs']
+                           end
+
+    # Additional search criteria
+    if (coil_efficiency_data[0].keys.include?('equipment_type') || ((template == 'NECB2011') || (template == 'NECB2015') || (template == 'NECB2017') || (template == 'NECB2020') || (template == 'BTAPPRE1980') ||
+      (template == 'BTAP1980TO2010'))) && !coil_dx_heat_pump?(coil_cooling_dx_two_speed)
+      search_criteria['equipment_type'] = 'Air Conditioners'
+    end
+    if coil_efficiency_data[0].keys.include?('region')
+      search_criteria['region'] = nil # non-nil values are currently used for residential products
+    end
+
+    # Look up the efficiency characteristics
     # Lookup efficiencies depending on whether it is a unitary AC or a heat pump
     ac_props = nil
-    ac_props = if coil_dx_heat_pump?(coil_cooling_dx_two_speed)
-                 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
+    ac_props = model_find_object(coil_efficiency_data, search_criteria, capacity_btu_per_hr, Date.today)
 
     # Check to make sure properties were found
     if ac_props.nil?
@@ -131,34 +182,60 @@ class Standard
     end
 
     # Make the total COOL-CAP-FT curve
-    tot_cool_cap_ft = model_add_curve(coil_cooling_dx_two_speed.model, ac_props['cool_cap_ft'])
-    if tot_cool_cap_ft
-      coil_cooling_dx_two_speed.setTotalCoolingCapacityFunctionOfTemperatureCurve(tot_cool_cap_ft)
+    cool_cap_ft = nil
+    if ac_props['cool_cap_ft']
+      cool_cap_ft = model_add_curve(coil_cooling_dx_two_speed.model, ac_props['cool_cap_ft'])
+    else
+      cool_cap_ft_curve_name = coil_dx_cap_ft(coil_cooling_dx_two_speed)
+      cool_cap_ft = model_add_curve(coil_cooling_dx_two_speed.model, cool_cap_ft_curve_name)
+    end
+    if cool_cap_ft
+      coil_cooling_dx_two_speed.setTotalCoolingCapacityFunctionOfTemperatureCurve(cool_cap_ft)
+      coil_cooling_dx_two_speed.setLowSpeedTotalCoolingCapacityFunctionOfTemperatureCurve(cool_cap_ft)
     else
       OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXTwoSpeed', "For #{coil_cooling_dx_two_speed.name}, cannot find cool_cap_ft curve, will not be set.")
       successfully_set_all_properties = false
     end
 
     # Make the total COOL-CAP-FFLOW curve
-    tot_cool_cap_fflow = model_add_curve(coil_cooling_dx_two_speed.model, ac_props['cool_cap_fflow'])
-    if tot_cool_cap_fflow
-      coil_cooling_dx_two_speed.setTotalCoolingCapacityFunctionOfFlowFractionCurve(tot_cool_cap_fflow)
+    cool_cap_fflow = nil
+    if ac_props['cool_cap_fflow']
+      cool_cap_fflow = model_add_curve(coil_cooling_dx_two_speed.model, ac_props['cool_cap_fflow'])
+    else
+      cool_cap_fflow_curve_name = coil_dx_cap_fff(coil_cooling_dx_two_speed)
+      cool_cap_fflow = model_add_curve(coil_cooling_dx_two_speed.model, cool_cap_fflow_curve_name)
+    end
+    if cool_cap_fflow
+      coil_cooling_dx_two_speed.setTotalCoolingCapacityFunctionOfFlowFractionCurve(cool_cap_fflow)
     else
       OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXTwoSpeed', "For #{coil_cooling_dx_two_speed.name}, cannot find cool_cap_fflow curve, will not be set.")
       successfully_set_all_properties = false
     end
 
     # Make the COOL-EIR-FT curve
-    cool_eir_ft = model_add_curve(coil_cooling_dx_two_speed.model, ac_props['cool_eir_ft'])
+    cool_eir_ft = nil
+    if ac_props['cool_eir_ft']
+      cool_eir_ft = model_add_curve(coil_cooling_dx_two_speed.model, ac_props['cool_eir_ft'])
+    else
+      cool_eir_ft_curve_name = coil_dx_eir_ft(coil_cooling_dx_two_speed)
+      cool_eir_ft = model_add_curve(coil_cooling_dx_two_speed.model, cool_eir_ft_curve_name)
+    end
     if cool_eir_ft
       coil_cooling_dx_two_speed.setEnergyInputRatioFunctionOfTemperatureCurve(cool_eir_ft)
+      coil_cooling_dx_two_speed.setLowSpeedEnergyInputRatioFunctionOfTemperatureCurve(cool_eir_ft)
     else
       OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXTwoSpeed', "For #{coil_cooling_dx_two_speed.name}, cannot find cool_eir_ft curve, will not be set.")
       successfully_set_all_properties = false
     end
 
     # Make the COOL-EIR-FFLOW curve
-    cool_eir_fflow = model_add_curve(coil_cooling_dx_two_speed.model, ac_props['cool_eir_fflow'])
+    cool_eir_fflow = nil
+    if ac_props['cool_eir_fflow']
+      cool_eir_fflow = model_add_curve(coil_cooling_dx_two_speed.model, ac_props['cool_eir_fflow'])
+    else
+      cool_eir_fflow_curve_name = coil_dx_eir_fff(coil_cooling_dx_two_speed)
+      cool_eir_fflow = model_add_curve(coil_cooling_dx_two_speed.model, cool_eir_fflow_curve_name)
+    end
     if cool_eir_fflow
       coil_cooling_dx_two_speed.setEnergyInputRatioFunctionOfFlowFractionCurve(cool_eir_fflow)
     else
@@ -167,7 +244,13 @@ class Standard
     end
 
     # Make the COOL-PLF-FPLR curve
-    cool_plf_fplr = model_add_curve(coil_cooling_dx_two_speed.model, ac_props['cool_plf_fplr'])
+    cool_plf_fplr = nil
+    if ac_props['cool_plf_fplr']
+      cool_plf_fplr = model_add_curve(coil_cooling_dx_two_speed.model, ac_props['cool_plf_fplr'])
+    else
+      cool_plf_fplr_curve_name = coil_dx_plf_fplr(coil_cooling_dx_two_speed)
+      cool_plf_fplr = model_add_curve(coil_cooling_dx_two_speed.model, cool_plf_fplr_curve_name)
+    end
     if cool_plf_fplr
       coil_cooling_dx_two_speed.setPartLoadFractionCorrelationCurve(cool_plf_fplr)
     else
@@ -175,24 +258,6 @@ class Standard
       successfully_set_all_properties = false
     end
 
-    # Make the low speed COOL-CAP-FT curve
-    low_speed_cool_cap_ft = model_add_curve(coil_cooling_dx_two_speed.model, ac_props['cool_cap_ft'])
-    if low_speed_cool_cap_ft
-      coil_cooling_dx_two_speed.setLowSpeedTotalCoolingCapacityFunctionOfTemperatureCurve(low_speed_cool_cap_ft)
-    else
-      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXTwoSpeed', "For #{coil_cooling_dx_two_speed.name}, cannot find cool_cap_ft curve, will not be set.")
-      successfully_set_all_properties = false
-    end
-
-    # Make the low speed COOL-EIR-FT curve
-    low_speed_cool_eir_ft = model_add_curve(coil_cooling_dx_two_speed.model, ac_props['cool_eir_ft'])
-    if low_speed_cool_eir_ft
-      coil_cooling_dx_two_speed.setLowSpeedEnergyInputRatioFunctionOfTemperatureCurve(low_speed_cool_eir_ft)
-    else
-      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXTwoSpeed', "For #{coil_cooling_dx_two_speed.name}, cannot find cool_eir_ft curve, will not be set.")
-      successfully_set_all_properties = false
-    end
-
     # Preserve the original name
     orig_name = coil_cooling_dx_two_speed.name.to_s
 

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

@@ -42,7 +42,7 @@ class Standard
 
     # Look up the efficiency characteristics
     if computer_room_air_conditioner
-      equipment_type = 'unitary_acs'
+      equipment_type = 'computer_room_acs'
     else
       equipment_type = 'water_source_heat_pumps'
     end

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

@@ -28,11 +28,8 @@ module CoilDX
 
     if coil_dx.airLoopHVAC.empty? && coil_dx.containingZoneHVACComponent.is_initialized
       containing_comp = coil_dx.containingZoneHVACComponent.get
-      # PTAC
-      if containing_comp.to_ZoneHVACPackagedTerminalAirConditioner.is_initialized
-        sub_category = 'PTAC'
       # PTHP
-      elsif containing_comp.to_ZoneHVACPackagedTerminalHeatPump.is_initialized
+      if containing_comp.to_ZoneHVACPackagedTerminalHeatPump.is_initialized
         sub_category = 'PTHP'
       end
       # @todo Add other zone hvac systems
@@ -168,8 +165,9 @@ module CoilDX
   # @param coil_dx [OpenStudio::Model::StraightComponent] coil cooling object, allowable types:
   #   CoilCoolingDXSingleSpeed, CoilCoolingDXTwoSpeed, CoilCoolingDXMultiSpeed
   # @param necb_ref_hp [Boolean] for compatability with NECB ruleset only.
+  # @param equipment_type [Boolean] indicate that equipment_type should be in the search criteria.
   # @return [Hash] has for search criteria to be used for find object
-  def coil_dx_find_search_criteria(coil_dx, necb_ref_hp = false)
+  def coil_dx_find_search_criteria(coil_dx, necb_ref_hp = false, equipment_type = false)
     search_criteria = {}
     search_criteria['template'] = template
 
@@ -204,6 +202,109 @@ module CoilDX
       # @todo Add other unitary systems
     end
 
+    # Get the equipment type
+    if equipment_type && coil_dx.airLoopHVAC.empty? && coil_dx.containingZoneHVACComponent.is_initialized
+      containing_comp = coil_dx.containingZoneHVACComponent.get
+      # PTAC
+      if containing_comp.to_ZoneHVACPackagedTerminalAirConditioner.is_initialized
+        search_criteria['equipment_type'] = 'PTAC'
+        search_criteria['subcategory'] = nil
+        unless (template == 'NECB2011') || (template == 'NECB2015') || (template == 'NECB2017') || (template == 'NECB2020') || (template == 'BTAPPRE1980') ||
+               (template == 'BTAP1980TO2010')
+          search_criteria['heating_type'] = nil
+        end
+      end
+    end
+
     return search_criteria
   end
+
+  # Determine what application to use for looking up the minimum efficiency requirements of PTACs
+  #
+  # @param coil_dx [OpenStudio::Model::StraightComponent] coil cooling object, allowable types:
+  #   CoilCoolingDXSingleSpeed, CoilCoolingDXTwoSpeed, CoilCoolingDXMultiSpeed
+  # @return [String] PTAC application
+  def coil_dx_ptac_application(coil_dx)
+    case template
+    when '90.1-2004', '90.1-2007'
+      return 'New Construction'
+    when '90.1-2010', '90.1-2013', '90.1-2016', '90.1-2019'
+      return 'Standard Size'
+    end
+  end
+
+  # Determine what capacity curve to use to represent the change of the coil's capacity as a function of changes in temperatures
+  #
+  # @param coil_dx [OpenStudio::Model::StraightComponent] coil cooling object, allowable types:
+  #   CoilCoolingDXSingleSpeed, CoilCoolingDXTwoSpeed, CoilCoolingDXMultiSpeed
+  # @param equipment_type [String] Type of equipment
+  # @return [String] PTAC application
+  def coil_dx_cap_ft(coil_dx, equipment_type = 'Air Conditioners')
+    case equipment_type
+    when 'PTAC'
+      return 'PSZ-Fine Storage DX Coil Cap-FT'
+    else
+      return 'CoilClgDXQRatio_fTwbToadbSI'
+    end
+  end
+
+  # Determine what capacity curve to use to represent the change of the coil's capacity as a function of changes in airflow fraction
+  #
+  # @param coil_dx [OpenStudio::Model::StraightComponent] coil cooling object, allowable types:
+  #   CoilCoolingDXSingleSpeed, CoilCoolingDXTwoSpeed, CoilCoolingDXMultiSpeed
+  # @param equipment_type [String] Type of equipment
+  # @return [String] PTAC application
+  def coil_dx_cap_fff(coil_dx, equipment_type = 'Air Conditioners')
+    case equipment_type
+    when 'PTAC'
+      return 'DX Coil Cap-FF'
+    else
+      return 'CoilClgDXSnglQRatio_fCFMRatio'
+    end
+  end
+
+  # Determine what EIR curve to use to represent the change of the coil's EIR as a function of changes in temperatures
+  #
+  # @param coil_dx [OpenStudio::Model::StraightComponent] coil cooling object, allowable types:
+  #   CoilCoolingDXSingleSpeed, CoilCoolingDXTwoSpeed, CoilCoolingDXMultiSpeed
+  # @param equipment_type [String] Type of equipment
+  # @return [String] PTAC application
+  def coil_dx_eir_ft(coil_dx, equipment_type = 'Air Conditioners')
+    case equipment_type
+    when 'PTAC'
+      return 'PSZ-AC DX Coil EIR-FT'
+    else
+      return 'CoilClgDXEIRRatio_fTwbToadbSI'
+    end
+  end
+
+  # Determine what EIR curve to use to represent the change of the coil's EIR as a function of changes in airflow fraction
+  #
+  # @param coil_dx [OpenStudio::Model::StraightComponent] coil cooling object, allowable types:
+  #   CoilCoolingDXSingleSpeed, CoilCoolingDXTwoSpeed, CoilCoolingDXMultiSpeed
+  # @param equipment_type [String] Type of equipment
+  # @return [String] PTAC application
+  def coil_dx_eir_fff(coil_dx, equipment_type = 'Air Conditioners')
+    case equipment_type
+    when 'PTAC'
+      return 'Split DX Coil EIR-FF'
+    else
+      return 'CoilClgDXSnglEIRRatio_fCFMRatio'
+    end
+  end
+
+  # Determine what PLF curve to use to represent the change of the coil's PLR as a function of changes in PLR
+  #
+  # @param coil_dx [OpenStudio::Model::StraightComponent] coil cooling object, allowable types:
+  #   CoilCoolingDXSingleSpeed, CoilCoolingDXTwoSpeed, CoilCoolingDXMultiSpeed
+  # @param equipment_type [String] Type of equipment
+  # @return [String] PTAC application
+  def coil_dx_plf_fplr(coil_dx, equipment_type = 'Air Conditioners')
+    case equipment_type
+    when 'PTAC'
+      return 'HPACCOOLPLFFPLR'
+    else
+      return 'CoilClgDXEIRRatio_fQFrac'
+    end
+  end
 end

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

@@ -55,14 +55,14 @@ class Standard
     htg_stages = coil_heating_gas_multi_stage.stages
     if htg_stages.last.nominalCapacity.is_initialized
       capacity_w = htg_stages.last.nominalCapacity.get
-    elsif (htg_stages.size == 1) && coil_heating_gas_multi_stage.autosizedStage1NominalCapacity.is_initialized
-      capacity_w = coil_heating_gas_multi_stage.autosizedStage1NominalCapacity.get
-    elsif (htg_stages.size == 2) && coil_heating_gas_multi_stage.autosizedStage2NominalCapacity.is_initialized
-      capacity_w = coil_heating_gas_multi_stage.autosizedStage2NominalCapacity.get
-    elsif (htg_stages.size == 3) && coil_heating_gas_multi_stage.autosizedStage3NominalCapacity.is_initialized
-      capacity_w = coil_heating_gas_multi_stage.autosizedStage3NominalCapacity.get
-    elsif (htg_stages.size == 4) && coil_heating_gas_multi_stage.autosizedStage4NominalCapacity.is_initialized
-      capacity_w = coil_heating_gas_multi_stage.autosizedStage4NominalCapacity.get
+    elsif (htg_stages.size == 1) && coil_heating_gas_multi_stage.stages[0].autosizedNominalCapacity.is_initialized
+      capacity_w = coil_heating_gas_multi_stage.stages[0].autosizedNominalCapacity.get
+    elsif (htg_stages.size == 2) && coil_heating_gas_multi_stage.stages[1].autosizedNominalCapacity.is_initialized
+      capacity_w = coil_heating_gas_multi_stage.stages[1].autosizedNominalCapacity.get
+    elsif (htg_stages.size == 3) && coil_heating_gas_multi_stage.stages[2].autosizedNominalCapacity.is_initialized
+      capacity_w = coil_heating_gas_multi_stage.stages[2].autosizedNominalCapacity.get
+    elsif (htg_stages.size == 4) && coil_heating_gas_multi_stage.stages[3].autosizedNominalCapacity.is_initialized
+      capacity_w = coil_heating_gas_multi_stage.stages[3].autosizedNominalCapacity.get
     else
       OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{coil_heating_gas_multi_stage.name} capacity is not available, cannot apply efficiency standard.")
       successfully_set_all_properties = false