urbanopt-cli 0.9.2 → 0.10.0

data/example_files/resources/hpxml-measures/HPXMLtoOpenStudio/resources/hvac_sizing.rb

@@ -1,29 +1,13 @@
 # frozen_string_literal: true
 
 class HVACSizing
-  def self.calculate(weather, hpxml, cfa, nbeds, hvac_systems)
+  def self.calculate(weather, hpxml, cfa, hvac_systems)
     # Calculates heating/cooling design loads, and selects equipment
     # values (e.g., capacities, airflows) specific to each HVAC system.
     # Calculations generally follow ACCA Manual J/S.
 
     @hpxml = hpxml
     @cfa = cfa
-    @nbeds = nbeds
-
-    def self.is_system_to_skip(hvac)
-      # These shared systems should be converted to other equivalent
-      # systems before being autosized
-      if [HPXML::HVACTypeChiller,
-          HPXML::HVACTypeCoolingTower].include?(hvac.CoolType)
-        return true
-      end
-      if [HPXML::HVACTypeHeatPumpWaterLoopToAir].include?(hvac.HeatType) &&
-         hvac.HeatingLoadFraction.nil?
-        return true
-      end
-
-      return false
-    end
 
     process_site_calcs_and_design_temps(weather)
 
@@ -31,8 +15,8 @@ class HVACSizing
     bldg_design_loads = DesignLoads.new
     process_load_windows_skylights(bldg_design_loads, weather)
     process_load_doors(bldg_design_loads)
-    process_load_walls(bldg_design_loads, weather)
-    process_load_roofs(bldg_design_loads, weather)
+    process_load_walls(bldg_design_loads)
+    process_load_roofs(bldg_design_loads)
     process_load_ceilings(bldg_design_loads)
     process_load_floors(bldg_design_loads)
     process_load_slabs(bldg_design_loads)
@@ -46,23 +30,26 @@ class HVACSizing
     all_hvac_sizing_values = {}
     system_design_loads = bldg_design_loads.dup
     hvac_systems.each do |hvac_system|
-      hvac = get_hvac_information(hvac_system)
-      next if is_system_to_skip(hvac)
+      hvac_heating, hvac_cooling = hvac_system[:heating], hvac_system[:cooling]
+      set_hvac_types(hvac_heating, hvac_cooling)
+      next if is_system_to_skip(hvac_heating)
 
       # Apply duct loads as needed
-      apply_hvac_temperatures(hvac, system_design_loads)
-      ducts_heat_load = calculate_load_ducts_heating(system_design_loads, hvac)
-      ducts_cool_load_sens, ducts_cool_load_lat = calculate_load_ducts_cooling(system_design_loads, weather, hvac)
+      set_fractions_load_served(hvac_heating, hvac_cooling)
+      apply_hvac_temperatures(system_design_loads, hvac_heating, hvac_cooling)
+      ducts_heat_load = calculate_load_ducts_heating(system_design_loads, hvac_heating)
+      ducts_cool_load_sens, ducts_cool_load_lat = calculate_load_ducts_cooling(system_design_loads, weather, hvac_cooling)
       apply_load_ducts(bldg_design_loads, ducts_heat_load, ducts_cool_load_sens, ducts_cool_load_lat) # Update duct loads in reported building design loads
 
       hvac_sizing_values = HVACSizingValues.new
-      apply_hvac_loads(hvac, hvac_sizing_values, system_design_loads, ducts_heat_load, ducts_cool_load_sens, ducts_cool_load_lat)
-      apply_hvac_heat_pump_logic(hvac_sizing_values, hvac)
-      apply_hvac_equipment_adjustments(hvac_sizing_values, weather, hvac)
-      apply_hvac_installation_quality(hvac_sizing_values, weather, hvac)
-      apply_hvac_fixed_capacities(hvac_sizing_values, hvac)
-      apply_hvac_ground_loop(hvac_sizing_values, weather, hvac)
-      apply_hvac_finalize_airflows(hvac_sizing_values, hvac)
+      apply_hvac_loads(hvac_heating, hvac_sizing_values, system_design_loads, ducts_heat_load, ducts_cool_load_sens, ducts_cool_load_lat)
+      apply_hvac_size_limits(hvac_cooling)
+      apply_hvac_heat_pump_logic(hvac_sizing_values, hvac_cooling)
+      apply_hvac_equipment_adjustments(hvac_sizing_values, weather, hvac_heating, hvac_cooling, hvac_system)
+      apply_hvac_installation_quality(hvac_sizing_values, hvac_heating, hvac_cooling)
+      apply_hvac_fixed_capacities(hvac_sizing_values, hvac_heating, hvac_cooling)
+      apply_hvac_ground_loop(hvac_sizing_values, weather, hvac_cooling)
+      apply_hvac_finalize_airflows(hvac_sizing_values, hvac_heating, hvac_cooling)
 
       all_hvac_sizing_values[hvac_system] = hvac_sizing_values
     end
@@ -72,6 +59,21 @@ class HVACSizing
 
   private
 
+  def self.is_system_to_skip(hvac_heating)
+    # These shared systems should be converted to other equivalent
+    # systems before being autosized
+    if [HPXML::HVACTypeChiller,
+        HPXML::HVACTypeCoolingTower].include?(@cooling_type)
+      return true
+    end
+    if (@heating_type == HPXML::HVACTypeHeatPumpWaterLoopToAir) &&
+       hvac_heating.fraction_heat_load_served.nil?
+      return true
+    end
+
+    return false
+  end
+
   def self.process_site_calcs_and_design_temps(weather)
     '''
     Site Calculations and Design Temperatures
@@ -81,14 +83,14 @@ class HVACSizing
     @daily_range_temp_adjust = [4, 0, -5]
 
     # Manual J inside conditions
-    @cool_setpoint = 75.0
-    @heat_setpoint = 70.0
+    @cool_setpoint = @hpxml.header.manualj_cooling_setpoint
+    @heat_setpoint = @hpxml.header.manualj_heating_setpoint
 
     @cool_design_grains = UnitConversions.convert(weather.design.CoolingHumidityRatio, 'lbm/lbm', 'grains')
 
     # Calculate the design temperature differences
-    @ctd = [weather.design.CoolingDrybulb - @cool_setpoint, 0.0].max
-    @htd = [@heat_setpoint - weather.design.HeatingDrybulb, 0.0].max
+    @ctd = [@hpxml.header.manualj_cooling_design_temp - @cool_setpoint, 0.0].max
+    @htd = [@heat_setpoint - @hpxml.header.manualj_heating_design_temp, 0.0].max
 
     # Calculate the average Daily Temperature Range (DTR) to determine the class (low, medium, high)
     dtr = weather.design.DailyTemperatureRange
@@ -109,11 +111,12 @@ class HVACSizing
     @acf = MathTools.interp2(weather.header.Altitude, alt_cnt * 1000.0, (alt_cnt + 1.0) * 1000.0, acfs[alt_cnt], acfs[alt_cnt + 1])
 
     # Calculate the interior humidity in Grains and enthalpy in Btu/lb for cooling
-    pwsat = UnitConversions.convert(0.430075, 'psi', 'kPa') # Calculated for 75degF indoor temperature
-    rh_indoor_cooling = 0.55 # Manual J is vague on the indoor RH. 55% corresponds to BA goals
+    cool_setpoint_c = UnitConversions.convert(@cool_setpoint, 'F', 'C')
+    pwsat = 6.11 * 10**(7.5 * cool_setpoint_c / (237.3 + cool_setpoint_c)) / 10.0 # kPa, using https://www.weather.gov/media/epz/wxcalc/vaporPressure.pdf
+    rh_indoor_cooling = 0.5 # Manual J is vague on the indoor RH but uses 50% in its examples
     hr_indoor_cooling = (0.62198 * rh_indoor_cooling * pwsat) / (UnitConversions.convert(weather.header.LocalPressure, 'atm', 'kPa') - rh_indoor_cooling * pwsat)
     @cool_indoor_grains = UnitConversions.convert(hr_indoor_cooling, 'lbm/lbm', 'grains')
-    @wetbulb_indoor_cooling = Psychrometrics.Twb_fT_R_P(@cool_setpoint, rh_indoor_cooling, UnitConversions.convert(weather.header.LocalPressure, 'atm', 'psi'))
+    @wetbulb_indoor_cooling = Psychrometrics.Twb_fT_R_P(nil, @cool_setpoint, rh_indoor_cooling, UnitConversions.convert(weather.header.LocalPressure, 'atm', 'psi'))
 
     db_indoor_degC = UnitConversions.convert(@cool_setpoint, 'F', 'C')
     @enthalpy_indoor_cooling = (1.006 * db_indoor_degC + hr_indoor_cooling * (2501.0 + 1.86 * db_indoor_degC)) * UnitConversions.convert(1.0, 'kJ', 'Btu') * UnitConversions.convert(1.0, 'lbm', 'kg')
@@ -144,11 +147,11 @@ class HVACSizing
 
       if [HPXML::LocationOtherHousingUnit, HPXML::LocationOtherHeatedSpace, HPXML::LocationOtherMultifamilyBufferSpace,
           HPXML::LocationOtherNonFreezingSpace, HPXML::LocationExteriorWall, HPXML::LocationUnderSlab].include? location
-        @cool_design_temps[location] = calculate_scheduled_space_design_temps(location, @cool_setpoint, weather.design.CoolingDrybulb, weather.data.GroundMonthlyTemps.max)
-        @heat_design_temps[location] = calculate_scheduled_space_design_temps(location, @heat_setpoint, weather.design.HeatingDrybulb, weather.data.GroundMonthlyTemps.min)
+        @cool_design_temps[location] = calculate_scheduled_space_design_temps(location, @cool_setpoint, @hpxml.header.manualj_cooling_design_temp, weather.data.GroundMonthlyTemps.max)
+        @heat_design_temps[location] = calculate_scheduled_space_design_temps(location, @heat_setpoint, @hpxml.header.manualj_heating_design_temp, weather.data.GroundMonthlyTemps.min)
       elsif [HPXML::LocationOutside, HPXML::LocationRoofDeck].include? location
-        @cool_design_temps[location] = weather.design.CoolingDrybulb
-        @heat_design_temps[location] = weather.design.HeatingDrybulb
+        @cool_design_temps[location] = @hpxml.header.manualj_cooling_design_temp
+        @heat_design_temps[location] = @hpxml.header.manualj_heating_design_temp
       elsif HPXML::conditioned_locations.include? location
         @cool_design_temps[location] = process_design_temp_cooling(weather, HPXML::LocationLivingSpace)
         @heat_design_temps[location] = process_design_temp_heating(weather, HPXML::LocationLivingSpace)
@@ -164,7 +167,7 @@ class HVACSizing
       heat_temp = @heat_setpoint
 
     elsif location == HPXML::LocationGarage
-      heat_temp = weather.design.HeatingDrybulb + 13.0
+      heat_temp = @hpxml.header.manualj_heating_design_temp + 13.0
 
     elsif (location == HPXML::LocationAtticUnvented) || (location == HPXML::LocationAtticVented)
 
@@ -178,16 +181,16 @@ class HVACSizing
         # Attic is considered to be encapsulated. MJ8 says to use an attic
         # temperature of 95F, however alternative approaches are permissible
         if location == HPXML::LocationAtticVented
-          heat_temp = weather.design.HeatingDrybulb
+          heat_temp = @hpxml.header.manualj_heating_design_temp
         else
-          heat_temp = calculate_space_design_temps(location, weather, @heat_setpoint, weather.design.HeatingDrybulb, weather.data.GroundMonthlyTemps.min)
+          heat_temp = calculate_space_design_temps(location, weather, @heat_setpoint, @hpxml.header.manualj_heating_design_temp, weather.data.GroundMonthlyTemps.min)
         end
       else
-        heat_temp = weather.design.HeatingDrybulb
+        heat_temp = @hpxml.header.manualj_heating_design_temp
       end
 
     elsif [HPXML::LocationBasementUnconditioned, HPXML::LocationCrawlspaceUnvented, HPXML::LocationCrawlspaceVented].include? location
-      heat_temp = calculate_space_design_temps(location, weather, @heat_setpoint, weather.design.HeatingDrybulb, weather.data.GroundMonthlyTemps.min)
+      heat_temp = calculate_space_design_temps(location, weather, @heat_setpoint, @hpxml.header.manualj_heating_design_temp, weather.data.GroundMonthlyTemps.min)
 
     end
 
@@ -224,15 +227,15 @@ class HVACSizing
       # Calculate the garage cooling design temperature based on Table 4C
       # Linearly interpolate between having living space over the garage and not having living space above the garage
       if @daily_range_num == 0.0
-        cool_temp = (weather.design.CoolingDrybulb +
+        cool_temp = (@hpxml.header.manualj_cooling_design_temp +
                      (11.0 * garage_frac_under_conditioned) +
                      (22.0 * (1.0 - garage_frac_under_conditioned)))
       elsif @daily_range_num == 1.0
-        cool_temp = (weather.design.CoolingDrybulb +
+        cool_temp = (@hpxml.header.manualj_cooling_design_temp +
                      (6.0 * garage_frac_under_conditioned) +
                      (17.0 * (1.0 - garage_frac_under_conditioned)))
       elsif @daily_range_num == 2.0
-        cool_temp = (weather.design.CoolingDrybulb +
+        cool_temp = (@hpxml.header.manualj_cooling_design_temp +
                      (1.0 * garage_frac_under_conditioned) +
                      (12.0 * (1.0 - garage_frac_under_conditioned)))
       end
@@ -249,9 +252,9 @@ class HVACSizing
         # Attic is considered to be encapsulated. MJ8 says to use an attic
         # temperature of 95F, however alternative approaches are permissible
         if location == HPXML::LocationAtticVented
-          cool_temp = weather.design.CoolingDrybulb + 40.0 # This is the number from a California study with dark shingle roof and similar ventilation.
+          cool_temp = @hpxml.header.manualj_cooling_design_temp + 40.0 # This is the number from a California study with dark shingle roof and similar ventilation.
         else
-          cool_temp = calculate_space_design_temps(location, weather, @cool_setpoint, weather.design.CoolingDrybulb, weather.data.GroundMonthlyTemps.max, true)
+          cool_temp = calculate_space_design_temps(location, weather, @cool_setpoint, @hpxml.header.manualj_cooling_design_temp, weather.data.GroundMonthlyTemps.max, true)
         end
 
       else
@@ -267,9 +270,9 @@ class HVACSizing
 
           if location == HPXML::LocationAtticUnvented
             if not roof.radiant_barrier
-              cool_temp += (150.0 + (weather.design.CoolingDrybulb - 95.0) + @daily_range_temp_adjust[@daily_range_num]) * roof.net_area
+              cool_temp += (150.0 + (@hpxml.header.manualj_cooling_design_temp - 95.0) + @daily_range_temp_adjust[@daily_range_num]) * roof.net_area
             else
-              cool_temp += (130.0 + (weather.design.CoolingDrybulb - 95.0) + @daily_range_temp_adjust[@daily_range_num]) * roof.net_area
+              cool_temp += (130.0 + (@hpxml.header.manualj_cooling_design_temp - 95.0) + @daily_range_temp_adjust[@daily_range_num]) * roof.net_area
             end
           else
             if not roof.radiant_barrier
@@ -331,11 +334,11 @@ class HVACSizing
         cool_temp /= tot_roof_area
 
         # Adjust base CLTD for cooling design temperature and daily range
-        cool_temp += (weather.design.CoolingDrybulb - 95.0) + @daily_range_temp_adjust[@daily_range_num]
+        cool_temp += (@hpxml.header.manualj_cooling_design_temp - 95.0) + @daily_range_temp_adjust[@daily_range_num]
       end
 
     elsif [HPXML::LocationBasementUnconditioned, HPXML::LocationCrawlspaceUnvented, HPXML::LocationCrawlspaceVented].include? location
-      cool_temp = calculate_space_design_temps(location, weather, @cool_setpoint, weather.design.CoolingDrybulb, weather.data.GroundMonthlyTemps.max)
+      cool_temp = calculate_space_design_temps(location, weather, @cool_setpoint, @hpxml.header.manualj_cooling_design_temp, weather.data.GroundMonthlyTemps.max)
 
     end
 
@@ -476,7 +479,7 @@ class HVACSizing
     # Windows
     bldg_design_loads.Heat_Windows = 0.0
     alp_load = 0.0 # Average Load Procedure (ALP) Load
-    afl_hr = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] # Initialize Hourly Aggregate Fenestration Load (AFL)
+    afl_hr = [0.0] * 12 # Initialize Hourly Aggregate Fenestration Load (AFL)
 
     @hpxml.windows.each do |window|
       next unless window.wall.is_exterior_thermal_boundary
@@ -489,7 +492,7 @@ class HVACSizing
 
       bldg_design_loads.Heat_Windows += window_ufactor * window.area * @htd
 
-      for hr in -1..12
+      for hr in -1..11
 
         # If hr == -1: Calculate the Average Load Procedure (ALP) Load
         # Else: Calculate the hourly Aggregate Fenestration Load (AFL)
@@ -610,7 +613,7 @@ class HVACSizing
     # Skylights
     bldg_design_loads.Heat_Skylights = 0.0
     alp_load = 0.0 # Average Load Procedure (ALP) Load
-    afl_hr = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] # Initialize Hourly Aggregate Fenestration Load (AFL)
+    afl_hr = [0.0] * 12 # Initialize Hourly Aggregate Fenestration Load (AFL)
 
     @hpxml.skylights.each do |skylight|
       skylight_summer_sf = skylight.interior_shading_factor_summer * skylight.exterior_shading_factor_summer
@@ -622,7 +625,7 @@ class HVACSizing
 
       bldg_design_loads.Heat_Skylights += skylight_ufactor * skylight.area * @htd
 
-      for hr in -1..12
+      for hr in -1..11
 
         # If hr == -1: Calculate the Average Load Procedure (ALP) Load
         # Else: Calculate the hourly Aggregate Fenestration Load (AFL)
@@ -716,7 +719,7 @@ class HVACSizing
     end
   end
 
-  def self.process_load_walls(bldg_design_loads, weather)
+  def self.process_load_walls(bldg_design_loads)
     '''
     Heating and Cooling Loads: Walls
     '''
@@ -771,7 +774,7 @@ class HVACSizing
 
           if @ctd >= 10.0
             # Adjust the CLTD for different cooling design temperatures
-            cltd += (weather.design.CoolingDrybulb - 95.0)
+            cltd += (@hpxml.header.manualj_cooling_design_temp - 95.0)
             # Adjust the CLTD for daily temperature range
             cltd += @daily_range_temp_adjust[@daily_range_num]
           else
@@ -799,7 +802,7 @@ class HVACSizing
     end
   end
 
-  def self.process_load_roofs(bldg_design_loads, weather)
+  def self.process_load_roofs(bldg_design_loads)
     '''
     Heating and Cooling Loads: Roofs
     '''
@@ -846,7 +849,7 @@ class HVACSizing
       end
 
       # Adjust base CLTD for different CTD or DR
-      cltd += (weather.design.CoolingDrybulb - 95.0) + @daily_range_temp_adjust[@daily_range_num]
+      cltd += (@hpxml.header.manualj_cooling_design_temp - 95.0) + @daily_range_temp_adjust[@daily_range_num]
 
       bldg_design_loads.Cool_Roofs += (1.0 / roof.insulation_assembly_r_value) * roof.net_area * cltd
       bldg_design_loads.Heat_Roofs += (1.0 / roof.insulation_assembly_r_value) * roof.net_area * @htd
@@ -953,9 +956,16 @@ class HVACSizing
         bldg_design_loads.Heat_Slabs += f_value * slab.exposed_perimeter * @htd
       elsif HPXML::conditioned_below_grade_locations.include? slab.interior_adjacent_to
         # Based on MJ 8th Ed. A12-7 and ASHRAE HoF 2013 pg 18.31 Eq 40
-        # FIXME: Assumes slab is uninsulated?
-        k_soil = @hpxml.site.ground_conductivity
-        r_other = Material.Concrete(4.0).rvalue + Material.AirFilmFloorAverage.rvalue
+        slab_is_insulated = false
+        if slab.under_slab_insulation_width > 0 && slab.under_slab_insulation_r_value > 0
+          slab_is_insulated = true
+        elsif slab.perimeter_insulation_depth > 0 && slab.perimeter_insulation_r_value > 0
+          slab_is_insulated = true
+        elsif slab.under_slab_insulation_spans_entire_slab && slab.under_slab_insulation_r_value > 0
+          slab_is_insulated = true
+        end
+        k_soil = 0.8 # Value from ASHRAE HoF, probably used by Manual J
+        r_other = 1.47 # Value from ASHRAE HoF, probably used by Manual J
         foundation_walls = @hpxml.foundation_walls.select { |fw| fw.is_thermal_boundary }
         z_f = foundation_walls.map { |fw| fw.depth_below_grade }.sum(0.0) / foundation_walls.size # Average below-grade depth
         sqrt_term = [slab.exposed_perimeter**2 - 16.0 * slab.area, 0.0].max
@@ -964,8 +974,11 @@ class HVACSizing
         w_b = [length, width].min
         w_b = [w_b, 1.0].max # handle zero exposed perimeter
         u_avg_bf = (2.0 * k_soil / (Math::PI * w_b)) * (Math::log(w_b / 2.0 + z_f / 2.0 + (k_soil * r_other) / Math::PI) - Math::log(z_f / 2.0 + (k_soil * r_other) / Math::PI))
-        u_value_mj8 = 0.85 * u_avg_bf
-        bldg_design_loads.Heat_Slabs += u_value_mj8 * slab.area * @htd
+        u_value = 0.85 * u_avg_bf # To account for the storage effect of soil, multiply by 0.85
+        if slab_is_insulated
+          u_value *= 0.7 # U-values are multiplied y 0.70 to produce U-values for insulated floors
+        end
+        bldg_design_loads.Heat_Slabs += u_value * slab.area * @htd
       end
     end
   end
@@ -975,23 +988,8 @@ class HVACSizing
     Heating and Cooling Loads: Infiltration & Ventilation
     '''
 
