urbanopt-cli 0.4.1 → 0.5.0

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

@@ -2,7 +2,7 @@
 
 require_relative '../resources/minitest_helper'
 require 'openstudio'
-require 'openstudio/ruleset/ShowRunnerOutput'
+require 'openstudio/measure/ShowRunnerOutput'
 require 'minitest/autorun'
 require 'fileutils'
 require_relative '../measure.rb'

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

@@ -2,7 +2,7 @@
 
 require_relative '../resources/minitest_helper'
 require 'openstudio'
-require 'openstudio/ruleset/ShowRunnerOutput'
+require 'openstudio/measure/ShowRunnerOutput'
 require 'minitest/autorun'
 require 'fileutils'
 require_relative '../measure.rb'
@@ -52,7 +52,7 @@ class HPXMLtoOpenStudioPVTest < MiniTest::Test
 
   def test_pv_shared
     args_hash = {}
-    args_hash['hpxml_path'] = File.absolute_path(File.join(sample_files_dir, 'base-pv-shared.xml'))
+    args_hash['hpxml_path'] = File.absolute_path(File.join(sample_files_dir, 'base-bldgtype-multifamily-shared-pv.xml'))
     model, hpxml = _test_measure(args_hash)
 
     hpxml.pv_systems.each do |pv_system|

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

@@ -2,7 +2,7 @@
 
 require_relative '../resources/minitest_helper'
 require 'openstudio'
-require 'openstudio/ruleset/ShowRunnerOutput'
+require 'openstudio/measure/ShowRunnerOutput'
 require 'minitest/autorun'
 require 'fileutils'
 require_relative '../measure.rb'
@@ -16,10 +16,10 @@ class HPXMLtoOpenStudioSimControlsTest < MiniTest::Test
   def get_run_period_month_and_days(model)
     run_period = model.getRunPeriod
     begin_month = run_period.getBeginMonth
-    begin_day_of_month = run_period.getBeginDayOfMonth
+    begin_day = run_period.getBeginDayOfMonth
     end_month = run_period.getEndMonth
-    end_day_of_month = run_period.getEndDayOfMonth
-    return begin_month, begin_day_of_month, end_month, end_day_of_month
+    end_day = run_period.getEndDayOfMonth
+    return begin_month, begin_day, end_month, end_day
   end
 
   def test_run_period_year
@@ -27,11 +27,11 @@ class HPXMLtoOpenStudioSimControlsTest < MiniTest::Test
     args_hash['hpxml_path'] = File.absolute_path(File.join(sample_files_dir, 'base.xml'))
     model, hpxml = _test_measure(args_hash)
 
-    begin_month, begin_day_of_month, end_month, end_day_of_month = get_run_period_month_and_days(model)
+    begin_month, begin_day, end_month, end_day = get_run_period_month_and_days(model)
     assert_equal(1, begin_month)
-    assert_equal(1, begin_day_of_month)
+    assert_equal(1, begin_day)
     assert_equal(12, end_month)
-    assert_equal(31, end_day_of_month)
+    assert_equal(31, end_day)
   end
 
   def test_run_period_1month
@@ -39,11 +39,11 @@ class HPXMLtoOpenStudioSimControlsTest < MiniTest::Test
     args_hash['hpxml_path'] = File.absolute_path(File.join(sample_files_dir, 'base-simcontrol-runperiod-1-month.xml'))
     model, hpxml = _test_measure(args_hash)
 
-    begin_month, begin_day_of_month, end_month, end_day_of_month = get_run_period_month_and_days(model)
+    begin_month, begin_day, end_month, end_day = get_run_period_month_and_days(model)
     assert_equal(1, begin_month)
-    assert_equal(1, begin_day_of_month)
+    assert_equal(1, begin_day)
     assert_equal(1, end_month)
-    assert_equal(31, end_day_of_month)
+    assert_equal(31, end_day)
   end
 
   def test_timestep_1hour

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

@@ -2,21 +2,10 @@
 
 require_relative '../resources/minitest_helper'
 require 'openstudio'
-require 'openstudio/ruleset/ShowRunnerOutput'
+require 'openstudio/measure/ShowRunnerOutput'
 require 'minitest/autorun'
 require 'fileutils'
 require_relative '../measure.rb'
-$has_schematron_nokogiri_gem = false
-begin
-  require 'schematron-nokogiri'
-  $has_schematron_nokogiri_gem = true
-rescue LoadError
-  if ENV['CI'] # Ensure we test via schematron-nokogiri on the CI
-    fail 'Could not load schematron-nokogiri gem. Try running with "bundle exec ruby ...".'
-  else
-    puts 'Could not load schematron-nokogiri gem. Proceeding using ruby validation tests only...'
-  end
-end
 
 class HPXMLtoOpenStudioValidationTest < MiniTest::Test
   def before_setup
@@ -24,11 +13,7 @@ class HPXMLtoOpenStudioValidationTest < MiniTest::Test
 
     # load the Schematron xml
     @stron_path = File.join(@root_path, 'HPXMLtoOpenStudio', 'resources', 'EPvalidator.xml')
