urbanopt-cli 0.9.2 → 0.10.0

data/example_files/resources/hpxml-measures/ReportSimulationOutput/measure.rb

@@ -43,6 +43,90 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
     arg.setDefaultValue('csv')
     args << arg
 
+    arg = OpenStudio::Measure::OSArgument::makeBoolArgument('include_annual_total_consumptions', false)
+    arg.setDisplayName('Generate Annual Output: Total Consumptions')
+    arg.setDescription('Generates annual energy consumptions for the total building.')
+    arg.setDefaultValue(true)
+    args << arg
+
+    arg = OpenStudio::Measure::OSArgument::makeBoolArgument('include_annual_fuel_consumptions', false)
+    arg.setDisplayName('Generate Annual Output: Fuel Consumptions')
+    arg.setDescription('Generates annual energy consumptions for each fuel type.')
+    arg.setDefaultValue(true)
+    args << arg
+
+    arg = OpenStudio::Measure::OSArgument::makeBoolArgument('include_annual_end_use_consumptions', false)
+    arg.setDisplayName('Generate Annual Output: End Use Consumptions')
+    arg.setDescription('Generates annual energy consumptions for each end use.')
+    arg.setDefaultValue(true)
+    args << arg
+
+    arg = OpenStudio::Measure::OSArgument::makeBoolArgument('include_annual_system_use_consumptions', false)
+    arg.setDisplayName('Generate Annual Output: System Use Consumptions')
+    arg.setDescription('Generates annual energy consumptions for each end use of each HVAC and water heating system.')
+    arg.setDefaultValue(true)
+    args << arg
+
+    arg = OpenStudio::Measure::OSArgument::makeBoolArgument('include_annual_emissions', false)
+    arg.setDisplayName('Generate Annual Output: Emissions')
+    arg.setDescription('Generates annual emissions. Requires the appropriate HPXML inputs to be specified.')
+    arg.setDefaultValue(true)
+    args << arg
+
+    arg = OpenStudio::Measure::OSArgument::makeBoolArgument('include_annual_emission_fuels', false)
+    arg.setDisplayName('Generate Annual Output: Emission Fuel Uses')
+    arg.setDescription('Generates annual emissions for each fuel type. Requires the appropriate HPXML inputs to be specified.')
+    arg.setDefaultValue(true)
+    args << arg
+
+    arg = OpenStudio::Measure::OSArgument::makeBoolArgument('include_annual_emission_end_uses', false)
+    arg.setDisplayName('Generate Annual Output: Emission End Uses')
+    arg.setDescription('Generates annual emissions for each end use. Requires the appropriate HPXML inputs to be specified.')
+    arg.setDefaultValue(true)
+    args << arg
+
+    arg = OpenStudio::Measure::OSArgument::makeBoolArgument('include_annual_total_loads', false)
+    arg.setDisplayName('Generate Annual Output: Total Loads')
+    arg.setDescription('Generates annual heating, cooling, and hot water loads.')
+    arg.setDefaultValue(true)
+    args << arg
+
+    arg = OpenStudio::Measure::OSArgument::makeBoolArgument('include_annual_unmet_hours', false)
+    arg.setDisplayName('Generate Annual Output: Unmet Hours')
+    arg.setDescription('Generates annual unmet hours for heating and cooling.')
+    arg.setDefaultValue(true)
+    args << arg
+
+    arg = OpenStudio::Measure::OSArgument::makeBoolArgument('include_annual_peak_fuels', false)
+    arg.setDisplayName('Generate Annual Output: Peak Fuels')
+    arg.setDescription('Generates annual electricity peaks for summer/winter.')
+    arg.setDefaultValue(true)
+    args << arg
+
+    arg = OpenStudio::Measure::OSArgument::makeBoolArgument('include_annual_peak_loads', false)
+    arg.setDisplayName('Generate Annual Output: Peak Loads')
+    arg.setDescription('Generates annual peak loads for heating/cooling.')
+    arg.setDefaultValue(true)
+    args << arg
+
+    arg = OpenStudio::Measure::OSArgument::makeBoolArgument('include_annual_component_loads', false)
+    arg.setDisplayName('Generate Annual Output: Component Loads')
+    arg.setDescription('Generates annual heating and cooling loads disaggregated by component type.')
+    arg.setDefaultValue(true)
+    args << arg
+
+    arg = OpenStudio::Measure::OSArgument::makeBoolArgument('include_annual_hot_water_uses', false)
+    arg.setDisplayName('Generate Annual Output: Hot Water Uses')
+    arg.setDescription('Generates annual hot water usages for each end use.')
+    arg.setDefaultValue(true)
+    args << arg
+
+    arg = OpenStudio::Measure::OSArgument::makeBoolArgument('include_annual_hvac_summary', false)
+    arg.setDisplayName('Generate Annual Output: HVAC Summary')
+    arg.setDescription('Generates HVAC capacities, design temperatures, and design loads.')
+    arg.setDefaultValue(true)
+    args << arg
+
     timeseries_frequency_chs = OpenStudio::StringVector.new
     timeseries_frequency_chs << 'none'
     timeseries_frequency_chs << 'timestep'
@@ -57,7 +141,7 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
 
     arg = OpenStudio::Measure::OSArgument::makeBoolArgument('include_timeseries_total_consumptions', false)
     arg.setDisplayName('Generate Timeseries Output: Total Consumptions')
-    arg.setDescription('Generates timeseries energy consumptions for building total.')
+    arg.setDescription('Generates timeseries energy consumptions for the total building.')
     arg.setDefaultValue(false)
     args << arg
 
@@ -73,6 +157,12 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
     arg.setDefaultValue(false)
     args << arg
 
+    arg = OpenStudio::Measure::OSArgument::makeBoolArgument('include_timeseries_system_use_consumptions', false)
+    arg.setDisplayName('Generate Timeseries Output: System Use Consumptions')
+    arg.setDescription('Generates timeseries energy consumptions for each end use of each HVAC and water heating system.')
+    arg.setDefaultValue(false)
+    args << arg
+
     arg = OpenStudio::Measure::OSArgument::makeBoolArgument('include_timeseries_emissions', false)
     arg.setDisplayName('Generate Timeseries Output: Emissions')
     arg.setDescription('Generates timeseries emissions. Requires the appropriate HPXML inputs to be specified.')
@@ -80,7 +170,7 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
     args << arg
 
     arg = OpenStudio::Measure::OSArgument::makeBoolArgument('include_timeseries_emission_fuels', false)
-    arg.setDisplayName('Generate Timeseries Output: Emissions')
+    arg.setDisplayName('Generate Timeseries Output: Emission Fuel Uses')
     arg.setDescription('Generates timeseries emissions for each fuel type. Requires the appropriate HPXML inputs to be specified.')
     arg.setDefaultValue(false)
     args << arg
@@ -99,7 +189,7 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
 
     arg = OpenStudio::Measure::OSArgument::makeBoolArgument('include_timeseries_total_loads', false)
     arg.setDisplayName('Generate Timeseries Output: Total Loads')
-    arg.setDescription('Generates timeseries total heating, cooling, and hot water loads.')
+    arg.setDescription('Generates timeseries heating, cooling, and hot water loads.')
     arg.setDefaultValue(false)
     args << arg
 
@@ -142,6 +232,11 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
     arg.setDefaultValue('start')
     args << arg
 
+    arg = OpenStudio::Measure::OSArgument::makeIntegerArgument('timeseries_num_decimal_places', false)
+    arg.setDisplayName('Generate Timeseries Output: Number of Decimal Places')
+    arg.setDescription('Allows overriding the default number of decimal places for timeseries output. Does not apply if output format is msgpack, where no rounding is performed because there is no file size penalty to storing full precision.')
+    args << arg
+
     arg = OpenStudio::Measure::OSArgument::makeBoolArgument('add_timeseries_dst_column', false)
     arg.setDisplayName('Generate Timeseries Output: Add TimeDST Column')
     arg.setDescription('Optionally add, in addition to the default local standard Time column, a local clock TimeDST column. Requires that daylight saving time is enabled.')
@@ -159,11 +254,6 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
     arg.setDescription('Optionally generates timeseries EnergyPlus output variables. If multiple output variables are desired, use a comma-separated list. Do not include key values; by default all key values will be requested. Example: "Zone People Occupant Count, Zone People Total Heating Energy"')
     args << arg
 
-    arg = OpenStudio::Measure::OSArgument::makeBoolArgument('generate_eri_outputs', false)
-    arg.setDisplayName('Generate ERI Outputs')
-    arg.setDescription('Optionally generate additional outputs needed for Energy Rating Index (ERI) calculations.')
-    args << arg
-
     arg = OpenStudio::Measure::OSArgument::makeStringArgument('annual_output_file_name', false)
     arg.setDisplayName('Annual Output File Name')
     arg.setDescription("If not provided, defaults to 'results_annual.csv' (or 'results_annual.json' or 'results_annual.msgpack').")
@@ -177,35 +267,28 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
     return args
   end
 
-  # define the outputs that the measure will create
-  def outputs
-    outs = OpenStudio::Measure::OSOutputVector.new
-
-    setup_outputs(true)
-
-    all_outputs = []
-    all_outputs << @totals
-    all_outputs << @fuels
-    all_outputs << @end_uses
-    all_outputs << @loads
-    all_outputs << @unmet_hours
-    all_outputs << @peak_fuels
-    all_outputs << @peak_loads
-    all_outputs << @component_loads
-    all_outputs << @hot_water_uses
-
-    output_names = []
-    all_outputs.each do |outputs|
-      outputs.values.each do |obj|
-        output_names << get_runner_output_name(obj.name, obj.annual_units)
+  def get_arguments(runner, arguments, user_arguments)
+    args = get_argument_values(runner, arguments, user_arguments)
+    args.each do |k, val|
+      if val.respond_to?(:is_initialized) && val.is_initialized
+        args[k] = val.get
+      elsif k.start_with?('include_annual')
+        args[k] = true # default if not provided
+      elsif k.start_with?('include_timeseries')
+        args[k] = false # default if not provided
+      else
+        args[k] = nil # default if not provided
       end
     end
+    if args[:timeseries_frequency] == 'none'
+      # Override all timeseries arguments
+      args.each do |k, _val|
+        next unless k.start_with?('include_timeseries')
 
-    output_names.each do |output_name|
-      outs << OpenStudio::Measure::OSOutput.makeDoubleOutput(output_name)
+        args[k] = false
+      end
     end
-
-    return outs
+    return args
   end
 
   # return a vector of IdfObject's to request EnergyPlus objects needed by the run method
@@ -238,56 +321,10 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
     has_heating = @model.getBuilding.additionalProperties.getFeatureAsBoolean('has_heating').get
     has_cooling = @model.getBuilding.additionalProperties.getFeatureAsBoolean('has_cooling').get
 
-    timeseries_frequency = runner.getStringArgumentValue('timeseries_frequency', user_arguments)
-    if timeseries_frequency != 'none'
-      include_timeseries_total_consumptions = runner.getOptionalBoolArgumentValue('include_timeseries_total_consumptions', user_arguments)
-      include_timeseries_fuel_consumptions = runner.getOptionalBoolArgumentValue('include_timeseries_fuel_consumptions', user_arguments)
-      include_timeseries_end_use_consumptions = runner.getOptionalBoolArgumentValue('include_timeseries_end_use_consumptions', user_arguments)
-      include_timeseries_emissions = runner.getOptionalBoolArgumentValue('include_timeseries_emissions', user_arguments)
-      include_timeseries_emission_fuels = runner.getOptionalBoolArgumentValue('include_timeseries_emission_fuels', user_arguments)
-      include_timeseries_emission_end_uses = runner.getOptionalBoolArgumentValue('include_timeseries_emission_end_uses', user_arguments)
-      include_timeseries_hot_water_uses = runner.getOptionalBoolArgumentValue('include_timeseries_hot_water_uses', user_arguments)
-      include_timeseries_total_loads = runner.getOptionalBoolArgumentValue('include_timeseries_total_loads', user_arguments)
-      include_timeseries_component_loads = runner.getOptionalBoolArgumentValue('include_timeseries_component_loads', user_arguments)
-      include_timeseries_unmet_hours = runner.getOptionalBoolArgumentValue('include_timeseries_unmet_hours', user_arguments)
-      include_timeseries_zone_temperatures = runner.getOptionalBoolArgumentValue('include_timeseries_zone_temperatures', user_arguments)
-      include_timeseries_airflows = runner.getOptionalBoolArgumentValue('include_timeseries_airflows', user_arguments)
-      include_timeseries_weather = runner.getOptionalBoolArgumentValue('include_timeseries_weather', user_arguments)
-      user_output_variables = runner.getOptionalStringArgumentValue('user_output_variables', user_arguments)
-
-      include_timeseries_total_consumptions = include_timeseries_total_consumptions.is_initialized ? include_timeseries_total_consumptions.get : false
-      include_timeseries_fuel_consumptions = include_timeseries_fuel_consumptions.is_initialized ? include_timeseries_fuel_consumptions.get : false
-      include_timeseries_end_use_consumptions = include_timeseries_end_use_consumptions.is_initialized ? include_timeseries_end_use_consumptions.get : false
-      include_timeseries_emissions = include_timeseries_emissions.is_initialized ? include_timeseries_emissions.get : false
-      include_timeseries_emission_fuels = include_timeseries_emission_fuels.is_initialized ? include_timeseries_emission_fuels.get : false
-      include_timeseries_emission_end_uses = include_timeseries_emission_end_uses.is_initialized ? include_timeseries_emission_end_uses.get : false
-      include_timeseries_hot_water_uses = include_timeseries_hot_water_uses.is_initialized ? include_timeseries_hot_water_uses.get : false
-      include_timeseries_total_loads = include_timeseries_total_loads.is_initialized ? include_timeseries_total_loads.get : false
-      include_timeseries_component_loads = include_timeseries_component_loads.is_initialized ? include_timeseries_component_loads.get : false
-      include_timeseries_unmet_hours = include_timeseries_unmet_hours.is_initialized ? include_timeseries_unmet_hours.get : false
-      include_timeseries_zone_temperatures = include_timeseries_zone_temperatures.is_initialized ? include_timeseries_zone_temperatures.get : false
-      include_timeseries_airflows = include_timeseries_airflows.is_initialized ? include_timeseries_airflows.get : false
-      include_timeseries_weather = include_timeseries_weather.is_initialized ? include_timeseries_weather.get : false
-      user_output_variables = user_output_variables.is_initialized ? user_output_variables.get : nil
-    end
-
-    setup_outputs(false, user_output_variables)
+    args = get_arguments(runner, arguments(model), user_arguments)
 
-    # To calculate timeseries emissions or timeseries fuel consumption, we also need to select timeseries
-    # end use consumption because EnergyPlus results may be post-processed due to HVAC DSE.
-    # TODO: This could be removed if we could account for DSE inside EnergyPlus.
-    if not @emissions.empty?
-      include_hourly_electric_end_use_consumptions = true # Need hourly electricity values for Cambium
-      if include_timeseries_emissions || include_timeseries_emission_end_uses || include_timeseries_emission_fuels
-        include_timeseries_fuel_consumptions = true
-      end
-    end
-    if include_timeseries_total_consumptions
-      include_timeseries_fuel_consumptions = true
-    end
-    if include_timeseries_fuel_consumptions
-      include_timeseries_end_use_consumptions = true
-    end
+    setup_outputs(false, args[:user_output_variables])
+    args = setup_timeseries_includes(@emissions, args)
 
     has_electricity_production = false
     if @end_uses.select { |_key, end_use| end_use.is_negative && end_use.variables.size > 0 }.size > 0
@@ -303,8 +340,8 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
     @fuels.each do |_fuel_type, fuel|
       fuel.meters.each do |meter|
         result << OpenStudio::IdfObject.load("Output:Meter,#{meter},runperiod;").get
-        if include_timeseries_fuel_consumptions
-          result << OpenStudio::IdfObject.load("Output:Meter,#{meter},#{timeseries_frequency};").get
+        if args[:include_timeseries_fuel_consumptions]
+          result << OpenStudio::IdfObject.load("Output:Meter,#{meter},#{args[:timeseries_frequency]};").get
         end
       end
     end
@@ -313,25 +350,24 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
     end
     if has_electricity_storage
       result << OpenStudio::IdfObject.load('Output:Meter,ElectricStorage:ElectricityProduced,runperiod;').get # Used for error checking
-      if include_timeseries_fuel_consumptions
-        result << OpenStudio::IdfObject.load("Output:Meter,ElectricStorage:ElectricityProduced,#{timeseries_frequency};").get
+      if args[:include_timeseries_fuel_consumptions]
+        result << OpenStudio::IdfObject.load("Output:Meter,ElectricStorage:ElectricityProduced,#{args[:timeseries_frequency]};").get
       end
     end
 
     # End Use/Hot Water Use/Ideal Load outputs
-    { @end_uses => include_timeseries_end_use_consumptions,
-      @hot_water_uses => include_timeseries_hot_water_uses,
-      @ideal_system_loads => false }.each do |uses, include_timeseries|
+    { @end_uses => args[:include_timeseries_end_use_consumptions],
+      @hot_water_uses => args[:include_timeseries_hot_water_uses] }.each do |uses, include_ts|
       uses.each do |key, use|
         use.variables.each do |_sys_id, varkey, var|
           result << OpenStudio::IdfObject.load("Output:Variable,#{varkey},#{var},runperiod;").get
