urbanopt-cli 0.8.2 → 0.9.0

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

@@ -9,6 +9,7 @@ require_relative '../HPXMLtoOpenStudio/resources/constants.rb'
 require_relative '../HPXMLtoOpenStudio/resources/location.rb'
 require_relative '../HPXMLtoOpenStudio/resources/meta_measure.rb'
 require_relative '../HPXMLtoOpenStudio/resources/output.rb'
+require_relative '../HPXMLtoOpenStudio/resources/util'
 
 # start the measure
 class ReportUtilityBills < OpenStudio::Measure::ReportingMeasure
@@ -29,7 +30,7 @@ class ReportUtilityBills < OpenStudio::Measure::ReportingMeasure
   end
 
   # define the arguments that the user will input
-  def arguments(model = nil)
+  def arguments(model = nil) # rubocop:disable Lint/UnusedMethodArgument
     args = OpenStudio::Measure::OSArgumentVector.new
 
     format_chs = OpenStudio::StringVector.new
@@ -42,173 +43,19 @@ class ReportUtilityBills < OpenStudio::Measure::ReportingMeasure
     arg.setDefaultValue('csv')
     args << arg
 
-    # electricity_bill_type_choices = OpenStudio::StringVector.new
-    # electricity_bill_type_choices << 'Simple'
-    # electricity_bill_type_choices << 'Detailed'
-
-    # arg = OpenStudio::Measure::OSArgument::makeChoiceArgument('electricity_bill_type', electricity_bill_type_choices, true)
-    # arg.setDisplayName('Electricity: Simple or Detailed')
-    # arg.setDescription("Choose either 'Simple' or 'Detailed'. If 'Simple' is selected, electric utility bills are calculated based on user-defined fixed charge and marginal rate. If 'Detailed' is selected, electric utility bills are calculated based on either: a tariff from the OpenEI Utility Rate Database (URDB), or a real-time pricing rate.")
-    # arg.setDefaultValue('Simple')
-    # args << arg
-
-    # utility_rate_type_choices = OpenStudio::StringVector.new
-    # utility_rate_type_choices << 'Autoselect OpenEI'
-    # utility_rate_type_choices << 'Sample Real-Time Pricing Rate'
-    # utility_rate_type_choices << 'Sample Tiered Rate'
-    # utility_rate_type_choices << 'Sample Time-of-Use Rate'
-    # utility_rate_type_choices << 'Sample Tiered Time-of-Use Rate'
-    # utility_rate_type_choices << 'User-Specified'
-
-    # arg = OpenStudio::Measure::OSArgument::makeChoiceArgument('electricity_utility_rate_type', utility_rate_type_choices, false)
-    # arg.setDisplayName('Electricity: Utility Rate Type')
-    # arg.setDescription("Type of the utility rate. Required if electricity bill type is 'Detailed'.")
-    # arg.setDefaultValue('Autoselect OpenEI')
-    # args << arg
-
-    # arg = OpenStudio::Measure::OSArgument::makeStringArgument('electricity_utility_rate_user_specified', false)
-    # arg.setDisplayName('Electricity: User-Specified Utility Rate')
-    # arg.setDescription("Absolute/relative path of the json. Relative paths are relative to the HPXML file. Required if utility rate type is 'User-Specified'.")
-    # args << arg
-
-    arg = OpenStudio::Measure::OSArgument::makeDoubleArgument('electricity_fixed_charge', false)
-    arg.setDisplayName('Electricity: Fixed Charge')
-    arg.setUnits('$/month')
-    arg.setDescription('Monthly fixed charge for electricity.')
-    arg.setDefaultValue(12.0) # https://www.nrdc.org/experts/samantha-williams/there-war-attrition-electricity-fixed-charges says $11.19/month in 2018
-    args << arg
-
-    arg = OpenStudio::Measure::OSArgument::makeStringArgument('electricity_marginal_rate', false)
-    arg.setDisplayName('Electricity: Marginal Rate')
-    arg.setUnits('$/kWh')
-    arg.setDescription("Price per kilowatt-hour for electricity. Use '#{Constants.Auto}' to obtain a state-average value from EIA.")
-    arg.setDefaultValue(Constants.Auto)
-    args << arg
-
-    arg = OpenStudio::Measure::OSArgument::makeDoubleArgument('natural_gas_fixed_charge', false)
-    arg.setDisplayName('Natural Gas: Fixed Charge')
-    arg.setUnits('$/month')
-    arg.setDescription('Monthly fixed charge for natural gas.')
-    arg.setDefaultValue(12.0) # https://www.aga.org/sites/default/files/aga_energy_analysis_-_natural_gas_utility_rate_structure.pdf says $11.25/month in 2015
-    args << arg
-
-    arg = OpenStudio::Measure::OSArgument::makeStringArgument('natural_gas_marginal_rate', false)
-    arg.setDisplayName('Natural Gas: Marginal Rate')
-    arg.setUnits('$/therm')
-    arg.setDescription("Price per therm for natural gas. Use '#{Constants.Auto}' to obtain a state-average value from EIA.")
-    arg.setDefaultValue(Constants.Auto)
-    args << arg
-
-    arg = OpenStudio::Measure::OSArgument::makeStringArgument('fuel_oil_marginal_rate', false)
-    arg.setDisplayName('Fuel Oil: Marginal Rate')
-    arg.setUnits('$/gal')
-    arg.setDescription("Price per gallon for fuel oil. Use '#{Constants.Auto}' to obtain a state-average value from EIA.")
-    arg.setDefaultValue(Constants.Auto)
-    args << arg
-
-    arg = OpenStudio::Measure::OSArgument::makeStringArgument('propane_marginal_rate', false)
-    arg.setDisplayName('Propane: Marginal Rate')
-    arg.setUnits('$/gal')
-    arg.setDescription("Price per gallon for propane. Use '#{Constants.Auto}' to obtain a state-average value from EIA.")
-    arg.setDefaultValue(Constants.Auto)
-    args << arg
-
-    arg = OpenStudio::Measure::OSArgument::makeDoubleArgument('wood_cord_marginal_rate', false)
-    arg.setDisplayName('Wood Cord: Marginal Rate')
-    arg.setUnits('$/kBtu')
-    arg.setDescription('Price per kBtu for wood cord.')
-    arg.setDefaultValue(0.015)
-    args << arg
-
-    arg = OpenStudio::Measure::OSArgument::makeDoubleArgument('wood_pellets_marginal_rate', false)
-    arg.setDisplayName('Wood Pellets: Marginal Rate')
-    arg.setUnits('$/kBtu')
-    arg.setDescription('Price per kBtu for wood pellets.')
-    arg.setDefaultValue(0.015)
-    args << arg
-
-    arg = OpenStudio::Measure::OSArgument::makeDoubleArgument('coal_marginal_rate', false)
-    arg.setDisplayName('Coal: Marginal Rate')
-    arg.setUnits('$/kBtu')
-    arg.setDescription('Price per kBtu for coal.')
-    arg.setDefaultValue(0.015)
-    args << arg
-
-    pv_compensation_type_choices = OpenStudio::StringVector.new
-    pv_compensation_type_choices << 'Net Metering'
-    pv_compensation_type_choices << 'Feed-In Tariff'
-
-    arg = OpenStudio::Measure::OSArgument::makeChoiceArgument('pv_compensation_type', pv_compensation_type_choices, false)
-    arg.setDisplayName('PV: Compensation Type')
-    arg.setDescription('The type of compensation for PV.')
-    arg.setDefaultValue('Net Metering')
-    args << arg
-
-    pv_annual_excess_sellback_rate_type_choices = OpenStudio::StringVector.new
-    pv_annual_excess_sellback_rate_type_choices << 'User-Specified'
-    pv_annual_excess_sellback_rate_type_choices << 'Retail Electricity Cost'
-
-    arg = OpenStudio::Measure::OSArgument::makeChoiceArgument('pv_annual_excess_sellback_rate_type', pv_annual_excess_sellback_rate_type_choices, false)
-    arg.setDisplayName('PV: Net Metering Annual Excess Sellback Rate Type')
-    arg.setDescription("The type of annual excess sellback rate for PV. Only applies if the PV compensation type is 'Net Metering'.")
-    arg.setDefaultValue('User-Specified')
-    args << arg
-
-    arg = OpenStudio::Measure::OSArgument::makeDoubleArgument('pv_net_metering_annual_excess_sellback_rate', false)
-    arg.setDisplayName('PV: Net Metering Annual Excess Sellback Rate')
-    arg.setUnits('$/kWh')
-    arg.setDescription("The annual excess sellback rate for PV. Only applies if the PV compensation type is 'Net Metering' and the PV annual excess sellback rate type is 'User-Specified'.")
-    arg.setDefaultValue(0.03)
-    args << arg
-
-    arg = OpenStudio::Measure::OSArgument::makeDoubleArgument('pv_feed_in_tariff_rate', false)
-    arg.setDisplayName('PV: Feed-In Tariff Rate')
-    arg.setUnits('$/kWh')
-    arg.setDescription("The annual full/gross tariff rate for PV. Only applies if the PV compensation type is 'Feed-In Tariff'.")
-    arg.setDefaultValue(0.12)
-    args << arg
-
-    pv_grid_connection_fee_units_choices = OpenStudio::StringVector.new
-    pv_grid_connection_fee_units_choices << '$/kW'
-    pv_grid_connection_fee_units_choices << '$'
-
-    arg = OpenStudio::Measure::OSArgument::makeChoiceArgument('pv_grid_connection_fee_units', pv_grid_connection_fee_units_choices, false)
-    arg.setDisplayName('PV: Grid Connection Fee Units')
-    arg.setDescription('Units for PV grid connection fee. Only applies when there is PV.')
-    arg.setDefaultValue('$/kW')
-    args << arg
-
-    arg = OpenStudio::Measure::OSArgument::makeDoubleArgument('pv_monthly_grid_connection_fee', false)
-    arg.setDisplayName('PV: Monthly Grid Connection Fee')
-    arg.setUnits('$')
-    arg.setDescription('Monthly fee for PV grid connection. Only applies when there is PV.')
-    arg.setDefaultValue(0.0)
-    args << arg
-
     return args
   end
 
