openstudio-standards 0.2.17.rc2 → 0.3.1.rc1

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

@@ -460,6 +460,36 @@ class ECMS
         updated_system_zones_map[sys_name] += zones
       end
     end
+
+    return updated_system_zones_map
+  end
+
+  # =============================================================================================================================
+  # The first 5 letters of the air loop name designate the system type (sys_abbr). This method updates the system type designation 
+  # in the air loop name. At the same time the chosen air loop names are checked to avoid duplicate names from being used in the 
+  # hash for system to zomes.
+  def update_system_zones_map_keys(system_zones_map,sys_abbr)
+    updated_system_zones_map = {}
+    system_zones_map.sort.each do |sname,zones|
+      updated_sys_name = "#{sys_abbr}#{sname[5..-1]}"
+      if !updated_system_zones_map.has_key? updated_sys_name
+        updated_system_zones_map[updated_sys_name] = zones
+      else
+        updated_sys_name_set = false
+        index = 1
+        while !updated_sys_name_set
+          updated_sys_name = "#{sys_abbr}#{sname[5..-1]}"
+          updated_sys_name.chop! if updated_sys_name.split.size > 1
+          updated_sys_name = updated_sys_name + index.to_s
+          if !updated_system_zones_map.has_key? updated_sys_name
+            updated_sys_name_set = true
+            updated_system_zones_map[updated_sys_name] = zones
+          end
+          index += 1
+        end
+      end
+    end
+
     return updated_system_zones_map
   end
 
@@ -467,7 +497,7 @@ class ECMS
   # Add equipment for ECM 'hs08_ccashp_vrf':
   #   -Constant-volume DOAS with air-source heat pump for heating and cooling and electric backup
   #   -Zonal terminal VRF units connected to an outdoor VRF condenser unit
-  #   -Zonal electric backup
+  #   -Zonal electric or hot-water backup
   def add_ecm_hs08_ccashp_vrf(
     model:,
     system_zones_map:,
@@ -477,16 +507,18 @@ class ECMS
     standard:,
     air_sys_eqpt_type: 'ccashp')
 
+    # Create one hot-water loop for hot-water baseboards if primary heating fuel is gas
+    hw_loop = nil
+    hw_loop = add_hotwater_loop(model: model) if heating_fuel == 'NaturalGas'
+
     # Update system zones map if needed
-    if ecm_system_zones_map_option != 'NECB_Default'
-      system_zones_map = update_system_zones_map(model,system_zones_map,ecm_system_zones_map_option,'sys_1')
-    else
-      updated_system_zones_map = {}
-      system_zones_map.each {|sname,zones| updated_system_zones_map["sys_1#{sname[5..-1]}"] = zones}  # doas unit is an NECB sys_1
-      system_zones_map = updated_system_zones_map
-    end
+    system_zones_map = update_system_zones_map_keys(system_zones_map,'sys_1')
+    system_zones_map = update_system_zones_map(model,system_zones_map,ecm_system_zones_map_option,'sys_1') if ecm_system_zones_map_option != 'NECB_Default'
     # Add outdoor VRF unit
     outdoor_vrf_unit = add_outdoor_vrf_unit(model: model, ecm_name: 'hs08_ccashp_vrf')
+    eqpt_name = 'Mitsubishi_Hyper_Heating_VRF_Outdoor_Unit'
+    airconditioner_variablerefrigerantflow_cooling_apply_curves(outdoor_vrf_unit,eqpt_name)
+    airconditioner_variablerefrigerantflow_heating_apply_curves(outdoor_vrf_unit,eqpt_name)
     # Update system doas flags
     system_doas_flags = {}
     system_zones_map.keys.each { |sname| system_doas_flags[sname] = true }
@@ -504,7 +536,7 @@ class ECMS
                                            system_doas_flags: system_doas_flags)
       sys_supp_htg_eqpt_type = 'coil_electric'
       sys_supp_htg_eqpt_type = 'coil_gas' if updated_heating_fuel == 'NaturalGas'
-      airloop, return_fan = add_air_system(model: model,
+      airloop,clg_dx_coil,htg_dx_coil,return_fan = add_air_system(model: model,
                                            zones: zones,
                                            sys_abbr: sys_info['sys_abbr'],
                                            sys_vent_type: sys_info['sys_vent_type'],
@@ -515,27 +547,17 @@ class ECMS
                                            sys_supp_fan_type: sys_info['sys_supp_fan_type'],
                                            sys_ret_fan_type: sys_info['sys_ret_fan_type'],
                                            sys_setpoint_mgr_type: sys_info['sys_setpoint_mgr_type'])
-      # get and assign defrost curve
-      dx_htg_coil = nil
-      airloop.supplyComponents.sort.each do |comp|
-        if comp.to_CoilHeatingDXSingleSpeed.is_initialized
-          dx_htg_coil = comp.to_CoilHeatingDXSingleSpeed.get
-        elsif comp.to_CoilHeatingDXVariableSpeed.is_initialized
-          dx_htg_coil = comp.to_CoilHeatingDXVariableSpeed.get
-        end
-      end
-      search_criteria = {}
+      # Appy performance curves
       if air_sys_eqpt_type == 'ccashp'
-        search_criteria['name'] = 'Mitsubishi_Hyper_Heating_VRF_Outdoor_Unit RTU'
+        eqpt_name = 'Mitsubishi_Hyper_Heating_VRF_Outdoor_Unit RTU'
+        coil_cooling_dx_variable_speed_apply_curves(clg_dx_coil, eqpt_name)
+        coil_heating_dx_variable_speed_apply_curves(htg_dx_coil, eqpt_name)
       elsif air_sys_eqpt_type == 'ashp'
-        search_criteria['name'] = 'NECB2015_ASHP'
-      end
-      props = model_find_object(standards_data['tables']['heat_pump_heating_ecm']['table'], search_criteria, 1.0)
-      heat_defrost_eir_ft = model_add_curve(model, props['heat_defrost_eir_ft'])
-      if heat_defrost_eir_ft
-        dx_htg_coil.setDefrostEnergyInputRatioFunctionofTemperatureCurve(heat_defrost_eir_ft)
+        eqpt_name = 'NECB2015_ASHP'
+        coil_cooling_dx_single_speed_apply_curves(clg_dx_coil, eqpt_name)
+        coil_heating_dx_single_speed_apply_curves(htg_dx_coil, eqpt_name)
       else
-        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDX', "For #{dx_htg_coil.name}, cannot find heat_defrost_eir_ft curve, will not be set.")
+        raise("add_ecm_hs08_ccashp_vrf: The air system equipment type is neither an ashp nor a ccashp")
       end
       # add zone equipment and diffuser
       # add terminal VRF units
@@ -547,17 +569,22 @@ class ECMS
                     zone_htg_eqpt_type: 'vrf',
                     zone_supp_htg_eqpt_type: 'none',
                     zone_clg_eqpt_type: 'vrf',
-                    zone_fan_type: 'On_Off')
-      # add electric baseboards for backup
+                    zone_fan_type: 'On_Off',
+                    hw_loop: hw_loop)
+      # add electric or hot-water baseboards for backup; Type of baseboard follows the primary heating fuel used in the building model.
+      zone_htg_eqpt_type = 'baseboard_hotwater' if heating_fuel == 'NaturalGas'
+      zone_htg_eqpt_type = 'baseboard_electric' if heating_fuel == 'Electricity'
+
       add_zone_eqpt(model: model,
                     airloop: airloop,
                     zones: zones,
                     outdoor_unit: nil,
                     zone_diffuser_type: nil,
-                    zone_htg_eqpt_type: 'baseboard_electric',
+                    zone_htg_eqpt_type: zone_htg_eqpt_type,
                     zone_supp_htg_eqpt_type: 'none',
                     zone_clg_eqpt_type: 'none',
-                    zone_fan_type: 'none')
+                    zone_fan_type: 'none',
+                    hw_loop: hw_loop)
       # Now we can find and apply maximum horizontal and vertical distances between outdoor vrf unit and zones with vrf terminal units
       max_hor_pipe_length, max_vert_pipe_length = get_max_vrf_pipe_lengths(model)
       outdoor_vrf_unit.setEquivalentPipingLengthusedforPipingCorrectionFactorinCoolingMode(max_hor_pipe_length)
@@ -567,7 +594,7 @@ class ECMS
   end
 
   # =============================================================================================================================
-  # Apply efficiencies and performance curves for ECM 'hs08_ccashp_vrf'
+  # Apply efficiencies for ECM 'hs08_ccashp_vrf'
   def apply_efficiency_ecm_hs08_ccashp_vrf(model, air_sys_eqpt_type: 'ccashp')
     # Use same performance data as ECM 'hs09_ccashpsys' for air system
     if air_sys_eqpt_type == 'ccashp'
@@ -575,11 +602,13 @@ class ECMS
     elsif air_sys_eqpt_type == 'ashp'
       apply_efficiency_ecm_hs12_ashp_baseboard(model)
     end
-    # Apply efficiency and curves for VRF units
+    # Apply efficiency for VRF units
     eqpt_name = 'Mitsubishi_Hyper_Heating_VRF_Outdoor_Unit'
+    search_criteria = {}
+    search_criteria['name'] = eqpt_name
     model.getAirConditionerVariableRefrigerantFlows.sort.each do |vrf_unit|
-      airconditioner_variablerefrigerantflow_cooling_apply_efficiency_and_curves(vrf_unit, eqpt_name)
-      airconditioner_variablerefrigerantflow_heating_apply_efficiency_and_curves(vrf_unit, eqpt_name)
+      airconditioner_variablerefrigerantflow_cooling_apply_cop(vrf_unit, search_criteria)
+      airconditioner_variablerefrigerantflow_heating_apply_cop(vrf_unit, search_criteria)
     end
     # Set fan size of VRF terminal units
     fan_power_per_flow_rate = 150.0 # based on Mitsubishi data: 100 low and 200 high (W-s/m3)
@@ -594,6 +623,7 @@ class ECMS
       fan_pr_rise = fan_power_per_flow_rate * (fan.fanEfficiency * fan.motorEfficiency)
       fan.setPressureRise(fan_pr_rise)
     end
+
   end
 
   # =============================================================================================================================
@@ -622,8 +652,8 @@ class ECMS
       airloop.sizingSystem.setAllOutdoorAirinCooling(true)
       airloop.sizingSystem.setAllOutdoorAirinHeating(true)
       airloop.sizingSystem.setTypeofLoadtoSizeOn('VentilationRequirement')
-      airloop.sizingSystem.setCentralCoolingDesignSupplyAirTemperature(19.9)
-      airloop.sizingSystem.setCentralHeatingDesignSupplyAirTemperature(20.0)
+      airloop.sizingSystem.setCentralCoolingDesignSupplyAirTemperature(13.0)
+      airloop.sizingSystem.setCentralHeatingDesignSupplyAirTemperature(22.0)
     when 'mixed'
       airloop.sizingSystem.setAllOutdoorAirinCooling(false)
       airloop.sizingSystem.setAllOutdoorAirinHeating(false)
@@ -637,7 +667,9 @@ class ECMS
 
   # =============================================================================================================================
   # create air system setpoint manager
-  def create_air_sys_spm(model, setpoint_mgr_type, zones)
+  def create_air_sys_spm(model,
+                         setpoint_mgr_type,
+                         zones)
     spm = nil
     case setpoint_mgr_type.downcase
     when 'scheduled'
@@ -653,7 +685,7 @@ class ECMS
     when 'warmest'
       spm = OpenStudio::Model::SetpointManagerWarmest.new(model)
       spm.setMinimumSetpointTemperature(13.0)
-      spm.setMaximumSetpointTemperature(43.0)
+      spm.setMaximumSetpointTemperature(22.0)
     end
 
     return spm
@@ -694,6 +726,9 @@ class ECMS
       clg_eqpt.addSpeed(clg_eqpt_speed1)
       clg_eqpt.setNominalSpeedLevel(1)
       clg_eqpt.setCrankcaseHeaterCapacity(1.0e-6)
+    when 'coil_chw'
+      clg_eqpt = OpenStudio::Model::CoilCoolingWater.new(model)
+      clg_eqpt.setName('CoilCoolingWater')
     when 'vrf'
       clg_eqpt = OpenStudio::Model::CoilCoolingDXVariableRefrigerantFlow.new(model)
       clg_eqpt.setName('CoilCoolingDXVariableRefrigerantFlow')
@@ -730,6 +765,9 @@ class ECMS
       htg_eqpt.setDefrostStrategy('ReverseCycle')
       htg_eqpt.setDefrostControl('OnDemand')
       htg_eqpt.setCrankcaseHeaterCapacity(1.0e-6)
