urbanopt-cli 0.9.2 → 0.10.0

data/example_files/resources/hpxml-measures/HPXMLtoOpenStudio/tests/test_defaults.rb

@@ -47,13 +47,25 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.header.allow_increased_fixed_capacities = true
     hpxml.header.state_code = 'CA'
     hpxml.header.time_zone_utc_offset = -8
-    hpxml.header.occupancy_calculation_type = HPXML::OccupancyCalculationTypeOperational
     hpxml.header.temperature_capacitance_multiplier = 1.5
     hpxml.header.natvent_days_per_week = 7
-    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
-    hpxml_default = _test_measure()
-    _test_default_header_values(hpxml_default, 30, 2, 2, 11, 11, 2009, false, 3, 3, 10, 10, HPXML::HeatPumpSizingMaxLoad,
-                                true, 'CA', -8, HPXML::OccupancyCalculationTypeOperational, 1.5, 7)
+    hpxml.header.unavailable_periods.add(column_name: 'Power Outage', begin_month: 1, begin_day: 1, begin_hour: 3, end_month: 12, end_day: 31, end_hour: 4, natvent_availability: HPXML::ScheduleUnavailable)
+    hpxml.header.shading_summer_begin_month = 2
+    hpxml.header.shading_summer_begin_day = 3
+    hpxml.header.shading_summer_end_month = 4
+    hpxml.header.shading_summer_end_day = 5
+    hpxml.header.manualj_heating_design_temp = 0.0
+    hpxml.header.manualj_cooling_design_temp = 100.0
+    hpxml.header.manualj_heating_setpoint = 68.0
+    hpxml.header.manualj_cooling_setpoint = 78.0
+    hpxml.header.manualj_humidity_setpoint = 0.44
+    hpxml.header.manualj_internal_loads_sensible = 1600.0
+    hpxml.header.manualj_internal_loads_latent = 60.0
+    hpxml.header.manualj_num_occupants = 8
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_header_values(hpxml_default, 30, 2, 2, 11, 11, 2009, false, 3, 3, 10, 10, HPXML::HeatPumpSizingMaxLoad, true, 'CA',
+                                -8, 1.5, 7, 3, 4, HPXML::ScheduleUnavailable, 2, 3, 4, 5, 0.0, 100.0, 68.0, 78.0, 0.44, 1600.0, 60.0, 8)
 
     # Test defaults - DST not in weather file
     hpxml.header.timestep = nil
@@ -71,13 +83,27 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.header.allow_increased_fixed_capacities = nil
     hpxml.header.state_code = nil
     hpxml.header.time_zone_utc_offset = nil
-    hpxml.header.occupancy_calculation_type = nil
     hpxml.header.temperature_capacitance_multiplier = nil
     hpxml.header.natvent_days_per_week = nil
-    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
-    hpxml_default = _test_measure()
-    _test_default_header_values(hpxml_default, 60, 1, 1, 12, 31, 2007, true, 3, 12, 11, 5, HPXML::HeatPumpSizingHERS,
-                                false, 'CO', -7, HPXML::OccupancyCalculationTypeAsset, 1.0, 3)
+    hpxml.header.unavailable_periods[-1].begin_hour = nil
+    hpxml.header.unavailable_periods[-1].end_hour = nil
+    hpxml.header.unavailable_periods[-1].natvent_availability = nil
+    hpxml.header.shading_summer_begin_month = nil
+    hpxml.header.shading_summer_begin_day = nil
+    hpxml.header.shading_summer_end_month = nil
+    hpxml.header.shading_summer_end_day = nil
+    hpxml.header.manualj_heating_design_temp = nil
+    hpxml.header.manualj_cooling_design_temp = nil
+    hpxml.header.manualj_heating_setpoint = nil
+    hpxml.header.manualj_cooling_setpoint = nil
+    hpxml.header.manualj_humidity_setpoint = nil
+    hpxml.header.manualj_internal_loads_sensible = nil
+    hpxml.header.manualj_internal_loads_latent = nil
+    hpxml.header.manualj_num_occupants = nil
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_header_values(hpxml_default, 60, 1, 1, 12, 31, 2007, true, 3, 12, 11, 5, HPXML::HeatPumpSizingHERS, false, 'CO',
+                                -7, 1.0, 3, 0, 24, HPXML::ScheduleRegular, 5, 1, 10, 31, 6.8, 91.8, 70.0, 75.0, 0.5, 2400.0, 0.0, 4)
 
     # Test defaults - DST in weather file
     hpxml = _create_hpxml('base-location-AMY-2012.xml')
@@ -96,21 +122,24 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.header.allow_increased_fixed_capacities = nil
     hpxml.header.state_code = nil
     hpxml.header.time_zone_utc_offset = nil
-    hpxml.header.occupancy_calculation_type = nil
     hpxml.header.temperature_capacitance_multiplier = nil
+    hpxml.header.shading_summer_begin_month = nil
+    hpxml.header.shading_summer_begin_day = nil
+    hpxml.header.shading_summer_end_month = nil
+    hpxml.header.shading_summer_end_day = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_header_values(hpxml_default, 60, 1, 1, 12, 31, 2012, true, 3, 11, 11, 4, nil,
-                                false, 'CO', -7, HPXML::OccupancyCalculationTypeAsset, 1.0, 3)
+    _test_default_header_values(hpxml_default, 60, 1, 1, 12, 31, 2012, true, 3, 11, 11, 4, nil, false, 'CO',
+                                -7, 1.0, 3, nil, nil, nil, 5, 1, 9, 30, 10.2, 91.4, 70.0, 75.0, 0.5, 2400.0, 0.0, 4)
 
     # Test defaults - calendar year override by AMY year
     hpxml.header.sim_calendar_year = 2020
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_header_values(hpxml_default, 60, 1, 1, 12, 31, 2012, true, 3, 11, 11, 4, nil,
-                                false, 'CO', -7, HPXML::OccupancyCalculationTypeAsset, 1.0, 3)
+    _test_default_header_values(hpxml_default, 60, 1, 1, 12, 31, 2012, true, 3, 11, 11, 4, nil, false, 'CO',
+                                -7, 1.0, 3, nil, nil, nil, 5, 1, 9, 30, 10.2, 91.4, 70.0, 75.0, 0.5, 2400.0, 0.0, 4)
 
-    # Test defaults - invalid state code
+    # Test defaults - southern hemisphere, invalid state code
     hpxml = _create_hpxml('base-location-capetown-zaf.xml')
     hpxml.header.timestep = nil
     hpxml.header.sim_begin_month = nil
@@ -127,12 +156,15 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.header.allow_increased_fixed_capacities = nil
     hpxml.header.state_code = nil
     hpxml.header.time_zone_utc_offset = nil
-    hpxml.header.occupancy_calculation_type = nil
     hpxml.header.temperature_capacitance_multiplier = nil
+    hpxml.header.shading_summer_begin_month = nil
+    hpxml.header.shading_summer_begin_day = nil
+    hpxml.header.shading_summer_end_month = nil
+    hpxml.header.shading_summer_end_day = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_header_values(hpxml_default, 60, 1, 1, 12, 31, 2007, true, 3, 12, 11, 5, nil,
-                                false, nil, 2, HPXML::OccupancyCalculationTypeAsset, 1.0, 3)
+    _test_default_header_values(hpxml_default, 60, 1, 1, 12, 31, 2007, true, 3, 12, 11, 5, nil, false, nil,
+                                2, 1.0, 3, nil, nil, nil, 12, 1, 4, 30, 41.0, 84.4, 70.0, 75.0, 0.5, 2400.0, 0.0, 4)
   end
 
   def test_emissions_factors
@@ -329,77 +361,74 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
   def test_occupancy
     # Test inputs not overridden by defaults
     hpxml = _create_hpxml('base.xml')
-    hpxml.building_occupancy.number_of_residents = 1
     hpxml.building_occupancy.weekday_fractions = ConstantDaySchedule
     hpxml.building_occupancy.weekend_fractions = ConstantDaySchedule
     hpxml.building_occupancy.monthly_multipliers = ConstantMonthSchedule
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_occupancy_values(hpxml_default, 1, ConstantDaySchedule, ConstantDaySchedule, ConstantMonthSchedule)
+    _test_default_occupancy_values(hpxml_default, ConstantDaySchedule, ConstantDaySchedule, ConstantMonthSchedule)
 
     # Test defaults
-    hpxml.building_occupancy.number_of_residents = nil
     hpxml.building_occupancy.weekday_fractions = nil
     hpxml.building_occupancy.weekend_fractions = nil
     hpxml.building_occupancy.monthly_multipliers = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_occupancy_values(hpxml_default, 3, Schedule.OccupantsWeekdayFractions, Schedule.OccupantsWeekendFractions, Schedule.OccupantsMonthlyMultipliers)
+    _test_default_occupancy_values(hpxml_default, Schedule.OccupantsWeekdayFractions, Schedule.OccupantsWeekendFractions, Schedule.OccupantsMonthlyMultipliers)
   end
 
   def test_building_construction
     # Test inputs not overridden by defaults
-    hpxml = _create_hpxml('base-enclosure-infil-flue.xml')
+    hpxml = _create_hpxml('base.xml')
     hpxml.building_construction.number_of_bathrooms = 4
     hpxml.building_construction.conditioned_building_volume = 20000
     hpxml.building_construction.average_ceiling_height = 7
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_building_construction_values(hpxml_default, 20000, 7, true, 4)
+    _test_default_building_construction_values(hpxml_default, 20000, 7, 4)
 
     # Test defaults
     hpxml.building_construction.conditioned_building_volume = nil
     hpxml.building_construction.average_ceiling_height = nil
-    hpxml.building_construction.has_flue_or_chimney = nil
     hpxml.building_construction.number_of_bathrooms = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_building_construction_values(hpxml_default, 21600, 8, false, 2)
+    _test_default_building_construction_values(hpxml_default, 21600, 8, 2)
 
     # Test defaults w/ average ceiling height
     hpxml.building_construction.conditioned_building_volume = nil
     hpxml.building_construction.average_ceiling_height = 10
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_building_construction_values(hpxml_default, 27000, 10, false, 2)
+    _test_default_building_construction_values(hpxml_default, 27000, 10, 2)
 
     # Test defaults w/ conditioned building volume
     hpxml.building_construction.conditioned_building_volume = 20000
     hpxml.building_construction.average_ceiling_height = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_building_construction_values(hpxml_default, 20000, 7.4, false, 2)
+    _test_default_building_construction_values(hpxml_default, 20000, 7.4, 2)
 
     # Test defaults w/ infiltration volume
     hpxml.building_construction.conditioned_building_volume = nil
     hpxml.air_infiltration_measurements[0].infiltration_volume = 25650
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_building_construction_values(hpxml_default, 21600, 8, false, 2)
+    _test_default_building_construction_values(hpxml_default, 21600, 8, 2)
 
     # Test defaults w/ infiltration volume
     hpxml.building_construction.conditioned_building_volume = nil
     hpxml.air_infiltration_measurements[0].infiltration_volume = 18000
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_building_construction_values(hpxml_default, 18000, 6.67, false, 2)
+    _test_default_building_construction_values(hpxml_default, 18000, 6.67, 2)
 
     # Test defaults w/ conditioned crawlspace
     hpxml = _create_hpxml('base-foundation-conditioned-crawlspace.xml')
     hpxml.building_construction.conditioned_building_volume = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_building_construction_values(hpxml_default, 16200, 8, false, 2)
+    _test_default_building_construction_values(hpxml_default, 16200, 8, 2)
   end
 
   def test_climate_and_risk_zones
@@ -428,29 +457,80 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     # Test inputs not overridden by defaults
     hpxml = _create_hpxml('base.xml')
     hpxml.air_infiltration_measurements[0].infiltration_volume = 25000
+    hpxml.air_infiltration.has_flue_or_chimney_in_conditioned_space = true
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_infiltration_values(hpxml_default.air_infiltration_measurements[0], 25000)
+    _test_default_infiltration_values(hpxml_default, 25000, true)
 
     # Test defaults w/ conditioned basement
     hpxml.air_infiltration_measurements[0].infiltration_volume = nil
+    hpxml.air_infiltration.has_flue_or_chimney_in_conditioned_space = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_infiltration_values(hpxml_default.air_infiltration_measurements[0], 2700 * 8)
+    _test_default_infiltration_values(hpxml_default, 2700 * 8, false)
+
+    # Test defaults w/ conditioned basement and atmospheric water heater w/ flue
+    hpxml.water_heating_systems[0].fuel_type = HPXML::FuelTypeNaturalGas
+    hpxml.water_heating_systems[0].energy_factor = 0.6
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_infiltration_values(hpxml_default, 2700 * 8, true)
 
     # Test defaults w/o conditioned basement
     hpxml = _create_hpxml('base-foundation-slab.xml')
     hpxml.air_infiltration_measurements[0].infiltration_volume = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_infiltration_values(hpxml_default.air_infiltration_measurements[0], 1350 * 8)
+    _test_default_infiltration_values(hpxml_default, 1350 * 8, false)
 
     # Test defaults w/ conditioned crawlspace
     hpxml = _create_hpxml('base-foundation-conditioned-crawlspace.xml')
     hpxml.air_infiltration_measurements[0].infiltration_volume = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_infiltration_values(hpxml_default.air_infiltration_measurements[0], 1350 * 12)
+    _test_default_infiltration_values(hpxml_default, 1350 * 12, false)
+  end
+
+  def test_infiltration_compartmentaliztion_test_adjustment
+    # Test single-family detached
+    hpxml = _create_hpxml('base.xml')
+    hpxml.air_infiltration_measurements[0].infiltration_type = HPXML::InfiltrationTypeUnitTotal
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_infiltration_compartmentalization_test_values(hpxml_default.air_infiltration_measurements[0], nil)
+
+    # Test single-family attached not overridden by defaults
+    hpxml = _create_hpxml('base-bldgtype-attached.xml')
+    hpxml.air_infiltration_measurements[0].infiltration_type = HPXML::InfiltrationTypeUnitTotal
+    hpxml.air_infiltration_measurements[0].a_ext = 0.5
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_infiltration_compartmentalization_test_values(hpxml_default.air_infiltration_measurements[0], 0.5)
+
+    # Test single-family attached defaults
+    hpxml.air_infiltration_measurements[0].a_ext = nil
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_infiltration_compartmentalization_test_values(hpxml_default.air_infiltration_measurements[0], 0.840)
+
+    hpxml.attics[0].within_infiltration_volume = true
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_infiltration_compartmentalization_test_values(hpxml_default.air_infiltration_measurements[0], 0.817)
+
+    # Test multifamily not overridden by defaults
+    hpxml = _create_hpxml('base-bldgtype-multifamily.xml')
+    hpxml.air_infiltration_measurements[0].infiltration_type = HPXML::InfiltrationTypeUnitTotal
+    hpxml.air_infiltration_measurements[0].a_ext = 0.5
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_infiltration_compartmentalization_test_values(hpxml_default.air_infiltration_measurements[0], 0.5)
+
+    # Test multifamily defaults
+    hpxml.air_infiltration_measurements[0].a_ext = nil
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_infiltration_compartmentalization_test_values(hpxml_default.air_infiltration_measurements[0], 0.247)
   end
 
   def test_attics
@@ -1044,16 +1124,17 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.cooling_systems[0].airflow_defect_ratio = -0.22
     hpxml.cooling_systems[0].cooling_capacity = 12345
     hpxml.cooling_systems[0].cooling_efficiency_seer = 12.0
