urbanopt-cli 0.6.4 → 0.7.0

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

@@ -310,14 +310,19 @@ class WeatherProcess
     @data.MonthlyAvgDailyHighDrybulbs = []
     @data.MonthlyAvgDailyLowDrybulbs = []
 
-    year_description = @model.getYearDescription
-    days_m = Constants.NumDaysInMonths(year_description.isLeapYear)
+    if daily_high_dbs.size == 365 # standard year
+      month_num_days = Constants.NumDaysInMonths(1999)
+    elsif daily_high_dbs.size == 366 # leap year
+      month_num_days = Constants.NumDaysInMonths(2000)
+    else
+      fail 'Unexpected number of days.'
+    end
 
     first_day = 0
     for month in 1..12
-      ndays = days_m[month - 1] # Number of days in current month
+      ndays = month_num_days[month - 1] # Number of days in current month
       if month > 1
-        first_day += days_m[month - 2] # Number of days in previous month
+        first_day += month_num_days[month - 2] # Number of days in previous month
       end
       avg_high = daily_high_dbs[first_day, ndays].sum(0.0) / ndays.to_f
       avg_low = daily_low_dbs[first_day, ndays].sum(0.0) / ndays.to_f
@@ -515,7 +520,7 @@ class WeatherProcess
     tmains_ratio = 0.4 + 0.01 * (avgOAT - 44)
     tmains_lag = 35 - (avgOAT - 44)
     if latitude < 0
-      sign = 1
+      sign = 1 # southern hemisphere
     else
       sign = -1
     end

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

@@ -4,8 +4,19 @@ class XMLHelper
   # Adds the child element with 'element_name' and sets its value. Returns the
   # child element.
   def self.add_element(parent, element_name, value = nil, datatype = nil, defaulted = false)
+    added = XMLHelper.insert_element(parent, element_name, -1, value, datatype, defaulted)
+    return added
+  end
+
+  # Inserts the child element with 'element_name' and sets its value. Returns the
+  # child element.
+  def self.insert_element(parent, element_name, index = 0, value = nil, datatype = nil, defaulted = false)
     added = Oga::XML::Element.new(name: element_name)
-    parent.children << added
+    if index == -1
+      parent.children << added
+    else
+      parent.children.insert(index, added)
+    end
     if not value.nil?
       if datatype == :integer
         value = to_integer(value, parent, element_name)
@@ -49,10 +60,10 @@ class XMLHelper
   # Deletes the child element with element_name. Returns the deleted element.
   def self.delete_element(parent, element_name)
     element = nil
-    begin
+    while !parent.at_xpath(element_name).nil?
       last_element = element
       element = parent.at_xpath(element_name).remove
-    end while !parent.at_xpath(element_name).nil?
+    end
     return last_element
   end
 
@@ -174,7 +185,7 @@ class XMLHelper
   end
 
   def self.write_file(doc, out_path)
-    doc_s = doc.to_xml
+    doc_s = doc.to_xml.delete("\r")
 
     # Manually apply pretty-printing (indentation and newlines)
     # Can remove if https://gitlab.com/yorickpeterse/oga/-/issues/75 is implemented
@@ -204,6 +215,8 @@ class XMLHelper
       end
     end
     indents.reverse_each do |pos, level|
+      next if doc_s[pos - 1] == ' '
+
       doc_s.insert(pos, "\n#{'  ' * level}")
     end
     # Retain REXML-styling
@@ -243,7 +256,7 @@ def to_integer(value, parent, element_name)
   end
 end
 
-def to_boolean(value, parent = nil, element_name = nil)
+def to_boolean(value, parent, element_name)
   if value.is_a? TrueClass
     return true
   elsif value.is_a? FalseClass
@@ -254,9 +267,7 @@ def to_boolean(value, parent = nil, element_name = nil)
     return false
   end
 
-  if (not parent.nil?) && (not element_name.nil?)
-    fail "Cannot convert '#{value}' to boolean for #{parent.name}/#{element_name}."
-  end
+  fail "Cannot convert '#{value}' to boolean for #{parent.name}/#{element_name}."
 end
 
 def to_float_or_nil(value, parent, element_name)

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