+    when 'coil_hw'
+      htg_eqpt = OpenStudio::Model::CoilHeatingWater.new(model)
+      htg_eqpt.setName('CoilHeatingWater')
     end
 
     return htg_eqpt
@@ -737,19 +775,17 @@ class ECMS
 
   # =============================================================================================================================
   # add air system with all its components
-  def add_air_system(
-    model:,
-    zones:,
-    sys_abbr:,
-    sys_vent_type:,
-    sys_heat_rec_type:,
-    sys_htg_eqpt_type:,
-    sys_supp_htg_eqpt_type:,
-    sys_clg_eqpt_type:,
-    sys_supp_fan_type:,
-    sys_ret_fan_type:,
-    sys_setpoint_mgr_type:
-  )
+  def add_air_system(model:,
+                     zones:,
+                     sys_abbr:,
+                     sys_vent_type:,
+                     sys_heat_rec_type:,
+                     sys_htg_eqpt_type:,
+                     sys_supp_htg_eqpt_type:,
+                     sys_clg_eqpt_type:,
+                     sys_supp_fan_type:,
+                     sys_ret_fan_type:,
+                     sys_setpoint_mgr_type:)
 
     # create all the needed components and the air loop
     airloop = create_airloop(model, sys_vent_type)
@@ -787,7 +823,7 @@ class ECMS
     sys_name_pars['sys_rf'] = 'cv' if sys_ret_fan_type == 'constant_volume'
     sys_name_pars['sys_rf'] = 'vv' if sys_ret_fan_type == 'variable_volume'
     assign_base_sys_name(airloop, sys_abbr: sys_abbr, sys_oa: sys_vent_type, sys_name_pars: sys_name_pars)
-    return airloop, return_fan
+    return airloop, clg_eqpt, htg_eqpt, return_fan
   end
 
   # =============================================================================================================================
@@ -811,18 +847,27 @@ class ECMS
 
   # =============================================================================================================================
   # create zonal heating equipment
-  def create_zone_htg_eqpt(model, zone_htg_eqpt_type)
+  def create_zone_htg_eqpt(model, zone_htg_eqpt_type, hw_loop)
     always_on = model.alwaysOnDiscreteSchedule
     always_off = model.alwaysOffDiscreteSchedule
     htg_eqpt = nil
     case zone_htg_eqpt_type.downcase
     when 'baseboard_electric'
       htg_eqpt = OpenStudio::Model::ZoneHVACBaseboardConvectiveElectric.new(model)
-      htg_eqpt.setName('Zone HVAC Baseboard Convective Electric')
+      htg_eqpt.setName('ZoneHVACBaseboardConvectiveElectric')
+    when 'baseboard_hotwater'
+      htg_coil = OpenStudio::Model::CoilHeatingWaterBaseboard.new(model)
+      htg_coil.setName("CoilHeatingWaterBaseboard")
+      hw_loop.addDemandBranchForComponent(htg_coil)
+      htg_eqpt = OpenStudio::Model::ZoneHVACBaseboardConvectiveWater.new(model, model.alwaysOnDiscreteSchedule, htg_coil)
+      htg_eqpt.setName('ZoneHVACBaseboardConvectiveWater')
     when 'coil_electric', 'ptac_electric_off', 'unitheater_electric'
       htg_eqpt = OpenStudio::Model::CoilHeatingElectric.new(model, always_on)
       htg_eqpt.setName('CoilHeatingElectric')
       htg_eqpt.setAvailabilitySchedule(always_off) if zone_htg_eqpt_type == 'ptac_electric_off'
+    when 'fancoil_4pipe'
+      htg_eqpt = OpenStudio::Model::CoilHeatingWater.new(model)
+      htg_eqpt.setName('CoilHeatingWater_FanCoil')
     when 'pthp'
       htg_eqpt = OpenStudio::Model::CoilHeatingDXSingleSpeed.new(model)
       htg_eqpt.setName('CoilHeatingDXSingleSpeed_PTHP')
@@ -843,6 +888,9 @@ class ECMS
     always_on = model.alwaysOnDiscreteSchedule
     clg_eqpt = nil
     case zone_clg_eqpt_type.downcase
+    when 'fancoil_4pipe'
+      clg_eqpt = OpenStudio::Model::CoilCoolingWater.new(model)
+      clg_eqpt.setName('CoilCoolingWater_FanCoil')
     when 'ptac_electric_off', 'pthp'
       clg_eqpt = OpenStudio::Model::CoilCoolingDXSingleSpeed.new(model)
       clg_eqpt.setName('CoilCoolingDXSingleSpeed_PTHP') if zone_clg_eqpt_type.downcase == 'pthp'
@@ -858,20 +906,23 @@ class ECMS
 
   # =============================================================================================================================
   # create zpne container eqpt
-  def create_zone_container_eqpt(
-    model:,
-    zone_cont_eqpt_type:,
-    zone_htg_eqpt:,
-    zone_supp_htg_eqpt:,
-    zone_clg_eqpt:,
-    zone_fan:,
-    zone_vent_off: true
-  )
+  def create_zone_container_eqpt(model:,
+                                 zone_cont_eqpt_type:,
+                                 zone_htg_eqpt:,
+                                 zone_supp_htg_eqpt:,
+                                 zone_clg_eqpt:,
+                                 zone_fan:,
+                                 zone_vent_off: true)
 
     always_on = model.alwaysOnDiscreteSchedule
     always_off = model.alwaysOffDiscreteSchedule
     zone_eqpt = nil
     case zone_cont_eqpt_type.downcase
+    when 'fancoil_4pipe'
+      zone_eqpt = OpenStudio::Model::ZoneHVACFourPipeFanCoil.new(model, always_on, zone_fan, zone_clg_eqpt, zone_htg_eqpt)
+      zone_eqpt.setName('ZoneHVACFourPipeFanCoil')
+      zone_eqpt.setSupplyAirFanOperatingModeSchedule(always_off)
+      zone_eqpt.setMaximumOutdoorAirFlowRate(1.0e-6)
     when 'ptac_electric_off'
       zone_eqpt = OpenStudio::Model::ZoneHVACPackagedTerminalAirConditioner.new(model, always_on, zone_fan, zone_htg_eqpt, zone_clg_eqpt)
       zone_eqpt.setName('ZoneHVACPackagedTerminalAirConditioner')
@@ -919,7 +970,8 @@ class ECMS
                     zone_htg_eqpt_type:,
                     zone_supp_htg_eqpt_type:,
                     zone_clg_eqpt_type:,
-                    zone_fan_type:)
+                    zone_fan_type:,
+                    hw_loop: nil)
 
     always_on = model.alwaysOnDiscreteSchedule
     zones.sort.each do |zone|
@@ -934,13 +986,14 @@ class ECMS
         airloop.addBranchForZone(zone, diffuser.to_StraightComponent)
       end
       clg_eqpt = create_zone_clg_eqpt(model, zone_clg_eqpt_type)
-      htg_eqpt = create_zone_htg_eqpt(model, zone_htg_eqpt_type)
-      supp_htg_eqpt = create_zone_htg_eqpt(model, zone_supp_htg_eqpt_type)
+      htg_eqpt = create_zone_htg_eqpt(model, zone_htg_eqpt_type, hw_loop)
+      supp_htg_eqpt = create_zone_htg_eqpt(model, zone_supp_htg_eqpt_type, hw_loop)
       fan = create_air_sys_fan(model, zone_fan_type)
       # for container zonal equipment call method "create_zone_container_equipment"
       this_is_container_comp = false
       if (zone_htg_eqpt_type == 'pthp') || (zone_htg_eqpt_type == 'vrf') ||
-         (zone_htg_eqpt_type.include? 'unitheater') || (zone_htg_eqpt_type.include? 'ptac')
+         (zone_htg_eqpt_type.include? 'unitheater') || (zone_htg_eqpt_type.include? 'ptac') ||
+         (zone_htg_eqpt_type.include? 'fancoil')
         this_is_container_comp = true
         zone_cont_eqpt = create_zone_container_eqpt(model: model,
                                                     zone_cont_eqpt_type: zone_htg_eqpt_type,
@@ -958,11 +1011,159 @@ class ECMS
     end
     sys_name_zone_htg_eqpt_type = zone_htg_eqpt_type
     sys_name_zone_htg_eqpt_type = 'b-e' if zone_htg_eqpt_type == 'baseboard_electric' || zone_htg_eqpt_type == 'ptac_electric_off'
+    sys_name_zone_htg_eqpt_type = 'b-hw' if zone_htg_eqpt_type == 'baseboard_hotwater'
     sys_name_zone_clg_eqpt_type = zone_clg_eqpt_type
     sys_name_zone_clg_eqpt_type = 'ptac' if zone_clg_eqpt_type == 'ptac_electric_off'
     update_sys_name(airloop, zone_htg: sys_name_zone_htg_eqpt_type, zone_clg: sys_name_zone_clg_eqpt_type) if zone_diffuser_type
   end
 
+  # =============================================================================================================================
+  # add plant loop pump
+  def create_plantloop_pump(model, loop_pump_type)
+
+    pump = nil
+    case loop_pump_type.downcase
+    when "constant_speed"
+      pump = OpenStudio::Model::PumpConstantSpeed.new(model)
+      pump.setName("PumpConstantSpeed")
+    when "variable_speed"
+      pump = OpenStudio::Model::PumpVariableSpeed.new(model)
+      pump.setName("PumpVariableSpeed")
+    end
+
+    return pump
+  end
+
+  # =============================================================================================================================
+  # add plant loop heating eqpt
+  # created by: kamel.haddad@nrcan-rncan.gc.ca (August 2021)
+  def create_plantloop_htg_eqpt(model, loop_htg_eqpt_type)
+
+    htg_eqpt = nil
+    case loop_htg_eqpt_type.downcase
+    when "district_heating"
+     htg_eqpt = OpenStudio::Model::DistrictHeating.new(model)
+     htg_eqpt.setName("DistrictHeating")
+    when "heatpump_watertowater_equationfit"
+      htg_eqpt = OpenStudio::Model::HeatPumpWaterToWaterEquationFitHeating.new(model)
+      htg_eqpt.setName("HeatPumpWaterToWaterEquationFitHeating")
+    end
+
+    return htg_eqpt
+  end
+
+  # =============================================================================================================================
+  # add plant loop cooling eqpt
+  def create_plantloop_clg_eqpt(model, loop_clg_eqpt_type)
+
+    clg_eqpt = nil
+    case loop_clg_eqpt_type.downcase
+    when "chiller_electric_eir"
+      clg_eqpt = OpenStudio::Model::ChillerElectricEIR.new(model)
+      clg_eqpt.setName("ChillerElectricEIR")
+    when "district_cooling"
+      clg_eqpt = OpenStudio::Model::DistrictCooling.new(model)
+      clg_eqpt.setName("DistrictCooling")
+    when "heatpump_watertowater_equationfit"
+      clg_eqpt = OpenStudio::Model::HeatPumpWaterToWaterEquationFitCooling.new(model)
+      clg_eqpt.setName("HeatPumpWaterToWaterEquationFitCooling")
+    end
+
+    return clg_eqpt
+
+  end
+
+  # =============================================================================================================================
+  # add plant loop setpoint manager
+  def create_plantloop_spm( model, loop_spm_type, loop_setpoint)
+
+    spm = nil
+    case loop_spm_type.downcase
+    when "scheduled"
+      sch = OpenStudio::Model::ScheduleConstant.new(model)
+      sch.setValue(loop_setpoint)
+      spm = OpenStudio::Model::SetpointManagerScheduled.new(model,sch)
+      spm.setName("SetpointManagerScheduled")
+    when "followgroundtemperature"
+      spm = OpenStudio::Model::SetpointManagerFollowGroundTemperature.new(model)
+      spm.setReferenceGroundTemperatureObjectType("Site:GroundTemperature:Deep")
+      spm.setMinimumSetpointTemperature(0.0)
+    end
+
+    return spm
+  end
+
+  # =============================================================================================================================
+  # add plant loop heat rejection equipment
+  def create_plantloop_heat_rej_eqpt(model, loop_heat_rej_eqpt_type)
+
+    heat_rej_eqpt = nil
+    case loop_heat_rej_eqpt_type.downcase
+    when "tower_single_speed"
+      heat_rej_eqpt = OpenStudio::Model::CoolingTowerSingleSpeed.new(model)
+      heat_rej_eqpt.setName("CoolingTowerSingleSpeed")
+    when "vertical_ground_hx"
+      heat_rej_eqpt = OpenStudio::Model::GroundHeatExchangerVertical.new(model)
+      heat_rej_eqpt.setName("GroundHeatExchangerVertical")
+    when "district_heating"
+      heat_rej_eqpt = OpenStudio::Model::DistrictHeating.new(model)
+      heat_rej_eqpt.setName("DistrictHeating")
+    when "district_cooling"
+      heat_rej_eqpt = OpenStudio::Model::DistrictCooling.new(model)
+      heat_rej_eqpt.setName("DistrictCooling")
+    end
+
+    return heat_rej_eqpt
+  end
+
+  # =============================================================================================================================
+  # add plant loop with all its components
+  def add_plantloop(model:,
+                    loop_htg_eqpt_type:,
+                    loop_clg_eqpt_type:,
+                    loop_heat_rej_eqpt_type:,
+                    loop_pump_type:,
+                    loop_spm_type:,
+                    loop_setpoint:,
+                    loop_temp_diff:)
+
+    # create all the needed components and the plant loop
+    plantloop = OpenStudio::Model::PlantLoop.new(model)
+    spm = create_plantloop_spm(model, loop_spm_type, loop_setpoint)
+    pump = create_plantloop_pump(model, loop_pump_type)
+    htg_eqpt = create_plantloop_htg_eqpt(model, loop_htg_eqpt_type)
+    clg_eqpt = create_plantloop_clg_eqpt(model, loop_clg_eqpt_type)
+    heat_rej_eqpt = create_plantloop_heat_rej_eqpt(model, loop_heat_rej_eqpt_type)
+    if heat_rej_eqpt.nil?
+      if !htg_eqpt.nil?
+        plantloop.sizingPlant.setLoopType('Heating')
+        plantloop.setName("HW PlantLoop")
+        eqpt = htg_eqpt
+      elsif !clg_eqpt.nil?
+        plantloop.sizingPlant.setLoopType('Cooling')
+        plantloop.setName("CHW PlantLoop")
+        eqpt = clg_eqpt
+      end
+    elsif !heat_rej_eqpt.nil?
+      plantloop.sizingPlant.setLoopType('Condenser')
+      plantloop.setName("Condenser PlantLoop")
+      eqpt = heat_rej_eqpt
+    end
+    plantloop.sizingPlant.setDesignLoopExitTemperature(loop_setpoint) if loop_setpoint != 'none'
+    plantloop.sizingPlant.setLoopDesignTemperatureDifference(loop_temp_diff) if loop_temp_diff != 'none'
+    bypass_pipe = OpenStudio::Model::PipeAdiabatic.new(model)
+    supply_outlet_pipe = OpenStudio::Model::PipeAdiabatic.new(model)
+    supply_inlet_node = plantloop.supplyInletNode
+    supply_outlet_node = plantloop.supplyOutletNode
+    pump.addToNode(supply_inlet_node)
+    plantloop.addSupplyBranchForComponent(eqpt)
+    plantloop.addSupplyBranchForComponent(bypass_pipe)
+    supply_outlet_pipe.addToNode(supply_outlet_node)
+    spm.addToNode(supply_outlet_node) if loop_spm_type != 'none'
+
+    return plantloop,eqpt
+  end
+
   # =============================================================================================================================
   # Set assumptions for type of components for air system based on the number of zones served by the system and whether it's
   # a mixed or doas.
@@ -1006,7 +1207,7 @@ class ECMS
   #   -Constant-volume reheat system for single zone systems
   #   -VAV system with reheat for non DOAS multi-zone systems
   #   -Cold-climate air-source heat pump for heating and cooling with electric backup
-  #   -Electric baseboards
+  #   -Electric or hot-water baseboards
   def add_ecm_hs09_ccashp_baseboard(model:,
                                     system_zones_map:,    # hash of ailoop names as keys and array of zones as values
                                     system_doas_flags:,   # hash of system names as keys and flag for DOAS as values
@@ -1014,6 +1215,10 @@ class ECMS
                                     heating_fuel:,
                                     standard:)
 
+    # Create one hot-water loop for hot-water baseboards if primary heating fuel is gas
+    hw_loop = nil
+    hw_loop = add_hotwater_loop(model: model) if heating_fuel == 'NaturalGas'
+
     # Set heating fuel
     updated_heating_fuel = heating_fuel
     if heating_fuel == 'DefaultFuel'
@@ -1030,7 +1235,7 @@ class ECMS
                                            zones: zones,
                                            system_doas_flags: system_doas_flags)
       # add airloop and its equipment