+    hpxml.cooling_systems[0].crankcase_heater_watts = 40.0
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_central_air_conditioner_values(hpxml_default.cooling_systems[0], 0.88, HPXML::HVACCompressorTypeVariableSpeed, 0.66, -0.11, -0.22, 12345, 12.0)
+    _test_default_central_air_conditioner_values(hpxml_default.cooling_systems[0], 0.88, HPXML::HVACCompressorTypeVariableSpeed, 0.66, -0.11, -0.22, 12345, 12.0, 40.0)
 
     # Test defaults - SEER2
     hpxml.cooling_systems[0].cooling_efficiency_seer = nil
     hpxml.cooling_systems[0].cooling_efficiency_seer2 = 11.4
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_central_air_conditioner_values(hpxml_default.cooling_systems[0], 0.88, HPXML::HVACCompressorTypeVariableSpeed, 0.66, -0.11, -0.22, 12345, 12.0)
+    _test_default_central_air_conditioner_values(hpxml_default.cooling_systems[0], 0.88, HPXML::HVACCompressorTypeVariableSpeed, 0.66, -0.11, -0.22, 12345, 12.0, 40.0)
 
     # Test defaults
     hpxml.cooling_systems[0].cooling_shr = nil
@@ -1062,9 +1143,10 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.cooling_systems[0].charge_defect_ratio = nil
     hpxml.cooling_systems[0].airflow_defect_ratio = nil
     hpxml.cooling_systems[0].cooling_capacity = nil
+    hpxml.cooling_systems[0].crankcase_heater_watts = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_central_air_conditioner_values(hpxml_default.cooling_systems[0], 0.73, HPXML::HVACCompressorTypeSingleStage, 0.5, 0, 0, nil, 12.0)
+    _test_default_central_air_conditioner_values(hpxml_default.cooling_systems[0], 0.73, HPXML::HVACCompressorTypeSingleStage, 0.5, 0, 0, nil, 12.0, 50.0)
   end
 
   def test_room_air_conditioners
@@ -1072,16 +1154,18 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml = _create_hpxml('base-hvac-room-ac-only.xml')
     hpxml.cooling_systems[0].cooling_shr = 0.88
     hpxml.cooling_systems[0].cooling_capacity = 12345
+    hpxml.cooling_systems[0].crankcase_heater_watts = 40.0
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_room_air_conditioner_ptac_values(hpxml_default.cooling_systems[0], 0.88, 12345)
+    _test_default_room_air_conditioner_ptac_values(hpxml_default.cooling_systems[0], 0.88, 12345, 40.0)
 
     # Test defaults
     hpxml.cooling_systems[0].cooling_shr = nil
     hpxml.cooling_systems[0].cooling_capacity = nil
+    hpxml.cooling_systems[0].crankcase_heater_watts = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_room_air_conditioner_ptac_values(hpxml_default.cooling_systems[0], 0.65, nil)
+    _test_default_room_air_conditioner_ptac_values(hpxml_default.cooling_systems[0], 0.65, nil, 0.0)
   end
 
   def test_evaporative_coolers
@@ -1107,9 +1191,10 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.cooling_systems[0].charge_defect_ratio = -0.11
     hpxml.cooling_systems[0].airflow_defect_ratio = -0.22
     hpxml.cooling_systems[0].cooling_capacity = 12345
+    hpxml.cooling_systems[0].crankcase_heater_watts = 40.0
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_mini_split_air_conditioner_values(hpxml_default.cooling_systems[0], 0.78, 0.66, -0.11, -0.22, 12345, 19.0)
+    _test_default_mini_split_air_conditioner_values(hpxml_default.cooling_systems[0], 0.78, 0.66, -0.11, -0.22, 12345, 19.0, 40.0)
 
     # Test defaults
     hpxml.cooling_systems[0].cooling_shr = nil
@@ -1117,22 +1202,23 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.cooling_systems[0].charge_defect_ratio = nil
     hpxml.cooling_systems[0].airflow_defect_ratio = nil
     hpxml.cooling_systems[0].cooling_capacity = nil
+    hpxml.cooling_systems[0].crankcase_heater_watts = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_mini_split_air_conditioner_values(hpxml_default.cooling_systems[0], 0.73, 0.18, 0, 0, nil, 19.0)
+    _test_default_mini_split_air_conditioner_values(hpxml_default.cooling_systems[0], 0.73, 0.18, 0, 0, nil, 19.0, 50.0)
 
     # Test defaults w/ ductless
     hpxml.cooling_systems[0].distribution_system.delete
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_mini_split_air_conditioner_values(hpxml_default.cooling_systems[0], 0.73, 0.07, 0, 0, nil, 19.0)
+    _test_default_mini_split_air_conditioner_values(hpxml_default.cooling_systems[0], 0.73, 0.07, 0, 0, nil, 19.0, 50.0)
 
     # Test defaults w/ ductless - SEER2
     hpxml.cooling_systems[0].cooling_efficiency_seer = nil
     hpxml.cooling_systems[0].cooling_efficiency_seer2 = 13.3
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_mini_split_air_conditioner_values(hpxml_default.cooling_systems[0], 0.73, 0.07, 0, 0, nil, 13.3)
+    _test_default_mini_split_air_conditioner_values(hpxml_default.cooling_systems[0], 0.73, 0.07, 0, 0, nil, 13.3, 50.0)
   end
 
   def test_ptac
@@ -1140,16 +1226,18 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml = _create_hpxml('base-hvac-ptac-with-heating-electricity.xml')
     hpxml.cooling_systems[0].cooling_shr = 0.75
     hpxml.cooling_systems[0].cooling_capacity = 12345
+    hpxml.cooling_systems[0].crankcase_heater_watts = 40.0
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_room_air_conditioner_ptac_values(hpxml_default.cooling_systems[0], 0.75, 12345)
+    _test_default_room_air_conditioner_ptac_values(hpxml_default.cooling_systems[0], 0.75, 12345, 40.0)
 
     # Test defaults
     hpxml.cooling_systems[0].cooling_shr = nil
     hpxml.cooling_systems[0].cooling_capacity = nil
+    hpxml.cooling_systems[0].crankcase_heater_watts = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_room_air_conditioner_ptac_values(hpxml_default.cooling_systems[0], 0.65, nil)
+    _test_default_room_air_conditioner_ptac_values(hpxml_default.cooling_systems[0], 0.65, nil, 0.0)
   end
 
   def test_furnaces
@@ -1158,17 +1246,26 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.heating_systems[0].fan_watts_per_cfm = 0.66
     hpxml.heating_systems[0].airflow_defect_ratio = -0.22
     hpxml.heating_systems[0].heating_capacity = 12345
+    hpxml.heating_systems[0].pilot_light = true
+    hpxml.heating_systems[0].pilot_light_btuh = 999
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_furnace_values(hpxml_default.heating_systems[0], 0.66, -0.22, 12345)
+    _test_default_furnace_values(hpxml_default.heating_systems[0], 0.66, -0.22, 12345, true, 999)
 
     # Test defaults
     hpxml.heating_systems[0].fan_watts_per_cfm = nil
     hpxml.heating_systems[0].airflow_defect_ratio = nil
     hpxml.heating_systems[0].heating_capacity = nil
+    hpxml.heating_systems[0].pilot_light_btuh = nil
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_furnace_values(hpxml_default.heating_systems[0], 0.375, 0, nil, true, 500)
+
+    # Test defaults w/o pilot
+    hpxml.heating_systems[0].pilot_light = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_furnace_values(hpxml_default.heating_systems[0], 0.375, 0, nil)
+    _test_default_furnace_values(hpxml_default.heating_systems[0], 0.375, 0, nil, false, nil)
 
     # Test defaults w/ gravity distribution system
     hpxml = _create_hpxml('base-hvac-furnace-gas-only.xml')
@@ -1178,7 +1275,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.heating_systems[0].heating_capacity = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_furnace_values(hpxml_default.heating_systems[0], 0.0, 0, nil)
+    _test_default_furnace_values(hpxml_default.heating_systems[0], 0.0, 0, nil, false, nil)
   end
 
   def test_wall_furnaces
@@ -1196,6 +1293,11 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
     _test_default_wall_furnace_values(hpxml_default.heating_systems[0], 0, nil)
+
+    # Test defaults w/o pilot
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_wall_furnace_values(hpxml_default.heating_systems[0], 0, nil)
   end
 
   def test_floor_furnaces
@@ -1203,15 +1305,24 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml = _create_hpxml('base-hvac-floor-furnace-propane-only.xml')
     hpxml.heating_systems[0].fan_watts = 22
     hpxml.heating_systems[0].heating_capacity = 12345
+    hpxml.heating_systems[0].pilot_light = true
+    hpxml.heating_systems[0].pilot_light_btuh = 999
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_floor_furnace_values(hpxml_default.heating_systems[0], 22, 12345)
+    _test_default_floor_furnace_values(hpxml_default.heating_systems[0], 22, 12345, true, 999)
 
     # Test defaults
     hpxml.heating_systems[0].fan_watts = nil
+    hpxml.heating_systems[0].pilot_light_btuh = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_floor_furnace_values(hpxml_default.heating_systems[0], 0, nil)
+    _test_default_floor_furnace_values(hpxml_default.heating_systems[0], 0, nil, true, 500)
+
+    # Test defaults w/o pilot
+    hpxml.heating_systems[0].pilot_light = nil
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_floor_furnace_values(hpxml_default.heating_systems[0], 0, nil, false, nil)
   end
 
   def test_boilers
@@ -1219,16 +1330,19 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml = _create_hpxml('base-hvac-boiler-gas-only.xml')
     hpxml.heating_systems[0].electric_auxiliary_energy = 99.9
     hpxml.heating_systems[0].heating_capacity = 12345
+    hpxml.heating_systems[0].pilot_light = true
+    hpxml.heating_systems[0].pilot_light_btuh = 999
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_boiler_values(hpxml_default.heating_systems[0], 99.9, 12345)
+    _test_default_boiler_values(hpxml_default.heating_systems[0], 99.9, 12345, true, 999)
 
     # Test defaults w/ in-unit boiler
     hpxml.heating_systems[0].electric_auxiliary_energy = nil
     hpxml.heating_systems[0].heating_capacity = nil
+    hpxml.heating_systems[0].pilot_light_btuh = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_boiler_values(hpxml_default.heating_systems[0], 170.0, nil)
+    _test_default_boiler_values(hpxml_default.heating_systems[0], 170.0, nil, true, 500)
 
     # Test inputs not overridden by defaults (shared boiler)
     hpxml = _create_hpxml('base-bldgtype-multifamily-shared-boiler-only-baseboard.xml')
@@ -1236,13 +1350,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.heating_systems[0].electric_auxiliary_energy = 99.9
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_boiler_values(hpxml_default.heating_systems[0], 99.9, nil)
-
-    # Test defaults w/ shared boiler
-    hpxml.heating_systems[0].electric_auxiliary_energy = nil
-    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
-    hpxml_default = _test_measure()
-    _test_default_boiler_values(hpxml_default.heating_systems[0], 220.0, nil)
+    _test_default_boiler_values(hpxml_default.heating_systems[0], 99.9, nil, false, nil)
   end
 
   def test_stoves
@@ -1250,16 +1358,25 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml = _create_hpxml('base-hvac-stove-oil-only.xml')
     hpxml.heating_systems[0].fan_watts = 22
     hpxml.heating_systems[0].heating_capacity = 12345
+    hpxml.heating_systems[0].pilot_light = true
+    hpxml.heating_systems[0].pilot_light_btuh = 999
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_stove_values(hpxml_default.heating_systems[0], 22, 12345)
+    _test_default_stove_values(hpxml_default.heating_systems[0], 22, 12345, true, 999)
 
     # Test defaults
     hpxml.heating_systems[0].fan_watts = nil
     hpxml.heating_systems[0].heating_capacity = nil
+    hpxml.heating_systems[0].pilot_light_btuh = nil
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_stove_values(hpxml_default.heating_systems[0], 40, nil, true, 500)
+
+    # Test defaults w/o pilot
+    hpxml.heating_systems[0].pilot_light = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_stove_values(hpxml_default.heating_systems[0], 40, nil)
+    _test_default_stove_values(hpxml_default.heating_systems[0], 40, nil, false, nil)
   end
 
   def test_portable_heaters
@@ -1301,16 +1418,25 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml = _create_hpxml('base-hvac-fireplace-wood-only.xml')
     hpxml.heating_systems[0].fan_watts = 22
     hpxml.heating_systems[0].heating_capacity = 12345
+    hpxml.heating_systems[0].pilot_light = true
+    hpxml.heating_systems[0].pilot_light_btuh = 999
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_fireplace_values(hpxml_default.heating_systems[0], 22, 12345)
+    _test_default_fireplace_values(hpxml_default.heating_systems[0], 22, 12345, true, 999)
 
     # Test defaults
     hpxml.heating_systems[0].fan_watts = nil
     hpxml.heating_systems[0].heating_capacity = nil
+    hpxml.heating_systems[0].pilot_light_btuh = nil
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_fireplace_values(hpxml_default.heating_systems[0], 0, nil, true, 500)
+
+    # Test defaults w/o pilot
+    hpxml.heating_systems[0].pilot_light = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_fireplace_values(hpxml_default.heating_systems[0], 0, nil)
+    _test_default_fireplace_values(hpxml_default.heating_systems[0], 0, nil, false, nil)
   end
 
   def test_air_source_heat_pumps
@@ -1323,14 +1449,23 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.heat_pumps[0].airflow_defect_ratio = -0.22
     hpxml.heat_pumps[0].cooling_capacity = 12345
     hpxml.heat_pumps[0].heating_capacity = 23456
-    hpxml.heat_pumps[0].heating_capacity_17F = 9876
     hpxml.heat_pumps[0].backup_heating_capacity = 34567
     hpxml.heat_pumps[0].cooling_efficiency_seer = 14.0
     hpxml.heat_pumps[0].heating_efficiency_hspf = 8.0
-    hpxml.heat_pumps[0].backup_heating_lockout_temp = 20.0
+    hpxml.heat_pumps[0].heating_capacity_retention_fraction = 0.1
+    hpxml.heat_pumps[0].heating_capacity_retention_temp = 2.0
+    hpxml.heat_pumps[0].crankcase_heater_watts = 40.0
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_air_to_air_heat_pump_values(hpxml_default.heat_pumps[0], 0.88, HPXML::HVACCompressorTypeVariableSpeed, 0.66, -0.11, -0.22, 12345, 23456, 9876, 34567, 14.0, 8.0, 20.0)
+    _test_default_air_to_air_heat_pump_values(hpxml_default.heat_pumps[0], 0.88, HPXML::HVACCompressorTypeVariableSpeed, 0.66, -0.11, -0.22, 12345, 23456, nil, 34567, 14.0, 8.0, 0.1, 2.0, 40.0)
+
+    # Test w/ heating capacity 17F
+    hpxml.heat_pumps[0].heating_capacity_17F = 9876
+    hpxml.heat_pumps[0].heating_capacity_retention_fraction = nil
+    hpxml.heat_pumps[0].heating_capacity_retention_temp = nil
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_air_to_air_heat_pump_values(hpxml_default.heat_pumps[0], 0.88, HPXML::HVACCompressorTypeVariableSpeed, 0.66, -0.11, -0.22, 12345, 23456, 9876, 34567, 14.0, 8.0, nil, nil, 40.0)
 
     # Test defaults - SEER2/HSPF2
     hpxml.heat_pumps[0].cooling_efficiency_seer = nil
@@ -1339,7 +1474,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.heat_pumps[0].heating_efficiency_hspf2 = 6.8
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_air_to_air_heat_pump_values(hpxml_default.heat_pumps[0], 0.88, HPXML::HVACCompressorTypeVariableSpeed, 0.66, -0.11, -0.22, 12345, 23456, 9876, 34567, 14.0, 8.0, 20.0)
+    _test_default_air_to_air_heat_pump_values(hpxml_default.heat_pumps[0], 0.88, HPXML::HVACCompressorTypeVariableSpeed, 0.66, -0.11, -0.22, 12345, 23456, 9876, 34567, 14.0, 8.0, nil, nil, 40.0)
 
     # Test defaults
     hpxml.heat_pumps[0].cooling_shr = nil
