urbanopt-cli 0.6.2 → 0.7.1

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

@@ -45,34 +45,36 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
   end
 
   def test_tank_gas_uef
-    args_hash = {}
-    args_hash['hpxml_path'] = File.absolute_path(File.join(sample_files_dir, 'base-dhw-tank-gas-uef.xml'))
-    model, hpxml = _test_measure(args_hash)
-
-    # Get HPXML values
-    water_heating_system = hpxml.water_heating_systems[0]
-
-    # Expected value
-    tank_volume = UnitConversions.convert(water_heating_system.tank_volume * 0.95, 'gal', 'm^3') # convert to actual volume
-    cap = UnitConversions.convert(water_heating_system.heating_capacity / 1000.0, 'kBtu/hr', 'W')
-    fuel = EPlus.fuel_type(water_heating_system.fuel_type)
-    ua = UnitConversions.convert(6.476, 'Btu/(hr*F)', 'W/K')
-    t_set = UnitConversions.convert(water_heating_system.temperature, 'F', 'C') + 1 # setpoint + 1/2 deadband
-    ther_eff = 0.762
-    loc = water_heating_system.location
-
-    # Check water heater
-    assert_equal(1, model.getWaterHeaterMixeds.size)
-    wh = model.getWaterHeaterMixeds[0]
-    assert_equal(fuel, wh.heaterFuelType)
-    assert_equal(loc, wh.ambientTemperatureThermalZone.get.name.get)
-    assert_in_epsilon(tank_volume, wh.tankVolume.get, 0.001)
-    assert_in_epsilon(cap, wh.heaterMaximumCapacity.get, 0.001)
-    assert_in_epsilon(ua, wh.onCycleLossCoefficienttoAmbientTemperature.get, 0.001)
-    assert_in_epsilon(ua, wh.offCycleLossCoefficienttoAmbientTemperature.get, 0.001)
-    assert_in_epsilon(t_set, wh.setpointTemperatureSchedule.get.to_ScheduleConstant.get.value, 0.001)
-    assert_in_epsilon(ther_eff, wh.heaterThermalEfficiency.get, 0.001)
-    assert_equal(0.64, wh.offCycleLossFractiontoThermalZone)
+    ['base-dhw-tank-gas-uef.xml', 'base-dhw-tank-gas-uef-fhr.xml'].each do |hpxml_name|
+      args_hash = {}
+      args_hash['hpxml_path'] = File.absolute_path(File.join(sample_files_dir, hpxml_name))
+      model, hpxml = _test_measure(args_hash)
+
+      # Get HPXML values
+      water_heating_system = hpxml.water_heating_systems[0]
+
+      # Expected value
+      tank_volume = UnitConversions.convert(water_heating_system.tank_volume * 0.95, 'gal', 'm^3') # convert to actual volume
+      cap = UnitConversions.convert(water_heating_system.heating_capacity / 1000.0, 'kBtu/hr', 'W')
+      fuel = EPlus.fuel_type(water_heating_system.fuel_type)
+      ua = UnitConversions.convert(6.476, 'Btu/(hr*F)', 'W/K')
+      t_set = UnitConversions.convert(water_heating_system.temperature, 'F', 'C') + 1 # setpoint + 1/2 deadband
+      ther_eff = 0.762
+      loc = water_heating_system.location
+
+      # Check water heater
+      assert_equal(1, model.getWaterHeaterMixeds.size)
+      wh = model.getWaterHeaterMixeds[0]
+      assert_equal(fuel, wh.heaterFuelType)
+      assert_equal(loc, wh.ambientTemperatureThermalZone.get.name.get)
+      assert_in_epsilon(tank_volume, wh.tankVolume.get, 0.001)
+      assert_in_epsilon(cap, wh.heaterMaximumCapacity.get, 0.001)
+      assert_in_epsilon(ua, wh.onCycleLossCoefficienttoAmbientTemperature.get, 0.001)
+      assert_in_epsilon(ua, wh.offCycleLossCoefficienttoAmbientTemperature.get, 0.001)
+      assert_in_epsilon(t_set, wh.setpointTemperatureSchedule.get.to_ScheduleConstant.get.value, 0.001)
+      assert_in_epsilon(ther_eff, wh.heaterThermalEfficiency.get, 0.001)
+      assert_equal(0.64, wh.offCycleLossFractiontoThermalZone)
+    end
   end
 
   def test_tank_oil
