urbanopt-cli 0.10.0 → 0.11.1

data/example_files/resources/hpxml-measures/ReportSimulationOutput/tests/{output_report_test.rb → test_report_sim_output.rb}

@@ -1,3 +1,8 @@
+# *********************************************************************************
+# URBANopt (tm), Copyright (c) Alliance for Sustainable Energy, LLC.
+# See also https://github.com/urbanopt/urbanopt-cli/blob/develop/LICENSE.md
+# *********************************************************************************
+
 # frozen_string_literal: true
 
 require_relative '../../HPXMLtoOpenStudio/resources/minitest_helper'
@@ -10,10 +15,19 @@ require_relative '../../HPXMLtoOpenStudio/resources/xmlhelper.rb'
 require_relative '../../HPXMLtoOpenStudio/resources/constants.rb'
 require_relative '../../HPXMLtoOpenStudio/resources/version.rb'
 require 'oga'
+require 'json'
 
-class ReportSimulationOutputTest < MiniTest::Test
+class ReportSimulationOutputTest < Minitest::Test
   def setup
     @tmp_hpxml_path = File.join(File.dirname(__FILE__), 'tmp.xml')
+
+    # Obtain measure.xml outputs once
+    measure_xml_path = File.join(File.dirname(__FILE__), '..', 'measure.xml')
+    doc = XMLHelper.parse_file(measure_xml_path)
+    @measure_xml_outputs = []
+    XMLHelper.get_elements(doc, '//measure/outputs/output').each do |el|
+      @measure_xml_outputs << XMLHelper.get_value(el, 'display_name', :string)
+    end
   end
 
   def teardown
@@ -61,8 +75,8 @@ class ReportSimulationOutputTest < MiniTest::Test
     "End Use: #{FT::Elec}: #{EUT::WellPump} (MBtu)",
     "End Use: #{FT::Elec}: #{EUT::PoolHeater} (MBtu)",
     "End Use: #{FT::Elec}: #{EUT::PoolPump} (MBtu)",
-    "End Use: #{FT::Elec}: #{EUT::HotTubHeater} (MBtu)",
-    "End Use: #{FT::Elec}: #{EUT::HotTubPump} (MBtu)",
+    "End Use: #{FT::Elec}: #{EUT::PermanentSpaHeater} (MBtu)",
+    "End Use: #{FT::Elec}: #{EUT::PermanentSpaPump} (MBtu)",
     "End Use: #{FT::Elec}: #{EUT::PV} (MBtu)",
     "End Use: #{FT::Elec}: #{EUT::Generator} (MBtu)",
     "End Use: #{FT::Elec}: #{EUT::Battery} (MBtu)",
@@ -73,7 +87,7 @@ class ReportSimulationOutputTest < MiniTest::Test
     "End Use: #{FT::Gas}: #{EUT::ClothesDryer} (MBtu)",
     "End Use: #{FT::Gas}: #{EUT::RangeOven} (MBtu)",
     "End Use: #{FT::Gas}: #{EUT::PoolHeater} (MBtu)",
-    "End Use: #{FT::Gas}: #{EUT::HotTubHeater} (MBtu)",
+    "End Use: #{FT::Gas}: #{EUT::PermanentSpaHeater} (MBtu)",
     "End Use: #{FT::Gas}: #{EUT::Grill} (MBtu)",
     "End Use: #{FT::Gas}: #{EUT::Lighting} (MBtu)",
     "End Use: #{FT::Gas}: #{EUT::Fireplace} (MBtu)",
@@ -144,6 +158,7 @@ class ReportSimulationOutputTest < MiniTest::Test
     "Unmet Hours: #{UHT::Cooling} (hr)",
     "Peak Electricity: #{PFT::Winter} #{TE::Total} (W)",
     "Peak Electricity: #{PFT::Summer} #{TE::Total} (W)",
+    "Peak Electricity: #{PFT::Annual} #{TE::Total} (W)",
     "Peak Load: #{PLT::Heating} (kBtu/hr)",
     "Peak Load: #{PLT::Cooling} (kBtu/hr)",
     "Component Load: Heating: #{CLT::Roofs} (MBtu)",
@@ -190,6 +205,7 @@ class ReportSimulationOutputTest < MiniTest::Test
     "Hot Water: #{HWT::Dishwasher} (gal)",
     "Hot Water: #{HWT::Fixtures} (gal)",
     "Hot Water: #{HWT::DistributionWaste} (gal)",
+    'Resilience: Battery (hr)',
     'HVAC Capacity: Cooling (Btu/h)',
     'HVAC Capacity: Heating (Btu/h)',
     'HVAC Capacity: Heat Pump Backup (Btu/h)',
@@ -265,6 +281,10 @@ class ReportSimulationOutputTest < MiniTest::Test
     "Hot Water: #{HWT::DistributionWaste}",
   ]
 
+  BaseHPXMLTimeseriesColsResilience = [
+    'Resilience: Battery'
+  ]
+
   BaseHPXMLTimeseriesColsTotalLoads = [
     "Load: #{LT::Heating}",
     "Load: #{LT::Cooling}",
@@ -311,7 +331,7 @@ class ReportSimulationOutputTest < MiniTest::Test
 
   BaseHPXMLTimeseriesColsZoneTemps = [
     'Temperature: Attic - Unvented',
-    'Temperature: Living Space',
+    'Temperature: Conditioned Space',
     'Temperature: Heating Setpoint',
     'Temperature: Cooling Setpoint',
   ]
@@ -331,16 +351,13 @@ class ReportSimulationOutputTest < MiniTest::Test
     "Weather: #{WT::DirectSolar}",
   ]
 