@@ -1351,10 +1486,10 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.heat_pumps[0].heating_capacity = nil
     hpxml.heat_pumps[0].heating_capacity_17F = nil
     hpxml.heat_pumps[0].backup_heating_capacity = nil
-    hpxml.heat_pumps[0].backup_heating_lockout_temp = nil
+    hpxml.heat_pumps[0].crankcase_heater_watts = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_air_to_air_heat_pump_values(hpxml_default.heat_pumps[0], 0.73, HPXML::HVACCompressorTypeSingleStage, 0.5, 0, 0, nil, nil, nil, nil, 14.0, 8.0, 40.0)
+    _test_default_air_to_air_heat_pump_values(hpxml_default.heat_pumps[0], 0.73, HPXML::HVACCompressorTypeSingleStage, 0.5, 0, 0, nil, nil, nil, nil, 14.0, 8.0, 0.425, 5.0, 50.0)
   end
 
   def test_pthp
@@ -1363,20 +1498,31 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.heat_pumps[0].cooling_shr = 0.88
     hpxml.heat_pumps[0].cooling_capacity = 12345
     hpxml.heat_pumps[0].heating_capacity = 23456
-    hpxml.heat_pumps[0].backup_heating_lockout_temp = 20.0
+    hpxml.heat_pumps[0].heating_capacity_retention_fraction = 0.1
+    hpxml.heat_pumps[0].heating_capacity_retention_temp = 2.0
+    hpxml.heat_pumps[0].crankcase_heater_watts = 40.0
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_pthp_values(hpxml_default.heat_pumps[0], 0.88, 12345, 23456, 20.0)
+    _test_default_pthp_values(hpxml_default.heat_pumps[0], 0.88, 12345, 23456, nil, 0.1, 2.0, 40.0)
+
+    # Test w/ heating capacity 17F
+    hpxml.heat_pumps[0].heating_capacity_17F = 9876
+    hpxml.heat_pumps[0].heating_capacity_retention_fraction = nil
+    hpxml.heat_pumps[0].heating_capacity_retention_temp = nil
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_pthp_values(hpxml_default.heat_pumps[0], 0.88, 12345, 23456, 9876, nil, nil, 40.0)
 
     # Test defaults
     hpxml.heat_pumps[0].cooling_shr = nil
     hpxml.heat_pumps[0].cooling_capacity = nil
     hpxml.heat_pumps[0].heating_capacity = nil
     hpxml.heat_pumps[0].backup_heating_capacity = nil
-    hpxml.heat_pumps[0].backup_heating_lockout_temp = nil
+    hpxml.heat_pumps[0].heating_capacity_17F = nil
+    hpxml.heat_pumps[0].crankcase_heater_watts = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_pthp_values(hpxml_default.heat_pumps[0], 0.65, nil, nil, 40.0)
+    _test_default_pthp_values(hpxml_default.heat_pumps[0], 0.65, nil, nil, nil, 0.425, 5.0, 0.0)
   end
 
   def test_mini_split_heat_pumps
@@ -1388,12 +1534,21 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.heat_pumps[0].airflow_defect_ratio = -0.22
     hpxml.heat_pumps[0].cooling_capacity = 12345
     hpxml.heat_pumps[0].heating_capacity = 23456
-    hpxml.heat_pumps[0].heating_capacity_17F = 9876
     hpxml.heat_pumps[0].backup_heating_capacity = 34567
-    hpxml.heat_pumps[0].backup_heating_lockout_temp = 20.0
+    hpxml.heat_pumps[0].heating_capacity_retention_fraction = 0.1
+    hpxml.heat_pumps[0].heating_capacity_retention_temp = 2.0
+    hpxml.heat_pumps[0].crankcase_heater_watts = 40.0
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_mini_split_heat_pump_values(hpxml_default.heat_pumps[0], 0.78, 0.66, -0.11, -0.22, 12345, 23456, 9876, 34567, 19.0, 10.0, 20.0)
+    _test_default_mini_split_heat_pump_values(hpxml_default.heat_pumps[0], 0.78, 0.66, -0.11, -0.22, 12345, 23456, nil, 34567, 19.0, 10.0, 0.1, 2.0, 40.0)
+
+    # Test w/ heating capacity 17F
+    hpxml.heat_pumps[0].heating_capacity_17F = 9876
+    hpxml.heat_pumps[0].heating_capacity_retention_fraction = nil
+    hpxml.heat_pumps[0].heating_capacity_retention_temp = nil
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_mini_split_heat_pump_values(hpxml_default.heat_pumps[0], 0.78, 0.66, -0.11, -0.22, 12345, 23456, 9876, 34567, 19.0, 10.0, nil, nil, 40.0)
 
     # Test defaults
     hpxml.heat_pumps[0].cooling_shr = nil
@@ -1404,16 +1559,16 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.heat_pumps[0].heating_capacity = nil
     hpxml.heat_pumps[0].heating_capacity_17F = nil
     hpxml.heat_pumps[0].backup_heating_capacity = nil
-    hpxml.heat_pumps[0].backup_heating_lockout_temp = nil
+    hpxml.heat_pumps[0].crankcase_heater_watts = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_mini_split_heat_pump_values(hpxml_default.heat_pumps[0], 0.73, 0.18, 0, 0, nil, nil, nil, nil, 19.0, 10.0, 40.0)
+    _test_default_mini_split_heat_pump_values(hpxml_default.heat_pumps[0], 0.73, 0.18, 0, 0, nil, nil, nil, nil, 19.0, 10.0, 0.5, 5.0, 50.0)
 
-    # Test defaults w/ ductless
+    # Test defaults w/ ductless and no backup
     hpxml.heat_pumps[0].distribution_system.delete
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_mini_split_heat_pump_values(hpxml_default.heat_pumps[0], 0.73, 0.07, 0, 0, nil, nil, nil, nil, 19.0, 10.0, 40.0)
+    _test_default_mini_split_heat_pump_values(hpxml_default.heat_pumps[0], 0.73, 0.07, 0, 0, nil, nil, nil, nil, 19.0, 10.0, 0.5, 5.0, 50.0)
 
     # Test defaults w/ ductless - SEER2/HSPF2
     hpxml.heat_pumps[0].cooling_efficiency_seer = nil
@@ -1422,7 +1577,78 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.heat_pumps[0].heating_efficiency_hspf2 = 6.8
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_mini_split_heat_pump_values(hpxml_default.heat_pumps[0], 0.73, 0.07, 0, 0, nil, nil, nil, nil, 13.3, 7.56, 40.0)
+    _test_default_mini_split_heat_pump_values(hpxml_default.heat_pumps[0], 0.73, 0.07, 0, 0, nil, nil, nil, nil, 13.3, 7.56, 0.5, 5.0, 50.0)
+  end
+
+  def test_heat_pump_temperatures
+    # Test inputs not overridden by defaults - ASHP w/ electric backup
+    hpxml = _create_hpxml('base-hvac-air-to-air-heat-pump-1-speed.xml')
+    hpxml.heat_pumps[0].compressor_lockout_temp = -2.0
+    hpxml.heat_pumps[0].backup_heating_lockout_temp = 44.0
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_heat_pump_temperature_values(hpxml_default.heat_pumps[0], -2.0, 44.0, nil)
+
+    # Test defaults
+    hpxml.heat_pumps[0].compressor_lockout_temp = nil
+    hpxml.heat_pumps[0].backup_heating_lockout_temp = nil
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_heat_pump_temperature_values(hpxml_default.heat_pumps[0], 0.0, 40.0, nil)
+
+    # Test inputs not overridden by defaults - MSHP w/o backup
+    hpxml = _create_hpxml('base-hvac-mini-split-heat-pump-ductless.xml')
+    hpxml.heat_pumps[0].compressor_lockout_temp = 33.0
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_heat_pump_temperature_values(hpxml_default.heat_pumps[0], 33.0, nil, nil)
+
+    # Test defaults
+    hpxml.heat_pumps[0].compressor_lockout_temp = nil
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_heat_pump_temperature_values(hpxml_default.heat_pumps[0], -20.0, nil, nil)
+
+    # Test inputs not overridden by defaults - MSHP w/ electric backup
+    hpxml = _create_hpxml('base-hvac-mini-split-heat-pump-ductless-backup-baseboard.xml')
+    hpxml.heat_pumps[0].compressor_lockout_temp = -2.0
+    hpxml.heat_pumps[0].backup_heating_lockout_temp = 44.0
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_heat_pump_temperature_values(hpxml_default.heat_pumps[0], -2.0, 44.0, nil)
+
+    # Test defaults
+    hpxml.heat_pumps[0].compressor_lockout_temp = nil
+    hpxml.heat_pumps[0].backup_heating_lockout_temp = nil
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_heat_pump_temperature_values(hpxml_default.heat_pumps[0], -20.0, 40.0, nil)
+
+    # Test inputs not overridden by defaults - HP w/ fuel backup
+    ['base-hvac-dual-fuel-air-to-air-heat-pump-1-speed.xml',
+     'base-hvac-air-to-air-heat-pump-var-speed-backup-boiler.xml',
+     'base-hvac-mini-split-heat-pump-ductless-backup-stove.xml'].each do |hpxml_name|
+      hpxml = _create_hpxml(hpxml_name)
+      hpxml.heat_pumps[0].backup_heating_switchover_temp = 33.0
+      XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+      hpxml_default = _test_measure()
+      _test_default_heat_pump_temperature_values(hpxml_default.heat_pumps[0], nil, nil, 33.0)
+
+      # Test inputs not overridden by defaults - HP w/ integrated/separate fuel backup, lockout temps
+      hpxml.heat_pumps[0].backup_heating_switchover_temp = nil
+      hpxml.heat_pumps[0].compressor_lockout_temp = 22.0
+      hpxml.heat_pumps[0].backup_heating_lockout_temp = 44.0
+      XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+      hpxml_default = _test_measure()
+      _test_default_heat_pump_temperature_values(hpxml_default.heat_pumps[0], 22.0, 44.0, nil)
+
+      # Test defaults
+      hpxml.heat_pumps[0].compressor_lockout_temp = nil
+      hpxml.heat_pumps[0].backup_heating_lockout_temp = nil
+      XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+      hpxml_default = _test_measure()
+      _test_default_heat_pump_temperature_values(hpxml_default.heat_pumps[0], 25.0, 50.0, nil)
+    end
   end
 
   def test_ground_source_heat_pumps
@@ -1450,33 +1676,67 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     _test_default_ground_to_air_heat_pump_values(hpxml_default.heat_pumps[0], 30.0, 0.375, 0, nil, nil, nil)
   end
 
-  def test_hvac_increased_hardsized_equipment
-    # Test hard-sized capacities are increased for air conditioner + furnace
-    hpxml = _create_hpxml('base-hvac-undersized-allow-increased-fixed-capacities.xml')
-    htg_cap = hpxml.heating_systems[0].heating_capacity
-    clg_cap = hpxml.cooling_systems[0].cooling_capacity
+  def test_hvac_location
+    # Test inputs not overridden by defaults
+    hpxml = _create_hpxml('base-foundation-unconditioned-basement.xml')
+    hpxml.heating_systems[0].location = HPXML::LocationAtticUnvented
+    hpxml.cooling_systems[0].delete
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    assert(hpxml_default.heating_systems[0].heating_capacity > htg_cap)
-    assert(hpxml_default.cooling_systems[0].cooling_capacity > clg_cap)
+    _test_default_hvac_location_values(hpxml_default.heating_systems[0], HPXML::LocationAtticUnvented)
 
-    # Test hard-sized capacities are increased for heat pump
-    hpxml = _create_hpxml('base-hvac-air-to-air-heat-pump-1-speed.xml')
-    hpxml.header.allow_increased_fixed_capacities = true
-    hpxml.heat_pumps[0].heating_capacity /= 10.0
-    hpxml.heat_pumps[0].heating_capacity_17F /= 10.0
-    hpxml.heat_pumps[0].backup_heating_capacity /= 10.0
-    hpxml.heat_pumps[0].cooling_capacity /= 10.0
-    htg_cap = hpxml.heat_pumps[0].heating_capacity
-    htg_17f_cap = hpxml.heat_pumps[0].heating_capacity_17F
-    htg_bak_cap = hpxml.heat_pumps[0].backup_heating_capacity
-    clg_cap = hpxml.heat_pumps[0].cooling_capacity
+    # Test defaults
+    hpxml.heating_systems[0].location = nil
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_hvac_location_values(hpxml_default.heating_systems[0], HPXML::LocationBasementUnconditioned)
+
+    # Test defaults -- multiple duct locations
+    hpxml.heating_systems[0].distribution_system.ducts.add(id: "Ducts#{hpxml.heating_systems[0].distribution_system.ducts.size + 1}",
+                                                           duct_type: HPXML::DuctTypeSupply,
+                                                           duct_insulation_r_value: 0,
+                                                           duct_location: HPXML::LocationAtticUnvented,
+                                                           duct_surface_area: 151)
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_hvac_location_values(hpxml_default.heating_systems[0], HPXML::LocationAtticUnvented)
+
+    # Test defaults -- ducts outside
+    hpxml.heating_systems[0].distribution_system.ducts.each do |d|
+      d.duct_location = HPXML::LocationOutside
+    end
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_hvac_location_values(hpxml_default.heating_systems[0], HPXML::LocationOtherExterior)
+
+    # Test defaults -- hydronic
+    hpxml.heating_systems[0].heating_system_type = HPXML::HVACTypeBoiler
+    hpxml.heating_systems[0].distribution_system.distribution_system_type = HPXML::HVACDistributionTypeHydronic
+    hpxml.heating_systems[0].distribution_system.hydronic_type = HPXML::HydronicTypeBaseboard
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_hvac_location_values(hpxml_default.heating_systems[0], HPXML::LocationBasementUnconditioned)
+
+    # Test defaults -- DSE = 1
+    hpxml.heating_systems[0].distribution_system.distribution_system_type = HPXML::HVACDistributionTypeDSE
+    hpxml.heating_systems[0].distribution_system.annual_heating_dse = 1.0
+    hpxml.heating_systems[0].distribution_system.annual_cooling_dse = 0.5
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_hvac_location_values(hpxml_default.heating_systems[0], HPXML::LocationLivingSpace)
+
+    # Test defaults -- DSE < 1
+    hpxml.heating_systems[0].distribution_system.annual_heating_dse = 0.8
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_hvac_location_values(hpxml_default.heating_systems[0], HPXML::LocationUnconditionedSpace)
+
+    # Test defaults -- ductless
+    hpxml.heating_systems[0].heating_system_type = HPXML::HVACTypeWallFurnace
+    hpxml.heating_systems[0].distribution_system.delete
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    assert(hpxml_default.heat_pumps[0].heating_capacity > htg_cap)
-    assert(hpxml_default.heat_pumps[0].heating_capacity_17F > htg_17f_cap)
-    assert(hpxml_default.heat_pumps[0].backup_heating_capacity > htg_bak_cap)
-    assert(hpxml_default.heat_pumps[0].cooling_capacity > clg_cap)
+    _test_default_hvac_location_values(hpxml_default.heating_systems[0], HPXML::LocationLivingSpace)
   end
 
   def test_hvac_controls
@@ -1536,6 +1796,12 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.hvac_distributions[0].number_of_return_registers = 2
     hpxml.hvac_distributions[0].ducts[0].duct_surface_area_multiplier = 0.5
     hpxml.hvac_distributions[0].ducts[1].duct_surface_area_multiplier = 1.5