-    # FUTURE: Consolidate code w/ airflow.rb
-    infil_volume = @hpxml.air_infiltration_measurements.select { |i| !i.infiltration_volume.nil? }[0].infiltration_volume
-    infil_height = @hpxml.air_infiltration_measurements.select { |i| !i.infiltration_height.nil? }[0].infiltration_height
-    sla = nil
-    @hpxml.air_infiltration_measurements.each do |measurement|
-      if [HPXML::UnitsACH, HPXML::UnitsCFM].include?(measurement.unit_of_measure) && !measurement.house_pressure.nil?
-        if measurement.unit_of_measure == HPXML::UnitsACH
-          ach50 = Airflow.calc_air_leakage_at_diff_pressure(0.65, measurement.air_leakage, measurement.house_pressure, 50.0)
-        elsif measurement.unit_of_measure == HPXML::UnitsCFM
-          achXX = measurement.air_leakage * 60.0 / infil_volume # Convert CFM to ACH
-          ach50 = Airflow.calc_air_leakage_at_diff_pressure(0.65, achXX, measurement.house_pressure, 50.0)
-        end
-        sla = Airflow.get_infiltration_SLA_from_ACH50(ach50, 0.65, @cfa, infil_volume)
-      elsif measurement.unit_of_measure == HPXML::UnitsACHNatural
-        sla = Airflow.get_infiltration_SLA_from_ACH(measurement.air_leakage, infil_height, weather)
-      end
-    end
+    sla, _ach50, _nach, _volume, _height, a_ext = Airflow.get_values_from_air_infiltration_measurements(@hpxml, @cfa, weather)
+    sla *= a_ext
     ela = sla * @cfa
 
     ncfl_ag = @hpxml.building_construction.number_of_conditioned_floors_above_grade
@@ -1012,13 +1010,13 @@ class HVACSizing
 
     cfm_Heating = q_bal_Sens + (icfm_Heating**2.0 + q_unb_cfm**2.0)**0.5 - q_preheat - q_recirc
 
-    cfm_Cool_Load_Sens = q_bal_Sens + (icfm_Cooling**2.0 + q_unb_cfm**2.0)**0.5 - q_precool - q_recirc
-    cfm_Cool_Load_Lat = q_bal_Lat + (icfm_Cooling**2.0 + q_unb_cfm**2.0)**0.5 - q_recirc
+    cfm_cool_load_sens = q_bal_Sens + (icfm_Cooling**2.0 + q_unb_cfm**2.0)**0.5 - q_precool - q_recirc
+    cfm_cool_load_lat = q_bal_Lat + (icfm_Cooling**2.0 + q_unb_cfm**2.0)**0.5 - q_recirc
 
     bldg_design_loads.Heat_InfilVent = 1.1 * @acf * cfm_Heating * @htd
 
-    bldg_design_loads.Cool_Infil_Sens = 1.1 * @acf * cfm_Cool_Load_Sens * @ctd
-    bldg_design_loads.Cool_Infil_Lat = 0.68 * @acf * cfm_Cool_Load_Lat * (@cool_design_grains - @cool_indoor_grains)
+    bldg_design_loads.Cool_InfilVent_Sens = 1.1 * @acf * cfm_cool_load_sens * @ctd
+    bldg_design_loads.Cool_InfilVent_Lat = 0.68 * @acf * cfm_cool_load_lat * (@cool_design_grains - @cool_indoor_grains)
   end
 
   def self.process_load_internal_gains(bldg_design_loads)
