urbanopt-cli 0.5.1 → 0.6.2

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

@@ -1,16 +1,33 @@
 # frozen_string_literal: true
 
 class SimControls
-  def self.apply(model, header)
+  def self.apply(model, hpxml)
     sim = model.getSimulationControl
     sim.setRunSimulationforSizingPeriods(false)
 
     tstep = model.getTimestep
-    tstep.setNumberOfTimestepsPerHour(60 / header.timestep)
+    tstep.setNumberOfTimestepsPerHour(60 / hpxml.header.timestep)
 
     shad = model.getShadowCalculation
-    shad.setShadingCalculationUpdateFrequency(20)
     shad.setMaximumFiguresInShadowOverlapCalculations(200)
+    # Use EnergyPlus default of 20 days for update frequency; it is a reasonable balance
+    # between speed and accuracy (e.g., sun position, picking up any change in window
+    # interior shading transmittance, etc.).
+    shad.setShadingCalculationUpdateFrequency(20)
+
+    has_windows_varying_transmittance = false
+    hpxml.windows.each do |window|
+      sf_summer = window.interior_shading_factor_summer * window.exterior_shading_factor_summer
+      sf_winter = window.interior_shading_factor_winter * window.exterior_shading_factor_winter
+      next if sf_summer == sf_winter
+
+      has_windows_varying_transmittance = true
+    end
+    if has_windows_varying_transmittance
+      # Detailed diffuse algorithm is required for window interior shading with varying
+      # transmittance schedules
+      shad.setSkyDiffuseModelingAlgorithm('DetailedSkyDiffuseModeling')
+    end
 
     outsurf = model.getOutsideSurfaceConvectionAlgorithm
     outsurf.setAlgorithm('DOE-2')
@@ -25,9 +42,9 @@ class SimControls
     convlim.setMinimumSystemTimestep(0)
 
     run_period = model.getRunPeriod
-    run_period.setBeginMonth(header.sim_begin_month)
-    run_period.setBeginDayOfMonth(header.sim_begin_day)
-    run_period.setEndMonth(header.sim_end_month)
-    run_period.setEndDayOfMonth(header.sim_end_day)
+    run_period.setBeginMonth(hpxml.header.sim_begin_month)
+    run_period.setBeginDayOfMonth(hpxml.header.sim_begin_day)
+    run_period.setEndMonth(hpxml.header.sim_end_month)
+    run_period.setEndDayOfMonth(hpxml.header.sim_end_day)
   end
 end

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

@@ -167,6 +167,8 @@ class UnitConversions
       return x + 273.15
     elsif key == ['f', 'c']
       return (x - 32.0) / 1.8
+    elsif key == ['f', 'k']
+      return (x - 32.0) / 1.8 + 273.15
     elsif key == ['f', 'r']
       return x + 459.67
     elsif key == ['k', 'c']

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 class Version
-  OS_HPXML_Version = '1.0.0' # Version of the OS-HPXML workflow
-  OS_Version = '3.1.0' # Required version of OpenStudio (can be 'X.X' or 'X.X.X')
+  OS_HPXML_Version = '1.1.0' # Version of the OS-HPXML workflow
+  OS_Version = '3.2.0' # Required version of OpenStudio (can be 'X.X' or 'X.X.X')
   HPXML_Version = '3.0' # HPXML schemaVersion
 
   def self.check_openstudio_version

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

@@ -183,6 +183,7 @@ class Waterheater
       if water_heating_system.standby_loss <= 0
         fail 'A negative indirect water heater standby loss was calculated, double check water heater inputs.'
       end
+
       act_vol = calc_storage_tank_actual_vol(water_heating_system.tank_volume, nil)
       a_side = calc_tank_areas(act_vol)[1]
       ua = calc_indirect_ua_with_standbyloss(act_vol, water_heating_system, a_side, solar_fraction)
@@ -1192,10 +1193,11 @@ class Waterheater
         ef = calc_ef_from_uef(water_heating_system)
       end
       if ef >= 0.75
-        return 0.778114 * ef + 0.276679
+        re = 0.561 * ef + 0.439
       else
-        return 0.252117 * ef + 0.607997
+        re = 0.252 * ef + 0.608
       end
+      return re
     end
   end
 
@@ -1398,8 +1400,6 @@ class Waterheater
       location_hierarchy = [HPXML::LocationBasementConditioned,
                             HPXML::LocationBasementUnconditioned,
                             HPXML::LocationLivingSpace]
-    else
-      fail "Unexpected IECC climate zone: '#{iecc_zone}'."
     end
     location_hierarchy.each do |space_type|
       if hpxml.has_space_type(space_type)

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

@@ -8,11 +8,11 @@ class XMLHelper
     parent.children << added
     if not value.nil?
       if datatype == :integer
-        value = to_integer(value)
+        value = to_integer(value, parent, element_name)
       elsif datatype == :float
-        value = to_float(value)
+        value = to_float(value, parent, element_name)
       elsif datatype == :boolean
-        value = to_boolean(value)
+        value = to_boolean(value, parent, element_name)
       elsif datatype != :string
         # If value provided, datatype required
         fail 'Unexpected datatype.'
@@ -58,30 +58,24 @@ class XMLHelper
 
   # Returns the value of 'element_name' in the parent element or nil.
   def self.get_value(parent, element_name, datatype)
-    value, isdefaulted = get_value_and_defaulted(parent, element_name, datatype)
-    return value
-  end
-
-  def self.get_value_and_defaulted(parent, element_name, datatype)
     element = parent.at_xpath(element_name)
     if element.nil?
       return
     end
+
     value = element.text
 
     if datatype == :integer
-      value = to_integer_or_nil(value)
+      value = to_integer_or_nil(value, parent, element_name)
     elsif datatype == :float
-      value = to_float_or_nil(value)
+      value = to_float_or_nil(value, parent, element_name)
     elsif datatype == :boolean
-      value = to_boolean_or_nil(value)
+      value = to_boolean_or_nil(value, parent, element_name)
     elsif datatype != :string
       fail 'Unexpected datatype.'
     end
 
-    isdefaulted = get_attribute_value(element, 'dataSource') == 'software'
-
-    return value, isdefaulted
+    return value
   end
 
   # Returns the value(s) of 'element_name' in the parent element or [].
@@ -91,11 +85,11 @@ class XMLHelper
       value = value.text
 
       if datatype == :integer
-        value = to_integer_or_nil(value)
+        value = to_integer_or_nil(value, parent, element_name)
       elsif datatype == :float
-        value = to_float_or_nil(value)
+        value = to_float_or_nil(value, parent, element_name)
       elsif datatype == :boolean
-        value = to_boolean_or_nil(value)
+        value = to_boolean_or_nil(value, parent, element_name)
       elsif datatype != :string
         fail 'Unexpected datatype.'
       end
@@ -148,6 +142,12 @@ class XMLHelper
     return element.get(attr_name)
   end
 
+  def self.delete_attribute(element, attr_name)
+    return if element.nil?
+
+    element.unset(attr_name)
+  end
+
   def self.validate(doc, xsd_path, runner = nil)
     if Gem::Specification::find_all_by_name('nokogiri').any?
       require 'nokogiri'
@@ -222,28 +222,28 @@ class XMLHelper
   end
 end
 
-def to_float(value)
+def to_float(value, parent, element_name)
   begin
     return Float(value)
   rescue
-    fail "Cannot convert '#{value}' to float."
+    fail "Cannot convert '#{value}' to float for #{parent.name}/#{element_name}."
   end
 end
 
-def to_integer(value)
+def to_integer(value, parent, element_name)
   begin
     value = Float(value)
   rescue
-    fail "Cannot convert '#{value}' to integer."
+    fail "Cannot convert '#{value}' to integer for #{parent.name}/#{element_name}."
   end
   if value % 1 == 0
     return Integer(value)
   else
-    fail "Cannot convert '#{value}' to integer."
+    fail "Cannot convert '#{value}' to integer for #{parent.name}/#{element_name}."
   end
 end
 
-def to_boolean(value)
+def to_boolean(value, parent = nil, element_name = nil)
   if value.is_a? TrueClass
     return true
   elsif value.is_a? FalseClass
@@ -254,23 +254,25 @@ def to_boolean(value)
     return false
   end
 
-  fail "Cannot convert '#{value}' to boolean."
+  if (not parent.nil?) && (not element_name.nil?)
+    fail "Cannot convert '#{value}' to boolean for #{parent.name}/#{element_name}."
+  end
 end
 
-def to_float_or_nil(value)
+def to_float_or_nil(value, parent, element_name)
   return if value.nil?
 
-  return to_float(value)
+  return to_float(value, parent, element_name)
 end
 
-def to_integer_or_nil(value)
+def to_integer_or_nil(value, parent, element_name)
   return if value.nil?
 
-  return to_integer(value)
+  return to_integer(value, parent, element_name)
 end
 
-def to_boolean_or_nil(value)
+def to_boolean_or_nil(value, parent, element_name)
   return if value.nil?
 
-  return to_boolean(value)
+  return to_boolean(value, parent, element_name)
 end

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

@@ -3,42 +3,16 @@
 require_relative '../resources/minitest_helper'
 require 'openstudio'
 require 'openstudio/measure/ShowRunnerOutput'
-require 'minitest/autorun'
 require 'fileutils'
 require_relative '../measure.rb'
 require_relative '../resources/util.rb'
+require_relative 'util.rb'
 
 class HPXMLtoOpenStudioAirflowTest < MiniTest::Test
   def sample_files_dir
     return File.join(File.dirname(__FILE__), '..', '..', 'workflow', 'sample_files')
   end
 
-  def get_ems_values(ems_objects, name)
-    values = {}
-    ems_objects.each do |ems_object|
-      next unless ems_object.name.to_s.include? name.gsub(' ', '_')
-
-      ems_object.lines.each do |line|
-        next unless line.downcase.start_with? 'set'
-
-        lhs, rhs = line.split('=')
-        lhs = lhs.gsub('Set', '').gsub('set', '').strip
-        rhs = rhs.gsub(',', '').gsub(';', '').strip
-        values[lhs] = [] if values[lhs].nil?
-        # eg. "Q = Q + 1.5"
-        if rhs.include? '+'
-          rhs_els = rhs.split('+')
-          rhs = rhs_els.map { |s| s.to_f }.sum(0.0)
-        else
-          rhs = rhs.to_f
-        end
-        values[lhs] << rhs
-      end
-    end
-    assert_operator(values.size, :>, 0)
-    return values
-  end
-
   def get_eed_for_ventilation(model, ee_name)
     eeds = []
     model.getElectricEquipmentDefinitions.each do |eed|
@@ -92,7 +66,7 @@ class HPXMLtoOpenStudioAirflowTest < MiniTest::Test
     # Check infiltration/ventilation program
     program_values = get_ems_values(model.getEnergyManagementSystemPrograms, "#{Constants.ObjectNameInfiltration} program")
     assert_in_epsilon(0.0436, program_values['c'].sum, 0.01)
-    assert_in_epsilon(0.0818, program_values['Cs'].sum, 0.01)
+    assert_in_epsilon(0.0661, program_values['Cs'].sum, 0.01)
     assert_in_epsilon(0.1323, program_values['Cw'].sum, 0.01)
   end
 
@@ -127,7 +101,7 @@ class HPXMLtoOpenStudioAirflowTest < MiniTest::Test
 
     # Check infiltration/ventilation program
     program_values = get_ems_values(model.getEnergyManagementSystemPrograms, "#{Constants.ObjectNameInfiltration} program")
-    assert_in_epsilon(0.3028, program_values['c'].sum, 0.01)
+    assert_in_epsilon(0.0904, program_values['c'].sum, 0.01)
     assert_in_epsilon(0.0573, program_values['Cs'].sum, 0.01)
     assert_in_epsilon(0.1446, program_values['Cw'].sum, 0.01)
   end
@@ -599,6 +573,7 @@ class HPXMLtoOpenStudioAirflowTest < MiniTest::Test
     model = OpenStudio::Model::Model.new
 
     # get arguments
+    args_hash['output_dir'] = 'tests'
     arguments = measure.arguments(model)
     argument_map = OpenStudio::Measure.convertOSArgumentVectorToMap(arguments)
 
@@ -623,6 +598,8 @@ class HPXMLtoOpenStudioAirflowTest < MiniTest::Test
 
     hpxml = HPXML.new(hpxml_path: args_hash['hpxml_path'])
 
+    File.delete(File.join(File.dirname(__FILE__), 'in.xml'))
+
     return model, hpxml
   end
 end

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

@@ -3,7 +3,6 @@
 require_relative '../resources/minitest_helper'
 require 'openstudio'
 require 'openstudio/measure/ShowRunnerOutput'
-require 'minitest/autorun'
 require 'fileutils'
 require_relative '../measure.rb'
 require_relative '../resources/util.rb'
@@ -12,7 +11,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
   ConstantDaySchedule = '0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1'
   ConstantMonthSchedule = '1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1'
 
-  def before_setup
+  def setup
     @root_path = File.absolute_path(File.join(File.dirname(__FILE__), '..', '..'))
     @sample_files_path = File.join(@root_path, 'workflow', 'sample_files')
     @tmp_hpxml_path = File.join(@sample_files_path, 'tmp.xml')
@@ -25,7 +24,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     @args_hash['output_dir'] = File.absolute_path(@tmp_output_path)
   end
 
-  def after_teardown
+  def teardown
     File.delete(@tmp_hpxml_path) if File.exist? @tmp_hpxml_path
     FileUtils.rm_rf(@tmp_output_path)
   end
@@ -48,7 +47,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.header.allow_increased_fixed_capacities = true
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_header_values(hpxml_default, false, 30, 2, 2, 11, 11, 2008, false, 3, 3, 10, 10, false, true)
+    _test_default_header_values(hpxml_default, 30, 2, 2, 11, 11, 2008, false, 3, 3, 10, 10, false, true)
 
     # Test defaults - DST not in weather file
     hpxml.header.timestep = nil
@@ -66,7 +65,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.header.allow_increased_fixed_capacities = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_header_values(hpxml_default, true, 60, 1, 1, 12, 31, 2007, true, 3, 12, 11, 5, true, false)
+    _test_default_header_values(hpxml_default, 60, 1, 1, 12, 31, 2007, true, 3, 12, 11, 5, true, false)
 
     # Test defaults - DST in weather file
     hpxml = _create_hpxml('base-location-AMY-2012.xml')
@@ -85,24 +84,24 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.header.allow_increased_fixed_capacities = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_header_values(hpxml_default, true, 60, 1, 1, 12, 31, 2012, true, 3, 11, 11, 4, true, false)
+    _test_default_header_values(hpxml_default, 60, 1, 1, 12, 31, 2012, true, 3, 11, 11, 4, true, false)
   end
 
   def test_site
     # Test inputs not overridden by defaults
     hpxml = _create_hpxml('base.xml')
     hpxml.site.site_type = HPXML::SiteTypeRural
-    hpxml.site.shelter_coefficient = 0.3
+    hpxml.site.shielding_of_home = HPXML::ShieldingExposed
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_site_values(hpxml_default, false, HPXML::SiteTypeRural, 0.3)
+    _test_default_site_values(hpxml_default, HPXML::SiteTypeRural, HPXML::ShieldingExposed)
 
     # Test defaults
     hpxml.site.site_type = nil
-    hpxml.site.shelter_coefficient = nil
+    hpxml.site.shielding_of_home = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_site_values(hpxml_default, true, HPXML::SiteTypeSuburban, 0.5)
+    _test_default_site_values(hpxml_default, HPXML::SiteTypeSuburban, HPXML::ShieldingNormal)
   end
 
   def test_occupancy
@@ -111,13 +110,13 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.building_occupancy.number_of_residents = 1
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_occupancy_values(hpxml_default, false, 1)
+    _test_default_occupancy_values(hpxml_default, 1)
 
     # Test defaults
     hpxml.building_occupancy.number_of_residents = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_occupancy_values(hpxml_default, true, 3)
+    _test_default_occupancy_values(hpxml_default, 3)
   end
 
   def test_building_construction
@@ -128,7 +127,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     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, false, 20000, 7, true, 4)
+    _test_default_building_construction_values(hpxml_default, 20000, 7, true, 4)
 
     # Test defaults
     hpxml.building_construction.conditioned_building_volume = nil
@@ -137,21 +136,21 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     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, true, 21600, 8, false, 2)
+    _test_default_building_construction_values(hpxml_default, 21600, 8, false, 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, true, 27000, 10, false, 2)
+    _test_default_building_construction_values(hpxml_default, 27000, 10, false, 2)
 
     # Test defaults w/ average ceiling height
-    hpxml.building_construction.conditioned_building_volume = 27000
+    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, true, 27000, 10, false, 2)
+    _test_default_building_construction_values(hpxml_default, 20000, 7.4, false, 2)
   end
 
   def test_infiltration
@@ -160,20 +159,20 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.air_infiltration_measurements[0].infiltration_volume = 25000
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_infiltration_values(hpxml_default, false, 25000)
+    _test_default_infiltration_values(hpxml_default, 25000)
 
     # Test defaults w/ conditioned basement
     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, true, 2700 * 8)
+    _test_default_infiltration_values(hpxml_default, 2700 * 8)
 
     # 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, true, 1350 * 8)
+    _test_default_infiltration_values(hpxml_default, 1350 * 8)
   end
 
   def test_attics
@@ -182,13 +181,13 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.attics[0].vented_attic_sla = 0.001
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_attic_values(hpxml_default, false, 0.001)
+    _test_default_attic_values(hpxml_default, 0.001)
 
     # Test defaults
     hpxml.attics[0].vented_attic_sla = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_attic_values(hpxml_default, true, 1.0 / 300.0)
+    _test_default_attic_values(hpxml_default, 1.0 / 300.0)
   end
 
   def test_foundations
@@ -197,13 +196,13 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.foundations[0].vented_crawlspace_sla = 0.001
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_foundation_values(hpxml_default, false, 0.001)
+    _test_default_foundation_values(hpxml_default, 0.001)
 
     # Test defaults
     hpxml.foundations[0].vented_crawlspace_sla = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_foundation_values(hpxml_default, true, 1.0 / 150.0)
+    _test_default_foundation_values(hpxml_default, 1.0 / 150.0)
   end
 
   def test_roofs
@@ -215,7 +214,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.roofs[0].emittance = 0.88
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_roof_values(hpxml_default, false, HPXML::RoofTypeMetal, 0.77, HPXML::ColorDark, 0.88, true)
+    _test_default_roof_values(hpxml_default, HPXML::RoofTypeMetal, 0.77, HPXML::ColorDark, 0.88, true)
 
     # Test defaults w/ RoofColor
     hpxml.roofs[0].roof_type = nil
@@ -225,14 +224,14 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.roofs[0].radiant_barrier = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_roof_values(hpxml_default, true, HPXML::RoofTypeAsphaltShingles, 0.75, HPXML::ColorLight, 0.90, false)
+    _test_default_roof_values(hpxml_default, HPXML::RoofTypeAsphaltShingles, 0.75, HPXML::ColorLight, 0.90, false)
 
     # Test defaults w/ SolarAbsorptance
     hpxml.roofs[0].solar_absorptance = 0.99
     hpxml.roofs[0].roof_color = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_roof_values(hpxml_default, true, HPXML::RoofTypeAsphaltShingles, 0.99, HPXML::ColorDark, 0.90, false)
+    _test_default_roof_values(hpxml_default, HPXML::RoofTypeAsphaltShingles, 0.99, HPXML::ColorDark, 0.90, false)
   end
 
   def test_rim_joists
@@ -244,7 +243,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.rim_joists[0].emittance = 0.88
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_rim_joist_values(hpxml_default, false, HPXML::SidingTypeBrick, 0.55, HPXML::ColorLight, 0.88)
+    _test_default_rim_joist_values(hpxml_default, HPXML::SidingTypeBrick, 0.55, HPXML::ColorLight, 0.88)
 
     # Test defaults w/ Color
     hpxml.rim_joists[0].siding = nil
@@ -253,14 +252,14 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.rim_joists[0].emittance = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_rim_joist_values(hpxml_default, true, HPXML::SidingTypeWood, 0.95, HPXML::ColorDark, 0.90)
+    _test_default_rim_joist_values(hpxml_default, HPXML::SidingTypeWood, 0.95, HPXML::ColorDark, 0.90)
 
     # Test defaults w/ SolarAbsorptance
     hpxml.rim_joists[0].solar_absorptance = 0.99
     hpxml.rim_joists[0].color = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_rim_joist_values(hpxml_default, true, HPXML::SidingTypeWood, 0.99, HPXML::ColorDark, 0.90)
+    _test_default_rim_joist_values(hpxml_default, HPXML::SidingTypeWood, 0.99, HPXML::ColorDark, 0.90)
   end
 
   def test_walls
@@ -272,7 +271,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.walls[0].emittance = 0.88
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_wall_values(hpxml_default, false, HPXML::SidingTypeFiberCement, 0.66, HPXML::ColorDark, 0.88)
+    _test_default_wall_values(hpxml_default, HPXML::SidingTypeFiberCement, 0.66, HPXML::ColorDark, 0.88)
 
     # Test defaults W/ Color
     hpxml.walls[0].siding = nil
@@ -281,14 +280,14 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.walls[0].emittance = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_wall_values(hpxml_default, true, HPXML::SidingTypeWood, 0.5, HPXML::ColorLight, 0.90)
+    _test_default_wall_values(hpxml_default, HPXML::SidingTypeWood, 0.5, HPXML::ColorLight, 0.90)
 
     # Test defaults W/ SolarAbsorptance
     hpxml.walls[0].solar_absorptance = 0.99
     hpxml.walls[0].color = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_wall_values(hpxml_default, true, HPXML::SidingTypeWood, 0.99, HPXML::ColorDark, 0.90)
+    _test_default_wall_values(hpxml_default, HPXML::SidingTypeWood, 0.99, HPXML::ColorDark, 0.90)
   end
 
   def test_foundation_walls
@@ -297,13 +296,13 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.foundation_walls[0].thickness = 7.0
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_foundation_wall_values(hpxml_default, false, 7.0)
+    _test_default_foundation_wall_values(hpxml_default, 7.0)
 
     # Test defaults
     hpxml.foundation_walls[0].thickness = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_foundation_wall_values(hpxml_default, true, 8.0)