+    hpxml.hvac_distributions[0].ducts[0].duct_buried_insulation_level = HPXML::DuctBuriedInsulationPartial
+    hpxml.hvac_distributions[0].ducts[1].duct_buried_insulation_level = HPXML::DuctBuriedInsulationDeep
+    hpxml.hvac_distributions[0].ducts[0].duct_insulation_r_value = nil
+    hpxml.hvac_distributions[0].ducts[1].duct_insulation_r_value = nil
+    hpxml.hvac_distributions[0].ducts[0].duct_effective_r_value = 1.23
+    hpxml.hvac_distributions[0].ducts[1].duct_effective_r_value = 3.21
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
     expected_supply_locations = ['attic - unvented']
@@ -1546,9 +1812,14 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     expected_return_fracs = [1.0]
     expected_supply_area_mults = [0.5]
     expected_return_area_mults = [1.5]
+    expected_supply_effective_rvalues = [1.23]
+    expected_return_effective_rvalues = [3.21]
+    expected_supply_buried_levels = [HPXML::DuctBuriedInsulationPartial]
+    expected_return_buried_levels = [HPXML::DuctBuriedInsulationDeep]
     expected_n_return_registers = hpxml_default.building_construction.number_of_conditioned_floors
     _test_default_duct_values(hpxml_default, expected_supply_locations, expected_return_locations, expected_supply_areas, expected_return_areas,
-                              expected_supply_fracs, expected_return_fracs, expected_n_return_registers, expected_supply_area_mults, expected_return_area_mults)
+                              expected_supply_fracs, expected_return_fracs, expected_n_return_registers, expected_supply_area_mults, expected_return_area_mults,
+                              expected_supply_buried_levels, expected_return_buried_levels, expected_supply_effective_rvalues, expected_return_effective_rvalues)
 
     # Test defaults w/ conditioned basement
     hpxml.hvac_distributions[0].number_of_return_registers = nil
@@ -1556,7 +1827,11 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
       duct.duct_location = nil
       duct.duct_surface_area = nil
       duct.duct_surface_area_multiplier = nil
+      duct.duct_buried_insulation_level = nil
+      duct.duct_effective_r_value = nil
     end
+    hpxml.hvac_distributions[0].ducts[0].duct_insulation_r_value = 4
+    hpxml.hvac_distributions[0].ducts[1].duct_insulation_r_value = 0
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
     expected_supply_locations = ['basement - conditioned']
@@ -1567,9 +1842,14 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     expected_return_fracs = [1.0]
     expected_supply_area_mults = [1.0]
     expected_return_area_mults = [1.0]
+    expected_supply_buried_levels = [HPXML::DuctBuriedInsulationNone]
+    expected_return_buried_levels = [HPXML::DuctBuriedInsulationNone]
+    expected_supply_effective_rvalues = [4.5]
+    expected_return_effective_rvalues = [1.7]
     expected_n_return_registers = hpxml_default.building_construction.number_of_conditioned_floors
     _test_default_duct_values(hpxml_default, expected_supply_locations, expected_return_locations, expected_supply_areas, expected_return_areas,
-                              expected_supply_fracs, expected_return_fracs, expected_n_return_registers, expected_supply_area_mults, expected_return_area_mults)
+                              expected_supply_fracs, expected_return_fracs, expected_n_return_registers, expected_supply_area_mults, expected_return_area_mults,
+                              expected_supply_buried_levels, expected_return_buried_levels, expected_supply_effective_rvalues, expected_return_effective_rvalues)
 
     # Test defaults w/ multiple foundations
     hpxml = _create_hpxml('base-foundation-multiple.xml')
@@ -1579,6 +1859,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
       duct.duct_location = nil
       duct.duct_surface_area = nil
       duct.duct_surface_area_multiplier = nil
+      duct.duct_buried_insulation_level = nil
     end
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
@@ -1590,9 +1871,14 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     expected_return_fracs = [1.0]
     expected_supply_area_mults = [1.0]
     expected_return_area_mults = [1.0]
+    expected_supply_effective_rvalues = [4.5]
+    expected_return_effective_rvalues = [1.7]
+    expected_supply_buried_levels = [HPXML::DuctBuriedInsulationNone]
+    expected_return_buried_levels = [HPXML::DuctBuriedInsulationNone]
     expected_n_return_registers = hpxml_default.building_construction.number_of_conditioned_floors
     _test_default_duct_values(hpxml_default, expected_supply_locations, expected_return_locations, expected_supply_areas, expected_return_areas,
-                              expected_supply_fracs, expected_return_fracs, expected_n_return_registers, expected_supply_area_mults, expected_return_area_mults)
+                              expected_supply_fracs, expected_return_fracs, expected_n_return_registers, expected_supply_area_mults, expected_return_area_mults,
+                              expected_supply_buried_levels, expected_return_buried_levels, expected_supply_effective_rvalues, expected_return_effective_rvalues)
 
     # Test defaults w/ foundation exposed to ambient
     hpxml = _create_hpxml('base-foundation-ambient.xml')
@@ -1602,6 +1888,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
       duct.duct_location = nil
       duct.duct_surface_area = nil
       duct.duct_surface_area_multiplier = nil
+      duct.duct_buried_insulation_level = nil
     end
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
@@ -1613,9 +1900,14 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     expected_return_fracs = [1.0]
     expected_supply_area_mults = [1.0]
     expected_return_area_mults = [1.0]
+    expected_supply_effective_rvalues = [4.5]
+    expected_return_effective_rvalues = [1.7]
+    expected_supply_buried_levels = [HPXML::DuctBuriedInsulationNone]
+    expected_return_buried_levels = [HPXML::DuctBuriedInsulationNone]
     expected_n_return_registers = hpxml_default.building_construction.number_of_conditioned_floors
     _test_default_duct_values(hpxml_default, expected_supply_locations, expected_return_locations, expected_supply_areas, expected_return_areas,
-                              expected_supply_fracs, expected_return_fracs, expected_n_return_registers, expected_supply_area_mults, expected_return_area_mults)
+                              expected_supply_fracs, expected_return_fracs, expected_n_return_registers, expected_supply_area_mults, expected_return_area_mults,
+                              expected_supply_buried_levels, expected_return_buried_levels, expected_supply_effective_rvalues, expected_return_effective_rvalues)
 
     # Test defaults w/ building/unit adjacent to other housing unit
     hpxml = _create_hpxml('base-bldgtype-multifamily-adjacent-to-other-housing-unit.xml')
@@ -1625,6 +1917,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
       duct.duct_location = nil
       duct.duct_surface_area = nil
       duct.duct_surface_area_multiplier = nil
+      duct.duct_buried_insulation_level = nil
     end
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
@@ -1636,9 +1929,14 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     expected_return_fracs = [1.0]
     expected_supply_area_mults = [1.0]
     expected_return_area_mults = [1.0]
+    expected_supply_effective_rvalues = [1.7]
+    expected_return_effective_rvalues = [1.7]
+    expected_supply_buried_levels = [HPXML::DuctBuriedInsulationNone]
+    expected_return_buried_levels = [HPXML::DuctBuriedInsulationNone]
     expected_n_return_registers = hpxml_default.building_construction.number_of_conditioned_floors
     _test_default_duct_values(hpxml_default, expected_supply_locations, expected_return_locations, expected_supply_areas, expected_return_areas,
-                              expected_supply_fracs, expected_return_fracs, expected_n_return_registers, expected_supply_area_mults, expected_return_area_mults)
+                              expected_supply_fracs, expected_return_fracs, expected_n_return_registers, expected_supply_area_mults, expected_return_area_mults,
+                              expected_supply_buried_levels, expected_return_buried_levels, expected_supply_effective_rvalues, expected_return_effective_rvalues)
 
     # Test defaults w/ 2-story building
     hpxml = _create_hpxml('base-enclosure-2stories.xml')
@@ -1648,6 +1946,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
       duct.duct_location = nil
       duct.duct_surface_area = nil
       duct.duct_surface_area_multiplier = nil
+      duct.duct_buried_insulation_level = nil
     end
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
@@ -1659,9 +1958,14 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     expected_return_fracs = [0.375, 0.375, 0.125, 0.125]
     expected_supply_area_mults = [1.0, 1.0, 1.0, 1.0]
     expected_return_area_mults = [1.0, 1.0, 1.0, 1.0]
+    expected_supply_buried_levels = [HPXML::DuctBuriedInsulationNone] * 4
+    expected_return_buried_levels = [HPXML::DuctBuriedInsulationNone] * 4
+    expected_supply_effective_rvalues = [4.5] * 4
+    expected_return_effective_rvalues = [1.7] * 4
     expected_n_return_registers = hpxml_default.building_construction.number_of_conditioned_floors
     _test_default_duct_values(hpxml_default, expected_supply_locations, expected_return_locations, expected_supply_areas, expected_return_areas,
-                              expected_supply_fracs, expected_return_fracs, expected_n_return_registers, expected_supply_area_mults, expected_return_area_mults)
+                              expected_supply_fracs, expected_return_fracs, expected_n_return_registers, expected_supply_area_mults, expected_return_area_mults,
+                              expected_supply_buried_levels, expected_return_buried_levels, expected_supply_effective_rvalues, expected_return_effective_rvalues)
 
     # Test defaults w/ 1-story building & multiple HVAC systems
     hpxml = _create_hpxml('base-hvac-multiple.xml')
@@ -1674,6 +1978,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
         duct.duct_location = nil
         duct.duct_surface_area = nil
         duct.duct_surface_area_multiplier = nil
+        duct.duct_buried_insulation_level = nil
       end
     end
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
@@ -1686,9 +1991,14 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     expected_return_fracs = [0.5, 0.5] * hpxml_default.hvac_distributions.size
     expected_supply_area_mults = [1.0, 1.0] * hpxml_default.hvac_distributions.size
     expected_return_area_mults = [1.0, 1.0] * hpxml_default.hvac_distributions.size
+    expected_supply_buried_levels = [HPXML::DuctBuriedInsulationNone] * 2 * hpxml_default.hvac_distributions.size
+    expected_return_buried_levels = [HPXML::DuctBuriedInsulationNone] * 2 * hpxml_default.hvac_distributions.size
+    expected_supply_effective_rvalues = [6.74] * 2 * hpxml_default.hvac_distributions.size
+    expected_return_effective_rvalues = [4.86] * 2 * hpxml_default.hvac_distributions.size
     expected_n_return_registers = hpxml_default.building_construction.number_of_conditioned_floors
     _test_default_duct_values(hpxml_default, expected_supply_locations, expected_return_locations, expected_supply_areas, expected_return_areas,
-                              expected_supply_fracs, expected_return_fracs, expected_n_return_registers, expected_supply_area_mults, expected_return_area_mults)
+                              expected_supply_fracs, expected_return_fracs, expected_n_return_registers, expected_supply_area_mults, expected_return_area_mults,
+                              expected_supply_buried_levels, expected_return_buried_levels, expected_supply_effective_rvalues, expected_return_effective_rvalues)
 
     # Test defaults w/ 2-story building & multiple HVAC systems
     hpxml = _create_hpxml('base-hvac-multiple.xml')
@@ -1702,6 +2012,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
         duct.duct_location = nil
         duct.duct_surface_area = nil
         duct.duct_surface_area_multiplier = nil
+        duct.duct_buried_insulation_level = nil
       end
     end
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
@@ -1714,9 +2025,14 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     expected_return_fracs = [0.375, 0.375, 0.125, 0.125] * hpxml_default.hvac_distributions.size
     expected_supply_area_mults = [1.0, 1.0, 1.0, 1.0] * hpxml_default.hvac_distributions.size
     expected_return_area_mults = [1.0, 1.0, 1.0, 1.0] * hpxml_default.hvac_distributions.size
+    expected_supply_buried_levels = [HPXML::DuctBuriedInsulationNone] * 4 * hpxml_default.hvac_distributions.size
+    expected_return_buried_levels = [HPXML::DuctBuriedInsulationNone] * 4 * hpxml_default.hvac_distributions.size
+    expected_supply_effective_rvalues = [6.74] * 4 * hpxml_default.hvac_distributions.size
+    expected_return_effective_rvalues = [4.86] * 4 * hpxml_default.hvac_distributions.size
     expected_n_return_registers = hpxml_default.building_construction.number_of_conditioned_floors
     _test_default_duct_values(hpxml_default, expected_supply_locations, expected_return_locations, expected_supply_areas, expected_return_areas,
-                              expected_supply_fracs, expected_return_fracs, expected_n_return_registers, expected_supply_area_mults, expected_return_area_mults)
+                              expected_supply_fracs, expected_return_fracs, expected_n_return_registers, expected_supply_area_mults, expected_return_area_mults,
+                              expected_supply_buried_levels, expected_return_buried_levels, expected_supply_effective_rvalues, expected_return_effective_rvalues)
 
     # Test defaults w/ 2-story building & multiple HVAC systems & duct area fractions
     hpxml = _create_hpxml('base-hvac-multiple.xml')
@@ -1735,6 +2051,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
       hvac_distribution.ducts.each do |duct|
         duct.duct_surface_area = nil
         duct.duct_surface_area_multiplier = nil
+        duct.duct_buried_insulation_level = nil
       end
     end
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
@@ -1747,25 +2064,29 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     expected_return_fracs = [0.5, 0.5] * hpxml_default.hvac_distributions.size
     expected_supply_area_mults = [1.0, 1.0] * hpxml_default.hvac_distributions.size
     expected_return_area_mults = [1.0, 1.0] * hpxml_default.hvac_distributions.size
+    expected_supply_buried_levels = [HPXML::DuctBuriedInsulationNone] * 2 * hpxml_default.hvac_distributions.size
+    expected_return_buried_levels = [HPXML::DuctBuriedInsulationNone] * 2 * hpxml_default.hvac_distributions.size
+    expected_supply_effective_rvalues = [6.74] * 2 * hpxml_default.hvac_distributions.size
+    expected_return_effective_rvalues = [4.86] * 2 * hpxml_default.hvac_distributions.size
     expected_n_return_registers = hpxml_default.building_construction.number_of_conditioned_floors
     _test_default_duct_values(hpxml_default, expected_supply_locations, expected_return_locations, expected_supply_areas, expected_return_areas,
-                              expected_supply_fracs, expected_return_fracs, expected_n_return_registers, expected_supply_area_mults, expected_return_area_mults)
+                              expected_supply_fracs, expected_return_fracs, expected_n_return_registers, expected_supply_area_mults, expected_return_area_mults,
+                              expected_supply_buried_levels, expected_return_buried_levels, expected_supply_effective_rvalues, expected_return_effective_rvalues)
   end
 
   def test_mech_ventilation_fans
     # Test inputs not overridden by defaults w/ shared exhaust system
-    hpxml = _create_hpxml('base-mechvent-exhaust.xml')
-    hpxml.building_construction.residential_facility_type = HPXML::ResidentialTypeSFA
-    vent_fan = hpxml.ventilation_fans.select { |f| f.used_for_whole_building_ventilation }[0]
-    vent_fan.is_shared_system = true
-    vent_fan.fraction_recirculation = 0.0
-    vent_fan.in_unit_flow_rate = 10.0
-    vent_fan.hours_in_operation = 22.0
-    vent_fan.fan_power = 12.5
-    vent_fan.tested_flow_rate = nil
-    vent_fan.rated_flow_rate = nil
-    vent_fan.calculated_flow_rate = nil
-    vent_fan.delivered_ventilation = 89
+    hpxml = _create_hpxml('base-bldgtype-attached.xml')
+    hpxml.ventilation_fans.add(id: 'MechanicalVentilation',
+                               fan_type: HPXML::MechVentTypeExhaust,
+                               used_for_whole_building_ventilation: true,
+                               is_shared_system: true,
+                               fraction_recirculation: 0.0,
+                               in_unit_flow_rate: 10.0,
+                               hours_in_operation: 22.0,
+                               fan_power: 12.5,
+                               delivered_ventilation: 89)
+    vent_fan = hpxml.ventilation_fans[0]
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
     _test_default_mech_vent_values(hpxml_default, true, 22.0, 12.5, 89)