-      airloop, return_fan = add_air_system(
+      airloop,clg_dx_coil,htg_dx_coil,return_fan = add_air_system(
         model: model,
         zones: zones,
         sys_abbr: sys_info['sys_abbr'],
@@ -1043,19 +1248,13 @@ class ECMS
         sys_ret_fan_type: sys_info['sys_ret_fan_type'],
         sys_setpoint_mgr_type: sys_info['sys_setpoint_mgr_type']
       )
-      htg_dx_coils = model.getCoilHeatingDXVariableSpeeds
-      search_criteria = {}
-      search_criteria['name'] = 'Mitsubishi_Hyper_Heating_VRF_Outdoor_Unit RTU',
-                                props = model_find_object(standards_data['tables']['heat_pump_heating_ecm']['table'], search_criteria, 1.0)
-      heat_defrost_eir_ft = model_add_curve(model, props['heat_defrost_eir_ft'])
-      # This defrost curve has to be assigned here before sizing
-      if heat_defrost_eir_ft
-        htg_dx_coils.sort.each { |dxcoil| dxcoil.setDefrostEnergyInputRatioFunctionofTemperatureCurve(heat_defrost_eir_ft) }
-      else
-        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXVariableSpeed', "For #{htg_dx_coils[0].name}, cannot find heat_defrost_eir_ft curve, will not be set.")
-      end
+      # Appy performance curves
+      eqpt_name = 'Mitsubishi_Hyper_Heating_VRF_Outdoor_Unit RTU'
+      coil_cooling_dx_variable_speed_apply_curves(clg_dx_coil, eqpt_name)
+      coil_heating_dx_variable_speed_apply_curves(htg_dx_coil, eqpt_name)
       # add zone equipment and diffuser
-      zone_htg_eqpt_type = 'baseboard_electric'
+      zone_htg_eqpt_type = 'baseboard_hotwater' if heating_fuel == 'NaturalGas'
+      zone_htg_eqpt_type = 'baseboard_electric' if heating_fuel == 'Electricity'
       zone_htg_eqpt_type = 'ptac_electric_off' if sys_info['sys_vent_type'] == 'doas'
       zone_clg_eqpt_type = 'none'
       zone_clg_eqpt_type = 'ptac_electric_off' if sys_info['sys_vent_type'] == 'doas'
@@ -1069,18 +1268,22 @@ class ECMS
                     zone_htg_eqpt_type: zone_htg_eqpt_type,
                     zone_supp_htg_eqpt_type: 'none',
                     zone_clg_eqpt_type: zone_clg_eqpt_type,
-                    zone_fan_type: zone_fan_type)
-      # for doas use baseboard electric as backup for PTAC units
+                    zone_fan_type: zone_fan_type,
+                    hw_loop: hw_loop)
+      # for doas use baseboard electric or hotwater as backup for PTAC units
+      zone_htg_eqpt_type = 'baseboard_hotwater' if heating_fuel == 'NaturalGas'
+      zone_htg_eqpt_type = 'baseboard_electric' if heating_fuel == 'Electricity'
       if sys_info['sys_vent_type'] == 'doas'
         add_zone_eqpt(model: model,
                       airloop: airloop,
                       zones: zones,
                       outdoor_unit: nil,
                       zone_diffuser_type: nil,
-                      zone_htg_eqpt_type: 'baseboard_electric',
+                      zone_htg_eqpt_type: zone_htg_eqpt_type,
                       zone_supp_htg_eqpt_type: 'none',
                       zone_clg_eqpt_type: 'none',
-                      zone_fan_type: 'none')
+                      zone_fan_type: 'none',
+                      hw_loop: hw_loop)
       end
       return_fan.addToNode(airloop.returnAirNode.get) if return_fan
       systems << airloop
@@ -1090,7 +1293,7 @@ class ECMS
   end
 
   # =============================================================================================================================
-  # Apply efficiencies and performance curves for ECM "hs09_ccashp_baseboard"
+  # Apply effiencies for ECM "hs09_ccashp_baseboard"
   def apply_efficiency_ecm_hs09_ccashp_baseboard(model)
     # fraction of electric backup heating coil capacity assigned to dx heating coil
     fr_backup_coil_cap_as_dx_coil_cap = 0.5
@@ -1166,10 +1369,11 @@ class ECMS
         if dx_cap < clg_dx_coil_cap then dx_cap = clg_dx_coil_cap end
         clg_dx_coil.setGrossRatedTotalCoolingCapacityAtSelectedNominalSpeedLevel(dx_cap)
         htg_dx_coil.setRatedHeatingCapacityAtSelectedNominalSpeedLevel(dx_cap)
-        # Assign performance curves and COPs
-        eqpt_name = 'Mitsubishi_Hyper_Heating_VRF_Outdoor_Unit RTU'
-        coil_cooling_dx_variable_speed_apply_efficiency_and_curves(clg_dx_coil, eqpt_name)
-        coil_heating_dx_variable_speed_apply_efficiency_and_curves(htg_dx_coil, eqpt_name)
+        # Assign COPs
+        search_criteria = {}
+        search_criteria['name'] = 'Mitsubishi_Hyper_Heating_VRF_Outdoor_Unit RTU'
+        coil_cooling_dx_variable_speed_apply_cop(clg_dx_coil, search_criteria, false)
+        coil_heating_dx_variable_speed_apply_cop(htg_dx_coil, search_criteria, false)
       end
     end
   end
@@ -1184,6 +1388,7 @@ class ECMS
                              ecm_system_zones_map_option:,
                              standard:,
                              heating_fuel:)
+    hw_loop = nil
 
     # Set heating fuel
     updated_heating_fuel = heating_fuel
@@ -1196,13 +1401,8 @@ class ECMS
     sys_supp_htg_eqpt_type = 'coil_electric'
     sys_supp_htg_eqpt_type = 'coil_gas' if updated_heating_fuel == 'NaturalGas'
     # Update system zones map if needed
-    if ecm_system_zones_map_option != 'NECB_Default'
-      system_zones_map = update_system_zones_map(model,system_zones_map,ecm_system_zones_map_option,'sys_1')
-    else
-      updated_system_zones_map = {}
-      system_zones_map.each {|sname,zones| updated_system_zones_map["sys_1#{sname[5..-1]}"] = zones}
-      system_zones_map = updated_system_zones_map
-    end
+    system_zones_map = update_system_zones_map_keys(system_zones_map,'sys_1')
+    system_zones_map = update_system_zones_map(model,system_zones_map,ecm_system_zones_map_option,'sys_1') if ecm_system_zones_map_option != 'NECB_Default'
     # Update system doas flags
     system_doas_flags = {}
     system_zones_map.keys.each { |sname| system_doas_flags[sname] = true }
@@ -1212,7 +1412,7 @@ class ECMS
       sys_info = air_sys_comps_assumptions(sys_name: sys_name,
                                            zones: zones,
                                            system_doas_flags: system_doas_flags)