@@ -296,10 +296,10 @@ class HPXMLtoOpenStudioAirflowTest < MiniTest::Test
 
     # Get HPXML values
     bath_fan = hpxml.ventilation_fans.select { |f| f.used_for_local_ventilation && f.fan_location == HPXML::LocationBath }[0]
-    bath_fan_cfm = bath_fan.rated_flow_rate * bath_fan.quantity
+    bath_fan_cfm = bath_fan.flow_rate * bath_fan.quantity
     bath_fan_power = bath_fan.fan_power * bath_fan.quantity
     kitchen_fan = hpxml.ventilation_fans.select { |f| f.used_for_local_ventilation && f.fan_location == HPXML::LocationKitchen }[0]
-    kitchen_fan_cfm = kitchen_fan.rated_flow_rate * (kitchen_fan.quantity.nil? ? 1 : kitchen_fan.quantity)
+    kitchen_fan_cfm = kitchen_fan.flow_rate * (kitchen_fan.quantity.nil? ? 1 : kitchen_fan.quantity)
     kitchen_fan_power = kitchen_fan.fan_power * (kitchen_fan.quantity.nil? ? 1 : kitchen_fan.quantity)
 
     # Check infiltration/ventilation program
@@ -333,7 +333,7 @@ class HPXMLtoOpenStudioAirflowTest < MiniTest::Test
 
     # Check infiltration/ventilation program
     program_values = get_ems_values(model.getEnergyManagementSystemPrograms, "#{Constants.ObjectNameInfiltration} program")
-    assert_in_epsilon(clothes_dryer_cfm, UnitConversions.convert(program_values['Qdryer'].sum, 'm^3/s', 'cfm'), 0.01)
+    assert_operator(UnitConversions.convert(program_values['Qdryer'].sum, 'm^3/s', 'cfm'), :>, 0)
   end
 
   def test_multiple_mechvent
@@ -342,30 +342,32 @@ class HPXMLtoOpenStudioAirflowTest < MiniTest::Test
     model, hpxml = _test_measure(args_hash)
 
     # Get HPXML values
-    bath_fans = hpxml.ventilation_fans.select { |f| f.used_for_local_ventilation && f.fan_location == HPXML::LocationBath }
-    bath_fan_cfm = bath_fans.map { |bath_fan| bath_fan.rated_flow_rate * bath_fan.quantity }.sum(0.0)
+    vent_fans = hpxml.ventilation_fans.select { |f| f.flow_rate > 0 && f.hours_in_operation.to_f > 0 }
+
+    bath_fans = vent_fans.select { |f| f.used_for_local_ventilation && f.fan_location == HPXML::LocationBath }
+    bath_fan_cfm = bath_fans.map { |bath_fan| bath_fan.flow_rate * bath_fan.quantity }.sum(0.0)
     bath_fan_power = bath_fans.map { |bath_fan| bath_fan.fan_power * bath_fan.quantity }.sum(0.0)
-    kitchen_fans = hpxml.ventilation_fans.select { |f| f.used_for_local_ventilation && f.fan_location == HPXML::LocationKitchen }
-    kitchen_fan_cfm = kitchen_fans.map { |kitchen_fan| kitchen_fan.rated_flow_rate }.sum(0.0)
+    kitchen_fans = vent_fans.select { |f| f.used_for_local_ventilation && f.fan_location == HPXML::LocationKitchen }
+    kitchen_fan_cfm = kitchen_fans.map { |kitchen_fan| kitchen_fan.flow_rate }.sum(0.0)
     kitchen_fan_power = kitchen_fans.map { |kitchen_fan| kitchen_fan.fan_power }.sum(0.0)
 
-    # Get HPXML values
-    vent_fan_sup = hpxml.ventilation_fans.select { |f| f.used_for_whole_building_ventilation && (f.fan_type == HPXML::MechVentTypeSupply) }
+    vent_fan_sup = vent_fans.select { |f| f.used_for_whole_building_ventilation && (f.fan_type == HPXML::MechVentTypeSupply) }
     vent_fan_cfm_sup = vent_fan_sup.map { |f| f.average_total_unit_flow_rate }.sum(0.0)
     vent_fan_power_sup = vent_fan_sup.map { |f| f.average_unit_fan_power }.sum(0.0)
