openstudio-standards 0.2.12.rc4 → 0.2.12.rc5

data/lib/openstudio-standards/standards/necb/NECB2011/hvac_system_3_and_8_single_speed.rb

@@ -1,5 +1,29 @@
 class NECB2011
 
+  def add_sys3and8_single_zone_packaged_rooftop_unit_with_baseboard_heating(model:,
+                                                                            zones:,
+                                                                            heating_coil_type:,
+                                                                            baseboard_type:,
+                                                                            hw_loop:,
+                                                                            new_auto_zoner: true,
+                                                                            multispeed: false)
+    if multispeed
+      add_sys3and8_single_zone_packaged_rooftop_unit_with_baseboard_heating_multi_speed(model: model,
+                                                                                         zones: zones,
+                                                                                         heating_coil_type: heating_coil_type,
+                                                                                         baseboard_type: baseboard_type,
+                                                                                         hw_loop: hw_loop,
+                                                                                         new_auto_zoner: new_auto_zoner)
+    else
+      add_sys3and8_single_zone_packaged_rooftop_unit_with_baseboard_heating_single_speed(model: model,
+                                                                                        zones: zones,
+                                                                                        heating_coil_type: heating_coil_type,
+                                                                                        baseboard_type: baseboard_type,
+                                                                                        hw_loop: hw_loop,
+                                                                                        new_auto_zoner: new_auto_zoner)
+    end
+  end
+
   # Some tests still require a simple way to set up a system without sizing.. so we are keeping the auto_zoner flag for this  method.
   #
   def add_sys3and8_single_zone_packaged_rooftop_unit_with_baseboard_heating_single_speed(model:,

data/lib/openstudio-standards/standards/necb/NECB2011/hvac_systems.rb

@@ -367,6 +367,34 @@ class NECB2011
     return true
   end
 
+  # Sets the minimum effectiveness of the heat exchanger per
+  # the standard.
+  def heat_exchanger_air_to_air_sensible_and_latent_apply_efficiency(heat_exchanger_air_to_air_sensible_and_latent, erv_name = nil)
+    # Assumed to be sensible and latent at all flow
+    # This will now get data of the erv from the json file instead of hardcoding it. Defaults to NECB2011 erv we have been using.
+    erv_name = 'Rotary-Minimum-Eff-Existing' if erv_name.nil?
+    erv_info = @standards_data['erv'].detect { |item| item['erv_name'] == erv_name }
+
+    raise("Could not find #{erv_name} in #{self.class.name} class' erv.json file or it's parents. The available ervs are #{@standards_data['erv'].map{|item| item['erv_name']}}") if erv_info.nil?
+
+    heat_exchanger_air_to_air_sensible_and_latent.setHeatExchangerType(erv_info['HeatExchangerType'])
+    heat_exchanger_air_to_air_sensible_and_latent.setSensibleEffectivenessat100HeatingAirFlow(erv_info['SensibleEffectivenessat100HeatingAirFlow'])
+    heat_exchanger_air_to_air_sensible_and_latent.setLatentEffectivenessat100HeatingAirFlow(erv_info['LatentEffectivenessat100HeatingAirFlow'])
+    heat_exchanger_air_to_air_sensible_and_latent.setSensibleEffectivenessat75HeatingAirFlow(erv_info['SensibleEffectivenessat75HeatingAirFlow'])
+    heat_exchanger_air_to_air_sensible_and_latent.setLatentEffectivenessat75HeatingAirFlow(erv_info['LatentEffectivenessat75HeatingAirFlow'])
+    heat_exchanger_air_to_air_sensible_and_latent.setSensibleEffectivenessat100CoolingAirFlow(erv_info['SensibleEffectivenessat100CoolingAirFlow'])
+    heat_exchanger_air_to_air_sensible_and_latent.setLatentEffectivenessat100CoolingAirFlow(erv_info['LatentEffectivenessat100CoolingAirFlow'])
+    heat_exchanger_air_to_air_sensible_and_latent.setSensibleEffectivenessat75CoolingAirFlow(erv_info['SensibleEffectivenessat75CoolingAirFlow'])
+    heat_exchanger_air_to_air_sensible_and_latent.setLatentEffectivenessat75CoolingAirFlow(erv_info['LatentEffectivenessat75CoolingAirFlow'])
+    heat_exchanger_air_to_air_sensible_and_latent.setSupplyAirOutletTemperatureControl(erv_info['SupplyAirOutletTemperatureControl'])
+    heat_exchanger_air_to_air_sensible_and_latent.setFrostControlType(erv_info['FrostControlType'])
+    heat_exchanger_air_to_air_sensible_and_latent.setEconomizerLockout(erv_info['EconomizerLockout'])
+    heat_exchanger_air_to_air_sensible_and_latent.setThresholdTemperature(erv_info['ThresholdTemperature'])
+    heat_exchanger_air_to_air_sensible_and_latent.setInitialDefrostTimeFraction(erv_info['InitialDefrostTimeFraction'])
+    return true
+  end
+
+
   # Determine if demand control ventilation (DCV) is
   # required for this air loop.
   #
@@ -798,127 +826,118 @@ class NECB2011
   # @return [Bool] true if successful, false if not
   def coil_cooling_dx_multi_speed_apply_efficiency_and_curves(coil_cooling_dx_multi_speed, sql_db_vars_map)
     successfully_set_all_properties = true
+    model = coil_cooling_dx_multi_speed.model
+    multi_speed_heat_pump = coil_cooling_dx_multi_speed.containingHVACComponent.get.to_AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed.get
+    airloop = multi_speed_heat_pump.airLoopHVAC.get
 
-    # Define the criteria to find the chiller properties
-    # in the hvac standards data set.
-    search_criteria = {}
-    cooling_type = coil_cooling_dx_multi_speed.condenserType
-    search_criteria['cooling_type'] = cooling_type
-
-    # TODO: Standards - add split system vs single package to model
-    # For now, assume single package as default
-    sub_category = 'Single Package'
-
-    # Determine the heating type if unitary or zone hvac
-    heat_pump = false
-    heating_type = nil
-    containing_comp = nil
-    if coil_cooling_dx_multi_speed.airLoopHVAC.empty?
-      if coil_cooling_dx_multi_speed.containingHVACComponent.is_initialized
-        containing_comp = coil_cooling_dx_multi_speed.containingHVACComponent.get
-        if containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed.is_initialized
-          htg_coil = containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed.get.heatingCoil
-          if htg_coil.to_CoilHeatingDXMultiSpeed.is_initialized
-            heat_pump = true
-            heating_type = 'Electric Resistance or None'
-          elsif htg_coil.to_CoilHeatingGasMultiStage.is_initialized
-            heating_type = 'All Other'
-          end
-        end # TODO: Add other unitary systems
-      elsif coil_cooling_dx_multi_speed.containingZoneHVACComponent.is_initialized
-        containing_comp = coil_cooling_dx_multi_speed.containingZoneHVACComponent.get
-        if containing_comp.to_ZoneHVACPackagedTerminalAirConditioner.is_initialized
-          sub_category = 'PTAC'
-          htg_coil = containing_comp.to_ZoneHVACPackagedTerminalAirConditioner.get.heatingCoil
-          if htg_coil.to_CoilHeatingElectric.is_initialized
-            heating_type = 'Electric Resistance or None'
-          elsif htg_coil.to_CoilHeatingWater.is_initialized || htg_coil.to_CoilHeatingGas.is_initialized || htg_col.to_CoilHeatingGasMultiStage
-            heating_type = 'All Other'
-          end
-        end # TODO: Add other zone hvac systems
-      end
-    end
+    # Define the criteria to find the properties in the hvac standards data set
+    search_criteria = coil_dx_find_search_criteria(coil_cooling_dx_multi_speed)
+    capacity_w = coil_cooling_dx_multi_speed_find_capacity(coil_cooling_dx_multi_speed)
 
-    # Add the heating type to the search criteria
-    unless heating_type.nil?
-      search_criteria['heating_type'] = heating_type
-    end
-
-    search_criteria['subcategory'] = sub_category
-
-    # Get the coil capacity
-    capacity_w = nil
-    clg_stages = stages
-    if clg_stages.last.grossRatedTotalCoolingCapacity.is_initialized
-      capacity_w = clg_stages.last.grossRatedTotalCoolingCapacity.get
-    elsif coil_cooling_dx_multi_speed.autosizedSpeed4GrossRatedTotalCoolingCapacity.is_initialized
-      capacity_w = coil_cooling_dx_multi_speed.autosizedSpeed4GrossRatedTotalCoolingCapacity.get
-    else
-      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{coil_cooling_dx_multi_speed.name} capacity is not available, cannot apply efficiency standard.")
-      successfully_set_all_properties = false
-      return successfully_set_all_properties
+    # Find design outside air flow rate and flow fraction
+    controller_oa = nil
+    if airloop.airLoopHVACOutdoorAirSystem.is_initialized
+      oa_system = airloop.airLoopHVACOutdoorAirSystem.get
+      controller_oa = oa_system.getControllerOutdoorAir
     end
-
-    # Volume flow rate
-    flow_rate4 = nil
-    if clg_stages.last.ratedAirFlowRate.is_initialized
-      flow_rate4 = clg_stages.last.ratedAirFlowRate.get
-    elsif coil_cooling_dx_multi_speed.autosizedSpeed4RatedAirFlowRate.is_initialized
-      flow_rate4 = coil_cooling_dx_multi_speed.autosizedSpeed4RatedAirFlowRate.get
+    min_oa_flow_rate, oaf = 0.0,0.0
+    if controller_oa
+      min_oa_flow_rate = nil
+      if controller_oa.minimumOutdoorAirFlowRate.is_initialized
+        min_oa_flow_rate = controller_oa.minimumOutdoorAirFlowRate.get
+      elsif controller_oa.autosizedMinimumOutdoorAirFlowRate.is_initialized
+        min_oa_flow_rate = controller_oa.autosizedMinimumOutdoorAirFlowRate.get
+      end
+      if min_oa_flow_rate then oaf = min_oa_flow_rate.to_f / airloop.autosizedDesignSupplyAirFlowRate.to_f end
     end
 
-    # Set number of stages
+    # Find required capacity of each stage and total number of stages based on NECB rules
+    # This implementation is limited to 4 stages only. The capacity of stages 1-3 is set to
+    # 66 kW as stipulated by NECB. The capacity of the 4th stage is then allowed to exceed 66 kW
+    # up to the design capacity.
     stage_cap = []
     num_stages = (capacity_w / (66.0 * 1000.0) + 0.5).round
-    num_stages = [num_stages, 4].min
-    if num_stages == 1
+    max_cap = 66.0 * 1000.0 * num_stages
+    final_num_stages = num_stages
+    case num_stages
+    when 1
       stage_cap[0] = capacity_w / 2.0
       stage_cap[1] = 2.0 * stage_cap[0]
-      stage_cap[2] = stage_cap[1] + 0.1
-      stage_cap[3] = stage_cap[2] + 0.1
+      final_num_stages = 2
     else
       stage_cap[0] = 66.0 * 1000.0
       stage_cap[1] = 2.0 * stage_cap[0]
-      if num_stages == 2
-        stage_cap[2] = stage_cap[1] + 0.1
-        stage_cap[3] = stage_cap[2] + 0.1
-      elsif num_stages == 3
+      case num_stages
+      when 2
+      when 3
         stage_cap[2] = 3.0 * stage_cap[0]
-        stage_cap[3] = stage_cap[2] + 0.1
-      elsif num_stages == 4
+      else
+        final_num_stages = 4
         stage_cap[2] = 3.0 * stage_cap[0]
-        stage_cap[3] = 4.0 * stage_cap[0]
+        stage_cap[3] = max_cap
       end
     end
-    # set capacities, flow rates, and sensible heat ratio for stages
-    (0..3).each do |istage|
-      clg_stages[istage].setGrossRatedTotalCoolingCapacity(stage_cap[istage])
-      clg_stages[istage].setRatedAirFlowRate(flow_rate4 * stage_cap[istage] / capacity_w)
+
+    # Set final number of cooling stages and create missing stages if needed
+    for istage in 2..final_num_stages-1
+      new_clg_stage = OpenStudio::Model::CoilCoolingDXMultiSpeedStageData.new(model)
+      coil_cooling_dx_multi_speed.addStage(new_clg_stage)
+    end
+    multi_speed_heat_pump.setNumberofSpeedsforCooling(final_num_stages)
+
+    # Set final capacities for each of the stages. The flow rate for each of the stages
+    # is maintained above the outside air flow rate
+    coil_cooling_dx_multi_speed.stages[0].setGrossRatedTotalCoolingCapacity(stage_cap[0])
+    coil_cooling_dx_multi_speed.stages[1].setGrossRatedTotalCoolingCapacity(stage_cap[1])
+    case  coil_cooling_dx_multi_speed.stages.size
+    when 2
+      if (oaf > 0.5) then multi_speed_heat_pump.setSpeed1SupplyAirFlowRateDuringCoolingOperation(min_oa_flow_rate) end
+    when 3
+      coil_cooling_dx_multi_speed.stages[2].setGrossRatedTotalCoolingCapacity(stage_cap[2])
+      if (oaf > 0.333) && (oaf <= 0.666)
+        multi_speed_heat_pump.setSpeed1SupplyAirFlowRateDuringCoolingOperation(min_oa_flow_rate)
+      elsif (oaf > 0.666)
+        multi_speed_heat_pump.setSpeed1SupplyAirFlowRateDuringCoolingOperation(min_oa_flow_rate)
+        multi_speed_heat_pump.setSpeed2SupplyAirFlowRateDuringCoolingOperation(min_oa_flow_rate)
+      end
+    when 4
+      coil_cooling_dx_multi_speed.stages[2].setGrossRatedTotalCoolingCapacity(stage_cap[2])
+      coil_cooling_dx_multi_speed.stages[3].setGrossRatedTotalCoolingCapacity(stage_cap[3])
+      if (oaf > 0.25) && (oaf <= 0.5)
+        multi_speed_heat_pump.setSpeed1SupplyAirFlowRateDuringCoolingOperation(min_oa_flow_rate)
+      elsif (oaf > 0.5) && (oaf <= 0.75)
+        multi_speed_heat_pump.setSpeed1SupplyAirFlowRateDuringCoolingOperation(min_oa_flow_rate)
+        multi_speed_heat_pump.setSpeed2SupplyAirFlowRateDuringCoolingOperation(min_oa_flow_rate)
+      elsif (oaf > 0.75)
+        multi_speed_heat_pump.setSpeed1SupplyAirFlowRateDuringCoolingOperation(min_oa_flow_rate)
+        multi_speed_heat_pump.setSpeed2SupplyAirFlowRateDuringCoolingOperation(min_oa_flow_rate)
+        multi_speed_heat_pump.setSpeed3SupplyAirFlowRateDuringCoolingOperation(min_oa_flow_rate)
+      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(stage_cap.last, 'W', 'Btu/hr').get
+    capacity_kbtu_per_hr = OpenStudio.convert(stage_cap.last, 'W', 'kBtu/hr').get
 
     # Lookup efficiencies depending on whether it is a unitary AC or a heat pump
     ac_props = nil
-    heat_pump_table = @standards_data['heat_pumps']
-    unitary_acs_table = @standards_data['unitary_acs']
-    ac_props = if heat_pump == true
-                 model_find_object(heat_pump_table, search_criteria, capacity_btu_per_hr, Date.today)
+    ac_props = if coil_dx_heat_pump?(coil_cooling_dx_multi_speed)
+                 model_find_object(standards_data['heat_pumps'], search_criteria, capacity_btu_per_hr, Date.today)
                else
-                 model_find_object(unitary_acs_table, search_criteria, capacity_btu_per_hr, Date.today)
+                 model_find_object(standards_data['unitary_acs'], 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.CoilCoolingDXMultiSpeed', "For #{coil_cooling_dx_multi_speed.name}, cannot find efficiency info, cannot apply efficiency standard.")
       successfully_set_all_properties = false
-      return successfully_set_all_properties
+      return sql_db_vars_map
     end
 
+    # get clg stages
+    clg_stages = coil_cooling_dx_multi_speed.stages
+
     # Make the COOL-CAP-FT curve
-    cool_cap_ft = model_add_curve(model, ac_props['cool_cap_ft'], standards)
+    cool_cap_ft = model_add_curve(model, ac_props['cool_cap_ft'])
     if cool_cap_ft
       clg_stages.each do |stage|
         stage.setTotalCoolingCapacityFunctionofTemperatureCurve(cool_cap_ft)
@@ -926,10 +945,11 @@ class NECB2011
     else
       OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{coil_cooling_dx_multi_speed.name}, cannot find cool_cap_ft curve, will not be set.")
       successfully_set_all_properties = false
+      return sql_db_vars_map
     end
 
     # Make the COOL-CAP-FFLOW curve
-    cool_cap_fflow = model_add_curve(model, ac_props['cool_cap_fflow'], standards)
+    cool_cap_fflow = model_add_curve(model, ac_props['cool_cap_fflow'])
     if cool_cap_fflow
       clg_stages.each do |stage|
         stage.setTotalCoolingCapacityFunctionofFlowFractionCurve(cool_cap_fflow)
@@ -937,10 +957,11 @@ class NECB2011
     else
       OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{coil_cooling_dx_multi_speed.name}, cannot find cool_cap_fflow curve, will not be set.")
       successfully_set_all_properties = false
+      return sql_db_vars_map
     end
 
     # Make the COOL-EIR-FT curve
-    cool_eir_ft = model_add_curve(model, ac_props['cool_eir_ft'], standards)
+    cool_eir_ft = model_add_curve(model, ac_props['cool_eir_ft'])
     if cool_eir_ft
       clg_stages.each do |stage|
         stage.setEnergyInputRatioFunctionofTemperatureCurve(cool_eir_ft)
@@ -948,10 +969,11 @@ class NECB2011
     else
       OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{coil_cooling_dx_multi_speed.name}, cannot find cool_eir_ft curve, will not be set.")
       successfully_set_all_properties = false
+      return sql_db_vars_map
     end
 
     # Make the COOL-EIR-FFLOW curve
-    cool_eir_fflow = model_add_curve(model, ac_props['cool_eir_fflow'], standards)
+    cool_eir_fflow = model_add_curve(model, ac_props['cool_eir_fflow'])
     if cool_eir_fflow
       clg_stages.each do |stage|
         stage.setEnergyInputRatioFunctionofFlowFractionCurve(cool_eir_fflow)
@@ -959,10 +981,11 @@ class NECB2011
     else
       OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{coil_cooling_dx_multi_speed.name}, cannot find cool_eir_fflow curve, will not be set.")
       successfully_set_all_properties = false
+      return sql_db_vars_map
     end
 
     # Make the COOL-PLF-FPLR curve
-    cool_plf_fplr = model_add_curve(model, ac_props['cool_plf_fplr'], standards)
+    cool_plf_fplr = model_add_curve(model, ac_props['cool_plf_fplr'])
     if cool_plf_fplr
       clg_stages.each do |stage|
         stage.setPartLoadFractionCorrelationCurve(cool_plf_fplr)
@@ -970,128 +993,259 @@ class NECB2011
     else
       OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{coil_cooling_dx_multi_speed.name}, cannot find cool_plf_fplr curve, will not be set.")
       successfully_set_all_properties = false
+      return sql_db_vars_map
     end
 
-    # Get the minimum efficiency standards
-    cop = nil
-
-    if coil_dx_subcategory(coil_cooling_dx_multi_speed) == 'PTAC'
-      ptac_eer_coeff_1 = ac_props['ptac_eer_coefficient_1']
-      ptac_eer_coeff_2 = ac_props['ptac_eer_coefficient_2']
-      capacity_btu_per_hr = 7000 if capacity_btu_per_hr < 7000
-      capacity_btu_per_hr = 15_000 if capacity_btu_per_hr > 15_000
-      ptac_eer = ptac_eer_coeff_1 + (ptac_eer_coeff_2 * capacity_btu_per_hr)
-      cop = eer_to_cop(ptac_eer)
-      # self.setName("#{self.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{ptac_eer}EER")
-      new_comp_name = "#{coil_cooling_dx_multi_speed.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{ptac_eer}EER"
-      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{template}: #{coil_cooling_dx_multi_speed.name}: #{cooling_type} #{heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; EER = #{ptac_eer}")
-    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)
-      new_comp_name = "#{coil_cooling_dx_multi_speed.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_seer}SEER"
-      #      self.setName("#{self.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_seer}SEER")
-      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{template}: #{coil_cooling_dx_multi_speed.name}: #{cooling_type} #{heating_type} #{subcategory} 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']
-      cop = eer_to_cop(min_eer)
-      new_comp_name = "#{coil_cooling_dx_multi_speed.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_eer}EER"
-      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{template}: #{coil_cooling_dx_multi_speed.name}: #{cooling_type} #{heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; EER = #{min_eer}")
-    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(min_seer)
-      new_comp_name = "#{coil_cooling_dx_multi_speed.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_seer}SEER"
-      #      self.setName("#{self.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_seer}SEER")
-      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{template}: #{coil_cooling_dx_multi_speed.name}: #{cooling_type} #{heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; SEER = #{min_seer}")
-    end
-
-    # If specified as EER (heat pump)
-    unless ac_props['minimum_full_load_efficiency'].nil?
-      min_eer = ac_props['minimum_full_load_efficiency']
-      cop = eer_to_cop(min_eer)
-      new_comp_name = "#{coil_cooling_dx_multi_speed.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_eer}EER"
-      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{template}: #{coil_cooling_dx_multi_speed.name}: #{cooling_type} #{heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; EER = #{min_eer}")
-    end
-
-    sql_db_vars_map[new_comp_name] = name.to_s
-    coil_cooling_dx_multi_speed.setName(new_comp_name)
-
-    # Set the efficiency values
-
+    # Set the COP values
+    cop, new_comp_name = coil_cooling_dx_multi_speed_standard_minimum_cop(coil_cooling_dx_multi_speed)
     unless cop.nil?
       clg_stages.each do |istage|
         istage.setGrossRatedCoolingCOP(cop)
       end
     end
+    sql_db_vars_map[new_comp_name] = coil_cooling_dx_multi_speed.name.to_s
+    coil_cooling_dx_multi_speed.setName(new_comp_name)
+
+    # It was found that the heat pump OS object doesn't respond to the call to turn on from the
+    # system availability manager night cycle. This EMS script is then implemented to check the status
+    # of the system availability manager night cycle and force the heat pump to turn on when needed. The
+    # heat pump is still turned on when its availability schedule calls for it.
+    create_ems_to_turn_on_AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed_for_night_cycle(multi_speed_heat_pump)
 
     return sql_db_vars_map
+
+  end
+
+  # Create EMS to turn on "AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed" in response to a call
+  # from the night cycle availability manager of the air loop. It was found that this object
+  # doesn't respond properly to this call from the night cycle
+  def create_ems_to_turn_on_AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed_for_night_cycle(multi_speed_heat_pump)
+    model = multi_speed_heat_pump.model
+    avail_manager_name = nil
+    if multi_speed_heat_pump.airLoopHVAC.is_initialized
+      if not multi_speed_heat_pump.airLoopHVAC.get.availabilityManagers.empty?
+        avail_manager_name = multi_speed_heat_pump.airLoopHVAC.get.availabilityManagers[0].name.to_s
+      end
+    end
+    if avail_manager_name
+      avail_manager_out_var_name = "Availability Manager Night Cycle Control Status"
+      avail_manager_out_var = OpenStudio::Model::OutputVariable.new(avail_manager_out_var_name, model)
+      avail_manager_out_var.setKeyValue(avail_manager_name)
+      avail_manager_out_var.setReportingFrequency("Timestep")
+      night_cycle_sensor = OpenStudio::Model::EnergyManagementSystemSensor.new(model, avail_manager_out_var)
+      heat_pump_avail_sch = nil
+      if multi_speed_heat_pump.availabilitySchedule.is_initialized
+        heat_pump_avail_sch = multi_speed_heat_pump.availabilitySchedule.get
+      elsif multi_speed_heat_pump.airLoopHVAC.get.availabilitySchedule.is_initialized
+        heat_pump_avail_sch = multi_speed_heat_pump.airLoopHVAC.get.availabilitySchedule.get
+      else
+        heat_pump_avail_sch = OpenStudio::Model::ScheduleConstant.new(model)
+        heat_pump_avail_sch.setValue(1.0)
+      end
+      heat_pump_avail_sch_var = OpenStudio::Model::OutputVariable.new("Schedule Value", model)
+      heat_pump_avail_sch_var.setKeyValue(heat_pump_avail_sch.name.to_s)
+      heat_pump_avail_sch_sensor = OpenStudio::Model::EnergyManagementSystemSensor.new(model, heat_pump_avail_sch_var)
+      updated_heat_pump_avail_sch = OpenStudio::Model::ScheduleConstant.new(model)
+      multi_speed_heat_pump.setAvailabilitySchedule(updated_heat_pump_avail_sch)
+      heat_pump_avail_sch_actuator = OpenStudio::Model::EnergyManagementSystemActuator.new(updated_heat_pump_avail_sch, "Schedule:Constant", "Schedule Value")
+      heat_pump_avail_sch_prog = OpenStudio::Model::EnergyManagementSystemProgram.new(model)
+      heat_pump_avail_sch_prog.setName("#{multi_speed_heat_pump.name.to_s.gsub(/[ +-.]/,'_')} Availability Schedule Program by Line")
+      heat_pump_avail_sch_prog_body = <<-EMS
+        IF #{heat_pump_avail_sch_sensor.handle} > 0.0 
+          SET #{heat_pump_avail_sch_actuator.handle} = #{heat_pump_avail_sch_sensor.handle}
+        ELSEIF #{night_cycle_sensor.handle} == 2.0
+          SET #{heat_pump_avail_sch_actuator.handle} = 1.0
+        ELSE
+          SET #{heat_pump_avail_sch_actuator.handle} = 0.0
+        ENDIF
+      EMS
+      heat_pump_avail_sch_prog.setBody(heat_pump_avail_sch_prog_body)
+      pcm = OpenStudio::Model::EnergyManagementSystemProgramCallingManager.new(model)
+      pcm.setName("#{heat_pump_avail_sch_prog.name.to_s.gsub(/[ +-.]/,'_')} Calling Manager")
+      pcm.setCallingPoint('InsideHVACSystemIterationLoop')
+      pcm.addProgram(heat_pump_avail_sch_prog)
+    end
   end
 
   # Applies the standard efficiency ratings and typical performance curves to this object.
   #
   # @return [Bool] true if successful, false if not
-  def coil_heating_gas_multi_stage_apply_efficiency_and_curves(coil_heating_gas_multi_stage, standards)
+  def coil_heating_gas_multi_stage_apply_efficiency_and_curves(coil_heating_gas_multi_stage)
     successfully_set_all_properties = true
+    model = coil_heating_gas_multi_stage.model
+
+    # get multi speed heat pump and air loop
+    multi_speed_heat_pump = nil
+    multi_speed_heat_pumps = model.getAirLoopHVACUnitaryHeatPumpAirToAirMultiSpeeds
+    multi_speed_heat_pumps.each do |iheat_pump|
+      htg_coil = iheat_pump.heatingCoil
+      if htg_coil.name.to_s.strip == coil_heating_gas_multi_stage.name.to_s.strip
+        multi_speed_heat_pump = iheat_pump
+        break
+      end
+    end
+    airloop = multi_speed_heat_pump.airLoopHVAC.get
 
-    # Get the coil capacity
-    capacity_w = nil
-    htg_stages = stages
-    if htg_stages.last.nominalCapacity.is_initialized
-      capacity_w = htg_stages.last.nominalCapacity.get
-    elsif coil_heating_gas_multi_stage.autosizedStage4NominalCapacity.is_initialized
-      capacity_w = coil_heating_gas_multi_stage.autosizedStage4NominalCapacity.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
-      return successfully_set_all_properties
+    # Define the criteria to find the properties in the hvac standards data set.
+    search_criteria = coil_heating_gas_multi_stage_find_search_criteria(coil_heating_gas_multi_stage)
+    fuel_type = search_criteria["fuel_type"]
+    capacity_w = coil_heating_gas_multi_stage_find_capacity(coil_heating_gas_multi_stage)
+
+    # Find system design outside air flow rate and fraction
+    controller_oa = nil
+    if airloop.airLoopHVACOutdoorAirSystem.is_initialized
+      oa_system = airloop.airLoopHVACOutdoorAirSystem.get
+      controller_oa = oa_system.getControllerOutdoorAir
+    end
+    min_oa_flow_rate, oaf = 0.0,0.0
+    if controller_oa
+      min_oa_flow_rate = nil
+      if controller_oa.minimumOutdoorAirFlowRate.is_initialized
+        min_oa_flow_rate = controller_oa.minimumOutdoorAirFlowRate.get
+      elsif controller_oa.autosizedMinimumOutdoorAirFlowRate.is_initialized
+        min_oa_flow_rate = controller_oa.autosizedMinimumOutdoorAirFlowRate.get
+      end
+      if min_oa_flow_rate then oaf = min_oa_flow_rate.to_f / airloop.autosizedDesignSupplyAirFlowRate.to_f end
     end
 
-    # Set number of stages
+    # Find capacities of each of the stages and the total number of stages required based on NECB rules.
+    # This implementation is limited to 4 stages. The capacity of stages 1-3 is set to 66 kW as stipulated
+    # by NECB. The capacity of the 4th stage can exceed 66 kW up to the design capacity.
+    htg_stages = coil_heating_gas_multi_stage.stages
     num_stages = (capacity_w / (66.0 * 1000.0) + 0.5).round
-    num_stages = [num_stages, 4].min
+    max_cap = 66.0 * 1000.0 * num_stages
     stage_cap = []
-    if num_stages == 1
-      stage_cap[0] = capacity_w / 2.0
-      stage_cap[1] = 2.0 * stage_cap[0]
-      stage_cap[2] = stage_cap[1] + 0.1
-      stage_cap[3] = stage_cap[2] + 0.1
+    final_num_stages = num_stages
+    if capacity_w == 0.001
+      final_num_stages = 1
+      stage_cap[0] = capacity_w
     else
-      stage_cap[0] = 66.0 * 1000.0
-      stage_cap[1] = 2.0 * stage_cap[0]
-      if num_stages == 2
-        stage_cap[2] = stage_cap[1] + 0.1
-        stage_cap[3] = stage_cap[2] + 0.1
-      elsif num_stages == 3
-        stage_cap[2] = 3.0 * stage_cap[0]
-        stage_cap[3] = stage_cap[2] + 0.1
-      elsif num_stages == 4
-        stage_cap[2] = 3.0 * stage_cap[0]
-        stage_cap[3] = 4.0 * stage_cap[0]
+      case num_stages
+      when 1
+        stage_cap[0] = capacity_w / 2.0
+        stage_cap[1] = 2.0 * stage_cap[0]
+        final_num_stages = 2
+      else
+        stage_cap[0] = 66.0 * 1000.0
+        stage_cap[1] = 2.0 * stage_cap[0]
+        case num_stages
+        when 2
+        when 3
+          stage_cap[2] = 3.0 * stage_cap[0]
+        else
+          final_num_stages = 4
+          stage_cap[2] = 3.0 * stage_cap[0]
+          stage_cap[3] = max_cap
+        end
       end
     end
-    # set capacities, flow rates, and sensible heat ratio for stages
-    (0..3).each do |istage|
-      htg_stages[istage].setNominalCapacity(stage_cap[istage])
+
+    # Set final number of stages and create missing stages if needed
+    for istage in 1..final_num_stages-1
+      new_htg_stage = OpenStudio::Model::CoilHeatingGasMultiStageStageData.new(model)
+      coil_heating_gas_multi_stage.addStage(new_htg_stage)
+    end
+    multi_speed_heat_pump.setNumberofSpeedsforHeating(final_num_stages)
+
+    # Set final capacities for each of the stages. The air flow rate for each of the stages
+    # is maintained above the outside air flow rate
+    coil_heating_gas_multi_stage.stages[0].setNominalCapacity(stage_cap[0])
+    case  coil_heating_gas_multi_stage.stages.size
+    when 2
+      coil_heating_gas_multi_stage.stages[1].setNominalCapacity(stage_cap[1])
+      if (oaf > 0.5) then multi_speed_heat_pump.setSpeed1SupplyAirFlowRateDuringHeatingOperation(min_oa_flow_rate) end
+    when 3
+      coil_heating_gas_multi_stage.stages[1].setNominalCapacity(stage_cap[1])
+      coil_heating_gas_multi_stage.stages[2].setNominalCapacity(stage_cap[2])
+      if (oaf > 0.333) && (oaf <= 0.666)
+        multi_speed_heat_pump.setSpeed1SupplyAirFlowRateDuringHeatingOperation(min_oa_flow_rate)
+      elsif (oaf > 0.666)
+        multi_speed_heat_pump.setSpeed1SupplyAirFlowRateDuringHeatingOperation(min_oa_flow_rate)
+        multi_speed_heat_pump.setSpeed2SupplyAirFlowRateDuringHeatingOperation(min_oa_flow_rate)
+      end
+    when 4
+      coil_heating_gas_multi_stage.stages[1].setNominalCapacity(stage_cap[1])
+      coil_heating_gas_multi_stage.stages[2].setNominalCapacity(stage_cap[2])
+      coil_heating_gas_multi_stage.stages[3].setNominalCapacity(stage_cap[3])
+      if (oaf > 0.25) && (oaf <= 0.5)
+        multi_speed_heat_pump.setSpeed1SupplyAirFlowRateDuringHeatingOperation(min_oa_flow_rate)
+      elsif (oaf > 0.5) && (oaf <= 0.75)
+        multi_speed_heat_pump.setSpeed1SupplyAirFlowRateDuringHeatingOperation(min_oa_flow_rate)
+        multi_speed_heat_pump.setSpeed2SupplyAirFlowRateDuringHeatingOperation(min_oa_flow_rate)
+      elsif (oaf > 0.75)
+        multi_speed_heat_pump.setSpeed1SupplyAirFlowRateDuringHeatingOperation(min_oa_flow_rate)
+        multi_speed_heat_pump.setSpeed2SupplyAirFlowRateDuringHeatingOperation(min_oa_flow_rate)
+        multi_speed_heat_pump.setSpeed3SupplyAirFlowRateDuringHeatingOperation(min_oa_flow_rate)
+      end
+    end
+
+    # Convert capacity to Btu/hr
+    capacity_btu_per_hr = OpenStudio.convert(stage_cap.last, 'W', 'Btu/hr').get
+    capacity_kbtu_per_hr = OpenStudio.convert(stage_cap.last, 'W', 'kBtu/hr').get
+
+    # Lookup efficiencies
+    heater_props = nil
+    heater_props = model_find_object(standards_data['furnaces'], search_criteria, capacity_btu_per_hr, Date.today)
+
+    # Check to make sure properties were found
+    if heater_props.nil?
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingGasMultiSpeed', "For #{coil_heating_gas_multi_stage.name}, cannot find efficiency info, cannot apply efficiency standard.")
+      successfully_set_all_properties = false
+      return successfully_set_all_properties
     end
-    # PLF vs PLR curve
-    furnace_plffplr_curve_name = 'FURNACE-EFFPLR-NECB2011'
 
-    # plf vs plr curve for furnace
-    furnace_plffplr_curve = model_add_curve(coil_heating_gas_multi_stage.model, furnace_plffplr_curve_name, standards)
-    if furnace_plffplr_curve
-      coil_heating_gas_multi_stage.setPartLoadFractionCorrelationCurve(furnace_plffplr_curve)
+    # Make the EFFPLR curve
+    efffplr = model_add_curve(coil_heating_gas_multi_stage.model, heater_props['efffplr'])
+    if efffplr
+      coil_heating_gas_multi_stage.setPartLoadFractionCorrelationCurve(efffplr)
     else
-      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingGasMultiStage', "For #{coil_heating_gas_multi_stage.name}, cannot find plffplr curve, will not be set.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingGasMultiStage', "For #{coil_heating_gas_multi_stage.name}, cannot find efffplr curve, will not be set.")
       successfully_set_all_properties = false