-  BaseHPXMLTimeseriesColsStandardOutputVariables = [
-    'Zone People Occupant Count: Living Space',
-    'Zone People Total Heating Energy: Living Space'
-  ]
-
-  BaseHPXMLTimeseriesColsAdvancedOutputVariables = [
+  BaseHPXMLTimeseriesColsEnergyPlusOutputVariables = [
+    'Zone People Occupant Count: Conditioned Space',
+    'Zone People Total Heating Energy: Conditioned Space',
     'Surface Construction Index: Door1',
     'Surface Construction Index: Foundationwall1',
     'Surface Construction Index: Floor1',
-    'Surface Construction Index: Furniture Mass Living Space 1',
+    'Surface Construction Index: Furniture Mass Conditioned Space 1',
     'Surface Construction Index: Inferred Conditioned Ceiling',
     'Surface Construction Index: Inferred Conditioned Floor',
     'Surface Construction Index: Partition Wall Mass',
@@ -443,8 +460,8 @@ class ReportSimulationOutputTest < MiniTest::Test
                "Emissions: #{scenario}: #{FT::Elec}: #{EUT::WellPump} (lb)",
                "Emissions: #{scenario}: #{FT::Elec}: #{EUT::PoolHeater} (lb)",
                "Emissions: #{scenario}: #{FT::Elec}: #{EUT::PoolPump} (lb)",
-               "Emissions: #{scenario}: #{FT::Elec}: #{EUT::HotTubHeater} (lb)",
-               "Emissions: #{scenario}: #{FT::Elec}: #{EUT::HotTubPump} (lb)",
+               "Emissions: #{scenario}: #{FT::Elec}: #{EUT::PermanentSpaHeater} (lb)",
+               "Emissions: #{scenario}: #{FT::Elec}: #{EUT::PermanentSpaPump} (lb)",
                "Emissions: #{scenario}: #{FT::Elec}: #{EUT::PV} (lb)",
                "Emissions: #{scenario}: #{FT::Elec}: #{EUT::Generator} (lb)",
                "Emissions: #{scenario}: #{FT::Elec}: #{EUT::Battery} (lb)",
@@ -454,7 +471,7 @@ class ReportSimulationOutputTest < MiniTest::Test
                "Emissions: #{scenario}: #{FT::Gas}: #{EUT::ClothesDryer} (lb)",
                "Emissions: #{scenario}: #{FT::Gas}: #{EUT::RangeOven} (lb)",
                "Emissions: #{scenario}: #{FT::Gas}: #{EUT::PoolHeater} (lb)",
-               "Emissions: #{scenario}: #{FT::Gas}: #{EUT::HotTubHeater} (lb)",
+               "Emissions: #{scenario}: #{FT::Gas}: #{EUT::PermanentSpaHeater} (lb)",
                "Emissions: #{scenario}: #{FT::Gas}: #{EUT::Grill} (lb)",
                "Emissions: #{scenario}: #{FT::Gas}: #{EUT::Lighting} (lb)",
                "Emissions: #{scenario}: #{FT::Gas}: #{EUT::Fireplace} (lb)",
@@ -581,14 +598,15 @@ class ReportSimulationOutputTest < MiniTest::Test
                   'include_timeseries_component_loads' => false,
                   'include_timeseries_zone_temperatures' => false,
                   'include_timeseries_airflows' => false,
-                  'include_timeseries_weather' => false }
+                  'include_timeseries_weather' => false,
+                  'include_timeseries_resilience' => false }
     annual_csv, timeseries_csv = _test_measure(args_hash)
     assert(File.exist?(annual_csv))
     assert(!File.exist?(timeseries_csv))
     expected_annual_rows = AnnualRows
     actual_annual_rows = _get_actual_annual_rows(annual_csv)
     assert_equal(expected_annual_rows.sort, actual_annual_rows.keys.sort)
-    _check_for_runner_registered_values(File.join(File.dirname(annual_csv), 'results.json'), actual_annual_rows)
+    _check_runner_registered_values_and_measure_xml_outputs(actual_annual_rows)
   end
 
   def test_annual_only2
@@ -609,14 +627,15 @@ class ReportSimulationOutputTest < MiniTest::Test
                   'include_timeseries_component_loads' => true,
                   'include_timeseries_zone_temperatures' => true,
                   'include_timeseries_airflows' => true,
-                  'include_timeseries_weather' => true }
+                  'include_timeseries_weather' => true,
+                  'include_timeseries_resilience' => true }
     annual_csv, timeseries_csv = _test_measure(args_hash)
     assert(File.exist?(annual_csv))
     assert(!File.exist?(timeseries_csv))
     expected_annual_rows = AnnualRows + emission_annual_cols
     actual_annual_rows = _get_actual_annual_rows(annual_csv)
     assert_equal(expected_annual_rows.sort, actual_annual_rows.keys.sort)
-    _check_for_runner_registered_values(File.join(File.dirname(annual_csv), 'results.json'), actual_annual_rows)
+    _check_runner_registered_values_and_measure_xml_outputs(actual_annual_rows)
   end
 
   def test_annual_disabled_outputs
@@ -635,7 +654,8 @@ class ReportSimulationOutputTest < MiniTest::Test
                   'include_annual_peak_loads' => false,
                   'include_annual_component_loads' => false,
                   'include_annual_hot_water_uses' => false,
-                  'include_annual_hvac_summary' => false }
+                  'include_annual_hvac_summary' => false,
+                  'include_annual_resilience' => false }
     annual_csv, timeseries_csv = _test_measure(args_hash)
     assert(File.exist?(annual_csv))
     assert(!File.exist?(timeseries_csv))
@@ -644,24 +664,6 @@ class ReportSimulationOutputTest < MiniTest::Test
   end
 
   def test_timeseries_hourly_total_energy