-          if include_timeseries
-            result << OpenStudio::IdfObject.load("Output:Variable,#{varkey},#{var},#{timeseries_frequency};").get
+          if include_ts
+            result << OpenStudio::IdfObject.load("Output:Variable,#{varkey},#{var},#{args[:timeseries_frequency]};").get
           end
           next unless use.is_a?(EndUse)
 
           fuel_type, _end_use = key
-          if fuel_type == FT::Elec && include_hourly_electric_end_use_consumptions
+          if fuel_type == FT::Elec && args[:include_hourly_electric_end_use_consumptions]
             result << OpenStudio::IdfObject.load("Output:Variable,#{varkey},#{var},hourly;").get
           end
         end
@@ -340,9 +376,7 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
 
     # Peak Fuel outputs (annual only)
     @peak_fuels.values.each do |peak_fuel|
-      peak_fuel.meters.each do |meter|
-        result << OpenStudio::IdfObject.load("Output:Table:Monthly,#{peak_fuel.report},2,#{meter},HoursPositive,Electricity:Facility,MaximumDuringHoursShown;").get
-      end
+      result << OpenStudio::IdfObject.load("Output:Table:Monthly,#{peak_fuel.report},2,Electricity:Facility,Maximum;").get
     end
 
     # Peak Load outputs (annual only)
@@ -355,9 +389,9 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
     @unmet_hours.each do |_key, unmet_hour|
       result << OpenStudio::IdfObject.load("EnergyManagementSystem:OutputVariable,#{unmet_hour.ems_variable}_annual_outvar,#{unmet_hour.ems_variable},Summed,ZoneTimestep,#{unmet_hours_program.name},hr;").get
       result << OpenStudio::IdfObject.load("Output:Variable,*,#{unmet_hour.ems_variable}_annual_outvar,runperiod;").get
-      if include_timeseries_unmet_hours
+      if args[:include_timeseries_unmet_hours]
         result << OpenStudio::IdfObject.load("EnergyManagementSystem:OutputVariable,#{unmet_hour.ems_variable}_timeseries_outvar,#{unmet_hour.ems_variable},Summed,ZoneTimestep,#{unmet_hours_program.name},hr;").get
-        result << OpenStudio::IdfObject.load("Output:Variable,*,#{unmet_hour.ems_variable}_timeseries_outvar,#{timeseries_frequency};").get
+        result << OpenStudio::IdfObject.load("Output:Variable,*,#{unmet_hour.ems_variable}_timeseries_outvar,#{args[:timeseries_frequency]};").get
       end
     end
 
@@ -367,9 +401,9 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
 
       result << OpenStudio::IdfObject.load("EnergyManagementSystem:OutputVariable,#{comp_load.ems_variable}_annual_outvar,#{comp_load.ems_variable},Summed,ZoneTimestep,#{comp_loads_program.name},J;").get
       result << OpenStudio::IdfObject.load("Output:Variable,*,#{comp_load.ems_variable}_annual_outvar,runperiod;").get
-      if include_timeseries_component_loads
+      if args[:include_timeseries_component_loads]
         result << OpenStudio::IdfObject.load("EnergyManagementSystem:OutputVariable,#{comp_load.ems_variable}_timeseries_outvar,#{comp_load.ems_variable},Summed,ZoneTimestep,#{comp_loads_program.name},J;").get
-        result << OpenStudio::IdfObject.load("Output:Variable,*,#{comp_load.ems_variable}_timeseries_outvar,#{timeseries_frequency};").get
+        result << OpenStudio::IdfObject.load("Output:Variable,*,#{comp_load.ems_variable}_timeseries_outvar,#{args[:timeseries_frequency]};").get
       end
     end
 
@@ -378,22 +412,22 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
       if not load.ems_variable.nil?
         result << OpenStudio::IdfObject.load("EnergyManagementSystem:OutputVariable,#{load.ems_variable}_annual_outvar,#{load.ems_variable},Summed,ZoneTimestep,#{total_loads_program.name},J;").get
         result << OpenStudio::IdfObject.load("Output:Variable,*,#{load.ems_variable}_annual_outvar,runperiod;").get
-        if include_timeseries_total_loads
+        if args[:include_timeseries_total_loads]
           result << OpenStudio::IdfObject.load("EnergyManagementSystem:OutputVariable,#{load.ems_variable}_timeseries_outvar,#{load.ems_variable},Summed,ZoneTimestep,#{total_loads_program.name},J;").get
-          result << OpenStudio::IdfObject.load("Output:Variable,*,#{load.ems_variable}_timeseries_outvar,#{timeseries_frequency};").get
+          result << OpenStudio::IdfObject.load("Output:Variable,*,#{load.ems_variable}_timeseries_outvar,#{args[:timeseries_frequency]};").get
         end
       end
       load.variables.each do |_sys_id, varkey, var|
         result << OpenStudio::IdfObject.load("Output:Variable,#{varkey},#{var},runperiod;").get
-        if include_timeseries_total_loads
-          result << OpenStudio::IdfObject.load("Output:Variable,#{varkey},#{var},#{timeseries_frequency};").get
+        if args[:include_timeseries_total_loads]
+          result << OpenStudio::IdfObject.load("Output:Variable,#{varkey},#{var},#{args[:timeseries_frequency]};").get
         end
       end
     end
 
     # Temperature outputs (timeseries only)