-  def timeseries_frequency
-    # Use monthly for fossil fuels and simple electric rates
-    # Use hourly for detailed electric rates (URDB tariff or real time pricing)
-    return 'monthly'
-  end
-
-  def check_for_warnings(args, pv_systems)
+  def check_for_return_type_warnings()
     warnings = []
 
-    # Require full annual simulation
+    # Require full annual simulation if PV
     if !(@hpxml.header.sim_begin_month == 1 && @hpxml.header.sim_begin_day == 1 && @hpxml.header.sim_end_month == 12 && @hpxml.header.sim_end_day == 31)
-      if args[:electricity_bill_type] != 'Simple' || pv_systems.size > 0
-        warnings << 'A full annual simulation is required for calculating detailed utility bills.'
+      if @hpxml.pv_systems.size > 0
+        warnings << 'A full annual simulation is required for calculating utility bills for homes with PV.'
       end
     end
 
-    # Require user-specified utility rate if 'User-Specified'
-    if args[:electricity_bill_type] == 'Detailed' && args[:electricity_utility_rate_type].get == 'User-Specified' && !args[:electricity_utility_rate_user_specified].is_initialized
-      warnings << 'Must specify a utility rate json path when choosing User-Specified utility rate type.'
-    end
-
     # Require not DSE
     (@hpxml.heating_systems + @hpxml.heat_pumps).each do |htg_system|
       next unless (htg_system.is_a?(HPXML::HeatingSystem) && htg_system.is_heat_pump_backup_system) || htg_system.fraction_heat_load_served > 0
@@ -232,6 +79,19 @@ class ReportUtilityBills < OpenStudio::Measure::ReportingMeasure
     return warnings.uniq
   end
 
+  def check_for_next_type_warnings(utility_bill_scenario)
+    warnings = []
+
+    # Require full annual simulation if 'Detailed'
+    if !(@hpxml.header.sim_begin_month == 1 && @hpxml.header.sim_begin_day == 1 && @hpxml.header.sim_end_month == 12 && @hpxml.header.sim_end_day == 31)
+      if !utility_bill_scenario.elec_tariff_filepath.nil?
+        warnings << 'A full annual simulation is required for calculating detailed utility bills.'
+      end
+    end
+
+    return warnings.uniq
+  end
+
   # return a vector of IdfObject's to request EnergyPlus objects needed by the run method
   def energyPlusOutputRequests(runner, user_arguments)
     super(runner, user_arguments)