@@ -1800,7 +2121,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     # Test defaults
     vent_fan.rated_flow_rate = nil
     vent_fan.start_hour = nil
-    vent_fan.quantity = nil
+    vent_fan.count = nil
     vent_fan.is_shared_system = nil
     vent_fan.fraction_recirculation = nil
     vent_fan.in_unit_flow_rate = nil
@@ -1812,19 +2133,27 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     vent_fan.delivered_ventilation = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_mech_vent_values(hpxml_default, false, 24.0, 35.0, 100)
+    _test_default_mech_vent_values(hpxml_default, false, 24.0, 27.1, 77.3)
 
-    # Test defaults w/ SFA building
-    hpxml = _create_hpxml('base-bldgtype-single-family-attached.xml')
+    # Test defaults w/ SFA building, compartmentalization test
+    hpxml = _create_hpxml('base-bldgtype-attached.xml')
+    hpxml.air_infiltration_measurements[0].infiltration_type = HPXML::InfiltrationTypeUnitTotal
     hpxml.ventilation_fans.add(id: 'MechanicalVentilation',
                                fan_type: HPXML::MechVentTypeExhaust,
                                used_for_whole_building_ventilation: true)
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_mech_vent_values(hpxml_default, false, 24.0, 27.2, 78)
+    _test_default_mech_vent_values(hpxml_default, false, 24.0, 27.4, 78.4)
+
+    # Test defaults w/ SFA building, guarded test
+    hpxml.air_infiltration_measurements[0].infiltration_type = HPXML::InfiltrationTypeUnitExterior
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_mech_vent_values(hpxml_default, false, 24.0, 27.2, 77.3)
 
-    # Test defaults w/ MF building
+    # Test defaults w/ MF building, compartmentalization test
     hpxml = _create_hpxml('base-bldgtype-multifamily.xml')
+    hpxml.air_infiltration_measurements[0].infiltration_type = HPXML::InfiltrationTypeUnitTotal
     hpxml.ventilation_fans.add(id: 'MechanicalVentilation',
                                fan_type: HPXML::MechVentTypeExhaust,
                                used_for_whole_building_ventilation: true)
@@ -1832,6 +2161,12 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml_default = _test_measure()
     _test_default_mech_vent_values(hpxml_default, false, 24.0, 19.8, 56.5)
 
+    # Test defaults w/ MF building, guarded test
+    hpxml.air_infiltration_measurements[0].infiltration_type = HPXML::InfiltrationTypeUnitExterior
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_mech_vent_values(hpxml_default, false, 24.0, 19.2, 54.9)
+
     # Test defaults w/ nACH infiltration
     hpxml = _create_hpxml('base-enclosure-infil-natural-ach.xml')
     hpxml.ventilation_fans.add(id: 'MechanicalVentilation',
@@ -1870,7 +2205,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
 
     # Test inputs not overridden by defaults w/ CFIS
     hpxml = _create_hpxml('base-mechvent-cfis.xml')
-    vent_fan = hpxml.ventilation_fans.select { |f| f.used_for_whole_building_ventilation }[0]
+    vent_fan = hpxml.ventilation_fans.find { |f| f.used_for_whole_building_ventilation }
     vent_fan.is_shared_system = false
     vent_fan.hours_in_operation = 12.0
     vent_fan.fan_power = 12.5
@@ -1907,11 +2242,11 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     vent_fan.cfis_addtl_runtime_operating_mode = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_mech_vent_values(hpxml_default, false, 8.0, 150.0, 300.0, 1.0, HPXML::CFISModeAirHandler)
+    _test_default_mech_vent_values(hpxml_default, false, 8.0, 149.4, 298.7, 1.0, HPXML::CFISModeAirHandler)
 
     # Test inputs not overridden by defaults w/ ERV
     hpxml = _create_hpxml('base-mechvent-erv.xml')
-    vent_fan = hpxml.ventilation_fans.select { |f| f.used_for_whole_building_ventilation }[0]
+    vent_fan = hpxml.ventilation_fans.find { |f| f.used_for_whole_building_ventilation }
     vent_fan.is_shared_system = false
     vent_fan.hours_in_operation = 20.0
     vent_fan.fan_power = 45.0
@@ -1931,17 +2266,17 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
   def test_local_ventilation_fans
     # Test inputs not overridden by defaults
     hpxml = _create_hpxml('base-mechvent-bath-kitchen-fans.xml')
-    kitchen_fan = hpxml.ventilation_fans.select { |f| f.used_for_local_ventilation && f.fan_location == HPXML::LocationKitchen }[0]
+    kitchen_fan = hpxml.ventilation_fans.find { |f| f.used_for_local_ventilation && f.fan_location == HPXML::LocationKitchen }
     kitchen_fan.rated_flow_rate = 300
     kitchen_fan.fan_power = 20
     kitchen_fan.start_hour = 12
-    kitchen_fan.quantity = 2
+    kitchen_fan.count = 2
     kitchen_fan.hours_in_operation = 2
-    bath_fan = hpxml.ventilation_fans.select { |f| f.used_for_local_ventilation && f.fan_location == HPXML::LocationBath }[0]
+    bath_fan = hpxml.ventilation_fans.find { |f| f.used_for_local_ventilation && f.fan_location == HPXML::LocationBath }
     bath_fan.rated_flow_rate = 80
     bath_fan.fan_power = 33
     bath_fan.start_hour = 6
-    bath_fan.quantity = 3
+    bath_fan.count = 3
     bath_fan.hours_in_operation = 3
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
@@ -1952,12 +2287,12 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     kitchen_fan.rated_flow_rate = nil
     kitchen_fan.fan_power = nil
     kitchen_fan.start_hour = nil
-    kitchen_fan.quantity = nil
+    kitchen_fan.count = nil
     kitchen_fan.hours_in_operation = nil
     bath_fan.rated_flow_rate = nil
     bath_fan.fan_power = nil
     bath_fan.start_hour = nil
-    bath_fan.quantity = nil
+    bath_fan.count = nil
     bath_fan.hours_in_operation = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
@@ -1968,7 +2303,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
   def test_whole_house_fan
     # Test inputs not overridden by defaults
     hpxml = _create_hpxml('base-mechvent-whole-house-fan.xml')
-    whf = hpxml.ventilation_fans.select { |f| f.used_for_seasonal_cooling_load_reduction }[0]
+    whf = hpxml.ventilation_fans.find { |f| f.used_for_seasonal_cooling_load_reduction }
     whf.rated_flow_rate = 3000
     whf.fan_power = 321
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
@@ -1985,8 +2320,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
 
   def test_storage_water_heaters
     # Test inputs not overridden by defaults
-    hpxml = _create_hpxml('base.xml')
-    hpxml.building_construction.residential_facility_type = HPXML::ResidentialTypeSFA
+    hpxml = _create_hpxml('base-bldgtype-attached.xml')
     hpxml.water_heating_systems.each do |wh|
       wh.is_shared_system = true
       wh.number_of_units_served = 2
@@ -2126,7 +2460,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.water_heating_systems[0].operating_mode = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_heat_pump_water_heater_values(hpxml_default, [HPXML::WaterHeaterOperatingModeStandard])
+    _test_default_heat_pump_water_heater_values(hpxml_default, [HPXML::WaterHeaterOperatingModeHybridAuto])
   end
 
   def test_indirect_water_heaters
@@ -2279,44 +2613,44 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
 
   def test_pv_systems
     # Test inputs not overridden by defaults
-    hpxml = _create_hpxml('base-pv.xml')
-    hpxml.building_construction.residential_facility_type = HPXML::ResidentialTypeSFA
-    hpxml.pv_systems.each do |pv|
-      pv.is_shared_system = true
-      pv.number_of_bedrooms_served = 20
-      pv.inverter_efficiency = 0.90
-      pv.system_losses_fraction = 0.20
-      pv.location = HPXML::LocationGround
-      pv.tracking = HPXML::PVTrackingType1Axis
-      pv.module_type = HPXML::PVModuleTypePremium
-      pv.array_azimuth = 123
-    end
+    hpxml = _create_hpxml('base-bldgtype-attached.xml')
+    hpxml.pv_systems.add(id: 'PVSystem',
+                         is_shared_system: true,
+                         number_of_bedrooms_served: 20,
+                         system_losses_fraction: 0.20,
+                         location: HPXML::LocationGround,
+                         tracking: HPXML::PVTrackingType1Axis,
+                         module_type: HPXML::PVModuleTypePremium,
+                         array_azimuth: 123,
+                         array_tilt: 0,
+                         max_power_output: 1000,
+                         inverter_idref: 'Inverter')
+    hpxml.inverters.add(id: 'Inverter',
+                        inverter_efficiency: 0.90)
+    pv = hpxml.pv_systems[0]
+    inv = hpxml.inverters[0]
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
     _test_default_pv_system_values(hpxml_default, 0.90, 0.20, true, HPXML::LocationGround, HPXML::PVTrackingType1Axis, HPXML::PVModuleTypePremium, 123)
 
     # Test defaults w/o year modules manufactured
-    hpxml.pv_systems.each do |pv|
-      pv.is_shared_system = nil
-      pv.inverter_efficiency = nil
-      pv.system_losses_fraction = nil
-      pv.location = nil
-      pv.tracking = nil
-      pv.module_type = nil
-      pv.array_orientation = HPXML::OrientationSoutheast
-      pv.array_azimuth = nil
-    end
+    pv.is_shared_system = nil
+    pv.system_losses_fraction = nil
+    pv.location = nil
+    pv.tracking = nil
+    pv.module_type = nil
+    pv.array_orientation = HPXML::OrientationSoutheast
+    pv.array_azimuth = nil
+    inv.inverter_efficiency = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
     _test_default_pv_system_values(hpxml_default, 0.96, 0.14, false, HPXML::LocationRoof, HPXML::PVTrackingTypeFixed, HPXML::PVModuleTypeStandard, 135)
 
     # Test defaults w/ year modules manufactured
-    hpxml.pv_systems.each do |pv|
-      pv.year_modules_manufactured = 2010
-    end
+    pv.year_modules_manufactured = 2010
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_pv_system_values(hpxml_default, 0.96, 0.190, false, HPXML::LocationRoof, HPXML::PVTrackingTypeFixed, HPXML::PVModuleTypeStandard, 135)
+    _test_default_pv_system_values(hpxml_default, 0.96, 0.194, false, HPXML::LocationRoof, HPXML::PVTrackingTypeFixed, HPXML::PVModuleTypeStandard, 135)
   end
 
   def test_batteries
@@ -2332,7 +2666,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.batteries[0].round_trip_efficiency = 0.9
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_battery_values(hpxml_default, 45.0, nil, 34.0, nil, 1234.0, HPXML::LocationBasementConditioned, nil, 0.9)
+    _test_default_battery_values(hpxml_default.batteries[0], 45.0, nil, 34.0, nil, 1234.0, HPXML::LocationBasementConditioned, nil, 0.9)
 
     # Test w/ Ah instead of kWh
     hpxml.batteries[0].nominal_capacity_kwh = nil
@@ -2341,7 +2675,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.batteries[0].usable_capacity_ah = 876.0
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_battery_values(hpxml_default, nil, 987.0, nil, 876.0, 1234.0, HPXML::LocationBasementConditioned, nil, 0.9)
+    _test_default_battery_values(hpxml_default.batteries[0], nil, 987.0, nil, 876.0, 1234.0, HPXML::LocationBasementConditioned, nil, 0.9)
 
     # Test defaults
     hpxml.batteries[0].nominal_capacity_kwh = nil
@@ -2354,7 +2688,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.batteries[0].round_trip_efficiency = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_battery_values(hpxml_default, 10.0, nil, 9.0, nil, 5000.0, HPXML::LocationOutside, nil, 0.925)
+    _test_default_battery_values(hpxml_default.batteries[0], 10.0, nil, 9.0, nil, 5000.0, HPXML::LocationOutside, nil, 0.925)
 
     # Test defaults w/ nominal kWh
     hpxml.batteries[0].nominal_capacity_kwh = 14.0
@@ -2364,7 +2698,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.batteries[0].rated_power_output = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_battery_values(hpxml_default, 14.0, nil, 12.6, nil, 7000.0, HPXML::LocationOutside, nil, 0.925)
+    _test_default_battery_values(hpxml_default.batteries[0], 14.0, nil, 12.6, nil, 7000.0, HPXML::LocationOutside, nil, 0.925)
 
     # Test defaults w/ usable kWh
     hpxml.batteries[0].nominal_capacity_kwh = nil
@@ -2374,7 +2708,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.batteries[0].rated_power_output = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_battery_values(hpxml_default, 13.33, nil, 12.0, nil, 6665.0, HPXML::LocationOutside, nil, 0.925)
+    _test_default_battery_values(hpxml_default.batteries[0], 13.33, nil, 12.0, nil, 6665.0, HPXML::LocationOutside, nil, 0.925)
 
     # Test defaults w/ nominal Ah
     hpxml.batteries[0].nominal_capacity_kwh = nil
@@ -2384,7 +2718,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.batteries[0].rated_power_output = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_battery_values(hpxml_default, nil, 280.0, nil, 252.0, 7000.0, HPXML::LocationOutside, nil, 0.925)
+    _test_default_battery_values(hpxml_default.batteries[0], nil, 280.0, nil, 252.0, 7000.0, HPXML::LocationOutside, nil, 0.925)
 
     # Test defaults w/ usable Ah
     hpxml.batteries[0].nominal_capacity_kwh = nil
@@ -2394,7 +2728,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.batteries[0].rated_power_output = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_battery_values(hpxml_default, nil, 266.67, nil, 240.0, 6667.0, HPXML::LocationOutside, nil, 0.925)
+    _test_default_battery_values(hpxml_default.batteries[0], nil, 266.67, nil, 240.0, 6667.0, HPXML::LocationOutside, nil, 0.925)
 
     # Test defaults w/ rated power output
     hpxml.batteries[0].nominal_capacity_kwh = nil
@@ -2404,7 +2738,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.batteries[0].rated_power_output = 10000.0
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_battery_values(hpxml_default, 20.0, nil, 18.0, nil, 10000.0, HPXML::LocationOutside, nil, 0.925)
+    _test_default_battery_values(hpxml_default.batteries[0], 20.0, nil, 18.0, nil, 10000.0, HPXML::LocationOutside, nil, 0.925)
 
     # Test defaults w/ garage
     hpxml = _create_hpxml('base-pv-battery-garage.xml')
@@ -2418,25 +2752,25 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.batteries[0].round_trip_efficiency = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_battery_values(hpxml_default, 10.0, nil, 9.0, nil, 5000.0, HPXML::LocationGarage, nil, 0.925)
+    _test_default_battery_values(hpxml_default.batteries[0], 10.0, nil, 9.0, nil, 5000.0, HPXML::LocationGarage, nil, 0.925)
   end
 
   def test_generators
     # Test inputs not overridden by defaults
-    hpxml = _create_hpxml('base-misc-generators.xml')
-    hpxml.building_construction.residential_facility_type = HPXML::ResidentialTypeSFA
-    hpxml.generators.each do |generator|
-      generator.is_shared_system = true
-      generator.number_of_bedrooms_served = 20
-    end
+    hpxml = _create_hpxml('base-bldgtype-attached.xml')
+    hpxml.generators.add(id: 'Generator',
+                         is_shared_system: true,
+                         number_of_bedrooms_served: 20,
+                         fuel_type: HPXML::FuelTypeNaturalGas,
+                         annual_consumption_kbtu: 8500,
+                         annual_output_kwh: 500)
+    generator = hpxml.generators[0]
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
     _test_default_generator_values(hpxml_default, true)
 
     # Test defaults
-    hpxml.generators.each do |generator|
-      generator.is_shared_system = nil
-    end
+    generator.is_shared_system = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
     _test_default_generator_values(hpxml_default, false)
@@ -2444,8 +2778,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
 
   def test_clothes_washers
     # Test inputs not overridden by defaults
-    hpxml = _create_hpxml('base.xml')
-    hpxml.building_construction.residential_facility_type = HPXML::ResidentialTypeSFA
+    hpxml = _create_hpxml('base-bldgtype-attached.xml')
     hpxml.water_heating_systems[0].is_shared_system = true
     hpxml.water_heating_systems[0].number_of_units_served = 6
     hpxml.clothes_washers[0].location = HPXML::LocationBasementConditioned
@@ -2500,8 +2833,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
 
   def test_clothes_dryers
     # Test inputs not overridden by defaults
-    hpxml = _create_hpxml('base.xml')
-    hpxml.building_construction.residential_facility_type = HPXML::ResidentialTypeSFA
+    hpxml = _create_hpxml('base-bldgtype-attached.xml')
     hpxml.water_heating_systems[0].is_shared_system = true
     hpxml.water_heating_systems[0].number_of_units_served = 6
     hpxml.clothes_dryers[0].location = HPXML::LocationBasementConditioned
@@ -2575,8 +2907,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
 
   def test_dishwashers
     # Test inputs not overridden by defaults
-    hpxml = _create_hpxml('base.xml')
-    hpxml.building_construction.residential_facility_type = HPXML::ResidentialTypeSFA
+    hpxml = _create_hpxml('base-bldgtype-attached.xml')
     hpxml.water_heating_systems[0].is_shared_system = true
     hpxml.water_heating_systems[0].number_of_units_served = 6
     hpxml.dishwashers[0].location = HPXML::LocationBasementConditioned
@@ -2866,7 +3197,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
   def test_ceiling_fans
     # Test inputs not overridden by defaults
     hpxml = _create_hpxml('base-lighting-ceiling-fans.xml')
-    hpxml.ceiling_fans[0].quantity = 2
+    hpxml.ceiling_fans[0].count = 2
     hpxml.ceiling_fans[0].efficiency = 100
     hpxml.ceiling_fans[0].weekday_fractions = ConstantDaySchedule
     hpxml.ceiling_fans[0].weekend_fractions = ConstantDaySchedule
@@ -2877,7 +3208,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
 
     # Test defaults
     hpxml.ceiling_fans.each do |ceiling_fan|
-      ceiling_fan.quantity = nil
+      ceiling_fan.count = nil
       ceiling_fan.efficiency = nil
       ceiling_fan.weekday_fractions = nil
       ceiling_fan.weekend_fractions = nil
@@ -3007,32 +3338,32 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
   def test_plug_loads
     # Test inputs not overridden by defaults
     hpxml = _create_hpxml('base-misc-loads-large-uncommon.xml')
-    tv_pl = hpxml.plug_loads.select { |pl| pl.plug_load_type == HPXML::PlugLoadTypeTelevision }[0]
-    tv_pl.kWh_per_year = 1000
+    tv_pl = hpxml.plug_loads.find { |pl| pl.plug_load_type == HPXML::PlugLoadTypeTelevision }
+    tv_pl.kwh_per_year = 1000
     tv_pl.usage_multiplier = 1.1
     tv_pl.frac_sensible = 0.6
     tv_pl.frac_latent = 0.3
     tv_pl.weekday_fractions = ConstantDaySchedule
     tv_pl.weekend_fractions = ConstantDaySchedule
     tv_pl.monthly_multipliers = ConstantMonthSchedule
-    other_pl = hpxml.plug_loads.select { |pl| pl.plug_load_type == HPXML::PlugLoadTypeOther }[0]
-    other_pl.kWh_per_year = 2000
+    other_pl = hpxml.plug_loads.find { |pl| pl.plug_load_type == HPXML::PlugLoadTypeOther }
+    other_pl.kwh_per_year = 2000
     other_pl.usage_multiplier = 1.2
     other_pl.frac_sensible = 0.5
     other_pl.frac_latent = 0.4
     other_pl.weekday_fractions = ConstantDaySchedule
     other_pl.weekend_fractions = ConstantDaySchedule
     other_pl.monthly_multipliers = ConstantMonthSchedule
-    veh_pl = hpxml.plug_loads.select { |pl| pl.plug_load_type == HPXML::PlugLoadTypeElectricVehicleCharging }[0]
-    veh_pl.kWh_per_year = 4000
+    veh_pl = hpxml.plug_loads.find { |pl| pl.plug_load_type == HPXML::PlugLoadTypeElectricVehicleCharging }
+    veh_pl.kwh_per_year = 4000
     veh_pl.usage_multiplier = 1.3
     veh_pl.frac_sensible = 0.4
     veh_pl.frac_latent = 0.5
     veh_pl.weekday_fractions = ConstantDaySchedule
     veh_pl.weekend_fractions = ConstantDaySchedule
     veh_pl.monthly_multipliers = ConstantMonthSchedule
-    wellpump_pl = hpxml.plug_loads.select { |pl| pl.plug_load_type == HPXML::PlugLoadTypeWellPump }[0]
-    wellpump_pl.kWh_per_year = 3000
+    wellpump_pl = hpxml.plug_loads.find { |pl| pl.plug_load_type == HPXML::PlugLoadTypeWellPump }
+    wellpump_pl.kwh_per_year = 3000
     wellpump_pl.usage_multiplier = 1.4
     wellpump_pl.frac_sensible = 0.3
     wellpump_pl.frac_latent = 0.6
@@ -3048,7 +3379,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
 
     # Test defaults
     hpxml.plug_loads.each do |plug_load|
-      plug_load.kWh_per_year = nil
+      plug_load.kwh_per_year = nil
       plug_load.usage_multiplier = nil
       plug_load.frac_sensible = nil
       plug_load.frac_latent = nil
@@ -3067,7 +3398,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
   def test_fuel_loads
     # Test inputs not overridden by defaults
     hpxml = _create_hpxml('base-misc-loads-large-uncommon.xml')
-    gg_fl = hpxml.fuel_loads.select { |fl| fl.fuel_load_type == HPXML::FuelLoadTypeGrill }[0]
+    gg_fl = hpxml.fuel_loads.find { |fl| fl.fuel_load_type == HPXML::FuelLoadTypeGrill }
     gg_fl.therm_per_year = 1000
     gg_fl.usage_multiplier = 0.9
     gg_fl.frac_sensible = 0.6
@@ -3075,7 +3406,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     gg_fl.weekday_fractions = ConstantDaySchedule
     gg_fl.weekend_fractions = ConstantDaySchedule
     gg_fl.monthly_multipliers = ConstantMonthSchedule
-    gl_fl = hpxml.fuel_loads.select { |fl| fl.fuel_load_type == HPXML::FuelLoadTypeLighting }[0]
+    gl_fl = hpxml.fuel_loads.find { |fl| fl.fuel_load_type == HPXML::FuelLoadTypeLighting }
     gl_fl.therm_per_year = 2000
     gl_fl.usage_multiplier = 0.8
     gl_fl.frac_sensible = 0.5
@@ -3083,7 +3414,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     gl_fl.weekday_fractions = ConstantDaySchedule
     gl_fl.weekend_fractions = ConstantDaySchedule
     gl_fl.monthly_multipliers = ConstantMonthSchedule
-    gf_fl = hpxml.fuel_loads.select { |fl| fl.fuel_load_type == HPXML::FuelLoadTypeFireplace }[0]
+    gf_fl = hpxml.fuel_loads.find { |fl| fl.fuel_load_type == HPXML::FuelLoadTypeFireplace }
     gf_fl.therm_per_year = 3000
     gf_fl.usage_multiplier = 0.7
     gf_fl.frac_sensible = 0.4
@@ -3151,8 +3482,11 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
 
   def _test_default_header_values(hpxml, tstep, sim_begin_month, sim_begin_day, sim_end_month, sim_end_day, sim_calendar_year,
                                   dst_enabled, dst_begin_month, dst_begin_day, dst_end_month, dst_end_day, heat_pump_sizing_methodology,
-                                  allow_increased_fixed_capacities, state_code, time_zone_utc_offset, occupancy_calculation_type,
-                                  temperature_capacitance_multiplier, natvent_days_per_week)
+                                  allow_increased_fixed_capacities, state_code, time_zone_utc_offset, temperature_capacitance_multiplier,
+                                  natvent_days_per_week, unavailable_period_begin_hour, unavailable_period_end_hour, unavailable_period_natvent_availability,
+                                  shading_summer_begin_month, shading_summer_begin_day, shading_summer_end_month, shading_summer_end_day,
+                                  manualj_heating_design_temp, manualj_cooling_design_temp, manualj_heating_setpoint, manualj_cooling_setpoint,
+                                  manualj_humidity_setpoint, manualj_internal_loads_sensible, manualj_internal_loads_latent, manualj_num_occupants)
     assert_equal(tstep, hpxml.header.timestep)
     assert_equal(sim_begin_month, hpxml.header.sim_begin_month)
     assert_equal(sim_begin_day, hpxml.header.sim_begin_day)