@@ -1094,43 +1096,27 @@ class HPXMLtoOpenStudioWaterHeaterTest < MiniTest::Test
 
     # Get HPXML values
     water_heating_system = hpxml.water_heating_systems[0]
-    shared_water_heating_system = hpxml.water_heating_systems[1]
 
     # Expected value
-    tank_volumes = [UnitConversions.convert(water_heating_system.tank_volume * 0.9, 'gal', 'm^3'),
-                    UnitConversions.convert(shared_water_heating_system.tank_volume * 0.9, 'gal', 'm^3')] # convert to actual volume
-    caps = [UnitConversions.convert(water_heating_system.heating_capacity / 1000.0, 'kBtu/hr', 'W'),
-            UnitConversions.convert(shared_water_heating_system.heating_capacity / 1000.0, 'kBtu/hr', 'W')]
-    fuels = [EPlus.fuel_type(water_heating_system.fuel_type),
-             EPlus.fuel_type(shared_water_heating_system.fuel_type)]
-    uas = [UnitConversions.convert(1.335, 'Btu/(hr*F)', 'W/K'),
-           UnitConversions.convert(1.335 / shared_water_heating_system.number_of_units_served, 'Btu/(hr*F)', 'W/K')]
-    t_sets = [UnitConversions.convert(water_heating_system.temperature, 'F', 'C') + 1,
-              UnitConversions.convert(shared_water_heating_system.temperature, 'F', 'C') + 1] # setpoint + 1/2 deadband
-    ther_effs = [1.0, 1.0]
-    locs = [water_heating_system.location,
-            shared_water_heating_system.location]
+    tank_volume = UnitConversions.convert(water_heating_system.tank_volume * 0.95, 'gal', 'm^3') # convert to actual volume
+    cap = UnitConversions.convert(water_heating_system.heating_capacity / 1000.0, 'kBtu/hr', 'W')
+    fuel = EPlus.fuel_type(water_heating_system.fuel_type)
+    ua = UnitConversions.convert(7.88, 'Btu/(hr*F)', 'W/K') / water_heating_system.number_of_units_served
+    t_set = UnitConversions.convert(water_heating_system.temperature, 'F', 'C') + 1 # setpoint + 1/2 deadband
+    ther_eff = 0.773
+    loc = water_heating_system.location
 
     # Check water heater
-    assert_equal(2, model.getWaterHeaterMixeds.size)
-    wh = model.getWaterHeaterMixeds.sort[0]
-    assert_equal(fuels[0], wh.heaterFuelType)
-    assert_equal(locs[0], wh.ambientTemperatureThermalZone.get.name.get)
-    assert_in_epsilon(tank_volumes[0], wh.tankVolume.get, 0.001)
-    assert_in_epsilon(caps[0], wh.heaterMaximumCapacity.get, 0.001)
-    assert_in_epsilon(uas[0], wh.onCycleLossCoefficienttoAmbientTemperature.get, 0.001)
-    assert_in_epsilon(uas[0], wh.offCycleLossCoefficienttoAmbientTemperature.get, 0.001)
-    assert_in_epsilon(t_sets[0], wh.setpointTemperatureSchedule.get.to_ScheduleConstant.get.value, 0.001)
-    assert_in_epsilon(ther_effs[0], wh.heaterThermalEfficiency.get, 0.001)
-    wh = model.getWaterHeaterMixeds.sort[1]
-    assert_equal(fuels[1], wh.heaterFuelType)
-    assert_equal('Schedule', wh.ambientTemperatureIndicator)
-    assert_in_epsilon(tank_volumes[1], wh.tankVolume.get, 0.001)
-    assert_in_epsilon(caps[1], wh.heaterMaximumCapacity.get, 0.001)
-    assert_in_epsilon(uas[1], wh.onCycleLossCoefficienttoAmbientTemperature.get, 0.001)
-    assert_in_epsilon(uas[1], wh.offCycleLossCoefficienttoAmbientTemperature.get, 0.001)
-    assert_in_epsilon(t_sets[1], wh.setpointTemperatureSchedule.get.to_ScheduleConstant.get.value, 0.001)
-    assert_in_epsilon(ther_effs[1], wh.heaterThermalEfficiency.get, 0.001)
+    assert_equal(1, model.getWaterHeaterMixeds.size)
+    wh = model.getWaterHeaterMixeds[0]
+    assert_equal(fuel, wh.heaterFuelType)
+    assert_equal(loc, wh.ambientTemperatureThermalZone.get.name.get)
+    assert_in_epsilon(tank_volume, wh.tankVolume.get, 0.001)
+    assert_in_epsilon(cap, wh.heaterMaximumCapacity.get, 0.001)
+    assert_in_epsilon(ua, wh.onCycleLossCoefficienttoAmbientTemperature.get, 0.001)
+    assert_in_epsilon(ua, wh.offCycleLossCoefficienttoAmbientTemperature.get, 0.001)
+    assert_in_epsilon(t_set, wh.setpointTemperatureSchedule.get.to_ScheduleConstant.get.value, 0.001)
+    assert_in_epsilon(ther_eff, wh.heaterThermalEfficiency.get, 0.001)
   end
 
   def _test_measure(args_hash)

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