@@ -1026,10 +1024,8 @@ class HVACSizing
     Cooling Load: Internal Gains
     '''
 
-    # Per ANSI/RESNET/ICC 301
-    n_occupants = @nbeds + 1
-    bldg_design_loads.Cool_IntGains_Sens = 1600.0 + 230.0 * n_occupants
-    bldg_design_loads.Cool_IntGains_Lat = 200.0 * n_occupants
+    bldg_design_loads.Cool_IntGains_Sens = @hpxml.header.manualj_internal_loads_sensible + 230.0 * @hpxml.header.manualj_num_occupants
+    bldg_design_loads.Cool_IntGains_Lat = @hpxml.header.manualj_internal_loads_latent + 200.0 * @hpxml.header.manualj_num_occupants
   end
 
   def self.aggregate_loads(bldg_design_loads)
@@ -1048,12 +1044,12 @@ class HVACSizing
     bldg_design_loads.Cool_Sens = bldg_design_loads.Cool_Windows + bldg_design_loads.Cool_Skylights +
                                   bldg_design_loads.Cool_Doors + bldg_design_loads.Cool_Walls +
                                   bldg_design_loads.Cool_Floors + bldg_design_loads.Cool_Ceilings +
-                                  bldg_design_loads.Cool_Roofs + bldg_design_loads.Cool_Infil_Sens +
+                                  bldg_design_loads.Cool_Roofs + bldg_design_loads.Cool_InfilVent_Sens +
                                   bldg_design_loads.Cool_IntGains_Sens
-    bldg_design_loads.Cool_Lat = bldg_design_loads.Cool_Infil_Lat + bldg_design_loads.Cool_IntGains_Lat
+    bldg_design_loads.Cool_Lat = bldg_design_loads.Cool_InfilVent_Lat + bldg_design_loads.Cool_IntGains_Lat
     if bldg_design_loads.Cool_Lat < 0 # No latent loads; also zero out individual components
       bldg_design_loads.Cool_Lat = 0.0
-      bldg_design_loads.Cool_Infil_Lat = 0.0
+      bldg_design_loads.Cool_InfilVent_Lat = 0.0
       bldg_design_loads.Cool_IntGains_Lat = 0.0
     end
     bldg_design_loads.Cool_Tot = bldg_design_loads.Cool_Sens + bldg_design_loads.Cool_Lat
@@ -1064,60 +1060,55 @@ class HVACSizing
     bldg_design_loads.Cool_Ducts_Lat = 0.0
   end
 
-  def self.apply_hvac_temperatures(hvac, system_design_loads)
+  def self.apply_hvac_temperatures(system_design_loads, hvac_heating, hvac_cooling)
     '''
     HVAC Temperatures
     '''
     # Evaporative cooler temperature calculation based on Manual S Figure 4-7
-    if hvac.CoolType == HPXML::HVACTypeEvaporativeCooler
+    if @cooling_type == HPXML::HVACTypeEvaporativeCooler
       td_potential = @cool_design_temps[HPXML::LocationOutside] - @wetbulb_outdoor_cooling
-      td = td_potential * hvac.EvapCoolerEffectiveness
-      hvac.LeavingAirTemp = @cool_design_temps[HPXML::LocationOutside] - td
+      td = td_potential * hvac_cooling.additional_properties.effectiveness
+      @leaving_air_temp = @cool_design_temps[HPXML::LocationOutside] - td
     else
       # Calculate Leaving Air Temperature
       shr = [system_design_loads.Cool_Sens / system_design_loads.Cool_Tot, 1.0].min
       # Determine the Leaving Air Temperature (LAT) based on Manual S Table 1-4
       if shr < 0.80
-        hvac.LeavingAirTemp = 54.0 # F
+        @leaving_air_temp = 54.0 # F
       elsif shr < 0.85
         # MJ8 says to use 56 degF in this SHR range. Linear interpolation provides a more
         # continuous supply air flow rate across building efficiency levels.
-        hvac.LeavingAirTemp = ((58.0 - 54.0) / (0.85 - 0.80)) * (shr - 0.8) + 54.0 # F
+        @leaving_air_temp = ((58.0 - 54.0) / (0.85 - 0.80)) * (shr - 0.8) + 54.0 # F
       else
-        hvac.LeavingAirTemp = 58.0 # F
+        @leaving_air_temp = 58.0 # F
       end
     end
 
     # Calculate Supply Air Temperature
-    if [HPXML::HVACTypeHeatPumpAirToAir,
-        HPXML::HVACTypeHeatPumpMiniSplit,
-        HPXML::HVACTypeHeatPumpGroundToAir,
-        HPXML::HVACTypeHeatPumpWaterLoopToAir,
-        HPXML::HVACTypeHeatPumpPTHP,
-        HPXML::HVACTypeHeatPumpRoom].include? hvac.HeatType
-      hvac.SupplyAirTemp = 105.0 # F
-      hvac.BackupSupplyAirTemp = 120.0 # F
+    if hvac_heating.is_a? HPXML::HeatPump
+      @supply_air_temp = 105.0 # F
+      @backup_supply_air_temp = 120.0 # F
     else
-      hvac.SupplyAirTemp = 120.0 # F
+      @supply_air_temp = 120.0 # F
     end
   end
 
-  def self.apply_hvac_loads(hvac, system_design_loads, bldg_design_loads, ducts_heat_load, ducts_cool_load_sens, ducts_cool_load_lat)
+  def self.apply_hvac_loads(hvac_heating, system_design_loads, bldg_design_loads, ducts_heat_load, ducts_cool_load_sens, ducts_cool_load_lat)
     # Calculate design loads that this HVAC system serves
 
     # Heating
-    system_design_loads.Heat_Load = bldg_design_loads.Heat_Tot * hvac.HeatingLoadFraction
-    if hvac.HeatType == HPXML::HVACTypeHeatPumpWaterLoopToAir
+    system_design_loads.Heat_Load = bldg_design_loads.Heat_Tot * @fraction_heat_load_served
+    if @heating_type == HPXML::HVACTypeHeatPumpWaterLoopToAir
       # Size to meet original fraction load served (not adjusted value from HVAC.apply_shared_heating_systems()
       # This ensures, e.g., that an appropriate heating airflow is used for duct losses.
-      system_design_loads.Heat_Load = system_design_loads.Heat_Load / (1.0 / hvac.HeatingCOP)
+      system_design_loads.Heat_Load = system_design_loads.Heat_Load / (1.0 / hvac_heating.heating_efficiency_cop)
     end
     system_design_loads.Heat_Load_Supp = system_design_loads.Heat_Load
 
     # Cooling
-    system_design_loads.Cool_Load_Tot = bldg_design_loads.Cool_Tot * hvac.CoolingLoadFraction
-    system_design_loads.Cool_Load_Sens = bldg_design_loads.Cool_Sens * hvac.CoolingLoadFraction
-    system_design_loads.Cool_Load_Lat = bldg_design_loads.Cool_Lat * hvac.CoolingLoadFraction
+    system_design_loads.Cool_Load_Tot = bldg_design_loads.Cool_Tot * @fraction_cool_load_served
+    system_design_loads.Cool_Load_Sens = bldg_design_loads.Cool_Sens * @fraction_cool_load_served
+    system_design_loads.Cool_Load_Lat = bldg_design_loads.Cool_Lat * @fraction_cool_load_served
 
     # After applying load fraction to building design loads (w/o ducts), add duct load specific to this HVAC system
     system_design_loads.Heat_Load += ducts_heat_load.to_f
@@ -1127,54 +1118,65 @@ class HVACSizing
     system_design_loads.Cool_Load_Tot += ducts_cool_load_sens.to_f + ducts_cool_load_lat.to_f
   end
 
-  def self.apply_hvac_heat_pump_logic(hvac_sizing_values, hvac)
-    # If HERS/MaxLoad methodology, uses at least the larger of heating and cooling loads for heat pump sizing (required for ERI).
-    if [HPXML::HVACTypeHeatPumpAirToAir,
-        HPXML::HVACTypeHeatPumpMiniSplit,
-        HPXML::HVACTypeHeatPumpGroundToAir,
-        HPXML::HVACTypeHeatPumpWaterLoopToAir,
-        HPXML::HVACTypeHeatPumpPTHP,
-        HPXML::HVACTypeHeatPumpRoom].include? hvac.CoolType
-      if (@hpxml.header.heat_pump_sizing_methodology != HPXML::HeatPumpSizingACCA) && (hvac.CoolingLoadFraction > 0) && (hvac.HeatingLoadFraction > 0)
-        # Note: Heat_Load_Supp should NOT be adjusted; we only want to adjust the HP capacity, not the HP backup heating capacity.
-        max_load = [hvac_sizing_values.Heat_Load, hvac_sizing_values.Cool_Load_Tot].max
-        hvac_sizing_values.Heat_Load = max_load
-        hvac_sizing_values.Cool_Load_Sens *= max_load / hvac_sizing_values.Cool_Load_Tot
-        hvac_sizing_values.Cool_Load_Lat *= max_load / hvac_sizing_values.Cool_Load_Tot
-        hvac_sizing_values.Cool_Load_Tot = max_load
+  def self.apply_hvac_size_limits(hvac_cooling)
+    @oversize_limit = 1.15
+    @oversize_delta = 15000.0
+    @undersize_limit = 0.9
 
-        # Override Manual S oversize allowances:
-        hvac.OverSizeLimit = 1.0
-        hvac.OverSizeDelta = 0.0
+    if not hvac_cooling.nil?
+      if hvac_cooling.compressor_type == HPXML::HVACCompressorTypeTwoStage
+        @oversize_limit = 1.2
+      elsif hvac_cooling.compressor_type == HPXML::HVACCompressorTypeVariableSpeed
+        @oversize_limit = 1.3
       end
     end
   end
 
+  def self.apply_hvac_heat_pump_logic(hvac_sizing_values, hvac_cooling)
+    # If HERS/MaxLoad methodology, uses at least the larger of heating and cooling loads for heat pump sizing (required for ERI).
+    return unless hvac_cooling.is_a? HPXML::HeatPump
+    return if @fraction_cool_load_served == 0
+    return if @fraction_heat_load_served == 0
+
+    if (@hpxml.header.heat_pump_sizing_methodology != HPXML::HeatPumpSizingACCA)
+      # Note: Heat_Load_Supp should NOT be adjusted; we only want to adjust the HP capacity, not the HP backup heating capacity.
+      max_load = [hvac_sizing_values.Heat_Load, hvac_sizing_values.Cool_Load_Tot].max
+      hvac_sizing_values.Heat_Load = max_load
+      hvac_sizing_values.Cool_Load_Sens *= max_load / hvac_sizing_values.Cool_Load_Tot
+      hvac_sizing_values.Cool_Load_Lat *= max_load / hvac_sizing_values.Cool_Load_Tot
+      hvac_sizing_values.Cool_Load_Tot = max_load
+
+      # Override Manual S oversize allowances:
+      @oversize_limit = 1.0
+      @oversize_delta = 0.0
+    end
+  end
+
   def self.get_duct_regain_factor(duct)
     # dse_Fregain values comes from MJ8 pg 204 and Walker (1998) "Technical background for default
     # values used for forced air systems in proposed ASHRAE Std. 152"
 
     dse_Fregain = nil
 
-    if [HPXML::LocationOutside, HPXML::LocationRoofDeck].include? duct.Location
+    if [HPXML::LocationOutside, HPXML::LocationRoofDeck].include? duct.duct_location
       dse_Fregain = 0.0
 
     elsif [HPXML::LocationOtherHousingUnit, HPXML::LocationOtherHeatedSpace, HPXML::LocationOtherMultifamilyBufferSpace,
-           HPXML::LocationOtherNonFreezingSpace, HPXML::LocationExteriorWall, HPXML::LocationUnderSlab].include? duct.Location
-      space_values = Geometry.get_temperature_scheduled_space_values(duct.Location)
+           HPXML::LocationOtherNonFreezingSpace, HPXML::LocationExteriorWall, HPXML::LocationUnderSlab].include? duct.duct_location
+      space_values = Geometry.get_temperature_scheduled_space_values(duct.duct_location)
       dse_Fregain = space_values[:f_regain]
 
-    elsif [HPXML::LocationBasementUnconditioned, HPXML::LocationCrawlspaceVented, HPXML::LocationCrawlspaceUnvented].include? duct.Location
+    elsif [HPXML::LocationBasementUnconditioned, HPXML::LocationCrawlspaceVented, HPXML::LocationCrawlspaceUnvented].include? duct.duct_location
 
-      ceilings = @hpxml.floors.select { |f| f.is_floor && [f.interior_adjacent_to, f.exterior_adjacent_to].include?(duct.Location) }
+      ceilings = @hpxml.floors.select { |f| f.is_floor && [f.interior_adjacent_to, f.exterior_adjacent_to].include?(duct.duct_location) }
       avg_ceiling_rvalue = calculate_average_r_value(ceilings)
       ceiling_insulated = (avg_ceiling_rvalue > 4)
 
-      walls = @hpxml.foundation_walls.select { |f| [f.interior_adjacent_to, f.exterior_adjacent_to].include? duct.Location }
+      walls = @hpxml.foundation_walls.select { |f| [f.interior_adjacent_to, f.exterior_adjacent_to].include? duct.duct_location }
       avg_wall_rvalue = calculate_average_r_value(walls)
       walls_insulated = (avg_wall_rvalue > 4)
 
-      if duct.Location == HPXML::LocationBasementUnconditioned
+      if duct.duct_location == HPXML::LocationBasementUnconditioned
         if not ceiling_insulated
           if not walls_insulated
             dse_Fregain = 0.50 # Uninsulated ceiling, uninsulated walls
@@ -1184,7 +1186,7 @@ class HVACSizing
         else
           dse_Fregain = 0.30 # Insulated ceiling
         end
-      elsif duct.Location == HPXML::LocationCrawlspaceVented
+      elsif duct.duct_location == HPXML::LocationCrawlspaceVented
         if ceiling_insulated && walls_insulated
           dse_Fregain = 0.17 # Insulated ceiling, insulated walls
         elsif ceiling_insulated && (not walls_insulated)
@@ -1194,7 +1196,7 @@ class HVACSizing
         elsif (not ceiling_insulated) && (not walls_insulated)
           dse_Fregain = 0.50 # Uninsulated ceiling, uninsulated walls
         end
-      elsif duct.Location == HPXML::LocationCrawlspaceUnvented
+      elsif duct.duct_location == HPXML::LocationCrawlspaceUnvented
         if ceiling_insulated && walls_insulated
           dse_Fregain = 0.30 # Insulated ceiling, insulated walls
         elsif ceiling_insulated && (not walls_insulated)
@@ -1206,13 +1208,13 @@ class HVACSizing
         end
       end
 
-    elsif [HPXML::LocationAtticVented, HPXML::LocationAtticUnvented].include? duct.Location
+    elsif [HPXML::LocationAtticVented, HPXML::LocationAtticUnvented].include? duct.duct_location
       dse_Fregain = 0.10 # This would likely be higher for unvented attics with roof insulation
 
-    elsif [HPXML::LocationGarage].include? duct.Location
+    elsif [HPXML::LocationGarage].include? duct.duct_location
       dse_Fregain = 0.05
 
-    elsif HPXML::conditioned_locations.include? duct.Location
+    elsif HPXML::conditioned_locations.include? duct.duct_location
       dse_Fregain = 1.0
 
     end
@@ -1220,31 +1222,20 @@ class HVACSizing
     return dse_Fregain
   end
 
-  def self.calculate_load_ducts_heating(system_design_loads, hvac)
+  def self.calculate_load_ducts_heating(system_design_loads, hvac_heating)
     '''
     Heating Duct Loads
     '''
 
-    return if (system_design_loads.Heat_Tot == 0) || (hvac.HeatingLoadFraction == 0) || hvac.Ducts.empty?
+    return if hvac_heating.nil? || (system_design_loads.Heat_Tot == 0) || hvac_heating.distribution_system.nil? || hvac_heating.distribution_system.ducts.empty?
+    return if @fraction_heat_load_served == 0
 
-    init_heat_load = system_design_loads.Heat_Tot * hvac.HeatingLoadFraction
+    init_heat_load = system_design_loads.Heat_Tot * @fraction_heat_load_served
 
     # Distribution system efficiency (DSE) calculations based on ASHRAE Standard 152
-    dse_As, dse_Ar = calc_ducts_areas(hvac.Ducts)
-    supply_r, return_r = calc_ducts_rvalues(hvac.Ducts)
-
-    design_temp_values = { HPXML::DuctTypeSupply => @heat_design_temps, HPXML::DuctTypeReturn => @heat_design_temps }
-    dse_Tamb_heating_s, dse_Tamb_heating_r = calc_ducts_area_weighted_average(hvac.Ducts, design_temp_values)
 
-    # ASHRAE 152 6.5.2
-    # For systems with ducts in several locations, F_regain shall be weighted by the fraction of exposed duct area
-    # in each space. F_regain shall be calculated separately for supply and return locations.
-    dse_Fregains = {}
-    hvac.Ducts.each do |duct|
-      dse_Fregains[duct.Location] = get_duct_regain_factor(duct)
-    end
-    fregain_values = { HPXML::DuctTypeSupply => dse_Fregains, HPXML::DuctTypeReturn => dse_Fregains }
-    dse_Fregain_s, dse_Fregain_r = calc_ducts_area_weighted_average(hvac.Ducts, fregain_values)
+    duct_values = calc_duct_conduction_values(hvac_heating.distribution_system, @heat_design_temps)
+    dse_As, dse_Ar, supply_r, return_r, dse_Tamb_s, dse_Tamb_r, dse_Fregain_s, dse_Fregain_r = duct_values
 
     # Initialize for the iteration
     delta = 1
@@ -1256,11 +1247,11 @@ class HVACSizing
       heat_load_prev = heat_load_next
 
       # Calculate the new heating air flow rate
-      heat_cfm = calc_airflow_rate_manual_s(heat_load_next, (hvac.SupplyAirTemp - @heat_setpoint))
+      heat_cfm = calc_airflow_rate_manual_s(heat_load_next, (@supply_air_temp - @heat_setpoint))
 
-      dse_Qs, dse_Qr = calc_ducts_leakages(hvac.Ducts, heat_cfm)
+      dse_Qs, dse_Qr = calc_duct_leakages_cfm25(hvac_heating.distribution_system, heat_cfm)
 
-      dse_DE = calc_delivery_effectiveness_heating(dse_Qs, dse_Qr, heat_cfm, heat_load_next, dse_Tamb_heating_s, dse_Tamb_heating_r, dse_As, dse_Ar, @heat_setpoint, dse_Fregain_s, dse_Fregain_r, supply_r, return_r)
+      dse_DE = calc_delivery_effectiveness_heating(dse_Qs, dse_Qr, heat_cfm, heat_load_next, dse_Tamb_s, dse_Tamb_r, dse_As, dse_Ar, @heat_setpoint, dse_Fregain_s, dse_Fregain_r, supply_r, return_r)
 
       # Calculate the increase in heating load due to ducts (Approach: DE = Qload/Qequip -> Qducts = Qequip-Qload)
       heat_load_next = init_heat_load / dse_DE
@@ -1273,41 +1264,31 @@ class HVACSizing
     return ducts_heat_load
   end
 
-  def self.calculate_load_ducts_cooling(system_design_loads, weather, hvac)
+  def self.calculate_load_ducts_cooling(system_design_loads, weather, hvac_cooling)
     '''
     Cooling Duct Loads
     '''
-    return if (system_design_loads.Cool_Sens == 0) || (hvac.CoolingLoadFraction == 0) || hvac.Ducts.empty?
 
-    init_cool_load_sens = system_design_loads.Cool_Sens * hvac.CoolingLoadFraction
-    init_cool_load_lat = system_design_loads.Cool_Lat * hvac.CoolingLoadFraction
+    return if hvac_cooling.nil? || (system_design_loads.Cool_Sens == 0) || hvac_cooling.distribution_system.nil? || hvac_cooling.distribution_system.ducts.empty?
+    return if @fraction_cool_load_served == 0
+
+    init_cool_load_sens = system_design_loads.Cool_Sens * @fraction_cool_load_served
+    init_cool_load_lat = system_design_loads.Cool_Lat * @fraction_cool_load_served
 
     # Distribution system efficiency (DSE) calculations based on ASHRAE Standard 152
-    dse_As, dse_Ar = calc_ducts_areas(hvac.Ducts)
-    supply_r, return_r = calc_ducts_rvalues(hvac.Ducts)
 
-    design_temp_values = { HPXML::DuctTypeSupply => @cool_design_temps, HPXML::DuctTypeReturn => @cool_design_temps }
-    dse_Tamb_cooling_s, dse_Tamb_cooling_r = calc_ducts_area_weighted_average(hvac.Ducts, design_temp_values)
-
-    # ASHRAE 152 6.5.2
-    # For systems with ducts in several locations, F_regain shall be weighted by the fraction of exposed duct area
-    # in each space. F_regain shall be calculated separately for supply and return locations.
-    dse_Fregains = {}
-    hvac.Ducts.each do |duct|
-      dse_Fregains[duct.Location] = get_duct_regain_factor(duct)
-    end
-    fregain_values = { HPXML::DuctTypeSupply => dse_Fregains, HPXML::DuctTypeReturn => dse_Fregains }
-    dse_Fregain_s, dse_Fregain_r = calc_ducts_area_weighted_average(hvac.Ducts, fregain_values)
+    duct_values = calc_duct_conduction_values(hvac_cooling.distribution_system, @cool_design_temps)
+    dse_As, dse_Ar, supply_r, return_r, dse_Tamb_s, dse_Tamb_r, dse_Fregain_s, dse_Fregain_r = duct_values
 
     # Calculate the air enthalpy in the return duct location for DSE calculations
-    dse_h_r = (1.006 * UnitConversions.convert(dse_Tamb_cooling_r, 'F', 'C') + weather.design.CoolingHumidityRatio * (2501.0 + 1.86 * UnitConversions.convert(dse_Tamb_cooling_r, 'F', 'C'))) * UnitConversions.convert(1.0, 'kJ', 'Btu') * UnitConversions.convert(1.0, 'lbm', 'kg')
+    dse_h_r = (1.006 * UnitConversions.convert(dse_Tamb_r, 'F', 'C') + weather.design.CoolingHumidityRatio * (2501.0 + 1.86 * UnitConversions.convert(dse_Tamb_r, 'F', 'C'))) * UnitConversions.convert(1.0, 'kJ', 'Btu') * UnitConversions.convert(1.0, 'lbm', 'kg')
 
     # Initialize for the iteration
     delta = 1
     cool_load_tot_next = init_cool_load_sens + init_cool_load_lat
 
-    cool_cfm = calc_airflow_rate_manual_s(init_cool_load_sens, (@cool_setpoint - hvac.LeavingAirTemp))
-    _dse_Qs, dse_Qr = calc_ducts_leakages(hvac.Ducts, cool_cfm)
+    cool_cfm = calc_airflow_rate_manual_s(init_cool_load_sens, (@cool_setpoint - @leaving_air_temp))
+    _dse_Qs, dse_Qr = calc_duct_leakages_cfm25(hvac_cooling.distribution_system, cool_cfm)
 
     for _iter in 1..50
       break if delta.abs <= 0.001
@@ -1318,11 +1299,11 @@ class HVACSizing
       cool_load_tot = cool_load_lat + cool_load_sens
 
       # Calculate the new cooling air flow rate
-      cool_cfm = calc_airflow_rate_manual_s(cool_load_sens, (@cool_setpoint - hvac.LeavingAirTemp))
+      cool_cfm = calc_airflow_rate_manual_s(cool_load_sens, (@cool_setpoint - @leaving_air_temp))
 
-      dse_Qs, dse_Qr = calc_ducts_leakages(hvac.Ducts, cool_cfm)
+      dse_Qs, dse_Qr = calc_duct_leakages_cfm25(hvac_cooling.distribution_system, cool_cfm)
 
-      dse_DE, _dse_dTe_cooling, _cool_duct_sens = calc_delivery_effectiveness_cooling(dse_Qs, dse_Qr, hvac.LeavingAirTemp, cool_cfm, cool_load_sens, dse_Tamb_cooling_s, dse_Tamb_cooling_r, dse_As, dse_Ar, @cool_setpoint, dse_Fregain_s, dse_Fregain_r, cool_load_tot, dse_h_r, supply_r, return_r)
+      dse_DE, _dse_dTe_cooling, _cool_duct_sens = calc_delivery_effectiveness_cooling(dse_Qs, dse_Qr, @leaving_air_temp, cool_cfm, cool_load_sens, dse_Tamb_s, dse_Tamb_r, dse_As, dse_Ar, @cool_setpoint, dse_Fregain_s, dse_Fregain_r, cool_load_tot, dse_h_r, supply_r, return_r)
 
       cool_load_tot_next = (init_cool_load_sens + init_cool_load_lat) / dse_DE
 
@@ -1345,17 +1326,19 @@ class HVACSizing
     bldg_design_loads.Cool_Tot += total_ducts_cool_load_sens.to_f + total_ducts_cool_load_lat.to_f
   end
 
-  def self.apply_hvac_equipment_adjustments(hvac_sizing_values, weather, hvac)
+  def self.apply_hvac_equipment_adjustments(hvac_sizing_values, weather, hvac_heating, hvac_cooling, hvac_system)
     '''
     Equipment Adjustments
     '''
 
-    underSizeLimit = 0.9
-
     # Cooling
 
+    if not hvac_cooling.nil?
+      hvac_cooling_ap = hvac_cooling.additional_properties
+    end
+
     # Calculate the air flow rate required for design conditions
-    hvac_sizing_values.Cool_Airflow = calc_airflow_rate_manual_s(hvac_sizing_values.Cool_Load_Sens, (@cool_setpoint - hvac.LeavingAirTemp))
+    hvac_sizing_values.Cool_Airflow = calc_airflow_rate_manual_s(hvac_sizing_values.Cool_Load_Sens, (@cool_setpoint - @leaving_air_temp))
 
     if hvac_sizing_values.Cool_Load_Tot <= 0
 
@@ -1364,19 +1347,21 @@ class HVACSizing
       hvac_sizing_values.Cool_Airflow = 0.0
 
     elsif [HPXML::HVACTypeCentralAirConditioner,
-           HPXML::HVACTypeHeatPumpAirToAir].include? hvac.CoolType
+           HPXML::HVACTypeHeatPumpAirToAir].include? @cooling_type
 
-      enteringTemp = weather.design.CoolingDrybulb
-      coefficients = hvac.COOL_CAP_FT_SPEC[hvac.SizingSpeed]
+      entering_temp = @hpxml.header.manualj_cooling_design_temp
+      hvac_cooling_speed = get_sizing_speed(hvac_cooling_ap)
+      coefficients = hvac_cooling_ap.cool_cap_ft_spec[hvac_cooling_speed]
 
-      totalCap_CurveValue = MathTools.biquadratic(@wetbulb_indoor_cooling, enteringTemp, coefficients)
-      coolCap_Rated = hvac_sizing_values.Cool_Load_Tot / totalCap_CurveValue
+      total_cap_curve_value = MathTools.biquadratic(@wetbulb_indoor_cooling, entering_temp, coefficients)
+      cool_cap_rated = hvac_sizing_values.Cool_Load_Tot / total_cap_curve_value
 
-      sensCap_Rated = coolCap_Rated * hvac.SHRRated[hvac.SizingSpeed]
+      hvac_cooling_shr = hvac_cooling_ap.cool_rated_shrs_gross[hvac_cooling_speed]
+      sens_cap_rated = cool_cap_rated * hvac_cooling_shr
 
-      sensibleCap_CurveValue = process_curve_fit(hvac_sizing_values.Cool_Airflow, hvac_sizing_values.Cool_Load_Tot, enteringTemp)
-      sensCap_Design = sensCap_Rated * sensibleCap_CurveValue
-      latCap_Design = [hvac_sizing_values.Cool_Load_Tot - sensCap_Design, 1.0].max
+      sensible_cap_curve_value = process_curve_fit(hvac_sizing_values.Cool_Airflow, hvac_sizing_values.Cool_Load_Tot, entering_temp)
+      sens_cap_design = sens_cap_rated * sensible_cap_curve_value
+      lat_cap_design = [hvac_sizing_values.Cool_Load_Tot - sens_cap_design, 1.0].max
 
       shr_biquadratic = get_shr_biquadratic
       a_sens = shr_biquadratic[0]
@@ -1385,75 +1370,75 @@ class HVACSizing
       d_sens = shr_biquadratic[5]
 
       # Adjust Sizing
-      if latCap_Design < hvac_sizing_values.Cool_Load_Lat
+      if lat_cap_design < hvac_sizing_values.Cool_Load_Lat
         # Size by MJ8 Latent load, return to rated conditions
 
         # Solve for the new sensible and total capacity at design conditions:
-        # CoolingLoad_Lat = cool_Capacity_Design - cool_Load_SensCap_Design
-        # solve the following for cool_Capacity_Design: SensCap_Design = SHRRated * cool_Capacity_Design / TotalCap_CurveValue * function(CFM/cool_Capacity_Design, ODB)
-        # substituting in CFM = cool_Load_SensCap_Design / (1.1 * ACF * (cool_setpoint - LAT))
+        # CoolingLoad_Lat = cool_cap_design - cool_load_sens_cap_design
+        # solve the following for cool_cap_design: sens_cap_design = SHRRated * cool_cap_design / total_cap_curve_value * function(CFM/cool_cap_design, ODB)
+        # substituting in CFM = cool_load_sens_cap_design / (1.1 * ACF * (cool_setpoint - LAT))
 
-        cool_Load_SensCap_Design = hvac_sizing_values.Cool_Load_Lat / ((totalCap_CurveValue / hvac.SHRRated[hvac.SizingSpeed] - \
-                                  (UnitConversions.convert(b_sens, 'ton', 'Btu/hr') + UnitConversions.convert(d_sens, 'ton', 'Btu/hr') * enteringTemp) / \
-                                  (1.1 * @acf * (@cool_setpoint - hvac.LeavingAirTemp))) / \
-                                  (a_sens + c_sens * enteringTemp) - 1.0)
+        cool_load_sens_cap_design = hvac_sizing_values.Cool_Load_Lat / ((total_cap_curve_value / hvac_cooling_shr - \
+                                  (UnitConversions.convert(b_sens, 'ton', 'Btu/hr') + UnitConversions.convert(d_sens, 'ton', 'Btu/hr') * entering_temp) / \
+                                  (1.1 * @acf * (@cool_setpoint - @leaving_air_temp))) / \
+                                  (a_sens + c_sens * entering_temp) - 1.0)
 
-        cool_Capacity_Design = cool_Load_SensCap_Design + hvac_sizing_values.Cool_Load_Lat
+        cool_cap_design = cool_load_sens_cap_design + hvac_sizing_values.Cool_Load_Lat
 
         # The SHR of the equipment at the design condition
-        sHR_design = cool_Load_SensCap_Design / cool_Capacity_Design
+        shr_design = cool_load_sens_cap_design / cool_cap_design
 
         # If the adjusted equipment size is negative (occurs at altitude), use oversize limit (the adjustment
         # almost always hits the oversize limit in this case, making this a safe assumption)
-        if (cool_Capacity_Design < 0) || (cool_Load_SensCap_Design < 0)
-          cool_Capacity_Design = hvac.OverSizeLimit * hvac_sizing_values.Cool_Load_Tot
+        if (cool_cap_design < 0) || (cool_load_sens_cap_design < 0)
+          cool_cap_design = @oversize_limit * hvac_sizing_values.Cool_Load_Tot
         end
 
         # Limit total capacity to oversize limit
-        cool_Capacity_Design = [cool_Capacity_Design, hvac.OverSizeLimit * hvac_sizing_values.Cool_Load_Tot].min
+        cool_cap_design = [cool_cap_design, @oversize_limit * hvac_sizing_values.Cool_Load_Tot].min
 
         # Determine the final sensible capacity at design using the SHR
-        cool_Load_SensCap_Design = sHR_design * cool_Capacity_Design
+        cool_load_sens_cap_design = shr_design * cool_cap_design
 
         # Calculate the final air flow rate using final sensible capacity at design
-        hvac_sizing_values.Cool_Airflow = calc_airflow_rate_manual_s(cool_Load_SensCap_Design, (@cool_setpoint - hvac.LeavingAirTemp))
+        hvac_sizing_values.Cool_Airflow = calc_airflow_rate_manual_s(cool_load_sens_cap_design, (@cool_setpoint - @leaving_air_temp))
 
         # Determine rated capacities
-        hvac_sizing_values.Cool_Capacity = cool_Capacity_Design / totalCap_CurveValue
-        hvac_sizing_values.Cool_Capacity_Sens = hvac_sizing_values.Cool_Capacity * hvac.SHRRated[hvac.SizingSpeed]
+        hvac_sizing_values.Cool_Capacity = cool_cap_design / total_cap_curve_value
+        hvac_sizing_values.Cool_Capacity_Sens = hvac_sizing_values.Cool_Capacity * hvac_cooling_shr
 
-      elsif sensCap_Design < underSizeLimit * hvac_sizing_values.Cool_Load_Sens
+      elsif sens_cap_design < @undersize_limit * hvac_sizing_values.Cool_Load_Sens
         # Size by MJ8 Sensible load, return to rated conditions, find Sens with SHRRated. Limit total
         # capacity to oversizing limit
 
-        sensCap_Design = underSizeLimit * hvac_sizing_values.Cool_Load_Sens
+        sens_cap_design = @undersize_limit * hvac_sizing_values.Cool_Load_Sens
 
         # Solve for the new total system capacity at design conditions:
-        # SensCap_Design   = SensCap_Rated * SensibleCap_CurveValue
-        #                  = SHRRated * cool_Capacity_Design / TotalCap_CurveValue * SensibleCap_CurveValue
-        #                  = SHRRated * cool_Capacity_Design / TotalCap_CurveValue * function(CFM/cool_Capacity_Design, ODB)
+        # sens_cap_design   = sens_cap_rated * sensible_cap_curve_value
+        #                  = SHRRated * cool_cap_design / total_cap_curve_value * sensible_cap_curve_value
+        #                  = SHRRated * cool_cap_design / total_cap_curve_value * function(CFM/cool_cap_design, ODB)
 
-        cool_Capacity_Design = (sensCap_Design / (hvac.SHRRated[hvac.SizingSpeed] / totalCap_CurveValue) - \
+        cool_cap_design = (sens_cap_design / (hvac_cooling_shr / total_cap_curve_value) - \
                                            (b_sens * UnitConversions.convert(hvac_sizing_values.Cool_Airflow, 'ton', 'Btu/hr') + \
-                                           d_sens * UnitConversions.convert(hvac_sizing_values.Cool_Airflow, 'ton', 'Btu/hr') * enteringTemp)) / \
-                               (a_sens + c_sens * enteringTemp)
+                                           d_sens * UnitConversions.convert(hvac_sizing_values.Cool_Airflow, 'ton', 'Btu/hr') * entering_temp)) / \
+                          (a_sens + c_sens * entering_temp)
 
         # Limit total capacity to oversize limit
-        cool_Capacity_Design = [cool_Capacity_Design, hvac.OverSizeLimit * hvac_sizing_values.Cool_Load_Tot].min
+        cool_cap_design = [cool_cap_design, @oversize_limit * hvac_sizing_values.Cool_Load_Tot].min
 
-        hvac_sizing_values.Cool_Capacity = cool_Capacity_Design / totalCap_CurveValue
-        hvac_sizing_values.Cool_Capacity_Sens = hvac_sizing_values.Cool_Capacity * hvac.SHRRated[hvac.SizingSpeed]
+        hvac_sizing_values.Cool_Capacity = cool_cap_design / total_cap_curve_value
+        hvac_sizing_values.Cool_Capacity_Sens = hvac_sizing_values.Cool_Capacity * hvac_cooling_shr
 
         # Recalculate the air flow rate in case the oversizing limit has been used
-        cool_Load_SensCap_Design = hvac_sizing_values.Cool_Capacity_Sens * sensibleCap_CurveValue
-        hvac_sizing_values.Cool_Airflow = calc_airflow_rate_manual_s(cool_Load_SensCap_Design, (@cool_setpoint - hvac.LeavingAirTemp))
+        cool_load_sens_cap_design = hvac_sizing_values.Cool_Capacity_Sens * sensible_cap_curve_value
+        hvac_sizing_values.Cool_Airflow = calc_airflow_rate_manual_s(cool_load_sens_cap_design, (@cool_setpoint - @leaving_air_temp))
 
       else
-        hvac_sizing_values.Cool_Capacity = hvac_sizing_values.Cool_Load_Tot / totalCap_CurveValue
-        hvac_sizing_values.Cool_Capacity_Sens = hvac_sizing_values.Cool_Capacity * hvac.SHRRated[hvac.SizingSpeed]
+        hvac_sizing_values.Cool_Capacity = hvac_sizing_values.Cool_Load_Tot / total_cap_curve_value
+        hvac_sizing_values.Cool_Capacity_Sens = hvac_sizing_values.Cool_Capacity * hvac_cooling_shr
 
-        cool_Load_SensCap_Design = hvac_sizing_values.Cool_Capacity_Sens * sensibleCap_CurveValue
-        hvac_sizing_values.Cool_Airflow = calc_airflow_rate_manual_s(cool_Load_SensCap_Design, (@cool_setpoint - hvac.LeavingAirTemp))
+        cool_load_sens_cap_design = hvac_sizing_values.Cool_Capacity_Sens * sensible_cap_curve_value
+        hvac_sizing_values.Cool_Airflow = calc_airflow_rate_manual_s(cool_load_sens_cap_design, (@cool_setpoint - @leaving_air_temp))
       end
 
       # Ensure the air flow rate is in between 200 and 500 cfm/ton.
@@ -1465,85 +1450,93 @@ class HVACSizing
       end
 
     elsif [HPXML::HVACTypeHeatPumpMiniSplit,
-           HPXML::HVACTypeMiniSplitAirConditioner].include? hvac.CoolType
+           HPXML::HVACTypeMiniSplitAirConditioner].include? @cooling_type
 
-      enteringTemp = weather.design.CoolingDrybulb
-      coefficients = hvac.COOL_CAP_FT_SPEC[hvac.SizingSpeed]
+      entering_temp = @hpxml.header.manualj_cooling_design_temp
+      hvac_cooling_speed = get_sizing_speed(hvac_cooling_ap)
+      coefficients = hvac_cooling_ap.cool_cap_ft_spec[hvac_cooling_speed]
 
-      totalCap_CurveValue = MathTools.biquadratic(@wetbulb_indoor_cooling, enteringTemp, coefficients)
+      total_cap_curve_value = MathTools.biquadratic(@wetbulb_indoor_cooling, entering_temp, coefficients)
+      hvac_cooling_shr = hvac_cooling_ap.cool_rated_shrs_gross[hvac_cooling_speed]
 
-      hvac_sizing_values.Cool_Capacity = (hvac_sizing_values.Cool_Load_Tot / totalCap_CurveValue)
-      hvac_sizing_values.Cool_Capacity_Sens = hvac_sizing_values.Cool_Capacity * hvac.SHRRated[hvac.SizingSpeed]
-      hvac_sizing_values.Cool_Airflow = calc_airflow_rate_user(hvac_sizing_values.Cool_Capacity, hvac.RatedCFMperTonCooling[-1], hvac.CapacityRatioCooling[-1])
+      hvac_sizing_values.Cool_Capacity = (hvac_sizing_values.Cool_Load_Tot / total_cap_curve_value)
+      hvac_sizing_values.Cool_Capacity_Sens = hvac_sizing_values.Cool_Capacity * hvac_cooling_shr
+      hvac_sizing_values.Cool_Airflow = calc_airflow_rate_user(hvac_sizing_values.Cool_Capacity, hvac_cooling_ap.cool_rated_cfm_per_ton[-1], hvac_cooling_ap.cool_capacity_ratios[-1])
 
     elsif [HPXML::HVACTypeRoomAirConditioner,
            HPXML::HVACTypePTAC,
            HPXML::HVACTypeHeatPumpPTHP,
-           HPXML::HVACTypeHeatPumpRoom].include? hvac.CoolType
+           HPXML::HVACTypeHeatPumpRoom].include? @cooling_type
 
-      enteringTemp = weather.design.CoolingDrybulb
-      totalCap_CurveValue = MathTools.biquadratic(@wetbulb_indoor_cooling, enteringTemp, hvac.COOL_CAP_FT_SPEC[hvac.SizingSpeed])
+      entering_temp = @hpxml.header.manualj_cooling_design_temp
+      hvac_cooling_speed = get_sizing_speed(hvac_cooling_ap)
+      total_cap_curve_value = MathTools.biquadratic(@wetbulb_indoor_cooling, entering_temp, hvac_cooling_ap.cool_cap_ft_spec[hvac_cooling_speed])
+      hvac_cooling_shr = hvac_cooling_ap.cool_rated_shrs_gross[hvac_cooling_speed]
 
-      hvac_sizing_values.Cool_Capacity = hvac_sizing_values.Cool_Load_Tot / totalCap_CurveValue
-      hvac_sizing_values.Cool_Capacity_Sens = hvac_sizing_values.Cool_Capacity * hvac.SHRRated[hvac.SizingSpeed]
-      hvac_sizing_values.Cool_Airflow = calc_airflow_rate_user(hvac_sizing_values.Cool_Capacity, hvac.RatedCFMperTonCooling[hvac.SizingSpeed], 1.0)
+      hvac_sizing_values.Cool_Capacity = hvac_sizing_values.Cool_Load_Tot / total_cap_curve_value
+      hvac_sizing_values.Cool_Capacity_Sens = hvac_sizing_values.Cool_Capacity * hvac_cooling_shr
+      hvac_sizing_values.Cool_Airflow = calc_airflow_rate_user(hvac_sizing_values.Cool_Capacity, hvac_cooling_ap.cool_rated_cfm_per_ton[hvac_cooling_speed], 1.0)
 
-    elsif hvac.CoolType == HPXML::HVACTypeHeatPumpGroundToAir
+    elsif HPXML::HVACTypeHeatPumpGroundToAir == @cooling_type
       coil_bf = gshp_coil_bf
-      enteringTemp = hvac.GSHP_design_chw
+      entering_temp = hvac_cooling_ap.design_chw
+      hvac_cooling_speed = get_sizing_speed(hvac_cooling_ap)
 
       # Neglecting the water flow rate for now because it's not available yet. Air flow rate is pre-adjusted values.
       design_wb_temp = UnitConversions.convert(@wetbulb_indoor_cooling, 'f', 'k')
       design_db_temp = UnitConversions.convert(@cool_setpoint, 'f', 'k')
-      design_w_temp = UnitConversions.convert(enteringTemp, 'f', 'k')
+      design_w_temp = UnitConversions.convert(entering_temp, 'f', 'k')
       design_vfr_air = UnitConversions.convert(hvac_sizing_values.Cool_Airflow, 'cfm', 'm^3/s')
 
-      totalCap_CurveValue, sensibleCap_CurveValue = calc_gshp_clg_curve_value(hvac, design_wb_temp, design_db_temp, design_w_temp, design_vfr_air, nil)
+      cool_cap_curve_spec = hvac_cooling_ap.cool_cap_curve_spec[hvac_cooling_speed]
+      cool_sh_curve_spec = hvac_cooling_ap.cool_sh_curve_spec[hvac_cooling_speed]
+      total_cap_curve_value, sensible_cap_curve_value = calc_gshp_clg_curve_value(cool_cap_curve_spec, cool_sh_curve_spec, design_wb_temp, design_db_temp, design_w_temp, design_vfr_air, nil)
 
-      bypassFactor_CurveValue = MathTools.biquadratic(@wetbulb_indoor_cooling, @cool_setpoint, gshp_coil_bf_ft_spec)
+      bypass_factor_curve_value = MathTools.biquadratic(@wetbulb_indoor_cooling, @cool_setpoint, gshp_coil_bf_ft_spec)
+      hvac_cooling_shr = hvac_cooling_ap.cool_rated_shrs_gross[hvac_cooling_speed]
 
-      hvac_sizing_values.Cool_Capacity = hvac_sizing_values.Cool_Load_Tot / totalCap_CurveValue # Note: cool_Capacity_Design = hvac_sizing_values.Cool_Load_Tot
-      hvac_sizing_values.Cool_Capacity_Sens = hvac_sizing_values.Cool_Capacity * hvac.SHRRated[hvac.SizingSpeed]
+      hvac_sizing_values.Cool_Capacity = hvac_sizing_values.Cool_Load_Tot / total_cap_curve_value # Note: cool_cap_design = hvac_sizing_values.Cool_Load_Tot
+      hvac_sizing_values.Cool_Capacity_Sens = hvac_sizing_values.Cool_Capacity * hvac_cooling_shr
 
-      cool_Load_SensCap_Design = (hvac_sizing_values.Cool_Capacity_Sens * sensibleCap_CurveValue /
-                                 (1.0 + (1.0 - coil_bf * bypassFactor_CurveValue) *
-                                 (80.0 - @cool_setpoint) / (@cool_setpoint - hvac.LeavingAirTemp)))
-      cool_Load_LatCap_Design = hvac_sizing_values.Cool_Load_Tot - cool_Load_SensCap_Design
+      cool_load_sens_cap_design = (hvac_sizing_values.Cool_Capacity_Sens * sensible_cap_curve_value /
+                                 (1.0 + (1.0 - coil_bf * bypass_factor_curve_value) *
+                                 (80.0 - @cool_setpoint) / (@cool_setpoint - @leaving_air_temp)))
+      cool_load_lat_cap_design = hvac_sizing_values.Cool_Load_Tot - cool_load_sens_cap_design
 
-      # Adjust Sizing so that coil sensible at design >= CoolingLoad_MJ8_Sens, and coil latent at design >= CoolingLoad_MJ8_Lat, and equipment SHRRated is maintained.
-      cool_Load_SensCap_Design = [cool_Load_SensCap_Design, hvac_sizing_values.Cool_Load_Sens].max
-      cool_Load_LatCap_Design = [cool_Load_LatCap_Design, hvac_sizing_values.Cool_Load_Lat].max
-      cool_Capacity_Design = cool_Load_SensCap_Design + cool_Load_LatCap_Design
+      # Adjust Sizing so that coil sensible at design >= CoolingLoad_Sens, and coil latent at design >= CoolingLoad_Lat, and equipment SHRRated is maintained.
+      cool_load_sens_cap_design = [cool_load_sens_cap_design, hvac_sizing_values.Cool_Load_Sens].max
+      cool_load_lat_cap_design = [cool_load_lat_cap_design, hvac_sizing_values.Cool_Load_Lat].max
+      cool_cap_design = cool_load_sens_cap_design + cool_load_lat_cap_design
 
       # Limit total capacity via oversizing limit
-      cool_Capacity_Design = [cool_Capacity_Design, hvac.OverSizeLimit * hvac_sizing_values.Cool_Load_Tot].min
-      hvac_sizing_values.Cool_Capacity = cool_Capacity_Design / totalCap_CurveValue
-      hvac_sizing_values.Cool_Capacity_Sens = hvac_sizing_values.Cool_Capacity * hvac.SHRRated[hvac.SizingSpeed]
+      cool_cap_design = [cool_cap_design, @oversize_limit * hvac_sizing_values.Cool_Load_Tot].min
+      hvac_sizing_values.Cool_Capacity = cool_cap_design / total_cap_curve_value
+      hvac_sizing_values.Cool_Capacity_Sens = hvac_sizing_values.Cool_Capacity * hvac_cooling_shr
 
       # Recalculate the air flow rate in case the oversizing limit has been used
-      cool_Load_SensCap_Design = (hvac_sizing_values.Cool_Capacity_Sens * sensibleCap_CurveValue /
-                                 (1.0 + (1.0 - coil_bf * bypassFactor_CurveValue) *
-                                 (80.0 - @cool_setpoint) / (@cool_setpoint - hvac.LeavingAirTemp)))
-      hvac_sizing_values.Cool_Airflow = calc_airflow_rate_manual_s(cool_Load_SensCap_Design, (@cool_setpoint - hvac.LeavingAirTemp))
+      cool_load_sens_cap_design = (hvac_sizing_values.Cool_Capacity_Sens * sensible_cap_curve_value /
+                                 (1.0 + (1.0 - coil_bf * bypass_factor_curve_value) *
+                                 (80.0 - @cool_setpoint) / (@cool_setpoint - @leaving_air_temp)))
+      hvac_sizing_values.Cool_Airflow = calc_airflow_rate_manual_s(cool_load_sens_cap_design, (@cool_setpoint - @leaving_air_temp))
 
-    elsif hvac.CoolType == HPXML::HVACTypeEvaporativeCooler
+    elsif HPXML::HVACTypeEvaporativeCooler == @cooling_type
 
       hvac_sizing_values.Cool_Capacity = hvac_sizing_values.Cool_Load_Tot
       hvac_sizing_values.Cool_Capacity_Sens = hvac_sizing_values.Cool_Load_Sens
-      if @cool_setpoint - hvac.LeavingAirTemp > 0
-        hvac_sizing_values.Cool_Airflow = calc_airflow_rate_manual_s(hvac_sizing_values.Cool_Load_Sens, (@cool_setpoint - hvac.LeavingAirTemp))
+      if @cool_setpoint - @leaving_air_temp > 0
+        hvac_sizing_values.Cool_Airflow = calc_airflow_rate_manual_s(hvac_sizing_values.Cool_Load_Sens, (@cool_setpoint - @leaving_air_temp))
       else
         hvac_sizing_values.Cool_Airflow = @cfa * 2.0 # Use industry rule of thumb sizing method adopted by HEScore
       end
 
-    elsif hvac.CoolType == HPXML::HVACTypeHeatPumpWaterLoopToAir
+    elsif HPXML::HVACTypeHeatPumpWaterLoopToAir == @cooling_type
 
       # Model only currently used for heating
       hvac_sizing_values.Cool_Capacity = 0.0
       hvac_sizing_values.Cool_Capacity_Sens = 0.0
       hvac_sizing_values.Cool_Airflow = 0.0
 
-    elsif hvac.CoolType.nil?
+    elsif @cooling_type.nil?
 
       hvac_sizing_values.Cool_Capacity = 0.0
       hvac_sizing_values.Cool_Capacity_Sens = 0.0
@@ -1551,11 +1544,16 @@ class HVACSizing
 
     else
 
-      fail "Unexpected cooling type: #{hvac.CoolType}."
+      fail "Unexpected cooling type: #{@cooling_type}."
 
     end
 
     # Heating
+
+    if not hvac_heating.nil?
+      hvac_heating_ap = hvac_heating.additional_properties
+    end
+
     if hvac_sizing_values.Heat_Load <= 0
 
       hvac_sizing_values.Heat_Capacity = 0.0
@@ -1566,17 +1564,17 @@ class HVACSizing
     elsif [HPXML::HVACTypeHeatPumpAirToAir,
            HPXML::HVACTypeHeatPumpMiniSplit,
            HPXML::HVACTypeHeatPumpPTHP,
-           HPXML::HVACTypeHeatPumpRoom].include? hvac.HeatType
-      process_heat_pump_adjustment(hvac_sizing_values, weather, hvac, totalCap_CurveValue)
+           HPXML::HVACTypeHeatPumpRoom].include? @heating_type
+      process_heat_pump_adjustment(hvac_sizing_values, weather, hvac_heating, total_cap_curve_value, hvac_system)
       hvac_sizing_values.Heat_Capacity_Supp = hvac_sizing_values.Heat_Load_Supp
-      if hvac.HeatType == HPXML::HVACTypeHeatPumpAirToAir
-        hvac_sizing_values.Heat_Airflow = calc_airflow_rate_manual_s(hvac_sizing_values.Heat_Capacity, (hvac.SupplyAirTemp - @heat_setpoint))
+      if @heating_type == HPXML::HVACTypeHeatPumpAirToAir
+        hvac_sizing_values.Heat_Airflow = calc_airflow_rate_manual_s(hvac_sizing_values.Heat_Capacity, (@supply_air_temp - @heat_setpoint))
       else
-        hvac_sizing_values.Heat_Airflow = calc_airflow_rate_user(hvac_sizing_values.Heat_Capacity, hvac.RatedCFMperTonHeating[-1], hvac.CapacityRatioHeating[-1])
+        hvac_sizing_values.Heat_Airflow = calc_airflow_rate_user(hvac_sizing_values.Heat_Capacity, hvac_heating_ap.heat_rated_cfm_per_ton[-1], hvac_heating_ap.heat_capacity_ratios[-1])
       end
-      hvac_sizing_values.Heat_Airflow_Supp = calc_airflow_rate_manual_s(hvac_sizing_values.Heat_Capacity_Supp, (hvac.BackupSupplyAirTemp - @heat_setpoint))
+      hvac_sizing_values.Heat_Airflow_Supp = calc_airflow_rate_manual_s(hvac_sizing_values.Heat_Capacity_Supp, (@backup_supply_air_temp - @heat_setpoint))
 
-    elsif [HPXML::HVACTypeHeatPumpGroundToAir].include? hvac.HeatType
+    elsif [HPXML::HVACTypeHeatPumpGroundToAir].include? @heating_type
 
       if hvac_sizing_values.Cool_Capacity > 0
         hvac_sizing_values.Heat_Capacity = hvac_sizing_values.Heat_Load
@@ -1591,32 +1589,32 @@ class HVACSizing
         hvac_sizing_values.Cool_Capacity = [hvac_sizing_values.Cool_Capacity, hvac_sizing_values.Heat_Capacity].max
         hvac_sizing_values.Heat_Capacity = hvac_sizing_values.Cool_Capacity
 
-        hvac_sizing_values.Cool_Capacity_Sens = hvac_sizing_values.Cool_Capacity * hvac.SHRRated[hvac.SizingSpeed]
-        cool_Load_SensCap_Design = (hvac_sizing_values.Cool_Capacity_Sens * sensibleCap_CurveValue /
-                                   (1.0 + (1.0 - gshp_coil_bf * bypassFactor_CurveValue) *
-                                   (80.0 - @cool_setpoint) / (@cool_setpoint - hvac.LeavingAirTemp)))
-        hvac_sizing_values.Cool_Airflow = calc_airflow_rate_manual_s(cool_Load_SensCap_Design, (@cool_setpoint - hvac.LeavingAirTemp))
+        hvac_sizing_values.Cool_Capacity_Sens = hvac_sizing_values.Cool_Capacity * hvac_cooling_shr
+        cool_load_sens_cap_design = (hvac_sizing_values.Cool_Capacity_Sens * sensible_cap_curve_value /
+                                   (1.0 + (1.0 - gshp_coil_bf * bypass_factor_curve_value) *
+                                   (80.0 - @cool_setpoint) / (@cool_setpoint - @leaving_air_temp)))
+        hvac_sizing_values.Cool_Airflow = calc_airflow_rate_manual_s(cool_load_sens_cap_design, (@cool_setpoint - @leaving_air_temp))
       else
         hvac_sizing_values.Heat_Capacity = hvac_sizing_values.Heat_Load
         hvac_sizing_values.Heat_Capacity_Supp = hvac_sizing_values.Heat_Load_Supp
       end
-      hvac_sizing_values.Heat_Airflow = calc_airflow_rate_manual_s(hvac_sizing_values.Heat_Capacity, (hvac.SupplyAirTemp - @heat_setpoint))
-      hvac_sizing_values.Heat_Airflow_Supp = calc_airflow_rate_manual_s(hvac_sizing_values.Heat_Capacity_Supp, (hvac.BackupSupplyAirTemp - @heat_setpoint))
+      hvac_sizing_values.Heat_Airflow = calc_airflow_rate_manual_s(hvac_sizing_values.Heat_Capacity, (@supply_air_temp - @heat_setpoint))
+      hvac_sizing_values.Heat_Airflow_Supp = calc_airflow_rate_manual_s(hvac_sizing_values.Heat_Capacity_Supp, (@backup_supply_air_temp - @heat_setpoint))
 
-    elsif [HPXML::HVACTypeHeatPumpWaterLoopToAir].include? hvac.HeatType
+    elsif [HPXML::HVACTypeHeatPumpWaterLoopToAir].include? @heating_type
 
       hvac_sizing_values.Heat_Capacity = hvac_sizing_values.Heat_Load
       hvac_sizing_values.Heat_Capacity_Supp = hvac_sizing_values.Heat_Load_Supp
 
-      hvac_sizing_values.Heat_Airflow = calc_airflow_rate_manual_s(hvac_sizing_values.Heat_Capacity, (hvac.SupplyAirTemp - @heat_setpoint))
-      hvac_sizing_values.Heat_Airflow_Supp = calc_airflow_rate_manual_s(hvac_sizing_values.Heat_Capacity_Supp, (hvac.BackupSupplyAirTemp - @heat_setpoint))
+      hvac_sizing_values.Heat_Airflow = calc_airflow_rate_manual_s(hvac_sizing_values.Heat_Capacity, (@supply_air_temp - @heat_setpoint))
+      hvac_sizing_values.Heat_Airflow_Supp = calc_airflow_rate_manual_s(hvac_sizing_values.Heat_Capacity_Supp, (@backup_supply_air_temp - @heat_setpoint))
 
-    elsif (hvac.HeatType == HPXML::HVACTypeFurnace) || hvac.HasIntegratedHeating
+    elsif (@heating_type == HPXML::HVACTypeFurnace) || ((not hvac_cooling.nil?) && hvac_cooling.has_integrated_heating)
 
       hvac_sizing_values.Heat_Capacity = hvac_sizing_values.Heat_Load
       hvac_sizing_values.Heat_Capacity_Supp = 0.0
 
-      hvac_sizing_values.Heat_Airflow = calc_airflow_rate_manual_s(hvac_sizing_values.Heat_Capacity, (hvac.SupplyAirTemp - @heat_setpoint))
+      hvac_sizing_values.Heat_Airflow = calc_airflow_rate_manual_s(hvac_sizing_values.Heat_Capacity, (@supply_air_temp - @heat_setpoint))
       hvac_sizing_values.Heat_Airflow_Supp = 0.0
 
     elsif [HPXML::HVACTypeStove,
@@ -1624,29 +1622,29 @@ class HVACSizing
            HPXML::HVACTypeFixedHeater,
            HPXML::HVACTypeWallFurnace,
            HPXML::HVACTypeFloorFurnace,
-           HPXML::HVACTypeFireplace].include? hvac.HeatType
+           HPXML::HVACTypeFireplace].include? @heating_type
 
       hvac_sizing_values.Heat_Capacity = hvac_sizing_values.Heat_Load
       hvac_sizing_values.Heat_Capacity_Supp = 0.0
 
-      if hvac.RatedCFMperTonHeating[0] > 0
+      if hvac_heating_ap.heat_rated_cfm_per_ton[0] > 0
         # Fixed airflow rate
-        hvac_sizing_values.Heat_Airflow = UnitConversions.convert(hvac_sizing_values.Heat_Capacity, 'Btu/hr', 'ton') * hvac.RatedCFMperTonHeating[0]
+        hvac_sizing_values.Heat_Airflow = UnitConversions.convert(hvac_sizing_values.Heat_Capacity, 'Btu/hr', 'ton') * hvac_heating_ap.heat_rated_cfm_per_ton[0]
       else
         # Autosized airflow rate
-        hvac_sizing_values.Heat_Airflow = calc_airflow_rate_manual_s(hvac_sizing_values.Heat_Capacity, (hvac.SupplyAirTemp - @heat_setpoint))
+        hvac_sizing_values.Heat_Airflow = calc_airflow_rate_manual_s(hvac_sizing_values.Heat_Capacity, (@supply_air_temp - @heat_setpoint))
       end
       hvac_sizing_values.Heat_Airflow_Supp = 0.0
 
     elsif [HPXML::HVACTypeBoiler,
-           HPXML::HVACTypeElectricResistance].include? hvac.HeatType
+           HPXML::HVACTypeElectricResistance].include? @heating_type
 
       hvac_sizing_values.Heat_Capacity = hvac_sizing_values.Heat_Load
       hvac_sizing_values.Heat_Capacity_Supp = 0.0
       hvac_sizing_values.Heat_Airflow = 0.0
       hvac_sizing_values.Heat_Airflow_Supp = 0.0
 
-    elsif hvac.HeatType.nil?
+    elsif @heating_type.nil?
 
       hvac_sizing_values.Heat_Capacity = 0.0
       hvac_sizing_values.Heat_Capacity_Supp = 0.0
@@ -1655,51 +1653,64 @@ class HVACSizing
 
     else
 
-      fail "Unexpected heating type: #{hvac.HeatType}."
+      fail "Unexpected heating type: #{@heating_type}."
 
     end
   end
 
-  def self.apply_hvac_installation_quality(hvac_sizing_values, weather, hvac)
+  def self.apply_hvac_installation_quality(hvac_sizing_values, hvac_heating, hvac_cooling)
     # Increases the autosized heating/cooling capacities to account for any reduction
     # in capacity due to HVAC installation quality. This is done to prevent causing
     # unmet loads.
 
-    return unless [HPXML::HVACTypeCentralAirConditioner,
-                   HPXML::HVACTypeHeatPumpAirToAir,
-                   HPXML::HVACTypeHeatPumpMiniSplit,
-                   HPXML::HVACTypeMiniSplitAirConditioner,
-                   HPXML::HVACTypeHeatPumpGroundToAir].include? hvac.CoolType
-    return if (hvac.ChargeDefectRatio.to_f.abs < 0.001) && (hvac.AirflowDefectRatioCooling.to_f.abs < 0.001) && (hvac.AirflowDefectRatioHeating.to_f.abs < 0.001)
+    cool_charge_defect_ratio = 0.0
+    cool_airflow_defect_ratio = 0.0
+    heat_airflow_defect_ratio = 0.0
 
-    tin_cool = UnitConversions.convert(@cool_setpoint, 'F', 'C')
-    tout_cool = UnitConversions.convert(weather.design.CoolingDrybulb, 'F', 'C')
-    tout_heat = UnitConversions.convert(weather.design.HeatingDrybulb, 'F', 'C')
+    if not hvac_cooling.nil?
+      if hvac_cooling.respond_to? :charge_defect_ratio
+        cool_charge_defect_ratio = hvac_cooling.charge_defect_ratio.to_f
+      end
+      if hvac_cooling.respond_to? :airflow_defect_ratio
+        cool_airflow_defect_ratio = hvac_cooling.airflow_defect_ratio.to_f
+      end
+    end
+    if (not hvac_heating.nil?)
+      if hvac_heating.respond_to? :airflow_defect_ratio
+        heat_airflow_defect_ratio = hvac_heating.airflow_defect_ratio.to_f
+      end
+    end
 
-    f_ch = hvac.ChargeDefectRatio.round(3)
+    return if (cool_charge_defect_ratio.abs < 0.001) && (cool_airflow_defect_ratio.abs < 0.001) && (heat_airflow_defect_ratio.abs < 0.001)
 
     # Cooling
+
+    f_ch = cool_charge_defect_ratio.round(3)
+
     if [HPXML::HVACTypeHeatPumpAirToAir,
         HPXML::HVACTypeCentralAirConditioner,
         HPXML::HVACTypeHeatPumpMiniSplit,
         HPXML::HVACTypeMiniSplitAirConditioner,
-        HPXML::HVACTypeHeatPumpGroundToAir].include?(hvac.CoolType) && hvac.CoolingLoadFraction > 0
+        HPXML::HVACTypeHeatPumpGroundToAir].include?(@cooling_type) && @fraction_cool_load_served > 0
+
+      hvac_cooling_ap = hvac_cooling.additional_properties
 
       cool_airflow_rated_defect_ratio = []
       cool_airflow_rated_ratio = []
-      cool_cfm_m3s = UnitConversions.convert(hvac_sizing_values.Cool_Airflow, 'cfm', 'm^3/s')
-      if hvac.CoolType != HPXML::HVACTypeHeatPumpGroundToAir
-        for speed in 0..(hvac.NumSpeedsCooling - 1)
-          cool_airflow_rated_ratio << cool_cfm_m3s / HVAC.calc_rated_airflow(hvac_sizing_values.Cool_Capacity, hvac.RatedCFMperTonCooling[speed], hvac.CapacityRatioCooling[speed])
-          cool_airflow_rated_defect_ratio << cool_cfm_m3s * (1 + hvac.AirflowDefectRatioCooling) / HVAC.calc_rated_airflow(hvac_sizing_values.Cool_Capacity, hvac.RatedCFMperTonCooling[speed], hvac.CapacityRatioCooling[speed])
+      if @cooling_type != HPXML::HVACTypeHeatPumpGroundToAir
+        cool_cfm_m3s = UnitConversions.convert(hvac_sizing_values.Cool_Airflow, 'cfm', 'm^3/s')
+        for speed in 0..(hvac_cooling_ap.cool_rated_cfm_per_ton.size - 1)
+          cool_airflow_rated_ratio << cool_cfm_m3s / HVAC.calc_rated_airflow(hvac_sizing_values.Cool_Capacity, hvac_cooling_ap.cool_rated_cfm_per_ton[speed], hvac_cooling_ap.cool_capacity_ratios[speed])
+          cool_airflow_rated_defect_ratio << cool_cfm_m3s * (1 + cool_airflow_defect_ratio) / HVAC.calc_rated_airflow(hvac_sizing_values.Cool_Capacity, hvac_cooling_ap.cool_rated_cfm_per_ton[speed], hvac_cooling_ap.cool_capacity_ratios[speed])
         end
       else
         cool_airflow_rated_ratio = [1.0] # actual air flow is equal to rated (before applying defect ratio) in current methodology
-        cool_airflow_rated_defect_ratio = [1 + hvac.AirflowDefectRatioCooling]
+        cool_airflow_rated_defect_ratio = [1 + cool_airflow_defect_ratio]
       end
+
       if not cool_airflow_rated_defect_ratio.empty?
         cap_clg_ratios = []
-        for speed in 0..(hvac.NumSpeedsCooling - 1)
+        for speed in 0..(cool_airflow_rated_defect_ratio.size - 1)
           # NOTE: heat pump (cooling) curves don't exhibit expected trends at extreme faults;
           clg_fff_cap_coeff, _clg_fff_eir_coeff = HVAC.get_airflow_fault_cooling_coeff()
           a1_AF_Qgr_c = clg_fff_cap_coeff[0]
@@ -1714,8 +1725,8 @@ class HVACSizing
           a4_CH_Qgr_c = qgr_values[3]
 
           q0_CH = a1_CH_Qgr_c
-          q1_CH = a2_CH_Qgr_c * tin_cool
-          q2_CH = a3_CH_Qgr_c * tout_cool
+          q1_CH = a2_CH_Qgr_c * UnitConversions.convert(@cool_setpoint, 'F', 'C')
+          q2_CH = a3_CH_Qgr_c * UnitConversions.convert(@hpxml.header.manualj_cooling_design_temp, 'F', 'C')
           q3_CH = a4_CH_Qgr_c * f_ch
           y_CH_Q_c = 1 + ((q0_CH + q1_CH + q2_CH + q3_CH) * f_ch)
 
@@ -1739,7 +1750,7 @@ class HVACSizing
 
         prev_capacity = hvac_sizing_values.Cool_Capacity
         hvac_sizing_values.Cool_Capacity *= cap_clg_ratios.max
-        hvac_sizing_values.Cool_Capacity_Sens = hvac_sizing_values.Cool_Capacity * hvac.SHRRated[hvac.SizingSpeed]
+        hvac_sizing_values.Cool_Capacity_Sens = hvac_sizing_values.Cool_Capacity * hvac_cooling_ap.cool_rated_shrs_gross[get_sizing_speed(hvac_cooling_ap)]
         if prev_capacity > 0 # Preserve cfm/ton
           hvac_sizing_values.Cool_Airflow = hvac_sizing_values.Cool_Airflow * hvac_sizing_values.Cool_Capacity / prev_capacity
         else
@@ -1749,24 +1760,29 @@ class HVACSizing
     end
 
     # Heating
+
     if [HPXML::HVACTypeHeatPumpAirToAir,
         HPXML::HVACTypeHeatPumpMiniSplit,
-        HPXML::HVACTypeHeatPumpGroundToAir].include?(hvac.HeatType) && hvac.HeatingLoadFraction > 0
+        HPXML::HVACTypeHeatPumpGroundToAir].include?(@heating_type) && @fraction_heat_load_served > 0
+
+      hvac_heating_ap = hvac_heating.additional_properties
+
       heat_airflow_rated_defect_ratio = []
       heat_airflow_rated_ratio = []
-      heat_cfm_m3s = UnitConversions.convert(hvac_sizing_values.Heat_Airflow, 'cfm', 'm^3/s')
-      if hvac.HeatType != HPXML::HVACTypeHeatPumpGroundToAir
-        for speed in 0..(hvac.NumSpeedsHeating - 1)
-          heat_airflow_rated_ratio << heat_cfm_m3s / HVAC.calc_rated_airflow(hvac_sizing_values.Heat_Capacity, hvac.RatedCFMperTonHeating[speed], hvac.CapacityRatioHeating[speed])
-          heat_airflow_rated_defect_ratio << heat_cfm_m3s * (1 + hvac.AirflowDefectRatioHeating) / HVAC.calc_rated_airflow(hvac_sizing_values.Heat_Capacity, hvac.RatedCFMperTonHeating[speed], hvac.CapacityRatioHeating[speed])
+      if @heating_type != HPXML::HVACTypeHeatPumpGroundToAir
+        heat_cfm_m3s = UnitConversions.convert(hvac_sizing_values.Heat_Airflow, 'cfm', 'm^3/s')
+        for speed in 0..(hvac_heating_ap.heat_rated_cfm_per_ton.size - 1)
+          heat_airflow_rated_ratio << heat_cfm_m3s / HVAC.calc_rated_airflow(hvac_sizing_values.Heat_Capacity, hvac_heating_ap.heat_rated_cfm_per_ton[speed], hvac_heating_ap.heat_capacity_ratios[speed])
+          heat_airflow_rated_defect_ratio << heat_cfm_m3s * (1 + heat_airflow_defect_ratio) / HVAC.calc_rated_airflow(hvac_sizing_values.Heat_Capacity, hvac_heating_ap.heat_rated_cfm_per_ton[speed], hvac_heating_ap.heat_capacity_ratios[speed])
         end
       else
         heat_airflow_rated_ratio = [1.0] # actual air flow is equal to rated (before applying defect ratio) in current methodology
-        heat_airflow_rated_defect_ratio = [1 + hvac.AirflowDefectRatioHeating]
+        heat_airflow_rated_defect_ratio = [1 + heat_airflow_defect_ratio]
       end
+
       if not heat_airflow_rated_defect_ratio.empty?
         cap_htg_ratios = []
-        for speed in 0..(hvac.NumSpeedsHeating - 1)
+        for speed in 0..(heat_airflow_rated_defect_ratio.size - 1)
           htg_fff_cap_coeff, _htg_fff_eir_coeff = HVAC.get_airflow_fault_heating_coeff()
           a1_AF_Qgr_h = htg_fff_cap_coeff[0]
           a2_AF_Qgr_h = htg_fff_cap_coeff[1]
@@ -1779,7 +1795,7 @@ class HVACSizing
           a3_CH_Qgr_h = qgr_values[3]
 
           qh1_CH = a1_CH_Qgr_h
-          qh2_CH = a2_CH_Qgr_h * tout_heat
+          qh2_CH = a2_CH_Qgr_h * UnitConversions.convert(@hpxml.header.manualj_heating_design_temp, 'F', 'C')
           qh3_CH = a3_CH_Qgr_h * f_ch
           y_CH_Q_h = 1 + ((qh1_CH + qh2_CH + qh3_CH) * f_ch)
 
@@ -1800,6 +1816,7 @@ class HVACSizing
           cap_htg_ratio = 1 / (heat_cap_fff / heat_cap_fff_nodefect)
           cap_htg_ratios << cap_htg_ratio
         end
+
         prev_capacity = hvac_sizing_values.Heat_Capacity
         hvac_sizing_values.Heat_Capacity *= cap_htg_ratios.max
         if prev_capacity > 0 # Preserve cfm/ton
@@ -1811,32 +1828,47 @@ class HVACSizing
     end
   end
 
-  def self.apply_hvac_fixed_capacities(hvac_sizing_values, hvac)
+  def self.apply_hvac_fixed_capacities(hvac_sizing_values, hvac_heating, hvac_cooling)
     '''
     Fixed Sizing Equipment
     '''
 
     # Override HVAC capacities if values are provided
-    if (not hvac.FixedCoolingCapacity.nil?) && (hvac_sizing_values.Cool_Capacity > 0)
+    if not hvac_cooling.nil?
+      fixed_cooling_capacity = hvac_cooling.cooling_capacity
+    end
+    if (not fixed_cooling_capacity.nil?) && (hvac_sizing_values.Cool_Capacity > 0)
       prev_capacity = hvac_sizing_values.Cool_Capacity
-      hvac_sizing_values.Cool_Capacity = hvac.FixedCoolingCapacity
+      hvac_sizing_values.Cool_Capacity = fixed_cooling_capacity
       if @hpxml.header.allow_increased_fixed_capacities
         hvac_sizing_values.Cool_Capacity = [hvac_sizing_values.Cool_Capacity, prev_capacity].max
       end
       hvac_sizing_values.Cool_Capacity_Sens = hvac_sizing_values.Cool_Capacity_Sens * hvac_sizing_values.Cool_Capacity / prev_capacity
       hvac_sizing_values.Cool_Airflow = hvac_sizing_values.Cool_Airflow * hvac_sizing_values.Cool_Capacity / prev_capacity
     end
-    if (not hvac.FixedHeatingCapacity.nil?) && (hvac_sizing_values.Heat_Capacity > 0)
+    if not hvac_heating.nil?
+      fixed_heating_capacity = hvac_heating.heating_capacity
+    elsif (not hvac_cooling.nil?) && hvac_cooling.has_integrated_heating
+      fixed_heating_capacity = hvac_cooling.integrated_heating_system_capacity
+    end
+    if (not fixed_heating_capacity.nil?) && (hvac_sizing_values.Heat_Capacity > 0)
       prev_capacity = hvac_sizing_values.Heat_Capacity
-      hvac_sizing_values.Heat_Capacity = hvac.FixedHeatingCapacity
+      hvac_sizing_values.Heat_Capacity = fixed_heating_capacity
       if @hpxml.header.allow_increased_fixed_capacities
         hvac_sizing_values.Heat_Capacity = [hvac_sizing_values.Heat_Capacity, prev_capacity].max
       end
       hvac_sizing_values.Heat_Airflow = hvac_sizing_values.Heat_Airflow * hvac_sizing_values.Heat_Capacity / prev_capacity
     end
-    if (not hvac.FixedSuppHeatingCapacity.nil?) && (hvac_sizing_values.Heat_Capacity_Supp > 0)
+    if hvac_heating.is_a? HPXML::HeatPump
+      if not hvac_heating.backup_heating_capacity.nil?
+        fixed_supp_heating_capacity = hvac_heating.backup_heating_capacity
+      elsif not hvac_heating.backup_system.nil?
+        fixed_supp_heating_capacity = hvac_heating.backup_system.heating_capacity
+      end
+    end
+    if (not fixed_supp_heating_capacity.nil?) && (hvac_sizing_values.Heat_Capacity_Supp > 0)
       prev_capacity = hvac_sizing_values.Heat_Capacity_Supp
-      hvac_sizing_values.Heat_Capacity_Supp = hvac.FixedSuppHeatingCapacity
+      hvac_sizing_values.Heat_Capacity_Supp = fixed_supp_heating_capacity
       if @hpxml.header.allow_increased_fixed_capacities
         hvac_sizing_values.Heat_Capacity_Supp = [hvac_sizing_values.Heat_Capacity_Supp, prev_capacity].max
       end
@@ -1844,16 +1876,18 @@ class HVACSizing
     end
   end
 
-  def self.apply_hvac_ground_loop(hvac_sizing_values, weather, hvac)
+  def self.apply_hvac_ground_loop(hvac_sizing_values, weather, hvac_cooling)
     '''
     GSHP Ground Loop Sizing Calculations
     '''
-    return unless hvac.CoolType == HPXML::HVACTypeHeatPumpGroundToAir
+    return if @cooling_type != HPXML::HVACTypeHeatPumpGroundToAir
+
+    hvac_cooling_ap = hvac_cooling.additional_properties
 
     # Autosize ground loop heat exchanger length
     bore_spacing = 20.0 # ft, distance between bores
-    pipe_r_value = gshp_hx_pipe_rvalue(hvac)
-    nom_length_heat, nom_length_cool = gshp_hxbore_ft_per_ton(weather, hvac, bore_spacing, pipe_r_value)
+    pipe_r_value = gshp_hx_pipe_rvalue(hvac_cooling_ap)
+    nom_length_heat, nom_length_cool = gshp_hxbore_ft_per_ton(weather, hvac_cooling_ap, bore_spacing, pipe_r_value)
 
     bore_length_heat = nom_length_heat * hvac_sizing_values.Heat_Capacity / UnitConversions.convert(1.0, 'ton', 'Btu/hr')
     bore_length_cool = nom_length_cool * hvac_sizing_values.Cool_Capacity / UnitConversions.convert(1.0, 'ton', 'Btu/hr')
@@ -1909,15 +1943,13 @@ class HVACSizing
       else
         # Search for first valid bore field
         new_bore_config = nil
-        valid_field_found = false
         valid_configs.keys.each do |bore_config|
           next unless valid_configs[bore_config].include? num_bore_holes
 
-          valid_field_found = true
           new_bore_config = bore_config
           break
         end
-        if valid_field_found
+        if not new_bore_config.nil?
           bore_config = new_bore_config
         else
           fail 'Could not construct a valid GSHP bore field configuration.'
@@ -1936,47 +1968,62 @@ class HVACSizing
     hvac_sizing_values.GSHP_G_Functions = [lntts, gfnc_coeff]
   end
 
-  def self.apply_hvac_finalize_airflows(hvac_sizing_values, hvac)
+  def self.apply_hvac_finalize_airflows(hvac_sizing_values, hvac_heating, hvac_cooling)
     '''
     Finalize Sizing Calculations
     '''
 
-    if hvac_sizing_values.Heat_Airflow > 0
-      hvac_sizing_values.Heat_Airflow *= (1.0 + hvac.AirflowDefectRatioHeating)
+    if (not hvac_heating.nil?) && hvac_heating.respond_to?(:airflow_defect_ratio)
+      if hvac_sizing_values.Heat_Airflow > 0
+        hvac_sizing_values.Heat_Airflow *= (1.0 + hvac_heating.airflow_defect_ratio.to_f)
+      end
     end
 
-    if hvac_sizing_values.Cool_Airflow > 0
-      hvac_sizing_values.Cool_Airflow *= (1.0 + hvac.AirflowDefectRatioCooling)
+    if (not hvac_cooling.nil?) && hvac_cooling.respond_to?(:airflow_defect_ratio)
+      if hvac_sizing_values.Cool_Airflow > 0
+        hvac_sizing_values.Cool_Airflow *= (1.0 + hvac_cooling.airflow_defect_ratio.to_f)
+      end
     end
   end
 
-  def self.process_heat_pump_adjustment(hvac_sizing_values, weather, hvac, totalCap_CurveValue)
+  def self.process_heat_pump_adjustment(hvac_sizing_values, weather, hvac_heating, total_cap_curve_value, hvac_system)
     '''
     Adjust heat pump sizing
     '''
-    if hvac.NumSpeedsHeating > 1
-      coefficients = hvac.HEAT_CAP_FT_SPEC[hvac.NumSpeedsHeating - 1]
-      capacity_ratio = hvac.CapacityRatioHeating[hvac.NumSpeedsHeating - 1]
+
+    hvac_heating_ap = hvac_heating.additional_properties
+
+    if hvac_heating_ap.heat_cap_ft_spec.size > 1
+      coefficients = hvac_heating_ap.heat_cap_ft_spec[-1]
+      capacity_ratio = hvac_heating_ap.heat_capacity_ratios[-1]
     else
-      coefficients = hvac.HEAT_CAP_FT_SPEC[0]
+      coefficients = hvac_heating_ap.heat_cap_ft_spec[0]
       capacity_ratio = 1.0
     end
 
-    if (not hvac.SwitchoverTemperature.nil?) && (hvac.SwitchoverTemperature > weather.design.HeatingDrybulb)
+    if hvac_heating.is_a? HPXML::HeatPump
+      if not hvac_heating.backup_heating_switchover_temp.nil?
+        min_compressor_temp = hvac_heating.backup_heating_switchover_temp
+      elsif not hvac_heating.compressor_lockout_temp.nil?
+        min_compressor_temp = hvac_heating.compressor_lockout_temp
+      end
+    end
+    if (not min_compressor_temp.nil?) && (min_compressor_temp > @hpxml.header.manualj_heating_design_temp)
       # Calculate the heating load at the switchover temperature to limit uninitialized capacity
-      switchover_weather = Marshal.load(Marshal.dump(weather))
-      switchover_weather.design.HeatingDrybulb = hvac.SwitchoverTemperature
-      _switchover_bldg_design_loads, switchover_all_hvac_sizing_values = calculate(switchover_weather, @hpxml, @cfa, @nbeds, [hvac.hvac_system])
-      heating_load = switchover_all_hvac_sizing_values[hvac.hvac_system].Heat_Load
-      heating_db = switchover_weather.design.HeatingDrybulb
+      temp_heat_design_temp = @hpxml.header.manualj_heating_design_temp
+      @hpxml.header.manualj_heating_design_temp = min_compressor_temp
+      _alternate_bldg_design_loads, alternate_all_hvac_sizing_values = calculate(weather, @hpxml, @cfa, [hvac_system])
+      heating_load = alternate_all_hvac_sizing_values[hvac_system].Heat_Load
+      heating_db = min_compressor_temp
+      @hpxml.header.manualj_heating_design_temp = temp_heat_design_temp
     else
       heating_load = hvac_sizing_values.Heat_Load
-      heating_db = weather.design.HeatingDrybulb
+      heating_db = @hpxml.header.manualj_heating_design_temp
     end
 
     heat_cap_rated = (heating_load / MathTools.biquadratic(@heat_setpoint, heating_db, coefficients)) / capacity_ratio
 
-    if totalCap_CurveValue.nil? # Heat pump has no cooling
+    if total_cap_curve_value.nil? # Heat pump has no cooling
       if @hpxml.header.heat_pump_sizing_methodology == HPXML::HeatPumpSizingMaxLoad
         # Size based on heating, taking into account reduced heat pump capacity at the design temperature
         hvac_sizing_values.Heat_Capacity = heat_cap_rated
@@ -1997,10 +2044,10 @@ class HVACSizing
         load_shr = hvac_sizing_values.Cool_Load_Sens / hvac_sizing_values.Cool_Load_Tot
         if ((weather.data.HDD65F / weather.data.CDD50F) < 2.0) || (load_shr < 0.95)
           # Mild winter or has a latent cooling load
-          hvac_sizing_values.Cool_Capacity = [(hvac.OverSizeLimit * hvac_sizing_values.Cool_Load_Tot) / totalCap_CurveValue, heat_cap_rated].min
+          hvac_sizing_values.Cool_Capacity = [(@oversize_limit * hvac_sizing_values.Cool_Load_Tot) / total_cap_curve_value, heat_cap_rated].min
         else
           # Cold winter and no latent cooling load (add a ton rule applies)
-          hvac_sizing_values.Cool_Capacity = [(hvac_sizing_values.Cool_Load_Tot + hvac.OverSizeDelta) / totalCap_CurveValue, heat_cap_rated].min
+          hvac_sizing_values.Cool_Capacity = [(hvac_sizing_values.Cool_Load_Tot + @oversize_delta) / total_cap_curve_value, heat_cap_rated].min
         end
       end
       hvac_sizing_values.Cool_Airflow = cfm_per_btuh * hvac_sizing_values.Cool_Capacity
@@ -2073,7 +2120,7 @@ class HVACSizing
     return rated_cfm_per_ton * capacity_ratio * UnitConversions.convert(capacity, 'Btu/hr', 'ton') # Maximum air flow under heating operation
   end
 
-  def self.calc_gshp_clg_curve_value(hvac, wb_temp, db_temp, w_temp, vfr_air, loop_flow = nil, rated_vfr_air = nil)
+  def self.calc_gshp_clg_curve_value(cool_cap_curve_spec, cool_sh_curve_spec, wb_temp, db_temp, w_temp, vfr_air, loop_flow = nil, rated_vfr_air = nil)
     # Reference conditions in thesis with largest capacity:
     # See Appendix B Figure B.3 of  https://hvac.okstate.edu/sites/default/files/pubs/theses/MS/27-Tang_Thesis_05.pdf
     ref_temp = 283 # K
@@ -2085,66 +2132,47 @@ class HVACSizing
     end
     ref_vfr_water = 0.000284
 
-    a_1 = hvac.COOL_CAP_CURVE_SPEC[hvac.SizingSpeed][0]
-    a_2 = hvac.COOL_CAP_CURVE_SPEC[hvac.SizingSpeed][1]
-    a_3 = hvac.COOL_CAP_CURVE_SPEC[hvac.SizingSpeed][2]
-    a_4 = hvac.COOL_CAP_CURVE_SPEC[hvac.SizingSpeed][3]
-    a_5 = hvac.COOL_CAP_CURVE_SPEC[hvac.SizingSpeed][4]
-    b_1 = hvac.COOL_SH_CURVE_SPEC[hvac.SizingSpeed][0]
-    b_2 = hvac.COOL_SH_CURVE_SPEC[hvac.SizingSpeed][1]
-    b_3 = hvac.COOL_SH_CURVE_SPEC[hvac.SizingSpeed][2]
-    b_4 = hvac.COOL_SH_CURVE_SPEC[hvac.SizingSpeed][3]
-    b_5 = hvac.COOL_SH_CURVE_SPEC[hvac.SizingSpeed][4]
-    b_6 = hvac.COOL_SH_CURVE_SPEC[hvac.SizingSpeed][5]
-
-    if not loop_flow.nil?
-      totalCap_CurveValue = a_1 + wb_temp / ref_temp * a_2 + w_temp / ref_temp * a_3 + vfr_air / ref_vfr_air * a_4 + loop_flow / ref_vfr_water * a_5
-      sensibleCap_CurveValue = b_1 + db_temp / ref_temp * b_2 + wb_temp / ref_temp * b_3 + w_temp / ref_temp * b_4 + vfr_air / ref_vfr_air * b_5 + loop_flow / ref_vfr_water * b_6
-    else
-      totalCap_CurveValue = a_1 + wb_temp / ref_temp * a_2 + w_temp / ref_temp * a_3 + vfr_air / ref_vfr_air * a_4
-      sensibleCap_CurveValue = b_1 + db_temp / ref_temp * b_2 + wb_temp / ref_temp * b_3 + w_temp / ref_temp * b_4 + vfr_air / ref_vfr_air * b_5
-    end
-    return totalCap_CurveValue, sensibleCap_CurveValue
-  end
+    a_1 = cool_cap_curve_spec[0]
+    a_2 = cool_cap_curve_spec[1]
+    a_3 = cool_cap_curve_spec[2]
+    a_4 = cool_cap_curve_spec[3]
+    a_5 = cool_cap_curve_spec[4]
+    b_1 = cool_sh_curve_spec[0]
+    b_2 = cool_sh_curve_spec[1]
+    b_3 = cool_sh_curve_spec[2]
+    b_4 = cool_sh_curve_spec[3]
+    b_5 = cool_sh_curve_spec[4]
+    b_6 = cool_sh_curve_spec[5]
 
-  def self.calc_gshp_htg_curve_value(hvac, db_temp, w_temp, vfr_air, loop_flow)
-    # Reference conditions in thesis with largest capacity:
-    # See Appendix B Figure B.3 of  https://hvac.okstate.edu/sites/default/files/pubs/theses/MS/27-Tang_Thesis_05.pdf
-    ref_temp = 283 # K
-    ref_vfr_air = UnitConversions.convert(1200, 'cfm', 'm^3/s')
-    ref_vfr_water = 0.000284
+    loop_flow = 0.0 if loop_flow.nil?
 
-    a_1 = hvac.HEAT_CAP_FT_SPEC[hvac.SizingSpeed][0]
-    a_2 = hvac.HEAT_CAP_FT_SPEC[hvac.SizingSpeed][1]
-    a_3 = hvac.HEAT_CAP_FT_SPEC[hvac.SizingSpeed][2]
-    a_4 = hvac.HEAT_CAP_FT_SPEC[hvac.SizingSpeed][3]
-    a_5 = hvac.HEAT_CAP_FT_SPEC[hvac.SizingSpeed][4]
+    total_cap_curve_value = a_1 + wb_temp / ref_temp * a_2 + w_temp / ref_temp * a_3 + vfr_air / ref_vfr_air * a_4 + loop_flow / ref_vfr_water * a_5
+    sensible_cap_curve_value = b_1 + db_temp / ref_temp * b_2 + wb_temp / ref_temp * b_3 + w_temp / ref_temp * b_4 + vfr_air / ref_vfr_air * b_5 + loop_flow / ref_vfr_water * b_6
 
-    cap_CurveValue = a_1 + db_temp / ref_temp * a_2 + w_temp / ref_temp * a_3 + vfr_air / ref_vfr_air * a_4 + loop_flow / ref_vfr_water * a_5
-    return cap_CurveValue
+    return total_cap_curve_value, sensible_cap_curve_value
   end
 
   def self.calc_delivery_effectiveness_heating(dse_Qs, dse_Qr, system_cfm, load_sens, dse_Tamb_s, dse_Tamb_r, dse_As, dse_Ar, t_setpoint, dse_Fregain_s, dse_Fregain_r, supply_r, return_r, air_dens = @inside_air_dens, air_cp = Gas.Air.cp)
     '''
     Calculate the Delivery Effectiveness for heating (using the method of ASHRAE Standard 152).
     '''
-    dse_Bs, dse_Br, dse_a_s, dse_a_r, dse_dTe, dse_dT_s, dse_dT_r = _calc_dse_init(system_cfm, load_sens, dse_Tamb_s, dse_Tamb_r, dse_As, dse_Ar, t_setpoint, dse_Qs, dse_Qr, supply_r, return_r, air_dens, air_cp)
-    dse_DE = _calc_dse_DE_heating(dse_a_s, dse_Bs, dse_a_r, dse_Br, dse_dT_s, dse_dT_r, dse_dTe)
-    dse_DEcorr = _calc_dse_DEcorr(dse_DE, dse_Fregain_s, dse_Fregain_r, dse_Br, dse_a_r, dse_dT_r, dse_dTe)
+    dse_Bs, dse_Br, dse_As, dse_Ar, dse_dTe, dse_dT_s, dse_dT_r = _calc_dse_init(system_cfm, load_sens, dse_Tamb_s, dse_Tamb_r, dse_As, dse_Ar, t_setpoint, dse_Qs, dse_Qr, supply_r, return_r, air_dens, air_cp)
+    dse_DE = _calc_dse_DE_heating(dse_As, dse_Bs, dse_Ar, dse_Br, dse_dT_s, dse_dT_r, dse_dTe)
+    dse_DEcorr = _calc_dse_DEcorr(dse_DE, dse_Fregain_s, dse_Fregain_r, dse_Br, dse_Ar, dse_dT_r, dse_dTe)
 
     return dse_DEcorr
   end
 
-  def self.calc_delivery_effectiveness_cooling(dse_Qs, dse_Qr, leavingAirTemp, system_cfm, load_sens, dse_Tamb_s, dse_Tamb_r, dse_As, dse_Ar, t_setpoint, dse_Fregain_s, dse_Fregain_r, load_total, dse_h_r, supply_r, return_r, air_dens = @inside_air_dens, air_cp = Gas.Air.cp, h_in = @enthalpy_indoor_cooling)
+  def self.calc_delivery_effectiveness_cooling(dse_Qs, dse_Qr, leaving_air_temp, system_cfm, load_sens, dse_Tamb_s, dse_Tamb_r, dse_As, dse_Ar, t_setpoint, dse_Fregain_s, dse_Fregain_r, load_total, dse_h_r, supply_r, return_r, air_dens = @inside_air_dens, air_cp = Gas.Air.cp, h_in = @enthalpy_indoor_cooling)
     '''
     Calculate the Delivery Effectiveness for cooling (using the method of ASHRAE Standard 152).
     '''
-    dse_Bs, dse_Br, dse_a_s, dse_a_r, dse_dTe, _dse_dT_s, dse_dT_r = _calc_dse_init(system_cfm, load_sens, dse_Tamb_s, dse_Tamb_r, dse_As, dse_Ar, t_setpoint, dse_Qs, dse_Qr, supply_r, return_r, air_dens, air_cp)
+    dse_Bs, dse_Br, dse_As, dse_Ar, dse_dTe, _dse_dT_s, dse_dT_r = _calc_dse_init(system_cfm, load_sens, dse_Tamb_s, dse_Tamb_r, dse_As, dse_Ar, t_setpoint, dse_Qs, dse_Qr, supply_r, return_r, air_dens, air_cp)
     dse_dTe *= -1.0
-    dse_DE, coolingLoad_Ducts_Sens = _calc_dse_DE_cooling(dse_a_s, system_cfm, load_total, dse_a_r, dse_h_r, dse_Br, dse_dT_r, dse_Bs, leavingAirTemp, dse_Tamb_s, load_sens, air_dens, air_cp, h_in)
-    dse_DEcorr = _calc_dse_DEcorr(dse_DE, dse_Fregain_s, dse_Fregain_r, dse_Br, dse_a_r, dse_dT_r, dse_dTe)
+    dse_DE, cooling_load_ducts_sens = _calc_dse_DE_cooling(dse_As, system_cfm, load_total, dse_Ar, dse_h_r, dse_Br, dse_dT_r, dse_Bs, leaving_air_temp, dse_Tamb_s, load_sens, air_dens, air_cp, h_in)
+    dse_DEcorr = _calc_dse_DEcorr(dse_DE, dse_Fregain_s, dse_Fregain_r, dse_Br, dse_Ar, dse_dT_r, dse_dTe)
 
-    return dse_DEcorr, dse_dTe, coolingLoad_Ducts_Sens
+    return dse_DEcorr, dse_dTe, cooling_load_ducts_sens
   end
 
   def self._calc_dse_init(system_cfm, load_sens, dse_Tamb_s, dse_Tamb_r, dse_As, dse_Ar, t_setpoint, dse_Qs, dse_Qr, supply_r, return_r, air_dens, air_cp)
@@ -2152,43 +2180,43 @@ class HVACSizing
     dse_Bs = Math.exp((-1.0 * dse_As) / (60.0 * system_cfm * air_dens * air_cp * supply_r))
     dse_Br = Math.exp((-1.0 * dse_Ar) / (60.0 * system_cfm * air_dens * air_cp * return_r))
 
-    dse_a_s = (system_cfm - dse_Qs) / system_cfm
-    dse_a_r = (system_cfm - dse_Qr) / system_cfm
+    dse_As = (system_cfm - dse_Qs) / system_cfm
+    dse_Ar = (system_cfm - dse_Qr) / system_cfm
 
     dse_dTe = load_sens / (60.0 * system_cfm * air_dens * air_cp)
     dse_dT_s = t_setpoint - dse_Tamb_s
     dse_dT_r = t_setpoint - dse_Tamb_r
 
-    return dse_Bs, dse_Br, dse_a_s, dse_a_r, dse_dTe, dse_dT_s, dse_dT_r
+    return dse_Bs, dse_Br, dse_As, dse_Ar, dse_dTe, dse_dT_s, dse_dT_r
   end
 
-  def self._calc_dse_DE_cooling(dse_a_s, system_cfm, load_total, dse_a_r, dse_h_r, dse_Br, dse_dT_r, dse_Bs, leavingAirTemp, dse_Tamb_s, load_sens, air_dens, air_cp, h_in)
+  def self._calc_dse_DE_cooling(dse_As, system_cfm, load_total, dse_Ar, dse_h_r, dse_Br, dse_dT_r, dse_Bs, leaving_air_temp, dse_Tamb_s, load_sens, air_dens, air_cp, h_in)
     # Calculate the delivery effectiveness (Equation 6-25)
-    dse_DE = ((dse_a_s * 60.0 * system_cfm * air_dens) / (-1.0 * load_total)) * \
+    dse_DE = ((dse_As * 60.0 * system_cfm * air_dens) / (-1.0 * load_total)) * \
              (((-1.0 * load_total) / (60.0 * system_cfm * air_dens)) + \
-              (1.0 - dse_a_r) * (dse_h_r - h_in) + \
-              dse_a_r * air_cp * (dse_Br - 1.0) * dse_dT_r + \
-              air_cp * (dse_Bs - 1.0) * (leavingAirTemp - dse_Tamb_s))
+              (1.0 - dse_Ar) * (dse_h_r - h_in) + \
+              dse_Ar * air_cp * (dse_Br - 1.0) * dse_dT_r + \
+              air_cp * (dse_Bs - 1.0) * (leaving_air_temp - dse_Tamb_s))
 
     # Calculate the sensible heat transfer from surroundings
-    coolingLoad_Ducts_Sens = (1.0 - [dse_DE, 0.0].max) * load_sens
+    cooling_load_ducts_sens = (1.0 - [dse_DE, 0.0].max) * load_sens
 
-    return dse_DE, coolingLoad_Ducts_Sens
+    return dse_DE, cooling_load_ducts_sens
   end
 
-  def self._calc_dse_DE_heating(dse_a_s, dse_Bs, dse_a_r, dse_Br, dse_dT_s, dse_dT_r, dse_dTe)
+  def self._calc_dse_DE_heating(dse_As, dse_Bs, dse_Ar, dse_Br, dse_dT_s, dse_dT_r, dse_dTe)
     # Calculate the delivery effectiveness (Equation 6-23)
-    dse_DE = (dse_a_s * dse_Bs -
-              dse_a_s * dse_Bs * (1.0 - dse_a_r * dse_Br) * (dse_dT_r / dse_dTe) -
-              dse_a_s * (1.0 - dse_Bs) * (dse_dT_s / dse_dTe))
+    dse_DE = (dse_As * dse_Bs -
+              dse_As * dse_Bs * (1.0 - dse_Ar * dse_Br) * (dse_dT_r / dse_dTe) -
+              dse_As * (1.0 - dse_Bs) * (dse_dT_s / dse_dTe))
 
     return dse_DE
   end
 
-  def self._calc_dse_DEcorr(dse_DE, dse_Fregain_s, dse_Fregain_r, dse_Br, dse_a_r, dse_dT_r, dse_dTe)
+  def self._calc_dse_DEcorr(dse_DE, dse_Fregain_s, dse_Fregain_r, dse_Br, dse_Ar, dse_dT_r, dse_dTe)
     # Calculate the delivery effectiveness corrector for regain (Equation 6-40)
     dse_DEcorr = (dse_DE + dse_Fregain_s * (1.0 - dse_DE) - (dse_Fregain_s - dse_Fregain_r -
-                  dse_Br * (dse_a_r * dse_Fregain_s - dse_Fregain_r)) * dse_dT_r / dse_dTe)
+                  dse_Br * (dse_Ar * dse_Fregain_s - dse_Fregain_r)) * dse_dT_r / dse_dTe)
 
     # Limit the DE to a reasonable value to prevent negative values and huge equipment
     dse_DEcorr = [dse_DEcorr, 0.25].max
@@ -2197,382 +2225,92 @@ class HVACSizing
     return dse_DEcorr
   end
 
-  def self.calculate_sensible_latent_split(return_leakage_cfm, cool_load_tot, coolingLoadLat)
+  def self.calculate_sensible_latent_split(return_leakage_cfm, cool_load_tot, cool_load_lat)
     # Calculate the latent duct leakage load (Manual J accounts only for return duct leakage)
-    dse_Cool_Load_Latent = [0.0, 0.68 * @acf * return_leakage_cfm * (@cool_design_grains - @cool_indoor_grains)].max
+    dse_cool_load_latent = [0.0, 0.68 * @acf * return_leakage_cfm * (@cool_design_grains - @cool_indoor_grains)].max
 
     # Calculate final latent and load
-    cool_Load_Lat = coolingLoadLat + dse_Cool_Load_Latent
-    cool_Load_Sens = cool_load_tot - cool_Load_Lat
+    cool_load_lat += dse_cool_load_latent
+    cool_load_sens = cool_load_tot - cool_load_lat
 
-    return cool_Load_Lat, cool_Load_Sens
+    return cool_load_lat, cool_load_sens
   end
 
-  def self.calc_ducts_area_weighted_average(ducts, values)
-    '''
-    Calculate area-weighted average values for unconditioned duct(s)
-    '''
-    uncond_area = { HPXML::DuctTypeSupply => 0.0, HPXML::DuctTypeReturn => 0.0 }
-    ducts.each do |duct|
-      next if HPXML::conditioned_locations_this_unit.include? duct.Location
-
-      uncond_area[duct.Side] += duct.Area
-    end
+  def self.calc_duct_conduction_values(distribution_system, design_temps)
+    dse_A = { HPXML::DuctTypeSupply => 0.0, HPXML::DuctTypeReturn => 0.0 }
+    dse_Ufactor = { HPXML::DuctTypeSupply => 0.0, HPXML::DuctTypeReturn => 0.0 }
+    dse_Tamb = { HPXML::DuctTypeSupply => 0.0, HPXML::DuctTypeReturn => 0.0 }
+    dse_Fregain = { HPXML::DuctTypeSupply => 0.0, HPXML::DuctTypeReturn => 0.0 }
 
-    value = { HPXML::DuctTypeSupply => 0.0, HPXML::DuctTypeReturn => 0.0 }
-    ducts.each do |duct|
-      next if HPXML::conditioned_locations_this_unit.include? duct.Location
+    [HPXML::DuctTypeSupply, HPXML::DuctTypeReturn].each do |duct_type|
+      # Calculate total area outside this unit's conditioned space
+      total_area = 0.0
+      distribution_system.ducts.each do |duct|
+        next if duct.duct_type != duct_type
+        next if HPXML::conditioned_locations_this_unit.include? duct.duct_location
 
-      if uncond_area[duct.Side] > 0
-        value[duct.Side] += values[duct.Side][duct.Location] * duct.Area / uncond_area[duct.Side]
-      else
-        value[duct.Side] += values[duct.Side][duct.Location]
+        total_area += duct.duct_surface_area * duct.duct_surface_area_multiplier
       end
-    end
 
-    return value[HPXML::DuctTypeSupply], value[HPXML::DuctTypeReturn]
-  end
-
-  def self.calc_ducts_areas(ducts)
-    '''
-    Calculate total supply & return duct areas in unconditioned space
-    '''
+      if total_area == 0
+        # There still may be leakage to the outside, so set Tamb to outside environment
+        dse_Tamb[duct_type] = design_temps[HPXML::LocationOutside]
+      else
+        distribution_system.ducts.each do |duct|
+          next if duct.duct_type != duct_type
+          next if HPXML::conditioned_locations_this_unit.include? duct.duct_location
 
-    areas = { HPXML::DuctTypeSupply => 0.0, HPXML::DuctTypeReturn => 0.0 }
-    ducts.each do |duct|
-      next if HPXML::conditioned_locations_this_unit.include? duct.Location
+          duct_area = duct.duct_surface_area * duct.duct_surface_area_multiplier
+          dse_A[duct_type] += duct_area
 
-      areas[duct.Side] += duct.Area
-    end
+          # Calculate area-weighted values:
 
-    return areas[HPXML::DuctTypeSupply], areas[HPXML::DuctTypeReturn]
-  end
+          duct_area_fraction = duct_area / total_area
 
-  def self.calc_ducts_leakages(ducts, system_cfm)
-    '''
-    Calculate total supply & return duct leakage in cfm.
-    '''
+          dse_Ufactor[duct_type] += 1.0 / duct.duct_effective_r_value * duct_area_fraction
 
-    cfms = { HPXML::DuctTypeSupply => 0.0, HPXML::DuctTypeReturn => 0.0 }
-    ducts.each do |duct|
-      next if HPXML::conditioned_locations_this_unit.include? duct.Location
+          dse_Tamb[duct_type] += design_temps[duct.duct_location] * duct_area_fraction
 
-      if duct.LeakageFrac.to_f > 0
-        cfms[duct.Side] += duct.LeakageFrac * system_cfm
-      elsif duct.LeakageCFM25.to_f > 0
-        cfms[duct.Side] += duct.LeakageCFM25
-      elsif duct.LeakageCFM50.to_f > 0
-        cfms[duct.Side] += Airflow.calc_air_leakage_at_diff_pressure(0.65, duct.LeakageCFM50, 50.0, 25.0)
+          dse_Fregain[duct_type] += get_duct_regain_factor(duct) * duct_area_fraction
+        end
       end
     end
 
-    return cfms[HPXML::DuctTypeSupply], cfms[HPXML::DuctTypeReturn]
+    return dse_A[HPXML::DuctTypeSupply], dse_A[HPXML::DuctTypeReturn],
+           1.0 / dse_Ufactor[HPXML::DuctTypeSupply], 1.0 / dse_Ufactor[HPXML::DuctTypeReturn],
+           dse_Tamb[HPXML::DuctTypeSupply], dse_Tamb[HPXML::DuctTypeReturn],
+           dse_Fregain[HPXML::DuctTypeSupply], dse_Fregain[HPXML::DuctTypeReturn]
   end
 
-  def self.calc_ducts_rvalues(ducts)
+  def self.calc_duct_leakages_cfm25(distribution_system, system_cfm)
     '''