@@ -3176,9 +3510,27 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
       assert_equal(state_code, hpxml.header.state_code)
     end
     assert_equal(time_zone_utc_offset, hpxml.header.time_zone_utc_offset)
-    assert_equal(occupancy_calculation_type, hpxml.header.occupancy_calculation_type)
     assert_equal(temperature_capacitance_multiplier, hpxml.header.temperature_capacitance_multiplier)
     assert_equal(natvent_days_per_week, hpxml.header.natvent_days_per_week)
+    if unavailable_period_begin_hour.nil? && unavailable_period_end_hour.nil? && unavailable_period_natvent_availability.nil?
+      assert_equal(0, hpxml.header.unavailable_periods.size)
+    else
+      assert_equal(unavailable_period_begin_hour, hpxml.header.unavailable_periods[-1].begin_hour)
+      assert_equal(unavailable_period_end_hour, hpxml.header.unavailable_periods[-1].end_hour)
+      assert_equal(unavailable_period_natvent_availability, hpxml.header.unavailable_periods[-1].natvent_availability)
+    end
+    assert_equal(shading_summer_begin_month, hpxml.header.shading_summer_begin_month)
+    assert_equal(shading_summer_begin_day, hpxml.header.shading_summer_begin_day)
+    assert_equal(shading_summer_end_month, hpxml.header.shading_summer_end_month)
+    assert_equal(shading_summer_end_day, hpxml.header.shading_summer_end_day)
+    assert_in_epsilon(manualj_heating_design_temp, hpxml.header.manualj_heating_design_temp, 0.01)
+    assert_in_epsilon(manualj_cooling_design_temp, hpxml.header.manualj_cooling_design_temp, 0.01)
+    assert_equal(manualj_heating_setpoint, hpxml.header.manualj_heating_setpoint)
+    assert_equal(manualj_cooling_setpoint, hpxml.header.manualj_cooling_setpoint)
+    assert_equal(manualj_humidity_setpoint, hpxml.header.manualj_humidity_setpoint)
+    assert_equal(manualj_internal_loads_sensible, hpxml.header.manualj_internal_loads_sensible)
+    assert_equal(manualj_internal_loads_latent, hpxml.header.manualj_internal_loads_latent)
+    assert_equal(manualj_num_occupants, hpxml.header.manualj_num_occupants)
   end
 
   def _test_default_emissions_values(scenario, elec_schedule_number_of_header_rows, elec_schedule_column_number,
@@ -3351,8 +3703,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     end
   end
 
-  def _test_default_occupancy_values(hpxml, num_occupants, weekday_sch, weekend_sch, monthly_mults)
-    assert_equal(num_occupants, hpxml.building_occupancy.number_of_residents)
+  def _test_default_occupancy_values(hpxml, weekday_sch, weekend_sch, monthly_mults)
     if weekday_sch.nil?
       assert_nil(hpxml.building_occupancy.weekday_fractions)
     else
@@ -3383,15 +3734,23 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     end
   end
 
-  def _test_default_building_construction_values(hpxml, building_volume, average_ceiling_height, has_flue_or_chimney, n_bathrooms)
+  def _test_default_building_construction_values(hpxml, building_volume, average_ceiling_height, n_bathrooms)
     assert_equal(building_volume, hpxml.building_construction.conditioned_building_volume)
     assert_in_epsilon(average_ceiling_height, hpxml.building_construction.average_ceiling_height, 0.01)
-    assert_equal(has_flue_or_chimney, hpxml.building_construction.has_flue_or_chimney)
     assert_equal(n_bathrooms, hpxml.building_construction.number_of_bathrooms)
   end
 
-  def _test_default_infiltration_values(air_infiltration_measurement, volume)
-    assert_equal(volume, air_infiltration_measurement.infiltration_volume)
+  def _test_default_infiltration_values(hpxml, volume, has_flue_or_chimney_in_conditioned_space)
+    assert_equal(volume, hpxml.air_infiltration_measurements[0].infiltration_volume)
+    assert_equal(has_flue_or_chimney_in_conditioned_space, hpxml.air_infiltration.has_flue_or_chimney_in_conditioned_space)
+  end
+
+  def _test_default_infiltration_compartmentalization_test_values(air_infiltration_measurement, a_ext)
+    if a_ext.nil?
+      assert_nil(air_infiltration_measurement.a_ext)
+    else
+      assert_in_delta(a_ext, air_infiltration_measurement.a_ext, 0.001)
+    end
   end
 
   def _test_default_attic_values(attic, sla)
@@ -3523,30 +3882,32 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
   end
 
   def _test_default_central_air_conditioner_values(cooling_system, shr, compressor_type, fan_watts_per_cfm, charge_defect_ratio,
-                                                   airflow_defect_ratio, cooling_capacity, cooling_efficiency_seer)
+                                                   airflow_defect_ratio, cooling_capacity, cooling_efficiency_seer, crankcase_heater_watts)
     assert_equal(shr, cooling_system.cooling_shr)
     assert_equal(compressor_type, cooling_system.compressor_type)
     assert_equal(fan_watts_per_cfm, cooling_system.fan_watts_per_cfm)
     assert_equal(charge_defect_ratio, cooling_system.charge_defect_ratio)
     assert_equal(airflow_defect_ratio, cooling_system.airflow_defect_ratio)
+    assert_equal(crankcase_heater_watts, cooling_system.crankcase_heater_watts)
     if cooling_capacity.nil?
       assert(cooling_system.cooling_capacity > 0)
     else
-      assert_equal(cooling_system.cooling_capacity, cooling_capacity)
+      assert_equal(cooling_capacity, cooling_system.cooling_capacity)
     end
     if cooling_efficiency_seer.nil?
       assert_nil(cooling_system.cooling_efficiency_seer)
     else
-      assert_equal(cooling_system.cooling_efficiency_seer, cooling_efficiency_seer)
+      assert_equal(cooling_efficiency_seer, cooling_system.cooling_efficiency_seer)
     end
   end
 
-  def _test_default_room_air_conditioner_ptac_values(cooling_system, shr, cooling_capacity)
+  def _test_default_room_air_conditioner_ptac_values(cooling_system, shr, cooling_capacity, crankcase_heater_watts)
     assert_equal(shr, cooling_system.cooling_shr)
+    assert_equal(crankcase_heater_watts, cooling_system.crankcase_heater_watts)
     if cooling_capacity.nil?
       assert(cooling_system.cooling_capacity > 0)
     else
-      assert_equal(cooling_system.cooling_capacity, cooling_capacity)
+      assert_equal(cooling_capacity, cooling_system.cooling_capacity)
     end
   end
 