@@ -251,24 +111,42 @@ class ReportUtilityBills < OpenStudio::Measure::ReportingMeasure
       return result
     end
 
-    # assign the user inputs to variables
-    args = get_argument_values(runner, arguments(@model), user_arguments)
-    args = Hash[args.collect { |k, v| [k.to_sym, v] }]
-    args[:electricity_bill_type] = 'Simple' # TODO: support Detailed
-
     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)
 
-    warnings = check_for_warnings(args, @hpxml.pv_systems)
+    warnings = check_for_return_type_warnings()
     return result if !warnings.empty?
 
-    fuels, _, _ = setup_outputs()
+    fuels = setup_fuel_outputs()
+
+    hpxml_fuel_map = { FT::Elec => HPXML::FuelTypeElectricity,
+                       FT::Gas => HPXML::FuelTypeNaturalGas,
+                       FT::Oil => HPXML::FuelTypeOil,
+                       FT::Propane => HPXML::FuelTypePropane,
+                       FT::WoodCord => HPXML::FuelTypeWoodCord,
+                       FT::WoodPellets => HPXML::FuelTypeWoodPellets,
+                       FT::Coal => HPXML::FuelTypeCoal }
+
+    # Check for presence of fuels once
+    has_fuel = { HPXML::FuelTypeElectricity => true }
+    hpxml_doc = @hpxml.to_oga
+    Constants.FossilFuels.each do |fuel|
+      has_fuel[fuel] = @hpxml.has_fuel(fuel, hpxml_doc)
+    end
 
     # Fuel outputs
-    fuels.each do |fuel_type, fuel|
+    fuels.each do |(fuel_type, is_production), fuel|
       fuel.meters.each do |meter|
-        result << OpenStudio::IdfObject.load("Output:Meter,#{meter},#{timeseries_frequency};").get
+        next unless has_fuel[hpxml_fuel_map[fuel_type]]
+        next if is_production && @hpxml.pv_systems.empty?
+
+        if fuel_type == FT::Elec
+          result << OpenStudio::IdfObject.load("Output:Meter,#{meter},monthly;").get if @hpxml.header.utility_bill_scenarios.has_simple_electric_rates
+          result << OpenStudio::IdfObject.load("Output:Meter,#{meter},hourly;").get if @hpxml.header.utility_bill_scenarios.has_detailed_electric_rates
+        else
+          result << OpenStudio::IdfObject.load("Output:Meter,#{meter},monthly;").get
+        end
       end
     end
 
@@ -303,7 +181,6 @@ class ReportUtilityBills < OpenStudio::Measure::ReportingMeasure
     # assign the user inputs to variables
     args = get_argument_values(runner, arguments(model), user_arguments)
     args = Hash[args.collect { |k, v| [k.to_sym, v] }]
-    args[:electricity_bill_type] = 'Simple' # TODO: support Detailed
     output_format = args[:output_format].get
 
     output_dir = File.dirname(runner.lastEpwFilePath.get.to_s)
@@ -314,245 +191,255 @@ class ReportUtilityBills < OpenStudio::Measure::ReportingMeasure
     end
     @msgpackData = MessagePack.unpack(File.read(File.join(output_dir, 'eplusout.msgpack'), mode: 'rb'))
 
+    hpxml_path = @model.getBuilding.additionalProperties.getFeatureAsString('hpxml_path').get
     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)
 
-    warnings = check_for_warnings(args, @hpxml.pv_systems)
+    return true if @hpxml.header.utility_bill_scenarios.empty?
+
+    warnings = check_for_return_type_warnings()
     if register_warnings(runner, warnings)
       return true
     end
 
     # Set paths
     output_path = File.join(output_dir, "results_bills.#{output_format}")
+    FileUtils.rm(output_path) if File.exist?(output_path)
 
-    # Setup outputs
-    fuels, utility_rates, utility_bills = setup_outputs()
+    @hpxml.header.utility_bill_scenarios.each do |utility_bill_scenario|
+      warnings = check_for_next_type_warnings(utility_bill_scenario)
+      if register_warnings(runner, warnings)
+        next
+      end
 
-    # Get timestamps
-    @timestamps, _, _ = OutputMethods.get_timestamps(timeseries_frequency, @msgpackData, @hpxml)
+      # Setup fuel outputs
+      fuels = setup_fuel_outputs()
 
-    # Get outputs
-    get_outputs(fuels)
+      # Get outputs
+      get_outputs(fuels, utility_bill_scenario)
 
-    # Preprocess arguments
-    preprocess_arguments(args)
+      # Setup utility outputs
+      utility_rates, utility_bills = setup_utility_outputs()
 
-    # Get utility rates
-    warnings = get_utility_rates(fuels, utility_rates, args, @hpxml.header.state_code, @hpxml.pv_systems, runner)
-    if register_warnings(runner, warnings)
-      return true
-    end
+      # Get utility rates
+      warnings = get_utility_rates(hpxml_path, fuels, utility_rates, utility_bill_scenario, @hpxml.pv_systems)
+      if register_warnings(runner, warnings)
+        next
+      end
 
-    # Calculate utility bills
-    net_elec = get_utility_bills(fuels, utility_rates, utility_bills, args, @hpxml.header)
+      # Calculate utility bills
+      get_utility_bills(fuels, utility_rates, utility_bills, utility_bill_scenario, @hpxml.header)
 
-    # Annual true up
-    annual_true_up(utility_rates, utility_bills, net_elec)
+      # Write/report results
+      report_runperiod_output_results(runner, utility_bills, output_format, output_path, utility_bill_scenario.name)
+    end
 
-    # Calculate annual bills
-    get_annual_bills(utility_bills)
+    return true
+  end
 