-    Calculate UA-weighted average R-value for supply & return ducts.
+    Calculate supply & return duct leakage in cfm25.
     '''
 
-    u_factors = { HPXML::DuctTypeSupply => {}, HPXML::DuctTypeReturn => {} }
-    ducts.each do |duct|
-      next if HPXML::conditioned_locations_this_unit.include? duct.Location
-
-      u_factors[duct.Side][duct.Location] = 1.0 / duct.Rvalue
-    end
-
-    supply_u, return_u = calc_ducts_area_weighted_average(ducts, u_factors)
-
-    return 1.0 / supply_u, 1.0 / return_u
-  end
-
-  def self.get_hvac_information(hvac_system)
-    # FUTURE: Remove this method and use hvac_system objects directly.
-    hvac = HVACInfo.new
-
-    hpxml_hvacs = []
-    if not hvac_system[:heating].nil?
-      hpxml_hvacs << hvac_system[:heating]
-    end
-    if not hvac_system[:cooling].nil?
-      hpxml_hvacs << hvac_system[:cooling]
-    end
-
-    # Get heating/cooling system info from HPXML objects
-    hpxml_hvacs.uniq.each do |hpxml_hvac|
-      hpxml_hvac_ap = hpxml_hvac.additional_properties
-
-      hvac.hvac_system = hvac_system
-
-      # System type
-      if hpxml_hvac.respond_to? :heating_system_type
-        hvac.HeatType = hpxml_hvac.heating_system_type
-      elsif hpxml_hvac.respond_to? :cooling_system_type
-        hvac.CoolType = hpxml_hvac.cooling_system_type
-      elsif hpxml_hvac.respond_to? :heat_pump_type
-        hvac.HeatType = hpxml_hvac.heat_pump_type
-        hvac.CoolType = hpxml_hvac.heat_pump_type
-      end
-
-      # Load fractions
-      if hpxml_hvac.respond_to? :fraction_heat_load_served
-        hvac.HeatingLoadFraction = hpxml_hvac.fraction_heat_load_served
-      end
-      if hpxml_hvac.respond_to? :fraction_cool_load_served
-        hvac.CoolingLoadFraction = hpxml_hvac.fraction_cool_load_served
-      end
-      if hpxml_hvac.is_a?(HPXML::HeatingSystem) && hpxml_hvac.is_heat_pump_backup_system
-        # Use the same load fractions as the heat pump
-        heat_pump = @hpxml.heat_pumps.select { |hp| hp.backup_system_idref == hpxml_hvac.id }[0]
-        hvac.HeatingLoadFraction = heat_pump.fraction_heat_load_served
-        hvac.CoolingLoadFraction = heat_pump.fraction_cool_load_served
-      end
-
-      # Capacities
-      if hpxml_hvac.is_a?(HPXML::HeatingSystem) || hpxml_hvac.is_a?(HPXML::HeatPump)
-        hvac.FixedHeatingCapacity = hpxml_hvac.heating_capacity
-      end
-      if hpxml_hvac.is_a?(HPXML::CoolingSystem) || hpxml_hvac.is_a?(HPXML::HeatPump)
-        hvac.FixedCoolingCapacity = hpxml_hvac.cooling_capacity
-      end
-      if hpxml_hvac.is_a?(HPXML::HeatPump)
-        if not hpxml_hvac.backup_heating_capacity.nil?
-          hvac.FixedSuppHeatingCapacity = hpxml_hvac.backup_heating_capacity
-        elsif not hpxml_hvac.backup_system.nil?
-          hvac.FixedSuppHeatingCapacity = hpxml_hvac.backup_system.heating_capacity
-        end
-      end
-
-      # Integrated heating systems
-      if hpxml_hvac.is_a?(HPXML::CoolingSystem) && hpxml_hvac.has_integrated_heating
-        hvac.HasIntegratedHeating = true
-        hvac.HeatingLoadFraction = hpxml_hvac.integrated_heating_system_fraction_heat_load_served
-        hvac.FixedHeatingCapacity = hpxml_hvac.integrated_heating_system_capacity
-      end
-
-      # HP Switchover Temperature
-      if hpxml_hvac.is_a?(HPXML::HeatPump)
-        hvac.SwitchoverTemperature = hpxml_hvac.backup_heating_switchover_temp
-      end
-
-      # Number of speeds
-      if hpxml_hvac.is_a?(HPXML::CoolingSystem) || hpxml_hvac.is_a?(HPXML::HeatPump)
-        # Cooling
-        if hpxml_hvac_ap.respond_to? :num_speeds
-          num_speeds = hpxml_hvac_ap.num_speeds
-        end
-        num_speeds = 1 if num_speeds.nil?
-        hvac.NumSpeedsCooling = num_speeds
-        if hvac.NumSpeedsCooling == 2
-          hvac.OverSizeLimit = 1.2
-        elsif hvac.NumSpeedsCooling > 2
-          hvac.OverSizeLimit = 1.3
-        end
-      end
-      if hpxml_hvac.is_a?(HPXML::HeatingSystem) || hpxml_hvac.is_a?(HPXML::HeatPump)
-        # Heating
-        if hpxml_hvac_ap.respond_to? :num_speeds
-          num_speeds = hpxml_hvac_ap.num_speeds
-        end
-        num_speeds = 1 if num_speeds.nil?
-        hvac.NumSpeedsHeating = num_speeds
-      end
-
-      # HVAC installation quality
-      if hpxml_hvac.respond_to? :charge_defect_ratio
-        if [HPXML::HVACTypeCentralAirConditioner,
-            HPXML::HVACTypeMiniSplitAirConditioner,
-            HPXML::HVACTypeHeatPumpAirToAir,
-            HPXML::HVACTypeHeatPumpMiniSplit,
-            HPXML::HVACTypeHeatPumpGroundToAir].include? hvac.CoolType
-          hvac.ChargeDefectRatio = hpxml_hvac.charge_defect_ratio
-        end
-      end
-      if hpxml_hvac.respond_to? :airflow_defect_ratio
-        # Cooling
-        if [HPXML::HVACTypeCentralAirConditioner,
-            HPXML::HVACTypeMiniSplitAirConditioner,
-            HPXML::HVACTypeHeatPumpAirToAir,
-            HPXML::HVACTypeHeatPumpMiniSplit,
-            HPXML::HVACTypeHeatPumpGroundToAir].include? hvac.CoolType
-          if not hpxml_hvac.distribution_system.nil? # Exclude ductless
-            hvac.AirflowDefectRatioCooling = hpxml_hvac.airflow_defect_ratio
-          end
-        end
-        # Heating
-        if [HPXML::HVACTypeFurnace,
-            HPXML::HVACTypeHeatPumpAirToAir,
-            HPXML::HVACTypeHeatPumpMiniSplit,
-            HPXML::HVACTypeHeatPumpGroundToAir].include? hvac.HeatType
-          if not hpxml_hvac.distribution_system.nil? # Exclude ductless
-            hvac.AirflowDefectRatioHeating = hpxml_hvac.airflow_defect_ratio
-          end
-        end
-      end
-
-      # Rated airflow rates
-      if hpxml_hvac_ap.respond_to? :cool_rated_cfm_per_ton
-        hvac.RatedCFMperTonCooling = hpxml_hvac_ap.cool_rated_cfm_per_ton
-      end
-      if hpxml_hvac_ap.respond_to? :heat_rated_cfm_per_ton
-        hvac.RatedCFMperTonHeating = hpxml_hvac_ap.heat_rated_cfm_per_ton
-      end
-
-      # Capacity ratios
-      if hpxml_hvac_ap.respond_to? :cool_capacity_ratios
-        hvac.CapacityRatioCooling = hpxml_hvac_ap.cool_capacity_ratios
-      end
-      if hpxml_hvac_ap.respond_to? :heat_capacity_ratios
-        hvac.CapacityRatioHeating = hpxml_hvac_ap.heat_capacity_ratios
-      end
-
-      # Sizing speed
-      hvac.SizingSpeed = get_sizing_speed(hvac.NumSpeedsCooling, hvac.CapacityRatioCooling)
-
-      # Rated SHRs
-      if hpxml_hvac_ap.respond_to? :cool_rated_shrs_gross
-        hvac.SHRRated = hpxml_hvac_ap.cool_rated_shrs_gross
-      end
-
-      # Performance curves
-      if hpxml_hvac_ap.respond_to? :cool_cap_ft_spec
-        hvac.COOL_CAP_FT_SPEC = hpxml_hvac_ap.cool_cap_ft_spec
-      end
-      if hpxml_hvac_ap.respond_to? :cool_sh_ft_spec
-        hvac.COOL_SH_FT_SPEC = hpxml_hvac_ap.cool_sh_ft_spec
-      end
-      if hpxml_hvac_ap.respond_to? :heat_cap_ft_spec
-        hvac.HEAT_CAP_FT_SPEC = hpxml_hvac_ap.heat_cap_ft_spec
-      end
-      if hpxml_hvac_ap.respond_to? :cool_cap_fflow_spec
-        hvac.COOL_CAP_FFLOW_SPEC = hpxml_hvac_ap.cool_cap_fflow_spec
-      end
-      if hpxml_hvac_ap.respond_to? :heat_cap_fflow_spec
-        hvac.HEAT_CAP_FFLOW_SPEC = hpxml_hvac_ap.heat_cap_fflow_spec
-      end
-      if hpxml_hvac_ap.respond_to? :cool_cap_curve_spec
-        hvac.COOL_CAP_CURVE_SPEC = hpxml_hvac_ap.cool_cap_curve_spec
-      end
-      if hpxml_hvac_ap.respond_to? :cool_sh_curve_spec
-        hvac.COOL_SH_CURVE_SPEC = hpxml_hvac_ap.cool_sh_curve_spec
-      end
-      if hpxml_hvac_ap.respond_to? :heat_cap_curve_spec
-        hvac.HEAT_CAP_CURVE_SPEC = hpxml_hvac_ap.heat_cap_curve_spec
-      end
+    cfms = { HPXML::DuctTypeSupply => 0.0, HPXML::DuctTypeReturn => 0.0 }
 
-      # WLHP
-      if hpxml_hvac.respond_to? :heating_efficiency_cop
-        hvac.HeatingCOP = hpxml_hvac.heating_efficiency_cop
-      end
+    distribution_system.duct_leakage_measurements.each do |m|
+      next if m.duct_leakage_total_or_to_outside != HPXML::DuctLeakageToOutside
+      next unless [HPXML::DuctTypeSupply, HPXML::DuctTypeReturn].include? m.duct_type
 
-      # GSHP
-      if hpxml_hvac_ap.respond_to? :u_tube_spacing_type
-        hvac.GSHP_SpacingType = hpxml_hvac_ap.u_tube_spacing_type
-      end
-      if hpxml_hvac_ap.respond_to? :cool_rated_eirs
-        hvac.CoolingEIR = hpxml_hvac_ap.cool_rated_eirs[0]
+      if m.duct_leakage_units == HPXML::UnitsPercent
+        cfms[m.duct_type] += m.duct_leakage_value * system_cfm
+      elsif m.duct_leakage_units == HPXML::UnitsCFM25
+        cfms[m.duct_type] += m.duct_leakage_value
+      elsif m.duct_leakage_units == HPXML::UnitsCFM50
+        cfms[m.duct_type] += Airflow.calc_air_leakage_at_diff_pressure(0.65, m.duct_leakage_value, 50.0, 25.0)
       end
-      if hpxml_hvac_ap.respond_to? :heat_rated_eirs
-        hvac.HeatingEIR = hpxml_hvac_ap.heat_rated_eirs[0]
-      end
-      if hvac.HeatType == HPXML::HVACTypeHeatPumpGroundToAir
-        hvac.GSHP_design_chw = hpxml_hvac_ap.design_chw
-        hvac.GSHP_design_delta_t = hpxml_hvac_ap.design_delta_t
-        hvac.GSHP_design_hw = hpxml_hvac_ap.design_hw
-        hvac.GSHP_bore_d = hpxml_hvac_ap.bore_diameter
-        hvac.GSHP_pipe_od = hpxml_hvac_ap.pipe_od
-        hvac.GSHP_pipe_id = hpxml_hvac_ap.pipe_id
-        hvac.GSHP_pipe_cond = hpxml_hvac_ap.pipe_cond
-        hvac.GSHP_grout_k = hpxml_hvac_ap.grout_conductivity
-      end
-
-      # Evaporative cooler
-      if hpxml_hvac_ap.respond_to? :effectiveness
-        hvac.EvapCoolerEffectiveness = hpxml_hvac_ap.effectiveness
-      end
-
-      # Ducts
-      # FUTURE: Consolidate w/ ducts code in measure.rb
-      hvac.Ducts = []
-      next unless not hpxml_hvac.distribution_system.nil?
-
-      lto = { supply_percent: nil, supply_cfm25: nil, return_percent: nil, return_cfm25: nil }
-      hpxml_hvac.distribution_system.duct_leakage_measurements.each do |m|
-        next unless m.duct_leakage_total_or_to_outside == 'to outside'
+    end
 
-        if m.duct_leakage_units == HPXML::UnitsPercent && m.duct_type == HPXML::DuctTypeSupply
-          lto[:supply_percent] = m.duct_leakage_value
-        elsif m.duct_leakage_units == HPXML::UnitsCFM25 && m.duct_type == HPXML::DuctTypeSupply
-          lto[:supply_cfm25] = m.duct_leakage_value
-        elsif m.duct_leakage_units == HPXML::UnitsCFM50 && m.duct_type == HPXML::DuctTypeSupply
-          lto[:supply_cfm50] = m.duct_leakage_value
-        elsif m.duct_leakage_units == HPXML::UnitsPercent && m.duct_type == HPXML::DuctTypeReturn
-          lto[:return_percent] = m.duct_leakage_value
-        elsif m.duct_leakage_units == HPXML::UnitsCFM25 && m.duct_type == HPXML::DuctTypeReturn
-          lto[:return_cfm25] = m.duct_leakage_value
-        elsif m.duct_leakage_units == HPXML::UnitsCFM50 && m.duct_type == HPXML::DuctTypeReturn
-          lto[:return_cfm50] = m.duct_leakage_value
-        end
-      end
-      total_uncond_supply_area = hpxml_hvac.distribution_system.total_unconditioned_duct_areas[HPXML::DuctTypeSupply]
-      total_uncond_return_area = hpxml_hvac.distribution_system.total_unconditioned_duct_areas[HPXML::DuctTypeReturn]
-      hpxml_hvac.distribution_system.ducts.each do |duct|
-        next if HPXML::conditioned_locations_this_unit.include? duct.duct_location
+    return cfms[HPXML::DuctTypeSupply], cfms[HPXML::DuctTypeReturn]
+  end
 
-        d = DuctInfo.new
-        d.Side = duct.duct_type
-        d.Location = duct.duct_location
-        d.Area = duct.duct_surface_area * duct.duct_surface_area_multiplier
-
-        # Calculate R-value w/ air film
-        d.Rvalue = Airflow.get_duct_insulation_rvalue(duct.duct_insulation_r_value, d.Side)
-
-        # Leakage to Outside apportioned to this duct
-        if d.Side == HPXML::DuctTypeSupply
-          d.LeakageFrac = lto[:supply_percent].to_f * d.Area / total_uncond_supply_area
-          d.LeakageCFM25 = lto[:supply_cfm25].to_f * d.Area / total_uncond_supply_area
-          d.LeakageCFM50 = lto[:supply_cfm50].to_f * d.Area / total_uncond_supply_area
-        elsif d.Side == HPXML::DuctTypeReturn
-          d.LeakageFrac = lto[:return_percent].to_f * d.Area / total_uncond_return_area
-          d.LeakageCFM25 = lto[:return_cfm25].to_f * d.Area / total_uncond_return_area
-          d.LeakageCFM50 = lto[:return_cfm50].to_f * d.Area / total_uncond_return_area
-        end
-        hvac.Ducts << d
-      end
-      # If all ducts are in conditioned space, treat leakage as going to outside
-      if (lto[:supply_percent].to_f + lto[:supply_cfm25].to_f + lto[:supply_cfm50].to_f) > 0 && total_uncond_supply_area == 0
-        d = DuctInfo.new
-        d.Side = HPXML::DuctTypeSupply
-        d.Location = HPXML::LocationOutside
-        d.Area = 0.0
-        d.Rvalue = Airflow.get_duct_insulation_rvalue(0.0, d.Side)
-        d.LeakageFrac = lto[:supply_percent]
-        d.LeakageCFM25 = lto[:supply_cfm25]
-        d.LeakageCFM50 = lto[:supply_cfm50]
-        hvac.Ducts << d
-      end
-      next unless (lto[:return_percent].to_f + lto[:return_cfm25].to_f + lto[:return_cfm50].to_f) > 0 && total_uncond_return_area == 0
-
-      d = DuctInfo.new
-      d.Side = HPXML::DuctTypeReturn
-      d.Location = HPXML::LocationOutside
-      d.Area = 0.0
-      d.Rvalue = Airflow.get_duct_insulation_rvalue(0.0, d.Side)
-      d.LeakageFrac = lto[:return_percent]
-      d.LeakageCFM25 = lto[:return_cfm25]
-      d.LeakageCFM50 = lto[:return_cfm50]
-      hvac.Ducts << d
-    end
-
-    return hvac
-  end
-
-  def self.process_curve_fit(airFlowRate, capacity, temp)
+  def self.process_curve_fit(airflow_rate, capacity, temp)
     # TODO: Get rid of this curve by using ADP/BF calculations
     return 0 if capacity == 0
 
     capacity_tons = UnitConversions.convert(capacity, 'Btu/hr', 'ton')
-    return MathTools.biquadratic(airFlowRate / capacity_tons, temp, get_shr_biquadratic)
+    return MathTools.biquadratic(airflow_rate / capacity_tons, temp, get_shr_biquadratic)
   end
 
   def self.get_shr_biquadratic
@@ -2582,19 +2320,19 @@ class HVACSizing
     return [1.08464364, 0.002096954, 0, -0.005766327, 0, -0.000011147]
   end
 
-  def self.get_sizing_speed(num_speeds_cooling, capacity_ratios_cooling)
-    if num_speeds_cooling > 1
-      sizingSpeed = num_speeds_cooling # Default
-      sizingSpeed_Test = 10 # Initialize
-      for speed in 0..(num_speeds_cooling - 1)
+  def self.get_sizing_speed(hvac_cooling_ap)
+    if hvac_cooling_ap.respond_to?(:cool_capacity_ratios) && (hvac_cooling_ap.cool_capacity_ratios.size > 1)
+      sizing_speed = hvac_cooling_ap.cool_capacity_ratios.size # Default
+      sizing_speed_delta = 10 # Initialize
+      for speed in 0..(hvac_cooling_ap.cool_capacity_ratios.size - 1)
         # Select curves for sizing using the speed with the capacity ratio closest to 1
-        temp = (capacity_ratios_cooling[speed] - 1).abs
-        if temp <= sizingSpeed_Test
-          sizingSpeed = speed
-          sizingSpeed_Test = temp
+        delta = (hvac_cooling_ap.cool_capacity_ratios[speed] - 1).abs
+        if delta <= sizing_speed_delta
+          sizing_speed = speed
+          sizing_speed_delta = delta
         end
       end
-      return sizingSpeed
+      return sizing_speed
     end
     return 0
   end
@@ -2638,10 +2376,10 @@ class HVACSizing
     if [HPXML::LocationCrawlspaceVented, HPXML::LocationAtticVented].include? location
       # Vented space
       if location == HPXML::LocationCrawlspaceVented
-        vented_crawl = @hpxml.foundations.select { |f| f.foundation_type == HPXML::FoundationTypeCrawlspaceVented }[0]
+        vented_crawl = @hpxml.foundations.find { |f| f.foundation_type == HPXML::FoundationTypeCrawlspaceVented }
         sla = vented_crawl.vented_crawlspace_sla
       else
-        vented_attic = @hpxml.attics.select { |f| f.attic_type == HPXML::AtticTypeVented }[0]
+        vented_attic = @hpxml.attics.find { |f| f.attic_type == HPXML::AtticTypeVented }
         if not vented_attic.vented_attic_sla.nil?
           sla = vented_attic.vented_attic_sla
         else
@@ -2915,32 +2653,32 @@ class HVACSizing
     return [1.21005458, -0.00664200, 0.00000000, 0.00348246, 0.00000000, 0.00000000]
   end
 
-  def self.gshp_hx_pipe_rvalue(hvac)
+  def self.gshp_hx_pipe_rvalue(hvac_cooling_ap)
     # Thermal Resistance of Pipe
-    return Math.log(hvac.GSHP_pipe_od / hvac.GSHP_pipe_id) / 2.0 / Math::PI / hvac.GSHP_pipe_cond
+    return Math.log(hvac_cooling_ap.pipe_od / hvac_cooling_ap.pipe_id) / 2.0 / Math::PI / hvac_cooling_ap.pipe_cond
   end
 
-  def self.gshp_hxbore_ft_per_ton(weather, hvac, bore_spacing, pipe_r_value)
-    if hvac.GSHP_SpacingType == 'b'
+  def self.gshp_hxbore_ft_per_ton(weather, hvac_cooling_ap, bore_spacing, pipe_r_value)
+    if hvac_cooling_ap.u_tube_spacing_type == 'b'
       beta_0 = 17.4427
       beta_1 = -0.6052
-    elsif hvac.GSHP_SpacingType == 'c'
+    elsif hvac_cooling_ap.u_tube_spacing_type == 'c'
       beta_0 = 21.9059
       beta_1 = -0.3796
-    elsif hvac.GSHP_SpacingType == 'as'
+    elsif hvac_cooling_ap.u_tube_spacing_type == 'as'
       beta_0 = 20.1004
       beta_1 = -0.94467
     end
 
-    r_value_ground = Math.log(bore_spacing / hvac.GSHP_bore_d * 12.0) / 2.0 / Math::PI / @hpxml.site.ground_conductivity
-    r_value_grout = 1.0 / hvac.GSHP_grout_k / beta_0 / ((hvac.GSHP_bore_d / hvac.GSHP_pipe_od)**beta_1)
+    r_value_ground = Math.log(bore_spacing / hvac_cooling_ap.bore_diameter * 12.0) / 2.0 / Math::PI / @hpxml.site.ground_conductivity
+    r_value_grout = 1.0 / hvac_cooling_ap.grout_conductivity / beta_0 / ((hvac_cooling_ap.bore_diameter / hvac_cooling_ap.pipe_od)**beta_1)
     r_value_bore = r_value_grout + pipe_r_value / 2.0 # Note: Convection resistance is negligible when calculated against Glhepro (Jeffrey D. Spitler, 2000)
 
     rtf_DesignMon_Heat = [0.25, (71.0 - weather.data.MonthlyAvgDrybulbs[0]) / @htd].max
     rtf_DesignMon_Cool = [0.25, (weather.data.MonthlyAvgDrybulbs[6] - 76.0) / @ctd].max
 
-    nom_length_heat = (1.0 - hvac.HeatingEIR) * (r_value_bore + r_value_ground * rtf_DesignMon_Heat) / (weather.data.AnnualAvgDrybulb - (2.0 * hvac.GSHP_design_hw - hvac.GSHP_design_delta_t) / 2.0) * UnitConversions.convert(1.0, 'ton', 'Btu/hr')
-    nom_length_cool = (1.0 + hvac.CoolingEIR) * (r_value_bore + r_value_ground * rtf_DesignMon_Cool) / ((2.0 * hvac.GSHP_design_chw + hvac.GSHP_design_delta_t) / 2.0 - weather.data.AnnualAvgDrybulb) * UnitConversions.convert(1.0, 'ton', 'Btu/hr')
+    nom_length_heat = (1.0 - hvac_cooling_ap.heat_rated_eirs[0]) * (r_value_bore + r_value_ground * rtf_DesignMon_Heat) / (weather.data.AnnualAvgDrybulb - (2.0 * hvac_cooling_ap.design_hw - hvac_cooling_ap.design_delta_t) / 2.0) * UnitConversions.convert(1.0, 'ton', 'Btu/hr')
+    nom_length_cool = (1.0 + hvac_cooling_ap.cool_rated_eirs[0]) * (r_value_bore + r_value_ground * rtf_DesignMon_Cool) / ((2.0 * hvac_cooling_ap.design_chw + hvac_cooling_ap.design_delta_t) / 2.0 - weather.data.AnnualAvgDrybulb) * UnitConversions.convert(1.0, 'ton', 'Btu/hr')
 
     return nom_length_heat, nom_length_cool
   end
@@ -3388,6 +3126,42 @@ class HVACSizing
 
     return f_values.sum() / f_values.size
   end
+
+  def self.set_hvac_types(hvac_heating, hvac_cooling)
+    if hvac_heating.nil?
+      @heating_type = nil
+    elsif hvac_heating.is_a? HPXML::HeatingSystem
+      @heating_type = hvac_heating.heating_system_type
+    else
+      @heating_type = hvac_heating.heat_pump_type
+    end
+    if hvac_cooling.nil?
+      @cooling_type = nil
+    elsif hvac_cooling.is_a? HPXML::CoolingSystem
+      @cooling_type = hvac_cooling.cooling_system_type
+    else
+      @cooling_type = hvac_cooling.heat_pump_type
+    end
+  end
+
+  def self.set_fractions_load_served(hvac_heating, hvac_cooling)
+    if hvac_cooling.is_a?(HPXML::CoolingSystem) && hvac_cooling.has_integrated_heating
+      @fraction_heat_load_served = hvac_cooling.integrated_heating_system_fraction_heat_load_served
+    elsif hvac_heating.nil?
+      @fraction_heat_load_served = 0
+    elsif hvac_heating.is_a?(HPXML::HeatingSystem) && hvac_heating.is_heat_pump_backup_system
+      # Use the same load fractions as the heat pump
+      heat_pump = @hpxml.heat_pumps.find { |hp| hp.backup_system_idref == hvac_heating.id }
+      @fraction_heat_load_served = heat_pump.fraction_heat_load_served
+    else
+      @fraction_heat_load_served = hvac_heating.fraction_heat_load_served
+    end
+    if hvac_cooling.nil?
+      @fraction_cool_load_served = 0
+    else
+      @fraction_cool_load_served = hvac_cooling.fraction_cool_load_served
+    end
+  end
 end
 
 class DesignLoads
@@ -3395,7 +3169,7 @@ class DesignLoads
   end
   attr_accessor(:Cool_Sens, :Cool_Lat, :Cool_Tot, :Heat_Tot, :Heat_Ducts, :Cool_Ducts_Sens, :Cool_Ducts_Lat,
                 :Cool_Windows, :Cool_Skylights, :Cool_Doors, :Cool_Walls, :Cool_Roofs, :Cool_Floors,
-                :Cool_Ceilings, :Cool_Infil_Sens, :Cool_Infil_Lat, :Cool_IntGains_Sens, :Cool_IntGains_Lat,
+                :Cool_Ceilings, :Cool_InfilVent_Sens, :Cool_InfilVent_Lat, :Cool_IntGains_Sens, :Cool_IntGains_Lat,
                 :Heat_Windows, :Heat_Skylights, :Heat_Doors, :Heat_Walls, :Heat_Roofs, :Heat_Floors,
                 :Heat_Slabs, :Heat_Ceilings, :Heat_InfilVent)
 end
@@ -3410,46 +3184,6 @@ class HVACSizingValues
                 :GSHP_Loop_flow, :GSHP_Bore_Holes, :GSHP_Bore_Depth, :GSHP_G_Functions)
 end
 
-class HVACInfo
-  # Model info for HVAC
-  def initialize
-    self.NumSpeedsCooling = 0
-    self.NumSpeedsHeating = 0
-    self.HeatingLoadFraction = 0.0
-    self.CoolingLoadFraction = 0.0
-    self.CapacityRatioCooling = [1.0]
-    self.CapacityRatioHeating = [1.0]
-    self.OverSizeLimit = 1.15
-    self.OverSizeDelta = 15000.0
-    self.Ducts = []
-    self.AirflowDefectRatioCooling = 0.0
-    self.AirflowDefectRatioHeating = 0.0
-  end
-
-  attr_accessor(:HeatType, :CoolType, :Ducts, :NumSpeedsCooling, :NumSpeedsHeating,
-                :FixedCoolingCapacity, :FixedHeatingCapacity, :FixedSuppHeatingCapacity,
-                :AirflowDefectRatioCooling, :AirflowDefectRatioHeating,
-                :RatedCFMperTonCooling, :RatedCFMperTonHeating, :ChargeDefectRatio,
-                :COOL_CAP_FT_SPEC, :HEAT_CAP_FT_SPEC, :COOL_SH_FT_SPEC,
-                :COOL_CAP_FFLOW_SPEC, :HEAT_CAP_FFLOW_SPEC,
-                :COOL_CAP_CURVE_SPEC, :COOL_SH_CURVE_SPEC, :HEAT_CAP_CURVE_SPEC,
-                :SHRRated, :CapacityRatioCooling, :CapacityRatioHeating,
-                :OverSizeLimit, :OverSizeDelta, :hvac_system,
-                :HeatingEIR, :CoolingEIR, :SizingSpeed, :HeatingCOP,
-                :GSHP_SpacingType, :EvapCoolerEffectiveness, :SwitchoverTemperature, :LeavingAirTemp,
-                :HeatingLoadFraction, :CoolingLoadFraction, :SupplyAirTemp, :BackupSupplyAirTemp,
-                :GSHP_design_chw, :GSHP_design_delta_t, :GSHP_design_hw, :GSHP_bore_d,
-                :GSHP_pipe_od, :GSHP_pipe_id, :GSHP_pipe_cond, :GSHP_grout_k, :HasIntegratedHeating)
-end
-
-class DuctInfo
-  # Model info for a duct
-  # FUTURE: Remove class; use either airflow.rb Duct class or HPXML Ducts class directly
-  def initial
-  end
-  attr_accessor(:LeakageFrac, :LeakageCFM25, :LeakageCFM50, :Area, :Rvalue, :Location, :Side)
-end
-
 class Numeric
   def deg2rad
     self * Math::PI / 180