@@ -3559,30 +3920,39 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
   end
 
   def _test_default_mini_split_air_conditioner_values(cooling_system, shr, fan_watts_per_cfm, charge_defect_ratio,
-                                                      airflow_defect_ratio, cooling_capacity, cooling_efficiency_seer)
+                                                      airflow_defect_ratio, cooling_capacity, cooling_efficiency_seer, crankcase_heater_watts)
     assert_equal(shr, cooling_system.cooling_shr)
     assert_equal(fan_watts_per_cfm, cooling_system.fan_watts_per_cfm)
     assert_equal(charge_defect_ratio, cooling_system.charge_defect_ratio)
     assert_equal(airflow_defect_ratio, cooling_system.airflow_defect_ratio)
+    assert_equal(crankcase_heater_watts, cooling_system.crankcase_heater_watts)
     if cooling_capacity.nil?
       assert(cooling_system.cooling_capacity > 0)
     else
-      assert_equal(cooling_system.cooling_capacity, cooling_capacity)
+      assert_equal(cooling_capacity, cooling_system.cooling_capacity)
     end
     if cooling_efficiency_seer.nil?
       assert_nil(cooling_system.cooling_efficiency_seer)
     else
-      assert_equal(cooling_system.cooling_efficiency_seer, cooling_efficiency_seer)
+      assert_equal(cooling_efficiency_seer, cooling_system.cooling_efficiency_seer)
     end
+    assert_equal(HPXML::HVACCompressorTypeVariableSpeed, cooling_system.compressor_type)
   end
 
-  def _test_default_furnace_values(heating_system, fan_watts_per_cfm, airflow_defect_ratio, heating_capacity)
+  def _test_default_furnace_values(heating_system, fan_watts_per_cfm, airflow_defect_ratio, heating_capacity,
+                                   pilot_light, pilot_light_btuh)
     assert_equal(fan_watts_per_cfm, heating_system.fan_watts_per_cfm)
     assert_equal(airflow_defect_ratio, heating_system.airflow_defect_ratio)
     if heating_capacity.nil?
       assert(heating_system.heating_capacity > 0)
     else
-      assert_equal(heating_system.heating_capacity, heating_capacity)
+      assert_equal(heating_capacity, heating_system.heating_capacity)
+    end
+    assert_equal(pilot_light, heating_system.pilot_light)
+    if pilot_light_btuh.nil?
+      assert_nil(heating_system.pilot_light_btuh)
+    else
+      assert_equal(pilot_light_btuh, heating_system.pilot_light_btuh)
     end
   end
 
@@ -3591,34 +3961,52 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     if heating_capacity.nil?
       assert(heating_system.heating_capacity > 0)
     else
-      assert_equal(heating_system.heating_capacity, heating_capacity)
+      assert_equal(heating_capacity, heating_system.heating_capacity)
     end
   end
 
-  def _test_default_floor_furnace_values(heating_system, fan_watts, heating_capacity)
+  def _test_default_floor_furnace_values(heating_system, fan_watts, heating_capacity, pilot_light, pilot_light_btuh)
     assert_equal(fan_watts, heating_system.fan_watts)
     if heating_capacity.nil?
       assert(heating_system.heating_capacity > 0)
     else
-      assert_equal(heating_system.heating_capacity, heating_capacity)
+      assert_equal(heating_capacity, heating_system.heating_capacity)
+    end
+    assert_equal(pilot_light, heating_system.pilot_light)
+    if pilot_light_btuh.nil?
+      assert_nil(heating_system.pilot_light_btuh)
+    else
+      assert_equal(pilot_light_btuh, heating_system.pilot_light_btuh)
     end
   end
 
-  def _test_default_boiler_values(heating_system, eae, heating_capacity)
+  def _test_default_boiler_values(heating_system, eae, heating_capacity, pilot_light, pilot_light_btuh)
     assert_equal(eae, heating_system.electric_auxiliary_energy)
     if heating_capacity.nil?
       assert(heating_system.heating_capacity > 0)
     else
-      assert_equal(heating_system.heating_capacity, heating_capacity)
+      assert_equal(heating_capacity, heating_system.heating_capacity)
+    end
+    assert_equal(pilot_light, heating_system.pilot_light)
+    if pilot_light_btuh.nil?
+      assert_nil(heating_system.pilot_light_btuh)
+    else
+      assert_equal(pilot_light_btuh, heating_system.pilot_light_btuh)
     end
   end
 
-  def _test_default_stove_values(heating_system, fan_watts, heating_capacity)
+  def _test_default_stove_values(heating_system, fan_watts, heating_capacity, pilot_light, pilot_light_btuh)
     assert_equal(fan_watts, heating_system.fan_watts)
     if heating_capacity.nil?
       assert(heating_system.heating_capacity > 0)
     else
-      assert_equal(heating_system.heating_capacity, heating_capacity)
+      assert_equal(heating_capacity, heating_system.heating_capacity)
+    end
+    assert_equal(pilot_light, heating_system.pilot_light)
+    if pilot_light_btuh.nil?
+      assert_nil(heating_system.pilot_light_btuh)
+    else
+      assert_equal(pilot_light_btuh, heating_system.pilot_light_btuh)
     end
   end
 
@@ -3627,7 +4015,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     if heating_capacity.nil?
       assert(heating_system.heating_capacity > 0)
     else
-      assert_equal(heating_system.heating_capacity, heating_capacity)
+      assert_equal(heating_capacity, heating_system.heating_capacity)
     end
   end
 
@@ -3636,16 +4024,22 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     if heating_capacity.nil?
       assert(heating_system.heating_capacity > 0)
     else
-      assert_equal(heating_system.heating_capacity, heating_capacity)
+      assert_equal(heating_capacity, heating_system.heating_capacity)
     end
   end
 
-  def _test_default_fireplace_values(heating_system, fan_watts, heating_capacity)
+  def _test_default_fireplace_values(heating_system, fan_watts, heating_capacity, pilot_light, pilot_light_btuh)
     assert_equal(fan_watts, heating_system.fan_watts)
     if heating_capacity.nil?
       assert(heating_system.heating_capacity > 0)
     else
-      assert_equal(heating_system.heating_capacity, heating_capacity)
+      assert_equal(heating_capacity, heating_system.heating_capacity)
+    end
+    assert_equal(pilot_light, heating_system.pilot_light)
+    if pilot_light_btuh.nil?
+      assert_nil(heating_system.pilot_light_btuh)
+    else
+      assert_equal(pilot_light_btuh, heating_system.pilot_light_btuh)
     end
   end
 
@@ -3653,101 +4047,159 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
                                                 airflow_defect_ratio, cooling_capacity, heating_capacity,
                                                 heating_capacity_17F, backup_heating_capacity,
                                                 cooling_efficiency_seer, heating_efficiency_hspf,
-                                                backup_heating_lockout_temp)
+                                                heating_capacity_retention_fraction, heating_capacity_retention_temp,
+                                                crankcase_heater_watts)
     assert_equal(shr, heat_pump.cooling_shr)
     assert_equal(compressor_type, heat_pump.compressor_type)
     assert_equal(fan_watts_per_cfm, heat_pump.fan_watts_per_cfm)
     assert_equal(charge_defect_ratio, heat_pump.charge_defect_ratio)
     assert_equal(airflow_defect_ratio, heat_pump.airflow_defect_ratio)
+    assert_equal(crankcase_heater_watts, heat_pump.crankcase_heater_watts)
     if cooling_capacity.nil?
       assert(heat_pump.cooling_capacity > 0)
     else
-      assert_equal(heat_pump.cooling_capacity, cooling_capacity)
+      assert_equal(cooling_capacity, heat_pump.cooling_capacity)
     end
     if heating_capacity.nil?
       assert(heat_pump.heating_capacity > 0)
     else
-      assert_equal(heat_pump.heating_capacity, heating_capacity)
+      assert_equal(heating_capacity, heat_pump.heating_capacity)
     end
     if heating_capacity_17F.nil?
-      # assert(heat_pump.heating_capacity_17F > 0) # FUTURE
+      assert_nil(heat_pump.heating_capacity_17F)
     else
-      assert_equal(heat_pump.heating_capacity_17F, heating_capacity_17F)
+      assert_equal(heating_capacity_17F, heat_pump.heating_capacity_17F)
     end
     if backup_heating_capacity.nil?
       assert(heat_pump.backup_heating_capacity > 0)
     else
-      assert_equal(heat_pump.backup_heating_capacity, backup_heating_capacity)
+      assert_equal(backup_heating_capacity, heat_pump.backup_heating_capacity)
     end
     if cooling_efficiency_seer.nil?
       assert_nil(heat_pump.cooling_efficiency_seer)
     else
-      assert_equal(heat_pump.cooling_efficiency_seer, cooling_efficiency_seer)
+      assert_equal(cooling_efficiency_seer, heat_pump.cooling_efficiency_seer)
     end
     if heating_efficiency_hspf.nil?
       assert_nil(heat_pump.heating_efficiency_hspf)
     else
-      assert_equal(heat_pump.heating_efficiency_hspf, heating_efficiency_hspf)
+      assert_equal(heating_efficiency_hspf, heat_pump.heating_efficiency_hspf)
+    end
+    if heating_capacity_retention_fraction.nil?
+      assert_nil(heat_pump.heating_capacity_retention_fraction)
+    else
+      assert_in_delta(heating_capacity_retention_fraction, heat_pump.heating_capacity_retention_fraction, 0.01)
+    end
+    if heating_capacity_retention_temp.nil?
+      assert_nil(heat_pump.heating_capacity_retention_temp)
+    else
+      assert_equal(heating_capacity_retention_temp, heat_pump.heating_capacity_retention_temp)
     end
-    assert_equal(heat_pump.backup_heating_lockout_temp, backup_heating_lockout_temp)
   end
 
-  def _test_default_pthp_values(heat_pump, shr, cooling_capacity, heating_capacity,
-                                backup_heating_lockout_temp)
+  def _test_default_pthp_values(heat_pump, shr, cooling_capacity, heating_capacity, heating_capacity_17F,
+                                heating_capacity_retention_fraction, heating_capacity_retention_temp,
+                                crankcase_heater_watts)
     assert_equal(shr, heat_pump.cooling_shr)
+    assert_equal(crankcase_heater_watts, heat_pump.crankcase_heater_watts)
     if cooling_capacity.nil?
       assert(heat_pump.cooling_capacity > 0)
     else
-      assert_equal(heat_pump.cooling_capacity, cooling_capacity)
+      assert_equal(cooling_capacity, heat_pump.cooling_capacity)
     end
     if heating_capacity.nil?
       assert(heat_pump.heating_capacity > 0)
     else
-      assert_equal(heat_pump.heating_capacity, heating_capacity)
+      assert_equal(heating_capacity, heat_pump.heating_capacity)
+    end
+    if heating_capacity_17F.nil?
+      assert_nil(heat_pump.heating_capacity_17F)
+    else
+      assert_equal(heating_capacity_17F, heat_pump.heating_capacity_17F)
+    end
+    if heating_capacity_retention_fraction.nil?
+      assert_nil(heat_pump.heating_capacity_retention_fraction)
+    else
+      assert_in_delta(heating_capacity_retention_fraction, heat_pump.heating_capacity_retention_fraction, 0.01)
+    end
+    if heating_capacity_retention_temp.nil?
+      assert_nil(heat_pump.heating_capacity_retention_temp)
+    else
+      assert_equal(heating_capacity_retention_temp, heat_pump.heating_capacity_retention_temp)
     end
-    assert_equal(heat_pump.backup_heating_lockout_temp, backup_heating_lockout_temp)
   end
 
   def _test_default_mini_split_heat_pump_values(heat_pump, shr, fan_watts_per_cfm, charge_defect_ratio,
                                                 airflow_defect_ratio, cooling_capacity, heating_capacity,
                                                 heating_capacity_17F, backup_heating_capacity,
                                                 cooling_efficiency_seer, heating_efficiency_hspf,
-                                                backup_heating_lockout_temp)
+                                                heating_capacity_retention_fraction, heating_capacity_retention_temp,
+                                                crankcase_heater_watts)
     assert_equal(shr, heat_pump.cooling_shr)
     assert_equal(fan_watts_per_cfm, heat_pump.fan_watts_per_cfm)
     assert_equal(charge_defect_ratio, heat_pump.charge_defect_ratio)
     assert_equal(airflow_defect_ratio, heat_pump.airflow_defect_ratio)
+    assert_equal(crankcase_heater_watts, heat_pump.crankcase_heater_watts)
     if cooling_capacity.nil?
       assert(heat_pump.cooling_capacity > 0)
     else
-      assert_equal(heat_pump.cooling_capacity, cooling_capacity)
+      assert_equal(cooling_capacity, heat_pump.cooling_capacity)
     end
     if heating_capacity.nil?
       assert(heat_pump.heating_capacity > 0)
     else
-      assert_equal(heat_pump.heating_capacity, heating_capacity)
+      assert_equal(heating_capacity, heat_pump.heating_capacity)
     end
     if heating_capacity_17F.nil?
-      # assert(heat_pump.heating_capacity_17F > 0) # FUTURE
+      assert_nil(heat_pump.heating_capacity_17F)
     else
-      assert_equal(heat_pump.heating_capacity_17F, heating_capacity_17F)
+      assert_equal(heating_capacity_17F, heat_pump.heating_capacity_17F)
     end
     if backup_heating_capacity.nil?
       assert(heat_pump.backup_heating_capacity > 0)
     else
-      assert_equal(heat_pump.backup_heating_capacity, backup_heating_capacity)
+      assert_equal(backup_heating_capacity, heat_pump.backup_heating_capacity)
     end
     if cooling_efficiency_seer.nil?
       assert_nil(heat_pump.cooling_efficiency_seer)
     else
-      assert_equal(heat_pump.cooling_efficiency_seer, cooling_efficiency_seer)
+      assert_equal(cooling_efficiency_seer, heat_pump.cooling_efficiency_seer)
     end
     if heating_efficiency_hspf.nil?
       assert_nil(heat_pump.heating_efficiency_hspf)
     else
-      assert_equal(heat_pump.heating_efficiency_hspf, heating_efficiency_hspf)
+      assert_equal(heating_efficiency_hspf, heat_pump.heating_efficiency_hspf)
+    end
+    assert_equal(HPXML::HVACCompressorTypeVariableSpeed, heat_pump.compressor_type)
+    if heating_capacity_retention_fraction.nil?
+      assert_nil(heat_pump.heating_capacity_retention_fraction)
+    else
+      assert_in_delta(heating_capacity_retention_fraction, heat_pump.heating_capacity_retention_fraction, 0.01)
+    end
+    if heating_capacity_retention_temp.nil?
+      assert_nil(heat_pump.heating_capacity_retention_temp)
+    else
+      assert_equal(heating_capacity_retention_temp, heat_pump.heating_capacity_retention_temp)
+    end
+  end
+
+  def _test_default_heat_pump_temperature_values(heat_pump, compressor_lockout_temp, backup_heating_lockout_temp,
+                                                 backup_heating_switchover_temp)
+    if compressor_lockout_temp.nil?
+      assert_nil(heat_pump.compressor_lockout_temp)
+    else
+      assert_equal(compressor_lockout_temp, heat_pump.compressor_lockout_temp)
+    end
+    if backup_heating_lockout_temp.nil?
+      assert_nil(heat_pump.backup_heating_lockout_temp)
+    else
+      assert_equal(backup_heating_lockout_temp, heat_pump.backup_heating_lockout_temp)
+    end
+    if backup_heating_switchover_temp.nil?
+      assert_nil(heat_pump.backup_heating_switchover_temp)
+    else
+      assert_equal(backup_heating_switchover_temp, heat_pump.backup_heating_switchover_temp)
     end