-    # Report results
-    utility_bill_type_str = OpenStudio::toUnderscoreCase('Total USD')
-    utility_bill_type_val = utility_bills.sum { |fuel_type, utility_bill| utility_bill.annual_total.round(2) }.round(2)
-    runner.registerValue(utility_bill_type_str, utility_bill_type_val)
-    runner.registerInfo("Registering #{utility_bill_type_val} for #{utility_bill_type_str}.")
+  def report_runperiod_output_results(runner, utility_bills, output_format, output_path, bill_scenario_name)
+    segment = utility_bills.keys[0].split(':', 2)[0]
+    segment = segment.strip
 
-    utility_bills.each do |fuel_type, utility_bill|
-      if [FT::Elec, FT::Gas].include? fuel_type
-        utility_bill_type_str = OpenStudio::toUnderscoreCase("#{fuel_type} Fixed USD")
-        utility_bill_type_val = utility_bill.annual_fixed_charge.round(2)
-        runner.registerValue(utility_bill_type_str, utility_bill_type_val)
-        runner.registerInfo("Registering #{utility_bill_type_val} for #{utility_bill_type_str}.")
-      end
+    results_out = []
+    results_out << ["#{bill_scenario_name}: Total (USD)", utility_bills.values.sum { |bill| bill.annual_total.round(2) }.round(2)]
 
-      if [FT::Elec, FT::Gas].include? fuel_type
-        utility_bill_type_str = OpenStudio::toUnderscoreCase("#{fuel_type} Marginal USD")
-        utility_bill_type_val = utility_bill.annual_energy_charge.round(2)
-        runner.registerValue(utility_bill_type_str, utility_bill_type_val)
-        runner.registerInfo("Registering #{utility_bill_type_val} for #{utility_bill_type_str}.")
+    utility_bills.each do |fuel_type, bill|
+      new_segment = fuel_type.split(':', 2)[0]
+      new_segment = new_segment.strip
+      if new_segment != segment
+        segment = new_segment
       end
 
-      if [FT::Elec].include? fuel_type
-        utility_bill_type_str = OpenStudio::toUnderscoreCase("#{fuel_type} PV Credit USD")
-        utility_bill_type_val = utility_bill.annual_production_credit.round(2)
-        runner.registerValue(utility_bill_type_str, utility_bill_type_val)
-        runner.registerInfo("Registering #{utility_bill_type_val} for #{utility_bill_type_str}.")
+      results_out << ["#{bill_scenario_name}: #{fuel_type}: Fixed (USD)", bill.annual_fixed_charge.round(2)] if bill.annual_fixed_charge != 0
+      results_out << ["#{bill_scenario_name}: #{fuel_type}: Energy (USD)", bill.annual_energy_charge.round(2)] if bill.annual_energy_charge != 0
+      results_out << ["#{bill_scenario_name}: #{fuel_type}: PV Credit (USD)", bill.annual_production_credit.round(2)] if [FT::Elec].include?(fuel_type) && bill.annual_production_credit != 0
+      results_out << ["#{bill_scenario_name}: #{fuel_type}: Total (USD)", bill.annual_total.round(2)] if bill.annual_total != 0
+    end
+
+    if ['csv'].include? output_format
+      CSV.open(output_path, 'a') { |csv| results_out.to_a.each { |elem| csv << elem } }
+    elsif ['json', 'msgpack'].include? output_format
+      h = {}
+      results_out.each do |out|
+        if out[0].include? ':'
+          grp, name = out[0].split(':', 2)
+          h[grp] = {} if h[grp].nil?
+          h[grp][name.strip] = out[1]
+        else
+          h[out[0]] = out[1]
+        end
       end
 
-      utility_bill_type_str = OpenStudio::toUnderscoreCase("#{fuel_type} Total USD")
-      utility_bill_type_val = utility_bill.annual_total.round(2)
-      runner.registerValue(utility_bill_type_str, utility_bill_type_val)
-      runner.registerInfo("Registering #{utility_bill_type_val} for #{utility_bill_type_str}.")
+      if output_format == 'json'
+        require 'json'
+        File.open(output_path, 'a') { |json| json.write(JSON.pretty_generate(h)) }
+      elsif output_format == 'msgpack'
+        File.open(output_path, 'a') { |json| h.to_msgpack(json) }
+      end
     end
+    runner.registerInfo("Wrote bills output to #{output_path}.")
 
-    # Write results
-    write_output(runner, utility_bills, output_format, output_path)
+    results_out.each do |name, value|
+      next if name.nil? || value.nil?
 
-    return true
-  end
+      name = OpenStudio::toUnderscoreCase(name).chomp('_')
 
-  def preprocess_arguments(args)
-    args[:electricity_fixed_charge] = args[:electricity_fixed_charge].get
-    args[:electricity_marginal_rate] = args[:electricity_marginal_rate].get
-    args[:natural_gas_fixed_charge] = args[:natural_gas_fixed_charge].get
-    args[:natural_gas_marginal_rate] = args[:natural_gas_marginal_rate].get
-    args[:fuel_oil_marginal_rate] = args[:fuel_oil_marginal_rate].get
-    args[:propane_marginal_rate] = args[:propane_marginal_rate].get
-    args[:wood_cord_marginal_rate] = args[:wood_cord_marginal_rate].get
-    args[:wood_pellets_marginal_rate] = args[:wood_pellets_marginal_rate].get
-    args[:coal_marginal_rate] = args[:coal_marginal_rate].get
-    args[:pv_compensation_type] = args[:pv_compensation_type].get
-    args[:pv_annual_excess_sellback_rate_type] = args[:pv_annual_excess_sellback_rate_type].get
-    args[:pv_net_metering_annual_excess_sellback_rate] = args[:pv_net_metering_annual_excess_sellback_rate].get
-    args[:pv_feed_in_tariff_rate] = args[:pv_feed_in_tariff_rate].get
-    args[:pv_grid_connection_fee_units] = args[:pv_grid_connection_fee_units].get
-    args[:pv_monthly_grid_connection_fee] = args[:pv_monthly_grid_connection_fee].get
+      runner.registerValue(name, value)
+      runner.registerInfo("Registering #{value} for #{name}.")
+    end
   end
 