-    vent_fan_exh = hpxml.ventilation_fans.select { |f| f.used_for_whole_building_ventilation && (f.fan_type == HPXML::MechVentTypeExhaust) }
+    vent_fan_exh = vent_fans.select { |f| f.used_for_whole_building_ventilation && (f.fan_type == HPXML::MechVentTypeExhaust) }
     vent_fan_cfm_exh = vent_fan_exh.map { |f| f.average_total_unit_flow_rate }.sum(0.0)
     vent_fan_power_exh = vent_fan_exh.map { |f| f.average_unit_fan_power }.sum(0.0)
-    vent_fan_bal = hpxml.ventilation_fans.select { |f| f.used_for_whole_building_ventilation && (f.fan_type == HPXML::MechVentTypeBalanced) }
+    vent_fan_bal = vent_fans.select { |f| f.used_for_whole_building_ventilation && (f.fan_type == HPXML::MechVentTypeBalanced) }
     vent_fan_cfm_bal = vent_fan_bal.map { |f| f.average_total_unit_flow_rate }.sum(0.0)
     vent_fan_power_bal = vent_fan_bal.map { |f| f.average_unit_fan_power }.sum(0.0)
-    vent_fan_ervhrv = hpxml.ventilation_fans.select { |f| f.used_for_whole_building_ventilation && [HPXML::MechVentTypeERV, HPXML::MechVentTypeHRV].include?(f.fan_type) }
+    vent_fan_ervhrv = vent_fans.select { |f| f.used_for_whole_building_ventilation && [HPXML::MechVentTypeERV, HPXML::MechVentTypeHRV].include?(f.fan_type) }
     vent_fan_cfm_ervhrv = vent_fan_ervhrv.map { |f| f.average_total_unit_flow_rate }.sum(0.0)
     vent_fan_power_ervhrv = vent_fan_ervhrv.map { |f| f.average_unit_fan_power }.sum(0.0)
-    vent_fan_cfis = hpxml.ventilation_fans.select { |f| f.used_for_whole_building_ventilation && (f.fan_type == HPXML::MechVentTypeCFIS) }
+    vent_fan_cfis = vent_fans.select { |f| f.used_for_whole_building_ventilation && (f.fan_type == HPXML::MechVentTypeCFIS) }
     vent_fan_cfm_cfis = vent_fan_cfis.map { |f| f.oa_unit_flow_rate }.sum(0.0)
     vent_fan_power_cfis = vent_fan_cfis.map { |f| f.fan_power }.sum(0.0)
     vent_fan_mins_cfis = vent_fan_cfis.map { |f| f.hours_in_operation / 24.0 * 60.0 }.sum(0.0)
+
     # total mech vent fan power excluding cfis
     total_mechvent_pow = vent_fan_power_sup + vent_fan_power_exh + vent_fan_power_bal + vent_fan_power_ervhrv
     fraction_heat_gain = (1.0 * vent_fan_power_sup + 0.0 * vent_fan_power_sup + 0.5 * (vent_fan_power_bal + vent_fan_power_ervhrv)) / total_mechvent_pow
@@ -470,6 +472,25 @@ class HPXMLtoOpenStudioAirflowTest < MiniTest::Test
     assert_in_epsilon(29.4, UnitConversions.convert(program_values['return_ua'].sum, 'W/K', 'Btu/(hr*F)'), 0.01)
   end
 
