openstudio-standards 0.1.4 → 0.1.5

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

@@ -1,11 +1,9 @@
 
 # open the class to add methods to return sizing values
 class OpenStudio::Model::CoilHeatingDXMultiSpeed
-
-  def setStandardEfficiencyAndCurves(template, standards, sql_db_vars_map)
-
+  def apply_efficiency_and_curves(template, standards, sql_db_vars_map)
     successfully_set_all_properties = true
-  
+
     heat_pumps = standards['heat_pumps_heating']
 
     # Define the criteria to find the unitary properties
@@ -16,30 +14,30 @@ class OpenStudio::Model::CoilHeatingDXMultiSpeed
     # Determine supplemental heating type if unitary
     heat_pump = false
     suppl_heating_type = nil
-    if self.airLoopHVAC.empty?
-      if self.containingHVACComponent.is_initialized
+    if airLoopHVAC.empty?
+      if containingHVACComponent.is_initialized
         containing_comp = containingHVACComponent.get
         if containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed.is_initialized
           heat_pump = true
           htg_coil = containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed.get.supplementalHeatingCoil
-          if htg_coil.to_CoilHeatingElectric.is_initialized
-            suppl_heating_type = 'Electric Resistance or None'
-          else
-            suppl_heating_type = 'All Other'
-          end
-        end # TODO Add other unitary systems
+          suppl_heating_type = if htg_coil.to_CoilHeatingElectric.is_initialized
+                                 'Electric Resistance or None'
+                               else
+                                 'All Other'
+                               end
+        end # TODO: Add other unitary systems
       end
     end
 
-    # TODO Standards - add split system vs single package to model
+    # TODO: Standards - add split system vs single package to model
     # For now, assume single package
     subcategory = 'Single Package'
     search_criteria['subcategory'] = subcategory
 
     # Get the coil capacity
     clg_capacity = nil
-    if(heat_pump == true)
-      containing_comp = self.containingHVACComponent.get
+    if heat_pump == true
+      containing_comp = containingHVACComponent.get
       heat_pump_comp = containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed.get
       ccoil = heat_pump_comp.coolingCoil
       dxcoil = ccoil.to_CoilCoolingDXMultiSpeed.get
@@ -55,129 +53,129 @@ class OpenStudio::Model::CoilHeatingDXMultiSpeed
       elsif dxcoil.autosizedSpeed4GrossRatedTotalCoolingCapacity.is_initialized
         clg_capacity = dxcoil.autosizedSpeed4GrossRatedTotalCoolingCapacity.get
       else
-        OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXMultiSpeed', "For #{self.name} capacity is not available, cannot apply efficiency standard.")
+        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXMultiSpeed', "For #{name} capacity is not available, cannot apply efficiency standard.")
         successfully_set_all_properties = false
-        return successfully_set_all_properties  
+        return successfully_set_all_properties
       end
       dxcoil.setName(dxcoil_name)
     end
 
     # Convert capacity to Btu/hr
-    capacity_btu_per_hr = OpenStudio.convert(clg_capacity, "W", "Btu/hr").get
-    capacity_kbtu_per_hr = OpenStudio.convert(clg_capacity, "W", "kBtu/hr").get
+    capacity_btu_per_hr = OpenStudio.convert(clg_capacity, 'W', 'Btu/hr').get
+    capacity_kbtu_per_hr = OpenStudio.convert(clg_capacity, 'W', 'kBtu/hr').get
 
     # Lookup efficiencies depending on whether it is a unitary AC or a heat pump
-    hp_props = self.model.find_object(heat_pumps, search_criteria, capacity_btu_per_hr)
+    hp_props = model.find_object(heat_pumps, search_criteria, capacity_btu_per_hr, Date.today)
 
     # Check to make sure properties were found
     if hp_props.nil?
-      OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXMultipeed', "For #{self.name}, cannot find efficiency info, cannot apply efficiency standard.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXMultipeed', "For #{name}, cannot find efficiency info, cannot apply efficiency standard.")
       successfully_set_all_properties = false
       return successfully_set_all_properties
     end
 
     # Make the HEAT-CAP-FT curve
-    htg_stages = self.stages
-    heat_cap_ft = self.model.add_curve(hp_props["heat_cap_ft"], standards)
+    htg_stages = stages
+    heat_cap_ft = model.add_curve(hp_props['heat_cap_ft'], standards)
     if heat_cap_ft