-  def get_utility_rates(fuels, utility_rates, args, state_code, pv_systems, runner = nil)
+  def get_utility_rates(hpxml_path, fuels, utility_rates, bill_scenario, pv_systems)
     warnings = []
     utility_rates.each do |fuel_type, rate|
       next if fuels[[fuel_type, false]].timeseries.sum == 0
 
       if fuel_type == FT::Elec
-        if args[:electricity_bill_type] == 'Simple'
-          rate.fixedmonthlycharge = args[:electricity_fixed_charge]
-          rate.flatratebuy = args[:electricity_marginal_rate]
-        elsif args[:electricity_bill_type] == 'Detailed'
-          if args[:electricity_utility_rate_type].get != 'Autoselect OpenEI'
-            if args[:electricity_utility_rate_type].get == 'User-Specified'
-              path = args[:electricity_utility_rate_user_specified].get
-
-              hpxml_path = @model.getBuilding.additionalProperties.getFeatureAsString('hpxml_path').get
-              filepath = FilePath.check_path(path,
-                                             File.dirname(hpxml_path),
-                                             'Tariff File')
-            else # sample rates
-              custom_rates_folder = File.join(File.dirname(__FILE__), 'resources/Data/CustomRates')
-              custom_rate_file = "#{args[:electricity_utility_rate_type].get}.json"
-              filepath = File.join(custom_rates_folder, custom_rate_file)
-            end
+        if bill_scenario.elec_tariff_filepath.nil?
+          rate.fixedmonthlycharge = bill_scenario.elec_fixed_charge
+          rate.flatratebuy = bill_scenario.elec_marginal_rate
+        else
+          require 'json'
 
-            fileread = File.read(filepath)
-            tariff = JSON.parse(fileread, symbolize_names: true)
-            tariff = tariff[:items][0]
+          filepath = FilePath.check_path(bill_scenario.elec_tariff_filepath,
+                                         File.dirname(hpxml_path),
+                                         'Tariff File')
 
-            if tariff.keys.include?(:realtimepricing)
-              rate.fixedmonthlycharge = tariff[:fixedmonthlycharge] if tariff.keys.include?(:fixedmonthlycharge)
-              rate.realtimeprice = tariff[:realtimepricing].split(',').map { |v| Float(v) }
+          tariff = JSON.parse(File.read(filepath), symbolize_names: true)
+          tariff = tariff[:items][0]
+          fields = tariff.keys
 
+          if fields.include?(:fixedchargeunits)
+            if tariff[:fixedchargeunits] == '$/month'
+              rate.fixedmonthlycharge = 0.0 if fields.include?(:fixedchargefirstmeter) || fields.include?(:fixedchargeeaaddl)
+              rate.fixedmonthlycharge += tariff[:fixedchargefirstmeter] if fields.include?(:fixedchargefirstmeter)
+              rate.fixedmonthlycharge += tariff[:fixedchargeeaaddl] if fields.include?(:fixedchargeeaaddl)
             else
-              rate.fixedmonthlycharge = tariff[:fixedmonthlycharge] if tariff.keys.include?(:fixedmonthlycharge)
-              rate.flatratebuy = tariff[:flatratebuy] if tariff.keys.include?(:flatratebuy)
+              warnings << 'Fixed charge units must be $/month.'
+            end
+          end
 
-              rate.energyratestructure = tariff[:energyratestructure] if tariff.keys.include?(:energyratestructure)
-              rate.energyweekdayschedule = tariff[:energyweekdayschedule] if tariff.keys.include?(:energyweekdayschedule)
-              rate.energyweekendschedule = tariff[:energyweekendschedule] if tariff.keys.include?(:energyweekendschedule)
+          if fields.include?(:minchargeunits)
+            if tariff[:minchargeunits] == '$/month'
+              rate.minmonthlycharge = tariff[:mincharge] if fields.include?(:mincharge)
+            elsif tariff[:minchargeunits] == '$/year'
+              rate.minannualcharge = tariff[:mincharge] if fields.include?(:mincharge)
+            else
+              warnings << 'Min charge units must be either $/month or $/year.'
+            end
+          end
 
-              rate.demandratestructure = tariff[:demandratestructure] if tariff.keys.include?(:demandratestructure)
-              rate.demandweekdayschedule = tariff[:demandweekdayschedule] if tariff.keys.include?(:demandweekdayschedule)
-              rate.demandweekendschedule = tariff[:demandweekendschedule] if tariff.keys.include?(:demandweekendschedule)
+          if fields.include?(:realtimepricing)
+            rate.realtimeprice = tariff[:realtimepricing]
 
-              rate.flatdemandstructure = tariff[:flatdemandstructure] if tariff.keys.include?(:flatdemandstructure)
-            end
           else
-            # TODO
+            if !fields.include?(:energyweekdayschedule) || !fields.include?(:energyweekendschedule) || !fields.include?(:energyratestructure)
+              warnings << 'Tariff file must contain energyweekdayschedule, energyweekendschedule, and energyratestructure fields.'
+            end
+
+            if fields.include?(:demandweekdayschedule) || fields.include?(:demandweekendschedule) || fields.include?(:demandratestructure) || fields.include?(:flatdemandstructure)
+              warnings << 'Demand charges are not currently supported when calculating detailed utility bills.'
+            end
+
+            rate.energyratestructure = tariff[:energyratestructure]
+            rate.energyweekdayschedule = tariff[:energyweekdayschedule]
+            rate.energyweekendschedule = tariff[:energyweekendschedule]
+
+            if rate.energyratestructure.collect { |r| r.collect { |s| s.keys.include?(:rate) } }.flatten.any? { |t| !t }
+              warnings << 'Every tier must contain a rate.'
+            end
+
+            if rate.energyratestructure.collect { |r| r.collect { |s| s.keys } }.flatten.uniq.include?(:sell)
+              warnings << 'No tier may contain a sell key.'
+            end
+
+            if rate.energyratestructure.collect { |r| r.collect { |s| s.keys.include?(:unit) } }.flatten.any? { |t| !t }
+              warnings << 'Every tier must contain a unit'
+            end
+
+            if rate.energyratestructure.collect { |r| r.collect { |s| s[:unit] == 'kWh' } }.flatten.any? { |t| !t }
+              warnings << 'All rates must be in units of kWh.'
+            end
           end
         end
 
         # Net Metering