-      airloop, return_fan = add_air_system(model: model,
+      airloop,clg_dx_coil,htg_dx_coil,return_fan = add_air_system(model: model,
                                            zones: zones,
                                            sys_abbr: sys_info['sys_abbr'],
                                            sys_vent_type: sys_info['sys_vent_type'],
@@ -1223,20 +1423,9 @@ class ECMS
                                            sys_supp_fan_type: sys_info['sys_supp_fan_type'],
                                            sys_ret_fan_type: sys_info['sys_ret_fan_type'],
                                            sys_setpoint_mgr_type: sys_info['sys_setpoint_mgr_type'])
-      # Get and assign defrost performance curve
-      search_criteria = {}
-      search_criteria['name'] = 'HS11_PTHP'
-      props = model_find_object(standards_data['tables']['heat_pump_heating_ecm']['table'], search_criteria, 1.0)
-      heat_defrost_eir_ft = model_add_curve(model, props['heat_defrost_eir_ft'])
-      if !heat_defrost_eir_ft
-        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXConstantSpeed', 'Cannot find heat_defrost_eir_ft curve, will not be set.')
-      end
-      airloop.supplyComponents.each do |comp|
-        if comp.to_CoilHeatingDXSingleSpeed.is_initialized
-          htg_coil = comp.to_CoilHeatingDXSingleSpeed.get
-          htg_coil.setDefrostEnergyInputRatioFunctionofTemperatureCurve(heat_defrost_eir_ft)
-        end
-      end
+      eqpt_name = 'HS11_PTHP'
+      coil_cooling_dx_single_speed_apply_curves(clg_dx_coil,eqpt_name)
+      coil_heating_dx_single_speed_apply_curves(htg_dx_coil,eqpt_name)
       # add zone equipment and diffuser
       zone_htg_eqpt_type = 'pthp'
       zone_clg_eqpt_type = 'pthp'
@@ -1250,13 +1439,18 @@ class ECMS
                     zone_htg_eqpt_type: zone_htg_eqpt_type,
                     zone_supp_htg_eqpt_type: zone_supp_htg_eqpt_type,
                     zone_clg_eqpt_type: zone_clg_eqpt_type,
-                    zone_fan_type: zone_fan_type)
+                    zone_fan_type: zone_fan_type,
+                    hw_loop: hw_loop)
       zones.each do |zone|
         zone.equipment.each do |comp|
           if comp.to_ZoneHVACPackagedTerminalHeatPump.is_initialized
             if comp.to_ZoneHVACPackagedTerminalHeatPump.get.heatingCoil.to_CoilHeatingDXSingleSpeed.is_initialized
               htg_coil = comp.to_ZoneHVACPackagedTerminalHeatPump.get.heatingCoil.to_CoilHeatingDXSingleSpeed.get
-              htg_coil.setDefrostEnergyInputRatioFunctionofTemperatureCurve(heat_defrost_eir_ft)
+              coil_heating_dx_single_speed_apply_curves(htg_coil,eqpt_name)
+            end
+            if comp.to_ZoneHVACPackagedTerminalHeatPump.get.coolingCoil.to_CoilCoolingDXSingleSpeed.is_initialized
+              clg_coil = comp.to_ZoneHVACPackagedTerminalHeatPump.get.coolingCoil.to_CoilCoolingDXSingleSpeed.get
+              coil_cooling_dx_single_speed_apply_curves(clg_coil,eqpt_name)
             end
           end
         end
@@ -1319,9 +1513,11 @@ class ECMS
             if dx_cap < clg_dx_coil_cap then dx_cap = clg_dx_coil_cap end
             # clg_dx_coil.setRatedTotalCoolingCapacity(dx_cap)
             # htg_dx_coil.setRatedTotalHeatingCapacity(dx_cap)
-            # assign performance curves and COPs
-            coil_cooling_dx_single_speed_apply_efficiency_and_curves(clg_dx_coil, pthp_eqpt_name)
-            coil_heating_dx_single_speed_apply_efficiency_and_curves(htg_dx_coil, pthp_eqpt_name)
+            # assign COPs
+            search_criteria = {}
+            search_criteria['name'] = pthp_eqpt_name
+            coil_cooling_dx_single_speed_apply_cop(clg_dx_coil, search_criteria)
+            coil_heating_dx_single_speed_apply_cop(htg_dx_coil, search_criteria)
             # Set fan power
             fan_power_per_flow_rate = 150.0 # based on Mitsubishi data: 100 low and 200 high (W-s/m3)
             fan_pr_rise = fan_power_per_flow_rate * (fan.fanEfficiency * fan.motorEfficiency)
@@ -1337,7 +1533,7 @@ class ECMS
   #   -Constant-volume reheat system for single zone systems
   #   -VAV system with reheat for non DOAS multi-zone systems
   #   -Air-source heat pump for heating and cooling with electric backup
-  #   -Electric baseboards
+  #   -Electric or hot-water baseboards
   def add_ecm_hs12_ashp_baseboard(model:,
                                   system_zones_map:,
                                   system_doas_flags:,
@@ -1345,6 +1541,10 @@ class ECMS
                                   standard:,
                                   heating_fuel:)
 
+    # Create one hot-water loop for hot-water baseboards if primary heating fuel is gas
+    hw_loop = nil
+    hw_loop = add_hotwater_loop(model: model) if heating_fuel == 'NaturalGas'
+
     # Set heating fuel
     updated_heating_fuel = heating_fuel
     if heating_fuel == 'DefaultFuel'
@@ -1361,7 +1561,7 @@ class ECMS
                                            zones: zones,
                                            system_doas_flags: system_doas_flags)
       # add air loop and its equipment
-      airloop, return_fan = add_air_system(model: model,
+      airloop,clg_dx_coil,htg_dx_coil,return_fan = add_air_system(model: model,
                                            zones: zones,
                                            sys_abbr: sys_info['sys_abbr'],
                                            sys_vent_type: sys_info['sys_vent_type'],
@@ -1372,19 +1572,12 @@ class ECMS
                                            sys_supp_fan_type: sys_info['sys_supp_fan_type'],
                                            sys_ret_fan_type: sys_info['sys_ret_fan_type'],
                                            sys_setpoint_mgr_type: sys_info['sys_setpoint_mgr_type'])
-      # get and assign defrost curve
-      htg_dx_coils = model.getCoilHeatingDXSingleSpeeds
-      search_criteria = {}
-      search_criteria['name'] = 'NECB2015_ASHP'
-      props = model_find_object(standards_data['tables']['heat_pump_heating_ecm']['table'], search_criteria, 1.0)
-      heat_defrost_eir_ft = model_add_curve(model, props['heat_defrost_eir_ft'])
-      if heat_defrost_eir_ft
-        htg_dx_coils.sort.each { |dxcoil| dxcoil.setDefrostEnergyInputRatioFunctionofTemperatureCurve(heat_defrost_eir_ft) }
-      else
-        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{htg_dx_coils[0].name}, cannot find heat_defrost_eir_ft curve, will not be set.")
-      end
+      eqpt_name = 'NECB2015_ASHP'
+      coil_cooling_dx_single_speed_apply_curves(clg_dx_coil,eqpt_name)
+      coil_heating_dx_single_speed_apply_curves(htg_dx_coil,eqpt_name)
       # add zone equipment and diffuser
-      zone_htg_eqpt_type = 'baseboard_electric'
+      zone_htg_eqpt_type = 'baseboard_hotwater' if heating_fuel == 'NaturalGas'
+      zone_htg_eqpt_type = 'baseboard_electric' if heating_fuel == 'Electricity'
       zone_htg_eqpt_type = 'ptac_electric_off' if sys_info['sys_vent_type'] == 'doas'
       zone_clg_eqpt_type = 'none'
       zone_clg_eqpt_type = 'ptac_electric_off' if sys_info['sys_vent_type'] == 'doas'
@@ -1398,18 +1591,20 @@ class ECMS
                     zone_htg_eqpt_type: zone_htg_eqpt_type,
                     zone_supp_htg_eqpt_type: 'none',
                     zone_clg_eqpt_type: zone_clg_eqpt_type,
-                    zone_fan_type: zone_fan_type)
-      # for doas use baseboard electric as backup for PTAC units
+                    zone_fan_type: zone_fan_type,
+                    hw_loop: hw_loop)
+      # for doas use baseboard electric or hotwater as backup for PTAC units
       if sys_info['sys_vent_type'] == 'doas'
         add_zone_eqpt(model: model,
                       airloop: airloop,
                       zones: zones,
                       outdoor_unit: nil,
                       zone_diffuser_type: nil,
-                      zone_htg_eqpt_type: 'baseboard_electric',
+                      zone_htg_eqpt_type: zone_htg_eqpt_type,
                       zone_supp_htg_eqpt_type: 'none',
                       zone_clg_eqpt_type: 'none',
-                      zone_fan_type: 'none')
+                      zone_fan_type: 'none',
+                      hw_loop: hw_loop)
       end
       return_fan.addToNode(airloop.returnAirNode.get) if return_fan
       systems << airloop
@@ -1479,9 +1674,11 @@ class ECMS
         if dx_cap < clg_dx_coil_cap then dx_cap = clg_dx_coil_cap end
         clg_dx_coil.setRatedTotalCoolingCapacity(dx_cap)
         htg_dx_coil.setRatedTotalHeatingCapacity(dx_cap)
-        # assign performance curves and COPs
-        coil_cooling_dx_single_speed_apply_efficiency_and_curves(clg_dx_coil, ashp_eqpt_name)
-        coil_heating_dx_single_speed_apply_efficiency_and_curves(htg_dx_coil, ashp_eqpt_name)
+        # assign COPs
+        search_criteria = {}
+        search_criteria['name'] = ashp_eqpt_name
+        coil_cooling_dx_single_speed_apply_cop(clg_dx_coil, search_criteria)
+        coil_heating_dx_single_speed_apply_cop(htg_dx_coil, search_criteria)
       end
     end
   end
@@ -1515,8 +1712,315 @@ class ECMS
   end
 
   # =============================================================================================================================