+      return successfully_set_all_properties
     end
+
+    # Get the minimum efficiency standards
+    thermal_eff = nil
+
+    # If specified as AFUE
+    unless heater_props['minimum_annual_fuel_utilization_efficiency'].nil?
+      min_afue = heater_props['minimum_annual_fuel_utilization_efficiency']
+      thermal_eff = afue_to_thermal_eff(min_afue)
+      new_comp_name = "#{coil_heating_gas_multi_stage.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_afue} AFUE"
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilHeatingGasMultiStage', "For #{template}: #{coil_heating_gas_multi_stage.name}: #{fuel_type} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; AFUE = #{min_afue}")
+    end
+
+    # If specified as thermal efficiency
+    unless heater_props['minimum_thermal_efficiency'].nil?
+      thermal_eff = heater_props['minimum_thermal_efficiency']
+      new_comp_name = "#{coil_heating_gas_multi_stage.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{thermal_eff} Thermal Eff"
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilHeatingGasMultiStage', "For #{template}: #{coil_heating_gas_multi_stage.name}: #{fuel_type} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; Thermal Efficiency = #{thermal_eff}")
+    end
+
+    # If specified as combustion efficiency
+    unless heater_props['minimum_combustion_efficiency'].nil?
+      min_comb_eff = heater_props['minimum_combustion_efficiency']
+      thermal_eff = combustion_eff_to_thermal_eff(min_comb_eff)
+      new_comp_name = "#{coil_heating_gas_multi_stage.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_comb_eff} Combustion Eff"
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.BoilerHotWater', "For #{template}: #{coil_heating_gas_multi_stage.name}: #{fuel_type} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; Combustion Efficiency = #{min_comb_eff}")
+    end
+    coil_heating_gas_multi_stage.setName(new_comp_name)
+
+    # Set the name
+    coil_heating_gas_multi_stage.setName(new_comp_name)
+
+    # Get heating stages
+    htg_stages = coil_heating_gas_multi_stage.stages
+
+    # Set the efficiency values
+    unless thermal_eff.nil?
+      htg_stages.each do |stage|
+        stage.setGasBurnerEfficiency(thermal_eff)
+      end
+    end
+
+    return successfully_set_all_properties
+
   end
 
   # Determines the baseline fan impeller efficiency