-        rate.net_metering_excess_sellback_type = args[:pv_annual_excess_sellback_rate_type] if args[:pv_compensation_type] == 'Net Metering'
-        rate.net_metering_user_excess_sellback_rate = args[:pv_net_metering_annual_excess_sellback_rate] if rate.net_metering_excess_sellback_type == 'User-Specified'
+        rate.net_metering_excess_sellback_type = bill_scenario.pv_net_metering_annual_excess_sellback_rate_type if bill_scenario.pv_compensation_type == HPXML::PVCompensationTypeNetMetering
+        rate.net_metering_user_excess_sellback_rate = bill_scenario.pv_net_metering_annual_excess_sellback_rate if rate.net_metering_excess_sellback_type == HPXML::PVAnnualExcessSellbackRateTypeUserSpecified
 
         # Feed-In Tariff
-        rate.feed_in_tariff_rate = args[:pv_feed_in_tariff_rate] if args[:pv_compensation_type] == 'Feed-In Tariff'
+        rate.feed_in_tariff_rate = bill_scenario.pv_feed_in_tariff_rate if bill_scenario.pv_compensation_type == HPXML::PVCompensationTypeFeedInTariff
       elsif fuel_type == FT::Gas
-        rate.fixedmonthlycharge = args[:natural_gas_fixed_charge]
-        rate.flatratebuy = args[:natural_gas_marginal_rate]
+        rate.fixedmonthlycharge = bill_scenario.natural_gas_fixed_charge
+        rate.flatratebuy = bill_scenario.natural_gas_marginal_rate
       elsif fuel_type == FT::Oil
-        rate.flatratebuy = args[:fuel_oil_marginal_rate]
+        rate.fixedmonthlycharge = bill_scenario.fuel_oil_fixed_charge
+        rate.flatratebuy = bill_scenario.fuel_oil_marginal_rate
       elsif fuel_type == FT::Propane
-        rate.flatratebuy = args[:propane_marginal_rate]
+        rate.fixedmonthlycharge = bill_scenario.propane_fixed_charge
+        rate.flatratebuy = bill_scenario.propane_marginal_rate
       elsif fuel_type == FT::WoodCord
-        rate.flatratebuy = args[:wood_cord_marginal_rate]
+        rate.fixedmonthlycharge = bill_scenario.wood_fixed_charge
+        rate.flatratebuy = bill_scenario.wood_marginal_rate
       elsif fuel_type == FT::WoodPellets
-        rate.flatratebuy = args[:wood_pellets_marginal_rate]
+        rate.fixedmonthlycharge = bill_scenario.wood_pellets_fixed_charge
+        rate.flatratebuy = bill_scenario.wood_pellets_marginal_rate
       elsif fuel_type == FT::Coal
-        rate.flatratebuy = args[:coal_marginal_rate]
+        rate.fixedmonthlycharge = bill_scenario.coal_fixed_charge
+        rate.flatratebuy = bill_scenario.coal_marginal_rate
       end
 
-      if rate.flatratebuy == Constants.Auto
-        if [FT::Elec, FT::Gas, FT::Oil, FT::Propane].include? fuel_type
-          rate.flatratebuy = get_auto_marginal_rate(runner, state_code, fuel_type, rate.fixedmonthlycharge)
-
-          if !rate.flatratebuy.nil?
-            runner.registerInfo("Found a marginal rate of '#{rate.flatratebuy}' for #{fuel_type}.") if !runner.nil?
-          else
-            warnings << "Could not find a marginal #{fuel_type} rate." if rate.flatratebuy.nil?
-          end
-        end
-      else
-        rate.flatratebuy = Float(rate.flatratebuy)
-      end
+      warnings << "Could not find a marginal #{fuel_type} rate." if rate.flatratebuy.nil?
 
       # Grid connection fee
       next unless fuel_type == FT::Elec
 
-      next unless args[:electricity_bill_type] == 'Simple'
-
       next unless pv_systems.size > 0
 
       monthly_fee = 0.0
-      if args[:pv_grid_connection_fee_units] == '$/kW'
+      if not bill_scenario.pv_monthly_grid_connection_fee_dollars_per_kw.nil?
         pv_systems.each do |pv_system|
           max_power_output_kW = UnitConversions.convert(pv_system.max_power_output, 'W', 'kW')
-          monthly_fee += args[:pv_monthly_grid_connection_fee] * max_power_output_kW
+          monthly_fee += bill_scenario.pv_monthly_grid_connection_fee_dollars_per_kw * max_power_output_kW
         end
-      elsif args[:pv_grid_connection_fee_units] == '$'
-        monthly_fee = args[:pv_monthly_grid_connection_fee]
+      elsif not bill_scenario.pv_monthly_grid_connection_fee_dollars.nil?
+        monthly_fee = bill_scenario.pv_monthly_grid_connection_fee_dollars
       end
       rate.fixedmonthlycharge += monthly_fee
     end
     return warnings
   end
 
-  def get_utility_bills(fuels, utility_rates, utility_bills, args, header)
+  def get_utility_bills(fuels, utility_rates, utility_bills, utility_bill_scenario, header)
     net_elec = 0
+
+    # Simple
     fuels.each do |(fuel_type, is_production), fuel|
       rate = utility_rates[fuel_type]
       bill = utility_bills[fuel_type]
 
       if fuel_type == FT::Elec
-        if args[:electricity_bill_type] == 'Detailed' && rate.realtimeprice.empty?
-          net_elec = CalculateUtilityBill.detailed_electric(fuels, rate, bill, net_elec)
-        else
+        if utility_bill_scenario.elec_tariff_filepath.nil?
           net_elec = CalculateUtilityBill.simple(fuel_type, header, fuel.timeseries, is_production, rate, bill, net_elec)
         end
       else
         net_elec = CalculateUtilityBill.simple(fuel_type, header, fuel.timeseries, is_production, rate, bill, net_elec)
       end
     end
-    return net_elec
-  end
 