-    args_hash = { 'hpxml_path' => File.join(File.dirname(__FILE__), '../../workflow/sample_files/base.xml'),
-                  'skip_validation' => true,
-                  'timeseries_frequency' => 'hourly',
-                  'include_timeseries_total_consumptions' => true }
-    annual_csv, timeseries_csv = _test_measure(args_hash)
-    assert(File.exist?(annual_csv))
-    assert(File.exist?(timeseries_csv))
-    expected_timeseries_cols = ['Time'] + BaseHPXMLTimeseriesColsEnergy
-    actual_timeseries_cols = File.readlines(timeseries_csv)[0].strip.split(',')
-    assert_equal(expected_timeseries_cols.sort, actual_timeseries_cols.sort)
-    timeseries_rows = CSV.read(timeseries_csv)
-    assert_equal(8760, timeseries_rows.size - 2)
-    timeseries_cols = timeseries_rows.transpose
-    assert_equal(1, _check_for_constant_timeseries_step(timeseries_cols[0]))
-    _check_for_nonzero_avg_timeseries_value(timeseries_csv, ["Energy Use: #{TE::Total}"])
-  end
-
-  def test_timeseries_hourly_total_energy_pv
     args_hash = { 'hpxml_path' => File.join(File.dirname(__FILE__), '../../workflow/sample_files/base-pv.xml'),
                   'skip_validation' => true,
                   'timeseries_frequency' => 'hourly',
@@ -681,24 +683,6 @@ class ReportSimulationOutputTest < MiniTest::Test
   end
 
   def test_timeseries_hourly_fuels
-    args_hash = { 'hpxml_path' => File.join(File.dirname(__FILE__), '../../workflow/sample_files/base.xml'),
-                  'skip_validation' => true,
-                  'timeseries_frequency' => 'hourly',
-                  'include_timeseries_fuel_consumptions' => true }
-    annual_csv, timeseries_csv = _test_measure(args_hash)
-    assert(File.exist?(annual_csv))
-    assert(File.exist?(timeseries_csv))
-    expected_timeseries_cols = ['Time'] + BaseHPXMLTimeseriesColsFuels
-    actual_timeseries_cols = File.readlines(timeseries_csv)[0].strip.split(',')
-    assert_equal(expected_timeseries_cols.sort, actual_timeseries_cols.sort)
-    timeseries_rows = CSV.read(timeseries_csv)
-    assert_equal(8760, timeseries_rows.size - 2)
-    timeseries_cols = timeseries_rows.transpose
-    assert_equal(1, _check_for_constant_timeseries_step(timeseries_cols[0]))
-    _check_for_nonzero_avg_timeseries_value(timeseries_csv, ["Fuel Use: #{FT::Elec}: #{TE::Total}"])
-  end
-
-  def test_timeseries_hourly_fuels_pv
     args_hash = { 'hpxml_path' => File.join(File.dirname(__FILE__), '../../workflow/sample_files/base-pv.xml'),
                   'skip_validation' => true,
                   'timeseries_frequency' => 'hourly',
@@ -809,70 +793,6 @@ class ReportSimulationOutputTest < MiniTest::Test
     _check_for_nonzero_timeseries_values(timeseries_csv, ["End Use: #{FT::Elec}: #{EUT::Refrigerator}"])
   end
 
-  def test_timeseries_hourly_enduses_power_outage
-    args_hash = { 'hpxml_path' => File.join(File.dirname(__FILE__), '../../workflow/sample_files/base-schedules-simple-power-outage.xml'),
-                  'skip_validation' => true,
-                  'timeseries_frequency' => 'hourly',
-                  'include_timeseries_end_use_consumptions' => true }
-    annual_csv, timeseries_csv = _test_measure(args_hash)
-    assert(File.exist?(annual_csv))
-    assert(File.exist?(timeseries_csv))
-    expected_timeseries_cols = ['Time'] + BaseHPXMLTimeseriesColsEndUses
-    actual_timeseries_cols = File.readlines(timeseries_csv)[0].strip.split(',')
-    assert_equal(expected_timeseries_cols.sort, actual_timeseries_cols.sort)
-    timeseries_rows = CSV.read(timeseries_csv)
-    assert_equal(8760, timeseries_rows.size - 2)
-    timeseries_cols = timeseries_rows.transpose
-    assert_equal(1, _check_for_constant_timeseries_step(timeseries_cols[0]))
-    _check_for_zero_timeseries_values(timeseries_csv, ["End Use: #{FT::Elec}: #{EUT::PlugLoads}"], (31 + 28 + 31 + 30 + 31 + 30) * 24 + 4, (31 + 28 + 31 + 30 + 31 + 30 + 31) * 24 - 12) # Jul
-  end
-
-  def test_timeseries_hourly_enduses_power_outage_natvent_availability
-    energy_use_total_col = "Energy Use: #{TE::Total}"
-    temperature_living_space_col = 'Temperature: Living Space'
-
-    args_hash = { 'hpxml_path' => File.join(File.dirname(__FILE__), '../../workflow/sample_files/base-schedules-simple-power-outage.xml'),
-                  'skip_validation' => true,
-                  'timeseries_frequency' => 'hourly',
-                  'include_timeseries_total_consumptions' => true,
-                  'include_timeseries_zone_temperatures' => true }
-    _annual_csv, timeseries_csv = _test_measure(args_hash)
-    assert(File.exist?(timeseries_csv))
-    values = _get_values(timeseries_csv, [energy_use_total_col, temperature_living_space_col])
-    schedule_regular_total = values[energy_use_total_col].sum(0.0)
-    schedule_regular_temp = values[temperature_living_space_col].sum(0.0) / values[temperature_living_space_col].size
-
-    args_hash = { 'hpxml_path' => File.join(File.dirname(__FILE__), '../../workflow/sample_files/base-schedules-simple-power-outage-natvent-available.xml'),
-                  'skip_validation' => true,
-                  'timeseries_frequency' => 'hourly',
-                  'include_timeseries_total_consumptions' => true,
-                  'include_timeseries_zone_temperatures' => true }
-    _annual_csv, timeseries_csv = _test_measure(args_hash)
-    assert(File.exist?(timeseries_csv))
-    values = _get_values(timeseries_csv, [energy_use_total_col, temperature_living_space_col])
-    schedule_available_total = values[energy_use_total_col].sum(0.0)
-    schedule_available_temp = values[temperature_living_space_col].sum(0.0) / values[temperature_living_space_col].size
-
-    args_hash = { 'hpxml_path' => File.join(File.dirname(__FILE__), '../../workflow/sample_files/base-schedules-simple-power-outage-natvent-unavailable.xml'),
-                  'skip_validation' => true,
-                  'timeseries_frequency' => 'hourly',
-                  'include_timeseries_total_consumptions' => true,
-                  'include_timeseries_zone_temperatures' => true }
-    _annual_csv, timeseries_csv = _test_measure(args_hash)
-    assert(File.exist?(timeseries_csv))
-    values = _get_values(timeseries_csv, [energy_use_total_col, temperature_living_space_col])
-    schedule_unavailable_total = values[energy_use_total_col].sum(0.0)
-    schedule_unavailable_temp = values[temperature_living_space_col].sum(0.0) / values[temperature_living_space_col].size
-
-    assert_operator(schedule_regular_total, :>, schedule_available_total)
-    assert_operator(schedule_available_total, :<, schedule_unavailable_total)
-    assert_operator(schedule_unavailable_total, :<, schedule_regular_total)
-
-    assert_operator(schedule_regular_temp, :>, schedule_available_temp)
-    assert_operator(schedule_available_temp, :<, schedule_unavailable_temp)
-    assert_operator(schedule_unavailable_temp, :>, schedule_regular_temp)
-  end
-
   def test_timeseries_hourly_system_uses
     args_hash = { 'hpxml_path' => File.join(File.dirname(__FILE__), '../../workflow/sample_files/base.xml'),
                   'skip_validation' => true,
@@ -891,7 +811,7 @@ class ReportSimulationOutputTest < MiniTest::Test
     _check_for_nonzero_avg_timeseries_value(timeseries_csv, ["System Use: HeatingSystem1: #{FT::Gas}: #{EUT::Heating}"])
   end
 
-  def test_timeseries_hourly_hotwateruses
+  def test_timeseries_hourly_hotwater_uses
     args_hash = { 'hpxml_path' => File.join(File.dirname(__FILE__), '../../workflow/sample_files/base.xml'),
                   'skip_validation' => true,
                   'timeseries_frequency' => 'hourly',
@@ -968,24 +888,6 @@ class ReportSimulationOutputTest < MiniTest::Test
   end
 
   def test_timeseries_hourly_zone_temperatures
-    args_hash = { 'hpxml_path' => File.join(File.dirname(__FILE__), '../../workflow/sample_files/base.xml'),
-                  'skip_validation' => true,
-                  'timeseries_frequency' => 'hourly',
-                  'include_timeseries_zone_temperatures' => true }
-    annual_csv, timeseries_csv = _test_measure(args_hash)
-    assert(File.exist?(annual_csv))
-    assert(File.exist?(timeseries_csv))
-    expected_timeseries_cols = ['Time'] + BaseHPXMLTimeseriesColsZoneTemps
-    actual_timeseries_cols = File.readlines(timeseries_csv)[0].strip.split(',')
-    assert_equal(expected_timeseries_cols.sort, actual_timeseries_cols.sort)
-    timeseries_rows = CSV.read(timeseries_csv)
-    assert_equal(8760, timeseries_rows.size - 2)
-    timeseries_cols = timeseries_rows.transpose
-    assert_equal(1, _check_for_constant_timeseries_step(timeseries_cols[0]))
-    _check_for_nonzero_avg_timeseries_value(timeseries_csv, BaseHPXMLTimeseriesColsZoneTemps)
-  end
-
-  def test_timeseries_hourly_zone_temperatures_without_cooling
     args_hash = { 'hpxml_path' => File.join(File.dirname(__FILE__), '../../workflow/sample_files/base-hvac-furnace-gas-only.xml'),
                   'skip_validation' => true,
                   'timeseries_frequency' => 'hourly',
@@ -1003,67 +905,71 @@ class ReportSimulationOutputTest < MiniTest::Test
     _check_for_nonzero_avg_timeseries_value(timeseries_csv, BaseHPXMLTimeseriesColsZoneTemps - ['Temperature: Cooling Setpoint'])
   end
 
-  def test_timeseries_hourly_zone_temperatures_mf_space
-    args_hash = { 'hpxml_path' => File.join(File.dirname(__FILE__), '../../workflow/sample_files/base-bldgtype-multifamily-adjacent-to-multiple.xml'),
+  def test_timeseries_hourly_zone_temperatures_mf_spaces
+    args_hash = { 'hpxml_path' => File.join(File.dirname(__FILE__), '../../workflow/sample_files/base-bldgtype-mf-unit-adjacent-to-multiple.xml'),
                   'skip_validation' => true,
                   'timeseries_frequency' => 'hourly',
                   'include_timeseries_zone_temperatures' => true }
     annual_csv, timeseries_csv = _test_measure(args_hash)
     assert(File.exist?(annual_csv))
     assert(File.exist?(timeseries_csv))
+    cols_temps = BaseHPXMLTimeseriesColsZoneTemps - ['Temperature: Attic - Unvented']
+    cols_temps_other_side = ['Temperature: Other Multifamily Buffer Space',
+                             'Temperature: Other Non-freezing Space',
+                             'Temperature: Other Housing Unit',
+                             'Temperature: Other Heated Space']
+    expected_timeseries_cols = ['Time'] + cols_temps + cols_temps_other_side
     actual_timeseries_cols = File.readlines(timeseries_csv)[0].strip.split(',')
-    cols_temps_other_side = [
-      'Temperature: Other Multifamily Buffer Space',
-      'Temperature: Other Non-freezing Space',
-      'Temperature: Other Housing Unit',
-      'Temperature: Other Heated Space'
-    ]
-    cols_temps_other_side.each do |expected_col|
-      assert(actual_timeseries_cols.include? expected_col)
-    end
+    assert_equal(expected_timeseries_cols.sort, actual_timeseries_cols.sort)
     timeseries_rows = CSV.read(timeseries_csv)
     assert_equal(8760, timeseries_rows.size - 2)
     timeseries_cols = timeseries_rows.transpose
     assert_equal(1, _check_for_constant_timeseries_step(timeseries_cols[0]))
-    _check_for_nonzero_avg_timeseries_value(timeseries_csv, cols_temps_other_side)
+    _check_for_nonzero_avg_timeseries_value(timeseries_csv, cols_temps + cols_temps_other_side)
   end
 
-  def test_timeseries_hourly_airflows_with_exhaust_mechvent
-    args_hash = { 'hpxml_path' => File.join(File.dirname(__FILE__), '../../workflow/sample_files/base-mechvent-exhaust.xml'),
+  def test_timeseries_hourly_zone_temperatures_whole_mf_building
+    args_hash = { 'hpxml_path' => File.join(File.dirname(__FILE__), '../../workflow/sample_files/base-multiple-mf-units.xml'),
+                  'building_id' => 'ALL',
                   'skip_validation' => true,
                   'timeseries_frequency' => 'hourly',
-                  'include_timeseries_airflows' => true }
+                  'include_timeseries_zone_temperatures' => true }
     annual_csv, timeseries_csv = _test_measure(args_hash)
     assert(File.exist?(annual_csv))
     assert(File.exist?(timeseries_csv))
-    expected_timeseries_cols = ['Time'] + BaseHPXMLTimeseriesColsAirflows
     actual_timeseries_cols = File.readlines(timeseries_csv)[0].strip.split(',')
+    expected_timeseries_cols = ['Time']
+    for i in 1..6
+      expected_timeseries_cols << "Temperature: Unit#{i} Conditioned Space"
+      if i <= 2
+        expected_timeseries_cols << "Temperature: Unit#{i} Basement Unconditioned"
+      elsif i >= 5
+        expected_timeseries_cols << "Temperature: Unit#{i} Attic Vented"
+      end
+      expected_timeseries_cols << "Temperature: Unit#{i} Heating Setpoint"
+      expected_timeseries_cols << "Temperature: Unit#{i} Cooling Setpoint"
+    end
     assert_equal(expected_timeseries_cols.sort, actual_timeseries_cols.sort)
     timeseries_rows = CSV.read(timeseries_csv)
     assert_equal(8760, timeseries_rows.size - 2)
-    timeseries_cols = timeseries_rows.transpose
-    assert_equal(1, _check_for_constant_timeseries_step(timeseries_cols[0]))
-    _check_for_nonzero_avg_timeseries_value(timeseries_csv, BaseHPXMLTimeseriesColsAirflows.select { |t| t != 'Airflow: Whole House Fan' })
   end
 
-  def test_timeseries_hourly_airflows_with_whf
-    args_hash = { 'hpxml_path' => File.join(File.dirname(__FILE__), '../../workflow/sample_files/base-mechvent-whole-house-fan.xml'),
+  def test_timeseries_hourly_airflows_with_mechvent
+    args_hash = { 'hpxml_path' => File.join(File.dirname(__FILE__), '../../workflow/sample_files/base-mechvent-multiple.xml'),
                   'skip_validation' => true,
                   'timeseries_frequency' => 'hourly',
                   'include_timeseries_airflows' => true }
     annual_csv, timeseries_csv = _test_measure(args_hash)
     assert(File.exist?(annual_csv))
     assert(File.exist?(timeseries_csv))
-    add_cols = ['Airflow: Whole House Fan']
-    remove_cols = ['Airflow: Natural Ventilation']
-    expected_timeseries_cols = ['Time'] + BaseHPXMLTimeseriesColsAirflows + add_cols - remove_cols
+    expected_timeseries_cols = ['Time'] + BaseHPXMLTimeseriesColsAirflows - ['Airflow: Natural Ventilation'] + ['Airflow: Whole House Fan']
     actual_timeseries_cols = File.readlines(timeseries_csv)[0].strip.split(',')
     assert_equal(expected_timeseries_cols.sort, actual_timeseries_cols.sort)
     timeseries_rows = CSV.read(timeseries_csv)
     assert_equal(8760, timeseries_rows.size - 2)
     timeseries_cols = timeseries_rows.transpose
     assert_equal(1, _check_for_constant_timeseries_step(timeseries_cols[0]))
-    _check_for_nonzero_avg_timeseries_value(timeseries_csv, add_cols)
+    _check_for_nonzero_avg_timeseries_value(timeseries_csv, BaseHPXMLTimeseriesColsAirflows - ['Airflow: Natural Ventilation'] + ['Airflow: Whole House Fan'])
   end
 
   def test_timeseries_hourly_airflows_with_clothes_dryer_exhaust
@@ -1084,42 +990,6 @@ class ReportSimulationOutputTest < MiniTest::Test
     _check_for_nonzero_avg_timeseries_value(timeseries_csv, ["Airflow: #{AFT::MechanicalVentilation}"])
   end
 
-  def test_timeseries_hourly_airflows_with_balanced_mechvent
-    args_hash = { 'hpxml_path' => File.join(File.dirname(__FILE__), '../../workflow/sample_files/base-mechvent-balanced.xml'),
-                  'skip_validation' => true,
-                  'timeseries_frequency' => 'hourly',
-                  'include_timeseries_airflows' => true }
-    annual_csv, timeseries_csv = _test_measure(args_hash)
-    assert(File.exist?(annual_csv))
-    assert(File.exist?(timeseries_csv))
-    expected_timeseries_cols = ['Time'] + BaseHPXMLTimeseriesColsAirflows
-    actual_timeseries_cols = File.readlines(timeseries_csv)[0].strip.split(',')
-    assert_equal(expected_timeseries_cols.sort, actual_timeseries_cols.sort)
-    timeseries_rows = CSV.read(timeseries_csv)
-    assert_equal(8760, timeseries_rows.size - 2)
-    timeseries_cols = timeseries_rows.transpose
-    assert_equal(1, _check_for_constant_timeseries_step(timeseries_cols[0]))
-    _check_for_nonzero_avg_timeseries_value(timeseries_csv, ["Airflow: #{AFT::MechanicalVentilation}"])
-  end
-
-  def test_timeseries_hourly_airflows_with_cfis
-    args_hash = { 'hpxml_path' => File.join(File.dirname(__FILE__), '../../workflow/sample_files/base-mechvent-cfis.xml'),
-                  'skip_validation' => true,
-                  'timeseries_frequency' => 'hourly',
-                  'include_timeseries_airflows' => true }
-    annual_csv, timeseries_csv = _test_measure(args_hash)
-    assert(File.exist?(annual_csv))
-    assert(File.exist?(timeseries_csv))
-    expected_timeseries_cols = ['Time'] + BaseHPXMLTimeseriesColsAirflows
-    actual_timeseries_cols = File.readlines(timeseries_csv)[0].strip.split(',')
-    assert_equal(expected_timeseries_cols.sort, actual_timeseries_cols.sort)
-    timeseries_rows = CSV.read(timeseries_csv)
-    assert_equal(8760, timeseries_rows.size - 2)
-    timeseries_cols = timeseries_rows.transpose
-    assert_equal(1, _check_for_constant_timeseries_step(timeseries_cols[0]))
-    _check_for_nonzero_avg_timeseries_value(timeseries_csv, ["Airflow: #{AFT::MechanicalVentilation}"])
-  end
-
   def test_timeseries_hourly_weather
     args_hash = { 'hpxml_path' => File.join(File.dirname(__FILE__), '../../workflow/sample_files/base.xml'),
                   'skip_validation' => true,
@@ -1155,7 +1025,8 @@ class ReportSimulationOutputTest < MiniTest::Test
                   'include_timeseries_component_loads' => true,
                   'include_timeseries_zone_temperatures' => true,
                   'include_timeseries_airflows' => true,
-                  'include_timeseries_weather' => true }
+                  'include_timeseries_weather' => true,
+                  'include_timeseries_resilience' => true }
     annual_csv, timeseries_csv = _test_measure(args_hash)
     assert(File.exist?(annual_csv))
     assert(File.exist?(timeseries_csv))
@@ -1164,7 +1035,8 @@ class ReportSimulationOutputTest < MiniTest::Test
                                emissions_timeseries_cols +
                                emission_fuels_timeseries_cols +
                                emission_end_uses_timeseries_cols +
-                               pv_battery_timeseries_cols
+                               pv_battery_timeseries_cols +
+                               BaseHPXMLTimeseriesColsResilience
     actual_timeseries_cols = File.readlines(timeseries_csv)[0].strip.split(',')
     assert_equal(expected_timeseries_cols.sort, actual_timeseries_cols.sort)
     timeseries_rows = CSV.read(timeseries_csv)
@@ -1192,7 +1064,8 @@ class ReportSimulationOutputTest < MiniTest::Test
                   'include_timeseries_component_loads' => true,
                   'include_timeseries_zone_temperatures' => true,
                   'include_timeseries_airflows' => true,
-                  'include_timeseries_weather' => true }
+                  'include_timeseries_weather' => true,
+                  'include_timeseries_resilience' => true }
     annual_csv, timeseries_csv = _test_measure(args_hash)
     assert(File.exist?(annual_csv))
     assert(File.exist?(timeseries_csv))
@@ -1201,7 +1074,8 @@ class ReportSimulationOutputTest < MiniTest::Test
                                emissions_timeseries_cols +
                                emission_fuels_timeseries_cols +
                                emission_end_uses_timeseries_cols +
-                               pv_battery_timeseries_cols
+                               pv_battery_timeseries_cols +
+                               BaseHPXMLTimeseriesColsResilience
     actual_timeseries_cols = File.readlines(timeseries_csv)[0].strip.split(',')
     assert_equal(expected_timeseries_cols.sort, actual_timeseries_cols.sort)
     timeseries_rows = CSV.read(timeseries_csv)
@@ -1229,7 +1103,8 @@ class ReportSimulationOutputTest < MiniTest::Test
                   'include_timeseries_component_loads' => true,
                   'include_timeseries_zone_temperatures' => true,
                   'include_timeseries_airflows' => true,
-                  'include_timeseries_weather' => true }
+                  'include_timeseries_weather' => true,
+                  'include_timeseries_resilience' => true }
     annual_csv, timeseries_csv = _test_measure(args_hash)
     assert(File.exist?(annual_csv))
     assert(File.exist?(timeseries_csv))
@@ -1238,7 +1113,8 @@ class ReportSimulationOutputTest < MiniTest::Test
                                emissions_timeseries_cols +
                                emission_fuels_timeseries_cols +
                                emission_end_uses_timeseries_cols +
-                               pv_battery_timeseries_cols
+                               pv_battery_timeseries_cols +
+                               BaseHPXMLTimeseriesColsResilience
     actual_timeseries_cols = File.readlines(timeseries_csv)[0].strip.split(',')
     assert_equal(expected_timeseries_cols.sort, actual_timeseries_cols.sort)
     timeseries_rows = CSV.read(timeseries_csv)
@@ -1247,10 +1123,28 @@ class ReportSimulationOutputTest < MiniTest::Test
     _check_for_nonzero_timeseries_values(timeseries_csv, ["End Use: #{FT::Elec}: #{EUT::Refrigerator}"])
   end
 
+  def test_timeseries_monthly_resilience
+    args_hash = { 'hpxml_path' => File.join(File.dirname(__FILE__), '../../workflow/sample_files/base-pv-battery-scheduled.xml'),
+                  'skip_validation' => true,
+                  'timeseries_frequency' => 'monthly',
+                  'include_timeseries_resilience' => true }
+    annual_csv, timeseries_csv = _test_measure(args_hash)
+    assert(File.exist?(annual_csv))
+    assert(File.exist?(timeseries_csv))
+    expected_timeseries_cols = ['Time'] +
+                               BaseHPXMLTimeseriesColsResilience
+    actual_timeseries_cols = File.readlines(timeseries_csv)[0].strip.split(',')
+    assert_equal(expected_timeseries_cols.sort, actual_timeseries_cols.sort)
+    timeseries_rows = CSV.read(timeseries_csv)
+    assert_equal(12, timeseries_rows.size - 2)
+  end
+
   def test_timeseries_timestep
     args_hash = { 'hpxml_path' => File.join(File.dirname(__FILE__), '../../workflow/sample_files/base.xml'),
                   'timeseries_frequency' => 'timestep',
-                  'include_timeseries_fuel_consumptions' => true }
+                  'include_timeseries_fuel_consumptions' => true,
+                  'add_timeseries_dst_column' => true,
+                  'add_timeseries_utc_column' => true }
     annual_csv, timeseries_csv = _test_measure(args_hash)
     assert(File.exist?(annual_csv))
     assert(File.exist?(timeseries_csv))
@@ -1258,7 +1152,12 @@ class ReportSimulationOutputTest < MiniTest::Test
     assert_equal(8760, timeseries_rows.size - 2)
     timeseries_cols = timeseries_rows.transpose
     assert_equal(1, _check_for_constant_timeseries_step(timeseries_cols[0]))
-  end
+    assert_equal(1, timeseries_rows[0].select { |r| r == 'Time' }.size)
+    assert_equal(1, timeseries_rows[0].select { |r| r == 'TimeDST' }.size)
+    assert_equal(1, timeseries_rows[0].select { |r| r == 'TimeUTC' }.size)
+    assert_equal(1, _check_for_constant_timeseries_step(timeseries_cols[0]))
+    assert_equal(3, _check_for_constant_timeseries_step(timeseries_cols[1]))
+    assert_equal(1, _check_for_constant_timeseries_step(timeseries_cols[2])) end
 
   def test_timeseries_timestep_emissions
     args_hash = { 'hpxml_path' => File.join(File.dirname(__FILE__), '../../workflow/sample_files/base-misc-emissions.xml'),
@@ -1298,9 +1197,7 @@ class ReportSimulationOutputTest < MiniTest::Test
   end
 
   def test_timeseries_hourly_runperiod_1month
-    expected_values = { 'timestep' => 28 * 24,
-                        'hourly' => 28 * 24,
-                        'daily' => 28,
+    expected_values = { 'hourly' => 28 * 24,
                         'monthly' => 1 }
 
     expected_values.each do |timeseries_frequency, expected_value|
@@ -1337,8 +1234,6 @@ class ReportSimulationOutputTest < MiniTest::Test
   def test_timeseries_timestamp_convention
     # Expected values are arrays of time offsets (in seconds) for each reported row of output
     expected_values_array = { 'timestep' => [30 * 60] * 17520,
-                              'hourly' => [60 * 60] * 8760,
-                              'daily' => [60 * 60 * 24] * 365,
                               'monthly' => Constants.NumDaysInMonths(1999).map { |n_days| n_days * 60 * 60 * 24 } }
 
     expected_values_array.each do |timeseries_frequency, expected_values|
@@ -1390,107 +1285,32 @@ class ReportSimulationOutputTest < MiniTest::Test
     assert_equal(Float(timeseries_csv[5000 + 1][col_ix].strip), Float(timeseries_csv2[5000][col_ix].strip)) # in dst period, values are shifted forward
   end
 
-  def test_timeseries_local_time_dst
-    args_hash = { 'hpxml_path' => File.join(File.dirname(__FILE__), '../../workflow/sample_files/base.xml'),
-                  'skip_validation' => true,
-                  'timeseries_frequency' => 'timestep',
-                  'include_timeseries_fuel_consumptions' => true,
-                  'add_timeseries_dst_column' => true }
-    annual_csv, timeseries_csv = _test_measure(args_hash)
-    assert(File.exist?(annual_csv))
-    assert(File.exist?(timeseries_csv))
-    timeseries_rows = CSV.read(timeseries_csv)
-    assert_equal(8760, timeseries_rows.size - 2)
-    timeseries_cols = timeseries_rows.transpose
-    assert_equal(1, timeseries_rows[0].select { |r| r == 'Time' }.size)
-    assert_equal(1, timeseries_rows[0].select { |r| r == 'TimeDST' }.size)
-    assert_equal(1, _check_for_constant_timeseries_step(timeseries_cols[0]))
-    assert_equal(3, _check_for_constant_timeseries_step(timeseries_cols[1]))
-  end
-
-  def test_timeseries_local_time_utc
-    args_hash = { 'hpxml_path' => File.join(File.dirname(__FILE__), '../../workflow/sample_files/base.xml'),
-                  'skip_validation' => true,
-                  'timeseries_frequency' => 'timestep',
-                  'include_timeseries_fuel_consumptions' => true,
-                  'add_timeseries_utc_column' => true }
-    annual_csv, timeseries_csv = _test_measure(args_hash)
-    assert(File.exist?(annual_csv))
-    assert(File.exist?(timeseries_csv))
-    timeseries_rows = CSV.read(timeseries_csv)
-    assert_equal(8760, timeseries_rows.size - 2)
-    timeseries_cols = timeseries_rows.transpose
-    assert_equal(1, timeseries_rows[0].select { |r| r == 'Time' }.size)
-    assert_equal(1, timeseries_rows[0].select { |r| r == 'TimeUTC' }.size)
-    assert_equal(1, _check_for_constant_timeseries_step(timeseries_cols[0]))
-    assert_equal(1, _check_for_constant_timeseries_step(timeseries_cols[1]))
-  end
-
-  def test_timeseries_local_time_dst_and_utc
-    args_hash = { 'hpxml_path' => File.join(File.dirname(__FILE__), '../../workflow/sample_files/base.xml'),
-                  'skip_validation' => true,
-                  'timeseries_frequency' => 'timestep',
-                  'include_timeseries_fuel_consumptions' => true,
-                  'add_timeseries_dst_column' => true,
-                  'add_timeseries_utc_column' => true }
-    annual_csv, timeseries_csv = _test_measure(args_hash)
-    assert(File.exist?(annual_csv))
-    assert(File.exist?(timeseries_csv))
-    timeseries_rows = CSV.read(timeseries_csv)
-    assert_equal(8760, timeseries_rows.size - 2)
-    timeseries_cols = timeseries_rows.transpose
-    assert_equal(1, timeseries_rows[0].select { |r| r == 'Time' }.size)
-    assert_equal(1, timeseries_rows[0].select { |r| r == 'TimeDST' }.size)
-    assert_equal(1, timeseries_rows[0].select { |r| r == 'TimeUTC' }.size)
-    assert_equal(1, _check_for_constant_timeseries_step(timeseries_cols[0]))
-    assert_equal(3, _check_for_constant_timeseries_step(timeseries_cols[1]))
-    assert_equal(1, _check_for_constant_timeseries_step(timeseries_cols[2]))
-  end
-
-  def test_timeseries_user_defined_standard_output_variables
+  def test_timeseries_energyplus_output_variables
     args_hash = { 'hpxml_path' => File.join(File.dirname(__FILE__), '../../workflow/sample_files/base.xml'),
                   'skip_validation' => true,
+                  'add_component_loads' => true,
                   'timeseries_frequency' => 'hourly',
-                  'user_output_variables' => 'Zone People Occupant Count, Zone People Total Heating Energy, Foo' }
+                  'user_output_variables' => 'Zone People Occupant Count, Zone People Total Heating Energy, Foo, Surface Construction Index' }
     annual_csv, timeseries_csv, run_log = _test_measure(args_hash)
     assert(File.exist?(annual_csv))
     assert(File.exist?(timeseries_csv))
-    expected_timeseries_cols = ['Time'] + BaseHPXMLTimeseriesColsStandardOutputVariables
+    expected_timeseries_cols = ['Time'] + BaseHPXMLTimeseriesColsEnergyPlusOutputVariables
     actual_timeseries_cols = File.readlines(timeseries_csv)[0].strip.split(',')
     assert_equal(expected_timeseries_cols.sort, actual_timeseries_cols.sort)
     timeseries_rows = CSV.read(timeseries_csv)
     assert_equal(8760, timeseries_rows.size - 2)
     timeseries_cols = timeseries_rows.transpose
     assert_equal(1, _check_for_constant_timeseries_step(timeseries_cols[0]))
-    _check_for_nonzero_avg_timeseries_value(timeseries_csv, BaseHPXMLTimeseriesColsStandardOutputVariables)
+    _check_for_nonzero_avg_timeseries_value(timeseries_csv, BaseHPXMLTimeseriesColsEnergyPlusOutputVariables)
     assert(File.readlines(run_log).any? { |line| line.include?("Request for output variable 'Foo'") })
   end
 
-  def test_timeseries_user_defined_advanced_output_variables
-    args_hash = { 'hpxml_path' => File.join(File.dirname(__FILE__), '../../workflow/sample_files/base.xml'),
-                  'skip_validation' => true,
-                  'add_component_loads' => true,
-                  'timeseries_frequency' => 'hourly',
-                  'user_output_variables' => 'Surface Construction Index' }
-    annual_csv, timeseries_csv = _test_measure(args_hash)
-    assert(File.exist?(annual_csv))
-    assert(File.exist?(timeseries_csv))
-    expected_timeseries_cols = ['Time'] + BaseHPXMLTimeseriesColsAdvancedOutputVariables
-    actual_timeseries_cols = File.readlines(timeseries_csv)[0].strip.split(',')
-    assert_equal(expected_timeseries_cols.sort, actual_timeseries_cols.sort)
-    timeseries_rows = CSV.read(timeseries_csv)
-    assert_equal(8760, timeseries_rows.size - 2)
-    timeseries_cols = timeseries_rows.transpose
-    assert_equal(1, _check_for_constant_timeseries_step(timeseries_cols[0]))
-    _check_for_nonzero_avg_timeseries_value(timeseries_csv, BaseHPXMLTimeseriesColsAdvancedOutputVariables)
-  end
-
   def test_for_unsuccessful_simulation_infinity
     # Create HPXML w/ AFUE=0 to generate Infinity result
     hpxml_path = File.join(File.dirname(__FILE__), '../../workflow/sample_files/base.xml')
     hpxml = HPXML.new(hpxml_path: hpxml_path)
-    hpxml.heating_systems[0].heating_efficiency_afue = 10.0**-315
-    XMLHelper.write_file(hpxml.to_oga(), @tmp_hpxml_path)
+    hpxml.buildings[0].heating_systems[0].heating_efficiency_afue = 10.0**-315
+    XMLHelper.write_file(hpxml.to_doc(), @tmp_hpxml_path)
 
     args_hash = { 'hpxml_path' => @tmp_hpxml_path,
                   'skip_validation' => true, }
@@ -1527,6 +1347,9 @@ class ReportSimulationOutputTest < MiniTest::Test
     workflow.setWorkflowSteps(steps)
     osw_path = File.join(File.dirname(template_osw), 'test.osw')
     workflow.saveAs(osw_path)
+    if args_hash.size != found_args.size
+      puts "ERROR: Did not find an argument (#{(args_hash.keys - found_args)[0]}) in #{File.basename(template_osw)}."
+    end
     assert_equal(args_hash.size, found_args.size)
 
     # Run OSW
@@ -1618,10 +1441,10 @@ class ReportSimulationOutputTest < MiniTest::Test
     return actual_annual_rows
   end
 
-  def _check_for_runner_registered_values(results_json, actual_annual_rows)
-    require 'json'
-    runner_annual_rows = JSON.parse(File.read(results_json))
-    runner_annual_rows = runner_annual_rows['ReportSimulationOutput']
+  def _check_runner_registered_values_and_measure_xml_outputs(actual_annual_rows)
+    # Check for runner registered values
+    results_json_path = File.join(File.dirname(__FILE__), '..', '..', 'workflow', 'run', 'results.json')
+    runner_annual_rows = JSON.parse(File.read(results_json_path))['ReportSimulationOutput']
 
     actual_annual_rows.each do |name, value|
       name = OpenStudio::toUnderscoreCase(name).chomp('_')
@@ -1629,5 +1452,13 @@ class ReportSimulationOutputTest < MiniTest::Test
       assert_includes(runner_annual_rows.keys, name)
       assert_equal(value, runner_annual_rows[name])
     end
+
+    # Check that all the "outputs" in the measure.xml, which are used by PAT,
+    # are found in the results.json file.
+    refute(@measure_xml_outputs.empty?)
+
+    @measure_xml_outputs.each do |measure_xml_output|
+      assert_includes(runner_annual_rows.keys, measure_xml_output)
+    end
   end
 end