@@ -1139,7 +1293,7 @@ class NECB2011
     # Assuming all fan motors are 4-pole ODP
     motor_use = 'FAN'
     motor_type = ''
-    if fan.class.name == 'OpenStudio::Model::FanConstantVolume'
+    if (fan.class.name == 'OpenStudio::Model::FanConstantVolume') || (fan.class.name == 'OpenStudio::Model::FanOnOff')
       motor_type = 'CONSTANT'
     elsif fan.class.name == 'OpenStudio::Model::FanVariableVolume'
       # Is this a return or supply fan
@@ -1560,51 +1714,7 @@ class NECB2011
 
     return clg_tower
   end
-
-
-  # Creates thermal zones to contain each space, as defined for each building in the
-  # system_to_space_map inside the Prototype.building_name
-  # e.g. (Prototype.secondary_school.rb) file.
-  #
-  # @param (see #add_constructions)
-  # @return [Bool] returns true if successful, false if not
-  def model_create_thermal_zones(model,
-                                 space_multiplier_map = nil)
-    OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.Model', 'Started creating thermal zones')
-    space_multiplier_map = {} if space_multiplier_map.nil?
-
-    # Remove any Thermal zones assigned
-    model.getThermalZones.each(&:remove)
-
-    # Create a thermal zone for each space in the self
-    model.getSpaces.sort.each do |space|
-      zone = OpenStudio::Model::ThermalZone.new(model)
-      zone.setName("#{space.name} ZN")
-      unless space_multiplier_map[space.name.to_s].nil? || (space_multiplier_map[space.name.to_s] == 1)
-        zone.setMultiplier(space_multiplier_map[space.name.to_s])
-      end
-      space.setThermalZone(zone)
-
-      # Skip thermostat for spaces with no space type
-      next if space.spaceType.empty?
-
-      # Add a thermostat
-      space_type_name = space.spaceType.get.name.get
-      thermostat_name = space_type_name + ' Thermostat'
-      thermostat = model.getThermostatSetpointDualSetpointByName(thermostat_name)
-      if thermostat.empty?
-        OpenStudio.logFree(OpenStudio::Error, 'openstudio.model.Model', "Thermostat #{thermostat_name} not found for space name: #{space.name}")
-      else
-        thermostat_clone = thermostat.get.clone(model).to_ThermostatSetpointDualSetpoint.get
-        zone.setThermostatSetpointDualSetpoint(thermostat_clone)
-        # Set Ideal loads to thermal zone for sizing for NECB needs. We need this for sizing.
-        ideal_loads = OpenStudio::Model::ZoneHVACIdealLoadsAirSystem.new(model)
-        ideal_loads.addToThermalZone(zone)
-      end
-    end
-
-    OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.Model', 'Finished creating thermal zones')
-  end
+  
 
   # This method cycles through the spaces in a thermal zone and then sorts them by story.  The method then cycles
   # through the spaces on a story and then calculates the centroid of the spaces in the thermal zone on that floor.  The