-      htg_stages.each do |istage| 
+      htg_stages.each do |istage|
         istage.setHeatingCapacityFunctionofTemperatureCurve(heat_cap_ft)
       end
     else
-      OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXMultiSpeed', "For #{self.name}, cannot find heat_cap_ft curve, will not be set.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXMultiSpeed', "For #{name}, cannot find heat_cap_ft curve, will not be set.")
       successfully_set_all_properties = false
     end
 
     # Make the HEAT-CAP-FFLOW curve
-    heat_cap_fflow = self.model.add_curve(hp_props["heat_cap_fflow"], standards)
+    heat_cap_fflow = model.add_curve(hp_props['heat_cap_fflow'], standards)
     if heat_cap_fflow
       htg_stages.each do |istage|
-          istage.setHeatingCapacityFunctionofFlowFractionCurve(heat_cap_fflow) 
+        istage.setHeatingCapacityFunctionofFlowFractionCurve(heat_cap_fflow)
       end
     else
-      OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXMultiSpeed', "For #{self.name}, cannot find heat_cap_fflow curve, will not be set.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXMultiSpeed', "For #{name}, cannot find heat_cap_fflow curve, will not be set.")
       successfully_set_all_properties = false
     end
-    
+
     # Make the HEAT-EIR-FT curve
-    heat_eir_ft = self.model.add_curve(hp_props["heat_eir_ft"], standards)
+    heat_eir_ft = model.add_curve(hp_props['heat_eir_ft'], standards)
     if heat_eir_ft
       htg_stages.each do |istage|
         istage.setEnergyInputRatioFunctionofTemperatureCurve(heat_eir_ft)
       end
     else
-      OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXMultiSpeed', "For #{self.name}, cannot find heat_eir_ft curve, will not be set.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXMultiSpeed', "For #{name}, cannot find heat_eir_ft curve, will not be set.")
       successfully_set_all_properties = false
     end
 
     # Make the HEAT-EIR-FFLOW curve
-    heat_eir_fflow = self.model.add_curve(hp_props["heat_eir_fflow"], standards)
+    heat_eir_fflow = model.add_curve(hp_props['heat_eir_fflow'], standards)
     if heat_eir_fflow
       htg_stages.each do |istage|
         istage.setEnergyInputRatioFunctionofFlowFractionCurve(heat_eir_fflow)
       end
     else
-      OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXMultiSpeed', "For #{self.name}, cannot find heat_eir_fflow curve, will not be set.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXMultiSpeed', "For #{name}, cannot find heat_eir_fflow curve, will not be set.")
       successfully_set_all_properties = false
     end
-    
+
     # Make the HEAT-PLF-FPLR curve
-    heat_plf_fplr = self.model.add_curve(hp_props["heat_plf_fplr"], standards)
+    heat_plf_fplr = model.add_curve(hp_props['heat_plf_fplr'], standards)
     if heat_plf_fplr
       htg_stages.each do |istage|
         istage.setPartLoadFractionCorrelationCurve(heat_plf_fplr)
       end
     else
-      OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXMultiSpeed', "For #{self.name}, cannot find heat_plf_fplr curve, will not be set.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXMultiSpeed', "For #{name}, cannot find heat_plf_fplr curve, will not be set.")
       successfully_set_all_properties = false
-    end 
-    
+    end
+
     # For NECB the heat pump needs only one stage
     htg_capacity = nil
-    flow_rate4 = nil    
-    if(template == 'NECB 2011')
-      htg_stages = self.stages
+    flow_rate4 = nil
+    if template == 'NECB 2011'
+      htg_stages = stages
       if htg_stages.last.grossRatedHeatingCapacity.is_initialized
         htg_capacity = htg_stages.last.grossRatedHeatingCapacity.get
-      elsif self.autosizedSpeed4GrossRatedHeatingCapacity.is_initialized
-        htg_capacity = self.autosizedSpeed4GrossRatedHeatingCapacity.get
+      elsif autosizedSpeed4GrossRatedHeatingCapacity.is_initialized
+        htg_capacity = autosizedSpeed4GrossRatedHeatingCapacity.get
       else
-        OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXMultiSpeed', "For #{self.name} capacity is not available, cannot apply efficiency standard.")
+        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXMultiSpeed', "For #{name} capacity is not available, cannot apply efficiency standard.")
         successfully_set_all_properties = false
         return successfully_set_all_properties