-
-    if $has_schematron_nokogiri_gem
-      # make a Schematron object
-      @stron_doc = SchematronNokogiri::Schema.new Nokogiri::XML File.open(@stron_path)
-    end
+    @stron_doc = XMLHelper.parse_file(@stron_path)
 
     # Load all HPXMLs
     hpxml_file_dirs = [File.absolute_path(File.join(@root_path, 'workflow', 'sample_files')),
@@ -42,31 +27,61 @@ class HPXMLtoOpenStudioValidationTest < MiniTest::Test
     end
 
     # Build up expected error messages hashes by parsing EPvalidator.xml
-    doc = XMLHelper.parse_file(@stron_path)
     @expected_assertions_by_addition = {}
     @expected_assertions_by_deletion = {}
-    XMLHelper.get_elements(doc, '/sch:schema/sch:pattern/sch:rule').each do |rule|
+    @expected_assertions_by_alteration = {}
+    XMLHelper.get_elements(@stron_doc, '/sch:schema/sch:pattern/sch:rule').each do |rule|
       rule_context = XMLHelper.get_attribute_value(rule, 'context')
       context_xpath = rule_context.gsub('h:', '')
 
-      XMLHelper.get_values(rule, 'sch:assert').each do |assertion|
+      XMLHelper.get_elements(rule, 'sch:assert').each do |assertion|
+        assertion_message = assertion.inner_text
         element_name = _get_element_name_for_assertion_test(assertion)
         key = [context_xpath, element_name]
 
-        if assertion.start_with?('Expected 0 element')
+        if assertion_message.start_with?('Expected 0 element')
           # Skipping for now
-        elsif assertion.start_with?('Expected 0 or ') || assertion.partition(': ').last.start_with?('[not') # FIXME: Is there another way to do this?
-          @expected_assertions_by_addition[key] = _get_expected_error_msg(context_xpath, assertion, 'addition')
-        elsif assertion.start_with?('Expected 1 ')
-          @expected_assertions_by_deletion[key] = _get_expected_error_msg(context_xpath, assertion, 'deletion')
-          @expected_assertions_by_addition[key] = _get_expected_error_msg(context_xpath, assertion, 'addition')
+        elsif assertion_message.start_with?('Expected 0 or ')
+          @expected_assertions_by_addition[key] = _get_expected_error_msg(context_xpath, assertion_message, 'addition')
+        elsif assertion_message.start_with?('Expected 1 ')
+          @expected_assertions_by_deletion[key] = _get_expected_error_msg(context_xpath, assertion_message, 'deletion')
+          @expected_assertions_by_addition[key] = _get_expected_error_msg(context_xpath, assertion_message, 'addition')
+        elsif assertion_message.include?("Expected #{element_name} to be")
+          @expected_assertions_by_alteration[key] = _get_expected_error_msg(context_xpath, assertion_message, 'alteration')
         else
-          fail "Unexpected assertion: '#{assertion}'."
+          fail "Unexpected assertion: '#{assertion_message}'."
         end
       end
     end
   end
 
+  def test_role_attributes
+    puts
+    puts 'Checking for correct role attributes...'
+
+    # check that every assert element has a role attribute
+    XMLHelper.get_elements(@stron_doc, '/sch:schema/sch:pattern/sch:rule/sch:assert').each do |assert_element|
+      assert_test = XMLHelper.get_attribute_value(assert_element, 'test').gsub('h:', '')
+      role_attribute = XMLHelper.get_attribute_value(assert_element, 'role')
+      if role_attribute.nil?
+        fail "No attribute \"role='ERROR'\" found for assertion test: #{assert_test}"
+      end
+
+      assert_equal('ERROR', role_attribute)
+    end
+
+    # check that every report element has a role attribute
+    XMLHelper.get_elements(@stron_doc, '/sch:schema/sch:pattern/sch:rule/sch:report').each do |report_element|
+      report_test = XMLHelper.get_attribute_value(report_element, 'test').gsub('h:', '')
+      role_attribute = XMLHelper.get_attribute_value(report_element, 'role')
+      if role_attribute.nil?
+        fail "No attribute \"role='WARN'\" found for report test: #{report_test}"
+      end
+
+      assert_equal('WARN', role_attribute)
+    end
+  end
+
   def test_sample_files
     puts
     puts "Testing #{@hpxml_docs.size} HPXML files..."
@@ -75,8 +90,7 @@ class HPXMLtoOpenStudioValidationTest < MiniTest::Test
 
       # Test validation
       _test_schema_validation(hpxml_doc, xml)
-      _test_schematron_validation(@stron_doc, hpxml_doc.to_xml) if $has_schematron_nokogiri_gem
-      _test_ruby_validation(hpxml_doc)
+      _test_schematron_validation(hpxml_doc)
     end
     puts
   end
@@ -93,8 +107,7 @@ class HPXMLtoOpenStudioValidationTest < MiniTest::Test
       XMLHelper.delete_element(parent_element, child_element_name)
 
       # Test validation
-      _test_ruby_validation(hpxml_doc, expected_error_msg)
-      _test_schematron_validation(@stron_doc, hpxml_doc.to_xml, expected_error_msg) if $has_schematron_nokogiri_gem
+      _test_schematron_validation(hpxml_doc, expected_error_msg)
     end
     puts
   end
@@ -125,39 +138,39 @@ class HPXMLtoOpenStudioValidationTest < MiniTest::Test
       (max_number_of_elements_allowed + 1).times { mod_parent_element.children << duplicated }
 
       # Test validation
-      _test_schematron_validation(@stron_doc, hpxml_doc.to_xml, expected_error_msg) if $has_schematron_nokogiri_gem
-      _test_ruby_validation(hpxml_doc, expected_error_msg)
+      _test_schematron_validation(hpxml_doc, expected_error_msg)
     end
     puts
   end
 
-  private
+  def test_schematron_asserts_by_alteration
+    puts "Testing #{@expected_assertions_by_alteration.size} Schematron asserts by alteration..."
 
-  def _test_schematron_validation(stron_doc, hpxml, expected_error_msg = nil)
-    # Validate via schematron-nokogiri gem
-    xml_doc = Nokogiri::XML hpxml
-    results = stron_doc.validate xml_doc
-    results_msgs = results.map { |i| i[:message].gsub(': ', [': ', i[:context_path].gsub('h:', '').concat(': ')].join('')) }
-    idx_of_msg = results_msgs.index { |m| m == expected_error_msg }
-    if expected_error_msg.nil?
-      assert_nil(idx_of_msg)
-    else
-      if idx_of_msg.nil?
-        puts "Did not find expected error message '#{expected_error_msg}' in #{results_msgs}."
-      end
-      refute_nil(idx_of_msg)
+    # Tests by element alteration
+    @expected_assertions_by_alteration.each do |key, expected_error_msg|
+      print '.'
+      hpxml_doc, parent_element = _get_hpxml_doc_and_parent_element(key)
+      child_element_name = key[1]
+      element_to_be_altered = XMLHelper.get_element(parent_element, child_element_name)
+      element_to_be_altered.inner_text = element_to_be_altered.inner_text + 'foo' # add arbitrary string to make the value invalid
+
+      # Test validation
+      _test_schematron_validation(hpxml_doc, expected_error_msg)
     end
+    puts
   end
 
-  def _test_ruby_validation(hpxml_doc, expected_error_msg = nil)
+  private
+
+  def _test_schematron_validation(hpxml_doc, expected_error_msg = nil)
     # Validate via validator.rb
-    results = Validator.run_validator(hpxml_doc, @stron_path)
-    idx_of_msg = results.index { |i| i == expected_error_msg }
+    errors, warnings = Validator.run_validators(hpxml_doc, [@stron_path])
+    idx_of_msg = errors.index { |i| i == expected_error_msg }
     if expected_error_msg.nil?
       assert_nil(idx_of_msg)
     else
       if idx_of_msg.nil?
-        puts "Did not find expected error message '#{expected_error_msg}' in #{results}."
+        puts "Did not find expected error message '#{expected_error_msg}' in #{errors}."
       end
       refute_nil(idx_of_msg)
     end
@@ -194,26 +207,30 @@ class HPXMLtoOpenStudioValidationTest < MiniTest::Test
     fail "Could not find an HPXML file with #{element_name} in #{context_xpath}. Add this to a HPXML file so that it's tested."
   end
 
-  def _get_expected_error_msg(parent_xpath, assertion, mode)
-    if assertion.start_with?('Expected 0 or more')
+  def _get_expected_error_msg(parent_xpath, assertion_message, mode)
+    if assertion_message.start_with?('Expected 0 or more')
       return
-    elsif assertion.start_with?('Expected 1 or more') && (mode == 'addition')
+    elsif assertion_message.start_with?('Expected 1 or more') && (mode == 'addition')
       return
     else
-      return [[assertion.partition(': ').first, parent_xpath].join(': '), assertion.partition(': ').last].join(': ') # return "Expected x element(s) for xpath: foo: bar"
+      return [assertion_message, "[context: #{parent_xpath}]"].join(' ') # return "Expected x element(s) for xpath: foo... [context: bar/baz/...]"
     end
   end
 
   def _get_element_name_for_assertion_test(assertion)
     # From the assertion, get the element name to be added or deleted for the assertion test.
-    if assertion.partition(': ').last.start_with?('[not')
-      element_name = assertion.partition(': ').last.partition(' | ').last
+    if assertion.inner_text.start_with?('Expected') && assertion.inner_text.include?('to be')
+      test_attr = assertion.get('test')
+      element_name = test_attr[/not\((.*?)\)/m, 1].gsub('h:', '') # pull text between "not(" and ")" (i.e. "foo" from "not(h:foo)")
+
+      return element_name
     else
-      element_name = assertion.partition(': ').last.partition(' | ').first
+      test_attr = assertion.get('test')
+      element_name = test_attr[/(?<=\().*(?=\))/].gsub('h:', '').partition(') + count').first # pull text between the first opening and the last closing parenthesis. (i.e. "foo" from "count(foo) + count(bar)...")
       _balance_brackets(element_name)
-    end
 
-    return element_name
+      return element_name
+    end
   end
 
   def _balance_brackets(element_name)

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

@@ -2,7 +2,7 @@
 
 require_relative '../resources/minitest_helper'
 require 'openstudio'
-require 'openstudio/ruleset/ShowRunnerOutput'
+require 'openstudio/measure/ShowRunnerOutput'
 require 'minitest/autorun'
 require 'fileutils'
 require_relative '../measure.rb'
@@ -25,7 +25,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     # Expected value
     tank_volume = UnitConversions.convert(water_heating_system.tank_volume * 0.95, 'gal', 'm^3') # convert to actual volume
     cap = UnitConversions.convert(water_heating_system.heating_capacity / 1000.0, 'kBtu/hr', 'W')
-    fuel = EPlus.input_fuel_map(water_heating_system.fuel_type)
+    fuel = EPlus.fuel_type(water_heating_system.fuel_type)
     ua = UnitConversions.convert(7.88, 'Btu/(hr*F)', 'W/K')
     t_set = UnitConversions.convert(water_heating_system.temperature, 'F', 'C') + 1 # setpoint + 1/2 deadband
     ther_eff = 0.773
@@ -42,6 +42,38 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     assert_in_epsilon(ua, wh.offCycleLossCoefficienttoAmbientTemperature.get, 0.001)
     assert_in_epsilon(t_set, wh.setpointTemperatureSchedule.get.to_ScheduleConstant.get.value, 0.001)
     assert_in_epsilon(ther_eff, wh.heaterThermalEfficiency.get, 0.001)
+    assert_equal(0.64, wh.offCycleLossFractiontoThermalZone)
+  end
+
+  def test_tank_gas_uef
+    args_hash = {}
+    args_hash['hpxml_path'] = File.absolute_path(File.join(sample_files_dir, 'base-dhw-tank-gas-uef.xml'))
+    model, hpxml = _test_measure(args_hash)
+
+    # Get HPXML values
+    water_heating_system = hpxml.water_heating_systems[0]
+
+    # Expected value
+    tank_volume = UnitConversions.convert(water_heating_system.tank_volume * 0.95, 'gal', 'm^3') # convert to actual volume
+    cap = UnitConversions.convert(water_heating_system.heating_capacity / 1000.0, 'kBtu/hr', 'W')
+    fuel = EPlus.fuel_type(water_heating_system.fuel_type)
+    ua = UnitConversions.convert(6.476, 'Btu/(hr*F)', 'W/K')
+    t_set = UnitConversions.convert(water_heating_system.temperature, 'F', 'C') + 1 # setpoint + 1/2 deadband
+    ther_eff = 0.762
+    loc = water_heating_system.location
+
+    # Check water heater
+    assert_equal(1, model.getWaterHeaterMixeds.size)
+    wh = model.getWaterHeaterMixeds[0]
+    assert_equal(fuel, wh.heaterFuelType)
+    assert_equal(loc, wh.ambientTemperatureThermalZone.get.name.get)
+    assert_in_epsilon(tank_volume, wh.tankVolume.get, 0.001)
+    assert_in_epsilon(cap, wh.heaterMaximumCapacity.get, 0.001)
+    assert_in_epsilon(ua, wh.onCycleLossCoefficienttoAmbientTemperature.get, 0.001)
+    assert_in_epsilon(ua, wh.offCycleLossCoefficienttoAmbientTemperature.get, 0.001)
+    assert_in_epsilon(t_set, wh.setpointTemperatureSchedule.get.to_ScheduleConstant.get.value, 0.001)
+    assert_in_epsilon(ther_eff, wh.heaterThermalEfficiency.get, 0.001)
+    assert_equal(0.64, wh.offCycleLossFractiontoThermalZone)
   end
 
   def test_tank_oil
@@ -55,7 +87,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     # Expected value
     tank_volume = UnitConversions.convert(water_heating_system.tank_volume * 0.95, 'gal', 'm^3') # convert to actual volume
     cap = UnitConversions.convert(water_heating_system.heating_capacity / 1000.0, 'kBtu/hr', 'W')
-    fuel = EPlus.input_fuel_map(water_heating_system.fuel_type)
+    fuel = EPlus.fuel_type(water_heating_system.fuel_type)
     ua = UnitConversions.convert(7.88, 'Btu/(hr*F)', 'W/K')
     t_set = UnitConversions.convert(water_heating_system.temperature, 'F', 'C') + 1 # setpoint + 1/2 deadband
     ther_eff = 0.773
@@ -72,6 +104,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     assert_in_epsilon(ua, wh.offCycleLossCoefficienttoAmbientTemperature.get, 0.001)
     assert_in_epsilon(t_set, wh.setpointTemperatureSchedule.get.to_ScheduleConstant.get.value, 0.001)
     assert_in_epsilon(ther_eff, wh.heaterThermalEfficiency.get, 0.001)
+    assert_equal(0.64, wh.offCycleLossFractiontoThermalZone)
   end
 
   def test_tank_wood
@@ -85,7 +118,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     # Expected value
     tank_volume = UnitConversions.convert(water_heating_system.tank_volume * 0.95, 'gal', 'm^3') # convert to actual volume
     cap = UnitConversions.convert(water_heating_system.heating_capacity / 1000.0, 'kBtu/hr', 'W')
-    fuel = EPlus.input_fuel_map(water_heating_system.fuel_type)
+    fuel = EPlus.fuel_type(water_heating_system.fuel_type)
     ua = UnitConversions.convert(7.88, 'Btu/(hr*F)', 'W/K')
     t_set = UnitConversions.convert(water_heating_system.temperature, 'F', 'C') + 1 # setpoint + 1/2 deadband
     ther_eff = 0.773
@@ -102,6 +135,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     assert_in_epsilon(ua, wh.offCycleLossCoefficienttoAmbientTemperature.get, 0.001)
     assert_in_epsilon(t_set, wh.setpointTemperatureSchedule.get.to_ScheduleConstant.get.value, 0.001)
     assert_in_epsilon(ther_eff, wh.heaterThermalEfficiency.get, 0.001)
+    assert_equal(0.64, wh.offCycleLossFractiontoThermalZone)
   end
 
   def test_tank_coal
@@ -115,7 +149,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     # Expected value
     tank_volume = UnitConversions.convert(water_heating_system.tank_volume * 0.95, 'gal', 'm^3') # convert to actual volume
     cap = UnitConversions.convert(water_heating_system.heating_capacity / 1000.0, 'kBtu/hr', 'W')
-    fuel = EPlus.input_fuel_map(water_heating_system.fuel_type)
+    fuel = EPlus.fuel_type(water_heating_system.fuel_type)
     ua = UnitConversions.convert(7.88, 'Btu/(hr*F)', 'W/K')
     t_set = UnitConversions.convert(water_heating_system.temperature, 'F', 'C') + 1 # setpoint + 1/2 deadband
     ther_eff = 0.773
@@ -132,6 +166,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     assert_in_epsilon(ua, wh.offCycleLossCoefficienttoAmbientTemperature.get, 0.001)
     assert_in_epsilon(t_set, wh.setpointTemperatureSchedule.get.to_ScheduleConstant.get.value, 0.001)
     assert_in_epsilon(ther_eff, wh.heaterThermalEfficiency.get, 0.001)
+    assert_equal(0.64, wh.offCycleLossFractiontoThermalZone)
   end
 
   def test_tank_electric
@@ -145,7 +180,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     # Expected value
     tank_volume = UnitConversions.convert(water_heating_system.tank_volume * 0.9, 'gal', 'm^3') # convert to actual volume
     cap = UnitConversions.convert(water_heating_system.heating_capacity / 1000.0, 'kBtu/hr', 'W')
-    fuel = EPlus.input_fuel_map(water_heating_system.fuel_type)
+    fuel = EPlus.fuel_type(water_heating_system.fuel_type)
     ua = UnitConversions.convert(1.335, 'Btu/(hr*F)', 'W/K')
     t_set = UnitConversions.convert(water_heating_system.temperature, 'F', 'C') + 1 # setpoint + 1/2 deadband
     ther_eff = 1.0
@@ -162,9 +197,41 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     assert_in_epsilon(ua, wh.offCycleLossCoefficienttoAmbientTemperature.get, 0.001)
     assert_in_epsilon(t_set, wh.setpointTemperatureSchedule.get.to_ScheduleConstant.get.value, 0.001)
     assert_in_epsilon(ther_eff, wh.heaterThermalEfficiency.get, 0.001)
+    assert_equal(1.0, wh.offCycleLossFractiontoThermalZone)
+  end
+
+  def test_tank_electric_uef
+    args_hash = {}
+    args_hash['hpxml_path'] = File.absolute_path(File.join(sample_files_dir, 'base-dhw-tank-elec-uef.xml'))
+    model, hpxml = _test_measure(args_hash)
+
+    # Get HPXML values
+    water_heating_system = hpxml.water_heating_systems[0]
+
+    # Expected value
+    tank_volume = UnitConversions.convert(water_heating_system.tank_volume * 0.9, 'gal', 'm^3') # convert to actual volume
+    cap = UnitConversions.convert(water_heating_system.heating_capacity / 1000.0, 'kBtu/hr', 'W')
+    fuel = EPlus.fuel_type(water_heating_system.fuel_type)
+    ua = UnitConversions.convert(1.503, 'Btu/(hr*F)', 'W/K')
+    t_set = UnitConversions.convert(water_heating_system.temperature, 'F', 'C') + 1 # setpoint + 1/2 deadband
+    ther_eff = 1.0
+    loc = water_heating_system.location
+
+    # Check water heater
+    assert_equal(1, model.getWaterHeaterMixeds.size)
+    wh = model.getWaterHeaterMixeds[0]
+    assert_equal(fuel, wh.heaterFuelType)
+    assert_equal(loc, wh.ambientTemperatureThermalZone.get.name.get)
+    assert_in_epsilon(tank_volume, wh.tankVolume.get, 0.001)
+    assert_in_epsilon(cap, wh.heaterMaximumCapacity.get, 0.001)
+    assert_in_epsilon(ua, wh.onCycleLossCoefficienttoAmbientTemperature.get, 0.001)
+    assert_in_epsilon(ua, wh.offCycleLossCoefficienttoAmbientTemperature.get, 0.001)
+    assert_in_epsilon(t_set, wh.setpointTemperatureSchedule.get.to_ScheduleConstant.get.value, 0.001)
+    assert_in_epsilon(ther_eff, wh.heaterThermalEfficiency.get, 0.001)
+    assert_equal(1.0, wh.offCycleLossFractiontoThermalZone)
   end
 
-  def test_tankless
+  def test_tankless_electric
     args_hash = {}
     args_hash['hpxml_path'] = File.absolute_path(File.join(sample_files_dir, 'base-dhw-tankless-electric.xml'))
     model, hpxml = _test_measure(args_hash)
@@ -175,7 +242,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     # Expected value
     tank_volume = UnitConversions.convert(1.0, 'gal', 'm^3') # convert to actual volume
     cap = UnitConversions.convert(100000000.0, 'kBtu/hr', 'W')
-    fuel = EPlus.input_fuel_map(water_heating_system.fuel_type)
+    fuel = EPlus.fuel_type(water_heating_system.fuel_type)
     ua = 0.0
     t_set = UnitConversions.convert(water_heating_system.temperature, 'F', 'C')
     ther_eff = 0.9108
@@ -192,23 +259,55 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     assert_in_epsilon(ua, wh.offCycleLossCoefficienttoAmbientTemperature.get, 0.001)
     assert_in_epsilon(t_set, wh.setpointTemperatureSchedule.get.to_ScheduleConstant.get.value, 0.001)
     assert_in_epsilon(ther_eff, wh.heaterThermalEfficiency.get, 0.001)
+    assert_equal(1.0, wh.offCycleLossFractiontoThermalZone)
   end
 
-  def test_uef
+  def test_tankless_electric_uef
     args_hash = {}
-    args_hash['hpxml_path'] = File.absolute_path(File.join(sample_files_dir, 'base-dhw-uef.xml'))
+    args_hash['hpxml_path'] = File.absolute_path(File.join(sample_files_dir, 'base-dhw-tankless-electric-uef.xml'))
     model, hpxml = _test_measure(args_hash)
 
     # Get HPXML values
     water_heating_system = hpxml.water_heating_systems[0]
 
     # Expected value
-    tank_volume = UnitConversions.convert(water_heating_system.tank_volume * 0.9, 'gal', 'm^3') # convert to actual volume
-    cap = UnitConversions.convert(water_heating_system.heating_capacity / 1000.0, 'kBtu/hr', 'W')
-    fuel = EPlus.input_fuel_map(water_heating_system.fuel_type)
-    ua = UnitConversions.convert(1.327, 'Btu/(hr*F)', 'W/K')
-    t_set = UnitConversions.convert(water_heating_system.temperature, 'F', 'C') + 1 # setpoint + 1/2 deadband
-    ther_eff = 1.0
+    tank_volume = UnitConversions.convert(1.0, 'gal', 'm^3') # convert to actual volume
+    cap = UnitConversions.convert(100000000.0, 'kBtu/hr', 'W')
+    fuel = EPlus.fuel_type(water_heating_system.fuel_type)
+    ua = 0.0
+    t_set = UnitConversions.convert(water_heating_system.temperature, 'F', 'C')
+    ther_eff = 0.9212
+    loc = water_heating_system.location
+
+    # Check water heater
+    assert_equal(1, model.getWaterHeaterMixeds.size)
+    wh = model.getWaterHeaterMixeds[0]
+    assert_equal(fuel, wh.heaterFuelType)
+    assert_equal(loc, wh.ambientTemperatureThermalZone.get.name.get)
+    assert_in_epsilon(tank_volume, wh.tankVolume.get, 0.001)
+    assert_in_epsilon(cap, wh.heaterMaximumCapacity.get, 0.001)
+    assert_in_epsilon(ua, wh.onCycleLossCoefficienttoAmbientTemperature.get, 0.001)
+    assert_in_epsilon(ua, wh.offCycleLossCoefficienttoAmbientTemperature.get, 0.001)
+    assert_in_epsilon(t_set, wh.setpointTemperatureSchedule.get.to_ScheduleConstant.get.value, 0.001)
+    assert_in_epsilon(ther_eff, wh.heaterThermalEfficiency.get, 0.001)
+    assert_equal(1.0, wh.offCycleLossFractiontoThermalZone)
+  end
+
+  def test_tankless_gas_uef
+    args_hash = {}
+    args_hash['hpxml_path'] = File.absolute_path(File.join(sample_files_dir, 'base-dhw-tankless-gas-uef.xml'))
+    model, hpxml = _test_measure(args_hash)
+
+    # Get HPXML values
+    water_heating_system = hpxml.water_heating_systems[0]
+
+    # Expected value
+    tank_volume = UnitConversions.convert(1.0, 'gal', 'm^3') # convert to actual volume
+    cap = UnitConversions.convert(100000000.0, 'kBtu/hr', 'W')
+    fuel = EPlus.fuel_type(water_heating_system.fuel_type)
+    ua = 0.0
+    t_set = UnitConversions.convert(water_heating_system.temperature, 'F', 'C')
+    ther_eff = 0.8742
     loc = water_heating_system.location
 
     # Check water heater
@@ -222,6 +321,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     assert_in_epsilon(ua, wh.offCycleLossCoefficienttoAmbientTemperature.get, 0.001)
     assert_in_epsilon(t_set, wh.setpointTemperatureSchedule.get.to_ScheduleConstant.get.value, 0.001)
     assert_in_epsilon(ther_eff, wh.heaterThermalEfficiency.get, 0.001)
+    assert_equal(1.0, wh.offCycleLossFractiontoThermalZone)
   end
 
   def test_tank_outside
@@ -235,7 +335,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     # Expected value
     tank_volume = UnitConversions.convert(water_heating_system.tank_volume * 0.95, 'gal', 'm^3') # convert to actual volume
     cap = UnitConversions.convert(water_heating_system.heating_capacity / 1000.0, 'kBtu/hr', 'W')
-    fuel = EPlus.input_fuel_map(water_heating_system.fuel_type)
+    fuel = EPlus.fuel_type(water_heating_system.fuel_type)
     ua = UnitConversions.convert(7.88, 'Btu/(hr*F)', 'W/K')
     t_set = UnitConversions.convert(water_heating_system.temperature, 'F', 'C') + 1 # setpoint + 1/2 deadband
     ther_eff = 0.773
@@ -264,7 +364,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     # Expected value
     tank_volume = UnitConversions.convert(water_heating_system.tank_volume * 0.9, 'gal', 'm^3') # convert to actual volume
     cap = UnitConversions.convert(water_heating_system.heating_capacity / 1000.0, 'kBtu/hr', 'W')
-    fuel = EPlus.input_fuel_map(water_heating_system.fuel_type)
+    fuel = EPlus.fuel_type(water_heating_system.fuel_type)
     ua = UnitConversions.convert(1.335, 'Btu/(hr*F)', 'W/K')
     t_set = UnitConversions.convert(water_heating_system.temperature, 'F', 'C') + 1 # setpoint + 1/2 deadband
     loc = water_heating_system.location
@@ -281,6 +381,8 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     assert_in_epsilon(ua, wh.offCycleLossCoefficienttoAmbientTemperature.get, 0.001)
     assert_in_epsilon(t_set, wh.setpointTemperatureSchedule.get.to_ScheduleConstant.get.value, 0.001)
     assert_in_epsilon(ther_eff, wh.heaterThermalEfficiency.get, 0.001)
+    assert_equal(1.0, wh.offCycleLossFractiontoThermalZone)
+
     # Check desuperheater
     assert_equal(1, model.getCoilWaterHeatingDesuperheaters.size)
     preheat_tank = model.getWaterHeaterMixeds.select { |wh| wh.name.get.include? 'storage tank' }[0]
@@ -300,7 +402,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     # Expected value
     tank_volume = UnitConversions.convert(water_heating_system.tank_volume * 0.9, 'gal', 'm^3') # convert to actual volume
     cap = UnitConversions.convert(water_heating_system.heating_capacity / 1000.0, 'kBtu/hr', 'W')
-    fuel = EPlus.input_fuel_map(water_heating_system.fuel_type)
+    fuel = EPlus.fuel_type(water_heating_system.fuel_type)
     ua = UnitConversions.convert(1.335, 'Btu/(hr*F)', 'W/K')
     t_set = UnitConversions.convert(water_heating_system.temperature, 'F', 'C') + 1 # setpoint + 1/2 deadband
     loc = water_heating_system.location
@@ -317,6 +419,8 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     assert_in_epsilon(ua, wh.offCycleLossCoefficienttoAmbientTemperature.get, 0.001)
     assert_in_epsilon(t_set, wh.setpointTemperatureSchedule.get.to_ScheduleConstant.get.value, 0.001)
     assert_in_epsilon(ther_eff, wh.heaterThermalEfficiency.get, 0.001)
+    assert_equal(1.0, wh.offCycleLossFractiontoThermalZone)
+
     # Check desuperheater
     assert_equal(1, model.getCoilWaterHeatingDesuperheaters.size)
     preheat_tank = model.getWaterHeaterMixeds.select { |wh| wh.name.get.include? 'storage tank' }[0]
@@ -336,7 +440,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     # Expected value
     tank_volume = UnitConversions.convert(water_heating_system.tank_volume * 0.9, 'gal', 'm^3') # convert to actual volume
     cap = UnitConversions.convert(water_heating_system.heating_capacity / 1000.0, 'kBtu/hr', 'W')
-    fuel = EPlus.input_fuel_map(water_heating_system.fuel_type)
+    fuel = EPlus.fuel_type(water_heating_system.fuel_type)
     ua = UnitConversions.convert(1.335, 'Btu/(hr*F)', 'W/K')
     t_set = UnitConversions.convert(water_heating_system.temperature, 'F', 'C') + 1 # setpoint + 1/2 deadband
     loc = water_heating_system.location
@@ -353,6 +457,8 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     assert_in_epsilon(ua, wh.offCycleLossCoefficienttoAmbientTemperature.get, 0.001)
     assert_in_epsilon(t_set, wh.setpointTemperatureSchedule.get.to_ScheduleConstant.get.value, 0.001)
     assert_in_epsilon(ther_eff, wh.heaterThermalEfficiency.get, 0.001)
+    assert_equal(1.0, wh.offCycleLossFractiontoThermalZone)
+
     # Check desuperheater
     assert_equal(1, model.getCoilWaterHeatingDesuperheaters.size)
     preheat_tank = model.getWaterHeaterMixeds.select { |wh| wh.name.get.include? 'storage tank' }[0]
@@ -373,7 +479,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     # Expected value
     tank_volume = UnitConversions.convert(water_heating_system.tank_volume * 0.9, 'gal', 'm^3') # convert to actual volume
     cap = UnitConversions.convert(water_heating_system.heating_capacity / 1000.0, 'kBtu/hr', 'W')
-    fuel = EPlus.input_fuel_map(water_heating_system.fuel_type)
+    fuel = EPlus.fuel_type(water_heating_system.fuel_type)
     ua = UnitConversions.convert(1.335, 'Btu/(hr*F)', 'W/K')
     t_set = UnitConversions.convert(water_heating_system.temperature, 'F', 'C') + 1 # setpoint + 1/2 deadband
     loc = water_heating_system.location
@@ -400,6 +506,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     assert_in_epsilon(ua, wh.offCycleLossCoefficienttoAmbientTemperature.get, 0.001)
     assert_in_epsilon(t_set, wh.setpointTemperatureSchedule.get.to_ScheduleConstant.get.value, 0.001)
     assert_in_epsilon(ther_eff, wh.heaterThermalEfficiency.get, 0.001)
+    assert_equal(1.0, wh.offCycleLossFractiontoThermalZone)
 
     # Check solar thermal system
     assert_equal(1, model.getSolarCollectorFlatPlateWaters.size)
@@ -445,7 +552,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     # Expected value
     tank_volume = UnitConversions.convert(water_heating_system.tank_volume * 0.9, 'gal', 'm^3') # convert to actual volume
     cap = UnitConversions.convert(water_heating_system.heating_capacity / 1000.0, 'kBtu/hr', 'W')
-    fuel = EPlus.input_fuel_map(water_heating_system.fuel_type)
+    fuel = EPlus.fuel_type(water_heating_system.fuel_type)
     ua = UnitConversions.convert(1.335, 'Btu/(hr*F)', 'W/K')
     t_set = UnitConversions.convert(water_heating_system.temperature, 'F', 'C') + 1 # setpoint + 1/2 deadband
     loc = water_heating_system.location
@@ -472,6 +579,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     assert_in_epsilon(ua, wh.offCycleLossCoefficienttoAmbientTemperature.get, 0.001)
     assert_in_epsilon(t_set, wh.setpointTemperatureSchedule.get.to_ScheduleConstant.get.value, 0.001)
     assert_in_epsilon(ther_eff, wh.heaterThermalEfficiency.get, 0.001)
+    assert_equal(1.0, wh.offCycleLossFractiontoThermalZone)
 
     # Check solar thermal system
     assert_equal(1, model.getSolarCollectorFlatPlateWaters.size)
@@ -517,7 +625,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     # Expected value
     tank_volume = UnitConversions.convert(water_heating_system.tank_volume * 0.9, 'gal', 'm^3') # convert to actual volume
     cap = UnitConversions.convert(water_heating_system.heating_capacity / 1000.0, 'kBtu/hr', 'W')
-    fuel = EPlus.input_fuel_map(water_heating_system.fuel_type)
+    fuel = EPlus.fuel_type(water_heating_system.fuel_type)
     ua = UnitConversions.convert(1.335, 'Btu/(hr*F)', 'W/K')
     t_set = UnitConversions.convert(water_heating_system.temperature, 'F', 'C') + 1 # setpoint + 1/2 deadband
     loc = water_heating_system.location
@@ -544,6 +652,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     assert_in_epsilon(ua, wh.offCycleLossCoefficienttoAmbientTemperature.get, 0.001)
     assert_in_epsilon(t_set, wh.setpointTemperatureSchedule.get.to_ScheduleConstant.get.value, 0.001)
     assert_in_epsilon(ther_eff, wh.heaterThermalEfficiency.get, 0.001)
+    assert_equal(1.0, wh.offCycleLossFractiontoThermalZone)
 
     # Check solar thermal system
     assert_equal(1, model.getSolarCollectorFlatPlateWaters.size)
@@ -589,7 +698,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     # Expected value
     tank_volume = UnitConversions.convert(water_heating_system.tank_volume * 0.9, 'gal', 'm^3') # convert to actual volume
     cap = UnitConversions.convert(water_heating_system.heating_capacity / 1000.0, 'kBtu/hr', 'W')
-    fuel = EPlus.input_fuel_map(water_heating_system.fuel_type)
+    fuel = EPlus.fuel_type(water_heating_system.fuel_type)
     ua = UnitConversions.convert(1.335, 'Btu/(hr*F)', 'W/K')
     t_set = UnitConversions.convert(water_heating_system.temperature, 'F', 'C') + 1 # setpoint + 1/2 deadband
     loc = water_heating_system.location
@@ -616,6 +725,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     assert_in_epsilon(ua, wh.offCycleLossCoefficienttoAmbientTemperature.get, 0.001)
     assert_in_epsilon(t_set, wh.setpointTemperatureSchedule.get.to_ScheduleConstant.get.value, 0.001)
     assert_in_epsilon(ther_eff, wh.heaterThermalEfficiency.get, 0.001)
+    assert_equal(1.0, wh.offCycleLossFractiontoThermalZone)
 
     # Check solar thermal system
     assert_equal(1, model.getSolarCollectorFlatPlateWaters.size)
@@ -661,7 +771,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     # Expected value
     tank_volume = UnitConversions.convert(water_heating_system.tank_volume * 0.9, 'gal', 'm^3') # convert to actual volume
     cap = UnitConversions.convert(water_heating_system.heating_capacity / 1000.0, 'kBtu/hr', 'W')
-    fuel = EPlus.input_fuel_map(water_heating_system.fuel_type)
+    fuel = EPlus.fuel_type(water_heating_system.fuel_type)
     ua = UnitConversions.convert(1.335, 'Btu/(hr*F)', 'W/K')
     t_set = UnitConversions.convert(water_heating_system.temperature, 'F', 'C') + 1 # setpoint + 1/2 deadband
     loc = water_heating_system.location
@@ -686,6 +796,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     assert_in_epsilon(ua, wh.offCycleLossCoefficienttoAmbientTemperature.get, 0.001)
     assert_in_epsilon(t_set, wh.setpointTemperatureSchedule.get.to_ScheduleConstant.get.value, 0.001)
     assert_in_epsilon(ther_eff, wh.heaterThermalEfficiency.get, 0.001)
+    assert_equal(1.0, wh.offCycleLossFractiontoThermalZone)
 
     # Check solar thermal system
     assert_equal(1, model.getSolarCollectorIntegralCollectorStorages.size)
@@ -727,7 +838,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     # Expected value
     tank_volume = UnitConversions.convert(water_heating_system.tank_volume * 0.9, 'gal', 'm^3') # convert to actual volume
     cap = UnitConversions.convert(water_heating_system.heating_capacity / 1000.0, 'kBtu/hr', 'W')
-    fuel = EPlus.input_fuel_map(water_heating_system.fuel_type)
+    fuel = EPlus.fuel_type(water_heating_system.fuel_type)
     ua = UnitConversions.convert(1.335, 'Btu/(hr*F)', 'W/K') * 0.35
     t_set = UnitConversions.convert(water_heating_system.temperature, 'F', 'C') + 1 # setpoint + 1/2 deadband
     ther_eff = 1.0
@@ -744,6 +855,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     assert_in_epsilon(ua, wh.offCycleLossCoefficienttoAmbientTemperature.get, 0.001)
     assert_in_epsilon(t_set, wh.setpointTemperatureSchedule.get.to_ScheduleConstant.get.value, 0.001)
     assert_in_epsilon(ther_eff, wh.heaterThermalEfficiency.get, 0.001)
+    assert_equal(1.0, wh.offCycleLossFractiontoThermalZone)
   end
 
   def test_tank_indirect
@@ -770,6 +882,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     assert_in_epsilon(ua, wh.onCycleLossCoefficienttoAmbientTemperature.get, 0.001)
     assert_in_epsilon(ua, wh.offCycleLossCoefficienttoAmbientTemperature.get, 0.001)
     assert_in_epsilon(t_set, wh.setpointTemperatureSchedule.get.to_ScheduleConstant.get.value, 0.001)
+    assert_equal(1.0, wh.offCycleLossFractiontoThermalZone)
 
     # Heat exchanger
     assert_equal(1, model.getHeatExchangerFluidToFluids.size)
@@ -804,7 +917,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     tank_volume = UnitConversions.convert(1, 'gal', 'm^3') # convert to actual volume
     cap = 0.0
     ua = 0.0
-    t_set = UnitConversions.convert(water_heating_system.temperature, 'F', 'C') # setpoint + 1/2 deadband
+    t_set = UnitConversions.convert(water_heating_system.temperature, 'F', 'C')
     loc = water_heating_system.location
 
     # Check water heater
@@ -817,6 +930,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     assert_in_epsilon(ua, wh.onCycleLossCoefficienttoAmbientTemperature.get, 0.001)
     assert_in_epsilon(ua, wh.offCycleLossCoefficienttoAmbientTemperature.get, 0.001)
     assert_in_epsilon(t_set, wh.setpointTemperatureSchedule.get.to_ScheduleConstant.get.value, 0.001)
+    assert_equal(1.0, wh.offCycleLossFractiontoThermalZone)
 
     # Heat exchanger
     assert_equal(1, model.getHeatExchangerFluidToFluids.size)
@@ -849,7 +963,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
 
     # Expected value
     tank_volume = UnitConversions.convert(water_heating_system.tank_volume * 0.9, 'gal', 'm^3') # convert to actual volume
-    fuel = EPlus.input_fuel_map(water_heating_system.fuel_type)
+    fuel = EPlus.fuel_type(water_heating_system.fuel_type)
     u =  0.925
     t_set = UnitConversions.convert(water_heating_system.temperature, 'F', 'C') - 9
     ther_eff = 1.0
@@ -876,6 +990,43 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     assert_in_epsilon(cop, coil.ratedCOP, 0.001)
   end
 
+  def test_tank_heat_pump_uef
+    args_hash = {}
+    args_hash['hpxml_path'] = File.absolute_path(File.join(sample_files_dir, 'base-dhw-tank-heat-pump-uef.xml'))
+    model, hpxml = _test_measure(args_hash)
+
+    # Get HPXML values
+    water_heating_system = hpxml.water_heating_systems[0]
+
+    # Expected value
+    tank_volume = UnitConversions.convert(water_heating_system.tank_volume * 0.9, 'gal', 'm^3') # convert to actual volume
+    fuel = EPlus.fuel_type(water_heating_system.fuel_type)
+    u =  1.045
+    t_set = UnitConversions.convert(water_heating_system.temperature, 'F', 'C') - 9
+    ther_eff = 1.0
+    cop = 4.004
+    tank_height = 1.0335
+
+    # Check water heater
+    assert_equal(1, model.getWaterHeaterHeatPumpWrappedCondensers.size)
+    assert_equal(1, model.getWaterHeaterStratifieds.size)
+    hpwh = model.getWaterHeaterHeatPumpWrappedCondensers[0]
+    wh = hpwh.tank.to_WaterHeaterStratified.get
+    coil = hpwh.dXCoil.to_CoilWaterHeatingAirToWaterHeatPumpWrapped.get
+    assert_equal(fuel, wh.heaterFuelType)
+    assert_equal('Schedule', wh.ambientTemperatureIndicator)
+    assert_in_epsilon(tank_volume, wh.tankVolume.get, 0.001)
+    assert_in_epsilon(tank_height, wh.tankHeight.get, 0.001)
+    assert_in_epsilon(4500.0, wh.heater1Capacity.get, 0.001)
+    assert_in_epsilon(4500.0, wh.heater2Capacity, 0.001)
+    assert_in_epsilon(u, wh.uniformSkinLossCoefficientperUnitAreatoAmbientTemperature.get, 0.001)
+    assert_in_epsilon(t_set, wh.heater1SetpointTemperatureSchedule.to_ScheduleConstant.get.value, 0.001)
+    assert_in_epsilon(ther_eff, wh.heaterThermalEfficiency, 0.001)
+
+    # Check heat pump cooling coil cop
+    assert_in_epsilon(cop, coil.ratedCOP, 0.001)
+  end
+
   def test_tank_jacket
     args_hash = {}
     args_hash['hpxml_path'] = File.absolute_path(File.join(sample_files_dir, 'base-dhw-jacket-electric.xml'))
@@ -887,7 +1038,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     # Expected value
     tank_volume = UnitConversions.convert(water_heating_system.tank_volume * 0.9, 'gal', 'm^3') # convert to actual volume
     cap = UnitConversions.convert(water_heating_system.heating_capacity / 1000.0, 'kBtu/hr', 'W')
-    fuel = EPlus.input_fuel_map(water_heating_system.fuel_type)
+    fuel = EPlus.fuel_type(water_heating_system.fuel_type)
     ua = UnitConversions.convert(0.6415, 'Btu/(hr*F)', 'W/K')
     t_set = UnitConversions.convert(water_heating_system.temperature, 'F', 'C') + 1 # setpoint + 1/2 deadband
     ther_eff = 1.0
@@ -904,11 +1055,12 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     assert_in_epsilon(ua, wh.offCycleLossCoefficienttoAmbientTemperature.get, 0.001)
     assert_in_epsilon(t_set, wh.setpointTemperatureSchedule.get.to_ScheduleConstant.get.value, 0.001)
     assert_in_epsilon(ther_eff, wh.heaterThermalEfficiency.get, 0.001)
+    assert_equal(1.0, wh.offCycleLossFractiontoThermalZone)
   end
 
   def test_shared_water_heater
     args_hash = {}
-    args_hash['hpxml_path'] = File.absolute_path(File.join(sample_files_dir, 'base-dhw-shared-water-heater.xml'))
+    args_hash['hpxml_path'] = File.absolute_path(File.join(sample_files_dir, 'base-bldgtype-multifamily-shared-water-heater.xml'))
     model, hpxml = _test_measure(args_hash)
 
     # Get HPXML values
@@ -917,7 +1069,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
     # Expected value
     tank_volume = UnitConversions.convert(water_heating_system.tank_volume * 0.95, 'gal', 'm^3') # convert to actual volume
     cap = UnitConversions.convert(water_heating_system.heating_capacity / 1000.0, 'kBtu/hr', 'W')
-    fuel = EPlus.input_fuel_map(water_heating_system.fuel_type)
+    fuel = EPlus.fuel_type(water_heating_system.fuel_type)
     ua = UnitConversions.convert(7.88, 'Btu/(hr*F)', 'W/K') / water_heating_system.number_of_units_served
     t_set = UnitConversions.convert(water_heating_system.temperature, 'F', 'C') + 1 # setpoint + 1/2 deadband
     ther_eff = 0.773
@@ -938,7 +1090,7 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
 
   def test_shared_laundry_room
     args_hash = {}
-    args_hash['hpxml_path'] = File.absolute_path(File.join(sample_files_dir, 'base-dhw-shared-laundry-room.xml'))
+    args_hash['hpxml_path'] = File.absolute_path(File.join(sample_files_dir, 'base-bldgtype-multifamily-shared-laundry-room.xml'))
     model, hpxml = _test_measure(args_hash)
 
     # Get HPXML values
@@ -950,8 +1102,8 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
                     UnitConversions.convert(shared_water_heating_system.tank_volume * 0.9, 'gal', 'm^3')] # convert to actual volume
     caps = [UnitConversions.convert(water_heating_system.heating_capacity / 1000.0, 'kBtu/hr', 'W'),
             UnitConversions.convert(shared_water_heating_system.heating_capacity / 1000.0, 'kBtu/hr', 'W')]
-    fuels = [EPlus.input_fuel_map(water_heating_system.fuel_type),
-             EPlus.input_fuel_map(shared_water_heating_system.fuel_type)]
+    fuels = [EPlus.fuel_type(water_heating_system.fuel_type),
+             EPlus.fuel_type(shared_water_heating_system.fuel_type)]
     uas = [UnitConversions.convert(1.335, 'Btu/(hr*F)', 'W/K'),
            UnitConversions.convert(1.335 / shared_water_heating_system.number_of_units_served, 'Btu/(hr*F)', 'W/K')]
     t_sets = [UnitConversions.convert(water_heating_system.temperature, 'F', 'C') + 1,