-  # Applies the standard efficiency ratings and typical performance curves "CoilCoolingDXSingleSpeed" object.
-  def coil_cooling_dx_single_speed_apply_efficiency_and_curves(coil_cooling_dx_single_speed, eqpt_name)
+  # Define object "SiteGroundTemperatureShallow" and use ground temperatures from weather file at 0.5 m depth
+  def set_undisturbed_ground_surface_temp_objs(model)
+    surface_ground_temp_obj = OpenStudio::Model::SiteGroundTemperatureShallow.new(model)
+    wfile_path = model.getWeatherFile.path.get.to_s
+    statsfile = EnergyPlus::StatFile.new(wfile_path.sub("epw","stat"))
+    surface_ground_temp_obj.setJanuarySurfaceGroundTemperature(statsfile.monthly_undis_ground_temps_0p5m[0])
+    surface_ground_temp_obj.setFebruarySurfaceGroundTemperature(statsfile.monthly_undis_ground_temps_0p5m[1])
+    surface_ground_temp_obj.setMarchSurfaceGroundTemperature(statsfile.monthly_undis_ground_temps_0p5m[2])
+    surface_ground_temp_obj.setAprilSurfaceGroundTemperature(statsfile.monthly_undis_ground_temps_0p5m[3])
+    surface_ground_temp_obj.setMaySurfaceGroundTemperature(statsfile.monthly_undis_ground_temps_0p5m[4])
+    surface_ground_temp_obj.setJuneSurfaceGroundTemperature(statsfile.monthly_undis_ground_temps_0p5m[5])
+    surface_ground_temp_obj.setJulySurfaceGroundTemperature(statsfile.monthly_undis_ground_temps_0p5m[6])
+    surface_ground_temp_obj.setAugustSurfaceGroundTemperature(statsfile.monthly_undis_ground_temps_0p5m[7])
+    surface_ground_temp_obj.setSeptemberSurfaceGroundTemperature(statsfile.monthly_undis_ground_temps_0p5m[8])
+    surface_ground_temp_obj.setOctoberSurfaceGroundTemperature(statsfile.monthly_undis_ground_temps_0p5m[9])
+    surface_ground_temp_obj.setNovemberSurfaceGroundTemperature(statsfile.monthly_undis_ground_temps_0p5m[10])
+    surface_ground_temp_obj.setDecemberSurfaceGroundTemperature(statsfile.monthly_undis_ground_temps_0p5m[11])
+  end
+
+  # =============================================================================================================================
+  # Define object "SiteGroundTemperatureDeep" and use ground temperatures from weather file at 4.0 m depth
+  def set_undisturbed_ground_deep_temp_objs(model)
+    surface_ground_temp_obj = OpenStudio::Model::SiteGroundTemperatureDeep.new(model)
+    wfile_path = model.getWeatherFile.path.get.to_s
+    statsfile = EnergyPlus::StatFile.new(wfile_path.sub("epw","stat"))
+    surface_ground_temp_obj.setJanuaryDeepGroundTemperature(statsfile.monthly_undis_ground_temps_4p0m[0])
+    surface_ground_temp_obj.setFebruaryDeepGroundTemperature(statsfile.monthly_undis_ground_temps_4p0m[1])
+    surface_ground_temp_obj.setMarchDeepGroundTemperature(statsfile.monthly_undis_ground_temps_4p0m[2])
+    surface_ground_temp_obj.setAprilDeepGroundTemperature(statsfile.monthly_undis_ground_temps_4p0m[3])
+    surface_ground_temp_obj.setMayDeepGroundTemperature(statsfile.monthly_undis_ground_temps_4p0m[4])
+    surface_ground_temp_obj.setJuneDeepGroundTemperature(statsfile.monthly_undis_ground_temps_4p0m[5])
+    surface_ground_temp_obj.setJulyDeepGroundTemperature(statsfile.monthly_undis_ground_temps_4p0m[6])
+    surface_ground_temp_obj.setAugustDeepGroundTemperature(statsfile.monthly_undis_ground_temps_4p0m[7])
+    surface_ground_temp_obj.setSeptemberDeepGroundTemperature(statsfile.monthly_undis_ground_temps_4p0m[8])
+    surface_ground_temp_obj.setOctoberDeepGroundTemperature(statsfile.monthly_undis_ground_temps_4p0m[9])
+    surface_ground_temp_obj.setNovemberDeepGroundTemperature(statsfile.monthly_undis_ground_temps_4p0m[10])
+    surface_ground_temp_obj.setDecemberDeepGroundTemperature(statsfile.monthly_undis_ground_temps_4p0m[11])
+  end
+
+  # =============================================================================================================================
+  # Add equipment for ECM "hs14_cgshp_fancoils"
+  #   -Constant volume DOAS with hydronic htg and clg coils.
+  #   -Zonal terminal fan coil (4-pipe) connected to central ground-source heat pump.
+  #   -Plant has a heating loop with water-to-water heat pump with a backup boiler. It also has a water-cooled chiller with a 
+  #    backup air-cooled chiller. Water-source heat pump and water-cooled chiller are connected to a ground-loop.
+  def add_ecm_hs14_cgshp_fancoils(model:,
+                                  system_zones_map:,
+                                  system_doas_flags:,
+                                  ecm_system_zones_map_option:,
+                                  standard:,
+                                  heating_fuel:)
+
+    updated_heating_fuel = heating_fuel
+    if heating_fuel == 'DefaultFuel'
+      epw = BTAP::Environment::WeatherFile.new(model.weatherFile.get.path.get)
+      updated_heating_fuel = standard.standards_data['regional_fuel_use'].detect { |fuel_sources| fuel_sources['state_province_regions'].include?(epw.state_province_region)}['fueltype_set']
+    end
+    raise("Heating fuel for ECM 'HS11_ASHP_PTHP' is neither Electricity nor NaturalGas") if ((updated_heating_fuel != 'Electricity') && (updated_heating_fuel != 'NaturalGas'))
+    # Set supplemental heaing for airloop
+    sys_supp_htg_eqpt_type = 'coil_electric'
+    sys_supp_htg_eqpt_type = 'coil_gas' if updated_heating_fuel == 'NaturalGas'
+    # Update system zones map if needed
+    system_zones_map = update_system_zones_map_keys(system_zones_map,'sys_1')
+    system_zones_map = update_system_zones_map(model,system_zones_map,ecm_system_zones_map_option,'sys_1') if ecm_system_zones_map_option != 'NECB_Default'
+    # Update system doas flags
+    system_doas_flags = {}
+    system_zones_map.keys.each { |sname| system_doas_flags[sname] = true }
+    # use system zones map and generate new air system and zonal equipment
+    systems = []
+    system_zones_map.sort.each do |sys_name, zones|
+      sys_info = air_sys_comps_assumptions(sys_name: sys_name,
+                                           zones: zones,
+                                           system_doas_flags: system_doas_flags)
+      airloop,clg_coil,htg_coil,return_fan = add_air_system(model: model,
+                                           zones: zones,
+                                           sys_abbr: sys_info['sys_abbr'],
+                                           sys_vent_type: sys_info['sys_vent_type'],
+                                           sys_heat_rec_type: sys_info['sys_heat_rec_type'],
+                                           sys_htg_eqpt_type: 'coil_hw',
+                                           sys_supp_htg_eqpt_type: 'none',
+                                           sys_clg_eqpt_type: 'coil_chw',
+                                           sys_supp_fan_type: sys_info['sys_supp_fan_type'],
+                                           sys_ret_fan_type: sys_info['sys_ret_fan_type'],
+                                           sys_setpoint_mgr_type: 'warmest')
+
+      # add zone equipment and diffuser
+      zone_htg_eqpt_type = 'fancoil_4pipe'
+      zone_clg_eqpt_type = 'fancoil_4pipe'
+      zone_supp_htg_eqpt_type = 'none'
+      zone_fan_type = 'on_off'
+      add_zone_eqpt(model: model,
+                    airloop: airloop,
+                    zones: zones,
+                    outdoor_unit: nil,
+                    zone_diffuser_type: sys_info['zone_diffuser_type'],
+                    zone_htg_eqpt_type: zone_htg_eqpt_type,
+                    zone_supp_htg_eqpt_type: zone_supp_htg_eqpt_type,
+                    zone_clg_eqpt_type: zone_clg_eqpt_type,
+                    zone_fan_type: zone_fan_type)
+
+      return_fan.addToNode(airloop.returnAirNode.get) if return_fan
+      systems << airloop
+    end
+
+    # add hot-water loop
+    hw_loop,hw_loop_htg_eqpt = add_plantloop(model: model,
+                                             loop_htg_eqpt_type: 'HeatPump_WaterToWater_EquationFit',
+                                             loop_clg_eqpt_type: 'none',
+                                             loop_heat_rej_eqpt_type: 'none',
+                                             loop_pump_type: 'variable_speed',
+                                             loop_spm_type: 'Scheduled',
+                                             loop_setpoint: 50.0,
+                                             loop_temp_diff: 5.0)
+    model.getCoilHeatingWaters.each {|coil| hw_loop.addDemandBranchForComponent(coil)}
+    hcapf_curve_name = "HEATPUMP_WATERTOWATER_HCAPF"
+    hcapf_curve = model_add_curve(model, hcapf_curve_name)
+    if hcapf_curve
+      hw_loop_htg_eqpt.setHeatingCapacityCurve(hcapf_curve)
+    else
+      raise("Can not find curve hcapf for  #{hw_loop_htg_eqpt.name}")
+    end    
+    hpowerf_curve_name = "HEATPUMP_WATERTOWATER_HPOWERF"
+    hpowerf_curve = model_add_curve(model, hpowerf_curve_name)
+    if hpowerf_curve
+      hw_loop_htg_eqpt.setHeatingCompressorPowerCurve(hpowerf_curve)
+    else
+      raise("Can not find curve hpowerf for #{hw_loop_htg_eqpt.name}")
+    end
+    boiler = OpenStudio::Model::BoilerHotWater.new(model)
+    boiler.setFuelType(updated_heating_fuel)
+    hw_loop_htg_eqpt_outlet_node = hw_loop_htg_eqpt.supplyOutletModelObject.get.to_Node.get
+    boiler.addToNode(hw_loop_htg_eqpt_outlet_node)
+
+    # add chilled-water loop
+    chw_loop,chw_loop_clg_eqpt = add_plantloop(model: model,
+                                               loop_htg_eqpt_type: 'none',
+                                               loop_clg_eqpt_type: 'chiller_electric_eir',
+                                               loop_heat_rej_eqpt_type: 'none',
+                                               loop_pump_type: 'variable_speed',
+                                               loop_spm_type: 'Scheduled',
+                                               loop_setpoint: 7.0,
+                                               loop_temp_diff: 6.0)
+    
+    chw_loop_clg_eqpt.setName('ChillerWaterCooled')
+    chw_loop_clg_eqpt.setCondenserType("WaterCooled")
+    model.getCoilCoolingWaters.each {|coil| chw_loop.addDemandBranchForComponent(coil)}
+    sec_chiller = OpenStudio::Model::ChillerElectricEIR.new(model)
+    chw_loop_clg_eqpt_outlet_node = chw_loop_clg_eqpt.supplyOutletModelObject.get.to_Node.get
+    sec_chiller.addToNode(chw_loop_clg_eqpt_outlet_node)
+    sec_chiller.setName('ChillerAirCooled')
+
+    # add ground HX loop with district heating and cooling plant to represent the ground HX
+    heat_rej_loop,heat_rej_loop_eqpt = add_plantloop(model: model,
+                                                     loop_htg_eqpt_type: 'none',
+                                                     loop_clg_eqpt_type: 'none',
+                                                     loop_heat_rej_eqpt_type: 'District_Heating',
+                                                     loop_pump_type: 'variable_speed',
+                                                     loop_spm_type: 'none',
+                                                     loop_setpoint: 'none',
+                                                     loop_temp_diff: 10.0)
+    heat_rej_loop_eqpt.setName('DistrictHeating GLHX')
+    htg_eqpt_outlet_node = heat_rej_loop_eqpt.outletModelObject.get.to_Node.get
+    clg_eqpt = create_plantloop_clg_eqpt(model, 'District_Cooling')
+    clg_eqpt.setName('DistrictCooling GLHX')
+    clg_eqpt.addToNode(htg_eqpt_outlet_node)
+    htg_spm = create_plantloop_spm( model, 'Scheduled', 5.0)
+    htg_spm.addToNode(htg_eqpt_outlet_node)
+    clg_eqpt_outlet_node = clg_eqpt.outletModelObject.get.to_Node.get
+    clg_spm = create_plantloop_spm( model, 'Scheduled', 25.0)
+    clg_spm.addToNode(heat_rej_loop.supplyOutletNode)
+    heat_rej_loop.setName("#{heat_rej_loop.name.to_s} GLHX")        
+    heat_rej_loop.addDemandBranchForComponent(hw_loop_htg_eqpt)
+    heat_rej_loop.addDemandBranchForComponent(chw_loop_clg_eqpt)
+
+    # add output variables  for district heating and cooling
+    model.getOutputVariables.each {|ivar| ivar.remove}
+    dist_htg_var = OpenStudio::Model::OutputVariable.new("District Heating Hot Water Rate",model)
+    dist_htg_var.setReportingFrequency("hourly")
+    dist_htg_var.setKeyValue("*")
+    dist_clg_var = OpenStudio::Model::OutputVariable.new("District Cooling Chilled Water Rate",model)
+    dist_clg_var.setReportingFrequency("hourly")
+    dist_clg_var.setKeyValue("*")
+
+    return systems
+  end
+
+  #=============================================================================================================================
+  # Appy efficiencies for ECM "hs14_cgshp_fancoils"
+  def apply_efficiency_ecm_hs14_cgshp_fancoils(model)
+    heatpump_siz_f = 0.4  # sizing factor for water-source heat pump (heating mode)
+    chiller_siz_f = 0.4  # sizing factor for water-cooled chiller 
+    # get water-source heat pump
+    hw_loops = model.getPlantLoops.select {|loop| loop.sizingPlant.loopType.to_s.downcase == 'heating'}
+    hw_heatpump_loop = nil
+    hw_heatpump = nil
+    hw_loops.each do |hw_loop|
+      hw_heatpumps = hw_loop.supplyComponents.select {|comp| comp.to_HeatPumpWaterToWaterEquationFitHeating.is_initialized}
+      if !hw_heatpumps.empty?
+        hw_heatpump_loop = hw_loop
+        hw_heatpump = hw_heatpumps[0].to_HeatPumpWaterToWaterEquationFitHeating.get
+        break
+      end
+    end
+    raise("apply_efficiency_ecm_hs14_cgshp_fancoils: no water-source heat pump found in heating loop #{hw_loops.name.to_s}") if hw_heatpump.nil?
+    cw_loop = model.getPlantLoops.select {|loop| loop.sizingPlant.loopType.to_s.downcase == 'condenser'}[0]
+    # condenser flow rate is set based on heating loop flow rate and cooling loop flow rate (adjusted for sizing factors)
+    cw_loop_max_flow = 0.0
+    if hw_heatpump_loop.autosizedMaximumLoopFlowRate.is_initialized
+      cw_loop_max_flow += heatpump_siz_f*hw_heatpump_loop.autosizedMaximumLoopFlowRate.to_f
+    elsif hw_heatpump_loop.maximumLoopFlowRate.is_initialized
+      cw_loop_max_flow += heatpump_siz_f*hw_heatpump_loop.maximumLoopFlowRate.to_f
+    else
+      raise("apply_efficiency_ecm_hs14_cgshp_fancoils: heating loop #{hw_heatpump_loop.name.to_s} flow rate is not defined")
+    end
+    chw_loop = model.getPlantLoops.select {|loop| loop.sizingPlant.loopType.to_s.downcase == 'cooling'}[0]
+    if chw_loop.autosizedMaximumLoopFlowRate.is_initialized
+      cw_loop_max_flow += chiller_siz_f*chw_loop.autosizedMaximumLoopFlowRate.to_f
+    elsif chw_loop.maximumLoopFlowRate.is_initialized
+      cw_loop_max_flow += chiller_siz_f*chw_loop.maximumLoopFlowRate.to_f
+    else
+      raise("apply_efficiency_ecm_hs14_cgshp_fancoils: cooling loop #{chw_loop.name.to_s} is not defined")
+    end
+    cw_loop.setMaximumLoopFlowRate(cw_loop_max_flow)
+    cw_loop_pump = cw_loop.supplyComponents.select {|comp| comp.to_PumpVariableSpeed.is_initialized}[0].to_PumpVariableSpeed.get
+    cw_loop_pump.setRatedFlowRate(cw_loop_max_flow)
+    # set heating capacity of water-source heat pump
+    if hw_heatpump.autosizedRatedHeatingCapacity.is_initialized
+      cap = hw_heatpump.autosizedRatedHeatingCapacity.to_f
+    elsif hw_heatpump.ratedHeatingCapacity.is_initialized
+      cap = hw_heatpump.ratedHeatingCapacity.to_f
+    else
+      raise("apply_efficiency_ecm_hs14_cgshp_fancoils: capacity of water-source heat pump #{hw_heatpump.name.to_s} is not defined")
+    end
+    hw_heatpump.setRatedHeatingCapacity(heatpump_siz_f*cap)
+    # set cooling capacity of water-cooled chiller
+    chillers = chw_loop.supplyComponents.select {|comp| comp.to_ChillerElectricEIR.is_initialized}
+    chiller_water_cooled = nil
+    chillers.each do |comp|
+      chlr = comp.to_ChillerElectricEIR.get
+      if chlr.name.to_s.include? 'ChillerWaterCooled'
+        chiller_water_cooled = chlr
+        break
+      end
+    end
+    raise("apply_efficiency_ecm_hs14_cgshp_fancoils: no water-cooled chiller found in cooling loop #{chw_loop.name.to_s}") if chiller_water_cooled.nil?
+    if chiller_water_cooled.autosizedReferenceCapacity.is_initialized
+      cap = chiller_water_cooled.autosizedReferenceCapacity.to_f
+    elsif chiller_water_cooled.referenceCapacity.is_initialized
+      cap = chiller_water_cooled.referenceCapacity.to_f
+    else
+      raise("apply_efficiency_ecm_hs14_cgshp_fancoils: cooling capacity of chiller #{chiller_water_cooled.name.to_s} is not defined")
+    end
+    chiller_water_cooled.setReferenceCapacity(chiller_siz_f*cap)
+  end
+
+  #=============================================================================================================================
+  def set_ghx_loop_district_cap(model)
+    # The autosized values for the district heating and cooling objects on a condenser loop are the sum of the peak heating and 
+    # cooling loads. Here the capacity of the district heating object of the condenser loop is set to the maximum district heating 
+    # rate on the winter design day. Similarily the capacity of the district cooling object of the condenser loop is set to the 
+    # maximum district cooling rate on the summer design day.
+
+    cw_loops = model.getPlantLoops.select{|loop| loop.sizingPlant.loopType.to_s.downcase == 'condenser'}
+    ghx_loops = cw_loops.select {|loop| loop.name.to_s.downcase.include? 'glhx'}
+    return if ghx_loops.empty?
+    ghx_loop = ghx_loops[0]
+    dist_htg_eqpts = ghx_loop.supplyComponents.select {|comp| comp.to_DistrictHeating.is_initialized}
+    dist_htg_eqpt = dist_htg_eqpts[0].to_DistrictHeating.get if !dist_htg_eqpts.empty?
+    dist_clg_eqpts = ghx_loop.supplyComponents.select {|comp| comp.to_DistrictCooling.is_initialized}
+    dist_clg_eqpt = dist_clg_eqpts[0].to_DistrictCooling.get if !dist_clg_eqpts.empty?
+    raise("set_cond_loop_district_cap: condenser loop doesn't have a district heating and district cooling objects") if dist_htg_eqpts.empty? || dist_clg_eqpts.empty?
+    # District Heating
+    sql_command = "SELECT ReportVariableDataDictionaryIndex FROM ReportVariableDataDictionary
+               WHERE VariableName='District Heating Hot Water Rate'"
+    dhtg_index = model.sqlFile.get.execAndReturnFirstString(sql_command).get
+    raise("set_ghx_loop_district_cap: EnergyPlus sql results file has no data for district heating hot water rate") if dhtg_index.nil?
+    sql_command = "SELECT Value FROM ReportVariableWithTime
+               WHERE ReportDataDictionaryIndex=#{dhtg_index} AND DayType='WinterDesignDay'"
+    dist_htg_w = model.sqlFile.get.execAndReturnVectorOfString(sql_command).get
+    sql_command = "SELECT Value FROM ReportVariableWithTime
+               WHERE ReportDataDictionaryIndex=#{dhtg_index} AND DayType='SummerDesignDay'"
+    dist_htg_s = model.sqlFile.get.execAndReturnVectorOfString(sql_command).get
+    # District Cooling
+    sql_command = "SELECT ReportVariableDataDictionaryIndex FROM ReportVariableDataDictionary
+               WHERE VariableName='District Cooling Chilled Water Rate'"
+    dclg_index = model.sqlFile.get.execAndReturnFirstString(sql_command).get
+    raise("set_ghx_loop_district_cap: EnergyPlus sql results file has no data for district cooling chilled water rate") if dclg_index.nil?
+    sql_command = "SELECT Value FROM ReportVariableWithTime
+               WHERE ReportDataDictionaryIndex=#{dclg_index} AND DayType='SummerDesignDay'"
+    dist_clg_s = model.sqlFile.get.execAndReturnVectorOfString(sql_command).get
+    sql_command = "SELECT Value FROM ReportVariableWithTime
+               WHERE ReportDataDictionaryIndex=#{dclg_index} AND DayType='WinterDesignDay'"
+    dist_clg_w = model.sqlFile.get.execAndReturnVectorOfString(sql_command).get
+    # Assign peak heating and cooling loads to capacities of district objects
+    max_htg_load = 0.0
+    max_clg_load = 0.0
+    for hour in 1..24
+      htg_load = [dist_htg_w[hour-1].to_f-dist_clg_w[hour-1].to_f,0.0].max
+      clg_load = [dist_clg_s[hour-1].to_f-dist_htg_s[hour-1].to_f,0.0].max
+      max_htg_load = [max_htg_load,htg_load].max
+      max_clg_load = [max_clg_load,clg_load].max
+    end
+    dist_htg_eqpt.setNominalCapacity(max_htg_load)
+    dist_clg_eqpt.setNominalCapacity(max_clg_load)
+  end
+
+  # =============================================================================================================================
+  # Applies the performance curves "CoilCoolingDXSingleSpeed" object.
+  def coil_cooling_dx_single_speed_apply_curves(coil_cooling_dx_single_speed, eqpt_name)
     successfully_set_all_properties = true
 
     search_criteria = {}