-      end   
+      end
       if htg_stages.last.ratedAirFlowRate.is_initialized
         flow_rate4 = htg_stages.last.ratedAirFlowRate.get
-      elsif self.autosizedSpeed4RatedAirFlowRate.is_initialized
-        flow_rate4 = self.autosizedSpeed4RatedAirFlowRate.get
+      elsif autosizedSpeed4RatedAirFlowRate.is_initialized
+        flow_rate4 = autosizedSpeed4RatedAirFlowRate.get
       else
-        OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXMultiSpeed', "For #{self.name} capacity is not available, cannot apply efficiency standard.")
+        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXMultiSpeed', "For #{name} capacity is not available, cannot apply efficiency standard.")
         successfully_set_all_properties = false
         return successfully_set_all_properties
-      end   
+      end
     end
-    
+
     # Convert capacity to Btu/hr
-    capacity_btu_per_hr = OpenStudio.convert(htg_capacity, "W", "Btu/hr").get
-    capacity_kbtu_per_hr = OpenStudio.convert(htg_capacity, "W", "kBtu/hr").get
+    capacity_btu_per_hr = OpenStudio.convert(htg_capacity, 'W', 'Btu/hr').get
+    capacity_kbtu_per_hr = OpenStudio.convert(htg_capacity, 'W', 'kBtu/hr').get
 
     # Get the minimum efficiency standards
     cop = nil
-    
+
     # If specified as SEER
     unless hp_props['minimum_seasonal_energy_efficiency_ratio'].nil?
       min_seer = hp_props['minimum_seasonal_energy_efficiency_ratio']
       cop = seer_to_cop(min_seer)
-      self.setName("#{self.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_seer}SEER")
-      OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.CoilHeatingDXMultiSpeed',  "For #{template}: #{self.name}: #{suppl_heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; SEER = #{min_seer}")
+      setName("#{name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_seer}SEER")
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilHeatingDXMultiSpeed', "For #{template}: #{name}: #{suppl_heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; SEER = #{min_seer}")
     end
-    
+
     # If specified as EER
     unless hp_props['minimum_energy_efficiency_ratio'].nil?
       min_eer = hp_props['minimum_energy_efficiency_ratio']
       cop = eer_to_cop(min_eer)
-      self.setName("#{self.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_eer}EER")
-      OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.CoilHeatingDXMultiSpeed', "For #{template}: #{self.name}:  #{suppl_heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; EER = #{min_eer}")
+      setName("#{name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_eer}EER")
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilHeatingDXMultiSpeed', "For #{template}: #{name}:  #{suppl_heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; EER = #{min_eer}")
     end
 
     # Set the efficiency values
@@ -186,7 +184,5 @@ class OpenStudio::Model::CoilHeatingDXMultiSpeed
         istage.setGrossRatedHeatingCOP(cop)
       end
     end
-
   end
-
 end

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

@@ -1,48 +1,43 @@
 
 # open the class to add methods to return sizing values
 class OpenStudio::Model::CoilHeatingDXSingleSpeed
-
   # Finds the search criteria
   #
   # @param template [String] valid choices: 'DOE Ref Pre-1980', 'DOE Ref 1980-2004', '90.1-2004', '90.1-2007', '90.1-2010', '90.1-2013'
   # @return [hash] has for search criteria to be used for find object
   def find_search_criteria(template)
-
     # Define the criteria to find the chiller properties
     # in the hvac standards data set.
     search_criteria = {}
     search_criteria['template'] = template
 
-    # TODO Standards - add split system vs single package to model
+    # TODO: Standards - add split system vs single package to model
     # For now, assume single package
     subcategory = 'Single Package'
     search_criteria['subcategory'] = subcategory
 
     return search_criteria
-
   end
 
   # Finds capacity in Btu/hr
   #
   # @return [Double] capacity in Btu/hr to be used for find object
-  def find_capacity()
-
+  def find_capacity
     # Get the coil capacity
     capacity_w = nil
-    if self.ratedTotalHeatingCapacity.is_initialized
-      capacity_w = self.ratedTotalHeatingCapacity.get
-    elsif self.autosizedRatedTotalHeatingCapacity.is_initialized
-      capacity_w = self.autosizedRatedTotalHeatingCapacity.get
+    if ratedTotalHeatingCapacity.is_initialized
+      capacity_w = ratedTotalHeatingCapacity.get
+    elsif autosizedRatedTotalHeatingCapacity.is_initialized
+      capacity_w = autosizedRatedTotalHeatingCapacity.get
     else
