openstudio-standards 0.2.17.rc2 → 0.3.1.rc1

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

@@ -1,5 +1,7 @@
 class NECB2011
   def add_sys4_single_zone_make_up_air_unit_with_baseboard_heating(model:,
+                                                                   necb_reference_hp:false,
+                                                                   necb_reference_hp_supp_fuel:'DefaultFuel',
                                                                    zones:,
                                                                    heating_coil_type:,
                                                                    baseboard_type:,
@@ -34,6 +36,8 @@ class NECB2011
     system_data[:ZoneHeatingDesignSupplyAirTemperatureInputMethod] = 'TemperatureDifference'
     system_data[:ZoneHeatingDesignSupplyAirTemperatureDifference] = 21.0
     system_data[:ZoneHeatingDesignSupplyAirTemperature] = 43.0
+    system_data[:ZoneDXCoolingSizingFactor] = 1.0
+    system_data[:ZoneDXHeatingSizingFactor] = 1.3
     system_data[:ZoneCoolingSizingFactor] = 1.1
     system_data[:ZoneHeatingSizingFactor] = 1.3
 
@@ -71,26 +75,38 @@ class NECB2011
     sizing_zone.setZoneCoolingDesignSupplyAirTemperatureDifference(system_data[:ZoneCoolingDesignSupplyAirTemperatureDifference])
     sizing_zone.setZoneHeatingDesignSupplyAirTemperatureInputMethod(system_data[:ZoneHeatingDesignSupplyAirTemperatureInputMethod])
     sizing_zone.setZoneCoolingDesignSupplyAirTemperatureDifference(system_data[:ZoneHeatingDesignSupplyAirTemperatureDifference])
-    sizing_zone.setZoneCoolingSizingFactor(system_data[:ZoneCoolingSizingFactor])
-    sizing_zone.setZoneHeatingSizingFactor(system_data[:ZoneHeatingSizingFactor])
+    if necb_reference_hp
+      sizing_zone.setZoneCoolingSizingFactor(system_data[:ZoneDXCoolingSizingFactor])
+      sizing_zone.setZoneHeatingSizingFactor(system_data[:ZoneDXHeatingSizingFactor])
+    else
+      sizing_zone.setZoneCoolingSizingFactor(system_data[:ZoneCoolingSizingFactor])
+      sizing_zone.setZoneHeatingSizingFactor(system_data[:ZoneHeatingSizingFactor])
+    end
 
-    fan = OpenStudio::Model::FanConstantVolume.new(model, always_on)
+    if necb_reference_hp
+      # AirLoopHVACUnitaryHeatPumpAirToAir needs FanOnOff in order for the fan to turn off during off hours
+      fan = OpenStudio::Model::FanOnOff.new(model, always_on)
+    else
+      fan = OpenStudio::Model::FanConstantVolume.new(model, always_on)
+    end
+    
+    # Set up DX coil with NECB performance curve characteristics;
+    clg_coil = add_onespeed_DX_coil(model, always_on)
+    clg_coil.setName('CoilCoolingDXSingleSpeed_dx')
+    clg_coil.setName('CoilCoolingDXSingleSpeed_ashp') if necb_reference_hp
 
+    raise("Flag 'necb_reference_hp' is set to true while parameter 'heating_coil_type' is not set to DX") if (necb_reference_hp && (heating_coil_type != 'DX'))
     if heating_coil_type == 'Electric' # electric coil
       htg_coil = OpenStudio::Model::CoilHeatingElectric.new(model, always_on)
-    end
-
-    if heating_coil_type == 'Gas'
+    elsif heating_coil_type == 'Gas'
       htg_coil = OpenStudio::Model::CoilHeatingGas.new(model, always_on)
+    elsif heating_coil_type == 'DX'
+      htg_coil = add_onespeed_htg_DX_coil(model, always_on)
+      htg_coil.setName('CoilHeatingDXSingleSpeed_ashp')
     end
 
     # TO DO: other fuel-fired heating coil types? (not available in OpenStudio/E+ - may need to play with efficiency to mimic other fuel types)
 
-    # Set up DX coil with NECB performance curve characteristics;
-
-    clg_coil = add_onespeed_DX_coil(model, always_on)
-    clg_coil.setName('CoilCoolingDXSingleSpeed_dx')
-
     # oa_controller
     oa_controller = OpenStudio::Model::ControllerOutdoorAir.new(model)
     oa_controller.autosizeMinimumOutdoorAirFlowRate
@@ -105,11 +121,32 @@ class NECB2011
     # Add the components to the air loop
     # in order from closest to zone to furthest from zone
     supply_inlet_node = air_loop.supplyInletNode
-    fan.addToNode(supply_inlet_node)
-    htg_coil.addToNode(supply_inlet_node)
-    clg_coil.addToNode(supply_inlet_node)
+    if necb_reference_hp
+      #create supplemental heating coil based on default regional fuel type
+      if necb_reference_hp_supp_fuel == 'DefaultFuel'
+        epw = BTAP::Environment::WeatherFile.new(model.weatherFile.get.path.get)
+        necb_reference_hp_supp_fuel = @standards_data['regional_fuel_use'].detect { |fuel_sources| fuel_sources['state_province_regions'].include?(epw.state_province_region) }['fueltype_set']
+      end
+      if necb_reference_hp_supp_fuel == 'NaturalGas'
+        supplemental_htg_coil = OpenStudio::Model::CoilHeatingGas.new(model, always_on)
+      elsif necb_reference_hp_supp_fuel == 'Electricity' or  necb_reference_hp_supp_fuel == 'FuelOilNo2'
+        supplemental_htg_coil = OpenStudio::Model::CoilHeatingElectric.new(model, always_on)
+      else #hot water coils is an option in the future
+        raise('Invalid fuel type selected for heat pump supplemental coil')
+      end
+      # This method will seem like an error in number of args..but this is due to swig voodoo.
+      air_to_air_heatpump = OpenStudio::Model::AirLoopHVACUnitaryHeatPumpAirToAir.new(model, always_on, fan, htg_coil, clg_coil, supplemental_htg_coil)
+      air_to_air_heatpump.setName("#{control_zone.name} ASHP")
+      air_to_air_heatpump.setControllingZone(control_zone)
+      air_to_air_heatpump.setSupplyAirFanOperatingModeSchedule(always_on)
+      air_to_air_heatpump.addToNode(supply_inlet_node)
+    else    
+      fan.addToNode(supply_inlet_node)
+      htg_coil.addToNode(supply_inlet_node)
+      clg_coil.addToNode(supply_inlet_node)
+      
+    end
     oa_system.addToNode(supply_inlet_node)
-
     # Add a setpoint manager single zone reheat to control the
     # supply air temperature based on the needs of this zone
     setpoint_mgr_single_zone_reheat = OpenStudio::Model::SetpointManagerSingleZoneReheat.new(model)
@@ -139,8 +176,13 @@ class NECB2011
       sizing_zone.setZoneCoolingDesignSupplyAirTemperatureDifference(system_data[:ZoneCoolingDesignSupplyAirTemperatureDifference])
       sizing_zone.setZoneHeatingDesignSupplyAirTemperatureInputMethod(system_data[:ZoneHeatingDesignSupplyAirTemperatureInputMethod])
       sizing_zone.setZoneHeatingDesignSupplyAirTemperatureDifference(system_data[:ZoneHeatingDesignSupplyAirTemperatureDifference])
-      sizing_zone.setZoneCoolingSizingFactor(system_data[:ZoneCoolingSizingFactor])
-      sizing_zone.setZoneHeatingSizingFactor(system_data[:ZoneHeatingSizingFactor])
+      if necb_reference_hp
+        sizing_zone.setZoneCoolingSizingFactor(system_data[:ZoneDXCoolingSizingFactor])
+        sizing_zone.setZoneHeatingSizingFactor(system_data[:ZoneDXHeatingSizingFactor])
+      else
+        sizing_zone.setZoneCoolingSizingFactor(system_data[:ZoneCoolingSizingFactor])
+        sizing_zone.setZoneHeatingSizingFactor(system_data[:ZoneHeatingSizingFactor])
+      end
       # Create a diffuser and attach the zone/diffuser pair to the air loop
       # diffuser = OpenStudio::Model::AirTerminalSingleDuctUncontrolled.new(model,always_on)
       add_zone_baseboards(baseboard_type: baseboard_type,
@@ -154,7 +196,9 @@ class NECB2011
     sys_name_pars = {}
     sys_name_pars['sys_hr'] = 'none'
     sys_name_pars['sys_clg'] = 'dx'
+    sys_name_pars['sys_clg'] = 'ashp' if necb_reference_hp
     sys_name_pars['sys_htg'] = heating_coil_type
+    sys_name_pars['sys_htg'] = 'ashp' if necb_reference_hp
     sys_name_pars['sys_sf'] = 'cv'
     sys_name_pars['zone_htg'] = baseboard_type
     sys_name_pars['zone_clg'] = 'none'

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

@@ -312,4 +312,132 @@ class NECB2011
     # puts "end add_sys6_multi_zone_built_up_with_baseboard_heating"
     return true
   end
+
+  def add_sys6_multi_zone_reference_hp_with_baseboard_heating(model:,
+                                                              zones:,
+                                                              heating_coil_type:,
+                                                              baseboard_type:,
+                                                              hw_loop:,
+                                                              necb_reference_hp_supp_fuel:'DefaultFuel')
+
+    #system data
+    system_data = {}
+    system_data[:name] = 'Sys_6_VAV with Reheat'
+    system_data[:CentralCoolingDesignSupplyAirTemperature] = 13.0
+    system_data[:CentralHeatingDesignSupplyAirTemperature] = 13.1
+    system_data[:AllOutdoorAirinCooling] = false
+    system_data[:AllOutdoorAirinHeating] = false
+
+    # zone data
+    system_data[:system_supply_air_temperature] = 13.0
+    system_data[:ZoneCoolingDesignSupplyAirTemperatureInputMethod] = 'TemperatureDifference'
+    system_data[:ZoneCoolingDesignSupplyAirTemperatureDifference] = 11.0
+    system_data[:ZoneHeatingDesignSupplyAirTemperatureInputMethod] = 'TemperatureDifference'
+    system_data[:ZoneHeatingDesignSupplyAirTemperatureDifference] = 21.0
+    system_data[:ZoneDXCoolingSizingFactor] = 1.0
+    system_data[:ZoneDXHeatingSizingFactor] = 1.3
+
+
+    always_on = model.alwaysOnDiscreteSchedule
+
+    model.getBuildingStorys.sort.each do |story|
+      unless (BTAP::Geometry::BuildingStoreys.get_zones_from_storey(story) & zones).empty?
+
+        air_loop = common_air_loop(model: model, system_data: system_data)
+        air_loop.setName('Sys_6_CAV')
+
+        supply_fan = OpenStudio::Model::FanConstantVolume.new(model, always_on)
+        supply_fan.setName('Sys6 Supply Fan')
+        return_fan = OpenStudio::Model::FanConstantVolume.new(model, always_on)
+        return_fan.setName('Sys6 Return Fan')
+
+        htg_coil = add_onespeed_htg_DX_coil(model, always_on)
+        htg_coil.setName('CoilHeatingDXSingleSpeed_ashp')
+
+        clg_coil = add_onespeed_DX_coil(model, always_on)
+        clg_coil.setName('CoilCoolingDXSingleSpeed_ashp')
+
+        oa_controller = OpenStudio::Model::ControllerOutdoorAir.new(model)
+        oa_controller.autosizeMinimumOutdoorAirFlowRate
+
+        # Set mechanical ventilation controller outdoor air to ZoneSum (used to be defaulted to ZoneSum but now should be
+        # set explicitly)
+        oa_controller.controllerMechanicalVentilation.setSystemOutdoorAirMethod('ZoneSum')
+        oa_system = OpenStudio::Model::AirLoopHVACOutdoorAirSystem.new(model, oa_controller)
+
+        # Add the components to the air loop
+        # in order from closest to zone to furthest from zone
+        supply_inlet_node = air_loop.supplyInletNode
+        supply_outlet_node = air_loop.supplyOutletNode
+        supply_fan.addToNode(supply_inlet_node)
+        htg_coil.addToNode(supply_inlet_node)
+        clg_coil.addToNode(supply_inlet_node)
+        oa_system.addToNode(supply_inlet_node)
+        returnAirNode = oa_system.returnAirModelObject.get.to_Node.get
+        return_fan.addToNode(returnAirNode)
+
+        # Add a setpoint manager to control the
+        # supply air to a constant temperature
+        sat_sch = OpenStudio::Model::ScheduleRuleset.new(model)
+        sat_sch.setName('Supply Air Temp')
+        #sat_sch.defaultDaySchedule.setName('Supply Air Temp Default')
+        #sat_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, 24, 0, 0), system_data[:system_supply_air_temperature])
+        #sat_stpt_manager = OpenStudio::Model::SetpointManagerScheduled.new(model, sat_sch)
+        sat_stpt_manager = OpenStudio::Model::SetpointManagerWarmest.new(model)
+        sat_stpt_manager.setControlVariable("Temperature")
+        sat_stpt_manager.setMinimumSetpointTemperature(13)
+        sat_stpt_manager.setMaximumSetpointTemperature(24)
+        sat_stpt_manager.addToNode(supply_outlet_node)
+        
+        # Make CAV terminals for each zone on this story that is in intersection with the zones array.
+        (BTAP::Geometry::BuildingStoreys.get_zones_from_storey(story) & zones).each do |zone|
+          # Zone sizing parameters
+          sizing_zone = zone.sizingZone
+          sizing_zone.setZoneCoolingDesignSupplyAirTemperatureInputMethod(system_data[:ZoneCoolingDesignSupplyAirTemperatureInputMethod])
+          sizing_zone.setZoneCoolingDesignSupplyAirTemperatureDifference(system_data[:ZoneCoolingDesignSupplyAirTemperatureDifference])
+          sizing_zone.setZoneHeatingDesignSupplyAirTemperatureInputMethod(system_data[:ZoneHeatingDesignSupplyAirTemperatureInputMethod])
+          sizing_zone.setZoneHeatingDesignSupplyAirTemperatureDifference(system_data[:ZoneHeatingDesignSupplyAirTemperatureDifference])
+          sizing_zone.setZoneCoolingSizingFactor(system_data[:ZoneDXCoolingSizingFactor])
+          sizing_zone.setZoneHeatingSizingFactor(system_data[:ZoneDXHeatingSizingFactor])
+
+          # Set zone baseboards
+          add_zone_baseboards(model: model,
+                              zone: zone,
+                              baseboard_type: baseboard_type,
+                              hw_loop: hw_loop)
+
+          # Create CAV RH (RH based on region's default fuel type)
+          if necb_reference_hp_supp_fuel == 'DefaultFuel'
+            epw = BTAP::Environment::WeatherFile.new(model.weatherFile.get.path.get)
+            necb_reference_hp_supp_fuel = @standards_data['regional_fuel_use'].detect { |fuel_sources| fuel_sources['state_province_regions'].include?(epw.state_province_region) }['fueltype_set']
+          end
+          if necb_reference_hp_supp_fuel == 'NaturalGas'
+            rh_coil = OpenStudio::Model::CoilHeatingGas.new(model, always_on)
+          elsif necb_reference_hp_supp_fuel == 'Electricity' or  necb_reference_hp_supp_fuel == 'FuelOilNo2'
+            rh_coil = OpenStudio::Model::CoilHeatingElectric.new(model, always_on)
+          else #hot water coils is an option in the future
+            raise('Invalid fuel type selected for heat pump supplemental coil')
+          end
+          cav_rh_terminal = OpenStudio::Model::AirTerminalSingleDuctConstantVolumeReheat.new(model, always_on, rh_coil)
+          air_loop.addBranchForZone(zone, cav_rh_terminal.to_StraightComponent)
+        end
+        sys_name_pars = {}
+        sys_name_pars['sys_hr'] = 'none'
+        sys_name_pars['sys_htg'] = 'ashp'
+        sys_name_pars['sys_clg'] = 'ashp'
+        sys_name_pars['sys_sf'] = 'cv'
+        sys_name_pars['zone_htg'] = baseboard_type
+        sys_name_pars['zone_clg'] = 'none'
+        sys_name_pars['sys_rf'] = 'cv'
+        assign_base_sys_name(air_loop,
+                             sys_abbr: 'sys_6',
+                             sys_oa: 'mixed',
+                             sys_name_pars: sys_name_pars)                
+
+      end
+    end
+
+    
+
+  end
 end

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

@@ -42,7 +42,7 @@ class NECB2011
 
     # puts air_loop_hvac.name.to_s
     # Design Supply Air Flow Rate: This method below reads the value from the sql file.
-    dsafr_m3_per_s = air_loop_hvac.model.getAutosizedValue(air_loop_hvac, 'Design Supply Air Flow Rate', 'm3/s')
+    dsafr_m3_per_s = air_loop_hvac.autosizedDesignSupplyAirFlowRate
     min_dsafr_l_per_s = 1500
     unless dsafr_m3_per_s.empty?
       dsafr_l_per_s = dsafr_m3_per_s.get * 1000
@@ -504,21 +504,25 @@ class NECB2011
     capacity_w = boiler_hot_water_find_capacity(boiler_hot_water)
 
     # Check if secondary and/or modulating boiler required
-    if capacity_w / 1000.0 >= 352.0
-      if boiler_hot_water.name.to_s.include?('Primary Boiler')
-        boiler_capacity = capacity_w
-        boiler_hot_water.setBoilerFlowMode('LeavingSetpointModulated')
-        boiler_hot_water.setMinimumPartLoadRatio(0.25)
-      elsif boiler_hot_water.name.to_s.include?('Secondary Boiler')
-        boiler_capacity = 0.001
-      end
-    elsif ((capacity_w / 1000.0) >= 176.0) && ((capacity_w / 1000.0) < 352.0)
-      boiler_capacity = capacity_w / 2
-    elsif (capacity_w / 1000.0) <= 176.0
-      if boiler_hot_water.name.to_s.include?('Primary Boiler')
-        boiler_capacity = capacity_w
-      elsif boiler_hot_water.name.to_s.include?('Secondary Boiler')
-        boiler_capacity = 0.001
+    # If boiler names include 'Primary Boiler' or 'Secondary Boiler' then NECB rules are applied
+    boiler_capacity = capacity_w
+    if boiler_hot_water.name.to_s.include?('Primary Boiler') || boiler_hot_water.name.to_s.include?('Secondary Boiler')
+      if capacity_w / 1000.0 >= 352.0
+        if boiler_hot_water.name.to_s.include?('Primary Boiler')
+          boiler_capacity = capacity_w
+          boiler_hot_water.setBoilerFlowMode('LeavingSetpointModulated')
+          boiler_hot_water.setMinimumPartLoadRatio(0.25)
+        elsif boiler_hot_water.name.to_s.include?('Secondary Boiler')
+          boiler_capacity = 0.001
+        end
+      elsif ((capacity_w / 1000.0) >= 176.0) && ((capacity_w / 1000.0) < 352.0)
+        boiler_capacity = capacity_w / 2
+      elsif (capacity_w / 1000.0) <= 176.0
+        if boiler_hot_water.name.to_s.include?('Primary Boiler')
+          boiler_capacity = capacity_w
+        elsif boiler_hot_water.name.to_s.include?('Secondary Boiler')
+          boiler_capacity = 0.001
+        end
       end
     end
     boiler_hot_water.setNominalCapacity(boiler_capacity)
@@ -602,14 +606,18 @@ class NECB2011
     chiller_electric_eir.setChillerFlowMode('LeavingSetpointModulated')
     chiller_electric_eir.setMinimumPartLoadRatio(0.25)
     chiller_electric_eir.setMinimumUnloadingRatio(0.25)
-    if (capacity_w / 1000.0) < 2100.0
-      if chiller_electric_eir.name.to_s.include? 'Primary Chiller'
-        chiller_capacity = capacity_w
-      elsif chiller_electric_eir.name.to_s.include? 'Secondary Chiller'
-        chiller_capacity = 0.001
+    chiller_capacity = capacity_w
+    # If the chiller name includes 'Primary' or 'Secondary' then apply NECB rules
+    if (chiller_electric_eir.name.to_s.include? 'Primary') || (chiller_electric_eir.name.to_s.include? 'Secondary')
+      if (capacity_w / 1000.0) < 2100.0
+        if chiller_electric_eir.name.to_s.include? 'Primary Chiller'
+          chiller_capacity = capacity_w
+        elsif chiller_electric_eir.name.to_s.include? 'Secondary Chiller'
+          chiller_capacity = 0.001
+        end
+      else
+        chiller_capacity = capacity_w / 2.0 
       end
-    else
-      chiller_capacity = capacity_w / 2.0
     end
     chiller_electric_eir.setReferenceCapacity(chiller_capacity)
 
@@ -1048,6 +1056,7 @@ class NECB2011
     heat_pump_avail_sch_sensor = OpenStudio::Model::EnergyManagementSystemSensor.new(model, heat_pump_avail_sch_var)
     updated_heat_pump_avail_sch = OpenStudio::Model::ScheduleConstant.new(model)
     multi_speed_heat_pump.setAvailabilitySchedule(updated_heat_pump_avail_sch)
+    # This method will seem like an error in number of args..but this is due to swig voodoo.
     heat_pump_avail_sch_actuator = OpenStudio::Model::EnergyManagementSystemActuator.new(updated_heat_pump_avail_sch, 'Schedule:Constant', 'Schedule Value')
     heat_pump_avail_sch_prog = OpenStudio::Model::EnergyManagementSystemProgram.new(model)
     heat_pump_avail_sch_prog.setName("#{multi_speed_heat_pump.name.to_s.gsub(/[ +-.]/, '_')} Availability Schedule Program by Line")
@@ -1917,6 +1926,60 @@ class NECB2011
                                                            clg_part_load_ratio)
   end
 
+  def add_onespeed_htg_DX_coil(model, sch)
+
+  
+    htg_cap_f_of_temp = OpenStudio::Model::CurveCubic.new(model)
+    htg_cap_f_of_temp.setCoefficient1Constant(0.729009)
+    htg_cap_f_of_temp.setCoefficient2x(0.0319275)
+    htg_cap_f_of_temp.setCoefficient3xPOW2(0.000136404)
+    htg_cap_f_of_temp.setCoefficient4xPOW3(-8.748e-06)
+    htg_cap_f_of_temp.setMinimumValueofx(-20.0)
+    htg_cap_f_of_temp.setMaximumValueofx(20.0)
+  
+    htg_cap_f_of_flow = OpenStudio::Model::CurveCubic.new(model)
+    htg_cap_f_of_flow.setCoefficient1Constant(0.84)
+    htg_cap_f_of_flow.setCoefficient2x(0.16)
+    htg_cap_f_of_flow.setCoefficient3xPOW2(0.0)
+    htg_cap_f_of_flow.setCoefficient4xPOW3(0.0)
+    htg_cap_f_of_flow.setMinimumValueofx(0.5)
+    htg_cap_f_of_flow.setMaximumValueofx(1.5)
+
+    htg_energy_input_ratio_f_of_temp = OpenStudio::Model::CurveCubic.new(model)
+    htg_energy_input_ratio_f_of_temp.setCoefficient1Constant(1.2183)
+    htg_energy_input_ratio_f_of_temp.setCoefficient2x(-0.03612)
+    htg_energy_input_ratio_f_of_temp.setCoefficient3xPOW2(0.00142)
+    htg_energy_input_ratio_f_of_temp.setCoefficient4xPOW3(-2.68e-05)
+    htg_energy_input_ratio_f_of_temp.setMinimumValueofx(-20.0)
+    htg_energy_input_ratio_f_of_temp.setMaximumValueofx(20.0)
+
+    htg_energy_input_ratio_f_of_flow = OpenStudio::Model::CurveQuadratic.new(model)
+    htg_energy_input_ratio_f_of_flow.setCoefficient1Constant(1.3824)
+    htg_energy_input_ratio_f_of_flow.setCoefficient2x(-0.4336)
+    htg_energy_input_ratio_f_of_flow.setCoefficient3xPOW2(0.0512)
+    htg_energy_input_ratio_f_of_flow.setMinimumValueofx(0.0)
+    htg_energy_input_ratio_f_of_flow.setMaximumValueofx(1.0)
+  
+    htg_part_load_ratio = OpenStudio::Model::CurveCubic.new(model)
+    htg_part_load_ratio.setCoefficient1Constant(0.3696)
+    htg_part_load_ratio.setCoefficient2x(2.3362)
+    htg_part_load_ratio.setCoefficient3xPOW2(-2.9577)
+    htg_part_load_ratio.setCoefficient4xPOW3(1.2596)
+    htg_part_load_ratio.setMinimumValueofx(0.7)
+    htg_part_load_ratio.setMaximumValueofx(1.0)
+     
+    dx_htg_coil = OpenStudio::Model::CoilHeatingDXSingleSpeed.new(model,
+                                                                  sch,
+                                                                  htg_cap_f_of_temp,
+                                                                  htg_cap_f_of_flow,
+                                                                  htg_energy_input_ratio_f_of_temp,
+                                                                  htg_energy_input_ratio_f_of_flow,
+                                                                  htg_part_load_ratio)
+    dx_htg_coil.setMinimumOutdoorDryBulbTemperatureforCompressorOperation(-10)
+
+    return dx_htg_coil                                                           
+  end
+
   # Zonal systems
   def add_zone_baseboards(baseboard_type:,
                           hw_loop:,
@@ -1961,6 +2024,7 @@ class NECB2011
     fan = OpenStudio::Model::FanConstantVolume.new(model, always_on)
     fan.setPressureRise(640)
 
+    # This method will seem like an error in number of args..but this is due to swig voodoo.
     ptac = OpenStudio::Model::ZoneHVACPackagedTerminalAirConditioner.new(model,
                                                                          always_on,
                                                                          fan,
@@ -2204,4 +2268,169 @@ class NECB2011
 
     airloop.setName(sys_name)
   end
+
+  def coil_heating_dx_single_speed_find_capacity(coil_heating_dx_single_speed, necb_reference_hp = false)
+    # Set Rated heating capacity = 50% cooling coil capacity at -8.3 C outdoor [8.4.4.13 (2)(c)]
+
+    if necb_reference_hp #NECB reference heat pump rules apply
+      # grab paired cooling coil
+      if coil_heating_dx_single_speed.airLoopHVAC.empty?
+        
+        if coil_heating_dx_single_speed.containingHVACComponent.is_initialized
+          
+          containing_comp = coil_heating_dx_single_speed.containingHVACComponent.get
+          if containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAir.is_initialized
+            clg_coil = containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAir.get.coolingCoil
+          elsif containing_comp.to_AirLoopHVACUnitarySystem.is_initialized
+            unitary = containing_comp.to_AirLoopHVACUnitarySystem.get
+            if unitary.coolingCoil.is_initialized
+              clg_coil = unitary.coolingCoil.get
+            end
+          end
+          # @todo Add other unitary systems
+        elsif coil_heating_dx_single_speed.containingZoneHVACComponent.is_initialized
+          containing_comp = coil_heating_dx_single_speed.containingZoneHVACComponent.get
+          # PTHP
+          if containing_comp.to_ZoneHVACPackagedTerminalHeatPump.is_initialized
+            pthp = containing_comp.to_ZoneHVACPackagedTerminalHeatPump.get
+            clg_coil = containing_comp.to_ZoneHVACPackagedTerminalHeatPump.get.coolingCoil
+          end
+        end
+      elsif coil_heating_dx_single_speed.airLoopHVAC.is_initialized
+        air_loop = coil_heating_dx_single_speed.airLoopHVAC.get
+        # Check for the presence of any other type of cooling coil
+        clg_types = ['OS:Coil:Cooling:DX:SingleSpeed',
+                    'OS:Coil:Cooling:DX:TwoSpeed',
+                    'OS:Coil:Cooling:DX:MultiSpeed']
+        clg_types.each do |ct|
+          coils = air_loop.supplyComponents(ct.to_IddObjectType)
+          next if coils.empty?
+          clg_coil = coils[0]
+          puts "coils = air_loop.supplyComponents(ct.to_IddObjectType) #{}"
+          break # Stop on first DX cooling coil found
+        end
+      end
+
+      # Paired cooling coil parameters
+      clg_coil = clg_coil.to_CoilCoolingDXSingleSpeed.get
+      capacity_w = coil_cooling_dx_single_speed_find_capacity(clg_coil)
+      indoor_wb = 19.4 #rated indoor wb
+      outdoor_db = -8.3 # outdoor db
+
+      # heating capacity = capacity factor (function of temp) from biquadratic curve
+      # with curve limits on minimum y/outdoor db (no extrapolation)
+      cooling_cap_f_temp_curve = clg_coil.totalCoolingCapacityFunctionOfTemperatureCurve
+      cooling_cap_f_temp_factor_min_y = cooling_cap_f_temp_curve.evaluate(indoor_wb,outdoor_db)
+      htg_cap_w_min_y = capacity_w*0.5*cooling_cap_f_temp_factor_min_y
+      
+      # heating capacity = capacity factor (function of temp) from biquadratic curve 
+      # without curve limits on minimum y/outdoor db (extrapolate)
+      cooling_cap_f_temp_const = 0.867905
+      cooling_cap_f_temp_x = 0.0142459
+      cooling_cap_f_temp_x2 = 0.00055436
+      cooling_cap_f_temp_y = -0.0075575
+      cooling_cap_f_temp_y2 = 3.3e-05 
+      cooling_cap_f_temp_xy = -0.0001918
+      cooling_cap_f_temp_factor_no_min_y = cooling_cap_f_temp_const + cooling_cap_f_temp_x*indoor_wb + cooling_cap_f_temp_x2*indoor_wb**2 + 
+      cooling_cap_f_temp_y*outdoor_db + cooling_cap_f_temp_y2*outdoor_db**2 + cooling_cap_f_temp_xy*indoor_wb*outdoor_db
+      htg_cap_w_no_min_y = capacity_w*0.5*cooling_cap_f_temp_factor_no_min_y
+
+      puts "capacity_w #{capacity_w}"
+      puts "cooling_cap_f_temp_factor_no_min_y #{cooling_cap_f_temp_factor_no_min_y}"
+      puts "cooling_cap_f_temp_factor_min_y #{cooling_cap_f_temp_factor_min_y}"
+      puts "htg_cap_w_no_min_y #{htg_cap_w_no_min_y}"
+      puts "htg_cap_w_min_y #{htg_cap_w_min_y}"
+
+      # use actual factor from -8.3 to compute rated heating capacity unless it's < 0
+      if cooling_cap_f_temp_factor_no_min_y>0
+        htg_cap_w = htg_cap_w_no_min_y
+      else
+        htg_cap_w = htg_cap_w_min_y
+      end
+
+      # Hardsize rated capacity of heating coil
+      coil_heating_dx_single_speed.setRatedTotalHeatingCapacity(htg_cap_w)
+
+      return htg_cap_w
+    else # Do not follow NECB reference HP rule; proceed as usual
+      return super(coil_heating_dx_single_speed)
+    end
+  end
+  
+  # NECB reference heat pump system
+  # heating type rules need to be flexible to account for 
+  # 1.  DX htg/cooling + gas supplement htg
+  # 2.  Potential lack of AirLoopHVACUnitaryHeatPumpAirToAir or AirLoopHVACUnitarySystem  
+  # @param necb_ref_hp [Bool] if true, NECB reference model rules for heat pumps will be used.
+  def coil_dx_heating_type(coil_dx, necb_reference_hp = false)
+    supp_htg_type = nil
+
+    # If not heat pump reference case use the standard implementation.
+    if !necb_reference_hp
+      return super(coil_dx)
+    else
+      if coil_dx.airLoopHVAC.empty?
+        if coil_dx.containingHVACComponent.is_initialized
+          containing_comp = coil_dx.containingHVACComponent.get
+          if containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAir.is_initialized
+            supp_htg_coil = containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAir.get.supplementalHeatingCoil
+            if supp_htg_coil.to_CoilHeatingElectric.is_initialized
+              supp_htg_type = 'Electric Resistance or None'
+            elsif supp_htg_coil.to_CoilHeatingGas.is_initialized or supp_htg_coil.to_CoilHeatingWater.is_initialized
+              supp_htg_type = 'All Other' 
+            else # None
+              supp_htg_type = 'Electric Resistance or None'
+            end
+          else 
+            # For other virtual wrapper, use method in Standard.DXCoil
+            # Or add future wrappers here
+            return super 
+          end
+        end
+
+      elsif coil_dx.airLoopHVAC.is_initialized # Heat pumps without a wrapper (lone DX coils in the air loop)
+        airloop = coil_dx.airLoopHVAC.get
+        num_of_DX_Coils = 0
+        num_of_supp_coils = 0 
+        supp_htg_type = ''
+        # Go through and determine number of each type of coils in air loop to determine supp_htg_type
+        airloop.supplyComponents.each do |supply_component| 
+          if supply_component.to_CoilHeatingDXSingleSpeed.is_initialized or supply_component.to_CoilHeatingDXMultiSpeed.is_initialized
+            supply_component.to_CoilHeatingDXVariableSpeed.is_initialized
+            num_of_DX_Coils = num_of_DX_Coils + 1
+          elsif supply_component.to_CoilCoolingDXSingleSpeed.is_initialized or supply_component.to_CoilCoolingDXTwoSpeed.is_initialized or
+            supply_component.to_CoilCoolingDXTwoSpeed.is_initialized or supply_component.to_CoilCoolingDXVariableSpeed.is_initialized or 
+            supply_component.to_CoilCoolingDXMultiSpeed.is_initialized or
+            supply_component.to_CoilCoolingDXCurveFitPerformance.is_initialized or
+            supply_component.to_CoilCoolingDXTwoStageWithHumidityControlMode.is_initialized
+            num_of_DX_Coils = num_of_DX_Coils + 1
+          elsif supply_component.to_CoilHeatingGas.is_initialized or supply_component.to_CoilHeatingGasMultiStage.is_initialized or 
+            supply_component.to_CoilHeatingWater.is_initialized
+            num_of_supp_coils = num_of_supp_coils + 1
+            supp_htg_type = 'All Other' 
+          elsif supply_component.to_CoilHeatingElectric.is_initialized 
+            num_of_supp_coils = num_of_supp_coils + 1        
+            supp_htg_type = 'Electric Resistance or None'
+          end
+        end
+
+        #Two possible heat pump configuration
+        if num_of_DX_Coils == 2 && num_of_supp_coils == 1 #Scenario 1: 1 DX htg + 1 DX clg + 1 Non-DX htg coil 
+          puts "scenario 1 supp_htg_type #{supp_htg_type}"
+          return supp_htg_type # return supplmental heating type
+        else #Scenario 2: num_of_DX_Coils < 2 or num_of_supp_coils = 0; 
+          puts "scenario 2 supp_htg_type #{supp_htg_type}"
+          puts "num_of_DX_Coils #{num_of_DX_Coils}"
+          puts "num_of_supp_coils #{num_of_supp_coils}"
+          return supp_htg_type = 'Electric Resistance or None' 
+        end
+
+
+
+      end
+    end
+
+
+  
+  end
 end