@@ -1524,6 +2028,7 @@ class ECMS
 
     # Get the capacity
     capacity_w = coil_cooling_dx_single_speed_find_capacity(coil_cooling_dx_single_speed)
+    capacity_w = [1.0,capacity_w].max
     capacity_btu_per_hr = OpenStudio.convert(capacity_w, 'W', 'Btu/hr').get
 
     # Lookup efficiencies
@@ -1581,16 +2086,11 @@ class ECMS
       successfully_set_all_properties = false
     end
 
-    # Find the minimum COP and rename with efficiency rating
-    cop = coil_cooling_dx_single_speed_standard_minimum_cop(coil_cooling_dx_single_speed, search_criteria, false)
-
-    # Set the efficiency values
-    coil_cooling_dx_single_speed.setRatedCOP(cop.to_f) unless cop.nil?
   end
 
   # =============================================================================================================================
-  # Applies the standard efficiency ratings and typical performance curves to "CoilHeatingSingleSpeed" object.
-  def coil_heating_dx_single_speed_apply_efficiency_and_curves(coil_heating_dx_single_speed, eqpt_name)
+  # Applies the performance curves to "CoilHeatingSingleSpeed" object.
+  def coil_heating_dx_single_speed_apply_curves(coil_heating_dx_single_speed, eqpt_name)
     successfully_set_all_properties = true
 
     # Get the search criteria
@@ -1599,6 +2099,7 @@ class ECMS
 
     # Get the capacity
     capacity_w = coil_heating_dx_single_speed_find_capacity(coil_heating_dx_single_speed)
+    capacity_w = [1.0,capacity_w].max
     capacity_btu_per_hr = OpenStudio.convert(capacity_w, 'W', 'Btu/hr').get
     capacity_kbtu_per_hr = OpenStudio.convert(capacity_w, 'W', 'kBtu/hr').get
 
@@ -1655,32 +2156,37 @@ class ECMS
       OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{coil_heating_dx_single_speed.name}, cannot find heat_plf_fplr curve, will not be set.")
       successfully_set_all_properties = false
     end
+    
+    # Make the HEAT-DEFROST-EIR-FT curve
+    heat_defrost_eir_ft = model_add_curve(coil_heating_dx_single_speed.model, props['heat_defrost_eir_ft'])
+    if heat_defrost_eir_ft
+      coil_heating_dx_single_speed.setDefrostEnergyInputRatioFunctionofTemperatureCurve(heat_defrost_eir_ft)
+    else
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXSingleSpeed', "For #{coil_heating_dx_single_speed.name}, can not find heat_defrost_eir_ft curve, will not be set.")
+      successfully_set_all_properties = false
+    end
 
-    # Find the minimum COP and rename with efficiency rating
-    cop = coil_heating_dx_single_speed_standard_minimum_cop(coil_heating_dx_single_speed, search_criteria, false)
-
-    # Set the efficiency values
-    coil_heating_dx_single_speed.setRatedCOP(cop.to_f) unless cop.nil?
   end
 
   # =============================================================================================================================
-  # Applies the standard efficiency ratings and typical performance curves "CoilCoolingDXVariableSpeed" object.
-  def coil_cooling_dx_variable_speed_apply_efficiency_and_curves(coil_cooling_dx_variable_speed, eqpt_name)
+  # Applies the performance curves "CoilCoolingDXVariableSpeed" object.
+  def coil_cooling_dx_variable_speed_apply_curves(coil_cooling_dx_variable_speed, eqpt_name)
     successfully_set_all_properties = true
 
     # Get the capacity
     capacity_w = coil_cooling_dx_variable_speed_find_capacity(coil_cooling_dx_variable_speed)
+    capacity_w = [1.0,capacity_w].max
     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 performance curves
     search_criteria = {}
     search_criteria['name'] = eqpt_name
     ac_props = model_find_object(standards_data['tables']['heat_pump_cooling_ecm']['table'], search_criteria, capacity_btu_per_hr)
 
     # Check to make sure properties were found
     if ac_props.nil?
-      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standard.CoilCoolingDXVariableSpeed', "For #{coil_cooling_dx_single_speed.name}, cannot find efficiency info using #{search_criteria}, cannot apply efficiency.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standard.CoilCoolingDXVariableSpeed', "For #{coil_cooling_dx_variable_speed.name}, cannot find efficiency info using #{search_criteria}, cannot apply efficiency.")
       successfully_set_all_properties = false
     end
 
@@ -1729,16 +2235,11 @@ class ECMS
       successfully_set_all_properties = false
     end
 
-    # Find the minimum COP and rename with efficiency rating
-    cop = coil_cooling_dx_variable_speed_standard_minimum_cop(coil_cooling_dx_variable_speed, search_criteria, false)
-
-    # Set the efficiency values
-    coil_cooling_dx_variable_speed.speeds.each { |speed| speed.setReferenceUnitGrossRatedCoolingCOP(cop.to_f) } unless cop.nil?
   end
 
   # =============================================================================================================================
-  # Applies the standard efficiency ratings and typical performance curves to "CoilHeatingVariableSpeed" object.
-  def coil_heating_dx_variable_speed_apply_efficiency_and_curves(coil_heating_dx_variable_speed, eqpt_name)
+  # Applies performance curves to "CoilHeatingVariableSpeed" object.
+  def coil_heating_dx_variable_speed_apply_curves(coil_heating_dx_variable_speed, eqpt_name)
     successfully_set_all_properties = true
 
     # Get the search criteria
@@ -1747,10 +2248,11 @@ class ECMS
 
     # Get the capacity
     capacity_w = coil_heating_dx_variable_speed_find_capacity(coil_heating_dx_variable_speed)
+    capacity_w = [1.0,capacity_w].max
     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
+    # Lookup performance curves
     props = model_find_object(standards_data['tables']['heat_pump_heating_ecm']['table'], search_criteria, capacity_btu_per_hr)
 
     # Check to make sure properties were found