-      OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{self.name} capacity is not available, cannot apply efficiency standard.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{name} capacity is not available, cannot apply efficiency standard.")
       return false
     end
 
     # Convert capacity to Btu/hr
-    capacity_btu_per_hr = OpenStudio.convert(capacity_w, "W", "Btu/hr").get
+    capacity_btu_per_hr = OpenStudio.convert(capacity_w, 'W', 'Btu/hr').get
 
     return capacity_btu_per_hr
-
   end
 
   # Finds lookup object in standards and return efficiency
@@ -50,18 +45,17 @@ class OpenStudio::Model::CoilHeatingDXSingleSpeed
   # @param template [String] valid choices: 'DOE Ref Pre-1980', 'DOE Ref 1980-2004', '90.1-2004', '90.1-2007', '90.1-2010', '90.1-2013'
   # @param standards [Hash] the OpenStudio_Standards spreadsheet in hash format
   # @return [Double] full load efficiency (COP)
-  def standard_minimum_cop(template,standards)
-
+  def standard_minimum_cop(template, standards)
     # find ac properties
-    search_criteria = self.find_search_criteria(template)
-    subcategory = search_criteria["subcategory"]
-    capacity_btu_per_hr = self.find_capacity
-    capacity_kbtu_per_hr = OpenStudio.convert(capacity_btu_per_hr, "Btu/hr", "kBtu/hr").get
+    search_criteria = find_search_criteria(template)
+    subcategory = search_criteria['subcategory']
+    capacity_btu_per_hr = find_capacity
+    capacity_kbtu_per_hr = OpenStudio.convert(capacity_btu_per_hr, 'Btu/hr', 'kBtu/hr').get
 
     # Determine supplemental heating type if unitary
     heat_pump = false
-    if self.airLoopHVAC.empty?
-      if self.containingHVACComponent.is_initialized
+    if airLoopHVAC.empty?
+      if containingHVACComponent.is_initialized
         containing_comp = containingHVACComponent.get
         if containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAir.is_initialized
           heat_pump = true
@@ -70,118 +64,124 @@ class OpenStudio::Model::CoilHeatingDXSingleSpeed
     end
 
     # find object