-    assert_equal(heat_pump.backup_heating_lockout_temp, backup_heating_lockout_temp)
   end
 
   def _test_default_ground_to_air_heat_pump_values(heat_pump, pump_watts_per_ton, fan_watts_per_cfm,
@@ -3759,20 +4211,24 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     if cooling_capacity.nil?
       assert(heat_pump.cooling_capacity > 0)
     else
-      assert_equal(heat_pump.cooling_capacity, cooling_capacity)
+      assert_equal(cooling_capacity, heat_pump.cooling_capacity)
     end
     if heating_capacity.nil?
       assert(heat_pump.heating_capacity > 0)
     else
-      assert_equal(heat_pump.heating_capacity, heating_capacity)
+      assert_equal(heating_capacity, heat_pump.heating_capacity)
     end
     if backup_heating_capacity.nil?
       assert(heat_pump.backup_heating_capacity > 0)
     else
-      assert_equal(heat_pump.backup_heating_capacity, backup_heating_capacity)
+      assert_equal(backup_heating_capacity, heat_pump.backup_heating_capacity)
     end
   end
 
+  def _test_default_hvac_location_values(hvac_system, location)
+    assert_equal(location, hvac_system.location)
+  end
+
   def _test_default_hvac_control_setpoint_values(hvac_control, heating_setpoint_temp, cooling_setpoint_temp)
     assert_equal(heating_setpoint_temp, hvac_control.heating_setpoint_temp)
     assert_equal(cooling_setpoint_temp, hvac_control.cooling_setpoint_temp)
@@ -3795,7 +4251,8 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
   end
 
   def _test_default_duct_values(hpxml, supply_locations, return_locations, supply_areas, return_areas,
-                                supply_fracs, return_fracs, n_return_registers, supply_area_mults, return_area_mults)
+                                supply_fracs, return_fracs, n_return_registers, supply_area_mults, return_area_mults,
+                                supply_buried_levels, return_buried_levels, supply_effective_rvalues, return_effective_rvalues)
     supply_duct_idx = 0
     return_duct_idx = 0
     hpxml.hvac_distributions.each do |hvac_distribution|
@@ -3808,12 +4265,16 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
           assert_in_epsilon(supply_areas[supply_duct_idx], duct.duct_surface_area, 0.01)
           assert_in_epsilon(supply_fracs[supply_duct_idx], duct.duct_fraction_area, 0.01)
           assert_in_epsilon(supply_area_mults[supply_duct_idx], duct.duct_surface_area_multiplier, 0.01)
+          assert_equal(supply_buried_levels[supply_duct_idx], duct.duct_buried_insulation_level)
+          assert_in_epsilon(supply_effective_rvalues[supply_duct_idx], duct.duct_effective_r_value, 0.01)
           supply_duct_idx += 1
         elsif duct.duct_type == HPXML::DuctTypeReturn
           assert_equal(return_locations[return_duct_idx], duct.duct_location)
           assert_in_epsilon(return_areas[return_duct_idx], duct.duct_surface_area, 0.01)
           assert_in_epsilon(return_fracs[return_duct_idx], duct.duct_fraction_area, 0.01)
           assert_in_epsilon(return_area_mults[return_duct_idx], duct.duct_surface_area_multiplier, 0.01)
+          assert_equal(return_buried_levels[return_duct_idx], duct.duct_buried_insulation_level)
+          assert_in_epsilon(return_effective_rvalues[return_duct_idx], duct.duct_effective_r_value, 0.01)
           return_duct_idx += 1
         end
       end
@@ -3822,12 +4283,12 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
 
   def _test_default_mech_vent_values(hpxml, is_shared_system, hours_in_operation, fan_power, flow_rate,
                                      cfis_vent_mode_airflow_fraction = nil, cfis_addtl_runtime_operating_mode = nil)
-    vent_fan = hpxml.ventilation_fans.select { |f| f.used_for_whole_building_ventilation && !f.is_cfis_supplemental_fan? }[0]
+    vent_fan = hpxml.ventilation_fans.find { |f| f.used_for_whole_building_ventilation && !f.is_cfis_supplemental_fan? }
 
     assert_equal(is_shared_system, vent_fan.is_shared_system)
     assert_equal(hours_in_operation, vent_fan.hours_in_operation)
-    assert_in_epsilon(fan_power, vent_fan.fan_power, 0.01)
-    assert_in_epsilon(flow_rate, vent_fan.rated_flow_rate.to_f + vent_fan.calculated_flow_rate.to_f + vent_fan.tested_flow_rate.to_f + vent_fan.delivered_ventilation.to_f, 0.01)
+    assert_in_delta(fan_power, vent_fan.fan_power, 0.1)
+    assert_in_delta(flow_rate, vent_fan.rated_flow_rate.to_f + vent_fan.calculated_flow_rate.to_f + vent_fan.tested_flow_rate.to_f + vent_fan.delivered_ventilation.to_f, 0.1)
     if cfis_vent_mode_airflow_fraction.nil?
       assert_nil(vent_fan.cfis_vent_mode_airflow_fraction)
     else
@@ -3841,7 +4302,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
   end
 
   def _test_default_mech_vent_suppl_values(hpxml, is_shared_system, hours_in_operation, fan_power, flow_rate)
-    vent_fan = hpxml.ventilation_fans.select { |f| f.used_for_whole_building_ventilation && f.is_cfis_supplemental_fan? }[0]
+    vent_fan = hpxml.ventilation_fans.find { |f| f.used_for_whole_building_ventilation && f.is_cfis_supplemental_fan? }
 
     assert_equal(is_shared_system, vent_fan.is_shared_system)
     if hours_in_operation.nil?
@@ -3853,20 +4314,20 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     assert_in_epsilon(flow_rate, vent_fan.rated_flow_rate.to_f + vent_fan.calculated_flow_rate.to_f + vent_fan.tested_flow_rate.to_f + vent_fan.delivered_ventilation.to_f, 0.01)
   end
 
-  def _test_default_kitchen_fan_values(hpxml, quantity, flow_rate, hours_in_operation, fan_power, start_hour)
-    kitchen_fan = hpxml.ventilation_fans.select { |f| f.used_for_local_ventilation && f.fan_location == HPXML::LocationKitchen }[0]
+  def _test_default_kitchen_fan_values(hpxml, count, flow_rate, hours_in_operation, fan_power, start_hour)
+    kitchen_fan = hpxml.ventilation_fans.find { |f| f.used_for_local_ventilation && f.fan_location == HPXML::LocationKitchen }
 
-    assert_equal(quantity, kitchen_fan.quantity)
+    assert_equal(count, kitchen_fan.count)
     assert_equal(flow_rate, kitchen_fan.rated_flow_rate.to_f + kitchen_fan.calculated_flow_rate.to_f + kitchen_fan.tested_flow_rate.to_f + kitchen_fan.delivered_ventilation.to_f)
     assert_equal(hours_in_operation, kitchen_fan.hours_in_operation)
     assert_equal(fan_power, kitchen_fan.fan_power)
     assert_equal(start_hour, kitchen_fan.start_hour)
   end
 
-  def _test_default_bath_fan_values(hpxml, quantity, flow_rate, hours_in_operation, fan_power, start_hour)
-    bath_fan = hpxml.ventilation_fans.select { |f| f.used_for_local_ventilation && f.fan_location == HPXML::LocationBath }[0]
+  def _test_default_bath_fan_values(hpxml, count, flow_rate, hours_in_operation, fan_power, start_hour)
+    bath_fan = hpxml.ventilation_fans.find { |f| f.used_for_local_ventilation && f.fan_location == HPXML::LocationBath }
 
-    assert_equal(quantity, bath_fan.quantity)
+    assert_equal(count, bath_fan.count)
     assert_equal(flow_rate, bath_fan.rated_flow_rate.to_f + bath_fan.calculated_flow_rate.to_f + bath_fan.tested_flow_rate.to_f + bath_fan.delivered_ventilation.to_f)
     assert_equal(hours_in_operation, bath_fan.hours_in_operation)
     assert_equal(fan_power, bath_fan.fan_power)
@@ -3874,7 +4335,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
   end
 
   def _test_default_whole_house_fan_values(hpxml, flow_rate, fan_power)
-    whf = hpxml.ventilation_fans.select { |f| f.used_for_seasonal_cooling_load_reduction }[0]
+    whf = hpxml.ventilation_fans.find { |f| f.used_for_seasonal_cooling_load_reduction }
 
     assert_equal(flow_rate, whf.rated_flow_rate.to_f + whf.calculated_flow_rate.to_f + whf.tested_flow_rate.to_f + whf.delivered_ventilation.to_f)
     assert_equal(fan_power, whf.fan_power)
@@ -3975,45 +4436,47 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
   def _test_default_pv_system_values(hpxml, interver_efficiency, system_loss_frac, is_shared_system, location, tracking, module_type, azimuth)
     hpxml.pv_systems.each do |pv|
       assert_equal(is_shared_system, pv.is_shared_system)
-      assert_equal(interver_efficiency, pv.inverter_efficiency)
       assert_in_epsilon(system_loss_frac, pv.system_losses_fraction, 0.01)
       assert_equal(location, pv.location)
       assert_equal(tracking, pv.tracking)
       assert_equal(module_type, pv.module_type)
       assert_equal(azimuth, pv.array_azimuth)
     end
+    hpxml.inverters.each do |inv|
+      assert_equal(interver_efficiency, inv.inverter_efficiency)
+    end
   end
 
-  def _test_default_battery_values(hpxml, nominal_capacity_kwh, nominal_capacity_ah, usable_capacity_kwh, usable_capacity_ah,
+  def _test_default_battery_values(battery, nominal_capacity_kwh, nominal_capacity_ah, usable_capacity_kwh, usable_capacity_ah,
                                    rated_power_output, location, lifetime_model, round_trip_efficiency)
     if nominal_capacity_kwh.nil?
-      assert_nil(hpxml.batteries[0].nominal_capacity_kwh)
+      assert_nil(battery.nominal_capacity_kwh)
     else
-      assert_equal(nominal_capacity_kwh, hpxml.batteries[0].nominal_capacity_kwh)
+      assert_equal(nominal_capacity_kwh, battery.nominal_capacity_kwh)
     end
     if nominal_capacity_ah.nil?
-      assert_nil(hpxml.batteries[0].nominal_capacity_ah)
+      assert_nil(battery.nominal_capacity_ah)
     else
-      assert_equal(nominal_capacity_ah, hpxml.batteries[0].nominal_capacity_ah)
+      assert_equal(nominal_capacity_ah, battery.nominal_capacity_ah)
     end
     if usable_capacity_kwh.nil?
-      assert_nil(hpxml.batteries[0].usable_capacity_kwh)
+      assert_nil(battery.usable_capacity_kwh)
     else
-      assert_equal(usable_capacity_kwh, hpxml.batteries[0].usable_capacity_kwh)
+      assert_equal(usable_capacity_kwh, battery.usable_capacity_kwh)
     end
     if usable_capacity_ah.nil?
-      assert_nil(hpxml.batteries[0].usable_capacity_ah)
+      assert_nil(battery.usable_capacity_ah)
     else
-      assert_equal(usable_capacity_ah, hpxml.batteries[0].usable_capacity_ah)
+      assert_equal(usable_capacity_ah, battery.usable_capacity_ah)
     end
-    assert_equal(rated_power_output, hpxml.batteries[0].rated_power_output)
-    assert_equal(location, hpxml.batteries[0].location)
+    assert_equal(rated_power_output, battery.rated_power_output)
+    assert_equal(location, battery.location)
     if lifetime_model.nil?
-      assert_nil(hpxml.batteries[0].lifetime_model)
+      assert_nil(battery.lifetime_model)
     else
-      assert_equal(lifetime_model, hpxml.batteries[0].lifetime_model)
+      assert_equal(lifetime_model, battery.lifetime_model)
     end
-    assert_equal(round_trip_efficiency, hpxml.batteries[0].round_trip_efficiency)
+    assert_equal(round_trip_efficiency, battery.round_trip_efficiency)
   end
 
   def _test_default_generator_values(hpxml, is_shared_system)
@@ -4280,8 +4743,8 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     end
   end
 
-  def _test_default_ceiling_fan_values(ceiling_fan, quantity, efficiency, weekday_sch, weekend_sch, monthly_mults)
-    assert_equal(quantity, ceiling_fan.quantity)
+  def _test_default_ceiling_fan_values(ceiling_fan, count, efficiency, weekday_sch, weekend_sch, monthly_mults)
+    assert_equal(count, ceiling_fan.count)
     assert_in_epsilon(efficiency, ceiling_fan.efficiency, 0.01)
     if weekday_sch.nil?
       assert_nil(ceiling_fan.weekday_fractions)
@@ -4333,8 +4796,8 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     end
   end
 
-  def _test_default_pool_pump_values(pool, kWh_per_year, usage_multiplier, weekday_sch, weekend_sch, monthly_mults)
-    assert_in_epsilon(kWh_per_year, pool.pump_kwh_per_year, 0.01)
+  def _test_default_pool_pump_values(pool, kwh_per_year, usage_multiplier, weekday_sch, weekend_sch, monthly_mults)
+    assert_in_epsilon(kwh_per_year, pool.pump_kwh_per_year, 0.01)
     assert_equal(usage_multiplier, pool.pump_usage_multiplier)
     assert_equal(weekday_sch, pool.pump_weekday_fractions)
     assert_equal(weekend_sch, pool.pump_weekend_fractions)
@@ -4374,18 +4837,18 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     end
   end
 
-  def _test_default_hot_tub_pump_values(hot_tub, kWh_per_year, usage_multiplier, weekday_sch, weekend_sch, monthly_mults)
-    assert_in_epsilon(kWh_per_year, hot_tub.pump_kwh_per_year, 0.01)
+  def _test_default_hot_tub_pump_values(hot_tub, kwh_per_year, usage_multiplier, weekday_sch, weekend_sch, monthly_mults)
+    assert_in_epsilon(kwh_per_year, hot_tub.pump_kwh_per_year, 0.01)
     assert_equal(usage_multiplier, hot_tub.pump_usage_multiplier)
     assert_equal(weekday_sch, hot_tub.pump_weekday_fractions)
     assert_equal(weekend_sch, hot_tub.pump_weekend_fractions)
     assert_equal(monthly_mults, hot_tub.pump_monthly_multipliers)
   end
 
-  def _test_default_plug_load_values(hpxml, load_type, kWh_per_year, frac_sensible, frac_latent, usage_multiplier, weekday_sch, weekend_sch, monthly_mults)
-    pl = hpxml.plug_loads.select { |pl| pl.plug_load_type == load_type }[0]
+  def _test_default_plug_load_values(hpxml, load_type, kwh_per_year, frac_sensible, frac_latent, usage_multiplier, weekday_sch, weekend_sch, monthly_mults)
+    pl = hpxml.plug_loads.find { |pl| pl.plug_load_type == load_type }
 
-    assert_in_epsilon(kWh_per_year, pl.kWh_per_year, 0.01)
+    assert_in_epsilon(kwh_per_year, pl.kwh_per_year, 0.01)
     assert_equal(usage_multiplier, pl.usage_multiplier)
     assert_in_epsilon(frac_sensible, pl.frac_sensible, 0.01)
     assert_in_epsilon(frac_latent, pl.frac_latent, 0.01)
@@ -4395,7 +4858,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
   end
 
   def _test_default_fuel_load_values(hpxml, load_type, therm_per_year, frac_sensible, frac_latent, usage_multiplier, weekday_sch, weekend_sch, monthly_mults)
-    fl = hpxml.fuel_loads.select { |fl| fl.fuel_load_type == load_type }[0]
+    fl = hpxml.fuel_loads.find { |fl| fl.fuel_load_type == load_type }
 
     assert_in_epsilon(therm_per_year, fl.therm_per_year, 0.01)
     assert_equal(usage_multiplier, fl.usage_multiplier)