@@ -1804,27 +2306,31 @@ class ECMS
       successfully_set_all_properties = false
     end
 
-    # Find the minimum COP and rename with efficiency rating
-    cop = coil_heating_dx_variable_speed_standard_minimum_cop(coil_heating_dx_variable_speed, search_criteria, false)
+    # Make the heat_defrost_eir_ft
+    heat_defrost_eir_ft = model_add_curve(coil_heating_dx_variable_speed.model, props['heat_defrost_eir_ft'])
+    if heat_defrost_eir_ft
+      coil_heating_dx_variable_speed.setDefrostEnergyInputRatioFunctionofTemperatureCurve(heat_defrost_eir_ft)
+    else
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingDXVariableSpeed', "For #{coil_heating_dx_variable_speed.name}, cannot find heat_defrost_eir_ft curve, will not be set")
+      successfully_set_all_properties = false
+    end
 
-    # Set the efficiency values
-    coil_heating_dx_variable_speed.speeds.each { |speed| speed.setReferenceUnitGrossRatedHeatingCOP(cop.to_f) } unless cop.nil?
   end
 
   # =============================================================================================================================
-  # Applies the standard cooling efficiency ratings and typical performance curves to "AirConditionerVariableRefrigerantFlow" object.
-  def airconditioner_variablerefrigerantflow_cooling_apply_efficiency_and_curves(airconditioner_variablerefrigerantflow, eqpt_name)
+  # Applies the cooling performance curves to "AirConditionerVariableRefrigerantFlow" object.
+  def airconditioner_variablerefrigerantflow_cooling_apply_curves(airconditioner_variablerefrigerantflow, eqpt_name)
     successfully_set_all_properties = true
 
     search_criteria = {}
     search_criteria['name'] = eqpt_name
-
     # Get the capacity
     capacity_w = airconditioner_variablerefrigerantflow_cooling_find_capacity(airconditioner_variablerefrigerantflow)
+    capacity_w = [1.0,capacity_w].max
     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
+    # Lookup performance curves
     props = model_find_object(standards_data['tables']['heat_pump_cooling_ecm']['table'], search_criteria, capacity_btu_per_hr)
 
     # Check to make sure properties were found
@@ -1941,27 +2447,22 @@ class ECMS
       successfully_set_all_properties = false
     end
 
-    # Find the minimum COP
-    cop = airconditioner_variablerefrigerantflow_cooling_standard_minimum_cop(airconditioner_variablerefrigerantflow, search_criteria, false)
-
-    # Set the efficiency values
-    airconditioner_variablerefrigerantflow.setRatedCoolingCOP(cop.to_f) unless cop.nil?
   end
 
   # =============================================================================================================================
-  # Applies the standard heating efficiency ratings and typical performance curves to "AirConditionerVariableRefrigerantFlow" object.
-  def airconditioner_variablerefrigerantflow_heating_apply_efficiency_and_curves(airconditioner_variablerefrigerantflow, eqpt_name)
+  # Applies the heating performance curves to "AirConditionerVariableRefrigerantFlow" object.
+  def airconditioner_variablerefrigerantflow_heating_apply_curves(airconditioner_variablerefrigerantflow, eqpt_name)
     successfully_set_all_properties = true
 
     search_criteria = {}
     search_criteria['name'] = eqpt_name
-
     # Get the capacity
     capacity_w = airconditioner_variablerefrigerantflow_heating_find_capacity(airconditioner_variablerefrigerantflow)
+    capacity_w = [1.0,capacity_w].max
     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
+    # Lookup performance curves
     props = model_find_object(standards_data['tables']['heat_pump_heating_ecm']['table'], search_criteria, capacity_btu_per_hr)
 
     # Check to make sure properties were found
@@ -2069,18 +2570,13 @@ class ECMS
       successfully_set_all_properties = false
     end
 
-    # Find the minimum COP and rename with efficiency rating
-    cop = airconditioner_variablerefrigerantflow_heating_standard_minimum_cop(airconditioner_variablerefrigerantflow, search_criteria, false)
-
-    # Set the efficiency values
-    airconditioner_variablerefrigerantflow.setRatedHeatingCOP(cop.to_f) unless cop.nil?
   end
 
   # =============================================================================================================================
-  # Find minimum efficiency for "CoilCoolingDXSingleSpeed" object
-  def coil_cooling_dx_single_speed_standard_minimum_cop(coil_cooling_dx_single_speed,
-                                                        search_criteria,
-                                                        rename = false)
+  # Find efficiency for "CoilCoolingDXSingleSpeed" object
+  def coil_cooling_dx_single_speed_apply_cop(coil_cooling_dx_single_speed,
+                                             search_criteria,
+                                             rename = false)
 
     capacity_w = coil_cooling_dx_single_speed_find_capacity(coil_cooling_dx_single_speed)
     capacity_btu_per_hr = OpenStudio.convert(capacity_w, 'W', 'Btu/hr').get
@@ -2142,15 +2638,17 @@ class ECMS
     if rename
       coil_cooling_dx_single_speed.setName(new_comp_name)
     end
+    
+    # Set COP
+    coil_cooling_dx_single_speed.setRatedCOP(cop.to_f) unless cop.nil?
 
-    return cop
   end
 
   # =============================================================================================================================
-  # Find minimum efficiency for "CoilHeatingDXSingleSpeed" object
-  def coil_heating_dx_single_speed_standard_minimum_cop(coil_heating_dx_single_speed,
-                                                        search_criteria,
-                                                        rename = false)
+  # Find efficiency for "CoilHeatingDXSingleSpeed" object
+  def coil_heating_dx_single_speed_apply_cop(coil_heating_dx_single_speed,
+                                             search_criteria,
+                                             rename = false)
 
     capacity_w = coil_heating_dx_single_speed_find_capacity(coil_heating_dx_single_speed)
     capacity_btu_per_hr = OpenStudio.convert(capacity_w, 'W', 'Btu/hr').get
@@ -2205,14 +2703,16 @@ class ECMS
       coil_heating_dx_single_speed.setName(new_comp_name)
     end
 
-    return cop
+    # Set COP
+    coil_heating_dx_single_speed.setRatedCOP(cop.to_f) unless cop.nil?
+
   end
 
   # =============================================================================================================================
-  # Find minimum efficiency for "CoilCoolingDXVariableSpeed" object
-  def coil_cooling_dx_variable_speed_standard_minimum_cop(coil_cooling_dx_variable_speed,
-                                                          search_criteria,
-                                                          rename = false)
+  # Find efficiency for "CoilCoolingDXVariableSpeed" object
+  def coil_cooling_dx_variable_speed_apply_cop(coil_cooling_dx_variable_speed,
+                                               search_criteria,
+                                               rename = false)
 
     capacity_w = coil_cooling_dx_variable_speed_find_capacity(coil_cooling_dx_variable_speed)
     capacity_btu_per_hr = OpenStudio.convert(capacity_w, 'W', 'Btu/hr').get
@@ -2275,14 +2775,16 @@ class ECMS
       coil_cooling_dx_variable_speed.setName(new_comp_name)
     end
 
-    return cop
+    # Set COP values
+    coil_cooling_dx_variable_speed.speeds.each { |speed| speed.setReferenceUnitGrossRatedCoolingCOP(cop.to_f) } unless cop.nil?
+
   end
 
   # =============================================================================================================================
-  # Find minimum efficiency for "CoilHeatingDXVariableSpeed" object
-  def coil_heating_dx_variable_speed_standard_minimum_cop(coil_heating_dx_variable_speed,
-                                                          search_criteria,
-                                                          rename = false)
+  # Find efficiency for "CoilHeatingDXVariableSpeed" object
+  def coil_heating_dx_variable_speed_apply_cop(coil_heating_dx_variable_speed,
+                                               search_criteria,
+                                               rename = false)
 
     capacity_w = coil_heating_dx_variable_speed_find_capacity(coil_heating_dx_variable_speed)
     capacity_btu_per_hr = OpenStudio.convert(capacity_w, 'W', 'Btu/hr').get
@@ -2337,14 +2839,16 @@ class ECMS
       coil_heating_dx_variable_speed.setName(new_comp_name)
     end
 
-    return cop
+    # Set COP values
+    coil_heating_dx_variable_speed.speeds.each { |speed| speed.setReferenceUnitGrossRatedHeatingCOP(cop.to_f) } unless cop.nil?
+
   end
 
   # =============================================================================================================================
-  # Find minimum cooling efficiency for "AirConditionerVariableRefrigerantFlow" object
-  def airconditioner_variablerefrigerantflow_cooling_standard_minimum_cop(airconditioner_variablerefrigerantflow,
-                                                                          search_criteria,
-                                                                          rename = false)
+  # Find cooling efficiency for "AirConditionerVariableRefrigerantFlow" object
+  def airconditioner_variablerefrigerantflow_cooling_apply_cop(airconditioner_variablerefrigerantflow,
+                                                               search_criteria,
+                                                               rename = false)
 
     capacity_w = airconditioner_variablerefrigerantflow_cooling_find_capacity(airconditioner_variablerefrigerantflow)
     capacity_btu_per_hr = OpenStudio.convert(capacity_w, 'W', 'Btu/hr').get
@@ -2399,14 +2903,16 @@ class ECMS
       airconditioner_variablerefrigerantflow.setName(new_comp_name)
     end
 
-    return cop
+    # Set COP
+    airconditioner_variablerefrigerantflow.setRatedCoolingCOP(cop.to_f) unless cop.nil?
+
   end
 
   # =============================================================================================================================
-  # Find minimum heating efficiency for "AirConditionerVariableRefrigerantFlow" object
-  def airconditioner_variablerefrigerantflow_heating_standard_minimum_cop(airconditioner_variablerefrigerantflow,
-                                                                          search_criteria,
-                                                                          rename = false)
+  # Find heating efficiency for "AirConditionerVariableRefrigerantFlow" object
+  def airconditioner_variablerefrigerantflow_heating_apply_cop(airconditioner_variablerefrigerantflow,
+                                                               search_criteria,
+                                                               rename = false)
 
     capacity_w = airconditioner_variablerefrigerantflow_heating_find_capacity(airconditioner_variablerefrigerantflow)
     capacity_btu_per_hr = OpenStudio.convert(capacity_w, 'W', 'Btu/hr').get
@@ -2461,7 +2967,9 @@ class ECMS
       airconditioner_variablerefrigerantflow.setName(new_comp_name)
     end
 
-    return cop
+    # Set COP
+    airconditioner_variablerefrigerantflow.setRatedHeatingCOP(cop.to_f) unless cop.nil?
+
   end
 
   # =============================================================================================================================
@@ -2613,7 +3121,7 @@ class ECMS
 
     component.setNormalizedBoilerEfficiencyCurve(part_load_curve)
     if component.isNominalCapacityAutosized
-      boiler_size_W = model.getAutosizedValue(component, 'Design Size Nominal Capacity', 'W').to_f
+      boiler_size_W = component.autosizedNominalCapacity.get
     else
       boiler_size_W = component.nominalCapacity.to_f
     end
@@ -2813,10 +3321,11 @@ class ECMS
   # Method to update the cop and/or the performance curves of unitary dx coils. The method input 'unitary_cop' can either be a
   # string or a hash. When it's a string it's used to find a hash in the json table 'unitary_cop_ecm'. When it's a hash it holds
   # the parameters needed to update the cop and/or the performance curves of the unitary coil.
-  def modify_unitary_cop(model:, unitary_cop:, sql_db_vars_map:)
+  def modify_unitary_cop(model:, unitary_cop:, sizing_done:, sql_db_vars_map:)
     return if unitary_cop.nil? || (unitary_cop.to_s == 'NECB_Default')
 
-    coils = model.getCoilCoolingDXSingleSpeeds + model.getCoilCoolingDXMultiSpeeds
+    coils = model.getCoilCoolingDXSingleSpeeds.select {|coil| coil.name.to_s.include? '_dx'}
+    coils += model.getCoilCoolingDXMultiSpeeds.select {|coil| coil.name.to_s.include? '_dx'}
     unitary_cop_copy = unitary_cop.dup
     coils.sort.each do |coil|
       coil_type = 'SingleSpeed'
@@ -2827,7 +3336,7 @@ class ECMS
         search_criteria = {}
         search_criteria['name'] = unitary_cop_copy
         coil_name = coil.name.to_s