@@ -15,7 +15,7 @@ def get_ems_values(ems_objects, name)
       # eg. "Q = Q + 1.5"
       if rhs.include? '+'
         rhs_els = rhs.split('+')
-        rhs = rhs_els.map { |s| s.to_f }.sum(0.0)
+        rhs = rhs_els.map { |s| s.tr('()', '').to_f }.sum(0.0)
       else
         rhs = rhs.to_f
       end

data/example_files/resources/hpxml-measures/LICENSE.md

@@ -1,4 +1,4 @@
-OpenStudio® HPXML Measures, Copyright (c) 2008-2020, Alliance for Sustainable Energy, LLC, and other contributors. All rights reserved.
+OpenStudio® HPXML Measures, Copyright (c) 2008-2021, Alliance for Sustainable Energy, LLC, and other contributors. All rights reserved.
 
 Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
 following conditions are met:

data/example_files/resources/hpxml-measures/README.md

@@ -15,25 +15,28 @@ For more information on running simulations, generating HPXML files, etc., pleas
 ## Workflows
 
 A simple [run_simulation.rb script](https://github.com/NREL/OpenStudio-HPXML/blob/master/workflow/run_simulation.rb) is provided to run a residential EnergyPlus simulation from an HPXML file.
-See the [Getting Started](https://openstudio-hpxml.readthedocs.io/en/latest/getting_started.html#getting-started) section of the documentation for running simulations.
+See the [Usage Instructions](https://openstudio-hpxml.readthedocs.io/en/latest/usage_instructions.html) for documentation on running the workflow.
 
-Since [OpenStudio measures](http://nrel.github.io/OpenStudio-user-documentation/getting_started/about_measures/) are used for model generation, additional OpenStudio-based workflows and interfaces can be used instead if desired.
+Since [OpenStudio measures](http://nrel.github.io/OpenStudio-user-documentation/getting_started/about_measures/) are used for model generation, additional OpenStudio-based workflows and interfaces can instead be used if desired.
 
 ## Measures
 
-This repository contains three OpenStudio measures:
-- `BuildResidentialHPXML`: A measure that translates a set of building unit argument values to an HPXML file.
+This repository contains several OpenStudio measures:
+- `BuildResidentialHPXML`: A measure that generates an HPXML file from a set of building description inputs (including, e.g., simplified geometry inputs).
+- `BuildResidentialScheduleFile`: A measure that generates a CSV of detailed schedules (e.g., stochastic occupancy) for use in the simulation.
 - `HPXMLtoOpenStudio`: A measure that translates an HPXML file to an OpenStudio model.
-- `SimulationOutputReport`: A reporting measure that generates a variety of annual/timeseries CSV outputs for a residential HPXML-based model.
+- `ReportSimulationOutput`: A reporting measure that generates a variety of simulation-based annual/timeseries outputs in CSV or JSON format.
+- `ReportHPXMLOutput`: A reporting measure that generates a variety of HPXML-based outputs (including defaults like autosized HVAC capacities) in CSV or JSON format.
 
 ## Projects
 
 The OpenStudio-HPXML workflow is used by a number of other residential projects, including:
-- [Energy Rating Index (ERI)](https://github.com/NREL/OpenStudio-ERI)
-- Home Energy Score (pending)
-- Weatherization Assistant (pending)
-- ResStock (pending)
+- [Energy Rating Index (ERI) and ENERGY STAR](https://github.com/NREL/OpenStudio-ERI)
+- [Home Energy Score](https://betterbuildingssolutioncenter.energy.gov/home-energy-score)
 - [UrbanOpt](https://www.nrel.gov/buildings/urbanopt.html)
+- [ResStock](https://resstock.nrel.gov/) (pending)
+- [BEopt](https://beopt.nrel.gov) (pending)
+- [Weatherization Assistant](https://weatherization.ornl.gov/obtain) (pending)
 
 ## License
 

data/example_files/resources/hpxml-measures/Rakefile

@@ -8,7 +8,7 @@ require 'rake/testtask'
 
 desc 'Run all tests'
 Rake::TestTask.new('test_all') do |t|
-  t.test_files = Dir['*/tests/*.rb'] - Dir['workflow/tests/compare.rb']
+  t.test_files = Dir['*/tests/*.rb']
   t.warning = false
   t.verbose = true
 end

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

@@ -0,0 +1,448 @@
+# frozen_string_literal: true
+
+# see the URL below for information on how to write OpenStudio measures
+# http://nrel.github.io/OpenStudio-user-documentation/reference/measure_writing_guide/
+
+require_relative 'resources/constants.rb'
+
+# start the measure
+class ReportHPXMLOutput < OpenStudio::Measure::ReportingMeasure
+  # human readable name
+  def name
+    # Measure name should be the title case of the class name.
+    return 'HPXML Output Report'
+  end
+
+  # human readable description
+  def description
+    return 'Reports HPXML outputs for residential HPXML-based models.'
+  end
+
+  # human readable description of modeling approach
+  def modeler_description
+    return 'Parses the HPXML file and reports pre-defined outputs.'
+  end
+
+  # define the arguments that the user will input
+  def arguments(model)
+    args = OpenStudio::Measure::OSArgumentVector.new
+
+    format_chs = OpenStudio::StringVector.new
+    format_chs << 'csv'
+    format_chs << 'json'
+    arg = OpenStudio::Measure::OSArgument::makeChoiceArgument('output_format', format_chs, false)
+    arg.setDisplayName('Output Format')
+    arg.setDescription('The file format of the annual (and timeseries, if requested) outputs.')
+    arg.setDefaultValue('csv')
+    args << arg
+
+    return args
+  end
+
+  # define what happens when the measure is run
+  def run(runner, user_arguments)
+    super(runner, user_arguments)
+
+    model = runner.lastOpenStudioModel
+    if model.empty?
+      runner.registerError('Cannot find OpenStudio model.')
+      return false
+    end
+    model = model.get
+
+    # use the built-in error checking
+    if !runner.validateUserArguments(arguments(model), user_arguments)
+      return false
+    end
+
+    output_format = runner.getStringArgumentValue('output_format', user_arguments)
+
+    sqlFile = runner.lastEnergyPlusSqlFile
+    if sqlFile.empty?
+      runner.registerError('Cannot find EnergyPlus sql file.')
+      return false
+    end
+    sqlFile = sqlFile.get
+    if not sqlFile.connectionOpen
+      runner.registerError('EnergyPlus simulation failed.')
+      return false
+    end
+    model.setSqlFile(sqlFile)
+
+    hpxml_defaults_path = model.getBuilding.additionalProperties.getFeatureAsString('hpxml_defaults_path').get
+    hpxml = HPXML.new(hpxml_path: hpxml_defaults_path)
+
+    # Set paths
+    output_dir = File.dirname(sqlFile.path.to_s)
+    output_path = File.join(output_dir, "results_hpxml.#{output_format}")
+
+    sqlFile.close()
+
+    # Ensure sql file is immediately freed; otherwise we can get
+    # errors on Windows when trying to delete this file.
+    GC.start()
+
+    # Initialize
+    cost_multipliers = {}
+    cost_multipliers[BS::WallAboveGradeConditioned] = BaseOutput.new
+    cost_multipliers[BS::WallAboveGradeExterior] = BaseOutput.new
+    cost_multipliers[BS::WallBelowGrade] = BaseOutput.new
+    cost_multipliers[BS::FloorConditioned] = BaseOutput.new
+    cost_multipliers[BS::FloorLighting] = BaseOutput.new
+    cost_multipliers[BS::Ceiling] = BaseOutput.new
+    cost_multipliers[BS::Roof] = BaseOutput.new
+    cost_multipliers[BS::Window] = BaseOutput.new
+    cost_multipliers[BS::Door] = BaseOutput.new
+    cost_multipliers[BS::DuctUnconditioned] = BaseOutput.new
+    cost_multipliers[BS::RimJoistAboveGradeExterior] = BaseOutput.new
+    cost_multipliers[BS::SlabPerimeterExposedConditioned] = BaseOutput.new
+    cost_multipliers[BS::CoolingSystem] = BaseOutput.new
+    cost_multipliers[BS::HeatingSystem] = BaseOutput.new
+    cost_multipliers[BS::HeatPumpBackup] = BaseOutput.new
+    cost_multipliers[BS::WaterHeater] = BaseOutput.new
+    cost_multipliers[BS::FlowRateMechanicalVentilation] = BaseOutput.new
+    cost_multipliers[BS::HeatingTotal] = BaseOutput.new
+    cost_multipliers[BS::HeatingDucts] = BaseOutput.new
+    cost_multipliers[BS::HeatingWindows] = BaseOutput.new
+    cost_multipliers[BS::HeatingSkylights] = BaseOutput.new
+    cost_multipliers[BS::HeatingDoors] = BaseOutput.new
+    cost_multipliers[BS::HeatingWalls] = BaseOutput.new
+    cost_multipliers[BS::HeatingRoofs] = BaseOutput.new
+    cost_multipliers[BS::HeatingFloors] = BaseOutput.new
+    cost_multipliers[BS::HeatingSlabs] = BaseOutput.new
+    cost_multipliers[BS::HeatingCeilings] = BaseOutput.new
+    cost_multipliers[BS::HeatingInfilVent] = BaseOutput.new
+    cost_multipliers[BS::CoolingSensibleTotal] = BaseOutput.new
+    cost_multipliers[BS::CoolingSensibleDucts] = BaseOutput.new
+    cost_multipliers[BS::CoolingSensibleWindows] = BaseOutput.new
+    cost_multipliers[BS::CoolingSensibleSkylights] = BaseOutput.new
+    cost_multipliers[BS::CoolingSensibleDoors] = BaseOutput.new
+    cost_multipliers[BS::CoolingSensibleWalls] = BaseOutput.new
+    cost_multipliers[BS::CoolingSensibleRoofs] = BaseOutput.new
+    cost_multipliers[BS::CoolingSensibleFloors] = BaseOutput.new
+    cost_multipliers[BS::CoolingSensibleSlabs] = BaseOutput.new
+    cost_multipliers[BS::CoolingSensibleCeilings] = BaseOutput.new
+    cost_multipliers[BS::CoolingSensibleInfilVent] = BaseOutput.new
+    cost_multipliers[BS::CoolingSensibleIntGains] = BaseOutput.new
+    cost_multipliers[BS::CoolingLatentTotal] = BaseOutput.new
+    cost_multipliers[BS::CoolingLatentDucts] = BaseOutput.new
+    cost_multipliers[BS::CoolingLatentInfilVent] = BaseOutput.new
+    cost_multipliers[BS::CoolingLatentIntGains] = BaseOutput.new
+
+    # Cost multipliers
+    cost_multipliers.each do |cost_mult_type, cost_mult|
+      cost_mult.output = get_cost_multiplier(hpxml, cost_mult_type)
+    end
+
+    # Primary and Secondary
+    if hpxml.primary_hvac_systems.size > 0
+      assign_primary_and_secondary(hpxml, cost_multipliers)
+    end
+
+    # Units
+    cost_multipliers.each do |cost_mult_type, cost_mult|
+      cost_mult.units = BS.get_units(cost_mult_type)
+    end
+
+    # Report results
+    cost_multipliers.each do |cost_mult_type, cost_mult|
+      cost_mult_type_str = OpenStudio::toUnderscoreCase("#{cost_mult_type} #{cost_mult.units}")
+      cost_mult = cost_mult.output.round(2)
+      runner.registerValue(cost_mult_type_str, cost_mult)
+    end
+
+    # Write results
+    write_output(runner, cost_multipliers, output_format, output_path)
+
+    return true
+  end
+
+  def write_output(runner, cost_multipliers, output_format, output_path)
+    line_break = nil
+
+    segment, _ = cost_multipliers.keys[0].split(':', 2)
+    segment = segment.strip
+    results_out = []
+    cost_multipliers.each do |key, cost_mult|
+      new_segment, _ = key.split(':', 2)
+      new_segment = new_segment.strip
+      if new_segment != segment
+        results_out << [line_break]
+        segment = new_segment
+      end
+      results_out << ["#{key} (#{cost_mult.units})", cost_mult.output.round(2)]
+    end
+
+    if output_format == 'csv'
+      CSV.open(output_path, 'wb') { |csv| results_out.to_a.each { |elem| csv << elem } }
+    elsif output_format == 'json'
+      h = {}
+      results_out.each do |out|
+        next if out == [line_break]
+
+        grp, name = out[0].split(':', 2)
+        h[grp] = {} if h[grp].nil?
+        h[grp][name.strip] = out[1]
+      end
+
+      require 'json'
+      File.open(output_path, 'w') { |json| json.write(JSON.pretty_generate(h)) }
+    end
+    runner.registerInfo("Wrote hpxml output to #{output_path}.")
+  end
+
+  class BaseOutput
+    def initialize()
+      @output = 0.0
+    end
+    attr_accessor(:output, :units)
+  end
+
+  def get_cost_multiplier(hpxml, cost_mult_type)
+    cost_mult = 0.0
+    if cost_mult_type == 'Enclosure: Wall Area Thermal Boundary'
+      hpxml.walls.each do |wall|
+        next unless wall.is_thermal_boundary
+
+        cost_mult += wall.area
+      end
+    elsif cost_mult_type == 'Enclosure: Wall Area Exterior'
+      hpxml.walls.each do |wall|
+        next unless wall.is_exterior
+
+        cost_mult += wall.area
+      end
+    elsif cost_mult_type == 'Enclosure: Foundation Wall Area Exterior'
+      hpxml.foundation_walls.each do |foundation_wall|
+        next unless foundation_wall.is_exterior
+
+        cost_mult += foundation_wall.area
+      end
+    elsif cost_mult_type == 'Enclosure: Floor Area Conditioned'
+      cost_mult += hpxml.building_construction.conditioned_floor_area
+    elsif cost_mult_type == 'Enclosure: Floor Area Lighting'
+      if hpxml.lighting.interior_usage_multiplier != 0
+        cost_mult += hpxml.building_construction.conditioned_floor_area
+      end
+      hpxml.slabs.each do |slab|
+        next unless [HPXML::LocationGarage].include?(slab.interior_adjacent_to)
+        next if hpxml.lighting.garage_usage_multiplier == 0
+
+        cost_mult += slab.area
+      end
+    elsif cost_mult_type == 'Enclosure: Ceiling Area Thermal Boundary'
+      hpxml.frame_floors.each do |frame_floor|
+        next unless frame_floor.is_thermal_boundary
+        next unless frame_floor.is_interior
+        next unless frame_floor.is_ceiling
+        next unless [HPXML::LocationAtticVented,
+                     HPXML::LocationAtticUnvented].include?(frame_floor.exterior_adjacent_to)
+
+        cost_mult += frame_floor.area
+      end
+    elsif cost_mult_type == 'Enclosure: Roof Area'
+      hpxml.roofs.each do |roof|
+        cost_mult += roof.area
+      end
+    elsif cost_mult_type == 'Enclosure: Window Area'
+      hpxml.windows.each do |window|
+        cost_mult += window.area
+      end
+    elsif cost_mult_type == 'Enclosure: Door Area'
+      hpxml.doors.each do |door|
+        cost_mult += door.area
+      end
+    elsif cost_mult_type == 'Enclosure: Duct Area Unconditioned'
+      hpxml.hvac_distributions.each do |hvac_distribution|
+        hvac_distribution.ducts.each do |duct|
+          next if [HPXML::LocationLivingSpace,
+                   HPXML::LocationBasementConditioned].include?(duct.duct_location)
+
+          cost_mult += duct.duct_surface_area
+        end
+      end
+    elsif cost_mult_type == 'Enclosure: Rim Joist Area'
+      hpxml.rim_joists.each do |rim_joist|
+        cost_mult += rim_joist.area
+      end
+    elsif cost_mult_type == 'Enclosure: Slab Exposed Perimeter Thermal Boundary'
+      hpxml.slabs.each do |slab|
+        next unless slab.is_exterior_thermal_boundary
+
+        cost_mult += slab.exposed_perimeter
+      end
+    elsif cost_mult_type == 'Systems: Heating Capacity'
+      hpxml.heating_systems.each do |heating_system|
+        next if heating_system.is_heat_pump_backup_system
+
+        cost_mult += heating_system.heating_capacity
+      end
+
+      hpxml.heat_pumps.each do |heat_pump|
+        cost_mult += heat_pump.heating_capacity
+      end
+    elsif cost_mult_type == 'Systems: Cooling Capacity'
+      hpxml.cooling_systems.each do |cooling_system|
+        cost_mult += cooling_system.cooling_capacity
+      end
+
+      hpxml.heat_pumps.each do |heat_pump|
+        cost_mult += heat_pump.cooling_capacity
+      end
+    elsif cost_mult_type == 'Systems: Heat Pump Backup Capacity'
+      hpxml.heat_pumps.each do |heat_pump|
+        if not heat_pump.backup_heating_capacity.nil?
+          cost_mult += heat_pump.backup_heating_capacity
+        elsif not heat_pump.backup_system.nil?
+          cost_mult += heat_pump.backup_system.heating_capacity
+        end
+      end
+    elsif cost_mult_type == 'Systems: Water Heater Tank Volume'
+      hpxml.water_heating_systems.each do |water_heating_system|
+        cost_mult += water_heating_system.tank_volume.to_f
+      end
+    elsif cost_mult_type == 'Systems: Mechanical Ventilation Flow Rate'
+      hpxml.ventilation_fans.each do |ventilation_fan|
+        next unless ventilation_fan.used_for_whole_building_ventilation
+
+        cost_mult += ventilation_fan.flow_rate.to_f
+      end
+    elsif cost_mult_type == 'Design Loads Heating: Total'
+      cost_mult += hpxml.hvac_plant.hdl_total
+    elsif cost_mult_type == 'Design Loads Heating: Ducts'
+      cost_mult += hpxml.hvac_plant.hdl_ducts
+    elsif cost_mult_type == 'Design Loads Heating: Windows'
+      cost_mult += hpxml.hvac_plant.hdl_windows
+    elsif cost_mult_type == 'Design Loads Heating: Skylights'
+      cost_mult += hpxml.hvac_plant.hdl_skylights
+    elsif cost_mult_type == 'Design Loads Heating: Doors'
+      cost_mult += hpxml.hvac_plant.hdl_doors
+    elsif cost_mult_type == 'Design Loads Heating: Walls'
+      cost_mult += hpxml.hvac_plant.hdl_walls
+    elsif cost_mult_type == 'Design Loads Heating: Roofs'
+      cost_mult += hpxml.hvac_plant.hdl_roofs
+    elsif cost_mult_type == 'Design Loads Heating: Floors'
+      cost_mult += hpxml.hvac_plant.hdl_floors
+    elsif cost_mult_type == 'Design Loads Heating: Slabs'
+      cost_mult += hpxml.hvac_plant.hdl_slabs
+    elsif cost_mult_type == 'Design Loads Heating: Ceilings'
+      cost_mult += hpxml.hvac_plant.hdl_ceilings
+    elsif cost_mult_type == 'Design Loads Heating: Infiltration/Ventilation'
+      cost_mult += hpxml.hvac_plant.hdl_infilvent
+    elsif cost_mult_type == 'Design Loads Cooling Sensible: Total'
+      cost_mult += hpxml.hvac_plant.cdl_sens_total
+    elsif cost_mult_type == 'Design Loads Cooling Sensible: Ducts'
+      cost_mult += hpxml.hvac_plant.cdl_sens_ducts
+    elsif cost_mult_type == 'Design Loads Cooling Sensible: Windows'
+      cost_mult += hpxml.hvac_plant.cdl_sens_windows
+    elsif cost_mult_type == 'Design Loads Cooling Sensible: Skylights'
+      cost_mult += hpxml.hvac_plant.cdl_sens_skylights
+    elsif cost_mult_type == 'Design Loads Cooling Sensible: Doors'
+      cost_mult += hpxml.hvac_plant.cdl_sens_doors
+    elsif cost_mult_type == 'Design Loads Cooling Sensible: Walls'
+      cost_mult += hpxml.hvac_plant.cdl_sens_walls
+    elsif cost_mult_type == 'Design Loads Cooling Sensible: Roofs'
+      cost_mult += hpxml.hvac_plant.cdl_sens_roofs
+    elsif cost_mult_type == 'Design Loads Cooling Sensible: Floors'
+      cost_mult += hpxml.hvac_plant.cdl_sens_floors
+    elsif cost_mult_type == 'Design Loads Cooling Sensible: Slabs'
+      cost_mult += hpxml.hvac_plant.cdl_sens_slabs
+    elsif cost_mult_type == 'Design Loads Cooling Sensible: Ceilings'
+      cost_mult += hpxml.hvac_plant.cdl_sens_ceilings
+    elsif cost_mult_type == 'Design Loads Cooling Sensible: Infiltration/Ventilation'
+      cost_mult += hpxml.hvac_plant.cdl_sens_infilvent
+    elsif cost_mult_type == 'Design Loads Cooling Sensible: Internal Gains'
+      cost_mult += hpxml.hvac_plant.cdl_sens_intgains
+    elsif cost_mult_type == 'Design Loads Cooling Latent: Total'
+      cost_mult += hpxml.hvac_plant.cdl_lat_total
+    elsif cost_mult_type == 'Design Loads Cooling Latent: Ducts'
+      cost_mult += hpxml.hvac_plant.cdl_lat_ducts
+    elsif cost_mult_type == 'Design Loads Cooling Latent: Infiltration/Ventilation'
+      cost_mult += hpxml.hvac_plant.cdl_lat_infilvent
+    elsif cost_mult_type == 'Design Loads Cooling Latent: Internal Gains'
+      cost_mult += hpxml.hvac_plant.cdl_lat_intgains
+    end
+    return cost_mult
+  end
+
+  def assign_primary_and_secondary(hpxml, cost_multipliers)
+    # Determine if we have primary/secondary systems
+    has_primary_cooling_system = false
+    has_secondary_cooling_system = false
+    hpxml.cooling_systems.each do |cooling_system|
+      has_primary_cooling_system = true if cooling_system.primary_system
+      has_secondary_cooling_system = true if !cooling_system.primary_system
+    end
+    hpxml.heat_pumps.each do |heat_pump|
+      has_primary_cooling_system = true if heat_pump.primary_cooling_system
+      has_secondary_cooling_system = true if !heat_pump.primary_cooling_system
+    end
+    has_secondary_cooling_system = false unless has_primary_cooling_system
+
+    has_primary_heating_system = false
+    has_secondary_heating_system = false
+    hpxml.heating_systems.each do |heating_system|
+      next if heating_system.is_heat_pump_backup_system
+
+      has_primary_heating_system = true if heating_system.primary_system
+      has_secondary_heating_system = true if !heating_system.primary_system
+    end
+    hpxml.heat_pumps.each do |heat_pump|
+      has_primary_heating_system = true if heat_pump.primary_heating_system
+      has_secondary_heating_system = true if !heat_pump.primary_heating_system
+    end
+    has_secondary_heating_system = false unless has_primary_heating_system
+
+    # Set up order of outputs
+    if has_primary_cooling_system
+      cost_multipliers["Primary #{BS::CoolingSystem}"] = BaseOutput.new
+    end
+
+    if has_primary_heating_system
+      cost_multipliers["Primary #{BS::HeatingSystem}"] = BaseOutput.new
+      cost_multipliers["Primary #{BS::HeatPumpBackup}"] = BaseOutput.new
+    end
+
+    if has_secondary_cooling_system
+      cost_multipliers["Secondary #{BS::CoolingSystem}"] = BaseOutput.new
+    end
+
+    if has_secondary_heating_system
+      cost_multipliers["Secondary #{BS::HeatingSystem}"] = BaseOutput.new
+      cost_multipliers["Secondary #{BS::HeatPumpBackup}"] = BaseOutput.new
+    end
+
+    # Obtain values
+    if has_primary_cooling_system || has_secondary_cooling_system
+      hpxml.cooling_systems.each do |cooling_system|
+        prefix = cooling_system.primary_system ? 'Primary' : 'Secondary'
+        cost_multipliers["#{prefix} #{BS::CoolingSystem}"].output += cooling_system.cooling_capacity
+      end
+      hpxml.heat_pumps.each do |heat_pump|
+        prefix = heat_pump.primary_cooling_system ? 'Primary' : 'Secondary'
+        cost_multipliers["#{prefix} #{BS::CoolingSystem}"].output += heat_pump.cooling_capacity
+      end
+    end
+
+    if has_primary_heating_system || has_secondary_heating_system
+      hpxml.heating_systems.each do |heating_system|
+        next if heating_system.is_heat_pump_backup_system
+
+        prefix = heating_system.primary_system ? 'Primary' : 'Secondary'
+        cost_multipliers["#{prefix} #{BS::HeatingSystem}"].output += heating_system.heating_capacity
+      end
+      hpxml.heat_pumps.each do |heat_pump|
+        prefix = heat_pump.primary_heating_system ? 'Primary' : 'Secondary'
+        cost_multipliers["#{prefix} #{BS::HeatingSystem}"].output += heat_pump.heating_capacity
+        if not heat_pump.backup_heating_capacity.nil?
+          cost_multipliers["#{prefix} #{BS::HeatPumpBackup}"].output += heat_pump.backup_heating_capacity
+        elsif not heat_pump.backup_system.nil?
+          cost_multipliers["#{prefix} #{BS::HeatPumpBackup}"].output += heat_pump.backup_system.heating_capacity
+        end
+      end
+    end
+  end
+end
+
+# register the measure to be used by the application
+ReportHPXMLOutput.new.registerWithApplication