+    _test_default_foundation_wall_values(hpxml_default, 8.0)
   end
 
   def test_slabs
@@ -314,7 +313,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.slabs[0].carpet_fraction = 0.5
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_slab_values(hpxml_default, false, 7.0, 1.1, 0.5)
+    _test_default_slab_values(hpxml_default, 7.0, 1.1, 0.5)
 
     # Test defaults w/ conditioned basement
     hpxml.slabs[0].thickness = nil
@@ -322,7 +321,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.slabs[0].carpet_fraction = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_slab_values(hpxml_default, true, 4.0, 2.0, 0.8)
+    _test_default_slab_values(hpxml_default, 4.0, 2.0, 0.8)
 
     # Test defaults w/ crawlspace
     hpxml = _create_hpxml('base-foundation-unvented-crawlspace.xml')
@@ -331,55 +330,63 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.slabs[0].carpet_fraction = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_slab_values(hpxml_default, true, 0.0, 0.0, 0.0)
+    _test_default_slab_values(hpxml_default, 0.0, 0.0, 0.0)
   end
 
   def test_windows
     # Test inputs not overridden by defaults
-    hpxml = _create_hpxml('base-enclosure-windows-interior-shading.xml')
+    hpxml = _create_hpxml('base-enclosure-windows-shading.xml')
     hpxml.windows.each do |window|
       window.fraction_operable = 0.5
+      window.exterior_shading_factor_summer = 0.44
+      window.exterior_shading_factor_winter = 0.55
       window.interior_shading_factor_summer = 0.66
       window.interior_shading_factor_winter = 0.77
     end
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
     n_windows = hpxml_default.windows.size
-    _test_default_window_values(hpxml_default, false, [0.66] * n_windows, [0.77] * n_windows, [0.5] * n_windows)
+    _test_default_window_values(hpxml_default, [0.44] * n_windows, [0.55] * n_windows, [0.66] * n_windows, [0.77] * n_windows, [0.5] * n_windows)
 
     # Test defaults
     hpxml.windows.each do |window|
       window.fraction_operable = nil
+      window.exterior_shading_factor_summer = nil
+      window.exterior_shading_factor_winter = nil
       window.interior_shading_factor_summer = nil
       window.interior_shading_factor_winter = nil
     end
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
     n_windows = hpxml_default.windows.size
-    _test_default_window_values(hpxml_default, true, [0.7] * n_windows, [0.85] * n_windows, [0.67] * n_windows)
+    _test_default_window_values(hpxml_default, [1.0] * n_windows, [1.0] * n_windows, [0.7] * n_windows, [0.85] * n_windows, [0.67] * n_windows)
   end
 
   def test_skylights
     # Test inputs not overridden by defaults
     hpxml = _create_hpxml('base-enclosure-skylights.xml')
     hpxml.skylights.each do |skylight|
+      skylight.exterior_shading_factor_summer = 0.44
+      skylight.exterior_shading_factor_winter = 0.55
       skylight.interior_shading_factor_summer = 0.66
       skylight.interior_shading_factor_winter = 0.77
     end
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
     n_skylights = hpxml_default.skylights.size
-    _test_default_skylight_values(hpxml_default, false, [0.66] * n_skylights, [0.77] * n_skylights)
+    _test_default_skylight_values(hpxml_default, [0.44] * n_skylights, [0.55] * n_skylights, [0.66] * n_skylights, [0.77] * n_skylights)
 
     # Test defaults
     hpxml.skylights.each do |skylight|
+      skylight.exterior_shading_factor_summer = nil
+      skylight.exterior_shading_factor_winter = nil
       skylight.interior_shading_factor_summer = nil
       skylight.interior_shading_factor_winter = nil
     end
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
     n_skylights = hpxml_default.skylights.size
-    _test_default_skylight_values(hpxml_default, true, [1.0] * n_skylights, [1.0] * n_skylights)
+    _test_default_skylight_values(hpxml_default, [1.0] * n_skylights, [1.0] * n_skylights, [1.0] * n_skylights, [1.0] * n_skylights)
   end
 
   def test_central_air_conditioners
@@ -388,32 +395,55 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.cooling_systems[0].cooling_shr = 0.88
     hpxml.cooling_systems[0].compressor_type = HPXML::HVACCompressorTypeVariableSpeed
     hpxml.cooling_systems[0].fan_watts_per_cfm = 0.66
+    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
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_central_air_conditioner_values(hpxml_default, false, 0.88, HPXML::HVACCompressorTypeVariableSpeed, 0.66)
+    _test_default_central_air_conditioner_values(hpxml_default, 0.88, HPXML::HVACCompressorTypeVariableSpeed, 0.66, -0.11, -0.22, 12345)
 
     # Test defaults
     hpxml.cooling_systems[0].cooling_shr = nil
     hpxml.cooling_systems[0].compressor_type = nil
     hpxml.cooling_systems[0].fan_watts_per_cfm = nil
+    hpxml.cooling_systems[0].charge_defect_ratio = nil
+    hpxml.cooling_systems[0].airflow_defect_ratio = nil
+    hpxml.cooling_systems[0].cooling_capacity = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_central_air_conditioner_values(hpxml_default, true, 0.73, HPXML::HVACCompressorTypeSingleStage, 0.5)
+    _test_default_central_air_conditioner_values(hpxml_default, 0.73, HPXML::HVACCompressorTypeSingleStage, 0.5, 0, 0, nil)
   end
 
   def test_room_air_conditioners
     # Test inputs not overridden by defaults
     hpxml = _create_hpxml('base-hvac-room-ac-only.xml')
     hpxml.cooling_systems[0].cooling_shr = 0.88
+    hpxml.cooling_systems[0].cooling_capacity = 12345
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_room_air_conditioner_values(hpxml_default, false, 0.88)
+    _test_default_room_air_conditioner_values(hpxml_default, 0.88, 12345)
 
     # Test defaults
     hpxml.cooling_systems[0].cooling_shr = nil
+    hpxml.cooling_systems[0].cooling_capacity = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_room_air_conditioner_values(hpxml_default, true, 0.65)
+    _test_default_room_air_conditioner_values(hpxml_default, 0.65, nil)
+  end
+
+  def test_evaporative_coolers
+    # Test inputs not overridden by defaults
+    hpxml = _create_hpxml('base-hvac-evap-cooler-only.xml')
+    hpxml.cooling_systems[0].cooling_capacity = 12345
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_evap_cooler_values(hpxml_default, 12345)
+
+    # Test defaults
+    hpxml.cooling_systems[0].cooling_capacity = nil
+    XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
+    hpxml_default = _test_measure()
+    _test_default_evap_cooler_values(hpxml_default, nil)
   end
 
   def test_mini_split_air_conditioners
@@ -421,76 +451,101 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml = _create_hpxml('base-hvac-mini-split-air-conditioner-only-ducted.xml')
     hpxml.cooling_systems[0].cooling_shr = 0.78
     hpxml.cooling_systems[0].fan_watts_per_cfm = 0.66
+    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
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_mini_split_air_conditioner_values(hpxml_default, false, 0.78, 0.66)
+    _test_default_mini_split_air_conditioner_values(hpxml_default, 0.78, 0.66, -0.11, -0.22, 12345)
 
     # Test defaults
     hpxml.cooling_systems[0].cooling_shr = nil
     hpxml.cooling_systems[0].fan_watts_per_cfm = nil
+    hpxml.cooling_systems[0].charge_defect_ratio = nil
+    hpxml.cooling_systems[0].airflow_defect_ratio = nil
+    hpxml.cooling_systems[0].cooling_capacity = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_mini_split_air_conditioner_values(hpxml_default, true, 0.73, 0.18)
+    _test_default_mini_split_air_conditioner_values(hpxml_default, 0.73, 0.18, 0, 0, nil)
   end
 
   def test_furnaces
     # Test inputs not overridden by defaults
     hpxml = _create_hpxml('base.xml')
     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
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_furnace_values(hpxml_default, false, 0.66)
+    _test_default_furnace_values(hpxml_default, 0.66, -0.22, 12345)
 
     # 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
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_furnace_values(hpxml_default, true, 0.375)
+    _test_default_furnace_values(hpxml_default, 0.375, 0, nil)
+
+    # Test defaults w/ gravity distribution system
+    hpxml = _create_hpxml('base-hvac-furnace-gas-only.xml')
+    hpxml.heating_systems[0].distribution_system.air_type = HPXML::AirTypeGravity
+    hpxml.heating_systems[0].fan_watts_per_cfm = nil
+    hpxml.heating_systems[0].airflow_defect_ratio = nil
+    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, 0.0, 0, nil)
   end
 
   def test_wall_furnaces
     # Test inputs not overridden by defaults
     hpxml = _create_hpxml('base-hvac-wall-furnace-elec-only.xml')
     hpxml.heating_systems[0].fan_watts = 22
+    hpxml.heating_systems[0].heating_capacity = 12345
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_wall_furnace_values(hpxml_default, false, 22)
+    _test_default_wall_furnace_values(hpxml_default, 22, 12345)
 
     # Test defaults
     hpxml.heating_systems[0].fan_watts = nil
+    hpxml.heating_systems[0].heating_capacity = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_wall_furnace_values(hpxml_default, true, 0)
+    _test_default_wall_furnace_values(hpxml_default, 0, nil)
   end
 
   def test_floor_furnaces
     # Test inputs not overridden by defaults
     hpxml = _create_hpxml('base-hvac-floor-furnace-propane-only.xml')
     hpxml.heating_systems[0].fan_watts = 22
+    hpxml.heating_systems[0].heating_capacity = 12345
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_floor_furnace_values(hpxml_default, false, 22)
+    _test_default_floor_furnace_values(hpxml_default, 22, 12345)
 
     # Test defaults
     hpxml.heating_systems[0].fan_watts = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_floor_furnace_values(hpxml_default, true, 0)
+    _test_default_floor_furnace_values(hpxml_default, 0, nil)
   end
 
   def test_boilers
     # Test inputs not overridden by defaults (in-unit boiler)
     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
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_boiler_values(hpxml_default, false, 99.9)
+    _test_default_boiler_values(hpxml_default, 99.9, 12345)
 
     # Test defaults w/ in-unit boiler
     hpxml.heating_systems[0].electric_auxiliary_energy = nil
+    hpxml.heating_systems[0].heating_capacity = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_boiler_values(hpxml_default, true, 170.0)
+    _test_default_boiler_values(hpxml_default, 170.0, nil)
 
     # Test inputs not overridden by defaults (shared boiler)
     hpxml = _create_hpxml('base-bldgtype-multifamily-shared-boiler-only-baseboard.xml')
@@ -498,73 +553,81 @@ 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, false, 99.9)
+    _test_default_boiler_values(hpxml_default, 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, true, 220.0)
+    _test_default_boiler_values(hpxml_default, 220.0, nil)
   end
 
   def test_stoves
     # Test inputs not overridden by defaults
     hpxml = _create_hpxml('base-hvac-stove-oil-only.xml')
     hpxml.heating_systems[0].fan_watts = 22
+    hpxml.heating_systems[0].heating_capacity = 12345
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_stove_values(hpxml_default, false, 22)
+    _test_default_stove_values(hpxml_default, 22, 12345)
 
     # Test defaults
     hpxml.heating_systems[0].fan_watts = nil
+    hpxml.heating_systems[0].heating_capacity = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_stove_values(hpxml_default, true, 40)
+    _test_default_stove_values(hpxml_default, 40, nil)
   end
 
   def test_portable_heaters
     # Test inputs not overridden by defaults
     hpxml = _create_hpxml('base-hvac-portable-heater-gas-only.xml')
     hpxml.heating_systems[0].fan_watts = 22
+    hpxml.heating_systems[0].heating_capacity = 12345
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_portable_heater_values(hpxml_default, false, 22)
+    _test_default_portable_heater_values(hpxml_default, 22, 12345)
 
     # Test defaults
     hpxml.heating_systems[0].fan_watts = nil
+    hpxml.heating_systems[0].heating_capacity = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_portable_heater_values(hpxml_default, true, 0)
+    _test_default_portable_heater_values(hpxml_default, 0, nil)
   end
 
   def test_fixed_heaters
     # Test inputs not overridden by defaults
     hpxml = _create_hpxml('base-hvac-fixed-heater-gas-only.xml')
     hpxml.heating_systems[0].fan_watts = 22
+    hpxml.heating_systems[0].heating_capacity = 12345
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_fixed_heater_values(hpxml_default, false, 22)
+    _test_default_fixed_heater_values(hpxml_default, 22, 12345)
 
     # Test defaults
     hpxml.heating_systems[0].fan_watts = nil
+    hpxml.heating_systems[0].heating_capacity = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_fixed_heater_values(hpxml_default, true, 0)
+    _test_default_fixed_heater_values(hpxml_default, 0, nil)
   end
 
   def test_fireplaces
     # Test inputs not overridden by defaults
     hpxml = _create_hpxml('base-hvac-fireplace-wood-only.xml')
     hpxml.heating_systems[0].fan_watts = 22
+    hpxml.heating_systems[0].heating_capacity = 12345
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_fireplace_values(hpxml_default, false, 22)
+    _test_default_fireplace_values(hpxml_default, 22, 12345)
 
     # Test defaults
     hpxml.heating_systems[0].fan_watts = nil
+    hpxml.heating_systems[0].heating_capacity = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_fireplace_values(hpxml_default, true, 0)
+    _test_default_fireplace_values(hpxml_default, 0, nil)
   end
 
   def test_air_source_heat_pumps
@@ -573,17 +636,29 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.heat_pumps[0].cooling_shr = 0.88
     hpxml.heat_pumps[0].compressor_type = HPXML::HVACCompressorTypeVariableSpeed
     hpxml.heat_pumps[0].fan_watts_per_cfm = 0.66
+    hpxml.heat_pumps[0].charge_defect_ratio = -0.11
+    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
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_air_to_air_heat_pump_values(hpxml_default, false, 0.88, HPXML::HVACCompressorTypeVariableSpeed, 0.66)
+    _test_default_air_to_air_heat_pump_values(hpxml_default, 0.88, HPXML::HVACCompressorTypeVariableSpeed, 0.66, -0.11, -0.22, 12345, 23456, 9876, 34567)
 
     # Test defaults
     hpxml.heat_pumps[0].cooling_shr = nil
     hpxml.heat_pumps[0].compressor_type = nil
     hpxml.heat_pumps[0].fan_watts_per_cfm = nil
+    hpxml.heat_pumps[0].charge_defect_ratio = nil
+    hpxml.heat_pumps[0].airflow_defect_ratio = nil
+    hpxml.heat_pumps[0].cooling_capacity = nil
+    hpxml.heat_pumps[0].heating_capacity = nil
+    hpxml.heat_pumps[0].heating_capacity_17F = nil
+    hpxml.heat_pumps[0].backup_heating_capacity = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_air_to_air_heat_pump_values(hpxml_default, true, 0.73, HPXML::HVACCompressorTypeSingleStage, 0.5)
+    _test_default_air_to_air_heat_pump_values(hpxml_default, 0.73, HPXML::HVACCompressorTypeSingleStage, 0.5, 0, 0, nil, nil, nil, nil)
   end
 
   def test_mini_split_heat_pumps
@@ -591,33 +666,82 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml = _create_hpxml('base-hvac-mini-split-heat-pump-ducted.xml')
     hpxml.heat_pumps[0].cooling_shr = 0.78
     hpxml.heat_pumps[0].fan_watts_per_cfm = 0.66
+    hpxml.heat_pumps[0].charge_defect_ratio = -0.11
+    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
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_mini_split_heat_pump_values(hpxml_default, false, 0.78, 0.66)
+    _test_default_mini_split_heat_pump_values(hpxml_default, 0.78, 0.66, -0.11, -0.22, 12345, 23456, 9876, 34567)
 
     # Test defaults
     hpxml.heat_pumps[0].cooling_shr = nil
     hpxml.heat_pumps[0].fan_watts_per_cfm = nil
+    hpxml.heat_pumps[0].charge_defect_ratio = nil
+    hpxml.heat_pumps[0].airflow_defect_ratio = nil
+    hpxml.heat_pumps[0].cooling_capacity = nil
+    hpxml.heat_pumps[0].heating_capacity = nil
+    hpxml.heat_pumps[0].heating_capacity_17F = nil
+    hpxml.heat_pumps[0].backup_heating_capacity = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_mini_split_heat_pump_values(hpxml_default, true, 0.73, 0.18)
+    _test_default_mini_split_heat_pump_values(hpxml_default, 0.73, 0.18, 0, 0, nil, nil, nil, nil)
   end
 
-  def test_ground_to_air_heat_pumps
+  def test_ground_source_heat_pumps
     # Test inputs not overridden by defaults
     hpxml = _create_hpxml('base-hvac-ground-to-air-heat-pump.xml')
     hpxml.heat_pumps[0].pump_watts_per_ton = 9.9
-    hpxml.heat_pumps[0].fan_watts_per_cfm = 0.99
+    hpxml.heat_pumps[0].fan_watts_per_cfm = 0.66
+    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].backup_heating_capacity = 34567
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_ground_to_air_heat_pump_values(hpxml_default, false, 9.9, 0.99)
+    _test_default_ground_to_air_heat_pump_values(hpxml_default, 9.9, 0.66, -0.22, 12345, 23456, 34567)
 
     # Test defaults
     hpxml.heat_pumps[0].pump_watts_per_ton = nil
     hpxml.heat_pumps[0].fan_watts_per_cfm = nil
+    hpxml.heat_pumps[0].airflow_defect_ratio = nil
+    hpxml.heat_pumps[0].cooling_capacity = nil
+    hpxml.heat_pumps[0].heating_capacity = nil
+    hpxml.heat_pumps[0].backup_heating_capacity = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_ground_to_air_heat_pump_values(hpxml_default, true, 30.0, 0.375)
+    _test_default_ground_to_air_heat_pump_values(hpxml_default, 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
+    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 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
+    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)
   end
 
   def test_hvac_controls
@@ -627,20 +751,19 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.hvac_controls[0].cooling_setup_start_hour = 12
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_hvac_control_values(hpxml_default, false, 12, 12)
+    _test_default_hvac_control_values(hpxml_default, 12, 12)
 
     # Test defaults
     hpxml.hvac_controls[0].heating_setback_start_hour = nil
     hpxml.hvac_controls[0].cooling_setup_start_hour = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_hvac_control_values(hpxml_default, true, 23, 9)
+    _test_default_hvac_control_values(hpxml_default, 23, 9)
   end
 
   def test_hvac_distribution
     # Test inputs not overridden by defaults
     hpxml = _create_hpxml('base.xml')
-    hpxml.hvac_distributions[0].number_of_return_registers = hpxml.building_construction.number_of_conditioned_floors
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
     expected_supply_locations = ['attic - unvented']
@@ -648,7 +771,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     expected_supply_areas = [150.0]
     expected_return_areas = [50.0]
     expected_n_return_registers = hpxml_default.building_construction.number_of_conditioned_floors
-    _test_default_duct_values(hpxml_default, false, expected_supply_locations, expected_return_locations, expected_supply_areas, expected_return_areas, expected_n_return_registers)
+    _test_default_duct_values(hpxml_default, expected_supply_locations, expected_return_locations, expected_supply_areas, expected_return_areas, expected_n_return_registers)
 
     # Test defaults w/ conditioned basement
     hpxml.hvac_distributions[0].number_of_return_registers = nil
@@ -665,7 +788,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     expected_supply_areas = [729.0]
     expected_return_areas = [270.0]
     expected_n_return_registers = hpxml_default.building_construction.number_of_conditioned_floors
-    _test_default_duct_values(hpxml_default, true, expected_supply_locations, expected_return_locations, expected_supply_areas, expected_return_areas, expected_n_return_registers)
+    _test_default_duct_values(hpxml_default, expected_supply_locations, expected_return_locations, expected_supply_areas, expected_return_areas, expected_n_return_registers)
 
     # Test defaults w/ multiple foundations
     hpxml = _create_hpxml('base-foundation-multiple.xml')
@@ -682,7 +805,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     expected_supply_areas = [364.5]
     expected_return_areas = [67.5]
     expected_n_return_registers = hpxml_default.building_construction.number_of_conditioned_floors
-    _test_default_duct_values(hpxml_default, true, expected_supply_locations, expected_return_locations, expected_supply_areas, expected_return_areas, expected_n_return_registers)
+    _test_default_duct_values(hpxml_default, expected_supply_locations, expected_return_locations, expected_supply_areas, expected_return_areas, expected_n_return_registers)
 
     # Test defaults w/ foundation exposed to ambient
     hpxml = _create_hpxml('base-foundation-ambient.xml')
@@ -699,7 +822,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     expected_supply_areas = [364.5]
     expected_return_areas = [67.5]
     expected_n_return_registers = hpxml_default.building_construction.number_of_conditioned_floors
-    _test_default_duct_values(hpxml_default, true, expected_supply_locations, expected_return_locations, expected_supply_areas, expected_return_areas, expected_n_return_registers)
+    _test_default_duct_values(hpxml_default, expected_supply_locations, expected_return_locations, expected_supply_areas, expected_return_areas, expected_n_return_registers)
 
     # Test defaults w/ building/unit adjacent to other housing unit
     hpxml = _create_hpxml('base-bldgtype-multifamily-adjacent-to-other-housing-unit.xml')
@@ -716,7 +839,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     expected_supply_areas = [243.0]
     expected_return_areas = [45.0]
     expected_n_return_registers = hpxml_default.building_construction.number_of_conditioned_floors
-    _test_default_duct_values(hpxml_default, true, expected_supply_locations, expected_return_locations, expected_supply_areas, expected_return_areas, expected_n_return_registers)
+    _test_default_duct_values(hpxml_default, expected_supply_locations, expected_return_locations, expected_supply_areas, expected_return_areas, expected_n_return_registers)
 
     # Test defaults w/ 2-story building
     hpxml = _create_hpxml('base-enclosure-2stories.xml')
@@ -733,7 +856,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     expected_supply_areas = [820.13, 273.38]
     expected_return_areas = [455.63, 151.88]
     expected_n_return_registers = hpxml_default.building_construction.number_of_conditioned_floors