+  def test_ducts_leakage_cfm50
+    args_hash = {}
+    args_hash['hpxml_path'] = File.absolute_path(File.join(sample_files_dir, 'base-hvac-ducts-leakage-cfm50.xml'))
+    model, hpxml = _test_measure(args_hash)
+
+    # Get HPXML values
+    supply_leakage = hpxml.hvac_distributions[0].duct_leakage_measurements.select { |m| m.duct_type == HPXML::DuctTypeSupply }[0]
+    return_leakage = hpxml.hvac_distributions[0].duct_leakage_measurements.select { |m| m.duct_type == HPXML::DuctTypeReturn }[0]
+    supply_leakage_cfm50 = supply_leakage.duct_leakage_value
+    return_leakage_cfm50 = return_leakage.duct_leakage_value
+
+    # Check ducts program
+    program_values = get_ems_values(model.getEnergyManagementSystemSubroutines, 'duct subroutine')
+    assert_in_epsilon(supply_leakage_cfm50 * (25.0 / 50.0)**0.65, UnitConversions.convert(program_values['f_sup'].sum, 'm^3/s', 'cfm'), 0.01)
+    assert_in_epsilon(return_leakage_cfm50 * (25.0 / 50.0)**0.65, UnitConversions.convert(program_values['f_ret'].sum, 'm^3/s', 'cfm'), 0.01)
+    assert_in_epsilon(33.4, UnitConversions.convert(program_values['supply_ua'].sum, 'W/K', 'Btu/(hr*F)'), 0.01)
+    assert_in_epsilon(29.4, UnitConversions.convert(program_values['return_ua'].sum, 'W/K', 'Btu/(hr*F)'), 0.01)
+  end
+
   def test_ducts_leakage_percent
     args_hash = {}
     args_hash['hpxml_path'] = File.absolute_path(File.join(sample_files_dir, 'base-hvac-ducts-leakage-percent.xml'))
@@ -493,14 +514,14 @@ class HPXMLtoOpenStudioAirflowTest < MiniTest::Test
     # Base
     hpxml = HPXML.new(hpxml_path: File.absolute_path(File.join(sample_files_dir, 'base.xml')))
     total_area, exterior_area = hpxml.compartmentalization_boundary_areas
-    assert_equal(5216, exterior_area)
-    assert_equal(5216, total_area)
+    assert_in_delta(5216, exterior_area, 1.0)
+    assert_in_delta(5216, total_area, 1.0)
 
     # Test adjacent garage
     hpxml = HPXML.new(hpxml_path: File.absolute_path(File.join(sample_files_dir, 'base-enclosure-garage.xml')))
     total_area, exterior_area = hpxml.compartmentalization_boundary_areas
-    assert_equal(4976, exterior_area)
-    assert_equal(5216, total_area)
+    assert_in_delta(4976, exterior_area, 1.0)
+    assert_in_delta(5216, total_area, 1.0)
 
     # Test unvented attic/crawlspace within infiltration volume
     hpxml = HPXML.new(hpxml_path: File.absolute_path(File.join(sample_files_dir, 'base-foundation-unvented-crawlspace.xml')))
@@ -511,8 +532,8 @@ class HPXMLtoOpenStudioAirflowTest < MiniTest::Test
       foundation.within_infiltration_volume = true
     end
     total_area, exterior_area = hpxml.compartmentalization_boundary_areas
-    assert_equal(5066, exterior_area)
-    assert_equal(5066, total_area)
+    assert_in_delta(5000, exterior_area, 1.0)
+    assert_in_delta(5000, total_area, 1.0)
 
     # Test unvented attic/crawlspace not within infiltration volume
     hpxml = HPXML.new(hpxml_path: File.absolute_path(File.join(sample_files_dir, 'base-foundation-unvented-crawlspace.xml')))
@@ -523,14 +544,14 @@ class HPXMLtoOpenStudioAirflowTest < MiniTest::Test
       foundation.within_infiltration_volume = false
     end
     total_area, exterior_area = hpxml.compartmentalization_boundary_areas
-    assert_equal(3900, exterior_area)
-    assert_equal(3900, total_area)
+    assert_in_delta(3900, exterior_area, 1.0)
+    assert_in_delta(3900, total_area, 1.0)
 
     # Test multifamily
     hpxml = HPXML.new(hpxml_path: File.absolute_path(File.join(sample_files_dir, 'base-bldgtype-multifamily.xml')))
     total_area, exterior_area = hpxml.compartmentalization_boundary_areas