-  def annual_true_up(utility_rates, utility_bills, net_elec)
-    rate = utility_rates[FT::Elec]
-    bill = utility_bills[FT::Elec]
-    if rate.net_metering_excess_sellback_type == 'User-Specified'
-      if bill.annual_production_credit > bill.annual_energy_charge
-        bill.annual_production_credit = bill.annual_energy_charge
-      end
-      if net_elec < 0
-        bill.annual_production_credit += -net_elec * rate.net_metering_user_excess_sellback_rate
-      end
+    # Detailed
+    if !utility_bill_scenario.elec_tariff_filepath.nil?
+      rate = utility_rates[FT::Elec]
+      bill = utility_bills[FT::Elec]
+
+      CalculateUtilityBill.detailed_electric(header, fuels, rate, bill)
     end
-  end
 
-  def get_annual_bills(utility_bills)
+    # Calculate totals
     utility_bills.values.each do |bill|
-      if bill.annual_production_credit > 0
+      if bill.annual_production_credit != 0
         bill.annual_production_credit *= -1
       end
 
@@ -560,7 +447,7 @@ class ReportUtilityBills < OpenStudio::Measure::ReportingMeasure
     end
   end
 
-  def setup_outputs()
+  def setup_fuel_outputs()
     def get_timeseries_units_from_fuel_type(fuel_type)
       if fuel_type == FT::Elec
         return 'kWh'
@@ -581,10 +468,14 @@ class ReportUtilityBills < OpenStudio::Measure::ReportingMeasure
     fuels[[FT::WoodPellets, false]] = Fuel.new(meters: ["#{EPlus::FuelTypeWoodPellets}:Facility"])
     fuels[[FT::Coal, false]] = Fuel.new(meters: ["#{EPlus::FuelTypeCoal}:Facility"])
 
-    fuels.each do |(fuel_type, is_production), fuel|
+    fuels.each do |(fuel_type, _is_production), fuel|
       fuel.units = get_timeseries_units_from_fuel_type(fuel_type)
     end
 
+    return fuels
+  end
+
+  def setup_utility_outputs()
     utility_rates = {}
     utility_rates[FT::Elec] = UtilityRate.new
     utility_rates[FT::Gas] = UtilityRate.new
@@ -603,16 +494,19 @@ class ReportUtilityBills < OpenStudio::Measure::ReportingMeasure
     utility_bills[FT::WoodPellets] = UtilityBill.new
     utility_bills[FT::Coal] = UtilityBill.new
 
-    return fuels, utility_rates, utility_bills
+    return utility_rates, utility_bills
   end
 
-  def get_outputs(fuels)
-    fuels.each do |(fuel_type, is_production), fuel|
+  def get_outputs(fuels, utility_bill_scenario)
+    fuels.each do |(fuel_type, _is_production), fuel|
       unit_conv = UnitConversions.convert(1.0, 'J', fuel.units)
       unit_conv /= 139.0 if fuel_type == FT::Oil
       unit_conv /= 91.6 if fuel_type == FT::Propane
 
-      fuel.timeseries = get_report_meter_data_timeseries(fuel.meters, unit_conv, 0)
+      timeseries_freq = 'monthly'
+      timeseries_freq = 'hourly' if fuel_type == FT::Elec && !utility_bill_scenario.elec_tariff_filepath.nil?
+      num_timestamps = OutputMethods.get_timestamps(@msgpackData, @hpxml, false)[0].size
+      fuel.timeseries = get_report_meter_data_timeseries(fuel.meters, unit_conv, 0, num_timestamps, timeseries_freq)
     end
   end
 
@@ -625,15 +519,15 @@ class ReportUtilityBills < OpenStudio::Measure::ReportingMeasure
     }
   end
 
-  def get_report_meter_data_timeseries(meter_names, unit_conv, unit_adder)
-    return [0.0] * @timestamps.size if meter_names.empty?
+  def get_report_meter_data_timeseries(meter_names, unit_conv, unit_adder, num_timestamps, timeseries_freq)
+    return [0.0] * num_timestamps if meter_names.empty?
 
-    msgpack_timeseries_name = OutputMethods.msgpack_frequency_map[timeseries_frequency]
+    msgpack_timeseries_name = OutputMethods.msgpack_frequency_map[timeseries_freq]
     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'] }
     vals = []
-    rows.each_with_index do |row, idx|
+    rows.each do |row|
       row = row[row.keys[0]]
       val = 0.0
       indexes.each do |i|
@@ -643,179 +537,6 @@ class ReportUtilityBills < OpenStudio::Measure::ReportingMeasure
     end
     return vals
   end