-    ac_props = nil
-    if heat_pump == true
-      ac_props = self.model.find_object(standards['heat_pumps_heating'], search_criteria, capacity_btu_per_hr)
-    else
-      ac_props = self.model.find_object(standards['heat_pumps'], search_criteria, capacity_btu_per_hr)
-    end
+    ac_props = model.find_object(standards['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 #{self.name}, cannot find efficiency info, cannot apply efficiency standard.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{name}, cannot find efficiency info, cannot apply efficiency standard.")
       return cop # value of nil
     end
 
-    # If specified as SEER
-    unless ac_props['minimum_seasonal_energy_efficiency_ratio'].nil?
-      min_seer = ac_props['minimum_seasonal_energy_efficiency_ratio']
-      cop = seer_to_cop(min_seer)
-      OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.CoilHeatingDXSingleSpeed',  "For #{template}: #{self.name}: #{suppl_heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; SEER = #{min_seer}")
+    # If specified as HSPF
+    unless ac_props['minimum_heating_seasonal_performance_factor'].nil?
+      min_hspf = ac_props['minimum_heating_seasonal_performance_factor']
+      cop = hspf_to_cop_heating_no_fan(min_hspf)
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{template}: #{name}: #{suppl_heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; HSPF = #{min_hspf}")
+    end
+
+    # If specified as COPH
+    unless ac_props['minimum_coefficient_of_performance_heating'].nil?
+      min_coph = ac_props['minimum_coefficient_of_performance_heating']
+      cop = cop_heating_to_cop_heating_no_fan(min_coph, OpenStudio.convert(capacity_kbtu_per_hr, 'kBtu/hr', 'W').get)
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{template}: #{name}: #{suppl_heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; COPH = #{min_coph}")
     end
 
     # If specified as EER
     unless ac_props['minimum_energy_efficiency_ratio'].nil?
       min_eer = ac_props['minimum_energy_efficiency_ratio']
-      cop = eer_to_cop(min_eer)
-      OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{template}: #{self.name}:  #{suppl_heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; EER = #{min_eer}")
+      cop = eer_to_cop(min_eer, OpenStudio.convert(capacity_kbtu_per_hr, 'kBtu/hr', 'W').get)
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{template}: #{name}:  #{suppl_heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; EER = #{min_eer}")
     end
 
     return cop
-
   end
 
-  def setStandardEfficiencyAndCurves(template, sql_db_vars_map)
-
+  def apply_efficiency_and_curves(template, sql_db_vars_map)
     successfully_set_all_properties = true
-  
+
     unitary_hps = $os_standards['heat_pumps']
     heat_pumps = $os_standards['heat_pumps_heating']
- 
+
     # Define the criteria to find the unitary properties
     # in the hvac standards data set.
     search_criteria = {}
     search_criteria['template'] = template
 
-    # TODO Standards - add split system vs single package to model
+    # TODO: Standards - add split system vs single package to model
     # For now, assume single package
     subcategory = 'Single Package'
-    search_criteria['subcategory'] = subcategory
+
+    # Assume they are all aircooled for now
+    search_criteria['cooling_type'] = 'AirCooled'
 
     # Determine supplemental heating type if unitary
-    heat_pump = false
+    unitary = false
     suppl_heating_type = nil
-    if self.airLoopHVAC.empty?
-      if self.containingHVACComponent.is_initialized
+    if airLoopHVAC.empty?
+      if containingHVACComponent.is_initialized
         containing_comp = containingHVACComponent.get
         if containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAir.is_initialized
-          heat_pump = true
+          unitary = true
           htg_coil = containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAir.get.supplementalHeatingCoil
-          if htg_coil.to_CoilHeatingElectric.is_initialized
-            suppl_heating_type = 'Electric Resistance or None'
-          else
-            suppl_heating_type = 'All Other'
-          end
-        end # TODO Add other unitary systems
-      elsif self.containingZoneHVACComponent.is_initialized
-        containing_comp = self.containingZoneHVACComponent.get
+          suppl_heating_type = if htg_coil.to_CoilHeatingElectric.is_initialized
+                                 'Electric Resistance or None'
+                               else
+                                 'All Other'
+                               end
+        end # TODO: Add other unitary systems
+      elsif containingZoneHVACComponent.is_initialized
+        containing_comp = containingZoneHVACComponent.get
         # PTHP
         if containing_comp.to_ZoneHVACPackagedTerminalHeatPump.is_initialized
           pthp = containing_comp.to_ZoneHVACPackagedTerminalHeatPump.get
-          #heat_pump = true?
-          # Todo: Should we implement a subcategory for PTHP like there is one for PTAC?
-          # Because for PTHP the COP has two coefficients two (eg 90.1-2007: COP = 3.2 - 0.000026*Cap)
           subcategory = 'PTHP'
           htg_coil = containing_comp.to_ZoneHVACPackagedTerminalHeatPump.get.supplementalHeatingCoil
-          if htg_coil.to_CoilHeatingElectric.is_initialized
-            suppl_heating_type = 'Electric Resistance or None'
-          else
-            suppl_heating_type = 'All Other'
-          end
+          suppl_heating_type = if htg_coil.to_CoilHeatingElectric.is_initialized
+                                 'Electric Resistance or None'
+                               else
+                                 'All Other'
+                               end
         end
       end
     end
 
+    # Add the subcategory to the search criteria
+    search_criteria['subcategory'] = subcategory
+
     # Determine the supplemental heating type if on an airloop
-    if self.airLoopHVAC.is_initialized
-      air_loop = self.airLoopHVAC.get
-      if air_loop.supplyComponents('Coil:Heating:Electric'.to_IddObjectType).size > 0
-        suppl_heating_type = 'Electric Resistance or None'
-      elsif air_loop.supplyComponents('Coil:Heating:Gas'.to_IddObjectType).size > 0
-        suppl_heating_type = 'All Other'
-      elsif air_loop.supplyComponents('Coil:Heating:Water'.to_IddObjectType).size > 0
-        suppl_heating_type = 'All Other'
-      elsif air_loop.supplyComponents('Coil:Heating:DX:SingleSpeed'.to_IddObjectType).size > 0
-        suppl_heating_type = 'All Other'
-      elsif air_loop.supplyComponents('Coil:Heating:Gas:MultiStage'.to_IddObjectType).size > 0
-        suppl_heating_type = 'All Other'
-      elsif air_loop.supplyComponents('Coil:Heating:Desuperheater'.to_IddObjectType).size > 0
-        suppl_heating_type = 'All Other'
-      elsif air_loop.supplyComponents('Coil:Heating:WaterToAirHeatPump:EquationFit'.to_IddObjectType).size > 0
-        suppl_heating_type = 'All Other'  
-      else
-        suppl_heating_type = 'Electric Resistance or None'
-      end
+    if airLoopHVAC.is_initialized
+      air_loop = airLoopHVAC.get
+      suppl_heating_type = if !air_loop.supplyComponents('OS:Coil:Heating:Electric'.to_IddObjectType).empty?
+                             'Electric Resistance or None'
+                           elsif !air_loop.supplyComponents('OS:Coil:Heating:Gas'.to_IddObjectType).empty?
+                             'All Other'
+                           elsif !air_loop.supplyComponents('OS:Coil:Heating:Water'.to_IddObjectType).empty?
+                             'All Other'
+                           elsif !air_loop.supplyComponents('OS:Coil:Heating:DX:SingleSpeed'.to_IddObjectType).empty?
+                             'All Other'
+                           elsif !air_loop.supplyComponents('OS:Coil:Heating:Gas:MultiStage'.to_IddObjectType).empty?
+                             'All Other'
+                           elsif !air_loop.supplyComponents('OS:Coil:Heating:Desuperheater'.to_IddObjectType).empty?
+                             'All Other'
+                           elsif !air_loop.supplyComponents('OS:Coil:Heating:WaterToAirHeatPump:EquationFit'.to_IddObjectType).empty?
+                             'All Other'
+                           else
+                             'Electric Resistance or None'
+                           end
     end
 
+    # Add the heating type to the search criteria
+    unless suppl_heating_type.nil?
+      search_criteria['heating_type'] = suppl_heating_type
+    end
 
     # Get the coil capacity
     capacity_w = nil
-    if(heat_pump == true)
-      containing_comp = self.containingHVACComponent.get
+    if unitary
+      containing_comp = containingHVACComponent.get
       heat_pump_comp = containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAir.get
       ccoil = heat_pump_comp.coolingCoil
       dxcoil = ccoil.to_CoilCoolingDXSingleSpeed.get
@@ -196,141 +196,131 @@ class OpenStudio::Model::CoilHeatingDXSingleSpeed
       elsif dxcoil.autosizedRatedTotalCoolingCapacity.is_initialized
         capacity_w = dxcoil.autosizedRatedTotalCoolingCapacity.get
       else
-        OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{self.name} capacity is not available, cannot apply efficiency standard.")
+        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{name} capacity is not available, cannot apply efficiency standard.")
         successfully_set_all_properties = false
-        return successfully_set_all_properties  
+        return successfully_set_all_properties
       end
       dxcoil.setName(dxcoil_name)
     else
-      if self.ratedTotalHeatingCapacity.is_initialized
-        capacity_w = self.ratedTotalHeatingCapacity.get
-      elsif self.autosizedRatedTotalHeatingCapacity.is_initialized
-        capacity_w = self.autosizedRatedTotalHeatingCapacity.get
+      if ratedTotalHeatingCapacity.is_initialized
+        capacity_w = ratedTotalHeatingCapacity.get
+      elsif autosizedRatedTotalHeatingCapacity.is_initialized
+        capacity_w = autosizedRatedTotalHeatingCapacity.get
       else
-        OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{self.name} capacity is not available, cannot apply efficiency standard.")
+        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{name} capacity is not available, cannot apply efficiency standard.")
         successfully_set_all_properties = false
         return successfully_set_all_properties
-      end    
+      end
     end
 
     # Convert capacity to Btu/hr
-    capacity_btu_per_hr = OpenStudio.convert(capacity_w, "W", "Btu/hr").get
-    capacity_kbtu_per_hr = OpenStudio.convert(capacity_w, "W", "kBtu/hr").get
+    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
+    # Lookup efficiencies depending on whether it is a unitary HP or a heat pump
     ac_props = nil
-    if heat_pump == true
-      ac_props = self.model.find_object(heat_pumps, search_criteria, capacity_btu_per_hr)
-    else
-      ac_props = self.model.find_object(unitary_hps, search_criteria, capacity_btu_per_hr)
-    end
-
-    # TODO: REMOVE THIS, TEMPORARY HACK ONLY
-    if subcategory == 'PTHP'
-      case template
-        when '90.1-2007'
-          pthp_cop_coeff_1 = 3.2
-          pthp_cop_coeff_2 = -0.000026
-        when '90.1-2010'
-          # As of 10/08/2012
-          pthp_cop_coeff_1 = 3.7
-          pthp_cop_coeff_2 = -0.000052
-      end
-
-      # TABLE 6.8.1D
-      # COP = pthp_cop_coeff_1 + pthp_cop_coeff_2 * Cap
-      # Note c: Cap means the rated cooling capacity of the product in Btu/h.
-      # If the unit’s capacity is less than 7000 Btu/h, use 7000 Btu/h in the calculation.
-      # If the unit’s capacity is greater than 15,000 Btu/h, use 15,000 Btu/h in the calculation.
-      capacity_btu_per_hr = 7000 if capacity_btu_per_hr < 7000
-      capacity_btu_per_hr = 15000 if capacity_btu_per_hr > 15000
-      pthp_cop = pthp_cop_coeff_1 + (pthp_cop_coeff_2 * capacity_btu_per_hr)
-      new_comp_name = "#{self.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{pthp_cop.round(1)}COP"
-      self.setName(new_comp_name)
-      self.setRatedCOP(pthp_cop)
-      OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.CoilHeatingDXSingleSpeed',  "HACK: For #{template}: #{self.name}: #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr #{pthp_cop.round(2)}COP")
-    end
-    # TODO: END OF REMOVE THIS TEMPORARY HACK ONLY
+    ac_props = if unitary == true
+                 model.find_object(unitary_hps, search_criteria, capacity_btu_per_hr, Date.today)
+               else
+                 model.find_object(heat_pumps, search_criteria, capacity_btu_per_hr, Date.today)
+               end
 
     # Check to make sure properties were found
     if ac_props.nil?
-      OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{self.name}, cannot find efficiency info, cannot apply efficiency standard.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{name}, cannot find efficiency info, cannot apply efficiency standard.")
       successfully_set_all_properties = false
       return successfully_set_all_properties
     end
 
     # Make the HEAT-CAP-FT curve
-    heat_cap_ft = self.model.add_curve(ac_props["heat_cap_ft"])
+    heat_cap_ft = model.add_curve(ac_props['heat_cap_ft'])
     if heat_cap_ft
-      self.setTotalHeatingCapacityFunctionofTemperatureCurve(heat_cap_ft)
+      setTotalHeatingCapacityFunctionofTemperatureCurve(heat_cap_ft)
     else
-      OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{self.name}, cannot find heat_cap_ft curve, will not be set.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{name}, cannot find heat_cap_ft curve, will not be set.")
       successfully_set_all_properties = false
     end
 
     # Make the HEAT-CAP-FFLOW curve
-    heat_cap_fflow = self.model.add_curve(ac_props["heat_cap_fflow"])
+    heat_cap_fflow = model.add_curve(ac_props['heat_cap_fflow'])
     if heat_cap_fflow
-      self.setTotalHeatingCapacityFunctionofFlowFractionCurve(heat_cap_fflow)
+      setTotalHeatingCapacityFunctionofFlowFractionCurve(heat_cap_fflow)
     else
-      OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{self.name}, cannot find heat_cap_fflow curve, will not be set.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{name}, cannot find heat_cap_fflow curve, will not be set.")
       successfully_set_all_properties = false
     end
-    
+
     # Make the HEAT-EIR-FT curve
-    heat_eir_ft = self.model.add_curve(ac_props["heat_eir_ft"])
+    heat_eir_ft = model.add_curve(ac_props['heat_eir_ft'])
     if heat_eir_ft
-      self.setEnergyInputRatioFunctionofTemperatureCurve(heat_eir_ft)  
+      setEnergyInputRatioFunctionofTemperatureCurve(heat_eir_ft)
     else
-      OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{self.name}, cannot find heat_eir_ft curve, will not be set.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{name}, cannot find heat_eir_ft curve, will not be set.")
       successfully_set_all_properties = false
     end
 
     # Make the HEAT-EIR-FFLOW curve
-    heat_eir_fflow = self.model.add_curve(ac_props["heat_eir_fflow"])
+    heat_eir_fflow = model.add_curve(ac_props['heat_eir_fflow'])
     if heat_eir_fflow
-      self.setEnergyInputRatioFunctionofFlowFractionCurve(heat_eir_fflow)
+      setEnergyInputRatioFunctionofFlowFractionCurve(heat_eir_fflow)
     else
-      OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{self.name}, cannot find heat_eir_fflow curve, will not be set.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{name}, cannot find heat_eir_fflow curve, will not be set.")
       successfully_set_all_properties = false
     end
-    
+
     # Make the HEAT-PLF-FPLR curve
-    heat_plf_fplr = self.model.add_curve(ac_props["heat_plf_fplr"])
+    heat_plf_fplr = model.add_curve(ac_props['heat_plf_fplr'])
     if heat_plf_fplr
-      self.setPartLoadFractionCorrelationCurve(heat_plf_fplr)
+      setPartLoadFractionCorrelationCurve(heat_plf_fplr)
     else
-      OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{self.name}, cannot find heat_plf_fplr curve, will not be set.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{name}, cannot find heat_plf_fplr curve, will not be set.")
       successfully_set_all_properties = false
-    end 
- 
+    end
+
     # Get the minimum efficiency standards
     cop = nil
-    
-    # If specified as SEER
-    unless ac_props['minimum_seasonal_energy_efficiency_ratio'].nil?
-      min_seer = ac_props['minimum_seasonal_energy_efficiency_ratio']
-      cop = seer_to_cop(min_seer)
-      self.setName("#{self.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_seer}SEER")
-      OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.CoilHeatingDXSingleSpeed',  "For #{template}: #{self.name}: #{suppl_heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; SEER = #{min_seer}")
+
+    # If PTHP, use equations
+    if subcategory == 'PTHP'
+      pthp_cop_coeff_1 = ac_props['pthp_cop_coefficient_1']
+      pthp_cop_coeff_2 = ac_props['pthp_cop_coefficient_2']
+      # TABLE 6.8.1D
+      # COP = pthp_cop_coeff_1 - (pthp_cop_coeff_2 * Cap / 1000)
+      # Note c: Cap means the rated cooling capacity of the product in Btu/h.
+      # If the unit's capacity is less than 7000 Btu/h, use 7000 Btu/h in the calculation.
+      # If the unit's capacity is greater than 15,000 Btu/h, use 15,000 Btu/h in the calculation.
+      capacity_btu_per_hr = 7000 if capacity_btu_per_hr < 7000
+      capacity_btu_per_hr = 15_000 if capacity_btu_per_hr > 15_000
+      cop = pthp_cop_coeff_1 - (pthp_cop_coeff_2 * capacity_btu_per_hr / 1000.0)
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{name}: #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; COPH = #{cop.round(2)}")
+    end
+
+    # If specified as HSPF
+    unless ac_props['minimum_heating_seasonal_performance_factor'].nil?
+      min_hspf = ac_props['minimum_heating_seasonal_performance_factor']
+      cop = hspf_to_cop_heating_no_fan(min_hspf)
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{template}: #{name}: #{suppl_heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; HSPF = #{min_hspf}")
     end
-    
+
+    # If specified as COPH
+    unless ac_props['minimum_coefficient_of_performance_heating'].nil?
+      min_coph = ac_props['minimum_coefficient_of_performance_heating']
+      cop = cop_heating_to_cop_heating_no_fan(min_coph, OpenStudio.convert(capacity_kbtu_per_hr, 'kBtu/hr', 'W').get)
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{template}: #{name}: #{suppl_heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; COPH = #{min_coph}")
+    end
+
     # If specified as EER
     unless ac_props['minimum_energy_efficiency_ratio'].nil?
       min_eer = ac_props['minimum_energy_efficiency_ratio']
-      cop = eer_to_cop(min_eer)
-      self.setName("#{self.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_eer}EER")
-      OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{template}: #{self.name}:  #{suppl_heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; EER = #{min_eer}")
+      cop = eer_to_cop(min_eer, OpenStudio.convert(capacity_kbtu_per_hr, 'kBtu/hr', 'W').get)
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{template}: #{name}:  #{suppl_heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; EER = #{min_eer}")
     end
 
-
     # Set the efficiency values
     unless cop.nil?
-      self.setRatedCOP(cop)
+      setRatedCOP(cop)
     end
 
     return sql_db_vars_map
-
   end
-
 end