-    assert_equal(686, exterior_area)
-    assert_equal(2780, total_area)
+    assert_in_delta(686, exterior_area, 1.0)
+    assert_in_delta(2780, total_area, 1.0)
   end
 
   def test_infiltration_assumed_height

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

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+require_relative '../resources/minitest_helper'
+require 'openstudio'
+require 'openstudio/measure/ShowRunnerOutput'
+require 'fileutils'
+require_relative '../measure.rb'
+require_relative '../resources/util.rb'
+
+class HPXMLtoOpenStudioBatteryTest < MiniTest::Test
+  def sample_files_dir
+    return File.join(File.dirname(__FILE__), '..', '..', 'workflow', 'sample_files')
+  end
+
+  def get_battery(model, name)
+    model.getElectricLoadCenterStorageLiIonNMCBatterys.each do |b|
+      next unless b.name.to_s.start_with? "#{name} "
+
+      return b
+    end
+  end
+
+  def calc_nom_capacity(battery)
+    return (battery.numberofCellsinSeries * battery.numberofStringsinParallel *
+            battery.cellVoltageatEndofNominalZone * battery.fullyChargedCellCapacity)
+  end
+
+  def test_battery_default
+    args_hash = {}
+    args_hash['hpxml_path'] = File.absolute_path(File.join(sample_files_dir, 'base-misc-defaults.xml'))
+    model, hpxml = _test_measure(args_hash)
+
+    hpxml.batteries.each do |hpxml_battery|
+      battery = get_battery(model, hpxml_battery.id)
+
+      # Check object
+      assert(!battery.thermalZone.is_initialized)
+      assert_equal(0, battery.radiativeFraction)
+      assert_equal(HPXML::BatteryLifetimeModelNone, battery.lifetimeModel)
+      assert_in_epsilon(15, battery.numberofCellsinSeries, 0.01)
+      assert_in_epsilon(62, battery.numberofStringsinParallel, 0.01)
+      assert_in_epsilon(0.5, battery.initialFractionalStateofCharge, 0.01)
+      assert_in_epsilon(99.0, battery.batteryMass, 0.01)
+      assert_in_epsilon(1.42, battery.batterySurfaceArea, 0.01)
+      assert_in_epsilon(10000, calc_nom_capacity(battery), 0.01)
+
+      elcds = model.getElectricLoadCenterDistributions
+      assert_equal(1, elcds.size)
+      elcd = elcds[0]
+      assert_equal('DirectCurrentWithInverterDCStorage', elcd.electricalBussType)
+      assert_equal(0.15, elcd.minimumStorageStateofChargeFraction)
+      assert_equal(0.95, elcd.maximumStorageStateofChargeFraction)
+      assert_equal(5000.0, elcd.designStorageControlChargePower.get)
+      assert_equal(5000.0, elcd.designStorageControlDischargePower.get)
+      assert(!elcd.demandLimitSchemePurchasedElectricDemandLimit.is_initialized)
+      assert_equal('TrackFacilityElectricDemandStoreExcessOnSite', elcd.storageOperationScheme)
+    end
+  end
+
+  def test_battery_outside
+    args_hash = {}
+    args_hash['hpxml_path'] = File.absolute_path(File.join(sample_files_dir, 'base-battery-outside.xml'))
+    model, hpxml = _test_measure(args_hash)
+
+    hpxml.batteries.each do |hpxml_battery|
+      battery = get_battery(model, hpxml_battery.id)
+
+      assert_empty(battery)
+    end
+
+    elcds = model.getElectricLoadCenterDistributions
+    assert_equal(0, elcds.size)
+  end
+
+  def test_pv_battery_outside
+    args_hash = {}
+    args_hash['hpxml_path'] = File.absolute_path(File.join(sample_files_dir, 'base-pv-battery-outside.xml'))
+    model, hpxml = _test_measure(args_hash)
+
+    hpxml.batteries.each do |hpxml_battery|
+      battery = get_battery(model, hpxml_battery.id)
+
+      # Check object
+      assert(!battery.thermalZone.is_initialized)
+      assert_equal(0, battery.radiativeFraction)
+      assert_equal(HPXML::BatteryLifetimeModelNone, battery.lifetimeModel)
+      assert_in_epsilon(15, battery.numberofCellsinSeries, 0.01)
+      assert_in_epsilon(125, battery.numberofStringsinParallel, 0.01)
+      assert_in_epsilon(0.5, battery.initialFractionalStateofCharge, 0.01)
+      assert_in_epsilon(198.0, battery.batteryMass, 0.01)
+      assert_in_epsilon(2.25, battery.batterySurfaceArea, 0.01)
+      assert_in_epsilon(20000, calc_nom_capacity(battery), 0.01)
+
+      elcds = model.getElectricLoadCenterDistributions
+      assert_equal(1, elcds.size)
+      elcd = elcds[0]
+      assert_equal('DirectCurrentWithInverterDCStorage', elcd.electricalBussType)
+      assert_equal(0.15, elcd.minimumStorageStateofChargeFraction)
+      assert_equal(0.95, elcd.maximumStorageStateofChargeFraction)
+      assert_equal(15000.0, elcd.designStorageControlChargePower.get)
+      assert_equal(15000.0, elcd.designStorageControlDischargePower.get)
+      assert(!elcd.demandLimitSchemePurchasedElectricDemandLimit.is_initialized)
+      assert_equal('TrackFacilityElectricDemandStoreExcessOnSite', elcd.storageOperationScheme)
+    end
+  end
+
+  def test_pv_battery_outside_degrades
+    args_hash = {}
+    args_hash['hpxml_path'] = File.absolute_path(File.join(sample_files_dir, 'base-pv-battery-outside-degrades.xml'))
+    model, hpxml = _test_measure(args_hash)
+
+    hpxml.batteries.each do |hpxml_battery|
+      battery = get_battery(model, hpxml_battery.id)
+
+      # Check object
+      assert(!battery.thermalZone.is_initialized)
+      assert_equal(0, battery.radiativeFraction)
+      assert_equal(HPXML::BatteryLifetimeModelKandlerSmith, battery.lifetimeModel)
+      assert_in_epsilon(15, battery.numberofCellsinSeries, 0.01)
+      assert_in_epsilon(125, battery.numberofStringsinParallel, 0.01)
+      assert_in_epsilon(0.5, battery.initialFractionalStateofCharge, 0.01)
+      assert_in_epsilon(198.0, battery.batteryMass, 0.01)
+      assert_in_epsilon(2.25, battery.batterySurfaceArea, 0.01)
+      assert_in_epsilon(20000, calc_nom_capacity(battery), 0.01)
+
+      elcds = model.getElectricLoadCenterDistributions
+      assert_equal(1, elcds.size)
+      elcd = elcds[0]
+      assert_equal('DirectCurrentWithInverterDCStorage', elcd.electricalBussType)
+      assert_equal(0.15, elcd.minimumStorageStateofChargeFraction)
+      assert_equal(0.95, elcd.maximumStorageStateofChargeFraction)
+      assert_equal(15000.0, elcd.designStorageControlChargePower.get)
+      assert_equal(15000.0, elcd.designStorageControlDischargePower.get)
+      assert(!elcd.demandLimitSchemePurchasedElectricDemandLimit.is_initialized)
+      assert_equal('TrackFacilityElectricDemandStoreExcessOnSite', elcd.storageOperationScheme)
+    end
+  end
+
+  def test_pv_battery_garage
+    args_hash = {}
+    args_hash['hpxml_path'] = File.absolute_path(File.join(sample_files_dir, 'base-pv-battery-garage.xml'))
+    model, hpxml = _test_measure(args_hash)
+
+    hpxml.batteries.each do |hpxml_battery|
+      battery = get_battery(model, hpxml_battery.id)
+
+      # Check object
+      assert(battery.thermalZone.is_initialized)
+      assert_equal(HPXML::LocationGarage, battery.thermalZone.get.name.to_s)
+      assert_equal(0.9, battery.radiativeFraction)
+      assert_equal(HPXML::BatteryLifetimeModelNone, battery.lifetimeModel)
+      assert_in_epsilon(15, battery.numberofCellsinSeries, 0.01)
+      assert_in_epsilon(125, battery.numberofStringsinParallel, 0.01)
+      assert_in_epsilon(0.5, battery.initialFractionalStateofCharge, 0.01)
+      assert_in_epsilon(198.0, battery.batteryMass, 0.01)
+      assert_in_epsilon(2.25, battery.batterySurfaceArea, 0.01)
+      assert_in_epsilon(20000, calc_nom_capacity(battery), 0.01)
+
+      elcds = model.getElectricLoadCenterDistributions
+      assert_equal(1, elcds.size)
+      elcd = elcds[0]
+      assert_equal('DirectCurrentWithInverterDCStorage', elcd.electricalBussType)
+      assert_equal(0.15, elcd.minimumStorageStateofChargeFraction)
+      assert_equal(0.95, elcd.maximumStorageStateofChargeFraction)
+      assert_equal(15000.0, elcd.designStorageControlChargePower.get)
+      assert_equal(15000.0, elcd.designStorageControlDischargePower.get)
+      assert(!elcd.demandLimitSchemePurchasedElectricDemandLimit.is_initialized)
+      assert_equal('TrackFacilityElectricDemandStoreExcessOnSite', elcd.storageOperationScheme)
+    end
+  end
+
+  def test_pv_battery_ah
+    args_hash = {}
+    args_hash['hpxml_path'] = File.absolute_path(File.join(sample_files_dir, 'base-pv-battery-ah.xml'))
+    model, hpxml = _test_measure(args_hash)
+
+    hpxml.batteries.each do |hpxml_battery|
+      battery = get_battery(model, hpxml_battery.id)
+
+      # Check object
+      assert(!battery.thermalZone.is_initialized)
+      assert_equal(0, battery.radiativeFraction)
+      assert_equal(HPXML::BatteryLifetimeModelNone, battery.lifetimeModel)
+      assert_in_epsilon(15, battery.numberofCellsinSeries, 0.01)
+      assert_in_epsilon(125, battery.numberofStringsinParallel, 0.01)
+      assert_in_epsilon(0.5, battery.initialFractionalStateofCharge, 0.01)
+      assert_in_epsilon(198.0, battery.batteryMass, 0.01)
+      assert_in_epsilon(2.25, battery.batterySurfaceArea, 0.01)
+      assert_in_epsilon(20000, calc_nom_capacity(battery), 0.01)
+
+      elcds = model.getElectricLoadCenterDistributions
+      assert_equal(1, elcds.size)
+      elcd = elcds[0]
+      assert_equal('DirectCurrentWithInverterDCStorage', elcd.electricalBussType)
+      assert_equal(0.15, elcd.minimumStorageStateofChargeFraction)
+      assert_equal(0.95, elcd.maximumStorageStateofChargeFraction)
+      assert_equal(15000.0, elcd.designStorageControlChargePower.get)
+      assert_equal(15000.0, elcd.designStorageControlDischargePower.get)
+      assert(!elcd.demandLimitSchemePurchasedElectricDemandLimit.is_initialized)
+      assert_equal('TrackFacilityElectricDemandStoreExcessOnSite', elcd.storageOperationScheme)
+    end
+  end
+
+  def _test_measure(args_hash)
+    # create an instance of the measure
+    measure = HPXMLtoOpenStudio.new
+
+    runner = OpenStudio::Measure::OSRunner.new(OpenStudio::WorkflowJSON.new)
+    model = OpenStudio::Model::Model.new
+
+    # get arguments
+    args_hash['output_dir'] = 'tests'
+    arguments = measure.arguments(model)
+    argument_map = OpenStudio::Measure.convertOSArgumentVectorToMap(arguments)
+
+    # populate argument with specified hash value if specified
+    arguments.each do |arg|
+      temp_arg_var = arg.clone
+      if args_hash.has_key?(arg.name)
+        assert(temp_arg_var.setValue(args_hash[arg.name]))
+      end
+      argument_map[arg.name] = temp_arg_var
+    end
+
+    # run the measure
+    measure.run(model, runner, argument_map)
+    result = runner.result
+
+    # show the output
+    show_output(result) unless result.value.valueName == 'Success'
+
+    # assert that it ran correctly
+    assert_equal('Success', result.value.valueName)
+
+    hpxml = HPXML.new(hpxml_path: args_hash['hpxml_path'])
+
+    File.delete(File.join(File.dirname(__FILE__), 'in.xml'))
+
+    return model, hpxml
+  end
+end