-        if sql_db_vars_map.has_key? coil_name then coil.setName(sql_db_vars_map[coil_name])  end
+        if (sql_db_vars_map.has_key? coil_name) && !sizing_done then coil.setName(sql_db_vars_map[coil_name]) end
         if coil_type == 'SingleSpeed'
           capacity_w = coil_cooling_dx_single_speed_find_capacity(coil)
         elsif coil_type == 'MultiSpeed'
@@ -2835,61 +3344,85 @@ class ECMS
         end
         coil.setName(coil_name)
         cop_package = model_find_object(@standards_data['tables']['unitary_cop_ecm'], search_criteria, capacity_w)
-        raise "Cannot not find #{unitary_cop_ecm} in the ECMS unitary_acs.json file.  Please check that the name is correctly spelled in the ECMS class unitary_acs.json file and in the code calling (directly or through another method) the ECMS class modify_unitary_eff method." if cop_package.empty?
+        raise "Cannot find #{unitary_cop_ecm} in the ECMS unitary_acs.json file.  Please check that the name is correctly spelled in the ECMS class unitary_acs.json file and in the code calling (directly or through another method) the ECMS class modify_unitary_eff method." if cop_package.empty?
 
         ecm_name = unitary_cop_copy
         unitary_cop = {
           'name' => ecm_name,
+          'maximum_capacity' => cop_package['maximum_capacity'],
           'minimum_energy_efficiency_ratio' => cop_package['minimum_energy_efficiency_ratio'],
           'minimum_seasonal_energy_efficiency_ratio' => cop_package['minimum_seasonal_energy_efficiency_ratio'],
+          'minimum_coefficient_of_performance_cooling' => cop_package['minimum_coefficient_of_performance_cooling'],
+          'ref_flow_rate_m3_per_sec' => cop_package['ref_flow_rate_m3_per_sec'],
           'cool_cap_ft' => cop_package['cool_cap_ft'],
           'cool_cap_fflow' => cop_package['cool_cap_fflow'],
           'cool_eir_ft' => cop_package['cool_eir_ft'],
           'cool_eir_fflow' => cop_package['cool_eir_fflow'],
-          'cool_plf_fplr' => cop_package['cool_eir_fplr']
+          'cool_plf_fplr' => cop_package['cool_plf_fplr']
         }
       end
-      next if unitary_cop['minimum_energy_efficiency_ratio'].nil? && unitary_cop['minimum_seasonal_energy_efficiency_ratio'].nil? && unitary_cop['cool_cap_ft'].nil? &&
-              unitary_cop['cool_cap_fflow'].nil? && unitary_cop['cool_eir_ft'].nil? && unitary_cop['cool_eir_fflow'].nil? && unitary_cop['cool_plf_fplr'].nil?
+      next if unitary_cop['minimum_energy_efficiency_ratio'].nil? && unitary_cop['minimum_seasonal_energy_efficiency_ratio'].nil? && 
+              unitary_cop['minimum_coefficient_of_performance_cooling'].nil? && unitary_cop['cool_cap_ft'].nil? && unitary_cop['cool_cap_fflow'].nil? && 
+              unitary_cop['cool_eir_ft'].nil? && unitary_cop['cool_eir_fflow'].nil? && unitary_cop['cool_plf_fplr'].nil? && unitary_cop['ref_flow_rate_m3_per_sec'].nil?
 
       # If the dx coil is on an air loop then update its cop and the performance curves when these are specified in the ecm data
       if (coil_type == 'SingleSpeed' && coil.airLoopHVAC.is_initialized && (!coil.name.to_s.include? "_ASHP")) ||
          (coil_type == 'MultiSpeed' && coil.containingHVACComponent.get.airLoopHVAC.is_initialized)
-        cop = nil
-        if unitary_cop['minimum_energy_efficiency_ratio']
-          cop = eer_to_cop(unitary_cop['minimum_energy_efficiency_ratio'].to_f)
-        elsif unitary_cop['minimum_seasonal_energy_efficiency_ratio']
-          cop = seer_to_cop_cooling_with_fan(unitary_cop['minimum_seasonal_energy_efficiency_ratio'].to_f)
-        end
-        cool_cap_ft = nil
-        cool_cap_ft = @standards_data['curves'].select { |curve| curve['name'] == unitary_cop['cool_cap_ft'] } if unitary_cop['cool_cap_ft']
-        cool_cap_fflow = nil
-        cool_cap_fflow = @standards_data['curves'].select { |curve| curve['name'] == unitary_cop['cool_cap_fflow'] } if unitary_cop['cool_cap_fflow']
-        cool_eir_ft = nil
-        cool_eir_ft = @standards_data['curves'].select { |curve| curve['name'] == unitary_cop['cool_eir_ft'] } if unitary_cop['cool_eir_ft']
-        cool_eir_fflow = nil
-        cool_eir_fflow = @standards_data['curves'].select { |curve| curve['name'] == unitary_cop['cool_eir_fflow'] } if unitary_cop['cool_eir_fflow']
-        cool_plf_fplr = nil
-        cool_plf_fplr = @standards_data['curves'].select { |curve| curve['name'] == unitary_cop['cool_plf_fplr'] } if unitary_cop['cool_plf_fplr']
-        if coil_type == 'SingleSpeed'
-          coil.setRatedCOP(cop) if cop
-          coil.setTotalCoolingCapacityFunctionOfTemperatureCurve(cool_cap_ft) if cool_cap_ft
-          coil.setTotalCoolingCapacityFunctionOfFlowFractionCurve(cool_cap_fflow) if cool_cap_fflow
-          coil.setEnergyInputRatioFunctionOfTemperatureCurve(cool_eir_ft) if cool_eir_ft
-          coil.setEnergyInputRatioFunctionOfFlowFractionCurve(cool_eir_fflow) if cool_eir_fflow
-          coil.setPartLoadFractionCorrelationCurve(cool_plf_fplr) if cool_plf_fplr
-        elsif coil_type == 'MultiSpeed'
-          coil.stages.sort.each do |stage|
-            stage.setGrossRatedCoolingCOP(cop) if cop
-            stage.setTotalCoolingCapacityFunctionofTemperatureCurve(cool_cap_ft) if cool_cap_ft
-            stage.setTotalCoolingCapacityFunctionofFlowFractionCurve(cool_cap_fflow) if cool_cap_fflow
-            stage.setEnergyInputRatioFunctionofTemperatureCurve(cool_eir_ft) if cool_eir_ft
-            stage.setEnergyInputRatioFunctionofFlowFractionCurve(cool_eir_fflow) if cool_eir_fflow
-            stage.setPartLoadFractionCorrelationCurve(cool_plf_fplr) if cool_plf_fplr
+        # Set COP if sizing run is done
+        if sizing_done
+          cop = nil
+          if unitary_cop['minimum_energy_efficiency_ratio']
+            cop = eer_to_cop(unitary_cop['minimum_energy_efficiency_ratio'].to_f)
+          elsif unitary_cop['minimum_seasonal_energy_efficiency_ratio']
+            cop = seer_to_cop_cooling_with_fan(unitary_cop['minimum_seasonal_energy_efficiency_ratio'].to_f)
+          elsif unitary_cop['minimum_coefficient_of_performance_cooling']
+            cop = unitary_cop['minimum_coefficient_of_performance_cooling'].to_f
+          end
+          if coil_type == 'SingleSpeed'
+            coil.setRatedCOP(cop) if cop
+          elsif coil_type == 'MultiSpeed'
+            coil.stages.sort.each do |stage|
+              stage.setGrossRatedCoolingCOP(cop) if cop
+            end
+          end
+          coil.setName('CoilCoolingDXSingleSpeed_dx-adv') if coil_type == 'SingleSpeed'
+          coil.setName('CoilCoolingDXMultiSpeed_dx-adv') if coil_type == 'MultiSpeed'
+        else
+        # Set performance curves before sizing run
+          cool_cap_ft = nil
+          cool_cap_ft = @standards_data['curves'].select { |curve| curve['name'] == unitary_cop['cool_cap_ft'] }[0] if unitary_cop['cool_cap_ft']
+          cool_cap_ft = model_add_curve(model, unitary_cop['cool_cap_ft']) if cool_cap_ft
+          cool_cap_fflow = nil
+          cool_cap_fflow = @standards_data['curves'].select { |curve| curve['name'] == unitary_cop['cool_cap_fflow'] }[0] if unitary_cop['cool_cap_fflow']
+          cool_cap_fflow = model_add_curve(model, unitary_cop['cool_cap_fflow']) if cool_cap_fflow
+          cool_eir_ft = nil
+          cool_eir_ft = @standards_data['curves'].select { |curve| curve['name'] == unitary_cop['cool_eir_ft'] }[0] if unitary_cop['cool_eir_ft']
+          cool_eir_ft = model_add_curve(model, unitary_cop['cool_eir_ft']) if cool_eir_ft
+          cool_eir_fflow = nil
+          cool_eir_fflow = @standards_data['curves'].select { |curve| curve['name'] == unitary_cop['cool_eir_fflow'] }[0] if unitary_cop['cool_eir_fflow']
+          cool_eir_fflow = model_add_curve(model, unitary_cop['cool_eir_fflow']) if cool_eir_fflow
+          cool_plf_fplr = nil
+          cool_plf_fplr = @standards_data['curves'].select { |curve| curve['name'] == unitary_cop['cool_plf_fplr'] }[0] if unitary_cop['cool_plf_fplr']
+          cool_plf_fplr = model_add_curve(model, unitary_cop['cool_plf_fplr']) if cool_plf_fplr
+          rated_flow_rate = nil
+          rated_flow_rate = unitary_cop['ref_flow_rate_m3_per_sec'] * (capacity_w / unitary_cop['maximum_capacity']) if unitary_cop['ref_flow_rate_m3_per_sec'] 
+          if coil_type == 'SingleSpeed'
+            coil.setTotalCoolingCapacityFunctionOfTemperatureCurve(cool_cap_ft) if cool_cap_ft
+            coil.setTotalCoolingCapacityFunctionOfFlowFractionCurve(cool_cap_fflow) if cool_cap_fflow
+            coil.setEnergyInputRatioFunctionOfTemperatureCurve(cool_eir_ft) if cool_eir_ft
+            coil.setEnergyInputRatioFunctionOfFlowFractionCurve(cool_eir_fflow) if cool_eir_fflow
+            coil.setPartLoadFractionCorrelationCurve(cool_plf_fplr) if cool_plf_fplr
+            coil.setRatedAirFlowRate(rated_flow_rate) if rated_flow_rate
+          elsif coil_type == 'MultiSpeed'
+            coil.stages.sort.each do |stage|
+              stage.setTotalCoolingCapacityFunctionofTemperatureCurve(cool_cap_ft) if cool_cap_ft
+              stage.setTotalCoolingCapacityFunctionofFlowFractionCurve(cool_cap_fflow) if cool_cap_fflow
+              stage.setEnergyInputRatioFunctionofTemperatureCurve(cool_eir_ft) if cool_eir_ft
+              stage.setEnergyInputRatioFunctionofFlowFractionCurve(cool_eir_fflow) if cool_eir_fflow
+              stage.setPartLoadFractionCorrelationCurve(cool_plf_fplr) if cool_plf_fplr
+            end
           end
         end
-        coil.setName('CoilCoolingDXSingleSpeed_dx-adv') if cop && coil_type == 'SingleSpeed'
-        coil.setName('CoilCoolingDXMultiSpeed_dx-adv') if cop && coil_type == 'MultiSpeed'
       end
     end
   end
@@ -2965,6 +3498,7 @@ class ECMS
     model.getCoolingTowerSingleSpeeds.sort.each(&:autosizeFanPoweratDesignAirFlowRate)
   end
 
+# ========================================================================================================================
   def find_chiller_set(chiller_type:, ref_capacity_w:)
     if chiller_type.is_a?(String)
       ##### Find the chiller that has the required capacity
@@ -3083,4 +3617,19 @@ class ECMS
       end
     end
   end
+  # ============================================================================================================================
+  # Add one hot-water loop for hot-water baseboards if primary heating fuel is gas
+  def add_hotwater_loop(model:)
+    plant_loop_names = []
+    model.getPlantLoops.sort.each do |plant_loop|
+      plant_loop_names << plant_loop.name.to_s
+    end
+    unless plant_loop_names.include? 'Hot Water Loop'
+      hw_loop = OpenStudio::Model::PlantLoop.new(model)
+      setup_hw_loop_with_components(model, hw_loop, 'NaturalGas', model.alwaysOnDiscreteSchedule)
+    end
+    return hw_loop
+  end
+  # ============================================================================================================================
+
 end