-    _test_default_duct_values(hpxml_default, true, expected_supply_locations, expected_return_locations, expected_supply_areas, expected_return_areas, expected_n_return_registers)
+    _test_default_duct_values(hpxml_default, expected_supply_locations, expected_return_locations, expected_supply_areas, expected_return_areas, expected_n_return_registers)
 
     # Test defaults w/ 1-story building & multiple HVAC systems
     hpxml = _create_hpxml('base-hvac-multiple.xml')
@@ -747,10 +870,10 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml_default = _test_measure()
     expected_supply_locations = ['basement - conditioned', 'basement - conditioned'] * hpxml_default.hvac_distributions.size
     expected_return_locations = ['basement - conditioned', 'basement - conditioned'] * hpxml_default.hvac_distributions.size
-    expected_supply_areas = [91.125, 91.125] * hpxml_default.hvac_distributions.size
-    expected_return_areas = [33.75, 33.75] * hpxml_default.hvac_distributions.size
+    expected_supply_areas = [36.45, 36.45] * hpxml_default.hvac_distributions.size
+    expected_return_areas = [13.5, 13.5] * hpxml_default.hvac_distributions.size
     expected_n_return_registers = hpxml_default.building_construction.number_of_conditioned_floors
-    _test_default_duct_values(hpxml_default, true, expected_supply_locations, expected_return_locations, expected_supply_areas, expected_return_areas, expected_n_return_registers)
+    _test_default_duct_values(hpxml_default, expected_supply_locations, expected_return_locations, expected_supply_areas, expected_return_areas, expected_n_return_registers)
 
     # Test defaults w/ 2-story building & multiple HVAC systems
     hpxml = _create_hpxml('base-hvac-multiple.xml')
@@ -765,10 +888,10 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml_default = _test_measure()
     expected_supply_locations = ['basement - conditioned', 'basement - conditioned', 'living space', 'living space'] * hpxml_default.hvac_distributions.size
     expected_return_locations = ['basement - conditioned', 'basement - conditioned', 'living space', 'living space'] * hpxml_default.hvac_distributions.size
-    expected_supply_areas = [68.34, 68.34, 22.78, 22.78] * hpxml_default.hvac_distributions.size
-    expected_return_areas = [25.31, 25.31, 8.44, 8.44] * hpxml_default.hvac_distributions.size
+    expected_supply_areas = [27.34, 27.34, 9.11, 9.11] * hpxml_default.hvac_distributions.size
+    expected_return_areas = [10.13, 10.13, 3.38, 3.38] * hpxml_default.hvac_distributions.size
     expected_n_return_registers = hpxml_default.building_construction.number_of_conditioned_floors
-    _test_default_duct_values(hpxml_default, true, expected_supply_locations, expected_return_locations, expected_supply_areas, expected_return_areas, expected_n_return_registers)
+    _test_default_duct_values(hpxml_default, expected_supply_locations, expected_return_locations, expected_supply_areas, expected_return_areas, expected_n_return_registers)
   end
 
   def test_mech_ventilation_fans
@@ -782,7 +905,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     vent_fan.hours_in_operation = 22.0
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_mech_vent_values(hpxml_default, false, true, 22.0)
+    _test_default_mech_vent_values(hpxml_default, true, 22.0)
 
     # Test defaults
     vent_fan.rated_flow_rate = nil
@@ -794,7 +917,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     vent_fan.hours_in_operation = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_mech_vent_values(hpxml_default, true, false, 24.0)
+    _test_default_mech_vent_values(hpxml_default, false, 24.0)
 
     # Test inputs not overridden by defaults w/ CFIS
     hpxml = _create_hpxml('base-mechvent-cfis.xml')
@@ -803,14 +926,14 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     vent_fan.hours_in_operation = 12.0
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_mech_vent_values(hpxml_default, false, false, 12.0)
+    _test_default_mech_vent_values(hpxml_default, false, 12.0)
 
     # Test defaults w/ CFIS
     vent_fan.is_shared_system = nil
     vent_fan.hours_in_operation = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_mech_vent_values(hpxml_default, true, false, 8.0)
+    _test_default_mech_vent_values(hpxml_default, false, 8.0)
   end
 
   def test_local_ventilation_fans
@@ -830,8 +953,8 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     bath_fan.hours_in_operation = 3
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_kitchen_fan_values(hpxml_default, false, 2, 300, 2, 20, 12)
-    _test_default_bath_fan_values(hpxml_default, false, 3, 80, 3, 33, 6)
+    _test_default_kitchen_fan_values(hpxml_default, 2, 300, 2, 20, 12)
+    _test_default_bath_fan_values(hpxml_default, 3, 80, 3, 33, 6)
 
     # Test defaults
     kitchen_fan.rated_flow_rate = nil
@@ -846,8 +969,8 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     bath_fan.hours_in_operation = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_kitchen_fan_values(hpxml_default, true, 1, 100, 1, 30, 18)
-    _test_default_bath_fan_values(hpxml_default, true, 2, 50, 1, 15, 7)
+    _test_default_kitchen_fan_values(hpxml_default, 1, 100, 1, 30, 18)
+    _test_default_bath_fan_values(hpxml_default, 2, 50, 1, 15, 7)
   end
 
   def test_storage_water_heaters