-    if include_timeseries_zone_temperatures
-      result << OpenStudio::IdfObject.load("Output:Variable,*,Zone Mean Air Temperature,#{timeseries_frequency};").get
+    if args[:include_timeseries_zone_temperatures]
+      result << OpenStudio::IdfObject.load("Output:Variable,*,Zone Mean Air Temperature,#{args[:timeseries_frequency]};").get
       # For reporting temperature-scheduled spaces timeseries temperatures.
       keys = [HPXML::LocationOtherHeatedSpace,
               HPXML::LocationOtherMultifamilyBufferSpace,
@@ -404,46 +438,38 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
       keys.each do |key|
         next if @model.getScheduleConstants.select { |o| o.name.to_s == key }.size == 0
 
-        result << OpenStudio::IdfObject.load("Output:Variable,#{key},Schedule Value,#{timeseries_frequency};").get
+        result << OpenStudio::IdfObject.load("Output:Variable,#{key},Schedule Value,#{args[:timeseries_frequency]};").get
       end
       # Also report thermostat setpoints
       if has_heating
-        result << OpenStudio::IdfObject.load("Output:Variable,#{HPXML::LocationLivingSpace.upcase},Zone Thermostat Heating Setpoint Temperature,#{timeseries_frequency};").get
+        result << OpenStudio::IdfObject.load("Output:Variable,#{HPXML::LocationLivingSpace.upcase},Zone Thermostat Heating Setpoint Temperature,#{args[:timeseries_frequency]};").get
       end
       if has_cooling
-        result << OpenStudio::IdfObject.load("Output:Variable,#{HPXML::LocationLivingSpace.upcase},Zone Thermostat Cooling Setpoint Temperature,#{timeseries_frequency};").get
+        result << OpenStudio::IdfObject.load("Output:Variable,#{HPXML::LocationLivingSpace.upcase},Zone Thermostat Cooling Setpoint Temperature,#{args[:timeseries_frequency]};").get
       end
     end
 
     # Airflow outputs (timeseries only)
-    if include_timeseries_airflows
+    if args[:include_timeseries_airflows]
       @airflows.values.each do |airflow|
         ems_program = @model.getModelObjectByName(airflow.ems_program.gsub(' ', '_')).get.to_EnergyManagementSystemProgram.get
         airflow.ems_variables.each do |ems_variable|
           result << OpenStudio::IdfObject.load("EnergyManagementSystem:OutputVariable,#{ems_variable}_timeseries_outvar,#{ems_variable},Averaged,ZoneTimestep,#{ems_program.name},m^3/s;").get
-          result << OpenStudio::IdfObject.load("Output:Variable,*,#{ems_variable}_timeseries_outvar,#{timeseries_frequency};").get
+          result << OpenStudio::IdfObject.load("Output:Variable,*,#{ems_variable}_timeseries_outvar,#{args[:timeseries_frequency]};").get
         end
       end
     end
 
     # Weather outputs (timeseries only)
-    if include_timeseries_weather
+    if args[:include_timeseries_weather]
       @weather.values.each do |weather_data|
-        result << OpenStudio::IdfObject.load("Output:Variable,*,#{weather_data.variable},#{timeseries_frequency};").get
+        result << OpenStudio::IdfObject.load("Output:Variable,*,#{weather_data.variable},#{args[:timeseries_frequency]};").get
       end
     end
 
     # Optional output variables (timeseries only)
     @output_variables_requests.each do |output_variable_name, _output_variable|
-      result << OpenStudio::IdfObject.load("Output:Variable,*,#{output_variable_name},#{timeseries_frequency};").get
-    end
-
-    # Dual-fuel heat pump loads
-    if not @object_variables_by_key[[LT, LT::Heating]].nil?
-      @object_variables_by_key[[LT, LT::Heating]].each do |vals|
-        _sys_id, key, var = vals
-        result << OpenStudio::IdfObject.load("Output:Variable,#{key},#{var},runperiod;").get
-      end
+      result << OpenStudio::IdfObject.load("Output:Variable,*,#{output_variable_name},#{args[:timeseries_frequency]};").get
     end
 
     return result.uniq
@@ -465,59 +491,22 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
       return false
     end
 
-    output_format = runner.getStringArgumentValue('output_format', user_arguments)
-    if output_format == 'csv_dview'
-      output_format = 'csv'
-      use_dview_format = true
-    end
-    timeseries_frequency = runner.getStringArgumentValue('timeseries_frequency', user_arguments)
-    if timeseries_frequency != 'none'
-      include_timeseries_total_consumptions = runner.getOptionalBoolArgumentValue('include_timeseries_total_consumptions', user_arguments)
-      include_timeseries_fuel_consumptions = runner.getOptionalBoolArgumentValue('include_timeseries_fuel_consumptions', user_arguments)
-      include_timeseries_end_use_consumptions = runner.getOptionalBoolArgumentValue('include_timeseries_end_use_consumptions', user_arguments)
-      include_timeseries_emissions = runner.getOptionalBoolArgumentValue('include_timeseries_emissions', user_arguments)
-      include_timeseries_emission_fuels = runner.getOptionalBoolArgumentValue('include_timeseries_emission_fuels', user_arguments)
-      include_timeseries_emission_end_uses = runner.getOptionalBoolArgumentValue('include_timeseries_emission_end_uses', user_arguments)
-      include_timeseries_hot_water_uses = runner.getOptionalBoolArgumentValue('include_timeseries_hot_water_uses', user_arguments)
-      include_timeseries_total_loads = runner.getOptionalBoolArgumentValue('include_timeseries_total_loads', user_arguments)
-      include_timeseries_component_loads = runner.getOptionalBoolArgumentValue('include_timeseries_component_loads', user_arguments)
-      include_timeseries_unmet_hours = runner.getOptionalBoolArgumentValue('include_timeseries_unmet_hours', user_arguments)
-      include_timeseries_zone_temperatures = runner.getOptionalBoolArgumentValue('include_timeseries_zone_temperatures', user_arguments)
-      include_timeseries_airflows = runner.getOptionalBoolArgumentValue('include_timeseries_airflows', user_arguments)
-      include_timeseries_weather = runner.getOptionalBoolArgumentValue('include_timeseries_weather', user_arguments)
-      use_timestamp_start_convention = (runner.getStringArgumentValue('timeseries_timestamp_convention', user_arguments) == 'start')
-      add_timeseries_dst_column = runner.getOptionalBoolArgumentValue('add_timeseries_dst_column', user_arguments)
-      add_timeseries_utc_column = runner.getOptionalBoolArgumentValue('add_timeseries_utc_column', user_arguments)
-      user_output_variables = runner.getOptionalStringArgumentValue('user_output_variables', user_arguments)
-
-      include_timeseries_total_consumptions = include_timeseries_total_consumptions.is_initialized ? include_timeseries_total_consumptions.get : false
-      include_timeseries_fuel_consumptions = include_timeseries_fuel_consumptions.is_initialized ? include_timeseries_fuel_consumptions.get : false
-      include_timeseries_end_use_consumptions = include_timeseries_end_use_consumptions.is_initialized ? include_timeseries_end_use_consumptions.get : false
-      include_timeseries_emissions = include_timeseries_emissions.is_initialized ? include_timeseries_emissions.get : false
-      include_timeseries_emission_fuels = include_timeseries_emission_fuels.is_initialized ? include_timeseries_emission_fuels.get : false
-      include_timeseries_emission_end_uses = include_timeseries_emission_end_uses.is_initialized ? include_timeseries_emission_end_uses.get : false
-      include_timeseries_hot_water_uses = include_timeseries_hot_water_uses.is_initialized ? include_timeseries_hot_water_uses.get : false
-      include_timeseries_total_loads = include_timeseries_total_loads.is_initialized ? include_timeseries_total_loads.get : false
-      include_timeseries_component_loads = include_timeseries_component_loads.is_initialized ? include_timeseries_component_loads.get : false
-      include_timeseries_unmet_hours = include_timeseries_unmet_hours.is_initialized ? include_timeseries_unmet_hours.get : false
-      include_timeseries_zone_temperatures = include_timeseries_zone_temperatures.is_initialized ? include_timeseries_zone_temperatures.get : false
-      include_timeseries_airflows = include_timeseries_airflows.is_initialized ? include_timeseries_airflows.get : false
-      include_timeseries_weather = include_timeseries_weather.is_initialized ? include_timeseries_weather.get : false
-      user_output_variables = user_output_variables.is_initialized ? user_output_variables.get : nil
-    end
-    generate_eri_outputs = runner.getOptionalBoolArgumentValue('generate_eri_outputs', user_arguments)
-    generate_eri_outputs = generate_eri_outputs.is_initialized ? generate_eri_outputs.get : false
-    annual_output_file_name = runner.getOptionalStringArgumentValue('annual_output_file_name', user_arguments)
-    timeseries_output_file_name = runner.getOptionalStringArgumentValue('timeseries_output_file_name', user_arguments)
+    args = get_arguments(runner, arguments(model), user_arguments)
+
+    if args[:output_format] == 'csv_dview'
+      args[:output_format] = 'csv'
+      args[:use_dview_format] = true
+    else
+      args[:use_dview_format] = false
+    end
 
     output_dir = File.dirname(runner.lastEpwFilePath.get.to_s)
 
     hpxml_defaults_path = @model.getBuilding.additionalProperties.getFeatureAsString('hpxml_defaults_path').get
     building_id = @model.getBuilding.additionalProperties.getFeatureAsString('building_id').get
     @hpxml = HPXML.new(hpxml_path: hpxml_defaults_path, building_id: building_id)
-    HVAC.apply_shared_systems(@hpxml) # Needed for ERI shared HVAC systems
 
-    setup_outputs(false, user_output_variables)
+    setup_outputs(false, args[:user_output_variables])
 
     if not File.exist? File.join(output_dir, 'eplusout.msgpack')
       runner.registerError('Cannot find eplusout.msgpack.')
@@ -525,7 +514,7 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
     end
     @msgpackData = MessagePack.unpack(File.read(File.join(output_dir, 'eplusout.msgpack'), mode: 'rb'))
     @msgpackDataRunPeriod = MessagePack.unpack(File.read(File.join(output_dir, 'eplusout_runperiod.msgpack'), mode: 'rb'))
-    msgpack_timeseries_path = File.join(output_dir, "eplusout_#{timeseries_frequency}.msgpack")
+    msgpack_timeseries_path = File.join(output_dir, "eplusout_#{args[:timeseries_frequency]}.msgpack")
     if File.exist? msgpack_timeseries_path
       @msgpackDataTimeseries = MessagePack.unpack(File.read(msgpack_timeseries_path, mode: 'rb'))
     end
@@ -534,137 +523,140 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
     end
 
     # Set paths
-    if annual_output_file_name.is_initialized
-      annual_output_path = File.join(output_dir, annual_output_file_name.get)
+    if not args[:annual_output_file_name].nil?
+      annual_output_path = File.join(output_dir, args[:annual_output_file_name])
     else
-      annual_output_path = File.join(output_dir, "results_annual.#{output_format}")
+      annual_output_path = File.join(output_dir, "results_annual.#{args[:output_format]}")
     end
-    if timeseries_output_file_name.is_initialized
-      timeseries_output_path = File.join(output_dir, timeseries_output_file_name.get)
+    if not args[:timeseries_output_file_name].nil?
+      timeseries_output_path = File.join(output_dir, args[:timeseries_output_file_name])
     else
-      timeseries_output_path = File.join(output_dir, "results_timeseries.#{output_format}")
+      timeseries_output_path = File.join(output_dir, "results_timeseries.#{args[:output_format]}")
     end
 
-    if timeseries_frequency != 'none'
-      add_dst_column = (add_timeseries_dst_column.is_initialized ? add_timeseries_dst_column.get : false)
-      add_utc_column = (add_timeseries_utc_column.is_initialized ? add_timeseries_utc_column.get : false)
-      @timestamps, timestamps_dst, timestamps_utc = OutputMethods.get_timestamps(@msgpackDataTimeseries, @hpxml, use_timestamp_start_convention,
-                                                                                 add_dst_column, add_utc_column, use_dview_format, timeseries_frequency)
+    if args[:timeseries_frequency] != 'none'
+      @timestamps, timestamps_dst, timestamps_utc = get_timestamps(@msgpackDataTimeseries, @hpxml, args)
     end
 
     # Retrieve outputs
-    outputs = get_outputs(runner, timeseries_frequency,
-                          include_timeseries_total_consumptions,
-                          include_timeseries_fuel_consumptions,
-                          include_timeseries_end_use_consumptions,
-                          include_timeseries_emissions,
-                          include_timeseries_emission_fuels,
-                          include_timeseries_emission_end_uses,
-                          include_timeseries_hot_water_uses,
-                          include_timeseries_total_loads,
-                          include_timeseries_component_loads,
-                          include_timeseries_unmet_hours,
-                          include_timeseries_zone_temperatures,
-                          include_timeseries_airflows,
-                          include_timeseries_weather)
+    outputs = get_outputs(runner, args)
 
     if not check_for_errors(runner, outputs)
       return false
     end
 
-    # Set rounding precision for run period (e.g., annual) outputs.
-    # Note: Make sure to round outputs with sufficient resolution for the worst case -- i.e., 1 day instead of a full year.
-    runperiod_n_digits = 3 # Default for annual (or near-annual) data
-    sim_n_days = (Schedule.get_day_num_from_month_day(2000, @hpxml.header.sim_end_month, @hpxml.header.sim_end_day) -
-                  Schedule.get_day_num_from_month_day(2000, @hpxml.header.sim_begin_month, @hpxml.header.sim_begin_day))
-    if sim_n_days <= 10 # 10 days or less; add two decimal places
-      runperiod_n_digits += 2
-    elsif sim_n_days <= 100 # 100 days or less; add one decimal place
-      runperiod_n_digits += 1
-    end
-
     # Write/report results
-    report_runperiod_output_results(runner, outputs, output_format, annual_output_path, runperiod_n_digits, generate_eri_outputs)
-    report_timeseries_output_results(runner, outputs, output_format,
-                                     timeseries_output_path,
-                                     timeseries_frequency,
-                                     include_timeseries_total_consumptions,
-                                     include_timeseries_fuel_consumptions,
-                                     include_timeseries_end_use_consumptions,
-                                     include_timeseries_emissions,
-                                     include_timeseries_emission_fuels,
-                                     include_timeseries_emission_end_uses,
-                                     include_timeseries_hot_water_uses,
-                                     include_timeseries_total_loads,
-                                     include_timeseries_component_loads,
-                                     include_timeseries_unmet_hours,
-                                     include_timeseries_zone_temperatures,
-                                     include_timeseries_airflows,
-                                     include_timeseries_weather,
-                                     add_dst_column,
-                                     add_utc_column,
-                                     timestamps_dst,
-                                     timestamps_utc,
-                                     use_dview_format)
+    report_runperiod_output_results(runner, outputs, args, annual_output_path)
+    report_timeseries_output_results(runner, outputs, timeseries_output_path, args, timestamps_dst, timestamps_utc)
 
     return true
   end
 
-  def get_outputs(runner, timeseries_frequency,
-                  include_timeseries_total_consumptions,
-                  include_timeseries_fuel_consumptions,
-                  include_timeseries_end_use_consumptions,
-                  include_timeseries_emissions,
-                  include_timeseries_emission_fuels,
-                  include_timeseries_emission_end_uses,
-                  include_timeseries_hot_water_uses,
-                  include_timeseries_total_loads,
-                  include_timeseries_component_loads,
-                  include_timeseries_unmet_hours,
-                  include_timeseries_zone_temperatures,
-                  include_timeseries_airflows,
-                  include_timeseries_weather)
-    outputs = {}
+  def get_timestamps(msgpackData, hpxml, args)
+    return if msgpackData.nil?
+
+    ep_timestamps = msgpackData['Rows'].map { |r| r.keys[0] }
+
+    if args[:add_timeseries_dst_column] || args[:use_dview_format]
+      dst_start_ts = Time.utc(hpxml.header.sim_calendar_year, hpxml.header.dst_begin_month, hpxml.header.dst_begin_day, 2)
+      dst_end_ts = Time.utc(hpxml.header.sim_calendar_year, hpxml.header.dst_end_month, hpxml.header.dst_end_day, 1)
+    end
+    if args[:add_timeseries_utc_column]
+      utc_offset = hpxml.header.time_zone_utc_offset
+      utc_offset *= 3600 # seconds
+    end
+
+    timestamps = []
+    timestamps_dst = [] if args[:add_timeseries_dst_column] || args[:use_dview_format]
+    timestamps_utc = [] if args[:add_timeseries_utc_column]
+    year = hpxml.header.sim_calendar_year
+    ep_timestamps.each do |ep_timestamp|
+      month_day, hour_minute = ep_timestamp.split(' ')
+      month, day = month_day.split('/').map(&:to_i)
+      hour, minute, _ = hour_minute.split(':').map(&:to_i)
+
+      # Convert from EnergyPlus default (end-of-timestep) to start-of-timestep convention
+      if args[:timeseries_timestamp_convention] == 'start'
+        if args[:timeseries_frequency] == 'timestep'
+          ts_offset = hpxml.header.timestep * 60 # seconds
+        elsif args[:timeseries_frequency] == 'hourly'
+          ts_offset = 60 * 60 # seconds
+        elsif args[:timeseries_frequency] == 'daily'
+          ts_offset = 60 * 60 * 24 # seconds
+        elsif args[:timeseries_frequency] == 'monthly'
+          ts_offset = Constants.NumDaysInMonths(year)[month - 1] * 60 * 60 * 24 # seconds
+        else
+          fail "Unexpected timeseries_frequency: #{args[:timeseries_frequency]}."
+        end
+      end
 
-    # To calculate timeseries emissions or timeseries fuel consumption, we also need to select timeseries
-    # end use consumption because EnergyPlus results may be post-processed due to, e.g., HVAC DSE.
-    # TODO: This could be removed if we could account for DSE inside EnergyPlus.
-    if not @emissions.empty?
-      include_hourly_electric_end_use_consumptions = true # For annual Cambium calculation
-      if include_timeseries_emissions || include_timeseries_emission_end_uses || include_timeseries_emission_fuels
-        include_timeseries_fuel_consumptions = true
+      ts = Time.utc(year, month, day, hour, minute)
+      ts -= ts_offset unless ts_offset.nil?
+
+      timestamps << ts.iso8601.delete('Z')
+
+      if args[:add_timeseries_dst_column] || args[:use_dview_format]
+        if (ts >= dst_start_ts) && (ts < dst_end_ts)
+          ts_dst = ts + 3600 # 1 hr shift forward
+        else
+          ts_dst = ts
+        end
+        timestamps_dst << ts_dst.iso8601.delete('Z')
+      end
+
+      if args[:add_timeseries_utc_column]
+        ts_utc = ts - utc_offset
+        timestamps_utc << ts_utc.iso8601
       end
-    end
-    if include_timeseries_total_consumptions
-      include_timeseries_fuel_consumptions = true
-    end
-    if include_timeseries_fuel_consumptions
-      include_timeseries_end_use_consumptions = true
     end
 
+    return timestamps, timestamps_dst, timestamps_utc
+  end
+
+  def get_outputs(runner, args)
+    outputs = {}
+
+    args = setup_timeseries_includes(@emissions, args)
+
     # Fuel Uses
     @fuels.each do |fuel_type, fuel|
       fuel.annual_output = get_report_meter_data_annual(fuel.meters)
       fuel.annual_output -= get_report_meter_data_annual(['ElectricStorage:ElectricityProduced']) if fuel_type == FT::Elec # We add Electric Storage onto the annual Electricity fuel meter
 
-      next unless include_timeseries_fuel_consumptions
+      next unless args[:include_timeseries_fuel_consumptions]
+
+      fuel.timeseries_output = get_report_meter_data_timeseries(fuel.meters, UnitConversions.convert(1.0, 'J', fuel.timeseries_units), 0, args[:timeseries_frequency])
 
-      fuel.timeseries_output = get_report_meter_data_timeseries(fuel.meters, UnitConversions.convert(1.0, 'J', fuel.timeseries_units), 0, timeseries_frequency)
-      fuel.timeseries_output = fuel.timeseries_output.zip(get_report_meter_data_timeseries(['ElectricStorage:ElectricityProduced'], UnitConversions.convert(1.0, 'J', fuel.timeseries_units), 0, timeseries_frequency)).map { |x, y| x - y } if fuel_type == FT::Elec # We add Electric Storage onto the timeseries Electricity fuel meter
+      next unless fuel_type == FT::Elec
+
+      # We add Electric Storage onto the timeseries Electricity fuel meter
+      elec_storage_timeseries_output = get_report_meter_data_timeseries(['ElectricStorage:ElectricityProduced'], UnitConversions.convert(1.0, 'J', fuel.timeseries_units), 0, args[:timeseries_frequency])
+      fuel.timeseries_output = fuel.timeseries_output.zip(elec_storage_timeseries_output).map { |x, y| x - y }
     end
 
     # Peak Electricity Consumption
-    @peak_fuels.each do |_key, peak_fuel|
-      peak_fuel.annual_output = get_tabular_data_value(peak_fuel.report.upcase, 'Meter', 'Custom Monthly Report', ['Maximum of Months'], 'ELECTRICITY:FACILITY {MAX FOR HOURS SHOWN}', peak_fuel.annual_units)
+    is_southern_hemisphere = @model.getBuilding.additionalProperties.getFeatureAsBoolean('is_southern_hemisphere').get
+    is_northern_hemisphere = !is_southern_hemisphere
+    @peak_fuels.each do |key, peak_fuel|
+      _fuel, season = key
+      if (season == PFT::Summer && is_northern_hemisphere) || (season == PFT::Winter && is_southern_hemisphere)
+        months = ['June', 'July', 'August']
+      elsif (season == PFT::Winter && is_northern_hemisphere) || (season == PFT::Summer && is_southern_hemisphere)
+        months = ['December', 'January', 'February']
+      end
+      for month in months
+        val = get_tabular_data_value(peak_fuel.report.upcase, 'Meter', 'Custom Monthly Report', [month], 'ELECTRICITY:FACILITY {Maximum}', peak_fuel.annual_units)
+        peak_fuel.annual_output = [peak_fuel.annual_output.to_f, val].max
+      end
     end
 
     # Total loads
-    @loads.each do |load_type, load|
+    @loads.each do |_load_type, load|
       if not load.ems_variable.nil?
         # Obtain from EMS output variable
         load.annual_output = get_report_variable_data_annual(['EMS'], ["#{load.ems_variable}_annual_outvar"])
-        if include_timeseries_total_loads
-          load.timeseries_output = get_report_variable_data_timeseries(['EMS'], ["#{load.ems_variable}_timeseries_outvar"], UnitConversions.convert(1.0, 'J', load.timeseries_units), 0, timeseries_frequency, ems_shift: true)
+        if args[:include_timeseries_total_loads]
+          load.timeseries_output = get_report_variable_data_timeseries(['EMS'], ["#{load.ems_variable}_timeseries_outvar"], UnitConversions.convert(1.0, 'J', load.timeseries_units), 0, args[:timeseries_frequency], ems_shift: true)
         end
       elsif load.variables.size > 0
         # Obtain from output variable
@@ -673,8 +665,8 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
           vars = load.variables.select { |v| v[0] == sys_id }.map { |v| v[2] }
 
           load.annual_output_by_system[sys_id] = get_report_variable_data_annual(keys, vars, is_negative: load.is_negative)
-          if include_timeseries_total_loads && (load_type == LT::HotWaterDelivered)
-            load.timeseries_output_by_system[sys_id] = get_report_variable_data_timeseries(keys, vars, UnitConversions.convert(1.0, 'J', load.timeseries_units), 0, timeseries_frequency, is_negative: load.is_negative, ems_shift: true)
+          if args[:include_timeseries_total_loads]
+            load.timeseries_output_by_system[sys_id] = get_report_variable_data_timeseries(keys, vars, UnitConversions.convert(1.0, 'J', load.timeseries_units), 0, args[:timeseries_frequency], is_negative: load.is_negative, ems_shift: true)
           end
         end
       end
@@ -683,26 +675,16 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
     # Component Loads
     @component_loads.each do |_key, comp_load|
       comp_load.annual_output = get_report_variable_data_annual(['EMS'], ["#{comp_load.ems_variable}_annual_outvar"])
-      if include_timeseries_component_loads
-        comp_load.timeseries_output = get_report_variable_data_timeseries(['EMS'], ["#{comp_load.ems_variable}_timeseries_outvar"], UnitConversions.convert(1.0, 'J', comp_load.timeseries_units), 0, timeseries_frequency, ems_shift: true)
+      if args[:include_timeseries_component_loads]
+        comp_load.timeseries_output = get_report_variable_data_timeseries(['EMS'], ["#{comp_load.ems_variable}_timeseries_outvar"], UnitConversions.convert(1.0, 'J', comp_load.timeseries_units), 0, args[:timeseries_frequency], ems_shift: true)
       end
     end
 
     # Unmet Hours
     @unmet_hours.each do |_key, unmet_hour|
       unmet_hour.annual_output = get_report_variable_data_annual(['EMS'], ["#{unmet_hour.ems_variable}_annual_outvar"], 1.0)
-      if include_timeseries_unmet_hours
-        unmet_hour.timeseries_output = get_report_variable_data_timeseries(['EMS'], ["#{unmet_hour.ems_variable}_timeseries_outvar"], 1.0, 0, timeseries_frequency)
-      end
-    end
-
-    # Ideal system loads (expected fraction of loads that are not met by partial HVAC (e.g., room AC that meets 30% of load))
-    @ideal_system_loads.each do |_load_type, ideal_load|
-      ideal_load.variables.map { |v| v[0] }.uniq.each do |sys_id|
-        keys = ideal_load.variables.select { |v| v[0] == sys_id }.map { |v| v[1] }
-        vars = ideal_load.variables.select { |v| v[0] == sys_id }.map { |v| v[2] }
-
-        ideal_load.annual_output = get_report_variable_data_annual(keys, vars)
+      if args[:include_timeseries_unmet_hours]
+        unmet_hour.timeseries_output = get_report_variable_data_timeseries(['EMS'], ["#{unmet_hour.ems_variable}_timeseries_outvar"], 1.0, 0, args[:timeseries_frequency])
       end
     end
 
@@ -721,10 +703,10 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
 
         end_use.annual_output_by_system[sys_id] = get_report_variable_data_annual(keys, vars, is_negative: (end_use.is_negative || end_use.is_storage))
 
-        if include_timeseries_end_use_consumptions
-          end_use.timeseries_output_by_system[sys_id] = get_report_variable_data_timeseries(keys, vars, UnitConversions.convert(1.0, 'J', end_use.timeseries_units), 0, timeseries_frequency, is_negative: (end_use.is_negative || end_use.is_storage))
+        if args[:include_timeseries_end_use_consumptions]
+          end_use.timeseries_output_by_system[sys_id] = get_report_variable_data_timeseries(keys, vars, UnitConversions.convert(1.0, 'J', end_use.timeseries_units), 0, args[:timeseries_frequency], is_negative: (end_use.is_negative || end_use.is_storage))
         end
-        if include_hourly_electric_end_use_consumptions && fuel_type == FT::Elec
+        if args[:include_hourly_electric_end_use_consumptions] && fuel_type == FT::Elec
           end_use.hourly_output_by_system[sys_id] = get_report_variable_data_timeseries(keys, vars, UnitConversions.convert(1.0, 'J', end_use.timeseries_units), 0, 'hourly', is_negative: (end_use.is_negative || end_use.is_storage))
         end
       end
@@ -734,16 +716,20 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
     # applying proportionally to the GSHP heating & cooling fan/pump energy use.
     gshp_shared_loop_end_use = @end_uses[[FT::Elec, 'TempGSHPSharedPump']]
     htg_fan_pump_end_use = @end_uses[[FT::Elec, EUT::HeatingFanPump]]
+    backup_htg_fan_pump_end_use = @end_uses[[FT::Elec, EUT::HeatingHeatPumpBackupFanPump]]
     clg_fan_pump_end_use = @end_uses[[FT::Elec, EUT::CoolingFanPump]]
     gshp_shared_loop_end_use.annual_output_by_system.keys.each do |sys_id|
       # Calculate heating & cooling fan/pump end use multiplier
-      htg_energy = htg_fan_pump_end_use.annual_output_by_system[sys_id]
-      clg_energy = clg_fan_pump_end_use.annual_output_by_system[sys_id]
+      htg_energy = htg_fan_pump_end_use.annual_output_by_system[sys_id].to_f + backup_htg_fan_pump_end_use.annual_output_by_system[sys_id].to_f
+      clg_energy = clg_fan_pump_end_use.annual_output_by_system[sys_id].to_f
       shared_pump_energy = gshp_shared_loop_end_use.annual_output_by_system[sys_id]
       energy_multiplier = (htg_energy + clg_energy + shared_pump_energy) / (htg_energy + clg_energy)
       # Apply multiplier
-      apply_multiplier_to_output(htg_fan_pump_end_use, nil, sys_id, energy_multiplier)
-      apply_multiplier_to_output(clg_fan_pump_end_use, nil, sys_id, energy_multiplier)
+      [htg_fan_pump_end_use, backup_htg_fan_pump_end_use, clg_fan_pump_end_use].each do |end_use|
+        next if end_use.annual_output_by_system[sys_id].nil?
+
+        apply_multiplier_to_output(end_use, nil, sys_id, energy_multiplier)
+      end
     end
     @end_uses.delete([FT::Elec, 'TempGSHPSharedPump'])
 
@@ -754,8 +740,8 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
         vars = hot_water.variables.select { |v| v[0] == sys_id }.map { |v| v[2] }
 
         hot_water.annual_output_by_system[sys_id] = get_report_variable_data_annual(keys, vars, UnitConversions.convert(1.0, 'm^3', hot_water.annual_units))
-        if include_timeseries_hot_water_uses
-          hot_water.timeseries_output_by_system[sys_id] = get_report_variable_data_timeseries(keys, vars, UnitConversions.convert(1.0, 'm^3', hot_water.timeseries_units), 0, timeseries_frequency)
+        if args[:include_timeseries_hot_water_uses]
+          hot_water.timeseries_output_by_system[sys_id] = get_report_variable_data_timeseries(keys, vars, UnitConversions.convert(1.0, 'm^3', hot_water.timeseries_units), 0, args[:timeseries_frequency])
         end
       end
     end
@@ -769,16 +755,13 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
 
       dse = htg_system.distribution_system.annual_heating_dse
       @fuels.each do |fuel_type, fuel|
-        [EUT::Heating, EUT::HeatingHeatPumpBackup, EUT::HeatingFanPump].each do |end_use_type|
+        [EUT::Heating, EUT::HeatingHeatPumpBackup, EUT::HeatingFanPump, EUT::HeatingHeatPumpBackupFanPump].each do |end_use_type|
           end_use = @end_uses[[fuel_type, end_use_type]]
           next if end_use.nil?
 
           if not end_use.annual_output_by_system[htg_system.id].nil?
             apply_multiplier_to_output(end_use, fuel, htg_system.id, 1.0 / dse)
           end
-          if not end_use.annual_output_by_system[htg_system.id + '_DFHPBackup'].nil?
-            apply_multiplier_to_output(end_use, fuel, htg_system.id + '_DFHPBackup', 1.0 / dse)
-          end
         end
       end
     end
@@ -817,6 +800,30 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
       end
     end
 
+    # Calculate System Uses from End Uses (by HPXML System)
+    @system_uses = {}
+    get_hpxml_system_ids.each do |sys_id|
+      @end_uses.each do |eu_key, end_use|
+        annual_output = end_use.annual_output_by_system[sys_id].to_f
+        next if annual_output <= 0
+
+        system_use_output = BaseOutput.new
+        @system_uses[[sys_id, eu_key]] = system_use_output
+        fuel_type, end_use_type = eu_key
+        system_use_output.name = "System Use: #{sys_id}: #{fuel_type}: #{end_use_type}"
+
+        # Annual
+        system_use_output.annual_output = annual_output
+        system_use_output.annual_units = end_use.annual_units
+
+        next unless args[:include_timeseries_system_use_consumptions]
+
+        # Timeseries
+        system_use_output.timeseries_output = end_use.timeseries_output_by_system[sys_id]
+        system_use_output.timeseries_units = end_use.timeseries_units
+      end
+    end
+
     # Calculate aggregated values from per-system values as needed
     (@end_uses.values + @loads.values + @hot_water_uses.values).each do |obj|
       # Annual
@@ -830,29 +837,22 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
 
       # Timeseries
       if obj.timeseries_output.empty? && (not obj.timeseries_output_by_system.empty?)
-        obj.timeseries_output = obj.timeseries_output_by_system.values[0]
-        obj.timeseries_output_by_system.values[1..-1].each do |values|
-          obj.timeseries_output = obj.timeseries_output.zip(values).map { |x, y| x + y }
-        end
+        obj.timeseries_output = obj.timeseries_output_by_system.values.transpose.map(&:sum)
       end
 
       # Hourly Electricity (for Cambium)
       next unless obj.is_a?(EndUse) && obj.hourly_output.empty? && (not obj.hourly_output_by_system.empty?)
 
-      obj.hourly_output = obj.hourly_output_by_system.values[0]
-      obj.hourly_output_by_system.values[1..-1].each do |values|
-        obj.hourly_output = obj.hourly_output.zip(values).map { |x, y| x + y }
-      end
+      obj.hourly_output = obj.hourly_output_by_system.values.transpose.map(&:sum)
     end
 
     # Total/Net Electricity (Net includes, e.g., PV and generators)
     outputs[:elec_prod_annual] = @end_uses.select { |k, eu| k[0] == FT::Elec && eu.is_negative }.map { |_k, eu| eu.annual_output.to_f }.sum(0.0) # Negative value
     outputs[:elec_net_annual] = @fuels[FT::Elec].annual_output.to_f + outputs[:elec_prod_annual]
-    if include_timeseries_fuel_consumptions
-      outputs[:elec_prod_timeseries] = [0.0] * @timestamps.size # Negative values
-      @end_uses.select { |k, eu| k[0] == FT::Elec && eu.is_negative && eu.timeseries_output.size > 0 }.each do |_key, end_use|
-        outputs[:elec_prod_timeseries] = outputs[:elec_prod_timeseries].zip(end_use.timeseries_output).map { |x, y| x + y }
-      end
+    if args[:include_timeseries_fuel_consumptions]
+      prod_end_uses = @end_uses.select { |k, eu| k[0] == FT::Elec && eu.is_negative && eu.timeseries_output.size > 0 }.map { |_k, v| v.timeseries_output }
+      outputs[:elec_prod_timeseries] = prod_end_uses.transpose.map(&:sum)
+      outputs[:elec_prod_timeseries] = [0.0] * @timestamps.size if outputs[:elec_prod_timeseries].empty?
       outputs[:elec_net_timeseries] = @fuels[FT::Elec].timeseries_output.zip(outputs[:elec_prod_timeseries]).map { |x, y| x + y }
     end
 
@@ -860,20 +860,20 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
     @totals[TE::Total].annual_output = 0.0
     @fuels.each do |_fuel_type, fuel|
       @totals[TE::Total].annual_output += fuel.annual_output
-      next unless include_timeseries_total_consumptions && fuel.timeseries_output.sum != 0.0
+      next unless args[:include_timeseries_total_consumptions] && fuel.timeseries_output.sum != 0.0
 
       @totals[TE::Total].timeseries_output = [0.0] * @timestamps.size if @totals[TE::Total].timeseries_output.empty?
       unit_conv = UnitConversions.convert(1.0, fuel.timeseries_units, @totals[TE::Total].timeseries_units)
       @totals[TE::Total].timeseries_output = @totals[TE::Total].timeseries_output.zip(fuel.timeseries_output).map { |x, y| x + y * unit_conv }
     end
     @totals[TE::Net].annual_output = @totals[TE::Total].annual_output + outputs[:elec_prod_annual]
-    if include_timeseries_total_consumptions
+    if args[:include_timeseries_total_consumptions]
       unit_conv = UnitConversions.convert(1.0, get_timeseries_units_from_fuel_type(FT::Elec), @totals[TE::Total].timeseries_units)
       @totals[TE::Net].timeseries_output = @totals[TE::Total].timeseries_output.zip(outputs[:elec_prod_timeseries]).map { |x, y| x + y * unit_conv }
     end
 
     # Zone temperatures
-    if include_timeseries_zone_temperatures
+    if args[:include_timeseries_zone_temperatures]
       zone_names = []
       scheduled_temperature_names = []
       @model.getThermalZones.each do |zone|
@@ -891,32 +891,32 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
         @zone_temps[zone_name] = ZoneTemp.new
         @zone_temps[zone_name].name = "Temperature: #{zone_name.split.map(&:capitalize).join(' ')}"
         @zone_temps[zone_name].timeseries_units = 'F'
-        @zone_temps[zone_name].timeseries_output = get_report_variable_data_timeseries([zone_name], ['Zone Mean Air Temperature'], 9.0 / 5.0, 32.0, timeseries_frequency)
+        @zone_temps[zone_name].timeseries_output = get_report_variable_data_timeseries([zone_name], ['Zone Mean Air Temperature'], 9.0 / 5.0, 32.0, args[:timeseries_frequency])
       end
       scheduled_temperature_names.sort.each do |scheduled_temperature_name|
         @zone_temps[scheduled_temperature_name] = ZoneTemp.new
         @zone_temps[scheduled_temperature_name].name = "Temperature: #{scheduled_temperature_name.split.map(&:capitalize).join(' ')}"
         @zone_temps[scheduled_temperature_name].timeseries_units = 'F'
-        @zone_temps[scheduled_temperature_name].timeseries_output = get_report_variable_data_timeseries([scheduled_temperature_name], ['Schedule Value'], 9.0 / 5.0, 32.0, timeseries_frequency)
+        @zone_temps[scheduled_temperature_name].timeseries_output = get_report_variable_data_timeseries([scheduled_temperature_name], ['Schedule Value'], 9.0 / 5.0, 32.0, args[:timeseries_frequency])
       end
       { 'Heating Setpoint' => 'Zone Thermostat Heating Setpoint Temperature',
         'Cooling Setpoint' => 'Zone Thermostat Cooling Setpoint Temperature' }.each do |sp_name, sp_var|
         @zone_temps[sp_name] = ZoneTemp.new
         @zone_temps[sp_name].name = "Temperature: #{sp_name}"
         @zone_temps[sp_name].timeseries_units = 'F'
-        @zone_temps[sp_name].timeseries_output = get_report_variable_data_timeseries([HPXML::LocationLivingSpace.upcase], [sp_var], 9.0 / 5.0, 32.0, timeseries_frequency)
+        @zone_temps[sp_name].timeseries_output = get_report_variable_data_timeseries([HPXML::LocationLivingSpace.upcase], [sp_var], 9.0 / 5.0, 32.0, args[:timeseries_frequency])
       end
     end
 
     # Airflows
-    if include_timeseries_airflows
+    if args[:include_timeseries_airflows]
       @airflows.each do |_airflow_type, airflow|
-        airflow.timeseries_output = get_report_variable_data_timeseries(['EMS'], airflow.ems_variables.map { |var| "#{var}_timeseries_outvar" }, UnitConversions.convert(1.0, 'm^3/s', 'cfm'), 0, timeseries_frequency)
+        airflow.timeseries_output = get_report_variable_data_timeseries(['EMS'], airflow.ems_variables.map { |var| "#{var}_timeseries_outvar" }, UnitConversions.convert(1.0, 'm^3/s', 'cfm'), 0, args[:timeseries_frequency])
       end
     end
 
     # Weather
-    if include_timeseries_weather
+    if args[:include_timeseries_weather]
       @weather.each do |_weather_type, weather_data|
         if weather_data.timeseries_units == 'F'
           unit_conv = 9.0 / 5.0
@@ -925,7 +925,7 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
           unit_conv = UnitConversions.convert(1.0, weather_data.variable_units, weather_data.timeseries_units)
           unit_adder = 0
         end
-        weather_data.timeseries_output = get_report_variable_data_timeseries(['Environment'], [weather_data.variable], unit_conv, unit_adder, timeseries_frequency)
+        weather_data.timeseries_output = get_report_variable_data_timeseries(['Environment'], [weather_data.variable], unit_conv, unit_adder, args[:timeseries_frequency])
       end
     end
 
@@ -937,7 +937,7 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
         @output_variables[[output_variable_name, key_value]] = OutputVariable.new
         @output_variables[[output_variable_name, key_value]].name = "#{output_variable_name}: #{key_value.split.map(&:capitalize).join(' ')}"
         @output_variables[[output_variable_name, key_value]].timeseries_units = units
-        @output_variables[[output_variable_name, key_value]].timeseries_output = get_report_variable_data_timeseries([key_value], [output_variable_name], 1, 0, timeseries_frequency)
+        @output_variables[[output_variable_name, key_value]].timeseries_output = get_report_variable_data_timeseries([key_value], [output_variable_name], 1, 0, args[:timeseries_frequency])
       end
     end
 
@@ -996,22 +996,18 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
           end
           @emissions[key].annual_output_by_end_use[eu_key] = hourly_elec.zip(hourly_elec_factors).map { |x, y| x * y * kwh_to_mwh * elec_units_mult }.sum
 
-          next unless include_timeseries_emissions || include_timeseries_emission_end_uses || include_timeseries_emission_fuels
+          next unless args[:include_timeseries_emissions] || args[:include_timeseries_emission_end_uses] || args[:include_timeseries_emission_fuels]
 
           # Calculate timeseries emissions for end use
 
-          if timeseries_frequency == 'timestep' && @hpxml.header.timestep != 60
-            timeseries_elec = nil
-            end_use.timeseries_output_by_system.each do |_sys_id, timeseries_output|
-              timeseries_elec = [0.0] * timeseries_output.size if timeseries_elec.nil?
-              timeseries_elec = timeseries_elec.zip(timeseries_output.map { |x| x * kwh_to_mwh }).map { |x, y| x + y }
-            end
+          if args[:timeseries_frequency] == 'timestep' && @hpxml.header.timestep != 60
+            timeseries_elec = end_use.timeseries_output_by_system.values.transpose.map(&:sum).map { |x| x * kwh_to_mwh }
           else
             # Need to perform calculations hourly at a minimum
             timeseries_elec = end_use.hourly_output.map { |x| x * kwh_to_mwh }
           end
 
-          if timeseries_frequency == 'timestep'
+          if args[:timeseries_frequency] == 'timestep'
             n_timesteps_per_hour = Integer(60.0 / @hpxml.header.timestep)
             timeseries_elec_factors = hourly_elec_factors.flat_map { |y| [y] * n_timesteps_per_hour }
           else
@@ -1022,11 +1018,11 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
           @emissions[key].timeseries_output_by_end_use[eu_key] = timeseries_elec.zip(timeseries_elec_factors).map { |n, f| n * f * elec_units_mult }
 
           # Aggregate up from hourly to the desired timeseries frequency
-          next unless ['daily', 'monthly'].include? timeseries_frequency
+          next unless ['daily', 'monthly'].include? args[:timeseries_frequency]
 
-          if timeseries_frequency == 'daily'
+          if args[:timeseries_frequency] == 'daily'
             n_hours_per_period = [24] * (sim_end_day_of_year - sim_start_day_of_year + 1)
-          elsif timeseries_frequency == 'monthly'
+          elsif args[:timeseries_frequency] == 'monthly'
             n_days_per_month = Constants.NumDaysInMonths(year)
             n_days_per_period = n_days_per_month[@hpxml.header.sim_begin_month - 1..@hpxml.header.sim_end_month - 1]
             n_days_per_period[0] -= @hpxml.header.sim_begin_day - 1
@@ -1069,41 +1065,45 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
           end
 
           @emissions[key].annual_output_by_end_use[eu_key] = UnitConversions.convert(end_use.annual_output, end_use.annual_units, 'MBtu') * fuel_factor * fuel_units_mult
-          next unless include_timeseries_emissions || include_timeseries_emission_end_uses || include_timeseries_emission_fuels
+          next unless args[:include_timeseries_emissions] || args[:include_timeseries_emission_end_uses] || args[:include_timeseries_emission_fuels]
 
           fuel_to_mbtu = UnitConversions.convert(1.0, end_use.timeseries_units, 'MBtu')
-
-          end_use.timeseries_output_by_system.each do |_sys_id, timeseries_output|
-            @emissions[key].timeseries_output_by_end_use[eu_key] = [0.0] * timeseries_output.size if @emissions[key].timeseries_output_by_end_use[eu_key].nil?
-            @emissions[key].timeseries_output_by_end_use[eu_key] = @emissions[key].timeseries_output_by_end_use[eu_key].zip(timeseries_output.map { |f| f * fuel_to_mbtu * fuel_factor * fuel_units_mult }).map { |x, y| x + y }
-          end
+          @emissions[key].timeseries_output_by_end_use[eu_key] = end_use.timeseries_output_by_system.values.transpose.map(&:sum).map { |f| f * fuel_to_mbtu * fuel_factor * fuel_units_mult }
         end
 
         # Roll up end use emissions to fuel emissions
         @fuels.each do |fuel_type, _fuel|
-          @emissions[key].annual_output_by_fuel[fuel_type] = 0.0
-          @emissions[key].annual_output_by_end_use.keys.each do |eu_key|
-            next unless eu_key[0] == fuel_type
-            next if @emissions[key].annual_output_by_end_use[eu_key] == 0
+          if fuel_type == FT::Elec
+            emission_types = [TE::Total, TE::Net]
+          else
+            emission_types = [TE::Total]
+          end
+          emission_types.each do |emission_type|
+            fuel_key = [fuel_type, emission_type]
+            @emissions[key].annual_output_by_fuel[fuel_key] = 0.0
+            @emissions[key].annual_output_by_end_use.keys.each do |eu_key|
+              next unless eu_key[0] == fuel_type
+              next if emission_type == TE::Total && @end_uses[eu_key].is_negative # Generation not included in total
+              next if @emissions[key].annual_output_by_end_use[eu_key] == 0
 
-            @emissions[key].annual_output_by_fuel[fuel_type] += @emissions[key].annual_output_by_end_use[eu_key]
+              @emissions[key].annual_output_by_fuel[fuel_key] += @emissions[key].annual_output_by_end_use[eu_key]
 
-            next unless include_timeseries_emissions || include_timeseries_emission_end_uses || include_timeseries_emission_fuels
+              next unless args[:include_timeseries_emissions] || args[:include_timeseries_emission_fuels]
 
-            @emissions[key].timeseries_output_by_fuel[fuel_type] = [0.0] * @emissions[key].timeseries_output_by_end_use[eu_key].size if @emissions[key].timeseries_output_by_fuel[fuel_type].nil?
-            @emissions[key].timeseries_output_by_fuel[fuel_type] = @emissions[key].timeseries_output_by_fuel[fuel_type].zip(@emissions[key].timeseries_output_by_end_use[eu_key]).map { |x, y| x + y }
+              @emissions[key].timeseries_output_by_fuel[fuel_key] = [0.0] * @emissions[key].timeseries_output_by_end_use[eu_key].size if @emissions[key].timeseries_output_by_fuel[fuel_key].nil?
+              @emissions[key].timeseries_output_by_fuel[fuel_key] = @emissions[key].timeseries_output_by_fuel[fuel_key].zip(@emissions[key].timeseries_output_by_end_use[eu_key]).map { |x, y| x + y }
+            end
           end
         end
 
-        # Sum individual fuel results for total
-        @emissions[key].annual_output = @emissions[key].annual_output_by_fuel.values.sum()
-        next unless not @emissions[key].timeseries_output_by_fuel.empty?
-
-        @emissions[key].timeseries_output = @emissions[key].timeseries_output_by_fuel.first[1]
-        @emissions[key].timeseries_output_by_fuel.each_with_index do |(_fuel, timeseries_output), i|
-          next if i == 0
-
-          @emissions[key].timeseries_output = @emissions[key].timeseries_output.zip(timeseries_output).map { |x, y| x + y }
+        # Sum individual fuel results for total/net
+        total_keys = @emissions[key].annual_output_by_fuel.keys.select { |k| k[0] != FT::Elec || (k[0] == FT::Elec && k[1] == TE::Total) }
+        net_keys = @emissions[key].annual_output_by_fuel.keys.select { |k| k[0] != FT::Elec || (k[0] == FT::Elec && k[1] == TE::Net) }
+        @emissions[key].annual_output = @emissions[key].annual_output_by_fuel.select { |k, _v| total_keys.include? k }.values.sum()
+        @emissions[key].net_annual_output = @emissions[key].annual_output_by_fuel.select { |k, _v| net_keys.include? k }.values.sum()
+        if args[:include_timeseries_emissions]
+          @emissions[key].timeseries_output = @emissions[key].timeseries_output_by_fuel.select { |k, _v| total_keys.include? k }.values.transpose.map(&:sum)
+          @emissions[key].net_timeseries_output = @emissions[key].timeseries_output_by_fuel.select { |k, _v| net_keys.include? k }.values.transpose.map(&:sum)
         end
       end
     end
@@ -1137,8 +1137,7 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
 
     # Check if simulation successful
     all_total = @fuels.values.map { |x| x.annual_output.to_f }.sum(0.0)
-    all_total += @ideal_system_loads.values.map { |x| x.annual_output.to_f }.sum(0.0)
-    if all_total == 0
+    if (all_total == 0) && (@hpxml.total_fraction_cool_load_served + @hpxml.total_fraction_heat_load_served > 0)
       runner.registerError('Simulation unsuccessful.')
       return false
     elsif all_total.infinite?
@@ -1169,6 +1168,7 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
     # Check sum of timeseries outputs match annual outputs
     { @totals => 'Total',
       @end_uses => 'End Use',
+      @system_uses => 'System Use',
       @fuels => 'Fuel',
       @emissions => 'Emissions',
       @loads => 'Load',
@@ -1188,80 +1188,161 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
     return true
   end
 
-  def report_runperiod_output_results(runner, outputs, output_format, annual_output_path, n_digits, generate_eri_outputs)
+  def report_runperiod_output_results(runner, outputs, args, annual_output_path)
+    # Set rounding precision for run period (e.g., annual) outputs.
+    if args[:output_format] == 'msgpack'
+      # No need to round; no file size penalty to storing full precision
+      n_digits = 100
+    else
+      # Note: Make sure to round outputs with sufficient resolution for the worst case -- i.e., 1 day instead of a full year.
+      n_digits = 3 # Default for annual (or near-annual) data
+      sim_n_days = (Schedule.get_day_num_from_month_day(2000, @hpxml.header.sim_end_month, @hpxml.header.sim_end_day) -
+                    Schedule.get_day_num_from_month_day(2000, @hpxml.header.sim_begin_month, @hpxml.header.sim_begin_day))
+      if sim_n_days <= 10 # 10 days or less; add two decimal places
+        n_digits += 2
+      elsif sim_n_days <= 100 # 100 days or less; add one decimal place
+        n_digits += 1
+      end
+    end
+
     line_break = nil
 
     results_out = []
-    @totals.each do |_energy_type, total_energy|
-      results_out << ["#{total_energy.name} (#{total_energy.annual_units})", total_energy.annual_output.to_f.round(n_digits)]
+
+    # Totals
+    if args[:include_annual_total_consumptions]
+      @totals.each do |_energy_type, total_energy|
+        results_out << ["#{total_energy.name} (#{total_energy.annual_units})", total_energy.annual_output.to_f.round(n_digits)]
+      end
+      results_out << [line_break]
     end
-    results_out << [line_break]
-    @fuels.each do |fuel_type, fuel|
-      results_out << ["#{fuel.name} (#{fuel.annual_units})", fuel.annual_output.to_f.round(n_digits)]
-      if fuel_type == FT::Elec
-        results_out << ['Fuel Use: Electricity: Net (MBtu)', outputs[:elec_net_annual].round(n_digits)]
+
+    # Fuels
+    if args[:include_annual_fuel_consumptions]
+      @fuels.each do |fuel_type, fuel|
+        results_out << ["#{fuel.name} (#{fuel.annual_units})", fuel.annual_output.to_f.round(n_digits)]
+        if fuel_type == FT::Elec
+          results_out << ['Fuel Use: Electricity: Net (MBtu)', outputs[:elec_net_annual].round(n_digits)]
+        end
       end
+      results_out << [line_break]
     end
-    results_out << [line_break]
-    @end_uses.each do |_key, end_use|
-      results_out << ["#{end_use.name} (#{end_use.annual_units})", end_use.annual_output.to_f.round(n_digits)]
+
+    # End uses
+    if args[:include_annual_end_use_consumptions]
+      @end_uses.each do |_key, end_use|
+        results_out << ["#{end_use.name} (#{end_use.annual_units})", end_use.annual_output.to_f.round(n_digits)]
+      end
+      results_out << [line_break]
     end
-    if not @emissions.empty?
+
+    # System uses
+    if args[:include_annual_system_use_consumptions]
+      @system_uses.each do |_key, system_use|
+        results_out << ["#{system_use.name} (#{system_use.annual_units})", system_use.annual_output.round(n_digits)]
+      end
       results_out << [line_break]
-      @emissions.each do |_scenario_key, emission|
-        # Emissions total
-        results_out << ["#{emission.name}: Total (#{emission.annual_units})", emission.annual_output.to_f.round(2)]
-        # Emissions by fuel
-        emission.annual_output_by_fuel.each do |fuel, annual_output|
-          next if annual_output.to_f == 0
-
-          results_out << ["#{emission.name}: #{fuel}: Total (#{emission.annual_units})", annual_output.to_f.round(2)]
-          # Emissions by end use
-          emission.annual_output_by_end_use.each do |key, eu_annual_output|
-            fuel_type, end_use_type = key
-            next unless fuel_type == fuel
-            next if eu_annual_output.to_f == 0
-
-            results_out << ["#{emission.name}: #{fuel_type}: #{end_use_type} (#{emission.annual_units})", eu_annual_output.to_f.round(2)]
+    end
+
+    # Total Emissions
+    if args[:include_annual_emissions]
+      if not @emissions.empty?
+        @emissions.each do |_scenario_key, emission|
+          results_out << ["#{emission.name}: Total (#{emission.annual_units})", emission.annual_output.to_f.round(n_digits - 1)]
+          results_out << ["#{emission.name}: Net (#{emission.annual_units})", emission.net_annual_output.to_f.round(n_digits - 1)]
+        end
+        results_out << [line_break]
+      end
+    end
+
+    # Fuel Emissions
+    if args[:include_annual_emission_fuels]
+      if not @emissions.empty?
+        @emissions.each do |_scenario_key, emission|
+          emission.annual_output_by_fuel.keys.each do |fuel_key|
+            fuel, emission_type = fuel_key
+            results_out << ["#{emission.name}: #{fuel}: #{emission_type} (#{emission.annual_units})", emission.annual_output_by_fuel[fuel_key].to_f.round(n_digits - 1)]
           end
         end
+        results_out << [line_break]
       end
     end
-    results_out << [line_break]
-    @loads.each do |_load_type, load|
-      results_out << ["#{load.name} (#{load.annual_units})", load.annual_output.to_f.round(n_digits)]
+
+    # End Use Emissions
+    if args[:include_annual_emission_end_uses]
+      if not @emissions.empty?
+        @emissions.each do |_scenario_key, emission|
+          @fuels.keys.each do |fuel|
+            @end_uses.keys.each do |key|
+              fuel_type, end_use_type = key
+              next unless fuel_type == fuel
+
+              results_out << ["#{emission.name}: #{fuel_type}: #{end_use_type} (#{emission.annual_units})", emission.annual_output_by_end_use[key].to_f.round(n_digits - 1)]
+            end
+          end
+        end
+        results_out << [line_break]
+      end
     end
-    results_out << [line_break]
-    @unmet_hours.each do |_load_type, unmet_hour|
-      results_out << ["#{unmet_hour.name} (#{unmet_hour.annual_units})", unmet_hour.annual_output.to_f.round(n_digits)]
+
+    # Loads
+    if args[:include_annual_total_loads]
+      @loads.each do |_load_type, load|
+        results_out << ["#{load.name} (#{load.annual_units})", load.annual_output.to_f.round(n_digits)]
+      end
+      results_out << [line_break]
     end
-    results_out << [line_break]
-    @peak_fuels.each do |_key, peak_fuel|
-      results_out << ["#{peak_fuel.name} (#{peak_fuel.annual_units})", peak_fuel.annual_output.to_f.round(n_digits - 2)]
+
+    # Unmet hours
+    if args[:include_annual_unmet_hours]
+      @unmet_hours.each do |_load_type, unmet_hour|
+        results_out << ["#{unmet_hour.name} (#{unmet_hour.annual_units})", unmet_hour.annual_output.to_f.round(n_digits)]
+      end
+      results_out << [line_break]
     end
-    results_out << [line_break]
-    @peak_loads.each do |_load_type, peak_load|
-      results_out << ["#{peak_load.name} (#{peak_load.annual_units})", peak_load.annual_output.to_f.round(n_digits)]
+
+    # Peak fuels
+    if args[:include_annual_peak_fuels]
+      @peak_fuels.each do |_key, peak_fuel|
+        results_out << ["#{peak_fuel.name} (#{peak_fuel.annual_units})", peak_fuel.annual_output.to_f.round(n_digits - 2)]
+      end
+      results_out << [line_break]
     end
-    if @component_loads.values.map { |load| load.annual_output.to_f }.sum != 0 # Skip if component loads not calculated
+
+    # Peak loads
+    if args[:include_annual_peak_loads]
+      @peak_loads.each do |_load_type, peak_load|
+        results_out << ["#{peak_load.name} (#{peak_load.annual_units})", peak_load.annual_output.to_f.round(n_digits)]
+      end
       results_out << [line_break]
-      @component_loads.each do |_load_type, load|
-        results_out << ["#{load.name} (#{load.annual_units})", load.annual_output.to_f.round(n_digits)]
+    end
+
+    # Component loads
+    if args[:include_annual_component_loads]
+      if @component_loads.values.map { |load| load.annual_output.to_f }.sum != 0 # Skip if component loads not calculated
+        @component_loads.each do |_load_type, load|
+          results_out << ["#{load.name} (#{load.annual_units})", load.annual_output.to_f.round(n_digits)]
+        end
+        results_out << [line_break]
       end
     end
-    results_out << [line_break]
-    @hot_water_uses.each do |_hot_water_type, hot_water|
-      results_out << ["#{hot_water.name} (#{hot_water.annual_units})", hot_water.annual_output.to_f.round(n_digits - 2)]
+
+    # Hot water uses
+    if args[:include_annual_hot_water_uses]
+      @hot_water_uses.each do |_hot_water_type, hot_water|
+        results_out << ["#{hot_water.name} (#{hot_water.annual_units})", hot_water.annual_output.to_f.round(n_digits - 2)]
+      end
+      results_out << [line_break]
     end
 
-    results_out = append_sizing_results(results_out, line_break)
-    if generate_eri_outputs
-      results_out = append_eri_results(results_out, line_break)
+    # Sizing data
+    if args[:include_annual_hvac_summary]
+      results_out = append_sizing_results(results_out, line_break)
     end
 
-    if ['csv'].include? output_format
+    if ['csv'].include? args[:output_format]
       CSV.open(annual_output_path, 'wb') { |csv| results_out.to_a.each { |elem| csv << elem } }
-    elsif ['json', 'msgpack'].include? output_format
+    elsif ['json', 'msgpack'].include? args[:output_format]
       h = {}
       results_out.each do |out|
         next if out == [line_break]
@@ -1271,10 +1352,10 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
         h[grp][name.strip] = out[1]
       end
 
-      if output_format == 'json'
+      if args[:output_format] == 'json'
         require 'json'
         File.open(annual_output_path, 'w') { |json| json.write(JSON.pretty_generate(h)) }
-      elsif output_format == 'msgpack'
+      elsif args[:output_format] == 'msgpack'
         File.open(annual_output_path, 'w') { |json| h.to_msgpack(json) }
       end
     end
@@ -1290,10 +1371,6 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
     end
   end
 
-  def get_runner_output_name(name, annual_units)
-    return "#{name} #{annual_units}"
-  end
-
   def append_sizing_results(results_out, line_break)
     # Summary HVAC capacities
     htg_cap, clg_cap, hp_backup_cap = 0.0, 0.0, 0.0
@@ -1317,15 +1394,14 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
         end
       end
     end
-    results_out << [line_break]
     results_out << ['HVAC Capacity: Heating (Btu/h)', htg_cap.round(1)]
     results_out << ['HVAC Capacity: Cooling (Btu/h)', clg_cap.round(1)]
     results_out << ['HVAC Capacity: Heat Pump Backup (Btu/h)', hp_backup_cap.round(1)]
 
     # HVAC design temperatures
     results_out << [line_break]
-    results_out << ['HVAC Design Temperature: Heating (F)', @hpxml.hvac_plant.temp_heating.round(2)]
-    results_out << ['HVAC Design Temperature: Cooling (F)', @hpxml.hvac_plant.temp_cooling.round(2)]
+    results_out << ['HVAC Design Temperature: Heating (F)', @hpxml.header.manualj_heating_design_temp.round(2)]
+    results_out << ['HVAC Design Temperature: Cooling (F)', @hpxml.header.manualj_cooling_design_temp.round(2)]
 
     # HVAC design loads
     results_out << [line_break]
@@ -1360,342 +1436,56 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
     return results_out
   end
 
-  def append_eri_results(results_out, line_break)
-    def ordered_values(hash, sys_ids)
-      vals = []
-      sys_ids.each do |sys_id|
-        if not hash[sys_id].nil?
-          if hash[sys_id].is_a? Float
-            vals << hash[sys_id].round(3)
-          else
-            vals << hash[sys_id]
-          end
-        else
-          vals << 0.0
-        end
-      end
-      return if vals.empty?
-
-      return vals.join(',')
-    end
-
-    def get_eec_value_numerator(unit)
-      if ['HSPF', 'HSPF2', 'SEER', 'SEER2', 'EER', 'CEER'].include? unit
-        return 3.413
-      elsif ['AFUE', 'COP', 'Percent', 'EF'].include? unit
-        return 1.0
-      end
-    end
-
-    def get_ids(ids, seed_id_map = {})
-      new_ids = ids.map { |id| seed_id_map[id].nil? ? id : seed_id_map[id] }
-      return if new_ids.empty?
-
-      return new_ids.join(',')
-    end
-
-    # Retrieve info from HPXML object
-    htg_ids, clg_ids, dhw_ids, prehtg_ids, preclg_ids = [], [], [], [], []
-    htg_eecs, clg_eecs, dhw_eecs, prehtg_eecs, preclg_eecs = {}, {}, {}, {}, {}
-    htg_fuels, clg_fuels, dhw_fuels, prehtg_fuels, preclg_fuels = {}, {}, {}, {}, {}
-    htg_seed_id_map, clg_seed_id_map = {}, {}
-    @hpxml.heating_systems.each do |htg_system|
-      next unless htg_system.fraction_heat_load_served > 0
-
-      htg_ids << htg_system.id
-      htg_seed_id_map[htg_system.id] = htg_system.htg_seed_id
-      htg_fuels[htg_system.id] = htg_system.heating_system_fuel
-      if not htg_system.heating_efficiency_afue.nil?
-        htg_eecs[htg_system.id] = get_eec_value_numerator('AFUE') / htg_system.heating_efficiency_afue
-      elsif not htg_system.heating_efficiency_percent.nil?
-        htg_eecs[htg_system.id] = get_eec_value_numerator('Percent') / htg_system.heating_efficiency_percent
-      end
-    end
-    @hpxml.cooling_systems.each do |clg_system|
-      if clg_system.has_integrated_heating && clg_system.integrated_heating_system_fraction_heat_load_served > 0
-        # Cooling system w/ integrated heating (e.g., Room AC w/ electric resistance heating)
-        htg_ids << clg_system.id
-        htg_seed_id_map[clg_system.id] = clg_system.htg_seed_id
-        htg_fuels[clg_system.id] = clg_system.integrated_heating_system_fuel
-        htg_eecs[clg_system.id] = get_eec_value_numerator('Percent') / clg_system.integrated_heating_system_efficiency_percent
-      end
-
-      next unless clg_system.fraction_cool_load_served > 0
-
-      clg_ids << clg_system.id
-      clg_seed_id_map[clg_system.id] = clg_system.clg_seed_id
-      clg_fuels[clg_system.id] = clg_system.cooling_system_fuel
-      if not clg_system.cooling_efficiency_seer.nil?
-        clg_eecs[clg_system.id] = get_eec_value_numerator('SEER') / clg_system.cooling_efficiency_seer
-      elsif not clg_system.cooling_efficiency_seer2.nil?
-        clg_eecs[clg_system.id] = get_eec_value_numerator('SEER2') / clg_system.cooling_efficiency_seer2
-      elsif not clg_system.cooling_efficiency_eer.nil?
-        clg_eecs[clg_system.id] = get_eec_value_numerator('EER') / clg_system.cooling_efficiency_eer
-      elsif not clg_system.cooling_efficiency_ceer.nil?
-        clg_eecs[clg_system.id] = get_eec_value_numerator('CEER') / clg_system.cooling_efficiency_ceer
-      end
-      if clg_system.cooling_system_type == HPXML::HVACTypeEvaporativeCooler
-        clg_eecs[clg_system.id] = get_eec_value_numerator('SEER') / 15.0 # Arbitrary
-      end
-    end
-    @hpxml.heat_pumps.each do |heat_pump|
-      if heat_pump.fraction_heat_load_served > 0
-        htg_ids << heat_pump.id
-        htg_seed_id_map[heat_pump.id] = heat_pump.htg_seed_id
-        htg_fuels[heat_pump.id] = heat_pump.heat_pump_fuel
-        if not heat_pump.heating_efficiency_hspf.nil?
-          htg_eecs[heat_pump.id] = get_eec_value_numerator('HSPF') / heat_pump.heating_efficiency_hspf
-        elsif not heat_pump.heating_efficiency_hspf2.nil?
-          htg_eecs[heat_pump.id] = get_eec_value_numerator('HSPF2') / heat_pump.heating_efficiency_hspf2
-        elsif not heat_pump.heating_efficiency_cop.nil?
-          htg_eecs[heat_pump.id] = get_eec_value_numerator('COP') / heat_pump.heating_efficiency_cop
-        end
-      end
-      next unless heat_pump.fraction_cool_load_served > 0
-
-      clg_ids << heat_pump.id
-      clg_seed_id_map[heat_pump.id] = heat_pump.clg_seed_id
-      clg_fuels[heat_pump.id] = heat_pump.heat_pump_fuel
-      if not heat_pump.cooling_efficiency_seer.nil?
-        clg_eecs[heat_pump.id] = get_eec_value_numerator('SEER') / heat_pump.cooling_efficiency_seer
-      elsif not heat_pump.cooling_efficiency_seer2.nil?
-        clg_eecs[heat_pump.id] = get_eec_value_numerator('SEER2') / heat_pump.cooling_efficiency_seer2
-      elsif not heat_pump.cooling_efficiency_eer.nil?
-        clg_eecs[heat_pump.id] = get_eec_value_numerator('EER') / heat_pump.cooling_efficiency_eer
-      end
-    end
-    @hpxml.water_heating_systems.each do |dhw_system|
-      dhw_ids << dhw_system.id
-      ef_or_uef = nil
-      ef_or_uef = dhw_system.energy_factor unless dhw_system.energy_factor.nil?
-      ef_or_uef = dhw_system.uniform_energy_factor unless dhw_system.uniform_energy_factor.nil?
-      if ef_or_uef.nil?
-        # Get assumed EF for combi system
-        @model.getWaterHeaterMixeds.each do |wh|
-          dhw_id = wh.additionalProperties.getFeatureAsString('HPXML_ID')
-          next unless (dhw_id.is_initialized && dhw_id.get == dhw_system.id)
-
-          ef_or_uef = wh.additionalProperties.getFeatureAsDouble('EnergyFactor').get
-        end
-      end
-      value_adj = 1.0
-      value_adj = dhw_system.performance_adjustment if dhw_system.water_heater_type == HPXML::WaterHeaterTypeTankless
-      if (not ef_or_uef.nil?) && (not value_adj.nil?)
-        dhw_eecs[dhw_system.id] = get_eec_value_numerator('EF') / (Float(ef_or_uef) * Float(value_adj))
-      end
-      if [HPXML::WaterHeaterTypeCombiTankless, HPXML::WaterHeaterTypeCombiStorage].include? dhw_system.water_heater_type
-        dhw_fuels[dhw_system.id] = dhw_system.related_hvac_system.heating_system_fuel
-      else
-        dhw_fuels[dhw_system.id] = dhw_system.fuel_type
-      end
-    end
-    @hpxml.ventilation_fans.each do |vent_fan|
-      next unless vent_fan.used_for_whole_building_ventilation
-      next if vent_fan.is_cfis_supplemental_fan?
-
-      if not vent_fan.preheating_fuel.nil?
-        prehtg_ids << vent_fan.id
-        prehtg_fuels[vent_fan.id] = vent_fan.preheating_fuel
-        prehtg_eecs[vent_fan.id] = get_eec_value_numerator('COP') / vent_fan.preheating_efficiency_cop
-      end
-      next unless not vent_fan.precooling_fuel.nil?
-
-      preclg_ids << vent_fan.id
-      preclg_fuels[vent_fan.id] = vent_fan.precooling_fuel
-      preclg_eecs[vent_fan.id] = get_eec_value_numerator('COP') / vent_fan.precooling_efficiency_cop
-    end
-
-    # Apportion ERI Reference loads to systems
-    (@hpxml.heating_systems + @hpxml.heat_pumps).each do |htg_system|
-      next unless htg_ids.include? htg_system.id
-
-      @loads[LT::Heating].annual_output_by_system[htg_system.id] = htg_system.fraction_heat_load_served * @loads[LT::Heating].annual_output
-    end
-    (@hpxml.cooling_systems + @hpxml.heat_pumps).each do |clg_system|
-      if clg_ids.include? clg_system.id
-        @loads[LT::Cooling].annual_output_by_system[clg_system.id] = clg_system.fraction_cool_load_served * @loads[LT::Cooling].annual_output
-      end
-      next unless (clg_system.is_a? HPXML::CoolingSystem) && clg_system.has_integrated_heating # Cooling system w/ integrated heating (e.g., Room AC w/ electric resistance heating)
-
-      if htg_ids.include? clg_system.id
-        @loads[LT::Heating].annual_output_by_system[clg_system.id] = clg_system.integrated_heating_system_fraction_heat_load_served * @loads[LT::Heating].annual_output
-      end
-    end
-
-    # Handle dual-fuel heat pumps
-    @hpxml.heat_pumps.each do |heat_pump|
-      next unless heat_pump.is_dual_fuel
-
-      # Create separate dual fuel heat pump backup system
-      dfhp_backup_id = heat_pump.id + '_DFHPBackup'
-      htg_ids << dfhp_backup_id
-      htg_seed_id_map[dfhp_backup_id] = heat_pump.htg_seed_id + '_DFHPBackup'
-      htg_fuels[dfhp_backup_id] = heat_pump.backup_heating_fuel
-      if not heat_pump.backup_heating_efficiency_afue.nil?
-        htg_eecs[dfhp_backup_id] = get_eec_value_numerator('AFUE') / heat_pump.backup_heating_efficiency_afue
-      elsif not heat_pump.backup_heating_efficiency_percent.nil?
-        htg_eecs[dfhp_backup_id] = get_eec_value_numerator('Percent') / heat_pump.backup_heating_efficiency_percent
-      end
-
-      # Apportion heating load for the two systems
-      primary_load, backup_load = nil
-      @object_variables_by_key[[LT, LT::Heating]].each do |vals|
-        sys_id, key_name, var_name = vals
-        if sys_id == heat_pump.id
-          primary_load = get_report_variable_data_annual([key_name], [var_name])
-        elsif sys_id == heat_pump.id + '_DFHPBackup'
-          backup_load = get_report_variable_data_annual([key_name], [var_name])
-        end
-      end
-      fail 'Could not obtain DFHP loads.' if primary_load.nil? || backup_load.nil?
-
-      total_load = @loads[LT::Heating].annual_output_by_system[heat_pump.id]
-      backup_ratio = backup_load / (primary_load + backup_load)
-      @loads[LT::Heating].annual_output_by_system[dfhp_backup_id] = total_load * backup_ratio
-      @loads[LT::Heating].annual_output_by_system[heat_pump.id] = total_load * (1.0 - backup_ratio)
-    end
-
-    # Collect final ERI Reference loads by system
-    htg_loads, clg_loads, dhw_loads = {}, {}, {}
-    @loads.each do |load_type, load|
-      if load_type == LT::Heating
-        htg_loads = load.annual_output_by_system
-      elsif load_type == LT::Cooling
-        clg_loads = load.annual_output_by_system
-      elsif load_type == LT::HotWaterDelivered
-        dhw_loads = load.annual_output_by_system
-      end
-    end
-
-    # Collect energy consumption (EC) by system
-    htg_ecs, clg_ecs, dhw_ecs, prehtg_ecs, preclg_ecs = {}, {}, {}, {}, {}
-    eut_map = { EUT::Heating => htg_ecs,
-                EUT::HeatingHeatPumpBackup => htg_ecs,
-                EUT::HeatingFanPump => htg_ecs,
-                EUT::Cooling => clg_ecs,
-                EUT::CoolingFanPump => clg_ecs,
-                EUT::HotWater => dhw_ecs,
-                EUT::HotWaterRecircPump => dhw_ecs,
-                EUT::HotWaterSolarThermalPump => dhw_ecs,
-                EUT::MechVentPreheat => prehtg_ecs,
-                EUT::MechVentPrecool => preclg_ecs }
-    @end_uses.each do |key, end_use|
-      _fuel_type, end_use_type = key
-      ec_obj = eut_map[end_use_type]
-      next if ec_obj.nil?
-
-      end_use.annual_output_by_system.each do |sys_id, val|
-        ec_obj[sys_id] = 0.0 if ec_obj[sys_id].nil?
-        ec_obj[sys_id] += val
-      end
-    end
-
-    results_out << [line_break]
-
-    # Building
-    results_out << ['ERI: Building: CFA', @hpxml.building_construction.conditioned_floor_area]
-    results_out << ['ERI: Building: NumBedrooms', @hpxml.building_construction.number_of_bedrooms]
-    results_out << ['ERI: Building: NumStories', @hpxml.building_construction.number_of_conditioned_floors_above_grade]
-    results_out << ['ERI: Building: Type', @hpxml.building_construction.residential_facility_type]
-
-    # Heating
-    results_out << ['ERI: Heating: ID', get_ids(htg_ids, htg_seed_id_map)]
-    results_out << ['ERI: Heating: FuelType', ordered_values(htg_fuels, htg_ids)]
-    results_out << ['ERI: Heating: EC', ordered_values(htg_ecs, htg_ids)]
-    results_out << ['ERI: Heating: EEC', ordered_values(htg_eecs, htg_ids)]
-    results_out << ['ERI: Heating: Load', ordered_values(htg_loads, htg_ids)]
-
-    # Cooling
-    results_out << ['ERI: Cooling: ID', get_ids(clg_ids, clg_seed_id_map)]
-    results_out << ['ERI: Cooling: FuelType', ordered_values(clg_fuels, clg_ids)]
-    results_out << ['ERI: Cooling: EC', ordered_values(clg_ecs, clg_ids)]
-    results_out << ['ERI: Cooling: EEC', ordered_values(clg_eecs, clg_ids)]
-    results_out << ['ERI: Cooling: Load', ordered_values(clg_loads, clg_ids)]
-
-    # Hot Water
-    results_out << ['ERI: Hot Water: ID', get_ids(dhw_ids)]
-    results_out << ['ERI: Hot Water: FuelType', ordered_values(dhw_fuels, dhw_ids)]
-    results_out << ['ERI: Hot Water: EC', ordered_values(dhw_ecs, dhw_ids)]
-    results_out << ['ERI: Hot Water: EEC', ordered_values(dhw_eecs, dhw_ids)]
-    results_out << ['ERI: Hot Water: Load', ordered_values(dhw_loads, dhw_ids)]
-
-    # Mech Vent Preheat
-    results_out << ['ERI: Mech Vent Preheating: ID', get_ids(prehtg_ids)]
-    results_out << ['ERI: Mech Vent Preheating: FuelType', ordered_values(prehtg_fuels, prehtg_ids)]
-    results_out << ['ERI: Mech Vent Preheating: EC', ordered_values(prehtg_ecs, prehtg_ids)]
-    results_out << ['ERI: Mech Vent Preheating: EEC', ordered_values(prehtg_eecs, prehtg_ids)]
-
-    # Mech Vent Precool
-    results_out << ['ERI: Mech Vent Precooling: ID', get_ids(preclg_ids)]
-    results_out << ['ERI: Mech Vent Precooling: FuelType', ordered_values(preclg_fuels, preclg_ids)]
-    results_out << ['ERI: Mech Vent Precooling: EC', ordered_values(preclg_ecs, preclg_ids)]
-    results_out << ['ERI: Mech Vent Precooling: EEC', ordered_values(preclg_eecs, preclg_ids)]
-
-    return results_out
-  end
-
-  def report_timeseries_output_results(runner, outputs, output_format,
-                                       timeseries_output_path,
-                                       timeseries_frequency,
-                                       include_timeseries_total_consumptions,
-                                       include_timeseries_fuel_consumptions,
-                                       include_timeseries_end_use_consumptions,
-                                       include_timeseries_emissions,
-                                       include_timeseries_emission_fuels,
-                                       include_timeseries_emission_end_uses,
-                                       include_timeseries_hot_water_uses,
-                                       include_timeseries_total_loads,
-                                       include_timeseries_component_loads,
-                                       include_timeseries_unmet_hours,
-                                       include_timeseries_zone_temperatures,
-                                       include_timeseries_airflows,
-                                       include_timeseries_weather,
-                                       add_dst_column,
-                                       add_utc_column,
-                                       timestamps_dst,
-                                       timestamps_utc,
-                                       use_dview_format)
+  def report_timeseries_output_results(runner, outputs, timeseries_output_path, args, timestamps_dst, timestamps_utc)
     return if @timestamps.nil?
 
-    if not ['timestep', 'hourly', 'daily', 'monthly'].include? timeseries_frequency
-      fail "Unexpected timeseries_frequency: #{timeseries_frequency}."
+    if not ['timestep', 'hourly', 'daily', 'monthly'].include? args[:timeseries_frequency]
+      fail "Unexpected timeseries_frequency: #{args[:timeseries_frequency]}."
     end
 
-    # Set rounding precision for timeseries (e.g., hourly) outputs.
-    # Note: Make sure to round outputs with sufficient resolution for the worst case -- i.e., 1 minute date instead of hourly data.
-    n_digits = 2 # Default for hourly (or longer) data
-    if timeseries_frequency == 'timestep'
-      if @hpxml.header.timestep <= 2 # 2-minute timesteps or shorter; add two decimal places
-        n_digits += 2
-      elsif @hpxml.header.timestep <= 15 # 15-minute timesteps or shorter; add one decimal place
-        n_digits += 1
+    if args[:output_format] == 'msgpack'
+      # No need to round; no file size penalty to storing full precision
+      n_digits = 100
+    elsif not args[:timeseries_num_decimal_places].nil?
+      n_digits = args[:timeseries_num_decimal_places]
+    else
+      # Set rounding precision for timeseries (e.g., hourly) outputs.
+      # Note: Make sure to round outputs with sufficient resolution for the worst case -- i.e., 1 minute date instead of hourly data.
+      n_digits = 3 # Default for hourly (or longer) data
+      if args[:timeseries_frequency] == 'timestep'
+        if @hpxml.header.timestep <= 2 # 2-minute timesteps or shorter; add two decimal places
+          n_digits += 2
+        elsif @hpxml.header.timestep <= 15 # 15-minute timesteps or shorter; add one decimal place
+          n_digits += 1
+        end
       end
     end
 
     # Initial output data w/ Time column(s)
     data = ['Time', nil] + @timestamps
-    if add_dst_column
+    if args[:add_timeseries_dst_column]
       timestamps2 = [['TimeDST', nil] + timestamps_dst]
     else
       timestamps2 = []
     end
-    if add_utc_column
+    if args[:add_timeseries_utc_column]
       timestamps3 = [['TimeUTC', nil] + timestamps_utc]
     else
       timestamps3 = []
     end
 
-    if include_timeseries_total_consumptions
+    if args[:include_timeseries_total_consumptions]
       total_energy_data = []
       [TE::Total, TE::Net].each do |energy_type|
         next if (energy_type == TE::Net) && (outputs[:elec_prod_timeseries].sum(0.0) == 0)
+        next if @totals[energy_type].timeseries_output.empty?
 
         total_energy_data << [@totals[energy_type].name, @totals[energy_type].timeseries_units] + @totals[energy_type].timeseries_output.map { |v| v.round(n_digits) }
       end
     else
       total_energy_data = []
     end
-    if include_timeseries_fuel_consumptions
+    if args[:include_timeseries_fuel_consumptions]
       fuel_data = @fuels.values.select { |x| x.timeseries_output.sum(0.0) != 0 }.map { |x| [x.name, x.timeseries_units] + x.timeseries_output.map { |v| v.round(n_digits) } }
 
       # Also add Net Electricity
@@ -1705,77 +1495,84 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
     else
       fuel_data = []
     end
-    if include_timeseries_end_use_consumptions
+    if args[:include_timeseries_end_use_consumptions]
       end_use_data = @end_uses.values.select { |x| x.timeseries_output.sum(0.0) != 0 }.map { |x| [x.name, x.timeseries_units] + x.timeseries_output.map { |v| v.round(n_digits) } }
     else
       end_use_data = []
     end
-    if include_timeseries_emissions
+    if args[:include_timeseries_system_use_consumptions]
+      system_use_data = @system_uses.values.select { |x| x.timeseries_output.sum(0.0) != 0 }.map { |x| [x.name, x.timeseries_units] + x.timeseries_output.map { |v| v.round(n_digits) } }
+    else
+      system_use_data = []
+    end
+    if args[:include_timeseries_emissions]
       emissions_data = []
       @emissions.values.each do |emission|
         next if emission.timeseries_output.sum(0.0) == 0
 
-        emissions_data << ["#{emission.name}: Total", emission.timeseries_units] + emission.timeseries_output.map { |v| v.round(5) }
+        emissions_data << ["#{emission.name}: Total", emission.timeseries_units] + emission.timeseries_output.map { |v| v.round(n_digits + 2) }
+        emissions_data << ["#{emission.name}: Net", emission.timeseries_units] + emission.net_timeseries_output.map { |v| v.round(n_digits + 2) }
       end
     else
       emissions_data = []
     end
-    if include_timeseries_emission_fuels
+    if args[:include_timeseries_emission_fuels]
       emission_fuel_data = []
       @emissions.values.each do |emission|
-        emission.timeseries_output_by_fuel.each do |fuel, timeseries_output|
+        emission.timeseries_output_by_fuel.each do |fuel_key, timeseries_output|
+          fuel, emission_type = fuel_key
           next if timeseries_output.sum(0.0) == 0
 
-          emission_fuel_data << ["#{emission.name}: #{fuel}: Total", emission.timeseries_units] + timeseries_output.map { |v| v.round(5) }
+          emission_fuel_data << ["#{emission.name}: #{fuel}: #{emission_type}", emission.timeseries_units] + timeseries_output.map { |v| v.round(n_digits + 2) }
         end
       end
     else
       emission_fuel_data = []
     end
-    if include_timeseries_emission_end_uses
+    if args[:include_timeseries_emission_end_uses]
       emission_end_use_data = []
       @emissions.values.each do |emission|
         emission.timeseries_output_by_end_use.each do |key, timeseries_output|
           next if timeseries_output.sum(0.0) == 0
 
           fuel_type, end_use_type = key
-          emission_end_use_data << ["#{emission.name}: #{fuel_type}: #{end_use_type}", emission.timeseries_units] + timeseries_output.map { |v| v.round(5) }
+          emission_end_use_data << ["#{emission.name}: #{fuel_type}: #{end_use_type}", emission.timeseries_units] + timeseries_output.map { |v| v.round(n_digits + 2) }
         end
       end
     else
       emission_end_use_data = []
     end
-    if include_timeseries_hot_water_uses
+    if args[:include_timeseries_hot_water_uses]
       hot_water_use_data = @hot_water_uses.values.select { |x| x.timeseries_output.sum(0.0) != 0 }.map { |x| [x.name, x.timeseries_units] + x.timeseries_output.map { |v| v.round(n_digits) } }
     else
       hot_water_use_data = []
     end
-    if include_timeseries_total_loads
+    if args[:include_timeseries_total_loads]
       total_loads_data = @loads.values.select { |x| x.timeseries_output.sum(0.0) != 0 }.map { |x| [x.name, x.timeseries_units] + x.timeseries_output.map { |v| v.round(n_digits) } }
     else
       total_loads_data = {}
     end
-    if include_timeseries_component_loads
+    if args[:include_timeseries_component_loads]
       comp_loads_data = @component_loads.values.select { |x| x.timeseries_output.sum(0.0) != 0 }.map { |x| [x.name, x.timeseries_units] + x.timeseries_output.map { |v| v.round(n_digits) } }
     else
       comp_loads_data = []
     end
-    if include_timeseries_unmet_hours
+    if args[:include_timeseries_unmet_hours]
       unmet_hours_data = @unmet_hours.values.map { |x| [x.name, x.timeseries_units] + x.timeseries_output.map { |v| v.round(n_digits) } }
     else
       unmet_hours_data = []
     end
-    if include_timeseries_zone_temperatures
+    if args[:include_timeseries_zone_temperatures]
       zone_temps_data = @zone_temps.values.select { |x| x.timeseries_output.sum(0.0) != 0 }.map { |x| [x.name, x.timeseries_units] + x.timeseries_output.map { |v| v.round(n_digits) } }
     else
       zone_temps_data = []
     end
-    if include_timeseries_airflows
+    if args[:include_timeseries_airflows]
       airflows_data = @airflows.values.select { |x| x.timeseries_output.sum(0.0) != 0 }.map { |x| [x.name, x.timeseries_units] + x.timeseries_output.map { |v| v.round(n_digits) } }
     else
       airflows_data = []
     end
-    if include_timeseries_weather
+    if args[:include_timeseries_weather]
       weather_data = @weather.values.select { |x| x.timeseries_output.sum(0.0) != 0 }.map { |x| [x.name, x.timeseries_units] + x.timeseries_output.map { |v| v.round(n_digits) } }
     else
       weather_data = []
@@ -1788,15 +1585,15 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
       output_variables_data = []
     end
 
-    return if (total_energy_data.size + fuel_data.size + end_use_data.size + emissions_data.size + emission_fuel_data.size +
+    return if (total_energy_data.size + fuel_data.size + end_use_data.size + system_use_data.size + emissions_data.size + emission_fuel_data.size +
                emission_end_use_data.size + hot_water_use_data.size + total_loads_data.size + comp_loads_data.size + unmet_hours_data.size +
                zone_temps_data.size + airflows_data.size + weather_data.size + output_variables_data.size) == 0
 
     fail 'Unable to obtain timestamps.' if @timestamps.empty?
 
-    if ['csv'].include? output_format
+    if ['csv'].include? args[:output_format]
       # Assemble data
-      data = data.zip(*timestamps2, *timestamps3, *total_energy_data, *fuel_data, *end_use_data, *emissions_data,
+      data = data.zip(*timestamps2, *timestamps3, *total_energy_data, *fuel_data, *end_use_data, *system_use_data, *emissions_data,
                       *emission_fuel_data, *emission_end_use_data, *hot_water_use_data, *total_loads_data, *comp_loads_data,
                       *unmet_hours_data, *zone_temps_data, *airflows_data, *weather_data, *output_variables_data)
 
@@ -1809,7 +1606,7 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
         fail "Inconsistent number of array elements: #{n_elements.uniq}."
       end
 
-      if use_dview_format
+      if args[:use_dview_format]
         # Remove Time column(s)
         while data[0][0].include? 'Time'
           data = data.map { |a| a[1..-1] }
@@ -1819,13 +1616,13 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
         year = @hpxml.header.sim_calendar_year
         start_day = Schedule.get_day_num_from_month_day(year, @hpxml.header.sim_begin_month, @hpxml.header.sim_begin_day)
         start_hr = (start_day - 1) * 24
-        if timeseries_frequency == 'timestep'
+        if args[:timeseries_frequency] == 'timestep'
           interval_hrs = @hpxml.header.timestep / 60.0
-        elsif timeseries_frequency == 'hourly'
+        elsif args[:timeseries_frequency] == 'hourly'
           interval_hrs = 1.0
-        elsif timeseries_frequency == 'daily'
+        elsif args[:timeseries_frequency] == 'daily'
           interval_hrs = 24.0
-        elsif timeseries_frequency == 'monthly'
+        elsif args[:timeseries_frequency] == 'monthly'
           interval_hrs = Constants.NumDaysInYear(year) * 24.0 / 12
         end
         header_data = [['wxDVFileHeaderVer.1'],
@@ -1837,9 +1634,9 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
         data.delete_at(0) # Remove series name, added to header data above
 
         # Apply daylight savings
-        if timeseries_frequency == 'timestep' || timeseries_frequency == 'hourly'
+        if args[:timeseries_frequency] == 'timestep' || args[:timeseries_frequency] == 'hourly'
           if @hpxml.header.dst_enabled
-            dst_start_ix, dst_end_ix = OutputMethods.get_dst_start_end_indexes(@timestamps, timestamps_dst)
+            dst_start_ix, dst_end_ix = get_dst_start_end_indexes(@timestamps, timestamps_dst)
             dst_end_ix.downto(dst_start_ix + 1) do |i|
               data[i + 1] = data[i]
             end
@@ -1851,14 +1648,14 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
 
       # Write file
       CSV.open(timeseries_output_path, 'wb') { |csv| data.to_a.each { |elem| csv << elem } }
-    elsif ['json', 'msgpack'].include? output_format
+    elsif ['json', 'msgpack'].include? args[:output_format]
       # Assemble data
       h = {}
       h['Time'] = data[2..-1]
       h['TimeDST'] = timestamps2[2..-1] if timestamps_dst
       h['TimeUTC'] = timestamps3[2..-1] if timestamps_utc
 
-      [total_energy_data, fuel_data, end_use_data, emissions_data, emission_fuel_data,
+      [total_energy_data, fuel_data, end_use_data, system_use_data, emissions_data, emission_fuel_data,
        emission_end_use_data, hot_water_use_data, total_loads_data, comp_loads_data, unmet_hours_data,
        zone_temps_data, airflows_data, weather_data, output_variables_data].each do |d|
         d.each do |o|
@@ -1869,16 +1666,29 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
       end
 
       # Write file
-      if output_format == 'json'
+      if args[:output_format] == 'json'
         require 'json'
         File.open(timeseries_output_path, 'w') { |json| json.write(JSON.pretty_generate(h)) }
-      elsif output_format == 'msgpack'
+      elsif args[:output_format] == 'msgpack'
         File.open(timeseries_output_path, 'w') { |json| h.to_msgpack(json) }
       end
     end
     runner.registerInfo("Wrote timeseries output results to #{timeseries_output_path}.")
   end
 
+  def get_dst_start_end_indexes(timestamps, timestamps_dst)
+    dst_start_ix = nil
+    dst_end_ix = nil
+    timestamps.zip(timestamps_dst).each_with_index do |ts, i|
+      dst_start_ix = i if ts[0] != ts[1] && dst_start_ix.nil?
+      dst_end_ix = i if ts[0] == ts[1] && dst_end_ix.nil? && !dst_start_ix.nil?
+    end
+
+    dst_end_ix = timestamps.size - 1 if dst_end_ix.nil? # run period ends before DST ends
+
+    return dst_start_ix, dst_end_ix
+  end
+
   def get_report_meter_data_annual(meter_names, unit_conv = UnitConversions.convert(1.0, 'J', 'MBtu'))
     return 0.0 if meter_names.empty?
 
@@ -1908,7 +1718,10 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
   def get_report_meter_data_timeseries(meter_names, unit_conv, unit_adder, timeseries_frequency)
     return [0.0] * @timestamps.size if meter_names.empty?
 
-    msgpack_timeseries_name = OutputMethods.msgpack_frequency_map[timeseries_frequency]
+    msgpack_timeseries_name = { 'timestep' => 'TimeStep',
+                                'hourly' => 'Hourly',
+                                'daily' => 'Daily',
+                                'monthly' => 'Monthly' }[timeseries_frequency]
     cols = @msgpackData['MeterData'][msgpack_timeseries_name]['Cols']
     rows = @msgpackData['MeterData'][msgpack_timeseries_name]['Rows']
     indexes = cols.each_index.select { |i| meter_names.include? cols[i]['Variable'] }
@@ -1930,8 +1743,14 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
     if key_values.uniq.size > 1 && key_values.include?('EMS') && ems_shift
       # Split into EMS and non-EMS queries so that the EMS values shift occurs for just the EMS query
       # Remove this code if we ever figure out a better way to handle when EMS output should shift
-      values = get_report_variable_data_timeseries(['EMS'], variables, unit_conv, unit_adder, timeseries_frequency, is_negative: is_negative, ems_shift: ems_shift)
-      sum_values = values.zip(get_report_variable_data_timeseries(key_values.select { |k| k != 'EMS' }, variables, unit_conv, unit_adder, timeseries_frequency, is_negative: is_negative, ems_shift: ems_shift)).map { |x, y| x + y }
+      ems_indices = key_values.each_index.select { |i| key_values[i] == 'EMS' }
+      ems_key_values = key_values.select.with_index { |_kv, i| ems_indices.include? i }
+      ems_variables = variables.select.with_index { |_kv, i| ems_indices.include? i }
+      non_ems_key_values = key_values.select.with_index { |_kv, i| !ems_indices.include? i }
+      non_ems_variables = variables.select.with_index { |_kv, i| !ems_indices.include? i }
+      values = get_report_variable_data_timeseries(ems_key_values, ems_variables, unit_conv, unit_adder, timeseries_frequency, is_negative: is_negative, ems_shift: ems_shift)
+      non_ems_values = get_report_variable_data_timeseries(non_ems_key_values, non_ems_variables, unit_conv, unit_adder, timeseries_frequency, is_negative: is_negative, ems_shift: ems_shift)
+      sum_values = [values, non_ems_values].transpose.map(&:sum)
       return sum_values
     end
 
@@ -1993,7 +1812,7 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
         next if table['TableName'] != table_name
 
         cols = table['Cols']
-        index = cols.each_index.select { |i| cols[i] == "#{col_name} [#{units}]" }[0]
+        index = cols.each_index.find { |i| cols[i] == "#{col_name} [#{units}]" }
         row_names.each do |row_name|
           vals << table['Rows'][row_name][index].to_f
         end
@@ -2015,8 +1834,8 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
     if not obj.timeseries_output_by_system.empty?
       orig_values = obj.timeseries_output_by_system[sys_id]
       obj.timeseries_output_by_system[sys_id] = obj.timeseries_output_by_system[sys_id].map { |x| x * mult }
-      diffs = obj.timeseries_output_by_system[sys_id].zip(orig_values).map { |x, y| x - y }
       if not sync_obj.nil?
+        diffs = obj.timeseries_output_by_system[sys_id].zip(orig_values).map { |x, y| x - y }
         sync_obj.timeseries_output = sync_obj.timeseries_output.zip(diffs).map { |x, y| x + y }
       end
     end
@@ -2031,19 +1850,14 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
     @object_variables_by_key = {}
     return if @model.nil?
 
-    @model.getModelObjects.each do |object|
+    @model.getModelObjects.sort.each do |object|
       next if object.to_AdditionalProperties.is_initialized
 
-      [EUT, HWT, LT, ILT].each do |class_name|
-        vars_by_key = get_object_output_variables_by_key(@model, object, class_name)
-        next if vars_by_key.size == 0
-
+      [EUT, HWT, LT].each do |class_name|
         sys_id = object.additionalProperties.getFeatureAsString('HPXML_ID')
-        if sys_id.is_initialized
-          sys_id = sys_id.get
-        else
-          sys_id = nil
-        end
+        sys_id = sys_id.is_initialized ? sys_id.get : nil
+        vars_by_key = get_object_output_variables_by_key(@model, object, sys_id, class_name)
+        next if vars_by_key.size == 0
 
         vars_by_key.each do |key, output_vars|
           output_vars.each do |output_var|
@@ -2116,8 +1930,11 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
       @timeseries_output_by_fuel = {}
       @annual_output_by_fuel = {}
       @annual_output_by_end_use = {}
+      @net_annual_output = 0.0
+      @net_timeseries_output = []
     end
-    attr_accessor(:annual_output_by_fuel, :annual_output_by_end_use, :timeseries_output_by_fuel, :timeseries_output_by_end_use)
+    attr_accessor(:annual_output_by_fuel, :annual_output_by_end_use, :timeseries_output_by_fuel, :timeseries_output_by_end_use,
+                  :net_annual_output, :net_timeseries_output)
   end
 
   class HotWater < BaseOutput
@@ -2131,12 +1948,11 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
   end
 
   class PeakFuel < BaseOutput
-    def initialize(meters:, report:)
+    def initialize(report:)
       super()
-      @meters = meters
       @report = report
     end
-    attr_accessor(:meters, :report)
+    attr_accessor(:report)
   end
 
   class Load < BaseOutput
@@ -2235,8 +2051,9 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
 
     @end_uses = {}
     @end_uses[[FT::Elec, EUT::Heating]] = EndUse.new(variables: get_object_variables(EUT, [FT::Elec, EUT::Heating]))
-    @end_uses[[FT::Elec, EUT::HeatingHeatPumpBackup]] = EndUse.new(variables: get_object_variables(EUT, [FT::Elec, EUT::HeatingHeatPumpBackup]))
     @end_uses[[FT::Elec, EUT::HeatingFanPump]] = EndUse.new(variables: get_object_variables(EUT, [FT::Elec, EUT::HeatingFanPump]))
+    @end_uses[[FT::Elec, EUT::HeatingHeatPumpBackup]] = EndUse.new(variables: get_object_variables(EUT, [FT::Elec, EUT::HeatingHeatPumpBackup]))
+    @end_uses[[FT::Elec, EUT::HeatingHeatPumpBackupFanPump]] = EndUse.new(variables: get_object_variables(EUT, [FT::Elec, EUT::HeatingHeatPumpBackupFanPump]))
     @end_uses[[FT::Elec, EUT::Cooling]] = EndUse.new(variables: get_object_variables(EUT, [FT::Elec, EUT::Cooling]))
     @end_uses[[FT::Elec, EUT::CoolingFanPump]] = EndUse.new(variables: get_object_variables(EUT, [FT::Elec, EUT::CoolingFanPump]))
     @end_uses[[FT::Elec, EUT::HotWater]] = EndUse.new(variables: get_object_variables(EUT, [FT::Elec, EUT::HotWater]))
@@ -2402,10 +2219,9 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
     end
 
     # Peak Fuels
-    # Using meters for energy transferred in conditioned space only (i.e., excluding ducts) to determine winter vs summer.
     @peak_fuels = {}
-    @peak_fuels[[FT::Elec, PFT::Winter]] = PeakFuel.new(meters: ["Heating:EnergyTransfer:Zone:#{HPXML::LocationLivingSpace.upcase}"], report: 'Peak Electricity Winter Total')
-    @peak_fuels[[FT::Elec, PFT::Summer]] = PeakFuel.new(meters: ["Cooling:EnergyTransfer:Zone:#{HPXML::LocationLivingSpace.upcase}"], report: 'Peak Electricity Summer Total')
+    @peak_fuels[[FT::Elec, PFT::Winter]] = PeakFuel.new(report: 'Peak Electricity Winter Total')
+    @peak_fuels[[FT::Elec, PFT::Summer]] = PeakFuel.new(report: 'Peak Electricity Summer Total')
 
     @peak_fuels.each do |key, peak_fuel|
       fuel_type, peak_fuel_type = key
@@ -2417,6 +2233,7 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
 
     @loads = {}
     @loads[LT::Heating] = Load.new(ems_variable: 'loads_htg_tot')
+    @loads[LT::HeatingHeatPumpBackup] = Load.new(variables: get_object_variables(LT, LT::HeatingHeatPumpBackup))
     @loads[LT::Cooling] = Load.new(ems_variable: 'loads_clg_tot')
     @loads[LT::HotWaterDelivered] = Load.new(variables: get_object_variables(LT, LT::HotWaterDelivered))
     @loads[LT::HotWaterTankLosses] = Load.new(variables: get_object_variables(LT, LT::HotWaterTankLosses),
@@ -2440,8 +2257,10 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
     @component_loads[[LT::Heating, CLT::RimJoists]] = ComponentLoad.new(ems_variable: 'loads_htg_rim_joists')
     @component_loads[[LT::Heating, CLT::FoundationWalls]] = ComponentLoad.new(ems_variable: 'loads_htg_foundation_walls')
     @component_loads[[LT::Heating, CLT::Doors]] = ComponentLoad.new(ems_variable: 'loads_htg_doors')
-    @component_loads[[LT::Heating, CLT::Windows]] = ComponentLoad.new(ems_variable: 'loads_htg_windows')
-    @component_loads[[LT::Heating, CLT::Skylights]] = ComponentLoad.new(ems_variable: 'loads_htg_skylights')
+    @component_loads[[LT::Heating, CLT::WindowsConduction]] = ComponentLoad.new(ems_variable: 'loads_htg_windows_conduction')
+    @component_loads[[LT::Heating, CLT::WindowsSolar]] = ComponentLoad.new(ems_variable: 'loads_htg_windows_solar')
+    @component_loads[[LT::Heating, CLT::SkylightsConduction]] = ComponentLoad.new(ems_variable: 'loads_htg_skylights_conduction')
+    @component_loads[[LT::Heating, CLT::SkylightsSolar]] = ComponentLoad.new(ems_variable: 'loads_htg_skylights_solar')
     @component_loads[[LT::Heating, CLT::Floors]] = ComponentLoad.new(ems_variable: 'loads_htg_floors')
     @component_loads[[LT::Heating, CLT::Slabs]] = ComponentLoad.new(ems_variable: 'loads_htg_slabs')
     @component_loads[[LT::Heating, CLT::InternalMass]] = ComponentLoad.new(ems_variable: 'loads_htg_internal_mass')
@@ -2451,14 +2270,17 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
     @component_loads[[LT::Heating, CLT::WholeHouseFan]] = ComponentLoad.new(ems_variable: 'loads_htg_whf')
     @component_loads[[LT::Heating, CLT::Ducts]] = ComponentLoad.new(ems_variable: 'loads_htg_ducts')
     @component_loads[[LT::Heating, CLT::InternalGains]] = ComponentLoad.new(ems_variable: 'loads_htg_intgains')
+    @component_loads[[LT::Heating, CLT::Lighting]] = ComponentLoad.new(ems_variable: 'loads_htg_lighting')
     @component_loads[[LT::Cooling, CLT::Roofs]] = ComponentLoad.new(ems_variable: 'loads_clg_roofs')
     @component_loads[[LT::Cooling, CLT::Ceilings]] = ComponentLoad.new(ems_variable: 'loads_clg_ceilings')
     @component_loads[[LT::Cooling, CLT::Walls]] = ComponentLoad.new(ems_variable: 'loads_clg_walls')
     @component_loads[[LT::Cooling, CLT::RimJoists]] = ComponentLoad.new(ems_variable: 'loads_clg_rim_joists')
     @component_loads[[LT::Cooling, CLT::FoundationWalls]] = ComponentLoad.new(ems_variable: 'loads_clg_foundation_walls')
     @component_loads[[LT::Cooling, CLT::Doors]] = ComponentLoad.new(ems_variable: 'loads_clg_doors')
-    @component_loads[[LT::Cooling, CLT::Windows]] = ComponentLoad.new(ems_variable: 'loads_clg_windows')
-    @component_loads[[LT::Cooling, CLT::Skylights]] = ComponentLoad.new(ems_variable: 'loads_clg_skylights')
+    @component_loads[[LT::Cooling, CLT::WindowsConduction]] = ComponentLoad.new(ems_variable: 'loads_clg_windows_conduction')
+    @component_loads[[LT::Cooling, CLT::WindowsSolar]] = ComponentLoad.new(ems_variable: 'loads_clg_windows_solar')
+    @component_loads[[LT::Cooling, CLT::SkylightsConduction]] = ComponentLoad.new(ems_variable: 'loads_clg_skylights_conduction')
+    @component_loads[[LT::Cooling, CLT::SkylightsSolar]] = ComponentLoad.new(ems_variable: 'loads_clg_skylights_solar')
     @component_loads[[LT::Cooling, CLT::Floors]] = ComponentLoad.new(ems_variable: 'loads_clg_floors')
     @component_loads[[LT::Cooling, CLT::Slabs]] = ComponentLoad.new(ems_variable: 'loads_clg_slabs')
     @component_loads[[LT::Cooling, CLT::InternalMass]] = ComponentLoad.new(ems_variable: 'loads_clg_internal_mass')
@@ -2468,6 +2290,7 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
     @component_loads[[LT::Cooling, CLT::WholeHouseFan]] = ComponentLoad.new(ems_variable: 'loads_clg_whf')
     @component_loads[[LT::Cooling, CLT::Ducts]] = ComponentLoad.new(ems_variable: 'loads_clg_ducts')
     @component_loads[[LT::Cooling, CLT::InternalGains]] = ComponentLoad.new(ems_variable: 'loads_clg_intgains')
+    @component_loads[[LT::Cooling, CLT::Lighting]] = ComponentLoad.new(ems_variable: 'loads_clg_lighting')
 
     @component_loads.each do |key, comp_load|
       load_type, comp_load_type = key
@@ -2487,16 +2310,6 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
       unmet_hour.timeseries_units = 'hr'
     end
 
-    # Ideal System Loads (expected load that is not met by the HVAC systems)
-    @ideal_system_loads = {}
-    @ideal_system_loads[ILT::Heating] = IdealLoad.new(variables: get_object_variables(ILT, ILT::Heating))
-    @ideal_system_loads[ILT::Cooling] = IdealLoad.new(variables: get_object_variables(ILT, ILT::Cooling))
-
-    @ideal_system_loads.each do |load_type, ideal_load|
-      ideal_load.name = "Ideal System Load: #{load_type}"
-      ideal_load.annual_units = 'MBtu'
-    end
-
     # Peak Loads
     @peak_loads = {}
     @peak_loads[PLT::Heating] = PeakLoad.new(ems_variable: 'loads_htg_tot', report: 'Peak Heating Load')
@@ -2545,6 +2358,30 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
     end
   end
 
+  def setup_timeseries_includes(emissions, args)
+    # To calculate timeseries emissions or timeseries fuel consumption, we also need to select timeseries
+    # end use consumption because EnergyPlus results may be post-processed due to HVAC DSE.
+    # TODO: This could be removed if we could account for DSE inside EnergyPlus.
+    args = args.dup # We don't want to modify the original arguments
+    args[:include_hourly_electric_end_use_consumptions] = false
+    if not emissions.empty?
+      args[:include_hourly_electric_end_use_consumptions] = true # Need hourly electricity values for Cambium
+      if args[:include_timeseries_emissions] || args[:include_timeseries_emission_end_uses] || args[:include_timeseries_emission_fuels]
+        args[:include_timeseries_fuel_consumptions] = true
+      end
+    end
+    if args[:include_timeseries_total_consumptions]
+      args[:include_timeseries_fuel_consumptions] = true
+    end
+    if args[:include_timeseries_fuel_consumptions]
+      args[:include_timeseries_end_use_consumptions] = true
+    end
+    if args[:include_timeseries_system_use_consumptions]
+      args[:include_timeseries_end_use_consumptions] = true
+    end
+    return args
+  end
+
   def is_heat_pump_backup(sys_id)
     return false if @hpxml.nil?
 
@@ -2563,14 +2400,24 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
       return true
     end
 
-    if sys_id.include? '_DFHPBackup'
-      return true
-    end
-
     return false
   end
 
-  def get_object_output_variables_by_key(model, object, class_name)
+  def get_hpxml_system_ids
+    # Returns a list of HPXML IDs corresponds to HVAC or water heating systems
+    return [] if @hpxml.nil?
+
+    system_ids = []
+    (@hpxml.hvac_systems + @hpxml.water_heating_systems + @hpxml.ventilation_fans).each do |system|
+      system_ids << system.id
+    end
+    return system_ids
+  end
+
+  def get_object_output_variables_by_key(model, object, sys_id, class_name)
+    # For a given object, returns the output variables to be requested and associates
+    # them with the appropriate keys (e.g., [FT::Elec, EUT::Heating]).
+
     to_ft = { EPlus::FuelTypeElectricity => FT::Elec,
               EPlus::FuelTypeNaturalGas => FT::Gas,
               EPlus::FuelTypeOil => FT::Oil,
@@ -2579,16 +2426,6 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
               EPlus::FuelTypeWoodPellets => FT::WoodPellets,
               EPlus::FuelTypeCoal => FT::Coal }
 
-    # For a given object, returns the output variables to be requested and associates
-    # them with the appropriate keys (e.g., [FT::Elec, EUT::Heating]).
-
-    sys_id = object.additionalProperties.getFeatureAsString('HPXML_ID')
-    if sys_id.is_initialized
-      sys_id = sys_id.get
-    else
-      sys_id = nil
-    end
-
     if class_name == EUT
 
       # End uses
@@ -2606,9 +2443,9 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
       elsif object.to_CoilHeatingGas.is_initialized
         fuel = object.to_CoilHeatingGas.get.fuelType
         if not is_heat_pump_backup(sys_id)
-          return { [to_ft[fuel], EUT::Heating] => ["Heating Coil #{fuel} Energy"] }
+          return { [to_ft[fuel], EUT::Heating] => ["Heating Coil #{fuel} Energy", "Heating Coil Ancillary #{fuel} Energy"] }
         else
-          return { [to_ft[fuel], EUT::HeatingHeatPumpBackup] => ["Heating Coil #{fuel} Energy"] }
+          return { [to_ft[fuel], EUT::HeatingHeatPumpBackup] => ["Heating Coil #{fuel} Energy", "Heating Coil Ancillary #{fuel} Energy"] }
         end
 
       elsif object.to_CoilHeatingWaterToAirHeatPumpEquationFit.is_initialized
@@ -2756,7 +2593,7 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
         if object.name.to_s.end_with? Constants.ObjectNameFanPumpDisaggregatePrimaryHeat
           return { [FT::Elec, EUT::HeatingFanPump] => [object.name.to_s] }
         elsif object.name.to_s.end_with? Constants.ObjectNameFanPumpDisaggregateBackupHeat
-          return { [FT::Elec, EUT::HeatingFanPump] => [object.name.to_s] }
+          return { [FT::Elec, EUT::HeatingHeatPumpBackupFanPump] => [object.name.to_s] }
         elsif object.name.to_s.end_with? Constants.ObjectNameFanPumpDisaggregateCool
           return { [FT::Elec, EUT::CoolingFanPump] => [object.name.to_s] }
         elsif object.name.to_s.include? Constants.ObjectNameWaterHeaterAdjustment(nil)
@@ -2764,6 +2601,9 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
           return { [to_ft[fuel], EUT::HotWater] => [object.name.to_s] }
         elsif object.name.to_s.include? Constants.ObjectNameBatteryLossesAdjustment(nil)
           return { [FT::Elec, EUT::Battery] => [object.name.to_s] }
+        elsif object.name.to_s.include? Constants.ObjectNameBoilerPilotLight(nil)
+          fuel = object.additionalProperties.getFeatureAsString('FuelType').get
+          return { [to_ft[fuel], EUT::Heating] => [object.name.to_s] }
         else
           return { ems: [object.name.to_s] }
         end
@@ -2809,20 +2649,24 @@ class ReportSimulationOutput < OpenStudio::Measure::ReportingMeasure
       elsif object.to_CoilWaterHeatingDesuperheater.is_initialized
         return { LT::HotWaterDesuperheater => ['Water Heater Heating Energy'] }
 
-      elsif object.to_CoilHeatingDXSingleSpeed.is_initialized || object.to_CoilHeatingDXMultiSpeed.is_initialized || object.to_CoilHeatingGas.is_initialized
-        # Needed to apportion heating loads for dual-fuel heat pumps
-        return { LT::Heating => ['Heating Coil Heating Energy'] }
-
-      end
-
-    elsif class_name == ILT
+      elsif object.to_CoilHeatingGas.is_initialized || object.to_CoilHeatingElectric.is_initialized
+        if object.additionalProperties.getFeatureAsBoolean('IsHeatPumpBackup').is_initialized
+          if object.additionalProperties.getFeatureAsBoolean('IsHeatPumpBackup').get
+            return { LT::HeatingHeatPumpBackup => ['Heating Coil Heating Energy'] }
+          end
+        end
 
-      # Ideal Load
+      elsif object.to_ZoneHVACBaseboardConvectiveElectric.is_initialized || object.to_ZoneHVACBaseboardConvectiveWater.is_initialized
+        if object.additionalProperties.getFeatureAsBoolean('IsHeatPumpBackup').is_initialized
+          if object.additionalProperties.getFeatureAsBoolean('IsHeatPumpBackup').get
+            return { LT::HeatingHeatPumpBackup => ['Baseboard Total Heating Energy'] }
+          end
+        end
 
-      if object.to_ZoneHVACIdealLoadsAirSystem.is_initialized
-        if object.name.to_s == Constants.ObjectNameIdealAirSystem
-          return { ILT::Heating => ['Zone Ideal Loads Zone Sensible Heating Energy'],
-                   ILT::Cooling => ['Zone Ideal Loads Zone Sensible Cooling Energy'] }
+      elsif object.to_EnergyManagementSystemOutputVariable.is_initialized
+        if object.name.to_s.end_with? Constants.ObjectNameFanPumpDisaggregateBackupHeat
+          # Fan/pump energy is contributing to the load
+          return { LT::HeatingHeatPumpBackup => [object.name.to_s] }
         end
 
       end