-
-  def average_rate_to_marginal_rate(average_rate, fixed_rate, household_consumption)
-    return average_rate - 12.0 * fixed_rate / household_consumption
-  end
-
-  def get_household_consumption(state_code, fuel_type)
-    rows = CSV.read(File.join(File.dirname(__FILE__), 'resources/Data/UtilityRates/HouseholdConsumption.csv'))
-    rows.each do |row|
-      next if row[0] != state_code
-
-      if fuel_type == FT::Elec
-        return Float(row[1])
-      elsif fuel_type == FT::Gas
-        return Float(row[2])
-      end
-    end
-  end
-
-  def get_auto_marginal_rate(runner, state_code, fuel_type, fixed_rate)
-    state_name = Constants.StateCodesMap[state_code]
-    return if state_name.nil?
-
-    average_rate = nil
-    marginal_rate = nil
-    if fuel_type == FT::Elec
-      year_ix = nil
-      rows = CSV.read(File.join(File.dirname(__FILE__), 'resources/Data/UtilityRates/Average_retail_price_of_electricity.csv'))
-      rows.each do |row|
-        year_ix = row.index('2021') if row[0] == 'description'
-        next if row[0].upcase != "Residential : #{state_name}".upcase
-
-        average_rate = Float(row[year_ix]) / 100.0 # Convert cents/kWh to $/kWh
-      end
-
-      household_consumption = get_household_consumption(state_code, fuel_type)
-      marginal_rate = average_rate_to_marginal_rate(average_rate, fixed_rate, household_consumption)
-
-    elsif fuel_type == FT::Gas
-      rows = CSV.read(File.join(File.dirname(__FILE__), 'resources/Data/UtilityRates/NG_PRI_SUM_A_EPG0_PRS_DMCF_A.csv'))
-      rows = rows[2..-1]
-
-      state_ix = rows[0].index("#{state_name} Price of Natural Gas Delivered to Residential Consumers (Dollars per Thousand Cubic Feet)")
-      rows[1..-1].each do |row|
-        average_rate = Float(row[state_ix]) / 10.37 if !row[state_ix].nil? # Convert Mcf to therms, from https://www.eia.gov/tools/faqs/faq.php?id=45&t=7
-      end
-
-      household_consumption = get_household_consumption(state_code, fuel_type)
-      marginal_rate = average_rate_to_marginal_rate(average_rate, fixed_rate, household_consumption)
-
-    elsif [FT::Oil, FT::Propane].include? fuel_type
-      if fuel_type == FT::Oil
-        marginal_rates = get_gallon_marginal_rates('PET_PRI_WFR_A_EPD2F_PRS_DPGAL_W.csv')
-        header = "Weekly #{state_name} Weekly No. 2 Heating Oil Residential Price  (Dollars per Gallon)"
-      elsif fuel_type == FT::Propane
-        marginal_rates = marginal_rates = get_gallon_marginal_rates('PET_PRI_WFR_A_EPLLPA_PRS_DPGAL_W.csv')
-        header = "Weekly #{state_name} Propane Residential Price  (Dollars per Gallon)"
-      end
-
-      if marginal_rates[header].nil?
-        padd = get_state_code_to_padd[state_code]
-        marginal_rates.each do |k, v|
-          header = k if k.include?(padd)
-        end
-        average = "region (#{padd})"
-
-        if marginal_rates[header].nil?
-          if fuel_type == FT::Oil
-            header = 'Weekly U.S. Weekly No. 2 Heating Oil Residential Price  (Dollars per Gallon)'
-          elsif fuel_type == FT::Propane
-            header = 'Weekly U.S. Propane Residential Price  (Dollars per Gallon)'
-          end
-          average = 'national'
-        end
-
-        runner.registerWarning("Could not find state average #{fuel_type} rate based on #{state_name}; using #{average} average.") if !runner.nil?
-      end
-      marginal_rate = marginal_rates[header].sum / marginal_rates[header].size
-    end
-
-    return marginal_rate
-  end
-
-  def get_state_code_to_padd
-    # https://www.eia.gov/tools/glossary/index.php?id=petroleum%20administration%20for%20defense%20district
-    padd_to_state_codes = { 'PADD 1A' => ['CT', 'MA', 'ME', 'NH', 'RI', 'VT'],
-                            'PADD 1B' => ['DE', 'DC', 'MD', 'NJ', 'NY', 'PA'],
-                            'PADD 1C' => ['FL', 'GA', 'NC', 'SC', 'WV', 'VA'],
-                            'PADD 2' => ['IA', 'IL', 'IN', 'KS', 'KY', 'MI', 'MN', 'MO', 'ND', 'NE', 'OH', 'OK', 'SD', 'TN', 'WI'],
-                            'PADD 3' => ['AL', 'AR', 'LA', 'MS', 'NM', 'TX'],
-                            'PADD 4' => ['CO', 'ID', 'MT', 'UT', 'WY'],
-                            'PADD 5' => ['AK', 'AZ', 'CA', 'HI', 'NV', 'OR', 'WA'] }
-
-    state_code_to_padd = {}
-    padd_to_state_codes.each do |padd, state_codes|
-      state_codes.each do |state_code|
-        state_code_to_padd[state_code] = padd
-      end
-    end
-
-    return state_code_to_padd
-  end
-
-  def get_gallon_marginal_rates(filename)
-    marginal_rates = {}
-
-    rows = CSV.read(File.join(File.dirname(__FILE__), "resources/Data/UtilityRates/#{filename}"))
-    rows = rows[2..-1]
-    headers = rows[0]
-
-    rows = rows.reverse[1..26].transpose
-    rows.each_with_index do |row, i|
-      marginal_rates[headers[i]] = row
-    end
-
-    marginal_rates.delete('Date')
-    marginal_rates.each do |header, values|
-      if values.all? { |x| x.nil? }
-        marginal_rates.delete(header)
-        next
-      end
-      marginal_rates[header] = marginal_rates[header].map { |x| Float(x) }
-    end
-
-    return marginal_rates
-  end
-
-  def write_output(runner, utility_bills, output_format, output_path)
-    line_break = nil
-
-    segment = utility_bills.keys[0].split(':', 2)[0]
-    segment = segment.strip
-    results_out = []
-    results_out << ['Total ($)', utility_bills.sum { |key, bill| bill.annual_total.round(2) }.round(2)]
-    results_out << [line_break]
-    utility_bills.each do |key, bill|
-      new_segment = key.split(':', 2)[0]
-      new_segment = new_segment.strip
-      if new_segment != segment
-        results_out << [line_break]
-        segment = new_segment
-      end
-
-      results_out << ["#{key}: Fixed ($)", bill.annual_fixed_charge.round(2)] if [FT::Elec, FT::Gas].include? key
-      results_out << ["#{key}: Marginal ($)", bill.annual_energy_charge.round(2)] if [FT::Elec, FT::Gas].include? key
-      results_out << ["#{key}: PV Credit ($)", bill.annual_production_credit.round(2)] if [FT::Elec].include? key
-      results_out << ["#{key}: Total ($)", bill.annual_total.round(2)]
-    end
-
-    if ['csv'].include? output_format
-      CSV.open(output_path, 'wb') { |csv| results_out.to_a.each { |elem| csv << elem } }
-    elsif ['json', 'msgpack'].include? output_format
-      h = {}
-      results_out.each do |out|
-        next if out == [line_break]
-
-        if out[0].include? ':'
-          grp, name = out[0].split(':', 2)
-          h[grp] = {} if h[grp].nil?
-          h[grp][name.strip] = out[1]
-        else
-          h[out[0]] = out[1]
-        end
-      end
-
-      if output_format == 'json'
-        require 'json'
-        File.open(output_path, 'w') { |json| json.write(JSON.pretty_generate(h)) }
-      elsif output_format == 'msgpack'
-        File.open(output_path, 'w') { |json| h.to_msgpack(json) }
-      end
-    end
-    runner.registerInfo("Wrote bills output to #{output_path}.")
-  end
 end
 
 # register the measure to be used by the application