@@ -865,7 +988,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     end
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_storage_water_heater_values(hpxml_default, false,
+    _test_default_storage_water_heater_values(hpxml_default,
                                               [true, 15000.0, 40.0, 0.95, HPXML::LocationLivingSpace, 111])
 
     # Test defaults w/ 3-bedroom house & electric storage water heater
@@ -879,7 +1002,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     end
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_storage_water_heater_values(hpxml_default, true,
+    _test_default_storage_water_heater_values(hpxml_default,
                                               [false, 18766.7, 50.0, 0.98, HPXML::LocationBasementConditioned, 125])
 
     # Test defaults w/ 5-bedroom house & electric storage water heater
@@ -894,7 +1017,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     end
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_storage_water_heater_values(hpxml_default, true,
+    _test_default_storage_water_heater_values(hpxml_default,
                                               [false, 18766.7, 66.0, 0.98, HPXML::LocationBasementConditioned, 125])
 
     # Test defaults w/ 3-bedroom house & 2 storage water heaters (1 electric and 1 natural gas)
@@ -911,7 +1034,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     end
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_storage_water_heater_values(hpxml_default, true,
+    _test_default_storage_water_heater_values(hpxml_default,
                                               [false, 15354.6, 50.0, 0.98, HPXML::LocationBasementConditioned, 125],
                                               [false, 36000.0, 40.0, 0.756, HPXML::LocationBasementConditioned, 125])
   end
@@ -922,13 +1045,13 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.water_heating_systems[0].performance_adjustment = 0.88
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_tankless_water_heater_values(hpxml_default, false, [0.88])
+    _test_default_tankless_water_heater_values(hpxml_default, [0.88])
 
     # Test defaults w/ EF
     hpxml.water_heating_systems[0].performance_adjustment = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_tankless_water_heater_values(hpxml_default, true, [0.92])
+    _test_default_tankless_water_heater_values(hpxml_default, [0.92])
 
     # Test defaults w/ UEF
     hpxml.water_heating_systems[0].energy_factor = nil
@@ -936,7 +1059,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.water_heating_systems[0].first_hour_rating = 5.7
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_tankless_water_heater_values(hpxml_default, true, [0.94])
+    _test_default_tankless_water_heater_values(hpxml_default, [0.94])
   end
 
   def test_hot_water_distribution
@@ -945,7 +1068,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.hot_water_distributions[0].pipe_r_value = 2.5
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_standard_distribution_values(hpxml_default, false, 50.0, 2.5)
+    _test_default_standard_distribution_values(hpxml_default, 50.0, 2.5)
 
     # Test inputs not overridden by defaults -- recirculation
     hpxml = _create_hpxml('base-dhw-recirc-demand.xml')
@@ -953,14 +1076,14 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.hot_water_distributions[0].pipe_r_value = 2.5
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_recirc_distribution_values(hpxml_default, false, 50.0, 50.0, 65.0, 2.5)
+    _test_default_recirc_distribution_values(hpxml_default, 50.0, 50.0, 65.0, 2.5)
 
     # Test inputs not overridden by defaults -- shared recirculation
     hpxml = _create_hpxml('base-bldgtype-multifamily-shared-water-heater-recirc.xml')
     hpxml.hot_water_distributions[0].shared_recirculation_pump_power = 333.0
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_shared_recirc_distribution_values(hpxml_default, false, 333.0)
+    _test_default_shared_recirc_distribution_values(hpxml_default, 333.0)
 
     # Test defaults w/ conditioned basement
     hpxml = _create_hpxml('base.xml')
@@ -968,7 +1091,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.hot_water_distributions[0].pipe_r_value = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_standard_distribution_values(hpxml_default, true, 93.48, 0.0)
+    _test_default_standard_distribution_values(hpxml_default, 93.48, 0.0)
 
     # Test defaults w/ unconditioned basement
     hpxml = _create_hpxml('base-foundation-unconditioned-basement.xml')
@@ -976,7 +1099,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.hot_water_distributions[0].pipe_r_value = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_standard_distribution_values(hpxml_default, true, 88.48, 0.0)
+    _test_default_standard_distribution_values(hpxml_default, 88.48, 0.0)
 
     # Test defaults w/ 2-story building
     hpxml = _create_hpxml('base-enclosure-2stories.xml')
@@ -984,7 +1107,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.hot_water_distributions[0].pipe_r_value = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_standard_distribution_values(hpxml_default, true, 103.48, 0.0)
+    _test_default_standard_distribution_values(hpxml_default, 103.48, 0.0)
 
     # Test defaults w/ recirculation & conditioned basement
     hpxml = _create_hpxml('base-dhw-recirc-demand.xml')
@@ -994,7 +1117,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.hot_water_distributions[0].pipe_r_value = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_recirc_distribution_values(hpxml_default, true, 166.96, 10.0, 50.0, 0.0)
+    _test_default_recirc_distribution_values(hpxml_default, 166.96, 10.0, 50.0, 0.0)
 
     # Test defaults w/ recirculation & unconditioned basement
     hpxml = _create_hpxml('base-foundation-unconditioned-basement.xml')
@@ -1004,7 +1127,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
                                       recirculation_control_type: HPXML::DHWRecirControlTypeSensor)
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_recirc_distribution_values(hpxml_default, true, 156.96, 10.0, 50.0, 0.0)
+    _test_default_recirc_distribution_values(hpxml_default, 156.96, 10.0, 50.0, 0.0)
 
     # Test defaults w/ recirculation & 2-story building
     hpxml = _create_hpxml('base-enclosure-2stories.xml')
@@ -1014,14 +1137,14 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
                                       recirculation_control_type: HPXML::DHWRecirControlTypeSensor)
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_recirc_distribution_values(hpxml_default, true, 186.96, 10.0, 50.0, 0.0)
+    _test_default_recirc_distribution_values(hpxml_default, 186.96, 10.0, 50.0, 0.0)
 
     # Test defaults w/ shared recirculation
     hpxml = _create_hpxml('base-bldgtype-multifamily-shared-water-heater-recirc.xml')
     hpxml.hot_water_distributions[0].shared_recirculation_pump_power = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_shared_recirc_distribution_values(hpxml_default, true, 220.0)
+    _test_default_shared_recirc_distribution_values(hpxml_default, 220.0)
   end
 
   def test_water_fixtures
@@ -1030,13 +1153,13 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.water_heating.water_fixtures_usage_multiplier = 2.0
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_water_fixture_values(hpxml_default, false, 2.0)
+    _test_default_water_fixture_values(hpxml_default, 2.0)
 
     # Test defaults
     hpxml.water_heating.water_fixtures_usage_multiplier = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_water_fixture_values(hpxml_default, true, 1.0)
+    _test_default_water_fixture_values(hpxml_default, 1.0)
   end
 
   def test_solar_thermal_systems
@@ -1045,20 +1168,20 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.solar_thermal_systems[0].storage_volume = 55.0
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_solar_thermal_values(hpxml_default, false, 55.0)
+    _test_default_solar_thermal_values(hpxml_default, 55.0)
 
     # Test defaults w/ collector area of 40 sqft
     hpxml.solar_thermal_systems[0].storage_volume = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_solar_thermal_values(hpxml_default, true, 60.0)
+    _test_default_solar_thermal_values(hpxml_default, 60.0)
 
     # Test defaults w/ collector area of 100 sqft
     hpxml.solar_thermal_systems[0].collector_area = 100.0
     hpxml.solar_thermal_systems[0].storage_volume = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_solar_thermal_values(hpxml_default, true, 150.0)
+    _test_default_solar_thermal_values(hpxml_default, 150.0)
   end
 
   def test_pv_systems
@@ -1076,7 +1199,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     end
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_pv_system_values(hpxml_default, false, 0.90, 0.20, true, HPXML::LocationGround, HPXML::PVTrackingType1Axis, HPXML::PVModuleTypePremium)
+    _test_default_pv_system_values(hpxml_default, 0.90, 0.20, true, HPXML::LocationGround, HPXML::PVTrackingType1Axis, HPXML::PVModuleTypePremium)
 
     # Test defaults w/o year modules manufactured
     hpxml.pv_systems.each do |pv|
@@ -1089,7 +1212,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     end
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_pv_system_values(hpxml_default, true, 0.96, 0.14, false, HPXML::LocationRoof, HPXML::PVTrackingTypeFixed, HPXML::PVModuleTypeStandard)
+    _test_default_pv_system_values(hpxml_default, 0.96, 0.14, false, HPXML::LocationRoof, HPXML::PVTrackingTypeFixed, HPXML::PVModuleTypeStandard)
 
     # Test defaults w/ year modules manufactured
     hpxml.pv_systems.each do |pv|
@@ -1097,7 +1220,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     end
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_pv_system_values(hpxml_default, true, 0.96, 0.182, false, HPXML::LocationRoof, HPXML::PVTrackingTypeFixed, HPXML::PVModuleTypeStandard)
+    _test_default_pv_system_values(hpxml_default, 0.96, 0.186, false, HPXML::LocationRoof, HPXML::PVTrackingTypeFixed, HPXML::PVModuleTypeStandard)
   end
 
   def test_generators
@@ -1110,7 +1233,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     end
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_generator_values(hpxml_default, false, true)
+    _test_default_generator_values(hpxml_default, true)
 
     # Test defaults
     hpxml.generators.each do |generator|
@@ -1118,7 +1241,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     end
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_generator_values(hpxml_default, true, false)
+    _test_default_generator_values(hpxml_default, false)
   end
 
   def test_clothes_washers
@@ -1134,7 +1257,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.clothes_washers[0].water_heating_system_idref = hpxml.water_heating_systems[0].id
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_clothes_washer_values(hpxml_default, false, true, HPXML::LocationBasementConditioned, 1.21, 380.0, 0.12, 1.09, 27.0, 3.2, 6.0, 1.5)
+    _test_default_clothes_washer_values(hpxml_default, true, HPXML::LocationBasementConditioned, 1.21, 380.0, 0.12, 1.09, 27.0, 3.2, 6.0, 1.5)
 
     # Test defaults
     hpxml.clothes_washers[0].is_shared_appliance = nil
@@ -1149,7 +1272,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.clothes_washers[0].usage_multiplier = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_clothes_washer_values(hpxml_default, true, false, HPXML::LocationLivingSpace, 1.0, 400.0, 0.12, 1.09, 27.0, 3.0, 6.0, 1.0)
+    _test_default_clothes_washer_values(hpxml_default, false, HPXML::LocationLivingSpace, 1.0, 400.0, 0.12, 1.09, 27.0, 3.0, 6.0, 1.0)
 
     # Test defaults before 301-2019 Addendum A
     hpxml = _create_hpxml('base.xml')
@@ -1166,7 +1289,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.clothes_washers[0].usage_multiplier = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_clothes_washer_values(hpxml_default, true, false, HPXML::LocationLivingSpace, 0.331, 704.0, 0.08, 0.58, 23.0, 2.874, 999, 1.0)
+    _test_default_clothes_washer_values(hpxml_default, false, HPXML::LocationLivingSpace, 0.331, 704.0, 0.08, 0.58, 23.0, 2.874, 999, 1.0)
   end
 
   def test_clothes_dryers
@@ -1178,41 +1301,39 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.water_heating_systems[0].fraction_dhw_load_served = 0
     hpxml.clothes_dryers[0].location = HPXML::LocationBasementConditioned
     hpxml.clothes_dryers[0].is_shared_appliance = true
-    hpxml.clothes_dryers[0].control_type = HPXML::ClothesDryerControlTypeMoisture
     hpxml.clothes_dryers[0].combined_energy_factor = 3.33
     hpxml.clothes_dryers[0].usage_multiplier = 1.1
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_clothes_dryer_values(hpxml_default, false, true, HPXML::LocationBasementConditioned, HPXML::ClothesDryerControlTypeMoisture, 3.33, 1.1)
+    _test_default_clothes_dryer_values(hpxml_default, true, HPXML::LocationBasementConditioned, 3.33, 1.1)
 
     # Test defaults w/ electric clothes dryer
     hpxml.clothes_dryers[0].location = nil
     hpxml.clothes_dryers[0].is_shared_appliance = nil
-    hpxml.clothes_dryers[0].control_type = nil
     hpxml.clothes_dryers[0].combined_energy_factor = nil
     hpxml.clothes_dryers[0].usage_multiplier = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_clothes_dryer_values(hpxml_default, true, false, HPXML::LocationLivingSpace, HPXML::ClothesDryerControlTypeTimer, 3.01, 1.0)
+    _test_default_clothes_dryer_values(hpxml_default, false, HPXML::LocationLivingSpace, 3.01, 1.0)
 
     # Test defaults w/ gas clothes dryer
     hpxml.clothes_dryers[0].fuel_type = HPXML::FuelTypeNaturalGas
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_clothes_dryer_values(hpxml_default, true, false, HPXML::LocationLivingSpace, HPXML::ClothesDryerControlTypeTimer, 3.01, 1.0)
+    _test_default_clothes_dryer_values(hpxml_default, false, HPXML::LocationLivingSpace, 3.01, 1.0)
 
     # Test defaults w/ electric clothes dryer before 301-2019 Addendum A
     hpxml.header.eri_calculation_version = '2019'
     hpxml.clothes_dryers[0].fuel_type = HPXML::FuelTypeElectricity
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_clothes_dryer_values(hpxml_default, true, false, HPXML::LocationLivingSpace, HPXML::ClothesDryerControlTypeTimer, 2.62, 1.0)
+    _test_default_clothes_dryer_values(hpxml_default, false, HPXML::LocationLivingSpace, 2.62, 1.0)
 
     # Test defaults w/ gas clothes dryer before 301-2019 Addendum A
     hpxml.clothes_dryers[0].fuel_type = HPXML::FuelTypeNaturalGas
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_clothes_dryer_values(hpxml_default, true, false, HPXML::LocationLivingSpace, HPXML::ClothesDryerControlTypeTimer, 2.32, 1.0)
+    _test_default_clothes_dryer_values(hpxml_default, false, HPXML::LocationLivingSpace, 2.32, 1.0)
   end
 
   def test_clothes_dryer_exhaust
@@ -1224,21 +1345,21 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     clothes_dryer.vented_flow_rate = 200
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_clothes_dryer_exhaust_values(hpxml_default, false, true, 200)
+    _test_default_clothes_dryer_exhaust_values(hpxml_default, true, 200)
 
     # Test inputs not overridden by defaults w/ unvented dryer
     clothes_dryer.is_vented = false
     clothes_dryer.vented_flow_rate = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_clothes_dryer_exhaust_values(hpxml_default, false, false, nil)
+    _test_default_clothes_dryer_exhaust_values(hpxml_default, false, nil)
 
     # Test defaults
     clothes_dryer.is_vented = nil
     clothes_dryer.vented_flow_rate = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_clothes_dryer_exhaust_values(hpxml_default, true, true, 100)
+    _test_default_clothes_dryer_exhaust_values(hpxml_default, true, 100)
   end
 
   def test_dishwashers
@@ -1254,7 +1375,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.dishwashers[0].water_heating_system_idref = hpxml.water_heating_systems[0].id
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_dishwasher_values(hpxml_default, false, true, HPXML::LocationBasementConditioned, 307.0, 0.12, 1.09, 22.32, 4.0, 12, 1.3)
+    _test_default_dishwasher_values(hpxml_default, true, HPXML::LocationBasementConditioned, 307.0, 0.12, 1.09, 22.32, 4.0, 12, 1.3)
 
     # Test defaults
     hpxml.dishwashers[0].is_shared_appliance = nil
@@ -1268,13 +1389,13 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.dishwashers[0].usage_multiplier = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_dishwasher_values(hpxml_default, true, false, HPXML::LocationLivingSpace, 467.0, 0.12, 1.09, 33.12, 4.0, 12, 1.0)
+    _test_default_dishwasher_values(hpxml_default, false, HPXML::LocationLivingSpace, 467.0, 0.12, 1.09, 33.12, 4.0, 12, 1.0)
 
     # Test defaults before 301-2019 Addendum A
     hpxml.header.eri_calculation_version = '2019'
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_dishwasher_values(hpxml_default, true, false, HPXML::LocationLivingSpace, 467.0, 999, 999, 999, 999, 12, 1.0)
+    _test_default_dishwasher_values(hpxml_default, false, HPXML::LocationLivingSpace, 467.0, 999, 999, 999, 999, 12, 1.0)
   end
 
   def test_refrigerators
@@ -1287,7 +1408,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.refrigerators[0].monthly_multipliers = ConstantMonthSchedule
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_refrigerator_values(hpxml_default, false, HPXML::LocationBasementConditioned, 650.0, 1.2, ConstantDaySchedule, ConstantDaySchedule, ConstantMonthSchedule)
+    _test_default_refrigerator_values(hpxml_default, HPXML::LocationBasementConditioned, 650.0, 1.2, ConstantDaySchedule, ConstantDaySchedule, ConstantMonthSchedule)
 
     # Test defaults
     hpxml.refrigerators[0].location = nil
@@ -1298,20 +1419,20 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.refrigerators[0].monthly_multipliers = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_refrigerator_values(hpxml_default, true, HPXML::LocationLivingSpace, 691.0, 1.0, '0.040, 0.039, 0.038, 0.037, 0.036, 0.036, 0.038, 0.040, 0.041, 0.041, 0.040, 0.040, 0.042, 0.042, 0.042, 0.041, 0.044, 0.048, 0.050, 0.048, 0.047, 0.046, 0.044, 0.041', '0.040, 0.039, 0.038, 0.037, 0.036, 0.036, 0.038, 0.040, 0.041, 0.041, 0.040, 0.040, 0.042, 0.042, 0.042, 0.041, 0.044, 0.048, 0.050, 0.048, 0.047, 0.046, 0.044, 0.041', '0.837, 0.835, 1.084, 1.084, 1.084, 1.096, 1.096, 1.096, 1.096, 0.931, 0.925, 0.837')
+    _test_default_refrigerator_values(hpxml_default, HPXML::LocationLivingSpace, 691.0, 1.0, '0.040, 0.039, 0.038, 0.037, 0.036, 0.036, 0.038, 0.040, 0.041, 0.041, 0.040, 0.040, 0.042, 0.042, 0.042, 0.041, 0.044, 0.048, 0.050, 0.048, 0.047, 0.046, 0.044, 0.041', '0.040, 0.039, 0.038, 0.037, 0.036, 0.036, 0.038, 0.040, 0.041, 0.041, 0.040, 0.040, 0.042, 0.042, 0.042, 0.041, 0.044, 0.048, 0.050, 0.048, 0.047, 0.046, 0.044, 0.041', '0.837, 0.835, 1.084, 1.084, 1.084, 1.096, 1.096, 1.096, 1.096, 0.931, 0.925, 0.837')
 
     # Test defaults w/ refrigerator in 5-bedroom house
     hpxml.building_construction.number_of_bedrooms = 5
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_refrigerator_values(hpxml_default, true, HPXML::LocationLivingSpace, 727.0, 1.0, '0.040, 0.039, 0.038, 0.037, 0.036, 0.036, 0.038, 0.040, 0.041, 0.041, 0.040, 0.040, 0.042, 0.042, 0.042, 0.041, 0.044, 0.048, 0.050, 0.048, 0.047, 0.046, 0.044, 0.041', '0.040, 0.039, 0.038, 0.037, 0.036, 0.036, 0.038, 0.040, 0.041, 0.041, 0.040, 0.040, 0.042, 0.042, 0.042, 0.041, 0.044, 0.048, 0.050, 0.048, 0.047, 0.046, 0.044, 0.041', '0.837, 0.835, 1.084, 1.084, 1.084, 1.096, 1.096, 1.096, 1.096, 0.931, 0.925, 0.837')
+    _test_default_refrigerator_values(hpxml_default, HPXML::LocationLivingSpace, 727.0, 1.0, '0.040, 0.039, 0.038, 0.037, 0.036, 0.036, 0.038, 0.040, 0.041, 0.041, 0.040, 0.040, 0.042, 0.042, 0.042, 0.041, 0.044, 0.048, 0.050, 0.048, 0.047, 0.046, 0.044, 0.041', '0.040, 0.039, 0.038, 0.037, 0.036, 0.036, 0.038, 0.040, 0.041, 0.041, 0.040, 0.040, 0.042, 0.042, 0.042, 0.041, 0.044, 0.048, 0.050, 0.048, 0.047, 0.046, 0.044, 0.041', '0.837, 0.835, 1.084, 1.084, 1.084, 1.096, 1.096, 1.096, 1.096, 0.931, 0.925, 0.837')
 
     # Test defaults before 301-2019 Addendum A
     hpxml.header.eri_calculation_version = '2019'
     hpxml.building_construction.number_of_bedrooms = 3
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_refrigerator_values(hpxml_default, true, HPXML::LocationLivingSpace, 691.0, 1.0, '0.040, 0.039, 0.038, 0.037, 0.036, 0.036, 0.038, 0.040, 0.041, 0.041, 0.040, 0.040, 0.042, 0.042, 0.042, 0.041, 0.044, 0.048, 0.050, 0.048, 0.047, 0.046, 0.044, 0.041', '0.040, 0.039, 0.038, 0.037, 0.036, 0.036, 0.038, 0.040, 0.041, 0.041, 0.040, 0.040, 0.042, 0.042, 0.042, 0.041, 0.044, 0.048, 0.050, 0.048, 0.047, 0.046, 0.044, 0.041', '0.837, 0.835, 1.084, 1.084, 1.084, 1.096, 1.096, 1.096, 1.096, 0.931, 0.925, 0.837')
+    _test_default_refrigerator_values(hpxml_default, HPXML::LocationLivingSpace, 691.0, 1.0, '0.040, 0.039, 0.038, 0.037, 0.036, 0.036, 0.038, 0.040, 0.041, 0.041, 0.040, 0.040, 0.042, 0.042, 0.042, 0.041, 0.044, 0.048, 0.050, 0.048, 0.047, 0.046, 0.044, 0.041', '0.040, 0.039, 0.038, 0.037, 0.036, 0.036, 0.038, 0.040, 0.041, 0.041, 0.040, 0.040, 0.042, 0.042, 0.042, 0.041, 0.044, 0.048, 0.050, 0.048, 0.047, 0.046, 0.044, 0.041', '0.837, 0.835, 1.084, 1.084, 1.084, 1.096, 1.096, 1.096, 1.096, 0.931, 0.925, 0.837')
   end
 
   def test_extra_refrigerators
@@ -1327,7 +1448,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     end
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_extra_refrigerators_values(hpxml_default, false, HPXML::LocationLivingSpace, 333.0, 1.5, ConstantDaySchedule, ConstantDaySchedule, ConstantMonthSchedule)
+    _test_default_extra_refrigerators_values(hpxml_default, HPXML::LocationLivingSpace, 333.0, 1.5, ConstantDaySchedule, ConstantDaySchedule, ConstantMonthSchedule)
 
     # Test defaults
     hpxml.refrigerators.each do |refrigerator|
@@ -1340,7 +1461,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     end
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_extra_refrigerators_values(hpxml_default, true, HPXML::LocationBasementConditioned, 244.0, 1.0, '0.040, 0.039, 0.038, 0.037, 0.036, 0.036, 0.038, 0.040, 0.041, 0.041, 0.040, 0.040, 0.042, 0.042, 0.042, 0.041, 0.044, 0.048, 0.050, 0.048, 0.047, 0.046, 0.044, 0.041', '0.040, 0.039, 0.038, 0.037, 0.036, 0.036, 0.038, 0.040, 0.041, 0.041, 0.040, 0.040, 0.042, 0.042, 0.042, 0.041, 0.044, 0.048, 0.050, 0.048, 0.047, 0.046, 0.044, 0.041', '0.837, 0.835, 1.084, 1.084, 1.084, 1.096, 1.096, 1.096, 1.096, 0.931, 0.925, 0.837')
+    _test_default_extra_refrigerators_values(hpxml_default, HPXML::LocationBasementConditioned, 244.0, 1.0, '0.040, 0.039, 0.038, 0.037, 0.036, 0.036, 0.038, 0.040, 0.041, 0.041, 0.040, 0.040, 0.042, 0.042, 0.042, 0.041, 0.044, 0.048, 0.050, 0.048, 0.047, 0.046, 0.044, 0.041', '0.040, 0.039, 0.038, 0.037, 0.036, 0.036, 0.038, 0.040, 0.041, 0.041, 0.040, 0.040, 0.042, 0.042, 0.042, 0.041, 0.044, 0.048, 0.050, 0.048, 0.047, 0.046, 0.044, 0.041', '0.837, 0.835, 1.084, 1.084, 1.084, 1.096, 1.096, 1.096, 1.096, 0.931, 0.925, 0.837')
   end
 
   def test_freezers
@@ -1356,7 +1477,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     end
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_freezers_values(hpxml_default, false, HPXML::LocationLivingSpace, 333.0, 1.5, ConstantDaySchedule, ConstantDaySchedule, ConstantMonthSchedule)
+    _test_default_freezers_values(hpxml_default, HPXML::LocationLivingSpace, 333.0, 1.5, ConstantDaySchedule, ConstantDaySchedule, ConstantMonthSchedule)
 
     # Test defaults
     hpxml.freezers.each do |freezer|
@@ -1369,7 +1490,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     end
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_freezers_values(hpxml_default, true, HPXML::LocationBasementConditioned, 320.0, 1.0, '0.040, 0.039, 0.038, 0.037, 0.036, 0.036, 0.038, 0.040, 0.041, 0.041, 0.040, 0.040, 0.042, 0.042, 0.042, 0.041, 0.044, 0.048, 0.050, 0.048, 0.047, 0.046, 0.044, 0.041', '0.040, 0.039, 0.038, 0.037, 0.036, 0.036, 0.038, 0.040, 0.041, 0.041, 0.040, 0.040, 0.042, 0.042, 0.042, 0.041, 0.044, 0.048, 0.050, 0.048, 0.047, 0.046, 0.044, 0.041', '0.837, 0.835, 1.084, 1.084, 1.084, 1.096, 1.096, 1.096, 1.096, 0.931, 0.925, 0.837')
+    _test_default_freezers_values(hpxml_default, HPXML::LocationBasementConditioned, 320.0, 1.0, '0.040, 0.039, 0.038, 0.037, 0.036, 0.036, 0.038, 0.040, 0.041, 0.041, 0.040, 0.040, 0.042, 0.042, 0.042, 0.041, 0.044, 0.048, 0.050, 0.048, 0.047, 0.046, 0.044, 0.041', '0.040, 0.039, 0.038, 0.037, 0.036, 0.036, 0.038, 0.040, 0.041, 0.041, 0.040, 0.040, 0.042, 0.042, 0.042, 0.041, 0.044, 0.048, 0.050, 0.048, 0.047, 0.046, 0.044, 0.041', '0.837, 0.835, 1.084, 1.084, 1.084, 1.096, 1.096, 1.096, 1.096, 0.931, 0.925, 0.837')
   end
 
   def test_cooking_ranges
@@ -1383,7 +1504,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.cooking_ranges[0].monthly_multipliers = ConstantMonthSchedule
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_cooking_range_values(hpxml_default, false, HPXML::LocationBasementConditioned, true, 1.1, ConstantDaySchedule, ConstantDaySchedule, ConstantMonthSchedule)
+    _test_default_cooking_range_values(hpxml_default, HPXML::LocationBasementConditioned, true, 1.1, ConstantDaySchedule, ConstantDaySchedule, ConstantMonthSchedule)
 
     # Test defaults
     hpxml.cooking_ranges[0].location = nil
@@ -1394,13 +1515,13 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.cooking_ranges[0].monthly_multipliers = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_cooking_range_values(hpxml_default, true, HPXML::LocationLivingSpace, false, 1.0, '0.007, 0.007, 0.004, 0.004, 0.007, 0.011, 0.025, 0.042, 0.046, 0.048, 0.042, 0.050, 0.057, 0.046, 0.057, 0.044, 0.092, 0.150, 0.117, 0.060, 0.035, 0.025, 0.016, 0.011', '0.007, 0.007, 0.004, 0.004, 0.007, 0.011, 0.025, 0.042, 0.046, 0.048, 0.042, 0.050, 0.057, 0.046, 0.057, 0.044, 0.092, 0.150, 0.117, 0.060, 0.035, 0.025, 0.016, 0.011', '1.097, 1.097, 0.991, 0.987, 0.991, 0.890, 0.896, 0.896, 0.890, 1.085, 1.085, 1.097')
+    _test_default_cooking_range_values(hpxml_default, HPXML::LocationLivingSpace, false, 1.0, '0.007, 0.007, 0.004, 0.004, 0.007, 0.011, 0.025, 0.042, 0.046, 0.048, 0.042, 0.050, 0.057, 0.046, 0.057, 0.044, 0.092, 0.150, 0.117, 0.060, 0.035, 0.025, 0.016, 0.011', '0.007, 0.007, 0.004, 0.004, 0.007, 0.011, 0.025, 0.042, 0.046, 0.048, 0.042, 0.050, 0.057, 0.046, 0.057, 0.044, 0.092, 0.150, 0.117, 0.060, 0.035, 0.025, 0.016, 0.011', '1.097, 1.097, 0.991, 0.987, 0.991, 0.890, 0.896, 0.896, 0.890, 1.085, 1.085, 1.097')
 
     # Test defaults before 301-2019 Addendum A
     hpxml.header.eri_calculation_version = '2019'
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_cooking_range_values(hpxml_default, true, HPXML::LocationLivingSpace, false, 1.0, '0.007, 0.007, 0.004, 0.004, 0.007, 0.011, 0.025, 0.042, 0.046, 0.048, 0.042, 0.050, 0.057, 0.046, 0.057, 0.044, 0.092, 0.150, 0.117, 0.060, 0.035, 0.025, 0.016, 0.011', '0.007, 0.007, 0.004, 0.004, 0.007, 0.011, 0.025, 0.042, 0.046, 0.048, 0.042, 0.050, 0.057, 0.046, 0.057, 0.044, 0.092, 0.150, 0.117, 0.060, 0.035, 0.025, 0.016, 0.011', '1.097, 1.097, 0.991, 0.987, 0.991, 0.890, 0.896, 0.896, 0.890, 1.085, 1.085, 1.097')
+    _test_default_cooking_range_values(hpxml_default, HPXML::LocationLivingSpace, false, 1.0, '0.007, 0.007, 0.004, 0.004, 0.007, 0.011, 0.025, 0.042, 0.046, 0.048, 0.042, 0.050, 0.057, 0.046, 0.057, 0.044, 0.092, 0.150, 0.117, 0.060, 0.035, 0.025, 0.016, 0.011', '0.007, 0.007, 0.004, 0.004, 0.007, 0.011, 0.025, 0.042, 0.046, 0.048, 0.042, 0.050, 0.057, 0.046, 0.057, 0.044, 0.092, 0.150, 0.117, 0.060, 0.035, 0.025, 0.016, 0.011', '1.097, 1.097, 0.991, 0.987, 0.991, 0.890, 0.896, 0.896, 0.890, 1.085, 1.085, 1.097')
   end
 
   def test_ovens
@@ -1409,19 +1530,19 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.ovens[0].is_convection = true
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_oven_values(hpxml_default, false, true)
+    _test_default_oven_values(hpxml_default, true)
 
     # Test defaults
     hpxml.ovens[0].is_convection = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_oven_values(hpxml_default, true, false)
+    _test_default_oven_values(hpxml_default, false)
 
     # Test defaults before 301-2019 Addendum A
     hpxml.header.eri_calculation_version = '2019'
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_oven_values(hpxml_default, true, false)
+    _test_default_oven_values(hpxml_default, false)
   end
 
   def test_lighting
@@ -1449,7 +1570,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.lighting.holiday_weekend_fractions = ConstantDaySchedule
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_lighting_values(hpxml_default, false, 2.0, 2.0, 2.0,
+    _test_default_lighting_values(hpxml_default, 2.0, 2.0, 2.0,
                                   { int_wk_sch: ConstantDaySchedule,
                                     int_wknd_sch: ConstantDaySchedule,
                                     int_month_mult: ConstantMonthSchedule,
@@ -1483,7 +1604,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.lighting.holiday_exists = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_lighting_values(hpxml_default, true, 1.0, 1.0, 1.0,
+    _test_default_lighting_values(hpxml_default, 1.0, 1.0, 1.0,
                                   { ext_wk_sch: '0.046, 0.046, 0.046, 0.046, 0.046, 0.037, 0.035, 0.034, 0.033, 0.028, 0.022, 0.015, 0.012, 0.011, 0.011, 0.012, 0.019, 0.037, 0.049, 0.065, 0.091, 0.105, 0.091, 0.063',
                                     ext_wknd_sch: '0.046, 0.046, 0.045, 0.045, 0.046, 0.045, 0.044, 0.041, 0.036, 0.03, 0.024, 0.016, 0.012, 0.011, 0.011, 0.012, 0.019, 0.038, 0.048, 0.06, 0.083, 0.098, 0.085, 0.059',
                                     ext_month_mult: '1.248, 1.257, 0.993, 0.989, 0.993, 0.827, 0.821, 0.821, 0.827, 0.99, 0.987, 1.248' })
@@ -1495,7 +1616,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.lighting.exterior_usage_multiplier = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_lighting_values(hpxml_default, true, 1.0, 1.0, 1.0,
+    _test_default_lighting_values(hpxml_default, 1.0, 1.0, 1.0,
                                   { ext_wk_sch: '0.046, 0.046, 0.046, 0.046, 0.046, 0.037, 0.035, 0.034, 0.033, 0.028, 0.022, 0.015, 0.012, 0.011, 0.011, 0.012, 0.019, 0.037, 0.049, 0.065, 0.091, 0.105, 0.091, 0.063',
                                     ext_wknd_sch: '0.046, 0.046, 0.045, 0.045, 0.046, 0.045, 0.044, 0.041, 0.036, 0.03, 0.024, 0.016, 0.012, 0.011, 0.011, 0.012, 0.019, 0.038, 0.048, 0.06, 0.083, 0.098, 0.085, 0.059',
                                     ext_month_mult: '1.248, 1.257, 0.993, 0.989, 0.993, 0.827, 0.821, 0.821, 0.827, 0.99, 0.987, 1.248',
@@ -1511,7 +1632,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hpxml.ceiling_fans[0].efficiency = 100
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_ceiling_fan_values(hpxml_default, false, 2, 100)
+    _test_default_ceiling_fan_values(hpxml_default, 2, 100)
 
     # Test defaults
     hpxml.ceiling_fans.each do |ceiling_fan|
@@ -1520,7 +1641,7 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     end
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_ceiling_fan_values(hpxml_default, true, 4, 70.4)
+    _test_default_ceiling_fan_values(hpxml_default, 4, 70.4)
   end
 
   def test_pools
@@ -1540,8 +1661,8 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     pool.pump_monthly_multipliers = ConstantMonthSchedule
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_pool_heater_values(hpxml_default, false, HPXML::UnitsKwhPerYear, 1000, 1.4, ConstantDaySchedule, ConstantDaySchedule, ConstantMonthSchedule)
-    _test_default_pool_pump_values(hpxml_default, false, 3000, 1.3, ConstantDaySchedule, ConstantDaySchedule, ConstantMonthSchedule)
+    _test_default_pool_heater_values(hpxml_default, HPXML::UnitsKwhPerYear, 1000, 1.4, ConstantDaySchedule, ConstantDaySchedule, ConstantMonthSchedule)
+    _test_default_pool_pump_values(hpxml_default, 3000, 1.3, ConstantDaySchedule, ConstantDaySchedule, ConstantMonthSchedule)
 
     # Test defaults
     pool = hpxml.pools[0]
@@ -1558,8 +1679,8 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     pool.pump_monthly_multipliers = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_pool_heater_values(hpxml_default, true, HPXML::UnitsThermPerYear, 236, 1.0, '0.003, 0.003, 0.003, 0.004, 0.008, 0.015, 0.026, 0.044, 0.084, 0.121, 0.127, 0.121, 0.120, 0.090, 0.075, 0.061, 0.037, 0.023, 0.013, 0.008, 0.004, 0.003, 0.003, 0.003', '0.003, 0.003, 0.003, 0.004, 0.008, 0.015, 0.026, 0.044, 0.084, 0.121, 0.127, 0.121, 0.120, 0.090, 0.075, 0.061, 0.037, 0.023, 0.013, 0.008, 0.004, 0.003, 0.003, 0.003', '1.154, 1.161, 1.013, 1.010, 1.013, 0.888, 0.883, 0.883, 0.888, 0.978, 0.974, 1.154')
-    _test_default_pool_pump_values(hpxml_default, true, 2496, 1.0, '0.003, 0.003, 0.003, 0.004, 0.008, 0.015, 0.026, 0.044, 0.084, 0.121, 0.127, 0.121, 0.120, 0.090, 0.075, 0.061, 0.037, 0.023, 0.013, 0.008, 0.004, 0.003, 0.003, 0.003', '0.003, 0.003, 0.003, 0.004, 0.008, 0.015, 0.026, 0.044, 0.084, 0.121, 0.127, 0.121, 0.120, 0.090, 0.075, 0.061, 0.037, 0.023, 0.013, 0.008, 0.004, 0.003, 0.003, 0.003', '1.154, 1.161, 1.013, 1.010, 1.013, 0.888, 0.883, 0.883, 0.888, 0.978, 0.974, 1.154')
+    _test_default_pool_heater_values(hpxml_default, HPXML::UnitsThermPerYear, 236, 1.0, '0.003, 0.003, 0.003, 0.004, 0.008, 0.015, 0.026, 0.044, 0.084, 0.121, 0.127, 0.121, 0.120, 0.090, 0.075, 0.061, 0.037, 0.023, 0.013, 0.008, 0.004, 0.003, 0.003, 0.003', '0.003, 0.003, 0.003, 0.004, 0.008, 0.015, 0.026, 0.044, 0.084, 0.121, 0.127, 0.121, 0.120, 0.090, 0.075, 0.061, 0.037, 0.023, 0.013, 0.008, 0.004, 0.003, 0.003, 0.003', '1.154, 1.161, 1.013, 1.010, 1.013, 0.888, 0.883, 0.883, 0.888, 0.978, 0.974, 1.154')
+    _test_default_pool_pump_values(hpxml_default, 2496, 1.0, '0.003, 0.003, 0.003, 0.004, 0.008, 0.015, 0.026, 0.044, 0.084, 0.121, 0.127, 0.121, 0.120, 0.090, 0.075, 0.061, 0.037, 0.023, 0.013, 0.008, 0.004, 0.003, 0.003, 0.003', '0.003, 0.003, 0.003, 0.004, 0.008, 0.015, 0.026, 0.044, 0.084, 0.121, 0.127, 0.121, 0.120, 0.090, 0.075, 0.061, 0.037, 0.023, 0.013, 0.008, 0.004, 0.003, 0.003, 0.003', '1.154, 1.161, 1.013, 1.010, 1.013, 0.888, 0.883, 0.883, 0.888, 0.978, 0.974, 1.154')
 
     # Test defaults 2
     hpxml = _create_hpxml('base-misc-loads-large-uncommon2.xml')
@@ -1577,8 +1698,8 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     pool.pump_monthly_multipliers = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_pool_heater_values(hpxml_default, true, nil, nil, nil, nil, nil, nil)
-    _test_default_pool_pump_values(hpxml_default, true, 2496, 1.0, '0.003, 0.003, 0.003, 0.004, 0.008, 0.015, 0.026, 0.044, 0.084, 0.121, 0.127, 0.121, 0.120, 0.090, 0.075, 0.061, 0.037, 0.023, 0.013, 0.008, 0.004, 0.003, 0.003, 0.003', '0.003, 0.003, 0.003, 0.004, 0.008, 0.015, 0.026, 0.044, 0.084, 0.121, 0.127, 0.121, 0.120, 0.090, 0.075, 0.061, 0.037, 0.023, 0.013, 0.008, 0.004, 0.003, 0.003, 0.003', '1.154, 1.161, 1.013, 1.010, 1.013, 0.888, 0.883, 0.883, 0.888, 0.978, 0.974, 1.154')
+    _test_default_pool_heater_values(hpxml_default, nil, nil, nil, nil, nil, nil)
+    _test_default_pool_pump_values(hpxml_default, 2496, 1.0, '0.003, 0.003, 0.003, 0.004, 0.008, 0.015, 0.026, 0.044, 0.084, 0.121, 0.127, 0.121, 0.120, 0.090, 0.075, 0.061, 0.037, 0.023, 0.013, 0.008, 0.004, 0.003, 0.003, 0.003', '0.003, 0.003, 0.003, 0.004, 0.008, 0.015, 0.026, 0.044, 0.084, 0.121, 0.127, 0.121, 0.120, 0.090, 0.075, 0.061, 0.037, 0.023, 0.013, 0.008, 0.004, 0.003, 0.003, 0.003', '1.154, 1.161, 1.013, 1.010, 1.013, 0.888, 0.883, 0.883, 0.888, 0.978, 0.974, 1.154')
   end
 
   def test_hot_tubs
@@ -1598,8 +1719,8 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hot_tub.pump_monthly_multipliers = ConstantMonthSchedule
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_hot_tub_heater_values(hpxml_default, false, HPXML::UnitsThermPerYear, 1000, 0.8, ConstantDaySchedule, ConstantDaySchedule, ConstantMonthSchedule)
-    _test_default_hot_tub_pump_values(hpxml_default, false, 3000, 0.7, ConstantDaySchedule, ConstantDaySchedule, ConstantMonthSchedule)
+    _test_default_hot_tub_heater_values(hpxml_default, HPXML::UnitsThermPerYear, 1000, 0.8, ConstantDaySchedule, ConstantDaySchedule, ConstantMonthSchedule)
+    _test_default_hot_tub_pump_values(hpxml_default, 3000, 0.7, ConstantDaySchedule, ConstantDaySchedule, ConstantMonthSchedule)
 
     # Test defaults
     hot_tub = hpxml.hot_tubs[0]
@@ -1616,8 +1737,8 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hot_tub.pump_monthly_multipliers = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_hot_tub_heater_values(hpxml_default, true, HPXML::UnitsKwhPerYear, 1125, 1.0, '0.024, 0.029, 0.024, 0.029, 0.047, 0.067, 0.057, 0.024, 0.024, 0.019, 0.015, 0.014, 0.014, 0.014, 0.024, 0.058, 0.126, 0.122, 0.068, 0.061, 0.051, 0.043, 0.024, 0.024', '0.024, 0.029, 0.024, 0.029, 0.047, 0.067, 0.057, 0.024, 0.024, 0.019, 0.015, 0.014, 0.014, 0.014, 0.024, 0.058, 0.126, 0.122, 0.068, 0.061, 0.051, 0.043, 0.024, 0.024', '0.837, 0.835, 1.084, 1.084, 1.084, 1.096, 1.096, 1.096, 1.096, 0.931, 0.925, 0.837')
-    _test_default_hot_tub_pump_values(hpxml_default, true, 1111, 1.0, '0.024, 0.029, 0.024, 0.029, 0.047, 0.067, 0.057, 0.024, 0.024, 0.019, 0.015, 0.014, 0.014, 0.014, 0.024, 0.058, 0.126, 0.122, 0.068, 0.061, 0.051, 0.043, 0.024, 0.024', '0.024, 0.029, 0.024, 0.029, 0.047, 0.067, 0.057, 0.024, 0.024, 0.019, 0.015, 0.014, 0.014, 0.014, 0.024, 0.058, 0.126, 0.122, 0.068, 0.061, 0.051, 0.043, 0.024, 0.024', '0.921, 0.928, 0.921, 0.915, 0.921, 1.160, 1.158, 1.158, 1.160, 0.921, 0.915, 0.921')
+    _test_default_hot_tub_heater_values(hpxml_default, HPXML::UnitsKwhPerYear, 1125, 1.0, '0.024, 0.029, 0.024, 0.029, 0.047, 0.067, 0.057, 0.024, 0.024, 0.019, 0.015, 0.014, 0.014, 0.014, 0.024, 0.058, 0.126, 0.122, 0.068, 0.061, 0.051, 0.043, 0.024, 0.024', '0.024, 0.029, 0.024, 0.029, 0.047, 0.067, 0.057, 0.024, 0.024, 0.019, 0.015, 0.014, 0.014, 0.014, 0.024, 0.058, 0.126, 0.122, 0.068, 0.061, 0.051, 0.043, 0.024, 0.024', '0.837, 0.835, 1.084, 1.084, 1.084, 1.096, 1.096, 1.096, 1.096, 0.931, 0.925, 0.837')
+    _test_default_hot_tub_pump_values(hpxml_default, 1111, 1.0, '0.024, 0.029, 0.024, 0.029, 0.047, 0.067, 0.057, 0.024, 0.024, 0.019, 0.015, 0.014, 0.014, 0.014, 0.024, 0.058, 0.126, 0.122, 0.068, 0.061, 0.051, 0.043, 0.024, 0.024', '0.024, 0.029, 0.024, 0.029, 0.047, 0.067, 0.057, 0.024, 0.024, 0.019, 0.015, 0.014, 0.014, 0.014, 0.024, 0.058, 0.126, 0.122, 0.068, 0.061, 0.051, 0.043, 0.024, 0.024', '0.921, 0.928, 0.921, 0.915, 0.921, 1.160, 1.158, 1.158, 1.160, 0.921, 0.915, 0.921')
 
     # Test defaults 2
     hpxml = _create_hpxml('base-misc-loads-large-uncommon2.xml')
@@ -1635,8 +1756,8 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     hot_tub.pump_monthly_multipliers = nil
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_hot_tub_heater_values(hpxml_default, true, HPXML::UnitsKwhPerYear, 225, 1.0, '0.024, 0.029, 0.024, 0.029, 0.047, 0.067, 0.057, 0.024, 0.024, 0.019, 0.015, 0.014, 0.014, 0.014, 0.024, 0.058, 0.126, 0.122, 0.068, 0.061, 0.051, 0.043, 0.024, 0.024', '0.024, 0.029, 0.024, 0.029, 0.047, 0.067, 0.057, 0.024, 0.024, 0.019, 0.015, 0.014, 0.014, 0.014, 0.024, 0.058, 0.126, 0.122, 0.068, 0.061, 0.051, 0.043, 0.024, 0.024', '0.837, 0.835, 1.084, 1.084, 1.084, 1.096, 1.096, 1.096, 1.096, 0.931, 0.925, 0.837')
-    _test_default_hot_tub_pump_values(hpxml_default, true, 1111, 1.0, '0.024, 0.029, 0.024, 0.029, 0.047, 0.067, 0.057, 0.024, 0.024, 0.019, 0.015, 0.014, 0.014, 0.014, 0.024, 0.058, 0.126, 0.122, 0.068, 0.061, 0.051, 0.043, 0.024, 0.024', '0.024, 0.029, 0.024, 0.029, 0.047, 0.067, 0.057, 0.024, 0.024, 0.019, 0.015, 0.014, 0.014, 0.014, 0.024, 0.058, 0.126, 0.122, 0.068, 0.061, 0.051, 0.043, 0.024, 0.024', '0.921, 0.928, 0.921, 0.915, 0.921, 1.160, 1.158, 1.158, 1.160, 0.921, 0.915, 0.921')
+    _test_default_hot_tub_heater_values(hpxml_default, HPXML::UnitsKwhPerYear, 225, 1.0, '0.024, 0.029, 0.024, 0.029, 0.047, 0.067, 0.057, 0.024, 0.024, 0.019, 0.015, 0.014, 0.014, 0.014, 0.024, 0.058, 0.126, 0.122, 0.068, 0.061, 0.051, 0.043, 0.024, 0.024', '0.024, 0.029, 0.024, 0.029, 0.047, 0.067, 0.057, 0.024, 0.024, 0.019, 0.015, 0.014, 0.014, 0.014, 0.024, 0.058, 0.126, 0.122, 0.068, 0.061, 0.051, 0.043, 0.024, 0.024', '0.837, 0.835, 1.084, 1.084, 1.084, 1.096, 1.096, 1.096, 1.096, 0.931, 0.925, 0.837')
+    _test_default_hot_tub_pump_values(hpxml_default, 1111, 1.0, '0.024, 0.029, 0.024, 0.029, 0.047, 0.067, 0.057, 0.024, 0.024, 0.019, 0.015, 0.014, 0.014, 0.014, 0.024, 0.058, 0.126, 0.122, 0.068, 0.061, 0.051, 0.043, 0.024, 0.024', '0.024, 0.029, 0.024, 0.029, 0.047, 0.067, 0.057, 0.024, 0.024, 0.019, 0.015, 0.014, 0.014, 0.014, 0.024, 0.058, 0.126, 0.122, 0.068, 0.061, 0.051, 0.043, 0.024, 0.024', '0.921, 0.928, 0.921, 0.915, 0.921, 1.160, 1.158, 1.158, 1.160, 0.921, 0.915, 0.921')
   end
 
   def test_plug_loads
@@ -1676,10 +1797,10 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     wellpump_pl.monthly_multipliers = ConstantMonthSchedule
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_plug_load_values(hpxml_default, false, HPXML::PlugLoadTypeTelevision, 1000, 0.6, 0.3, 1.1, ConstantDaySchedule, ConstantDaySchedule, ConstantMonthSchedule)
-    _test_default_plug_load_values(hpxml_default, false, HPXML::PlugLoadTypeOther, 2000, 0.5, 0.4, 1.2, ConstantDaySchedule, ConstantDaySchedule, ConstantMonthSchedule)
-    _test_default_plug_load_values(hpxml_default, false, HPXML::PlugLoadTypeElectricVehicleCharging, 4000, 0.4, 0.5, 1.3, ConstantDaySchedule, ConstantDaySchedule, ConstantMonthSchedule)
-    _test_default_plug_load_values(hpxml_default, false, HPXML::PlugLoadTypeWellPump, 3000, 0.3, 0.6, 1.4, ConstantDaySchedule, ConstantDaySchedule, ConstantMonthSchedule)
+    _test_default_plug_load_values(hpxml_default, HPXML::PlugLoadTypeTelevision, 1000, 0.6, 0.3, 1.1, ConstantDaySchedule, ConstantDaySchedule, ConstantMonthSchedule)
+    _test_default_plug_load_values(hpxml_default, HPXML::PlugLoadTypeOther, 2000, 0.5, 0.4, 1.2, ConstantDaySchedule, ConstantDaySchedule, ConstantMonthSchedule)
+    _test_default_plug_load_values(hpxml_default, HPXML::PlugLoadTypeElectricVehicleCharging, 4000, 0.4, 0.5, 1.3, ConstantDaySchedule, ConstantDaySchedule, ConstantMonthSchedule)
+    _test_default_plug_load_values(hpxml_default, HPXML::PlugLoadTypeWellPump, 3000, 0.3, 0.6, 1.4, ConstantDaySchedule, ConstantDaySchedule, ConstantMonthSchedule)
 
     # Test defaults
     hpxml.plug_loads.each do |plug_load|
@@ -1693,10 +1814,10 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     end
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_plug_load_values(hpxml_default, true, HPXML::PlugLoadTypeTelevision, 620, 1.0, 0.0, 1.0, '0.037, 0.018, 0.009, 0.007, 0.011, 0.018, 0.029, 0.040, 0.049, 0.058, 0.065, 0.072, 0.076, 0.086, 0.091, 0.102, 0.127, 0.156, 0.210, 0.294, 0.363, 0.344, 0.208, 0.090', '0.044, 0.022, 0.012, 0.008, 0.011, 0.014, 0.024, 0.043, 0.071, 0.094, 0.112, 0.123, 0.132, 0.156, 0.178, 0.196, 0.206, 0.213, 0.251, 0.330, 0.388, 0.358, 0.226, 0.103', '1.137, 1.129, 0.961, 0.969, 0.961, 0.993, 0.996, 0.96, 0.993, 0.867, 0.86, 1.137')
-    _test_default_plug_load_values(hpxml_default, true, HPXML::PlugLoadTypeOther, 2457, 0.855, 0.045, 1.0, '0.035, 0.033, 0.032, 0.031, 0.032, 0.033, 0.037, 0.042, 0.043, 0.043, 0.043, 0.044, 0.045, 0.045, 0.044, 0.046, 0.048, 0.052, 0.053, 0.05, 0.047, 0.045, 0.04, 0.036', '0.035, 0.033, 0.032, 0.031, 0.032, 0.033, 0.037, 0.042, 0.043, 0.043, 0.043, 0.044, 0.045, 0.045, 0.044, 0.046, 0.048, 0.052, 0.053, 0.05, 0.047, 0.045, 0.04, 0.036', '1.248, 1.257, 0.993, 0.989, 0.993, 0.827, 0.821, 0.821, 0.827, 0.99, 0.987, 1.248')
-    _test_default_plug_load_values(hpxml_default, true, HPXML::PlugLoadTypeElectricVehicleCharging, 1667, 0.0, 0.0, 1.0, '0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042', '0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042', '1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1')
-    _test_default_plug_load_values(hpxml_default, true, HPXML::PlugLoadTypeWellPump, 441, 0.0, 0.0, 1.0, '0.044, 0.023, 0.019, 0.015, 0.016, 0.018, 0.026, 0.033, 0.033, 0.032, 0.033, 0.033, 0.032, 0.032, 0.032, 0.033, 0.045, 0.057, 0.066, 0.076, 0.081, 0.086, 0.075, 0.065', '0.044, 0.023, 0.019, 0.015, 0.016, 0.018, 0.026, 0.033, 0.033, 0.032, 0.033, 0.033, 0.032, 0.032, 0.032, 0.033, 0.045, 0.057, 0.066, 0.076, 0.081, 0.086, 0.075, 0.065', '1.154, 1.161, 1.013, 1.010, 1.013, 0.888, 0.883, 0.883, 0.888, 0.978, 0.974, 1.154')
+    _test_default_plug_load_values(hpxml_default, HPXML::PlugLoadTypeTelevision, 620, 1.0, 0.0, 1.0, '0.037, 0.018, 0.009, 0.007, 0.011, 0.018, 0.029, 0.040, 0.049, 0.058, 0.065, 0.072, 0.076, 0.086, 0.091, 0.102, 0.127, 0.156, 0.210, 0.294, 0.363, 0.344, 0.208, 0.090', '0.044, 0.022, 0.012, 0.008, 0.011, 0.014, 0.024, 0.043, 0.071, 0.094, 0.112, 0.123, 0.132, 0.156, 0.178, 0.196, 0.206, 0.213, 0.251, 0.330, 0.388, 0.358, 0.226, 0.103', '1.137, 1.129, 0.961, 0.969, 0.961, 0.993, 0.996, 0.96, 0.993, 0.867, 0.86, 1.137')
+    _test_default_plug_load_values(hpxml_default, HPXML::PlugLoadTypeOther, 2457, 0.855, 0.045, 1.0, '0.035, 0.033, 0.032, 0.031, 0.032, 0.033, 0.037, 0.042, 0.043, 0.043, 0.043, 0.044, 0.045, 0.045, 0.044, 0.046, 0.048, 0.052, 0.053, 0.05, 0.047, 0.045, 0.04, 0.036', '0.035, 0.033, 0.032, 0.031, 0.032, 0.033, 0.037, 0.042, 0.043, 0.043, 0.043, 0.044, 0.045, 0.045, 0.044, 0.046, 0.048, 0.052, 0.053, 0.05, 0.047, 0.045, 0.04, 0.036', '1.248, 1.257, 0.993, 0.989, 0.993, 0.827, 0.821, 0.821, 0.827, 0.99, 0.987, 1.248')
+    _test_default_plug_load_values(hpxml_default, HPXML::PlugLoadTypeElectricVehicleCharging, 1667, 0.0, 0.0, 1.0, '0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042', '0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042, 0.042', '1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1')
+    _test_default_plug_load_values(hpxml_default, HPXML::PlugLoadTypeWellPump, 441, 0.0, 0.0, 1.0, '0.044, 0.023, 0.019, 0.015, 0.016, 0.018, 0.026, 0.033, 0.033, 0.032, 0.033, 0.033, 0.032, 0.032, 0.032, 0.033, 0.045, 0.057, 0.066, 0.076, 0.081, 0.086, 0.075, 0.065', '0.044, 0.023, 0.019, 0.015, 0.016, 0.018, 0.026, 0.033, 0.033, 0.032, 0.033, 0.033, 0.032, 0.032, 0.032, 0.033, 0.045, 0.057, 0.066, 0.076, 0.081, 0.086, 0.075, 0.065', '1.154, 1.161, 1.013, 1.010, 1.013, 0.888, 0.883, 0.883, 0.888, 0.978, 0.974, 1.154')
   end
 
   def test_fuel_loads
@@ -1728,9 +1849,9 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     gf_fl.monthly_multipliers = ConstantMonthSchedule
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_fuel_load_values(hpxml_default, false, HPXML::FuelLoadTypeGrill, 1000, 0.6, 0.3, 0.9, ConstantDaySchedule, ConstantDaySchedule, ConstantMonthSchedule)
-    _test_default_fuel_load_values(hpxml_default, false, HPXML::FuelLoadTypeLighting, 2000, 0.5, 0.4, 0.8, ConstantDaySchedule, ConstantDaySchedule, ConstantMonthSchedule)
-    _test_default_fuel_load_values(hpxml_default, false, HPXML::FuelLoadTypeFireplace, 3000, 0.4, 0.5, 0.7, ConstantDaySchedule, ConstantDaySchedule, ConstantMonthSchedule)
+    _test_default_fuel_load_values(hpxml_default, HPXML::FuelLoadTypeGrill, 1000, 0.6, 0.3, 0.9, ConstantDaySchedule, ConstantDaySchedule, ConstantMonthSchedule)
+    _test_default_fuel_load_values(hpxml_default, HPXML::FuelLoadTypeLighting, 2000, 0.5, 0.4, 0.8, ConstantDaySchedule, ConstantDaySchedule, ConstantMonthSchedule)
+    _test_default_fuel_load_values(hpxml_default, HPXML::FuelLoadTypeFireplace, 3000, 0.4, 0.5, 0.7, ConstantDaySchedule, ConstantDaySchedule, ConstantMonthSchedule)
 
     # Test defaults
     hpxml.fuel_loads.each do |fuel_load|
@@ -1744,9 +1865,9 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     end
     XMLHelper.write_file(hpxml.to_oga, @tmp_hpxml_path)
     hpxml_default = _test_measure()
-    _test_default_fuel_load_values(hpxml_default, true, HPXML::FuelLoadTypeGrill, 33, 0.0, 0.0, 1.0, '0.004, 0.001, 0.001, 0.002, 0.007, 0.012, 0.029, 0.046, 0.044, 0.041, 0.044, 0.046, 0.042, 0.038, 0.049, 0.059, 0.110, 0.161, 0.115, 0.070, 0.044, 0.019, 0.013, 0.007', '0.004, 0.001, 0.001, 0.002, 0.007, 0.012, 0.029, 0.046, 0.044, 0.041, 0.044, 0.046, 0.042, 0.038, 0.049, 0.059, 0.110, 0.161, 0.115, 0.070, 0.044, 0.019, 0.013, 0.007', '1.097, 1.097, 0.991, 0.987, 0.991, 0.890, 0.896, 0.896, 0.890, 1.085, 1.085, 1.097')
-    _test_default_fuel_load_values(hpxml_default, true, HPXML::FuelLoadTypeLighting, 20, 0.0, 0.0, 1.0, '0.044, 0.023, 0.019, 0.015, 0.016, 0.018, 0.026, 0.033, 0.033, 0.032, 0.033, 0.033, 0.032, 0.032, 0.032, 0.033, 0.045, 0.057, 0.066, 0.076, 0.081, 0.086, 0.075, 0.065', '0.044, 0.023, 0.019, 0.015, 0.016, 0.018, 0.026, 0.033, 0.033, 0.032, 0.033, 0.033, 0.032, 0.032, 0.032, 0.033, 0.045, 0.057, 0.066, 0.076, 0.081, 0.086, 0.075, 0.065', '1.154, 1.161, 1.013, 1.010, 1.013, 0.888, 0.883, 0.883, 0.888, 0.978, 0.974, 1.154')
-    _test_default_fuel_load_values(hpxml_default, true, HPXML::FuelLoadTypeFireplace, 67, 0.5, 0.1, 1.0, '0.044, 0.023, 0.019, 0.015, 0.016, 0.018, 0.026, 0.033, 0.033, 0.032, 0.033, 0.033, 0.032, 0.032, 0.032, 0.033, 0.045, 0.057, 0.066, 0.076, 0.081, 0.086, 0.075, 0.065', '0.044, 0.023, 0.019, 0.015, 0.016, 0.018, 0.026, 0.033, 0.033, 0.032, 0.033, 0.033, 0.032, 0.032, 0.032, 0.033, 0.045, 0.057, 0.066, 0.076, 0.081, 0.086, 0.075, 0.065', '1.154, 1.161, 1.013, 1.010, 1.013, 0.888, 0.883, 0.883, 0.888, 0.978, 0.974, 1.154')
+    _test_default_fuel_load_values(hpxml_default, HPXML::FuelLoadTypeGrill, 33, 0.0, 0.0, 1.0, '0.004, 0.001, 0.001, 0.002, 0.007, 0.012, 0.029, 0.046, 0.044, 0.041, 0.044, 0.046, 0.042, 0.038, 0.049, 0.059, 0.110, 0.161, 0.115, 0.070, 0.044, 0.019, 0.013, 0.007', '0.004, 0.001, 0.001, 0.002, 0.007, 0.012, 0.029, 0.046, 0.044, 0.041, 0.044, 0.046, 0.042, 0.038, 0.049, 0.059, 0.110, 0.161, 0.115, 0.070, 0.044, 0.019, 0.013, 0.007', '1.097, 1.097, 0.991, 0.987, 0.991, 0.890, 0.896, 0.896, 0.890, 1.085, 1.085, 1.097')
+    _test_default_fuel_load_values(hpxml_default, HPXML::FuelLoadTypeLighting, 20, 0.0, 0.0, 1.0, '0.044, 0.023, 0.019, 0.015, 0.016, 0.018, 0.026, 0.033, 0.033, 0.032, 0.033, 0.033, 0.032, 0.032, 0.032, 0.033, 0.045, 0.057, 0.066, 0.076, 0.081, 0.086, 0.075, 0.065', '0.044, 0.023, 0.019, 0.015, 0.016, 0.018, 0.026, 0.033, 0.033, 0.032, 0.033, 0.033, 0.032, 0.032, 0.032, 0.033, 0.045, 0.057, 0.066, 0.076, 0.081, 0.086, 0.075, 0.065', '1.154, 1.161, 1.013, 1.010, 1.013, 0.888, 0.883, 0.883, 0.888, 0.978, 0.974, 1.154')
+    _test_default_fuel_load_values(hpxml_default, HPXML::FuelLoadTypeFireplace, 67, 0.5, 0.1, 1.0, '0.044, 0.023, 0.019, 0.015, 0.016, 0.018, 0.026, 0.033, 0.033, 0.032, 0.033, 0.033, 0.032, 0.032, 0.032, 0.033, 0.045, 0.057, 0.066, 0.076, 0.081, 0.086, 0.075, 0.065', '0.044, 0.023, 0.019, 0.015, 0.016, 0.018, 0.026, 0.033, 0.033, 0.032, 0.033, 0.033, 0.032, 0.032, 0.032, 0.033, 0.045, 0.057, 0.066, 0.076, 0.081, 0.086, 0.075, 0.065', '1.154, 1.161, 1.013, 1.010, 1.013, 0.888, 0.883, 0.883, 0.888, 0.978, 0.974, 1.154')
   end
 
   def _test_measure()
@@ -1784,879 +1905,710 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     return hpxml_default
   end
 
-  def _test_default_header_values(hpxml, isdefaulted, tstep, sim_begin_month, sim_begin_day, sim_end_month, sim_end_day, sim_calendar_year,
+  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,
                                   use_max_load_for_heat_pumps, allow_increased_fixed_capacities)
     assert_equal(tstep, hpxml.header.timestep)
-    assert_equal(isdefaulted, hpxml.header.timestep_isdefaulted)
-
     assert_equal(sim_begin_month, hpxml.header.sim_begin_month)
-    assert_equal(isdefaulted, hpxml.header.sim_begin_month_isdefaulted)
-
     assert_equal(sim_begin_day, hpxml.header.sim_begin_day)
-    assert_equal(isdefaulted, hpxml.header.sim_begin_day_isdefaulted)
-
     assert_equal(sim_end_month, hpxml.header.sim_end_month)
-    assert_equal(isdefaulted, hpxml.header.sim_end_month_isdefaulted)
-
     assert_equal(sim_end_day, hpxml.header.sim_end_day)
-    assert_equal(isdefaulted, hpxml.header.sim_end_day_isdefaulted)
-
     assert_equal(sim_calendar_year, hpxml.header.sim_calendar_year)
-    assert_equal(isdefaulted, hpxml.header.sim_calendar_year_isdefaulted)
-
     assert_equal(dst_enabled, hpxml.header.dst_enabled)
-    assert_equal(isdefaulted, hpxml.header.dst_enabled_isdefaulted)
-
     assert_equal(dst_begin_month, hpxml.header.dst_begin_month)
-    assert_equal(isdefaulted, hpxml.header.dst_begin_month_isdefaulted)
-
     assert_equal(dst_begin_day, hpxml.header.dst_begin_day)
-    assert_equal(isdefaulted, hpxml.header.dst_begin_day_isdefaulted)
-
     assert_equal(dst_end_month, hpxml.header.dst_end_month)
-    assert_equal(isdefaulted, hpxml.header.dst_end_month_isdefaulted)
-
     assert_equal(dst_end_day, hpxml.header.dst_end_day)
-    assert_equal(isdefaulted, hpxml.header.dst_end_day_isdefaulted)
-
     assert_equal(use_max_load_for_heat_pumps, hpxml.header.use_max_load_for_heat_pumps)
-    assert_equal(isdefaulted, hpxml.header.use_max_load_for_heat_pumps_isdefaulted)
-
     assert_equal(allow_increased_fixed_capacities, hpxml.header.allow_increased_fixed_capacities)
-    assert_equal(isdefaulted, hpxml.header.allow_increased_fixed_capacities_isdefaulted)
   end
 
-  def _test_default_site_values(hpxml, isdefaulted, site_type, shelter_coefficient)
+  def _test_default_site_values(hpxml, site_type, shielding_of_home)
     assert_equal(site_type, hpxml.site.site_type)
-    assert_equal(isdefaulted, hpxml.site.site_type_isdefaulted)
-
-    assert_equal(shelter_coefficient, hpxml.site.shelter_coefficient)
-    assert_equal(isdefaulted, hpxml.site.shelter_coefficient_isdefaulted)
+    assert_equal(shielding_of_home, hpxml.site.shielding_of_home)
   end
 
-  def _test_default_occupancy_values(hpxml, isdefaulted, num_occupants)
+  def _test_default_occupancy_values(hpxml, num_occupants)
     assert_equal(num_occupants, hpxml.building_occupancy.number_of_residents)
-    assert_equal(isdefaulted, hpxml.building_occupancy.number_of_residents_isdefaulted)
   end
 
-  def _test_default_building_construction_values(hpxml, isdefaulted, building_volume, average_ceiling_height, has_flue_or_chimney, n_bathrooms)
+  def _test_default_building_construction_values(hpxml, building_volume, average_ceiling_height, has_flue_or_chimney, n_bathrooms)
     assert_equal(building_volume, hpxml.building_construction.conditioned_building_volume)
-    assert_equal(average_ceiling_height, hpxml.building_construction.average_ceiling_height)
-    if isdefaulted
-      assert_equal(isdefaulted, hpxml.building_construction.conditioned_building_volume_isdefaulted || hpxml.building_construction.average_ceiling_height_isdefaulted)
-    else
-      assert_equal(isdefaulted, hpxml.building_construction.conditioned_building_volume_isdefaulted)
-      assert_equal(isdefaulted, hpxml.building_construction.average_ceiling_height_isdefaulted)
-    end
-
+    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(isdefaulted, hpxml.building_construction.has_flue_or_chimney_isdefaulted)
-
     assert_equal(n_bathrooms, hpxml.building_construction.number_of_bathrooms)
-    assert_equal(isdefaulted, hpxml.building_construction.number_of_bathrooms_isdefaulted)
   end
 
-  def _test_default_infiltration_values(hpxml, isdefaulted, volume)
+  def _test_default_infiltration_values(hpxml, volume)
     air_infiltration_measurement = hpxml.air_infiltration_measurements[0]
 
     assert_equal(volume, air_infiltration_measurement.infiltration_volume)
-    assert_equal(isdefaulted, air_infiltration_measurement.infiltration_volume_isdefaulted)
   end
 
-  def _test_default_attic_values(hpxml, isdefaulted, sla)
+  def _test_default_attic_values(hpxml, sla)
     attic = hpxml.attics[0]
 
-    assert_equal(sla, attic.vented_attic_sla)
-    assert_equal(isdefaulted, attic.vented_attic_sla_isdefaulted)
+    assert_in_epsilon(sla, attic.vented_attic_sla, 0.001)
   end
 
-  def _test_default_foundation_values(hpxml, isdefaulted, sla)
+  def _test_default_foundation_values(hpxml, sla)
     foundation = hpxml.foundations[0]
 
-    assert_equal(sla, foundation.vented_crawlspace_sla)
-    assert_equal(isdefaulted, foundation.vented_crawlspace_sla_isdefaulted)
+    assert_in_epsilon(sla, foundation.vented_crawlspace_sla, 0.001)
   end
 
-  def _test_default_roof_values(hpxml, isdefaulted, roof_type, solar_absorptance, roof_color, emittance, radiant_barrier)
+  def _test_default_roof_values(hpxml, roof_type, solar_absorptance, roof_color, emittance, radiant_barrier)
     roof = hpxml.roofs[0]
 
     assert_equal(roof_type, roof.roof_type)
-    assert_equal(isdefaulted, roof.roof_type_isdefaulted)
-
     assert_equal(solar_absorptance, roof.solar_absorptance)
     assert_equal(roof_color, roof.roof_color)
-    if isdefaulted
-      assert_equal(isdefaulted, roof.solar_absorptance_isdefaulted || roof.roof_color_isdefaulted)
-    else
-      assert_equal(isdefaulted, roof.solar_absorptance_isdefaulted)
-      assert_equal(isdefaulted, roof.roof_color_isdefaulted)
-    end
-
     assert_equal(emittance, roof.emittance)
-    assert_equal(isdefaulted, roof.emittance_isdefaulted)
-
     assert_equal(radiant_barrier, roof.radiant_barrier)
-    assert_equal(isdefaulted, roof.radiant_barrier_isdefaulted)
   end
 
-  def _test_default_rim_joist_values(hpxml, isdefaulted, siding, solar_absorptance, color, emittance)
+  def _test_default_rim_joist_values(hpxml, siding, solar_absorptance, color, emittance)
     rim_joist = hpxml.rim_joists[0]
 
     assert_equal(siding, rim_joist.siding)
-    assert_equal(isdefaulted, rim_joist.siding_isdefaulted)
-
     assert_equal(solar_absorptance, rim_joist.solar_absorptance)
     assert_equal(color, rim_joist.color)
-    if isdefaulted
-      assert_equal(isdefaulted, rim_joist.solar_absorptance_isdefaulted || rim_joist.color_isdefaulted)
-    else
-      assert_equal(isdefaulted, rim_joist.solar_absorptance_isdefaulted)
-      assert_equal(isdefaulted, rim_joist.color_isdefaulted)
-    end
-
     assert_equal(emittance, rim_joist.emittance)
-    assert_equal(isdefaulted, rim_joist.emittance_isdefaulted)
   end
 
-  def _test_default_wall_values(hpxml, isdefaulted, siding, solar_absorptance, color, emittance)
+  def _test_default_wall_values(hpxml, siding, solar_absorptance, color, emittance)
     wall = hpxml.walls[0]
 
     assert_equal(siding, wall.siding)
-    assert_equal(isdefaulted, wall.siding_isdefaulted)
-
     assert_equal(solar_absorptance, wall.solar_absorptance)
     assert_equal(color, wall.color)
-    if isdefaulted
-      assert_equal(isdefaulted, wall.solar_absorptance_isdefaulted || wall.color_isdefaulted)
-    else
-      assert_equal(isdefaulted, wall.solar_absorptance_isdefaulted)
-      assert_equal(isdefaulted, wall.color_isdefaulted)
-    end
-
     assert_equal(emittance, wall.emittance)
-    assert_equal(isdefaulted, wall.emittance_isdefaulted)
   end
 
-  def _test_default_foundation_wall_values(hpxml, isdefaulted, thickness)
+  def _test_default_foundation_wall_values(hpxml, thickness)
     foundation_wall = hpxml.foundation_walls[0]
 
     assert_equal(thickness, foundation_wall.thickness)
-    assert_equal(isdefaulted, foundation_wall.thickness_isdefaulted)
   end
 
-  def _test_default_slab_values(hpxml, isdefaulted, thickness, carpet_r_value, carpet_fraction)
+  def _test_default_slab_values(hpxml, thickness, carpet_r_value, carpet_fraction)
     slab = hpxml.slabs[0]
 
     assert_equal(thickness, slab.thickness)
-    assert_equal(isdefaulted, slab.thickness_isdefaulted)
-
     assert_equal(carpet_r_value, slab.carpet_r_value)
-    assert_equal(isdefaulted, slab.carpet_r_value_isdefaulted)
-
     assert_equal(carpet_fraction, slab.carpet_fraction)
-    assert_equal(isdefaulted, slab.carpet_fraction_isdefaulted)
   end
 
-  def _test_default_window_values(hpxml, isdefaulted, summer_shade_coeffs, winter_shade_coeffs, fraction_operable)
-    assert_equal(summer_shade_coeffs.size, hpxml.windows.size)
+  def _test_default_window_values(hpxml, ext_summer_sfs, ext_winter_sfs, int_summer_sfs, int_winter_sfs, fraction_operable)
+    assert_equal(ext_summer_sfs.size, hpxml.windows.size)
     hpxml.windows.each_with_index do |window, idx|
-      assert_equal(summer_shade_coeffs[idx], window.interior_shading_factor_summer)
-      assert_equal(isdefaulted, window.interior_shading_factor_summer_isdefaulted)
-
-      assert_equal(winter_shade_coeffs[idx], window.interior_shading_factor_winter)
-      assert_equal(isdefaulted, window.interior_shading_factor_winter_isdefaulted)
-
+      assert_equal(ext_summer_sfs[idx], window.exterior_shading_factor_summer)
+      assert_equal(ext_winter_sfs[idx], window.exterior_shading_factor_winter)
+      assert_equal(int_summer_sfs[idx], window.interior_shading_factor_summer)
+      assert_equal(int_winter_sfs[idx], window.interior_shading_factor_winter)
       assert_equal(fraction_operable[idx], window.fraction_operable)
-      assert_equal(isdefaulted, window.fraction_operable_isdefaulted)
     end
   end
 
-  def _test_default_skylight_values(hpxml, isdefaulted, summer_shade_coeffs, winter_shade_coeffs)
-    assert_equal(summer_shade_coeffs.size, hpxml.skylights.size)
+  def _test_default_skylight_values(hpxml, ext_summer_sfs, ext_winter_sfs, int_summer_sfs, int_winter_sfs)
+    assert_equal(ext_summer_sfs.size, hpxml.skylights.size)
     hpxml.skylights.each_with_index do |skylight, idx|
-      assert_equal(summer_shade_coeffs[idx], skylight.interior_shading_factor_summer)
-      assert_equal(isdefaulted, skylight.interior_shading_factor_summer_isdefaulted)
-
-      assert_equal(winter_shade_coeffs[idx], skylight.interior_shading_factor_winter)
-      assert_equal(isdefaulted, skylight.interior_shading_factor_winter_isdefaulted)
+      assert_equal(ext_summer_sfs[idx], skylight.exterior_shading_factor_summer)
+      assert_equal(ext_winter_sfs[idx], skylight.exterior_shading_factor_winter)
+      assert_equal(int_summer_sfs[idx], skylight.interior_shading_factor_summer)
+      assert_equal(int_winter_sfs[idx], skylight.interior_shading_factor_winter)
     end
   end
 
-  def _test_default_central_air_conditioner_values(hpxml, isdefaulted, shr, compressor_type, fan_watts_per_cfm)
+  def _test_default_central_air_conditioner_values(hpxml, shr, compressor_type, fan_watts_per_cfm, charge_defect_ratio,
+                                                   airflow_defect_ratio, cooling_capacity)
     cooling_system = hpxml.cooling_systems[0]
 
     assert_equal(shr, cooling_system.cooling_shr)
-    assert_equal(isdefaulted, cooling_system.cooling_shr_isdefaulted)
-
     assert_equal(compressor_type, cooling_system.compressor_type)
-    assert_equal(isdefaulted, cooling_system.compressor_type_isdefaulted)
-
     assert_equal(fan_watts_per_cfm, cooling_system.fan_watts_per_cfm)
-    assert_equal(isdefaulted, cooling_system.fan_watts_per_cfm_isdefaulted)
+    assert_equal(charge_defect_ratio, cooling_system.charge_defect_ratio)
+    assert_equal(airflow_defect_ratio, cooling_system.airflow_defect_ratio)
+    if cooling_capacity.nil?
+      assert(cooling_system.cooling_capacity > 0)
+    else
+      assert_equal(cooling_system.cooling_capacity, cooling_capacity)
+    end
   end
 
-  def _test_default_room_air_conditioner_values(hpxml, isdefaulted, shr)
+  def _test_default_room_air_conditioner_values(hpxml, shr, cooling_capacity)
     cooling_system = hpxml.cooling_systems[0]
 
     assert_equal(shr, cooling_system.cooling_shr)
-    assert_equal(isdefaulted, cooling_system.cooling_shr_isdefaulted)
+    if cooling_capacity.nil?
+      assert(cooling_system.cooling_capacity > 0)
+    else
+      assert_equal(cooling_system.cooling_capacity, cooling_capacity)
+    end
   end
 
-  def _test_default_mini_split_air_conditioner_values(hpxml, isdefaulted, shr, fan_watts_per_cfm)
+  def _test_default_evap_cooler_values(hpxml, cooling_capacity)
     cooling_system = hpxml.cooling_systems[0]
 
-    assert_equal(shr, cooling_system.cooling_shr)
-    assert_equal(isdefaulted, cooling_system.cooling_shr_isdefaulted)
+    if cooling_capacity.nil?
+      assert(cooling_system.cooling_capacity > 0)
+    else
+      assert_equal(cooling_system.cooling_capacity, cooling_capacity)
+    end
+  end
+
+  def _test_default_mini_split_air_conditioner_values(hpxml, shr, fan_watts_per_cfm, charge_defect_ratio,
+                                                      airflow_defect_ratio, cooling_capacity)
+    cooling_system = hpxml.cooling_systems[0]
 
+    assert_equal(shr, cooling_system.cooling_shr)
     assert_equal(fan_watts_per_cfm, cooling_system.fan_watts_per_cfm)
-    assert_equal(isdefaulted, cooling_system.fan_watts_per_cfm_isdefaulted)
+    assert_equal(charge_defect_ratio, cooling_system.charge_defect_ratio)
+    assert_equal(airflow_defect_ratio, cooling_system.airflow_defect_ratio)
+    if cooling_capacity.nil?
+      assert(cooling_system.cooling_capacity > 0)
+    else
+      assert_equal(cooling_system.cooling_capacity, cooling_capacity)
+    end
   end
 
-  def _test_default_furnace_values(hpxml, isdefaulted, fan_watts_per_cfm)
+  def _test_default_furnace_values(hpxml, fan_watts_per_cfm, airflow_defect_ratio,
+                                   heating_capacity)
     heating_system = hpxml.heating_systems[0]
 
     assert_equal(fan_watts_per_cfm, heating_system.fan_watts_per_cfm)
-    assert_equal(isdefaulted, heating_system.fan_watts_per_cfm_isdefaulted)
+    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)
+    end
   end
 
-  def _test_default_wall_furnace_values(hpxml, isdefaulted, fan_watts)
+  def _test_default_wall_furnace_values(hpxml, fan_watts, heating_capacity)
     heating_system = hpxml.heating_systems[0]
 
     assert_equal(fan_watts, heating_system.fan_watts)
-    assert_equal(isdefaulted, heating_system.fan_watts_isdefaulted)
+    if heating_capacity.nil?
+      assert(heating_system.heating_capacity > 0)
+    else
+      assert_equal(heating_system.heating_capacity, heating_capacity)
+    end
   end
 
-  def _test_default_floor_furnace_values(hpxml, isdefaulted, fan_watts)
+  def _test_default_floor_furnace_values(hpxml, fan_watts, heating_capacity)
     heating_system = hpxml.heating_systems[0]
 
     assert_equal(fan_watts, heating_system.fan_watts)
-    assert_equal(isdefaulted, heating_system.fan_watts_isdefaulted)
+    if heating_capacity.nil?
+      assert(heating_system.heating_capacity > 0)
+    else
+      assert_equal(heating_system.heating_capacity, heating_capacity)
+    end
   end
 
-  def _test_default_stove_values(hpxml, isdefaulted, fan_watts)
+  def _test_default_boiler_values(hpxml, eae, heating_capacity)
     heating_system = hpxml.heating_systems[0]
 
-    assert_equal(fan_watts, heating_system.fan_watts)
-    assert_equal(isdefaulted, heating_system.fan_watts_isdefaulted)
+    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)
+    end
   end
 
-  def _test_default_portable_heater_values(hpxml, isdefaulted, fan_watts)
+  def _test_default_stove_values(hpxml, fan_watts, heating_capacity)
     heating_system = hpxml.heating_systems[0]
 
     assert_equal(fan_watts, heating_system.fan_watts)
-    assert_equal(isdefaulted, heating_system.fan_watts_isdefaulted)
+    if heating_capacity.nil?
+      assert(heating_system.heating_capacity > 0)
+    else
+      assert_equal(heating_system.heating_capacity, heating_capacity)
+    end
   end
 
-  def _test_default_fixed_heater_values(hpxml, isdefaulted, fan_watts)
+  def _test_default_portable_heater_values(hpxml, fan_watts, heating_capacity)
     heating_system = hpxml.heating_systems[0]
 
     assert_equal(fan_watts, heating_system.fan_watts)
-    assert_equal(isdefaulted, heating_system.fan_watts_isdefaulted)
+    if heating_capacity.nil?
+      assert(heating_system.heating_capacity > 0)
+    else
+      assert_equal(heating_system.heating_capacity, heating_capacity)
+    end
   end
 
-  def _test_default_fireplace_values(hpxml, isdefaulted, fan_watts)
+  def _test_default_fixed_heater_values(hpxml, fan_watts, heating_capacity)
     heating_system = hpxml.heating_systems[0]
 
     assert_equal(fan_watts, heating_system.fan_watts)
-    assert_equal(isdefaulted, heating_system.fan_watts_isdefaulted)
+    if heating_capacity.nil?
+      assert(heating_system.heating_capacity > 0)
+    else
+      assert_equal(heating_system.heating_capacity, heating_capacity)
+    end
   end
 
-  def _test_default_boiler_values(hpxml, isdefaulted, eae)
+  def _test_default_fireplace_values(hpxml, fan_watts, heating_capacity)
     heating_system = hpxml.heating_systems[0]
 
-    assert_equal(eae, heating_system.electric_auxiliary_energy)
-    assert_equal(isdefaulted, heating_system.electric_auxiliary_energy_isdefaulted)
+    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)
+    end
   end
 
-  def _test_default_air_to_air_heat_pump_values(hpxml, isdefaulted, shr, compressor_type, fan_watts_per_cfm)
+  def _test_default_air_to_air_heat_pump_values(hpxml, shr, compressor_type, fan_watts_per_cfm, charge_defect_ratio,
+                                                airflow_defect_ratio, cooling_capacity, heating_capacity,
+                                                heating_capacity_17F, backup_heating_capacity)
     heat_pump = hpxml.heat_pumps[0]
 
     assert_equal(shr, heat_pump.cooling_shr)
-    assert_equal(isdefaulted, heat_pump.cooling_shr_isdefaulted)
-
     assert_equal(compressor_type, heat_pump.compressor_type)
-    assert_equal(isdefaulted, heat_pump.compressor_type_isdefaulted)
-
     assert_equal(fan_watts_per_cfm, heat_pump.fan_watts_per_cfm)
-    assert_equal(isdefaulted, heat_pump.fan_watts_per_cfm_isdefaulted)
+    assert_equal(charge_defect_ratio, heat_pump.charge_defect_ratio)
+    assert_equal(airflow_defect_ratio, heat_pump.airflow_defect_ratio)
+    if cooling_capacity.nil?
+      assert(heat_pump.cooling_capacity > 0)
+    else
+      assert_equal(heat_pump.cooling_capacity, cooling_capacity)
+    end
+    if heating_capacity.nil?
+      assert(heat_pump.heating_capacity > 0)
+    else
+      assert_equal(heat_pump.heating_capacity, heating_capacity)
+    end
+    if heating_capacity_17F.nil?
+      # assert(heat_pump.heating_capacity_17F > 0) # FUTURE
+    else
+      assert_equal(heat_pump.heating_capacity_17F, 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)
+    end
   end
 
-  def _test_default_mini_split_heat_pump_values(hpxml, isdefaulted, shr, fan_watts_per_cfm)
+  def _test_default_mini_split_heat_pump_values(hpxml, shr, fan_watts_per_cfm, charge_defect_ratio,
+                                                airflow_defect_ratio, cooling_capacity, heating_capacity,
+                                                heating_capacity_17F, backup_heating_capacity)
     heat_pump = hpxml.heat_pumps[0]
 
     assert_equal(shr, heat_pump.cooling_shr)
-    assert_equal(isdefaulted, heat_pump.cooling_shr_isdefaulted)
-
     assert_equal(fan_watts_per_cfm, heat_pump.fan_watts_per_cfm)
-    assert_equal(isdefaulted, heat_pump.fan_watts_per_cfm_isdefaulted)
+    assert_equal(charge_defect_ratio, heat_pump.charge_defect_ratio)
+    assert_equal(airflow_defect_ratio, heat_pump.airflow_defect_ratio)
+    if cooling_capacity.nil?
+      assert(heat_pump.cooling_capacity > 0)
+    else
+      assert_equal(heat_pump.cooling_capacity, cooling_capacity)
+    end
+    if heating_capacity.nil?
+      assert(heat_pump.heating_capacity > 0)
+    else
+      assert_equal(heat_pump.heating_capacity, heating_capacity)
+    end
+    if heating_capacity_17F.nil?
+      # assert(heat_pump.heating_capacity_17F > 0) # FUTURE
+    else
+      assert_equal(heat_pump.heating_capacity_17F, 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)
+    end
   end
 
-  def _test_default_ground_to_air_heat_pump_values(hpxml, isdefaulted, pump_watts_per_ton, fan_watts_per_cfm)
+  def _test_default_ground_to_air_heat_pump_values(hpxml, pump_watts_per_ton, fan_watts_per_cfm,
+                                                   airflow_defect_ratio, cooling_capacity, heating_capacity,
+                                                   backup_heating_capacity)
+
     heat_pump = hpxml.heat_pumps[0]
 
     assert_equal(pump_watts_per_ton, heat_pump.pump_watts_per_ton)
-    assert_equal(isdefaulted, heat_pump.pump_watts_per_ton_isdefaulted)
-
     assert_equal(fan_watts_per_cfm, heat_pump.fan_watts_per_cfm)
-    assert_equal(isdefaulted, heat_pump.fan_watts_per_cfm_isdefaulted)
+    assert_equal(airflow_defect_ratio, heat_pump.airflow_defect_ratio)
+    if cooling_capacity.nil?
+      assert(heat_pump.cooling_capacity > 0)
+    else
+      assert_equal(heat_pump.cooling_capacity, cooling_capacity)
+    end
+    if heating_capacity.nil?
+      assert(heat_pump.heating_capacity > 0)
+    else
+      assert_equal(heat_pump.heating_capacity, 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)
+    end
   end
 
-  def _test_default_hvac_control_values(hpxml, isdefaulted, htg_setback_start_hr, clg_setup_start_hr)
+  def _test_default_hvac_control_values(hpxml, htg_setback_start_hr, clg_setup_start_hr)
     hvac_control = hpxml.hvac_controls[0]
 
     assert_equal(htg_setback_start_hr, hvac_control.heating_setback_start_hour)
-    assert_equal(isdefaulted, hvac_control.heating_setback_start_hour_isdefaulted)
-
     assert_equal(clg_setup_start_hr, hvac_control.cooling_setup_start_hour)
-    assert_equal(isdefaulted, hvac_control.cooling_setup_start_hour_isdefaulted)
   end
 
-  def _test_default_duct_values(hpxml, isdefaulted, supply_locations, return_locations, supply_areas, return_areas, n_return_registers)
+  def _test_default_duct_values(hpxml, supply_locations, return_locations, supply_areas, return_areas, n_return_registers)
     supply_duct_idx = 0
     return_duct_idx = 0
     hpxml.hvac_distributions.each do |hvac_distribution|
-      next unless [HPXML::HVACDistributionTypeAir, HPXML::HVACDistributionTypeHydronicAndAir].include? hvac_distribution.distribution_system_type
+      next unless [HPXML::HVACDistributionTypeAir].include? hvac_distribution.distribution_system_type
 
       assert_equal(n_return_registers, hvac_distribution.number_of_return_registers)
-      assert_equal(isdefaulted, hvac_distribution.number_of_return_registers_isdefaulted)
-
       hvac_distribution.ducts.each do |duct|
         if duct.duct_type == HPXML::DuctTypeSupply
           assert_equal(supply_locations[supply_duct_idx], duct.duct_location)
-          assert_equal(isdefaulted, duct.duct_location_isdefaulted)
-
           assert_in_epsilon(supply_areas[supply_duct_idx], duct.duct_surface_area, 0.01)
-          assert_equal(isdefaulted, duct.duct_surface_area_isdefaulted)
-
           supply_duct_idx += 1
         elsif duct.duct_type == HPXML::DuctTypeReturn
           assert_equal(return_locations[return_duct_idx], duct.duct_location)
-          assert_equal(isdefaulted, duct.duct_location_isdefaulted)
-
           assert_in_epsilon(return_areas[return_duct_idx], duct.duct_surface_area, 0.01)
-          assert_equal(isdefaulted, duct.duct_surface_area_isdefaulted)
-
           return_duct_idx += 1
         end
       end
     end
   end
 
-  def _test_default_mech_vent_values(hpxml, isdefaulted, is_shared_system, hours_in_operation)
+  def _test_default_mech_vent_values(hpxml, is_shared_system, hours_in_operation)
     vent_fan = hpxml.ventilation_fans.select { |f| f.used_for_whole_building_ventilation }[0]
 
     assert_equal(is_shared_system, vent_fan.is_shared_system)
-    assert_equal(isdefaulted, vent_fan.is_shared_system_isdefaulted)
-
     assert_equal(hours_in_operation, vent_fan.hours_in_operation)
-    assert_equal(isdefaulted, vent_fan.hours_in_operation_isdefaulted)
   end
 
-  def _test_default_kitchen_fan_values(hpxml, isdefaulted, quantity, rated_flow_rate, hours_in_operation, fan_power, start_hour)
+  def _test_default_kitchen_fan_values(hpxml, quantity, rated_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]
 
     assert_equal(quantity, kitchen_fan.quantity)
-    assert_equal(isdefaulted, kitchen_fan.quantity_isdefaulted)
-
     assert_equal(rated_flow_rate, kitchen_fan.rated_flow_rate)
-    assert_equal(isdefaulted, kitchen_fan.rated_flow_rate_isdefaulted)
-
     assert_equal(hours_in_operation, kitchen_fan.hours_in_operation)
-    assert_equal(isdefaulted, kitchen_fan.hours_in_operation_isdefaulted)
-
     assert_equal(fan_power, kitchen_fan.fan_power)
-    assert_equal(isdefaulted, kitchen_fan.fan_power_isdefaulted)
-
     assert_equal(start_hour, kitchen_fan.start_hour)
-    assert_equal(isdefaulted, kitchen_fan.start_hour_isdefaulted)
   end
 
-  def _test_default_bath_fan_values(hpxml, isdefaulted, quantity, rated_flow_rate, hours_in_operation, fan_power, start_hour)
+  def _test_default_bath_fan_values(hpxml, quantity, rated_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]
 
     assert_equal(quantity, bath_fan.quantity)
-    assert_equal(isdefaulted, bath_fan.quantity_isdefaulted)
-
     assert_equal(rated_flow_rate, bath_fan.rated_flow_rate)
-    assert_equal(isdefaulted, bath_fan.rated_flow_rate_isdefaulted)
-
     assert_equal(hours_in_operation, bath_fan.hours_in_operation)
-    assert_equal(isdefaulted, bath_fan.hours_in_operation_isdefaulted)
-
     assert_equal(fan_power, bath_fan.fan_power)
-    assert_equal(isdefaulted, bath_fan.fan_power_isdefaulted)
-
     assert_equal(start_hour, bath_fan.start_hour)
-    assert_equal(isdefaulted, bath_fan.start_hour_isdefaulted)
   end
 
-  def _test_default_storage_water_heater_values(hpxml, isdefaulted, *expected_wh_values)
+  def _test_default_storage_water_heater_values(hpxml, *expected_wh_values)
     storage_water_heaters = hpxml.water_heating_systems.select { |w| w.water_heater_type == HPXML::WaterHeaterTypeStorage }
     assert_equal(expected_wh_values.size, storage_water_heaters.size)
     storage_water_heaters.each_with_index do |wh_system, idx|
       is_shared, heating_capacity, tank_volume, recovery_efficiency, location = expected_wh_values[idx]
 
       assert_equal(is_shared, wh_system.is_shared_system)
-      assert_equal(isdefaulted, wh_system.is_shared_system_isdefaulted)
-
       assert_in_epsilon(heating_capacity, wh_system.heating_capacity, 0.01)
-      assert_equal(isdefaulted, wh_system.heating_capacity_isdefaulted)
-
       assert_equal(tank_volume, wh_system.tank_volume)
-      assert_equal(isdefaulted, wh_system.tank_volume_isdefaulted)
-
       assert_in_epsilon(recovery_efficiency, wh_system.recovery_efficiency, 0.01)
-      assert_equal(isdefaulted, wh_system.recovery_efficiency_isdefaulted)
-
       assert_equal(location, wh_system.location)
-      assert_equal(isdefaulted, wh_system.location_isdefaulted)
     end
   end
 
-  def _test_default_tankless_water_heater_values(hpxml, isdefaulted, *expected_wh_values)
+  def _test_default_tankless_water_heater_values(hpxml, *expected_wh_values)
     tankless_water_heaters = hpxml.water_heating_systems.select { |w| w.water_heater_type == HPXML::WaterHeaterTypeTankless }
     assert_equal(expected_wh_values.size, tankless_water_heaters.size)
     tankless_water_heaters.each_with_index do |wh_system, idx|
       performance_adjustment, = expected_wh_values[idx]
 
       assert_equal(performance_adjustment, wh_system.performance_adjustment)
-      assert_equal(isdefaulted, wh_system.performance_adjustment_isdefaulted)
     end
   end
 
-  def _test_default_standard_distribution_values(hpxml, isdefaulted, piping_length, pipe_r_value)
+  def _test_default_standard_distribution_values(hpxml, piping_length, pipe_r_value)
     hot_water_distribution = hpxml.hot_water_distributions[0]
 
     assert_in_epsilon(piping_length, hot_water_distribution.standard_piping_length, 0.01)
-    assert_equal(isdefaulted, hot_water_distribution.standard_piping_length_isdefaulted)
-
     assert_equal(pipe_r_value, hot_water_distribution.pipe_r_value)
-    assert_equal(isdefaulted, hot_water_distribution.pipe_r_value_isdefaulted)
   end
 
-  def _test_default_recirc_distribution_values(hpxml, isdefaulted, piping_length, branch_piping_length, pump_power, pipe_r_value)
+  def _test_default_recirc_distribution_values(hpxml, piping_length, branch_piping_length, pump_power, pipe_r_value)
     hot_water_distribution = hpxml.hot_water_distributions[0]
 
     assert_in_epsilon(piping_length, hot_water_distribution.recirculation_piping_length, 0.01)
-    assert_equal(isdefaulted, hot_water_distribution.recirculation_piping_length_isdefaulted)
-
     assert_in_epsilon(branch_piping_length, hot_water_distribution.recirculation_branch_piping_length, 0.01)
-    assert_equal(isdefaulted, hot_water_distribution.recirculation_branch_piping_length_isdefaulted)
-
     assert_in_epsilon(pump_power, hot_water_distribution.recirculation_pump_power, 0.01)
-    assert_equal(isdefaulted, hot_water_distribution.recirculation_pump_power_isdefaulted)
-
     assert_equal(pipe_r_value, hot_water_distribution.pipe_r_value)
-    assert_equal(isdefaulted, hot_water_distribution.pipe_r_value_isdefaulted)
   end
 
-  def _test_default_shared_recirc_distribution_values(hpxml, isdefaulted, pump_power)
+  def _test_default_shared_recirc_distribution_values(hpxml, pump_power)
     hot_water_distribution = hpxml.hot_water_distributions[0]
 
     assert_in_epsilon(pump_power, hot_water_distribution.shared_recirculation_pump_power, 0.01)
-    assert_equal(isdefaulted, hot_water_distribution.shared_recirculation_pump_power_isdefaulted)
   end
 
-  def _test_default_water_fixture_values(hpxml, isdefaulted, usage_multiplier)
+  def _test_default_water_fixture_values(hpxml, usage_multiplier)
     assert_equal(usage_multiplier, hpxml.water_heating.water_fixtures_usage_multiplier)
-    assert_equal(isdefaulted, hpxml.water_heating.water_fixtures_usage_multiplier_isdefaulted)
   end
 
-  def _test_default_solar_thermal_values(hpxml, isdefaulted, storage_volume)
+  def _test_default_solar_thermal_values(hpxml, storage_volume)
     solar_thermal_system = hpxml.solar_thermal_systems[0]
 
     assert_equal(storage_volume, solar_thermal_system.storage_volume)
-    assert_equal(isdefaulted, solar_thermal_system.storage_volume_isdefaulted)
   end
 
-  def _test_default_pv_system_values(hpxml, isdefaulted, interver_efficiency, system_loss_frac, is_shared_system, location, tracking, module_type)
+  def _test_default_pv_system_values(hpxml, interver_efficiency, system_loss_frac, is_shared_system, location, tracking, module_type)
     hpxml.pv_systems.each_with_index do |pv, idx|
       assert_equal(is_shared_system, pv.is_shared_system)
-      assert_equal(isdefaulted, pv.is_shared_system_isdefaulted)
-
       assert_equal(interver_efficiency, pv.inverter_efficiency)
-      assert_equal(isdefaulted, pv.inverter_efficiency_isdefaulted)
-
       assert_in_epsilon(system_loss_frac, pv.system_losses_fraction, 0.01)
-      assert_equal(isdefaulted, pv.system_losses_fraction_isdefaulted)
-
       assert_equal(location, pv.location)
-      assert_equal(isdefaulted, pv.location_isdefaulted)
-
       assert_equal(tracking, pv.tracking)
-      assert_equal(isdefaulted, pv.tracking_isdefaulted)
-
       assert_equal(module_type, pv.module_type)
-      assert_equal(isdefaulted, pv.module_type_isdefaulted)
     end
   end
 
-  def _test_default_generator_values(hpxml, isdefaulted, is_shared_system)
+  def _test_default_generator_values(hpxml, is_shared_system)
     hpxml.generators.each_with_index do |generator, idx|
       assert_equal(is_shared_system, generator.is_shared_system)
-      assert_equal(isdefaulted, generator.is_shared_system_isdefaulted)
     end
   end
 
-  def _test_default_clothes_washer_values(hpxml, isdefaulted, is_shared, location, imef, rated_annual_kwh, label_electric_rate, label_gas_rate, label_annual_gas_cost, capacity, label_usage, usage_multiplier)
+  def _test_default_clothes_washer_values(hpxml, is_shared, location, imef, rated_annual_kwh, label_electric_rate, label_gas_rate, label_annual_gas_cost, capacity, label_usage, usage_multiplier)
     clothes_washer = hpxml.clothes_washers[0]
 
     assert_equal(is_shared, clothes_washer.is_shared_appliance)
-    assert_equal(isdefaulted, clothes_washer.is_shared_appliance_isdefaulted)
-
     assert_equal(location, clothes_washer.location)
-    assert_equal(isdefaulted, clothes_washer.location_isdefaulted)
-
     assert_equal(imef, clothes_washer.integrated_modified_energy_factor)
-    assert_equal(isdefaulted, clothes_washer.integrated_modified_energy_factor_isdefaulted)
-
     assert_equal(rated_annual_kwh, clothes_washer.rated_annual_kwh)
-    assert_equal(isdefaulted, clothes_washer.rated_annual_kwh_isdefaulted)
-
     assert_equal(label_electric_rate, clothes_washer.label_electric_rate)
-    assert_equal(isdefaulted, clothes_washer.label_electric_rate_isdefaulted)
-
     assert_equal(label_gas_rate, clothes_washer.label_gas_rate)
-    assert_equal(isdefaulted, clothes_washer.label_gas_rate_isdefaulted)
-
     assert_equal(label_annual_gas_cost, clothes_washer.label_annual_gas_cost)
-    assert_equal(isdefaulted, clothes_washer.label_annual_gas_cost_isdefaulted)
-
     assert_equal(capacity, clothes_washer.capacity)
-    assert_equal(isdefaulted, clothes_washer.capacity_isdefaulted)
-
     assert_equal(label_usage, clothes_washer.label_usage)
-    assert_equal(isdefaulted, clothes_washer.label_usage_isdefaulted)
-
     assert_equal(usage_multiplier, clothes_washer.usage_multiplier)
-    assert_equal(isdefaulted, clothes_washer.usage_multiplier_isdefaulted)
   end
 
-  def _test_default_clothes_dryer_values(hpxml, isdefaulted, is_shared, location, control_type, cef, usage_multiplier)
+  def _test_default_clothes_dryer_values(hpxml, is_shared, location, cef, usage_multiplier)
     clothes_dryer = hpxml.clothes_dryers[0]
 
     assert_equal(is_shared, clothes_dryer.is_shared_appliance)
-    assert_equal(isdefaulted, clothes_dryer.is_shared_appliance_isdefaulted)
-
     assert_equal(location, clothes_dryer.location)
-    assert_equal(isdefaulted, clothes_dryer.location_isdefaulted)
-
-    assert_equal(control_type, clothes_dryer.control_type)
-    assert_equal(isdefaulted, clothes_dryer.control_type_isdefaulted)
-
     assert_equal(cef, clothes_dryer.combined_energy_factor)
-    assert_equal(isdefaulted, clothes_dryer.combined_energy_factor_isdefaulted)
-
     assert_equal(usage_multiplier, clothes_dryer.usage_multiplier)
-    assert_equal(isdefaulted, clothes_dryer.usage_multiplier_isdefaulted)
   end
 
-  def _test_default_clothes_dryer_exhaust_values(hpxml, isdefaulted, is_vented, vented_flow_rate)
+  def _test_default_clothes_dryer_exhaust_values(hpxml, is_vented, vented_flow_rate)
     clothes_dryer = hpxml.clothes_dryers[0]
 
     assert_equal(is_vented, clothes_dryer.is_vented)
-    assert_equal(isdefaulted, clothes_dryer.is_vented_isdefaulted)
-
     if vented_flow_rate.nil?
       assert_nil(clothes_dryer.vented_flow_rate)
     else
       assert_equal(vented_flow_rate, clothes_dryer.vented_flow_rate)
-      assert_equal(isdefaulted, clothes_dryer.vented_flow_rate_isdefaulted)
     end
   end
 
-  def _test_default_dishwasher_values(hpxml, isdefaulted, is_shared, location, rated_annual_kwh, label_electric_rate, label_gas_rate, label_annual_gas_cost, label_usage, place_setting_capacity, usage_multiplier)
+  def _test_default_dishwasher_values(hpxml, is_shared, location, rated_annual_kwh, label_electric_rate, label_gas_rate, label_annual_gas_cost, label_usage, place_setting_capacity, usage_multiplier)
     dishwasher = hpxml.dishwashers[0]
 
     assert_equal(is_shared, dishwasher.is_shared_appliance)
-    assert_equal(isdefaulted, dishwasher.is_shared_appliance_isdefaulted)
-
     assert_equal(location, dishwasher.location)
-    assert_equal(isdefaulted, dishwasher.location_isdefaulted)
-
     assert_equal(rated_annual_kwh, dishwasher.rated_annual_kwh)
-    assert_equal(isdefaulted, dishwasher.rated_annual_kwh_isdefaulted)
-
     assert_equal(label_electric_rate, dishwasher.label_electric_rate)
-    assert_equal(isdefaulted, dishwasher.label_electric_rate_isdefaulted)
-
     assert_equal(label_gas_rate, dishwasher.label_gas_rate)
-    assert_equal(isdefaulted, dishwasher.label_gas_rate_isdefaulted)
-
     assert_equal(label_annual_gas_cost, dishwasher.label_annual_gas_cost)
-    assert_equal(isdefaulted, dishwasher.label_annual_gas_cost_isdefaulted)
-
     assert_equal(label_usage, dishwasher.label_usage)
-    assert_equal(isdefaulted, dishwasher.label_usage_isdefaulted)
-
     assert_equal(place_setting_capacity, dishwasher.place_setting_capacity)
-    assert_equal(isdefaulted, dishwasher.place_setting_capacity_isdefaulted)
-
     assert_equal(usage_multiplier, dishwasher.usage_multiplier)
-    assert_equal(isdefaulted, dishwasher.usage_multiplier_isdefaulted)
   end
 
-  def _test_default_refrigerator_values(hpxml, isdefaulted, location, rated_annual_kwh, usage_multiplier, weekday_sch, weekend_sch, monthly_mults)
+  def _test_default_refrigerator_values(hpxml, location, rated_annual_kwh, usage_multiplier, weekday_sch, weekend_sch, monthly_mults)
     hpxml.refrigerators.each do |refrigerator|
       next unless refrigerator.primary_indicator
 
       assert_equal(location, refrigerator.location)
-      assert_equal(isdefaulted, refrigerator.location_isdefaulted)
-
       assert_equal(rated_annual_kwh, refrigerator.rated_annual_kwh)
-      assert_equal(isdefaulted, refrigerator.rated_annual_kwh_isdefaulted)
-
       assert_equal(usage_multiplier, refrigerator.usage_multiplier)
-      assert_equal(isdefaulted, refrigerator.usage_multiplier_isdefaulted)
-
       if weekday_sch.nil?
         assert_nil(refrigerator.weekday_fractions)
       else
         assert_equal(weekday_sch, refrigerator.weekday_fractions)
-        assert_equal(isdefaulted, refrigerator.weekday_fractions_isdefaulted)
       end
-
       if weekend_sch.nil?
         assert_nil(refrigerator.weekend_fractions)
       else
         assert_equal(weekend_sch, refrigerator.weekend_fractions)
-        assert_equal(isdefaulted, refrigerator.weekend_fractions_isdefaulted)
       end
-
       if monthly_mults.nil?
         assert_nil(refrigerator.monthly_multipliers)
       else
         assert_equal(monthly_mults, refrigerator.monthly_multipliers)
-        assert_equal(isdefaulted, refrigerator.monthly_multipliers_isdefaulted)
       end
     end
   end
 
-  def _test_default_extra_refrigerators_values(hpxml, isdefaulted, location, rated_annual_kwh, usage_multiplier, weekday_sch, weekend_sch, monthly_mults)
+  def _test_default_extra_refrigerators_values(hpxml, location, rated_annual_kwh, usage_multiplier, weekday_sch, weekend_sch, monthly_mults)
     hpxml.refrigerators.each do |refrigerator|
       next if refrigerator.primary_indicator
 
       assert_equal(location, refrigerator.location)
-      assert_equal(isdefaulted, refrigerator.location_isdefaulted)
-
       assert_in_epsilon(rated_annual_kwh, refrigerator.rated_annual_kwh, 0.01)
-      assert_equal(isdefaulted, refrigerator.rated_annual_kwh_isdefaulted)
-
       assert_equal(usage_multiplier, refrigerator.usage_multiplier)
-      assert_equal(isdefaulted, refrigerator.usage_multiplier_isdefaulted)
-
       if weekday_sch.nil?
         assert_nil(refrigerator.weekday_fractions)
       else
         assert_equal(weekday_sch, refrigerator.weekday_fractions)
-        assert_equal(isdefaulted, refrigerator.weekday_fractions_isdefaulted)
       end
-
       if weekend_sch.nil?
         assert_nil(refrigerator.weekend_fractions)
       else
         assert_equal(weekend_sch, refrigerator.weekend_fractions)
-        assert_equal(isdefaulted, refrigerator.weekend_fractions_isdefaulted)
       end
-
       if monthly_mults.nil?
         assert_nil(refrigerator.monthly_multipliers)
       else
         assert_equal(monthly_mults, refrigerator.monthly_multipliers)
-        assert_equal(isdefaulted, refrigerator.monthly_multipliers_isdefaulted)
       end
     end
   end
 
-  def _test_default_freezers_values(hpxml, isdefaulted, location, rated_annual_kwh, usage_multiplier, weekday_sch, weekend_sch, monthly_mults)
+  def _test_default_freezers_values(hpxml, location, rated_annual_kwh, usage_multiplier, weekday_sch, weekend_sch, monthly_mults)
     hpxml.freezers.each do |freezer|
       assert_equal(location, freezer.location)
-      assert_equal(isdefaulted, freezer.location_isdefaulted)
-
       assert_in_epsilon(rated_annual_kwh, freezer.rated_annual_kwh, 0.01)
-      assert_equal(isdefaulted, freezer.rated_annual_kwh_isdefaulted)
-
       assert_equal(usage_multiplier, freezer.usage_multiplier)
-      assert_equal(isdefaulted, freezer.usage_multiplier_isdefaulted)
-
       if weekday_sch.nil?
         assert_nil(freezer.weekday_fractions)
       else
         assert_equal(weekday_sch, freezer.weekday_fractions)
-        assert_equal(isdefaulted, freezer.weekday_fractions_isdefaulted)
       end
-
       if weekend_sch.nil?
         assert_nil(freezer.weekend_fractions)
       else
         assert_equal(weekend_sch, freezer.weekend_fractions)
-        assert_equal(isdefaulted, freezer.weekend_fractions_isdefaulted)
       end
-
       if monthly_mults.nil?
         assert_nil(freezer.monthly_multipliers)
       else
         assert_equal(monthly_mults, freezer.monthly_multipliers)
-        assert_equal(isdefaulted, freezer.monthly_multipliers_isdefaulted)
       end
     end
   end
 
-  def _test_default_cooking_range_values(hpxml, isdefaulted, location, is_induction, usage_multiplier, weekday_sch, weekend_sch, monthly_mults)
+  def _test_default_cooking_range_values(hpxml, location, is_induction, usage_multiplier, weekday_sch, weekend_sch, monthly_mults)
     cooking_range = hpxml.cooking_ranges[0]
 
     assert_equal(location, cooking_range.location)
-    assert_equal(isdefaulted, cooking_range.location_isdefaulted)
-
     assert_equal(is_induction, cooking_range.is_induction)
-    assert_equal(isdefaulted, cooking_range.is_induction_isdefaulted)
-
     assert_equal(usage_multiplier, cooking_range.usage_multiplier)
-    assert_equal(isdefaulted, cooking_range.usage_multiplier_isdefaulted)
-
     if weekday_sch.nil?
       assert_nil(cooking_range.weekday_fractions)
     else
       assert_equal(weekday_sch, cooking_range.weekday_fractions)
-      assert_equal(isdefaulted, cooking_range.weekday_fractions_isdefaulted)
     end
-
     if weekend_sch.nil?
       assert_nil(cooking_range.weekend_fractions)
     else
       assert_equal(weekend_sch, cooking_range.weekend_fractions)
-      assert_equal(isdefaulted, cooking_range.weekend_fractions_isdefaulted)
     end
-
     if monthly_mults.nil?
       assert_nil(cooking_range.monthly_multipliers)
     else
       assert_equal(monthly_mults, cooking_range.monthly_multipliers)
-      assert_equal(isdefaulted, cooking_range.monthly_multipliers_isdefaulted)
     end
   end
 
-  def _test_default_oven_values(hpxml, isdefaulted, is_convection)
+  def _test_default_oven_values(hpxml, is_convection)
     oven = hpxml.ovens[0]
 
     assert_equal(is_convection, oven.is_convection)
-    assert_equal(isdefaulted, oven.is_convection_isdefaulted)
   end
 
-  def _test_default_lighting_values(hpxml, isdefaulted, interior_usage_multiplier, garage_usage_multiplier, exterior_usage_multiplier, schedules = {})
+  def _test_default_lighting_values(hpxml, interior_usage_multiplier, garage_usage_multiplier, exterior_usage_multiplier, schedules = {})
     assert_equal(interior_usage_multiplier, hpxml.lighting.interior_usage_multiplier)
-    assert_equal(isdefaulted, hpxml.lighting.interior_usage_multiplier_isdefaulted)
-
     assert_equal(garage_usage_multiplier, hpxml.lighting.garage_usage_multiplier)
-    assert_equal(isdefaulted, hpxml.lighting.garage_usage_multiplier_isdefaulted)
-
     assert_equal(exterior_usage_multiplier, hpxml.lighting.exterior_usage_multiplier)
-    assert_equal(isdefaulted, hpxml.lighting.exterior_usage_multiplier_isdefaulted)
-
     if not schedules[:grg_wk_sch].nil?
       assert_equal(schedules[:grg_wk_sch], hpxml.lighting.garage_weekday_fractions)
-      assert_equal(isdefaulted, hpxml.lighting.garage_weekday_fractions_isdefaulted)
     else
       assert_nil(hpxml.lighting.garage_weekday_fractions)
     end
-
     if not schedules[:grg_wknd_sch].nil?
       assert_equal(schedules[:grg_wknd_sch], hpxml.lighting.garage_weekend_fractions)
-      assert_equal(isdefaulted, hpxml.lighting.garage_weekend_fractions_isdefaulted)
     else
       assert_nil(hpxml.lighting.garage_weekend_fractions)
     end
-
     if not schedules[:grg_month_mult].nil?
       assert_equal(schedules[:grg_month_mult], hpxml.lighting.garage_monthly_multipliers)
-      assert_equal(isdefaulted, hpxml.lighting.garage_monthly_multipliers_isdefaulted)
     else
       assert_nil(hpxml.lighting.garage_monthly_multipliers)
     end
-
     if not schedules[:ext_wk_sch].nil?
       assert_equal(schedules[:ext_wk_sch], hpxml.lighting.exterior_weekday_fractions)
-      assert_equal(isdefaulted, hpxml.lighting.exterior_weekday_fractions_isdefaulted)
     else
       assert_nil(hpxml.lighting.exterior_weekday_fractions)
     end
-
     if not schedules[:ext_wknd_sch].nil?
       assert_equal(schedules[:ext_wknd_sch], hpxml.lighting.exterior_weekend_fractions)
-      assert_equal(isdefaulted, hpxml.lighting.exterior_weekend_fractions_isdefaulted)
     else
       assert_nil(hpxml.lighting.exterior_weekday_fractions)
     end
-
     if not schedules[:ext_month_mult].nil?
       assert_equal(schedules[:ext_month_mult], hpxml.lighting.exterior_monthly_multipliers)
-      assert_equal(isdefaulted, hpxml.lighting.exterior_monthly_multipliers_isdefaulted)
     else
       assert_nil(hpxml.lighting.exterior_monthly_multipliers)
     end
-
     if not schedules[:hol_kwh_per_day].nil?
       assert_equal(schedules[:hol_kwh_per_day], hpxml.lighting.holiday_kwh_per_day)
-      assert_equal(isdefaulted, hpxml.lighting.holiday_kwh_per_day_isdefaulted)
     else
       assert_nil(hpxml.lighting.holiday_kwh_per_day)
     end
-
     if not schedules[:hol_begin_month].nil?
       assert_equal(schedules[:hol_begin_month], hpxml.lighting.holiday_period_begin_month)
-      assert_equal(isdefaulted, hpxml.lighting.holiday_period_begin_month_isdefaulted)
     else
       assert_nil(hpxml.lighting.holiday_period_begin_month)
     end
-
     if not schedules[:hol_begin_day].nil?
       assert_equal(schedules[:hol_begin_day], hpxml.lighting.holiday_period_begin_day)
-      assert_equal(isdefaulted, hpxml.lighting.holiday_period_begin_day_isdefaulted)
     else
       assert_nil(hpxml.lighting.holiday_period_begin_day)
     end
-
     if not schedules[:hol_end_month].nil?
       assert_equal(schedules[:hol_end_month], hpxml.lighting.holiday_period_end_month)
-      assert_equal(isdefaulted, hpxml.lighting.holiday_period_end_month_isdefaulted)
     else
       assert_nil(hpxml.lighting.holiday_period_end_month)
     end
-
     if not schedules[:hol_end_day].nil?
       assert_equal(schedules[:hol_end_day], hpxml.lighting.holiday_period_end_day)
-      assert_equal(isdefaulted, hpxml.lighting.holiday_period_end_day_isdefaulted)
     else
       assert_nil(hpxml.lighting.holiday_period_end_day)
     end
-
     if not schedules[:hol_wk_sch].nil?
       assert_equal(schedules[:hol_wk_sch], hpxml.lighting.holiday_weekday_fractions)
-      assert_equal(isdefaulted, hpxml.lighting.holiday_weekday_fractions_isdefaulted)
     else
       assert_nil(hpxml.lighting.holiday_weekday_fractions)
     end
-
     if not schedules[:hol_wknd_sch].nil?
       assert_equal(schedules[:hol_wknd_sch], hpxml.lighting.holiday_weekend_fractions)
-      assert_equal(isdefaulted, hpxml.lighting.holiday_weekend_fractions_isdefaulted)
     else
       assert_nil(hpxml.lighting.holiday_weekend_fractions)
     end
   end
 
-  def _test_default_ceiling_fan_values(hpxml, isdefaulted, quantity, efficiency)
+  def _test_default_ceiling_fan_values(hpxml, quantity, efficiency)
     ceiling_fan = hpxml.ceiling_fans[0]
 
     assert_equal(quantity, ceiling_fan.quantity)
-    assert_equal(isdefaulted, ceiling_fan.quantity_isdefaulted)
-
     assert_in_epsilon(efficiency, ceiling_fan.efficiency, 0.01)
-    assert_equal(isdefaulted, ceiling_fan.efficiency_isdefaulted)
   end
 
-  def _test_default_pool_heater_values(hpxml, isdefaulted, load_units, load_value, usage_multiplier, weekday_sch, weekend_sch, monthly_mults)
+  def _test_default_pool_heater_values(hpxml, load_units, load_value, usage_multiplier, weekday_sch, weekend_sch, monthly_mults)
     pool = hpxml.pools[0]
 
     if load_units.nil?
@@ -2664,63 +2616,44 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     else
       assert_equal(load_units, pool.heater_load_units)
     end
-
     if load_value.nil?
       assert_nil(pool.heater_load_value)
     else
       assert_in_epsilon(load_value, pool.heater_load_value, 0.01)
-      assert_equal(isdefaulted, pool.heater_load_value_isdefaulted)
     end
-
     if usage_multiplier.nil?
       assert_nil(pool.heater_usage_multiplier)
     else
       assert_equal(usage_multiplier, pool.heater_usage_multiplier)
-      assert_equal(isdefaulted, pool.heater_usage_multiplier_isdefaulted)
     end
-
     if weekday_sch.nil?
       assert_nil(pool.heater_weekday_fractions)
     else
       assert_equal(weekday_sch, pool.heater_weekday_fractions)
-      assert_equal(isdefaulted, pool.heater_weekday_fractions_isdefaulted)
     end
-
     if weekend_sch.nil?
       assert_nil(pool.heater_weekend_fractions)
     else
       assert_equal(weekend_sch, pool.heater_weekend_fractions)
-      assert_equal(isdefaulted, pool.heater_weekend_fractions_isdefaulted)
     end
-
     if monthly_mults.nil?
       assert_nil(pool.heater_monthly_multipliers)
     else
       assert_equal(monthly_mults, pool.heater_monthly_multipliers)
-      assert_equal(isdefaulted, pool.heater_monthly_multipliers_isdefaulted)
     end
   end
 
-  def _test_default_pool_pump_values(hpxml, isdefaulted, kWh_per_year, usage_multiplier, weekday_sch, weekend_sch, monthly_mults)
+  def _test_default_pool_pump_values(hpxml, kWh_per_year, usage_multiplier, weekday_sch, weekend_sch, monthly_mults)
     pool = hpxml.pools[0]
 
     assert_in_epsilon(kWh_per_year, pool.pump_kwh_per_year, 0.01)
-    assert_equal(isdefaulted, pool.pump_kwh_per_year_isdefaulted)
-
     assert_equal(usage_multiplier, pool.pump_usage_multiplier)
-    assert_equal(isdefaulted, pool.pump_usage_multiplier_isdefaulted)
-
     assert_equal(weekday_sch, pool.pump_weekday_fractions)
-    assert_equal(isdefaulted, pool.pump_weekday_fractions_isdefaulted)
-
     assert_equal(weekend_sch, pool.pump_weekend_fractions)
-    assert_equal(isdefaulted, pool.pump_weekend_fractions_isdefaulted)
-
     assert_equal(monthly_mults, pool.pump_monthly_multipliers)
-    assert_equal(isdefaulted, pool.pump_monthly_multipliers_isdefaulted)
   end
 
-  def _test_default_hot_tub_heater_values(hpxml, isdefaulted, load_units, load_value, usage_multiplier, weekday_sch, weekend_sch, monthly_mults)
+  def _test_default_hot_tub_heater_values(hpxml, load_units, load_value, usage_multiplier, weekday_sch, weekend_sch, monthly_mults)
     hot_tub = hpxml.hot_tubs[0]
 
     if load_units.nil?
@@ -2728,110 +2661,65 @@ class HPXMLtoOpenStudioDefaultsTest < MiniTest::Test
     else
       assert_equal(load_units, hot_tub.heater_load_units)
     end
-
     if load_value.nil?
       assert_nil(hot_tub.heater_load_value)
     else
       assert_in_epsilon(load_value, hot_tub.heater_load_value, 0.01)
-      assert_equal(isdefaulted, hot_tub.heater_load_value_isdefaulted)
     end
-
     if usage_multiplier.nil?
       assert_nil(hot_tub.heater_usage_multiplier)
     else
       assert_equal(usage_multiplier, hot_tub.heater_usage_multiplier)
-      assert_equal(isdefaulted, hot_tub.heater_usage_multiplier_isdefaulted)
     end
-
     if weekday_sch.nil?
       assert_nil(hot_tub.heater_weekday_fractions)
     else
       assert_equal(weekday_sch, hot_tub.heater_weekday_fractions)
-      assert_equal(isdefaulted, hot_tub.heater_weekday_fractions_isdefaulted)
     end
-
     if weekend_sch.nil?
       assert_nil(hot_tub.heater_weekend_fractions)
     else
       assert_equal(weekend_sch, hot_tub.heater_weekend_fractions)
-      assert_equal(isdefaulted, hot_tub.heater_weekend_fractions_isdefaulted)
     end
-
     if monthly_mults.nil?
       assert_nil(hot_tub.heater_monthly_multipliers)
     else
       assert_equal(monthly_mults, hot_tub.heater_monthly_multipliers)
-      assert_equal(isdefaulted, hot_tub.heater_monthly_multipliers_isdefaulted)
     end
   end
 
-  def _test_default_hot_tub_pump_values(hpxml, isdefaulted, kWh_per_year, usage_multiplier, weekday_sch, weekend_sch, monthly_mults)
+  def _test_default_hot_tub_pump_values(hpxml, kWh_per_year, usage_multiplier, weekday_sch, weekend_sch, monthly_mults)
     hot_tub = hpxml.hot_tubs[0]
 
     assert_in_epsilon(kWh_per_year, hot_tub.pump_kwh_per_year, 0.01)
-    assert_equal(isdefaulted, hot_tub.pump_kwh_per_year_isdefaulted)
-
     assert_equal(usage_multiplier, hot_tub.pump_usage_multiplier)
-    assert_equal(isdefaulted, hot_tub.pump_usage_multiplier_isdefaulted)
-
     assert_equal(weekday_sch, hot_tub.pump_weekday_fractions)
-    assert_equal(isdefaulted, hot_tub.pump_weekday_fractions_isdefaulted)
-
     assert_equal(weekend_sch, hot_tub.pump_weekend_fractions)
-    assert_equal(isdefaulted, hot_tub.pump_weekend_fractions_isdefaulted)
-
     assert_equal(monthly_mults, hot_tub.pump_monthly_multipliers)
-    assert_equal(isdefaulted, hot_tub.pump_monthly_multipliers_isdefaulted)
   end
 
-  def _test_default_plug_load_values(hpxml, isdefaulted, load_type, kWh_per_year, frac_sensible, frac_latent, usage_multiplier, weekday_sch, weekend_sch, monthly_mults)
+  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]
 
     assert_in_epsilon(kWh_per_year, pl.kWh_per_year, 0.01)
-    assert_equal(isdefaulted, pl.kWh_per_year_isdefaulted)
-
     assert_equal(usage_multiplier, pl.usage_multiplier)
-    assert_equal(isdefaulted, pl.usage_multiplier_isdefaulted)
-
     assert_in_epsilon(frac_sensible, pl.frac_sensible, 0.01)
-    assert_equal(isdefaulted, pl.frac_sensible_isdefaulted)
-
     assert_in_epsilon(frac_latent, pl.frac_latent, 0.01)
-    assert_equal(isdefaulted, pl.frac_latent_isdefaulted)
-
     assert_equal(weekday_sch, pl.weekday_fractions)
-    assert_equal(isdefaulted, pl.weekday_fractions_isdefaulted)
-
     assert_equal(weekend_sch, pl.weekend_fractions)
-    assert_equal(isdefaulted, pl.weekend_fractions_isdefaulted)
-
     assert_equal(monthly_mults, pl.monthly_multipliers)
-    assert_equal(isdefaulted, pl.monthly_multipliers_isdefaulted)
   end
 
-  def _test_default_fuel_load_values(hpxml, isdefaulted, load_type, therm_per_year, frac_sensible, frac_latent, usage_multiplier, weekday_sch, weekend_sch, monthly_mults)
+  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]
 
     assert_in_epsilon(therm_per_year, fl.therm_per_year, 0.01)
-    assert_equal(isdefaulted, fl.therm_per_year_isdefaulted)
-
     assert_equal(usage_multiplier, fl.usage_multiplier)
-    assert_equal(isdefaulted, fl.usage_multiplier_isdefaulted)
-
     assert_in_epsilon(frac_sensible, fl.frac_sensible, 0.01)
-    assert_equal(isdefaulted, fl.frac_sensible_isdefaulted)
-
     assert_in_epsilon(frac_latent, fl.frac_latent, 0.01)
-    assert_equal(isdefaulted, fl.frac_latent_isdefaulted)
-
     assert_equal(weekday_sch, fl.weekday_fractions)
-    assert_equal(isdefaulted, fl.weekday_fractions_isdefaulted)
-
     assert_equal(weekend_sch, fl.weekend_fractions)
-    assert_equal(isdefaulted, fl.weekend_fractions_isdefaulted)
-
     assert_equal(monthly_mults, fl.monthly_multipliers)
-    assert_equal(isdefaulted, fl.monthly_multipliers_isdefaulted)
   end
 
   def _create_hpxml(hpxml_name)