output.rb

# frozen_string_literal: true

# Collection of methods related to output reporting or writing output files.
module Outputs
  MeterCustomElectricityTotal = 'Electricity:Total'
  MeterCustomElectricityNet = 'Electricity:Net'
  MeterCustomElectricityPV = 'Electricity:PV'
  MeterCustomElectricityCritical = 'Electricity:Critical'
  MeterCustomElectricityNetCritical = 'Electricity:NetCritical'

  FT_to_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
  }

  FT_to_EPlus_fuel_map = {
    FT::Elec => EPlus::FuelTypeElectricity,
    FT::Gas => EPlus::FuelTypeNaturalGas,
    FT::Oil => EPlus::FuelTypeOil,
    FT::Propane => EPlus::FuelTypePropane,
    FT::WoodCord => EPlus::FuelTypeWoodCord,
    FT::WoodPellets => EPlus::FuelTypeWoodPellets,
    FT::Coal => EPlus::FuelTypeCoal
  }

  # Add EMS programs for output reporting. In the case where a whole SFA/MF building is
  # being simulated, these programs are added to the whole building (merged) model, not
  # the individual dwelling unit models.
  #
  #
  # @param model [OpenStudio::Model::Model] OpenStudio Model object
  # @param hpxml_osm_map [Hash] Map of HPXML::Building objects => OpenStudio Model objects for each dwelling unit
  # @param hpxml_header [HPXML::Header] HPXML Header object (one per HPXML file)
  # @param add_component_loads [Boolean] Whether to calculate component loads (since it incurs a runtime speed penalty)
  # @return [nil]
  def self.apply_ems_programs(model, hpxml_osm_map, hpxml_header, add_component_loads)
    season_day_nums = apply_unmet_hours_ems_program(model, hpxml_osm_map, hpxml_header)
    apply_unmet_driving_hours_ems_program(model, hpxml_osm_map)
    loads_data = apply_total_loads_ems_program(model, hpxml_osm_map, hpxml_header)
    if add_component_loads
      apply_component_loads_ems_program(model, hpxml_osm_map, loads_data, season_day_nums)
    end
    apply_total_airflows_ems_program(model, hpxml_osm_map)
  end

  # Creates an EMS program that calculates heating and cooling unmet hours (number
  # of hours where the heating or cooling setpoint is not maintained).
  #
  # Note: We do our own unmet hours calculation via EMS so that we can incorporate,
  # e.g., heating/cooling seasons into the logic. The calculation layers on top
  # of the built-in EnergyPlus unmet hours output.
  #
  # @param model [OpenStudio::Model::Model] OpenStudio Model object
  # @param hpxml_osm_map [Hash] Map of HPXML::Building objects => OpenStudio Model objects for each dwelling unit
  # @param hpxml_header [HPXML::Header] HPXML Header object (one per HPXML file)
  # @return [Hash] Mapping of unit index => heating/cooling season begin and end dates for use by subsequent programs
  def self.apply_unmet_hours_ems_program(model, hpxml_osm_map, hpxml_header)
    # Create sensors and gather data
    htg_sensors, clg_sensors = {}, {}
    zone_air_temp_sensors, htg_spt_sensors, clg_spt_sensors = {}, {}, {}
    total_heat_load_serveds, total_cool_load_serveds = {}, {}
    season_day_nums = {}
    onoff_deadbands = hpxml_header.hvac_onoff_thermostat_deadband.to_f
    hpxml_osm_map.each_with_index do |(hpxml_bldg, unit_model), unit|
      conditioned_zone = unit_model.getThermalZones.find { |z| z.additionalProperties.getFeatureAsString('ObjectType').to_s == HPXML::LocationConditionedSpace }
      conditioned_zone_name = conditioned_zone.name.to_s

      # EMS sensors
      htg_sensors[unit] = Model.add_ems_sensor(
        model,
        name: "#{conditioned_zone_name} htg unmet s",
        output_var_or_meter_name: 'Zone Heating Setpoint Not Met Time',
        key_name: conditioned_zone_name
      )

      clg_sensors[unit] = Model.add_ems_sensor(
        model,
        name: "#{conditioned_zone_name} clg unmet s",
        output_var_or_meter_name: 'Zone Cooling Setpoint Not Met Time',
        key_name: conditioned_zone_name
      )

      total_heat_load_serveds[unit] = hpxml_bldg.total_fraction_heat_load_served
      total_cool_load_serveds[unit] = hpxml_bldg.total_fraction_cool_load_served

      hvac_control = hpxml_bldg.hvac_controls[0]
      next if hvac_control.nil?

      if (onoff_deadbands > 0)
        zone_air_temp_sensors[unit] = Model.add_ems_sensor(
          model,
          name: "#{conditioned_zone_name} space temp",
          output_var_or_meter_name: 'Zone Air Temperature',
          key_name: conditioned_zone_name
        )

        htg_sch = conditioned_zone.thermostatSetpointDualSetpoint.get.heatingSetpointTemperatureSchedule.get
        htg_spt_sensors[unit] = Model.add_ems_sensor(
          model,
          name: "#{htg_sch.name} sch value",
          output_var_or_meter_name: 'Schedule Value',
          key_name: htg_sch.name
        )

        clg_sch = conditioned_zone.thermostatSetpointDualSetpoint.get.coolingSetpointTemperatureSchedule.get
        clg_spt_sensors[unit] = Model.add_ems_sensor(
          model,
          name: "#{clg_sch.name} sch value",
          output_var_or_meter_name: 'Schedule Value',
          key_name: clg_sch.name
        )
      end

      sim_year = hpxml_header.sim_calendar_year
      season_day_nums[unit] = {
        htg_start: Calendar.get_day_num_from_month_day(sim_year, hvac_control.seasons_heating_begin_month, hvac_control.seasons_heating_begin_day),
        htg_end: Calendar.get_day_num_from_month_day(sim_year, hvac_control.seasons_heating_end_month, hvac_control.seasons_heating_end_day),
        clg_start: Calendar.get_day_num_from_month_day(sim_year, hvac_control.seasons_cooling_begin_month, hvac_control.seasons_cooling_begin_day),
        clg_end: Calendar.get_day_num_from_month_day(sim_year, hvac_control.seasons_cooling_end_month, hvac_control.seasons_cooling_end_day)
      }
    end

    htg_avail_sensor = model.getEnergyManagementSystemSensors.find { |s| s.additionalProperties.getFeatureAsString('ObjectType').to_s == Constants::ObjectTypeHeatingAvailabilitySensor }
    clg_avail_sensor = model.getEnergyManagementSystemSensors.find { |s| s.additionalProperties.getFeatureAsString('ObjectType').to_s == Constants::ObjectTypeCoolingAvailabilitySensor }

    htg_tol = model.getOutputControlReportingTolerances.toleranceforTimeHeatingSetpointNotMet
    clg_tol = model.getOutputControlReportingTolerances.toleranceforTimeCoolingSetpointNotMet

    # EMS program
    clg_hrs = 'clg_unmet_hours'
    htg_hrs = 'htg_unmet_hours'
    unit_clg_hrs = 'unit_clg_unmet_hours'
    unit_htg_hrs = 'unit_htg_unmet_hours'
    program = Model.add_ems_program(
      model,
      name: 'unmet hours program'
    )
    program.additionalProperties.setFeature('ObjectType', Constants::ObjectTypeUnmetHoursProgram)
    program.addLine("Set #{htg_hrs} = 0")
    program.addLine("Set #{clg_hrs} = 0")
    for unit in 0..hpxml_osm_map.size - 1
      if total_heat_load_serveds[unit] > 0
        program.addLine("Set #{unit_htg_hrs} = 0")
        if season_day_nums[unit][:htg_end] >= season_day_nums[unit][:htg_start]
          line = "If ((DayOfYear >= #{season_day_nums[unit][:htg_start]}) && (DayOfYear <= #{season_day_nums[unit][:htg_end]}))"
        else
          line = "If ((DayOfYear >= #{season_day_nums[unit][:htg_start]}) || (DayOfYear <= #{season_day_nums[unit][:htg_end]}))"
        end
        line += " && (#{htg_avail_sensor.name} == 1)" if not htg_avail_sensor.nil?
        program.addLine(line)
        if zone_air_temp_sensors.keys.include? unit # on off deadband
          program.addLine("  If #{zone_air_temp_sensors[unit].name} < (#{htg_spt_sensors[unit].name} - #{htg_tol})")
          program.addLine("    Set #{unit_htg_hrs} = #{unit_htg_hrs} + #{htg_sensors[unit].name}")
          program.addLine('  EndIf')
        else
          program.addLine("  Set #{unit_htg_hrs} = #{unit_htg_hrs} + #{htg_sensors[unit].name}")
        end
        program.addLine("  If #{unit_htg_hrs} > #{htg_hrs}") # Use max hourly value across all units
        program.addLine("    Set #{htg_hrs} = #{unit_htg_hrs}")
        program.addLine('  EndIf')
        program.addLine('EndIf')
      end
      next unless total_cool_load_serveds[unit] > 0

      program.addLine("Set #{unit_clg_hrs} = 0")
      if season_day_nums[unit][:clg_end] >= season_day_nums[unit][:clg_start]
        line = "If ((DayOfYear >= #{season_day_nums[unit][:clg_start]}) && (DayOfYear <= #{season_day_nums[unit][:clg_end]}))"
      else
        line = "If ((DayOfYear >= #{season_day_nums[unit][:clg_start]}) || (DayOfYear <= #{season_day_nums[unit][:clg_end]}))"
      end
      line += " && (#{clg_avail_sensor.name} == 1)" if not clg_avail_sensor.nil?
      program.addLine(line)
      if zone_air_temp_sensors.keys.include? unit # on off deadband
        program.addLine("  If #{zone_air_temp_sensors[unit].name} > (#{clg_spt_sensors[unit].name} + #{clg_tol})")
        program.addLine("    Set #{unit_clg_hrs} = #{unit_clg_hrs} + #{clg_sensors[unit].name}")
        program.addLine('  EndIf')
      else
        program.addLine("  Set #{unit_clg_hrs} = #{unit_clg_hrs} + #{clg_sensors[unit].name}")
      end
      program.addLine("  If #{unit_clg_hrs} > #{clg_hrs}") # Use max hourly value across all units
      program.addLine("    Set #{clg_hrs} = #{unit_clg_hrs}")
      program.addLine('  EndIf')
      program.addLine('EndIf')
    end

    # EMS calling manager
    Model.add_ems_program_calling_manager(
      model,
      name: "#{program.name} calling manager",
      calling_point: 'EndOfZoneTimestepBeforeZoneReporting',
      ems_programs: [program]
    )

    return season_day_nums
  end

  # Creates an EMS program that calculates driving unmet hours (number
  # of hours where the EV driving demand is not met).
  #
  # @param model [OpenStudio::Model::Model] OpenStudio Model object
  # @param hpxml_osm_map [Hash] Map of HPXML::Building objects => OpenStudio Model objects for each dwelling unit
  # @return [nil]
  def self.apply_unmet_driving_hours_ems_program(model, hpxml_osm_map)
    return if hpxml_osm_map.keys.map { |hpxml_bldg| hpxml_bldg.vehicles.map { |vehicle| vehicle.vehicle_type == HPXML::VehicleTypeBEV && !vehicle.ev_charger_idref.nil? }.size }.sum == 0

    # EMS program
    driving_hrs = 'unmet_driving_hours'
    unit_driving_hrs = 'unit_driving_unmet_hours'
    program = Model.add_ems_program(
      model,
      name: 'unmet driving hours program'
    )
    program.additionalProperties.setFeature('ObjectType', Constants::ObjectTypeVehicleUnmetHoursProgram)
    program.addLine("Set #{driving_hrs} = 0")

    hpxml_osm_map.each do |hpxml_bldg, unit_model|
      vehicle = hpxml_bldg.vehicles.find { |vehicle| vehicle.vehicle_type == HPXML::VehicleTypeBEV && !vehicle.ev_charger_idref.nil? }
      next if vehicle.nil?

      ev_elcd = unit_model.getElectricLoadCenterDistributions.find { |elcd| elcd.name.to_s.include?(vehicle.id) }
      discharge_sch_sensor = unit_model.getEnergyManagementSystemSensors.find { |s| s.additionalProperties.getFeatureAsString('ObjectType').to_s == Constants::ObjectTypeVehicleDischargeScheduleSensor }

      unit_model.getElectricLoadCenterStorageLiIonNMCBatterys.each do |elcs|
        next unless elcs.name.to_s.include? vehicle.id

        min_soc = ev_elcd.minimumStorageStateofChargeFraction

        soc_sensor = Model.add_ems_sensor(
          model,
          name: "#{elcs.name} soc_sensor",
          output_var_or_meter_name: 'Electric Storage Charge Fraction',
          key_name: elcs.name.to_s
        )

        program.addLine("  If #{discharge_sch_sensor.name} > 0.0")
        program.addLine("    If #{soc_sensor.name} <= #{min_soc}")
        program.addLine("      Set #{unit_driving_hrs} = #{discharge_sch_sensor.name}")
        program.addLine('    Else')
        program.addLine("      Set #{unit_driving_hrs} = 0")
        program.addLine('    EndIf')
        program.addLine('  Else')
        program.addLine("    Set #{unit_driving_hrs} = 0")
        program.addLine('  EndIf')
        program.addLine("  If #{unit_driving_hrs} > #{driving_hrs}") # Use max hourly value across all units
        program.addLine("    Set #{driving_hrs} = #{unit_driving_hrs}")
        program.addLine('  EndIf')
      end
    end

    Model.add_ems_program_calling_manager(
      model,
      name: "#{program.name} calling manager",
      calling_point: 'BeginTimestepBeforePredictor',
      ems_programs: [program]
    )
  end

  # Creates an EMS program that calculates total heating and cooling loads delivered
  # by the HVAC system(s).
  #
  # @param model [OpenStudio::Model::Model] OpenStudio Model object
  # @param hpxml_osm_map [Hash] Map of HPXML::Building objects => OpenStudio Model objects for each dwelling unit
  # @param hpxml_header [HPXML::Header] HPXML Header object (one per HPXML file)
  # @return [Array] Misc collection of things for use in the component loads EMS program
  def self.apply_total_loads_ems_program(model, hpxml_osm_map, hpxml_header)
    # Create sensors and gather data
    htg_cond_load_sensors, clg_cond_load_sensors = {}, {}
    htg_duct_load_sensors, clg_duct_load_sensors = {}, {}
    total_heat_load_serveds, total_cool_load_serveds = {}, {}
    dehumidifier_global_vars, dehumidifier_sensors, defrost_load_oe_sensors = {}, {}, {}
    unit_multipliers = {}

    hpxml_osm_map.each_with_index do |(hpxml_bldg, unit_model), unit|
      # Retrieve objects
      conditioned_zone_name = unit_model.getThermalZones.find { |z| z.additionalProperties.getFeatureAsString('ObjectType').to_s == HPXML::LocationConditionedSpace }.name.to_s
      duct_zone_names = unit_model.getThermalZones.select { |z| z.isPlenum }.map { |z| z.name.to_s }
      dehumidifier = unit_model.getZoneHVACDehumidifierDXs
      dehumidifier_name = dehumidifier[0].name.to_s unless dehumidifier.empty?
      defrost_load_oes = unit_model.getOtherEquipments.select { |o| o.additionalProperties.getFeatureAsString('ObjectType').to_s == Constants::ObjectTypeHPDefrostHeatLoad }

      # Fraction heat/cool load served
      if hpxml_header.apply_ashrae140_assumptions
        total_heat_load_serveds[unit] = 1.0
        total_cool_load_serveds[unit] = 1.0
      else
        total_heat_load_serveds[unit] = hpxml_bldg.total_fraction_heat_load_served
        total_cool_load_serveds[unit] = hpxml_bldg.total_fraction_cool_load_served
      end

      # Energy transferred in conditioned zone, used for determining heating (winter) vs cooling (summer)
      htg_cond_load_sensors[unit] = Model.add_ems_sensor(
        model,
        name: 'htg_load_cond',
        output_var_or_meter_name: "Heating:EnergyTransfer:Zone:#{conditioned_zone_name.upcase}",
        key_name: nil
      )

      clg_cond_load_sensors[unit] = Model.add_ems_sensor(
        model,
        name: 'clg_load_cond',
        output_var_or_meter_name: "Cooling:EnergyTransfer:Zone:#{conditioned_zone_name.upcase}",
        key_name: nil
      )

      # Energy transferred in duct zone(s)
      htg_duct_load_sensors[unit] = []
      clg_duct_load_sensors[unit] = []
      duct_zone_names.each do |duct_zone_name|
        htg_duct_load_sensors[unit] << Model.add_ems_sensor(
          model,
          name: 'htg_load_duct',
          output_var_or_meter_name: "Heating:EnergyTransfer:Zone:#{duct_zone_name.upcase}",
          key_name: nil
        )

        clg_duct_load_sensors[unit] << Model.add_ems_sensor(
          model,
          name: 'clg_load_duct',
          output_var_or_meter_name: "Cooling:EnergyTransfer:Zone:#{duct_zone_name.upcase}",
          key_name: nil
        )
      end

      defrost_load_oe_sensors[unit] = []
      defrost_load_oes.sort.each_with_index do |o, i|
        defrost_load_oe_sensors[unit] << Model.add_ems_sensor(
          model,
          name: "ig_defrost_#{i}",
          output_var_or_meter_name: 'Other Equipment Total Heating Energy',
          key_name: o.name.to_s
        )
      end
      unit_multipliers[unit] = hpxml_bldg.building_construction.number_of_units
      next if dehumidifier_name.nil?

      # Need to adjust E+ EnergyTransfer meters for dehumidifier internal gains.
      # We also offset the dehumidifier load by one timestep so that it aligns with the EnergyTransfer meters.

      # Global Variable
      dehumidifier_global_vars[unit] = Model.add_ems_global_var(
        model,
        var_name: "prev #{dehumidifier_name}"
      )

      # Initialization Program
      timestep_offset_program = Model.add_ems_program(
        model,
        name: "#{dehumidifier_name} timestep offset init program"
      )
      timestep_offset_program.addLine("Set #{dehumidifier_global_vars[unit].name} = 0")

      # calling managers
      Model.add_ems_program_calling_manager(
        model,
        name: "#{timestep_offset_program.name} calling manager",
        calling_point: 'BeginNewEnvironment',
        ems_programs: [timestep_offset_program]
      )

      Model.add_ems_program_calling_manager(
        model,
        name: "#{timestep_offset_program.name} calling manager2",
        calling_point: 'AfterNewEnvironmentWarmUpIsComplete',
        ems_programs: [timestep_offset_program]
      )

      dehumidifier_sensors[unit] = Model.add_ems_sensor(
        model,
        name: 'ig_dehumidifier',
        output_var_or_meter_name: 'Zone Dehumidifier Sensible Heating Energy',
        key_name: dehumidifier_name
      )
    end

    # EMS program
    program = Model.add_ems_program(
      model,
      name: 'total loads program'
    )
    program.additionalProperties.setFeature('ObjectType', Constants::ObjectTypeTotalLoadsProgram)
    program.addLine('Set loads_htg_tot = 0')
    program.addLine('Set loads_clg_tot = 0')
    for unit in 0..hpxml_osm_map.size - 1
      program.addLine("If #{htg_cond_load_sensors[unit].name} > 0")
      program.addLine("  Set loads_htg_tot = loads_htg_tot + (#{htg_cond_load_sensors[unit].name} - #{clg_cond_load_sensors[unit].name}) * #{total_heat_load_serveds[unit]}")
      for i in 0..htg_duct_load_sensors[unit].size - 1
        program.addLine("  Set loads_htg_tot = loads_htg_tot + (#{htg_duct_load_sensors[unit][i].name} - #{clg_duct_load_sensors[unit][i].name}) * #{total_heat_load_serveds[unit]}")
      end
      if not dehumidifier_global_vars[unit].nil?
        program.addLine("  Set loads_htg_tot = loads_htg_tot - #{dehumidifier_global_vars[unit].name}")
      end
      defrost_load_oe_sensors[unit].each do |defrost_ss|
        program.addLine("  Set loads_htg_tot = loads_htg_tot + #{defrost_ss.name} * #{unit_multipliers[unit]}")
      end
      program.addLine('EndIf')
    end
    program.addLine('Set loads_htg_tot = (@Max loads_htg_tot 0)')
    for unit in 0..hpxml_osm_map.size - 1
      program.addLine("If #{clg_cond_load_sensors[unit].name} > 0")
      program.addLine("  Set loads_clg_tot = loads_clg_tot + (#{clg_cond_load_sensors[unit].name} - #{htg_cond_load_sensors[unit].name}) * #{total_cool_load_serveds[unit]}")
      for i in 0..clg_duct_load_sensors[unit].size - 1
        program.addLine("  Set loads_clg_tot = loads_clg_tot + (#{clg_duct_load_sensors[unit][i].name} - #{htg_duct_load_sensors[unit][i].name}) * #{total_cool_load_serveds[unit]}")
      end
      if not dehumidifier_global_vars[unit].nil?
        program.addLine("  Set loads_clg_tot = loads_clg_tot + #{dehumidifier_global_vars[unit].name}")
      end
      program.addLine('EndIf')
    end
    program.addLine('Set loads_clg_tot = (@Max loads_clg_tot 0)')
    for unit in 0..hpxml_osm_map.size - 1
      if not dehumidifier_global_vars[unit].nil?
        # Store dehumidifier internal gain, will be used in EMS program next timestep
        program.addLine("Set #{dehumidifier_global_vars[unit].name} = #{dehumidifier_sensors[unit].name}")
      end
    end

    # EMS calling manager
    Model.add_ems_program_calling_manager(
      model,
      name: "#{program.name} calling manager",
      calling_point: 'EndOfZoneTimestepAfterZoneReporting',
      ems_programs: [program]
    )

    loads_data = [htg_cond_load_sensors, clg_cond_load_sensors, total_heat_load_serveds, total_cool_load_serveds, dehumidifier_sensors]
    return loads_data
  end

  # Creates an EMS program that calculates component heating and cooling loads (e.g., loads
  # attributes to walls, windows, infiltration, ducts, internal gains, etc.).
  #
  # @param model [OpenStudio::Model::Model] OpenStudio Model object
  # @param hpxml_osm_map [Hash] Map of HPXML::Building objects => OpenStudio Model objects for each dwelling unit
  # @param loads_data [Array] Misc collection of things from the total loads EMS program
  # @param season_day_nums [Hash] Mapping of unit index => heating/cooling season begin and end dates
  # @return [nil]
  def self.apply_component_loads_ems_program(model, hpxml_osm_map, loads_data, season_day_nums)
    htg_cond_load_sensors, clg_cond_load_sensors, total_heat_load_serveds, total_cool_load_serveds, dehumidifier_sensors = loads_data

    # Output diagnostics needed for some output variables used below
    output_diagnostics = model.getOutputDiagnostics
    output_diagnostics.addKey('DisplayAdvancedReportVariables')

    area_tolerance = UnitConversions.convert(1.0, 'ft^2', 'm^2')

    nonsurf_names = ['intgains', 'lighting', 'infil', 'mechvent', 'natvent', 'whf', 'ducts']
    surf_names = ['walls', 'rim_joists', 'foundation_walls', 'floors', 'slabs', 'ceilings',
                  'roofs', 'windows_conduction', 'windows_solar', 'doors', 'skylights_conduction',
                  'skylights_solar', 'internal_mass']

    # EMS program
    program = Model.add_ems_program(
      model,
      name: 'component loads program'
    )
    program.additionalProperties.setFeature('ObjectType', Constants::ObjectTypeComponentLoadsProgram)

    # Initialize
    [:htg, :clg].each do |mode|
      surf_names.each do |surf_name|
        program.addLine("Set loads_#{mode}_#{surf_name} = 0")
      end
      nonsurf_names.each do |nonsurf_name|
        program.addLine("Set loads_#{mode}_#{nonsurf_name} = 0")
      end
    end

    hpxml_osm_map.each_with_index do |(hpxml_bldg, unit_model), unit|
      conditioned_zone = unit_model.getThermalZones.find { |z| z.additionalProperties.getFeatureAsString('ObjectType').to_s == HPXML::LocationConditionedSpace }

      # Prevent certain objects (e.g., OtherEquipment) from being counted towards both, e.g., ducts and internal gains
      objects_already_processed = []

      # EMS Sensors: Surfaces, SubSurfaces, InternalMass
      surfaces_sensors = {}
      surf_names.each do |surf_name|
        surfaces_sensors[surf_name.to_sym] = []
      end

      unit_model.getSurfaces.sort.each do |s|
        next unless s.space.get.thermalZone.get.name.to_s == conditioned_zone.name.to_s

        surface_type = s.additionalProperties.getFeatureAsString('SurfaceType')
        if not surface_type.is_initialized
          fail "Could not identify surface type for surface: '#{s.name}'."
        end

        surface_type = surface_type.get

        s.subSurfaces.each do |ss|
          # Conduction (windows, skylights, doors)
          key = { 'Window' => :windows_conduction,
                  'Door' => :doors,
                  'Skylight' => :skylights_conduction }[surface_type]
          fail "Unexpected subsurface for component loads: '#{ss.name}'." if key.nil?

          if (surface_type == 'Window') || (surface_type == 'Skylight')
            vars = { 'Surface Inside Face Convection Heat Gain Energy' => 'ss_conv',
                     'Surface Inside Face Internal Gains Radiation Heat Gain Energy' => 'ss_ig',
                     'Surface Inside Face Net Surface Thermal Radiation Heat Gain Energy' => 'ss_surf' }
          else
            vars = { 'Surface Inside Face Solar Radiation Heat Gain Energy' => 'ss_sol',
                     'Surface Inside Face Lights Radiation Heat Gain Energy' => 'ss_lgt',
                     'Surface Inside Face Convection Heat Gain Energy' => 'ss_conv',
                     'Surface Inside Face Internal Gains Radiation Heat Gain Energy' => 'ss_ig',
                     'Surface Inside Face Net Surface Thermal Radiation Heat Gain Energy' => 'ss_surf' }
          end

          vars.each do |var, name|
            surfaces_sensors[key] << []
            surfaces_sensors[key][-1] << Model.add_ems_sensor(
              model,
              name: name,
              output_var_or_meter_name: var,
              key_name: ss.name
            )
          end

          # Solar (windows, skylights)
          next unless (surface_type == 'Window') || (surface_type == 'Skylight')

          key = { 'Window' => :windows_solar,
                  'Skylight' => :skylights_solar }[surface_type]
          vars = { 'Surface Window Transmitted Solar Radiation Rate' => 'ss_trans_in',
                   'Surface Window Shortwave from Zone Back Out Window Heat Transfer Rate' => 'ss_back_out',
                   'Surface Inside Face Initial Transmitted Diffuse Transmitted Out Window Solar Radiation Rate' => 'ss_trans_out' }

          surfaces_sensors[key] << []
          vars.each do |var, name|
            surfaces_sensors[key][-1] << Model.add_ems_sensor(
              model,
              name: name,
              output_var_or_meter_name: var,
              key_name: ss.name
            )
          end
        end

        next if s.netArea < area_tolerance # Skip parent surfaces (of subsurfaces) that have near zero net area

        key = { 'FoundationWall' => :foundation_walls,
                'RimJoist' => :rim_joists,
                'Wall' => :walls,
                'Slab' => :slabs,
                'Floor' => :floors,
                'Ceiling' => :ceilings,
                'Roof' => :roofs,
                'Skylight' => :skylights_conduction, # Skylight curb/shaft
                'InferredCeiling' => :internal_mass,
                'InferredFloor' => :internal_mass }[surface_type]
        fail "Unexpected surface for component loads: '#{s.name}'." if key.nil?

        surfaces_sensors[key] << []
        { 'Surface Inside Face Convection Heat Gain Energy' => 's_conv',
          'Surface Inside Face Internal Gains Radiation Heat Gain Energy' => 's_ig',
          'Surface Inside Face Solar Radiation Heat Gain Energy' => 's_sol',
          'Surface Inside Face Lights Radiation Heat Gain Energy' => 's_lgt',
          'Surface Inside Face Net Surface Thermal Radiation Heat Gain Energy' => 's_surf' }.each do |var, name|
          surfaces_sensors[key][-1] << Model.add_ems_sensor(
            model,
            name: name,
            output_var_or_meter_name: var,
            key_name: s.name
          )
        end
      end

      unit_model.getInternalMasss.sort.each do |m|
        next unless m.space.get.thermalZone.get.name.to_s == conditioned_zone.name.to_s

        surfaces_sensors[:internal_mass] << []
        { 'Surface Inside Face Convection Heat Gain Energy' => 'im_conv',
          'Surface Inside Face Internal Gains Radiation Heat Gain Energy' => 'im_ig',
          'Surface Inside Face Solar Radiation Heat Gain Energy' => 'im_sol',
          'Surface Inside Face Lights Radiation Heat Gain Energy' => 'im_lgt',
          'Surface Inside Face Net Surface Thermal Radiation Heat Gain Energy' => 'im_surf' }.each do |var, name|
          surfaces_sensors[:internal_mass][-1] << Model.add_ems_sensor(
            model,
            name: name,
            output_var_or_meter_name: var,
            key_name: m.name
          )
        end
      end

      # EMS Sensors: Infiltration, Natural Ventilation, Whole House Fan
      infil_sensors, natvent_sensors, whf_sensors = [], [], []
      unit_model.getSpaceInfiltrationDesignFlowRates.sort.each do |i|
        next unless i.space.get.thermalZone.get.name.to_s == conditioned_zone.name.to_s

        object_type = i.additionalProperties.getFeatureAsString('ObjectType').get

        { 'Infiltration Sensible Heat Gain Energy' => 'airflow_gain',
          'Infiltration Sensible Heat Loss Energy' => 'airflow_loss' }.each do |var, name|
          airflow_sensor = Model.add_ems_sensor(
            model,
            name: name,
            output_var_or_meter_name: var,
            key_name: i.name
          )

          if object_type == Constants::ObjectTypeInfiltration
            infil_sensors << airflow_sensor
          elsif object_type == Constants::ObjectTypeNaturalVentilation
            natvent_sensors << airflow_sensor
          elsif object_type == Constants::ObjectTypeWholeHouseFan
            whf_sensors << airflow_sensor
          end
        end
      end

      # EMS Sensors: Mechanical Ventilation
      mechvents_sensors = []
      unit_model.getElectricEquipments.sort.each do |o|
        next unless o.endUseSubcategory == Constants::ObjectTypeMechanicalVentilation

        objects_already_processed << o
        { 'Electric Equipment Convective Heating Energy' => 'mv_conv',
          'Electric Equipment Radiant Heating Energy' => 'mv_rad' }.each do |var, name|
          mechvents_sensors << Model.add_ems_sensor(
            model,
            name: name,
            output_var_or_meter_name: var,
            key_name: o.name
          )
        end
      end
      unit_model.getOtherEquipments.sort.each do |o|
        next unless o.endUseSubcategory == Constants::ObjectTypeMechanicalVentilationHouseFan

        objects_already_processed << o
        { 'Other Equipment Convective Heating Energy' => 'mv_conv',
          'Other Equipment Radiant Heating Energy' => 'mv_rad' }.each do |var, name|
          mechvents_sensors << Model.add_ems_sensor(
            model,
            name: name,
            output_var_or_meter_name: var,
            key_name: o.name
          )
        end
      end

      # EMS Sensors: Ducts
      ducts_sensors = []
      ducts_mix_gain_sensor = nil
      ducts_mix_loss_sensor = nil
      conditioned_zone.zoneMixing.each do |zone_mix|
        object_type = zone_mix.additionalProperties.getFeatureAsString('ObjectType').to_s
        next unless object_type == Constants::ObjectTypeDuctLoad

        ducts_mix_gain_sensor = Model.add_ems_sensor(
          model,
          name: 'duct_mix_gain',
          output_var_or_meter_name: 'Zone Mixing Sensible Heat Gain Energy',
          key_name: conditioned_zone.name
        )

        ducts_mix_loss_sensor = Model.add_ems_sensor(
          model,
          name: 'duct_mix_loss',
          output_var_or_meter_name: 'Zone Mixing Sensible Heat Loss Energy',
          key_name: conditioned_zone.name
        )
      end
      unit_model.getOtherEquipments.sort.each do |o|
        next if objects_already_processed.include? o
        next unless o.endUseSubcategory == Constants::ObjectTypeDuctLoad

        objects_already_processed << o
        { 'Other Equipment Convective Heating Energy' => 'ducts_conv',
          'Other Equipment Radiant Heating Energy' => 'ducts_rad' }.each do |var, name|
          ducts_sensors << Model.add_ems_sensor(
            model,
            name: name,
            output_var_or_meter_name: var,
            key_name: o.name
          )
        end
      end

      # EMS Sensors: Lighting
      lightings_sensors = []
      unit_model.getLightss.sort.each do |e|
        next unless e.space.get.thermalZone.get.name.to_s == conditioned_zone.name.to_s

        { 'Lights Convective Heating Energy' => 'ig_lgt_conv',
          'Lights Radiant Heating Energy' => 'ig_lgt_rad',
          'Lights Visible Radiation Heating Energy' => 'ig_lgt_vis' }.each do |var, name|
          lightings_sensors << Model.add_ems_sensor(
            model,
            name: name,
            output_var_or_meter_name: var,
            key_name: e.name
          )
        end
      end

      # EMS Sensors: Internal Gains
      intgains_sensors = []
      unit_model.getElectricEquipments.sort.each do |o|
        next if objects_already_processed.include? o
        next unless o.space.get.thermalZone.get.name.to_s == conditioned_zone.name.to_s

        { 'Electric Equipment Convective Heating Energy' => 'ig_ee_conv',
          'Electric Equipment Radiant Heating Energy' => 'ig_ee_rad' }.each do |var, name|
          intgains_sensors << Model.add_ems_sensor(
            model,
            name: name,
            output_var_or_meter_name: var,
            key_name: o.name
          )
        end
      end

      unit_model.getOtherEquipments.sort.each do |o|
        next if objects_already_processed.include? o
        next unless o.space.get.thermalZone.get.name.to_s == conditioned_zone.name.to_s

        { 'Other Equipment Convective Heating Energy' => 'ig_oe_conv',
          'Other Equipment Radiant Heating Energy' => 'ig_oe_rad' }.each do |var, name|
          intgains_sensors << Model.add_ems_sensor(
            model,
            name: name,
            output_var_or_meter_name: var,
            key_name: o.name
          )
        end
      end

      unit_model.getPeoples.sort.each do |e|
        next unless e.space.get.thermalZone.get.name.to_s == conditioned_zone.name.to_s

        { 'People Convective Heating Energy' => 'ig_ppl_conv',
          'People Radiant Heating Energy' => 'ig_ppl_rad' }.each do |var, name|
          intgains_sensors << Model.add_ems_sensor(
            model,
            name: name,
            output_var_or_meter_name: var,
            key_name: e.name
          )
        end
      end

      if not dehumidifier_sensors[unit].nil?
        intgains_sensors << dehumidifier_sensors[unit]
      end

      intgains_dhw_sensors = {}

      (unit_model.getWaterHeaterMixeds + unit_model.getWaterHeaterStratifieds).sort.each do |wh|
        next unless wh.ambientTemperatureThermalZone.is_initialized
        next unless wh.ambientTemperatureThermalZone.get.name.to_s == conditioned_zone.name.to_s

        dhw_sensor = Model.add_ems_sensor(
          model,
          name: 'dhw_loss',
          output_var_or_meter_name: 'Water Heater Heat Loss Energy',
          key_name: wh.name
        )

        if wh.is_a? OpenStudio::Model::WaterHeaterMixed
          oncycle_loss = wh.onCycleLossFractiontoThermalZone
          offcycle_loss = wh.offCycleLossFractiontoThermalZone
        else
          oncycle_loss = wh.skinLossFractiontoZone
          offcycle_loss = wh.offCycleFlueLossFractiontoZone
        end

        dhw_rtf_sensor = Model.add_ems_sensor(
          model,
          name: 'dhw_rtf',
          output_var_or_meter_name: 'Water Heater Runtime Fraction',
          key_name: wh.name
        )

        intgains_dhw_sensors[dhw_sensor] = [offcycle_loss, oncycle_loss, dhw_rtf_sensor]
      end

      # EMS program: Surfaces
      surfaces_sensors.each do |k, surface_sensors|
        program.addLine("Set hr_#{k} = 0")
        surface_sensors.each do |sensors|
          s = "Set hr_#{k} = hr_#{k}"
          sensors.each do |sensor|
            if sensor.name.to_s.start_with?('ss_trans_in', 'ss_infra', 'ss_glaz')
              s += " - #{sensor.name} * ZoneTimestep * 3600"
            elsif sensor.name.to_s.start_with?('ss_trans_out', 'ss_back_out')
              s += " + #{sensor.name} * ZoneTimestep * 3600"
            else
              s += " + #{sensor.name}"
            end
          end
          program.addLine(s) if sensors.size > 0
        end
      end

      # EMS program: Internal Gains, Lighting, Infiltration, Natural Ventilation, Mechanical Ventilation, Ducts
      { 'intgains' => intgains_sensors,
        'lighting' => lightings_sensors,
        'infil' => infil_sensors,
        'natvent' => natvent_sensors,
        'whf' => whf_sensors,
        'mechvent' => mechvents_sensors,
        'ducts' => ducts_sensors }.each do |loadtype, sensors|
        program.addLine("Set hr_#{loadtype} = 0")
        next if sensors.empty?

        s = "Set hr_#{loadtype} = hr_#{loadtype}"
        sensors.each do |sensor|
          if ['intgains', 'lighting', 'mechvent', 'ducts'].include? loadtype
            s += " - #{sensor.name}"
          elsif sensor.name.to_s.include? 'gain'
            s += " - #{sensor.name}"
          elsif sensor.name.to_s.include? 'loss'
            s += " + #{sensor.name}"
          end
        end
        program.addLine(s)
      end
      intgains_dhw_sensors.each do |sensor, vals|
        off_loss, on_loss, rtf_sensor = vals
        program.addLine("Set hr_intgains = hr_intgains + #{sensor.name} * (#{off_loss}*(1-#{rtf_sensor.name}) + #{on_loss}*#{rtf_sensor.name})") # Water heater tank losses to zone
      end
      if (not ducts_mix_loss_sensor.nil?) && (not ducts_mix_gain_sensor.nil?)
        program.addLine("Set hr_ducts = hr_ducts + (#{ducts_mix_loss_sensor.name} - #{ducts_mix_gain_sensor.name})")
      end

      # EMS Sensors: Indoor temperature, setpoints
      tin_sensor = Model.add_ems_sensor(
        model,
        name: 'tin s',
        output_var_or_meter_name: 'Zone Mean Air Temperature',
        key_name: conditioned_zone.name
      )

      thermostat = nil
      if conditioned_zone.thermostatSetpointDualSetpoint.is_initialized
        thermostat = conditioned_zone.thermostatSetpointDualSetpoint.get

        htg_sp_sensor = Model.add_ems_sensor(
          model,
          name: 'htg sp s',
          output_var_or_meter_name: 'Schedule Value',
          key_name: thermostat.heatingSetpointTemperatureSchedule.get.name
        )

        clg_sp_sensor = Model.add_ems_sensor(
          model,
          name: 'clg sp s',
          output_var_or_meter_name: 'Schedule Value',
          key_name: thermostat.coolingSetpointTemperatureSchedule.get.name
        )
      end

      # EMS program: Heating vs Cooling logic
      program.addLine('Set htg_mode = 0')
      program.addLine('Set clg_mode = 0')
      program.addLine("If (#{htg_cond_load_sensors[unit].name} > 0)") # Assign hour to heating if heating load
      program.addLine("  Set htg_mode = #{total_heat_load_serveds[unit]}")
      program.addLine("ElseIf (#{clg_cond_load_sensors[unit].name} > 0)") # Assign hour to cooling if cooling load
      program.addLine("  Set clg_mode = #{total_cool_load_serveds[unit]}")
      program.addLine('Else')
      program.addLine('  Set htg_season = 0')
      program.addLine('  Set clg_season = 0')
      if not season_day_nums[unit].nil?
        # Determine whether we're in the heating and/or cooling season
        if season_day_nums[unit][:clg_end] >= season_day_nums[unit][:clg_start]
          program.addLine("  If ((DayOfYear >= #{season_day_nums[unit][:clg_start]}) && (DayOfYear <= #{season_day_nums[unit][:clg_end]}))")
        else
          program.addLine("  If ((DayOfYear >= #{season_day_nums[unit][:clg_start]}) || (DayOfYear <= #{season_day_nums[unit][:clg_end]}))")
        end
        program.addLine('    Set clg_season = 1')
        program.addLine('  EndIf')
        if season_day_nums[unit][:htg_end] >= season_day_nums[unit][:htg_start]
          program.addLine("  If ((DayOfYear >= #{season_day_nums[unit][:htg_start]}) && (DayOfYear <= #{season_day_nums[unit][:htg_end]}))")
        else
          program.addLine("  If ((DayOfYear >= #{season_day_nums[unit][:htg_start]}) || (DayOfYear <= #{season_day_nums[unit][:htg_end]}))")
        end
        program.addLine('    Set htg_season = 1')
        program.addLine('  EndIf')
      end
      program.addLine("  If ((#{natvent_sensors[0].name} <> 0) || (#{natvent_sensors[1].name} <> 0)) && (clg_season == 1)") # Assign hour to cooling if natural ventilation is operating
      program.addLine("    Set clg_mode = #{total_cool_load_serveds[unit]}")
      program.addLine("  ElseIf ((#{whf_sensors[0].name} <> 0) || (#{whf_sensors[1].name} <> 0)) && (clg_season == 1)") # Assign hour to cooling if whole house fan is operating
      program.addLine("    Set clg_mode = #{total_cool_load_serveds[unit]}")
      if not thermostat.nil?
        program.addLine('  Else') # Indoor temperature floating between setpoints; determine assignment by comparing to average of heating/cooling setpoints
        program.addLine("    Set Tmid_setpoint = (#{htg_sp_sensor.name} + #{clg_sp_sensor.name}) / 2")
        program.addLine("    If (#{tin_sensor.name} > Tmid_setpoint) && (clg_season == 1)")
        program.addLine("      Set clg_mode = #{total_cool_load_serveds[unit]}")
        program.addLine("    ElseIf (#{tin_sensor.name} < Tmid_setpoint) && (htg_season == 1)")
        program.addLine("      Set htg_mode = #{total_heat_load_serveds[unit]}")
        program.addLine('    EndIf')
      end
      program.addLine('  EndIf')
      program.addLine('EndIf')

      unit_multiplier = hpxml_bldg.building_construction.number_of_units
      [:htg, :clg].each do |mode|
        if mode == :htg
          sign = ''
        else
          sign = '-'
        end
        surf_names.each do |surf_name|
          program.addLine("Set loads_#{mode}_#{surf_name} = loads_#{mode}_#{surf_name} + (#{sign}hr_#{surf_name} * #{mode}_mode * #{unit_multiplier})")
        end
        nonsurf_names.each do |nonsurf_name|
          program.addLine("Set loads_#{mode}_#{nonsurf_name} = loads_#{mode}_#{nonsurf_name} + (#{sign}hr_#{nonsurf_name} * #{mode}_mode * #{unit_multiplier})")
        end
      end
    end

    # EMS calling manager
    Model.add_ems_program_calling_manager(
      model,
      name: "#{program.name} calling manager",
      calling_point: 'EndOfZoneTimestepAfterZoneReporting',
      ems_programs: [program]
    )
  end

  # Creates airflow outputs (for infiltration, ventilation, etc.) that sum across all individual dwelling
  # units for output reporting.
  #
  # @param model [OpenStudio::Model::Model] OpenStudio Model object
  # @param hpxml_osm_map [Hash] Map of HPXML::Building objects => OpenStudio Model objects for each dwelling unit
  # @return [nil]
  def self.apply_total_airflows_ems_program(model, hpxml_osm_map)
    # Retrieve objects
    infil_vars = []
    mechvent_vars = []
    natvent_vars = []
    whf_vars = []
    unit_multipliers = []
    hpxml_osm_map.each do |hpxml_bldg, unit_model|
      infil_vars << unit_model.getEnergyManagementSystemGlobalVariables.find { |v| v.additionalProperties.getFeatureAsString('ObjectType').to_s == Constants::ObjectTypeInfiltration }
      mechvent_vars << unit_model.getEnergyManagementSystemGlobalVariables.find { |v| v.additionalProperties.getFeatureAsString('ObjectType').to_s == Constants::ObjectTypeMechanicalVentilation }
      natvent_vars << unit_model.getEnergyManagementSystemGlobalVariables.find { |v| v.additionalProperties.getFeatureAsString('ObjectType').to_s == Constants::ObjectTypeNaturalVentilation }
      whf_vars << unit_model.getEnergyManagementSystemGlobalVariables.find { |v| v.additionalProperties.getFeatureAsString('ObjectType').to_s == Constants::ObjectTypeWholeHouseFan }
      unit_multipliers << hpxml_bldg.building_construction.number_of_units
    end

    # EMS program
    program = Model.add_ems_program(
      model,
      name: 'total airflows program'
    )
    program.additionalProperties.setFeature('ObjectType', Constants::ObjectTypeTotalAirflowsProgram)
    program.addLine('Set total_infil_flow_rate = 0')
    program.addLine('Set total_mechvent_flow_rate = 0')
    program.addLine('Set total_natvent_flow_rate = 0')
    program.addLine('Set total_whf_flow_rate = 0')
    infil_vars.each_with_index do |infil_var, i|
      program.addLine("Set total_infil_flow_rate = total_infil_flow_rate + (#{infil_var.name} * #{unit_multipliers[i]})")
    end
    mechvent_vars.each_with_index do |mechvent_var, i|
      program.addLine("Set total_mechvent_flow_rate = total_mechvent_flow_rate + (#{mechvent_var.name} * #{unit_multipliers[i]})")
    end
    natvent_vars.each_with_index do |natvent_var, i|
      program.addLine("Set total_natvent_flow_rate = total_natvent_flow_rate + (#{natvent_var.name} * #{unit_multipliers[i]})")
    end
    whf_vars.each_with_index do |whf_var, i|
      program.addLine("Set total_whf_flow_rate = total_whf_flow_rate + (#{whf_var.name} * #{unit_multipliers[i]})")
    end

    # EMS calling manager
    Model.add_ems_program_calling_manager(
      model,
      name: "#{program.name} calling manager",
      calling_point: 'EndOfZoneTimestepAfterZoneReporting',
      ems_programs: [program]
    )
  end

  # Populate fields of both unique OpenStudio objects OutputJSON and OutputControlFiles based on the debug argument.
  # Always request MessagePack output.
  #
  # @param model [OpenStudio::Model::Model] OpenStudio Model object
  # @param debug [Boolean] If true,  writes in.osm, generates additional log output, and creates all E+ output files
  # @return [nil]
  def self.apply_output_file_controls(model, debug)
    oj = model.getOutputJSON
    oj.setOptionType('TimeSeriesAndTabular')
    oj.setOutputJSON(debug)
    oj.setOutputMessagePack(true) # Used by ReportSimulationOutput reporting measure

    ocf = model.getOutputControlFiles
    ocf.setOutputAUDIT(debug)
    ocf.setOutputCSV(debug)
    ocf.setOutputBND(debug)
    ocf.setOutputEIO(debug)
    ocf.setOutputESO(debug)
    ocf.setOutputMDD(debug)
    ocf.setOutputMTD(debug)
    ocf.setOutputMTR(debug)
    ocf.setOutputRDD(debug)
    ocf.setOutputSHD(debug)
    ocf.setOutputCSV(debug)
    ocf.setOutputSQLite(debug)
    ocf.setOutputPerfLog(debug)
    ocf.setOutputTabular(debug)
  end

  # Store some data for use in reporting measure.
  #
  # @param model [OpenStudio::Model::Model] OpenStudio Model object
  # @param hpxml [HPXML] HPXML object
  # @param hpxml_osm_map [Hash] Map of HPXML::Building objects => OpenStudio Model objects for each dwelling unit
  # @param hpxml_path [String] Path to the HPXML file
  # @param building_id [String] HPXML Building ID
  # @param hpxml_defaults_path [String] Path to the HPXML defaults (in.xml) file
  # @return [nil]
  def self.apply_additional_properties(model, hpxml, hpxml_osm_map, hpxml_path, building_id, hpxml_defaults_path)
    additionalProperties = model.getBuilding.additionalProperties
    additionalProperties.setFeature('hpxml_path', hpxml_path)
    additionalProperties.setFeature('hpxml_defaults_path', hpxml_defaults_path)
    additionalProperties.setFeature('hpxml_bldgs_size', hpxml.buildings.size)
    additionalProperties.setFeature('building_id', building_id.to_s)
    additionalProperties.setFeature('emissions_scenario_names', hpxml.header.emissions_scenarios.map { |s| s.name }.to_s)
    additionalProperties.setFeature('emissions_scenario_types', hpxml.header.emissions_scenarios.map { |s| s.emissions_type }.to_s)
    heated_zones, cooled_zones = [], []
    hpxml_osm_map.each do |hpxml_bldg, unit_model|
      conditioned_zone_name = unit_model.getThermalZones.find { |z| z.additionalProperties.getFeatureAsString('ObjectType').to_s == HPXML::LocationConditionedSpace }.name.to_s

      heated_zones << conditioned_zone_name if hpxml_bldg.total_fraction_heat_load_served > 0
      cooled_zones << conditioned_zone_name if hpxml_bldg.total_fraction_cool_load_served > 0
    end
    additionalProperties.setFeature('heated_zones', heated_zones.to_s)
    additionalProperties.setFeature('cooled_zones', cooled_zones.to_s)
    additionalProperties.setFeature('is_southern_hemisphere', hpxml_osm_map.keys[0].latitude < 0)
  end

  # Requests very detailed EMS output files to help debug EMS programs line-by-line.
  #
  # Note: The call to this method is commented out by default as this is slow and produces
  # huge output files. It should only be enabled temporarily for debugging purposes.
  #
  # @param model [OpenStudio::Model::Model] OpenStudio Model object
  # @return [nil]
  def self.apply_ems_debug_output(model)
    oems = model.getOutputEnergyManagementSystem
    oems.setActuatorAvailabilityDictionaryReporting('Verbose')
    oems.setInternalVariableAvailabilityDictionaryReporting('Verbose')
    oems.setEMSRuntimeLanguageDebugOutputLevel('Verbose')
  end

  # Writes OSM & EPW files to the output directory when in debug mode.
  #
  # @param runner [OpenStudio::Measure::OSRunner] Object typically used to display warnings
  # @param model [OpenStudio::Model::Model] OpenStudio Model object
  # @param weather [WeatherFile] Weather object containing EPW information
  # @param debug [Boolean] If true, writes the OSM/EPW files to the output dir
  # @param output_dir [String] Path of the output files directory
  # @return [nil]
  def self.write_debug_files(runner, model, weather, debug, output_dir)
    return unless debug

    # Write OSM file to run dir
    osm_output_path = File.join(output_dir, 'in.osm')
    File.write(osm_output_path, model.to_s)
    runner.registerInfo("Wrote file: #{osm_output_path}")

    # Copy EPW file to run dir
    epw_output_path = File.join(output_dir, 'in.epw')
    FileUtils.cp(weather.epw_path, epw_output_path)
  end

  # Calculates total HVAC capacities (across all HVAC systems) for a given HPXML Building.
  # These capacities will be reported in the annual output file.
  #
  # @param hpxml_bldg [HPXML::Building] HPXML Building object representing an individual dwelling unit
  # @return [Hash] Map of :htg/:clg/:htg_backup => total capacity (Btu/hr)
  def self.get_total_hvac_capacities(hpxml_bldg)
    capacities = { htg: 0.0, clg: 0.0, htg_backup: 0.0 }
    unit_multiplier = hpxml_bldg.building_construction.number_of_units
    hpxml_bldg.hvac_systems.each do |hvac_system|
      if hvac_system.is_a? HPXML::HeatingSystem
        next if hvac_system.is_heat_pump_backup_system

        capacities[:htg] += hvac_system.heating_capacity.to_f * unit_multiplier
      elsif hvac_system.is_a? HPXML::CoolingSystem
        capacities[:clg] += hvac_system.cooling_capacity.to_f * unit_multiplier
        if hvac_system.has_integrated_heating
          capacities[:htg] += hvac_system.integrated_heating_system_capacity.to_f * unit_multiplier
        end
      elsif hvac_system.is_a? HPXML::HeatPump
        capacities[:htg] += hvac_system.heating_capacity.to_f * unit_multiplier
        capacities[:clg] += hvac_system.cooling_capacity.to_f * unit_multiplier
        if hvac_system.backup_type == HPXML::HeatPumpBackupTypeIntegrated
          capacities[:htg_backup] += hvac_system.backup_heating_capacity.to_f * unit_multiplier
        elsif hvac_system.backup_type == HPXML::HeatPumpBackupTypeSeparate
          capacities[:htg_backup] += hvac_system.backup_system.heating_capacity.to_f * unit_multiplier
        end
      end
    end
    return capacities
  end

  # Calculates total panel loads (across all service feeders for a given service feeder load type) for a given HPXML Building.
  #
  # @param hpxml_bldg [HPXML::Building] HPXML Building object representing an individual dwelling unit
  # @return [Hash] Map of HPXML::ElectricPanelLoadTypeXXX => total panel load (W)
  def self.get_total_panel_loads(hpxml_bldg)
    panel_loads = ElectricPanel.all_panel_load_types.map { |lt| [lt, 0.0] }.to_h
    unit_multiplier = hpxml_bldg.building_construction.number_of_units
    hpxml_bldg.electric_panels.each do |electric_panel|
      panel_loads[HPXML::ElectricPanelLoadTypeHeating] += ElectricPanel.get_service_feeder_heating(hpxml_bldg, electric_panel) * unit_multiplier
      electric_panel.service_feeders.each do |service_feeder|
        if [HPXML::ElectricPanelLoadTypeLighting, HPXML::ElectricPanelLoadTypeKitchen,
            HPXML::ElectricPanelLoadTypeLaundry, HPXML::ElectricPanelLoadTypeOther].include? service_feeder.type
          panel_loads[HPXML::ElectricPanelLoadTypeOther] += service_feeder.power * unit_multiplier
        elsif service_feeder.type != HPXML::ElectricPanelLoadTypeHeating
          panel_loads[service_feeder.type] += service_feeder.power * unit_multiplier
        end
      end
    end
    return panel_loads
  end

  # Calculates total breaker spaces (across all service feeders for a given service feeder load type) for a given HPXML Building.
  #
  # @param hpxml_bldg [HPXML::Building] HPXML Building object representing an individual dwelling unit
  # @return [Hash] Map of HPXML::ElectricPanelLoadTypeXXX => total breaker spaces
  def self.get_total_breaker_spaces(hpxml_bldg)
    breaker_spaces = ElectricPanel.all_panel_load_types.map { |lt| [lt, 0.0] }.to_h
    unit_multiplier = hpxml_bldg.building_construction.number_of_units
    hpxml_bldg.electric_panels.each do |electric_panel|
      electric_panel.service_feeders.each do |service_feeder|
        service_feeder.components.each do |component|
          if service_feeder.type == HPXML::ElectricPanelLoadTypeCooling
            # So we don't double-count, e.g., heat pump breaker spaces since it is shared across two service feeder types
            next unless component.service_feeders.select { |sf| sf.type == HPXML::ElectricPanelLoadTypeHeating }.empty?
          end
          if [HPXML::ElectricPanelLoadTypePoolHeater,
              HPXML::ElectricPanelLoadTypePermanentSpaHeater].include? service_feeder.type
            branch_circuits = component.heater_branch_circuits
          elsif [HPXML::ElectricPanelLoadTypePoolPump,
                 HPXML::ElectricPanelLoadTypePermanentSpaPump].include? service_feeder.type
            branch_circuits = component.pump_branch_circuits
          else
            branch_circuits = component.branch_circuits
          end
          branch_circuits.each do |branch_circuit|
            breaker_spaces[service_feeder.type] += branch_circuit.occupied_spaces * unit_multiplier
          end
        end
      end
      electric_panel.branch_circuits.each do |branch_circuit|
        if branch_circuit.components.empty?
          breaker_spaces[HPXML::ElectricPanelLoadTypeOther] += branch_circuit.occupied_spaces * unit_multiplier
        end
      end
    end
    return breaker_spaces
  end

  # Calculates total HVAC airflow rates (across all HVAC systems) for a given HPXML Building.
  #
  # @param hpxml_bldg [HPXML::Building] HPXML Building object representing an individual dwelling unit
  # @return [Hash] Map of :htg/:clg => total airflow rate (cfm)
  def self.get_total_hvac_airflows(hpxml_bldg)
    cfms = { htg: 0.0, clg: 0.0 }
    unit_multiplier = hpxml_bldg.building_construction.number_of_units
    hpxml_bldg.hvac_systems.each do |hvac_system|
      if hvac_system.is_a? HPXML::HeatingSystem
        cfms[:htg] += hvac_system.heating_design_airflow_cfm.to_f * unit_multiplier
      elsif hvac_system.is_a? HPXML::CoolingSystem
        cfms[:clg] += hvac_system.cooling_design_airflow_cfm.to_f * unit_multiplier
        if hvac_system.has_integrated_heating
          cfms[:htg] += hvac_system.integrated_heating_system_airflow_cfm.to_f * unit_multiplier
        end
      elsif hvac_system.is_a? HPXML::HeatPump
        cfms[:htg] += hvac_system.heating_design_airflow_cfm.to_f * unit_multiplier
        cfms[:clg] += hvac_system.cooling_design_airflow_cfm.to_f * unit_multiplier
      end
    end
    return cfms
  end

  # Appends HVAC sizing results to the provided array for use in writing output files.
  #
  # @param hpxml_bldgs [Array<HPXML::Building>] List of HPXML Building objects representing an individual dwelling unit
  # @param results_out [Array] Rows of output data
  # @return [Array] Rows of output data, with HVAC sizing results appended
  def self.append_sizing_results(hpxml_bldgs, results_out)
    line_break = nil

    # Summary HVAC capacities
    all_hvac_capacities = hpxml_bldgs.map { |hpxml_bldg| get_total_hvac_capacities(hpxml_bldg) }
    results_out << ['HVAC Capacity: Heating (Btu/h)', all_hvac_capacities.sum { |h| h[:htg] }.round]
    results_out << ['HVAC Capacity: Cooling (Btu/h)', all_hvac_capacities.sum { |h| h[:clg] }.round]
    results_out << ['HVAC Capacity: Heat Pump Backup (Btu/h)', all_hvac_capacities.sum { |h| h[:htg_backup] }.round]

    # HVAC design temperatures
    results_out << [line_break]
    results_out << ['HVAC Design Temperature: Heating (F)', (hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.header.manualj_heating_design_temp }.sum(0.0) / hpxml_bldgs.size).round(2)]
    results_out << ['HVAC Design Temperature: Cooling (F)', (hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.header.manualj_cooling_design_temp }.sum(0.0) / hpxml_bldgs.size).round(2)]

    # HVAC Building design loads
    results_out << [line_break]
    results_out << ['HVAC Design Load: Heating: Total (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.hdl_total * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]
    results_out << ['HVAC Design Load: Heating: Ducts (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.hdl_ducts * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]
    results_out << ['HVAC Design Load: Heating: Windows (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.hdl_windows * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]
    results_out << ['HVAC Design Load: Heating: Skylights (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.hdl_skylights * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]
    results_out << ['HVAC Design Load: Heating: Doors (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.hdl_doors * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]
    results_out << ['HVAC Design Load: Heating: Walls (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.hdl_walls * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]
    results_out << ['HVAC Design Load: Heating: Roofs (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.hdl_roofs * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]
    results_out << ['HVAC Design Load: Heating: Floors (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.hdl_floors * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]
    results_out << ['HVAC Design Load: Heating: Slabs (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.hdl_slabs * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]
    results_out << ['HVAC Design Load: Heating: Ceilings (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.hdl_ceilings * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]
    results_out << ['HVAC Design Load: Heating: Infiltration (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.hdl_infil * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]
    results_out << ['HVAC Design Load: Heating: Ventilation (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.hdl_vent * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]
    results_out << ['HVAC Design Load: Heating: Piping (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.hdl_piping * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]
    results_out << ['HVAC Design Load: Cooling Sensible: Total (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.cdl_sens_total * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]
    results_out << ['HVAC Design Load: Cooling Sensible: Ducts (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.cdl_sens_ducts * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]
    results_out << ['HVAC Design Load: Cooling Sensible: Windows (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.cdl_sens_windows * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]
    results_out << ['HVAC Design Load: Cooling Sensible: Skylights (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.cdl_sens_skylights * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]
    results_out << ['HVAC Design Load: Cooling Sensible: Doors (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.cdl_sens_doors * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]
    results_out << ['HVAC Design Load: Cooling Sensible: Walls (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.cdl_sens_walls * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]
    results_out << ['HVAC Design Load: Cooling Sensible: Roofs (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.cdl_sens_roofs * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]
    results_out << ['HVAC Design Load: Cooling Sensible: Floors (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.cdl_sens_floors * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]
    results_out << ['HVAC Design Load: Cooling Sensible: Slabs (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.cdl_sens_slabs * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]
    results_out << ['HVAC Design Load: Cooling Sensible: Ceilings (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.cdl_sens_ceilings * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]
    results_out << ['HVAC Design Load: Cooling Sensible: Infiltration (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.cdl_sens_infil * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]
    results_out << ['HVAC Design Load: Cooling Sensible: Ventilation (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.cdl_sens_vent * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]
    results_out << ['HVAC Design Load: Cooling Sensible: Internal Gains (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.cdl_sens_intgains * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]
    results_out << ['HVAC Design Load: Cooling Sensible: Blower Heat (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.cdl_sens_blowerheat * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]
    results_out << ['HVAC Design Load: Cooling Sensible: AED Excursion (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.cdl_sens_aedexcursion * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]
    results_out << ['HVAC Design Load: Cooling Latent: Total (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.cdl_lat_total * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]
    results_out << ['HVAC Design Load: Cooling Latent: Ducts (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.cdl_lat_ducts * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]
    results_out << ['HVAC Design Load: Cooling Latent: Infiltration (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.cdl_lat_infil * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]
    results_out << ['HVAC Design Load: Cooling Latent: Ventilation (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.cdl_lat_vent * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]
    results_out << ['HVAC Design Load: Cooling Latent: Internal Gains (Btu/h)', hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.hvac_plant.cdl_lat_intgains * hpxml_bldg.building_construction.number_of_units }.sum(0.0).round]

    # HVAC Zone design loads
    hpxml_bldgs.each do |hpxml_bldg|
      hpxml_bldg.conditioned_zones.each do |zone|
        next if zone.id.start_with? Constants::AutomaticallyAdded

        results_out << [line_break]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Heating: Total (Btu/h)", zone.hdl_total.round]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Heating: Ducts (Btu/h)", zone.hdl_ducts.round]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Heating: Windows (Btu/h)", zone.hdl_windows.round]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Heating: Skylights (Btu/h)", zone.hdl_skylights.round]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Heating: Doors (Btu/h)", zone.hdl_doors.round]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Heating: Walls (Btu/h)", zone.hdl_walls.round]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Heating: Roofs (Btu/h)", zone.hdl_roofs.round]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Heating: Floors (Btu/h)", zone.hdl_floors.round]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Heating: Slabs (Btu/h)", zone.hdl_slabs.round]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Heating: Ceilings (Btu/h)", zone.hdl_ceilings.round]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Heating: Infiltration (Btu/h)", zone.hdl_infil.round]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Heating: Ventilation (Btu/h)", zone.hdl_vent.round]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Heating: Piping (Btu/h)", zone.hdl_piping.round]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Cooling Sensible: Total (Btu/h)", zone.cdl_sens_total.round]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Cooling Sensible: Ducts (Btu/h)", zone.cdl_sens_ducts.round]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Cooling Sensible: Windows (Btu/h)", zone.cdl_sens_windows.round]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Cooling Sensible: Skylights (Btu/h)", zone.cdl_sens_skylights.round]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Cooling Sensible: Doors (Btu/h)", zone.cdl_sens_doors.round]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Cooling Sensible: Walls (Btu/h)", zone.cdl_sens_walls.round]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Cooling Sensible: Roofs (Btu/h)", zone.cdl_sens_roofs.round]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Cooling Sensible: Floors (Btu/h)", zone.cdl_sens_floors.round]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Cooling Sensible: Slabs (Btu/h)", zone.cdl_sens_slabs.round]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Cooling Sensible: Ceilings (Btu/h)", zone.cdl_sens_ceilings.round]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Cooling Sensible: Infiltration (Btu/h)", zone.cdl_sens_infil.round]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Cooling Sensible: Ventilation (Btu/h)", zone.cdl_sens_vent.round]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Cooling Sensible: Internal Gains (Btu/h)", zone.cdl_sens_intgains.round]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Cooling Sensible: Blower Heat (Btu/h)", zone.cdl_sens_blowerheat.round]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Cooling Sensible: AED Excursion (Btu/h)", zone.cdl_sens_aedexcursion.round]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Cooling Latent: Total (Btu/h)", zone.cdl_lat_total.round]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Cooling Latent: Ducts (Btu/h)", zone.cdl_lat_ducts.round]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Cooling Latent: Infiltration (Btu/h)", zone.cdl_lat_infil.round]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Cooling Latent: Ventilation (Btu/h)", zone.cdl_lat_vent.round]
        results_out << ["HVAC Zone Design Load: #{zone.id}: Cooling Latent: Internal Gains (Btu/h)", zone.cdl_lat_intgains.round]
      end
    end

    # HVAC Space design loads
    hpxml_bldgs.each do |hpxml_bldg|
      hpxml_bldg.conditioned_spaces.each do |space|
        results_out << [line_break]
        # Note: Latent loads are not calculated for spaces
        results_out << ["HVAC Space Design Load: #{space.id}: Heating: Total (Btu/h)", space.hdl_total.round]
        results_out << ["HVAC Space Design Load: #{space.id}: Heating: Ducts (Btu/h)", space.hdl_ducts.round]
        results_out << ["HVAC Space Design Load: #{space.id}: Heating: Windows (Btu/h)", space.hdl_windows.round]
        results_out << ["HVAC Space Design Load: #{space.id}: Heating: Skylights (Btu/h)", space.hdl_skylights.round]
        results_out << ["HVAC Space Design Load: #{space.id}: Heating: Doors (Btu/h)", space.hdl_doors.round]
        results_out << ["HVAC Space Design Load: #{space.id}: Heating: Walls (Btu/h)", space.hdl_walls.round]
        results_out << ["HVAC Space Design Load: #{space.id}: Heating: Roofs (Btu/h)", space.hdl_roofs.round]
        results_out << ["HVAC Space Design Load: #{space.id}: Heating: Floors (Btu/h)", space.hdl_floors.round]
        results_out << ["HVAC Space Design Load: #{space.id}: Heating: Slabs (Btu/h)", space.hdl_slabs.round]
        results_out << ["HVAC Space Design Load: #{space.id}: Heating: Ceilings (Btu/h)", space.hdl_ceilings.round]
        results_out << ["HVAC Space Design Load: #{space.id}: Heating: Infiltration (Btu/h)", space.hdl_infil.round]
        results_out << ["HVAC Space Design Load: #{space.id}: Cooling Sensible: Total (Btu/h)", space.cdl_sens_total.round]
        results_out << ["HVAC Space Design Load: #{space.id}: Cooling Sensible: Ducts (Btu/h)", space.cdl_sens_ducts.round]
        results_out << ["HVAC Space Design Load: #{space.id}: Cooling Sensible: Windows (Btu/h)", space.cdl_sens_windows.round]
        results_out << ["HVAC Space Design Load: #{space.id}: Cooling Sensible: Skylights (Btu/h)", space.cdl_sens_skylights.round]
        results_out << ["HVAC Space Design Load: #{space.id}: Cooling Sensible: Doors (Btu/h)", space.cdl_sens_doors.round]
        results_out << ["HVAC Space Design Load: #{space.id}: Cooling Sensible: Walls (Btu/h)", space.cdl_sens_walls.round]
        results_out << ["HVAC Space Design Load: #{space.id}: Cooling Sensible: Roofs (Btu/h)", space.cdl_sens_roofs.round]
        results_out << ["HVAC Space Design Load: #{space.id}: Cooling Sensible: Floors (Btu/h)", space.cdl_sens_floors.round]
        results_out << ["HVAC Space Design Load: #{space.id}: Cooling Sensible: Slabs (Btu/h)", space.cdl_sens_slabs.round]
        results_out << ["HVAC Space Design Load: #{space.id}: Cooling Sensible: Ceilings (Btu/h)", space.cdl_sens_ceilings.round]
        results_out << ["HVAC Space Design Load: #{space.id}: Cooling Sensible: Infiltration (Btu/h)", space.cdl_sens_infil.round]
        results_out << ["HVAC Space Design Load: #{space.id}: Cooling Sensible: Internal Gains (Btu/h)", space.cdl_sens_intgains.round]
        results_out << ["HVAC Space Design Load: #{space.id}: Cooling Sensible: AED Excursion (Btu/h)", space.cdl_sens_aedexcursion.round]
      end
    end

    # Geothermal loop
    results_out << [line_break]
    geothermal_loops = hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.geothermal_loops }.flatten
    num_boreholes = geothermal_loops.map { |loop| loop.num_bore_holes }.sum(0)
    total_length = geothermal_loops.map { |loop| loop.bore_length * loop.num_bore_holes }.sum(0.0)
    results_out << ['HVAC Geothermal Loop: Borehole/Trench Count', num_boreholes]
    results_out << ['HVAC Geothermal Loop: Borehole/Trench Length (ft)', (total_length / [num_boreholes, 1].max).round(1)] # [num_boreholes, 1].max to prevent divide by zero

    return results_out
  end

  # Returns electric panel results for use in writing output files.
  #
  # @param hpxml_bldgs [Array<HPXML::Building>] List of HPXML Building objects representing an individual dwelling unit
  # @return [Array] Rows of output data, with electric panel results appended
  def self.get_panel_results(hpxml_header, hpxml_bldgs)
    results_out = []

    # Currently, we only write this file if:
    # (1) at least one load calculation type is specified
    # (2) an electric panel is specified
    if hpxml_header.service_feeders_load_calculation_types.empty?
      return results_out
    elsif hpxml_bldgs.map { |hpxml_bldg| hpxml_bldg.electric_panels.size }.sum == 0
      return results_out
    end

    line_break = nil

    # Summary breaker spaces
    all_breaker_spaces = hpxml_bldgs.map { |hpxml_bldg| get_total_breaker_spaces(hpxml_bldg) }
    results_out << ['Electric Panel Breaker Spaces: Heating Count', all_breaker_spaces.sum { |h| h[HPXML::ElectricPanelLoadTypeHeating] }]
    results_out << ['Electric Panel Breaker Spaces: Cooling Count', all_breaker_spaces.sum { |h| h[HPXML::ElectricPanelLoadTypeCooling] }]
    results_out << ['Electric Panel Breaker Spaces: Hot Water Count', all_breaker_spaces.sum { |h| h[HPXML::ElectricPanelLoadTypeWaterHeater] }]
    results_out << ['Electric Panel Breaker Spaces: Clothes Dryer Count', all_breaker_spaces.sum { |h| h[HPXML::ElectricPanelLoadTypeClothesDryer] }]
    results_out << ['Electric Panel Breaker Spaces: Dishwasher Count', all_breaker_spaces.sum { |h| h[HPXML::ElectricPanelLoadTypeDishwasher] }]
    results_out << ['Electric Panel Breaker Spaces: Range/Oven Count', all_breaker_spaces.sum { |h| h[HPXML::ElectricPanelLoadTypeRangeOven] }]
    results_out << ['Electric Panel Breaker Spaces: Mech Vent Count', all_breaker_spaces.sum { |h| h[HPXML::ElectricPanelLoadTypeMechVent] }]
    results_out << ['Electric Panel Breaker Spaces: Permanent Spa Heater Count', all_breaker_spaces.sum { |h| h[HPXML::ElectricPanelLoadTypePermanentSpaHeater] }]
    results_out << ['Electric Panel Breaker Spaces: Permanent Spa Pump Count', all_breaker_spaces.sum { |h| h[HPXML::ElectricPanelLoadTypePermanentSpaPump] }]
    results_out << ['Electric Panel Breaker Spaces: Pool Heater Count', all_breaker_spaces.sum { |h| h[HPXML::ElectricPanelLoadTypePoolHeater] }]
    results_out << ['Electric Panel Breaker Spaces: Pool Pump Count', all_breaker_spaces.sum { |h| h[HPXML::ElectricPanelLoadTypePoolPump] }]
    results_out << ['Electric Panel Breaker Spaces: Well Pump Count', all_breaker_spaces.sum { |h| h[HPXML::ElectricPanelLoadTypeWellPump] }]
    results_out << ['Electric Panel Breaker Spaces: Electric Vehicle Charging Count', all_breaker_spaces.sum { |h| h[HPXML::ElectricPanelLoadTypeElectricVehicleCharging] }]
    results_out << ['Electric Panel Breaker Spaces: Other Count', all_breaker_spaces.sum { |h| h[HPXML::ElectricPanelLoadTypeOther] }]

    # Total breaker spaces
    results_out << [line_break]
    results_out << ['Electric Panel Breaker Spaces: Total Count', hpxml_bldgs.map { |b| b.electric_panels.map { |p| p.rated_total_spaces }.sum * b.building_construction.number_of_units }.sum]
    results_out << ['Electric Panel Breaker Spaces: Occupied Count', hpxml_bldgs.map { |b| b.electric_panels.map { |p| p.occupied_spaces }.sum * b.building_construction.number_of_units }.sum]
    results_out << ['Electric Panel Breaker Spaces: Headroom Count', hpxml_bldgs.map { |b| b.electric_panels.map { |p| p.headroom_spaces }.sum * b.building_construction.number_of_units }.sum]

    # Summary panel loads
    all_panel_loads = hpxml_bldgs.map { |hpxml_bldg| get_total_panel_loads(hpxml_bldg) }
    results_out << [line_break]
    results_out << ['Electric Panel Load: Heating (W)', all_panel_loads.sum { |h| h[HPXML::ElectricPanelLoadTypeHeating] }.round(1)]
    results_out << ['Electric Panel Load: Cooling (W)', all_panel_loads.sum { |h| h[HPXML::ElectricPanelLoadTypeCooling] }.round(1)]
    results_out << ['Electric Panel Load: Hot Water (W)', all_panel_loads.sum { |h| h[HPXML::ElectricPanelLoadTypeWaterHeater] }.round(1)]
    results_out << ['Electric Panel Load: Clothes Dryer (W)', all_panel_loads.sum { |h| h[HPXML::ElectricPanelLoadTypeClothesDryer] }.round(1)]
    results_out << ['Electric Panel Load: Dishwasher (W)', all_panel_loads.sum { |h| h[HPXML::ElectricPanelLoadTypeDishwasher] }.round(1)]
    results_out << ['Electric Panel Load: Range/Oven (W)', all_panel_loads.sum { |h| h[HPXML::ElectricPanelLoadTypeRangeOven] }.round(1)]
    results_out << ['Electric Panel Load: Mech Vent (W)', all_panel_loads.sum { |h| h[HPXML::ElectricPanelLoadTypeMechVent] }.round(1)]
    results_out << ['Electric Panel Load: Permanent Spa Heater (W)', all_panel_loads.sum { |h| h[HPXML::ElectricPanelLoadTypePermanentSpaHeater] }.round(1)]
    results_out << ['Electric Panel Load: Permanent Spa Pump (W)', all_panel_loads.sum { |h| h[HPXML::ElectricPanelLoadTypePermanentSpaPump] }.round(1)]
    results_out << ['Electric Panel Load: Pool Heater (W)', all_panel_loads.sum { |h| h[HPXML::ElectricPanelLoadTypePoolHeater] }.round(1)]
    results_out << ['Electric Panel Load: Pool Pump (W)', all_panel_loads.sum { |h| h[HPXML::ElectricPanelLoadTypePoolPump] }.round(1)]
    results_out << ['Electric Panel Load: Well Pump (W)', all_panel_loads.sum { |h| h[HPXML::ElectricPanelLoadTypeWellPump] }.round(1)]
    results_out << ['Electric Panel Load: Electric Vehicle Charging (W)', all_panel_loads.sum { |h| h[HPXML::ElectricPanelLoadTypeElectricVehicleCharging] }.round(1)]
    results_out << ['Electric Panel Load: Other (W)', all_panel_loads.sum { |h| h[HPXML::ElectricPanelLoadTypeOther] }.round(1)]

    # Total panel loads
    results_out << [line_break]
    results_out << ['Electric Panel Load: Max Current Rating (A)', hpxml_bldgs.map { |b| b.electric_panels.map { |p| p.max_current_rating }.sum * b.building_construction.number_of_units }.sum]

    # Load calculations
    hpxml_header.service_feeders_load_calculation_types.each do |service_feeders_load_calculation_type|
      capacity_total_watt = 0.0
      capacity_total_amp = 0.0
      capacity_headroom_amp = 0.0
      hpxml_bldgs.each do |hpxml_bldg|
        hpxml_bldg.electric_panels.each do |electric_panel|
          capacity_types = electric_panel.capacity_types
          capacity_total_watts = electric_panel.capacity_total_watts
          capacity_total_amps = electric_panel.capacity_total_amps
          capacity_headroom_amps = electric_panel.capacity_headroom_amps
          capacities = capacity_types.zip(capacity_total_watts, capacity_total_amps, capacity_headroom_amps)
          capacities.each do |capacity|
            ct, ctw, cta, cha = capacity
            next if ct != service_feeders_load_calculation_type

            capacity_total_watt += ctw * hpxml_bldg.building_construction.number_of_units
            capacity_total_amp += cta * hpxml_bldg.building_construction.number_of_units
            capacity_headroom_amp += cha * hpxml_bldg.building_construction.number_of_units
          end
        end
      end
      results_out << [line_break]
      results_out << ["Electric Panel Load: #{service_feeders_load_calculation_type}: Total Load (W)", capacity_total_watt.round(1)]
      results_out << ["Electric Panel Load: #{service_feeders_load_calculation_type}: Total Capacity (A)", capacity_total_amp.round(1)]
      results_out << ["Electric Panel Load: #{service_feeders_load_calculation_type}: Headroom Capacity (A)", capacity_headroom_amp.round(1)]
    end

    return results_out
  end

  # Writes an output file for the given rows of output data.
  #
  # @param results_out [Array] Rows of output data
  # @param output_format [String] Type of output file (csv, json, or msgpack)
  # @param output_file_path [String] Path for the output file
  # @param mode [String] File opening mode (e.g., write or append)
  # @return [nil]
  def self.write_results_out_to_file(results_out, output_format, output_file_path, mode = 'w')
    line_break = nil
    if ['csv'].include? output_format
      CSV.open(output_file_path, mode) { |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_file_path, mode) { |json| json.write(JSON.pretty_generate(h)) }
      elsif output_format == 'msgpack'
        require 'msgpack'
        File.open(output_file_path, "#{mode}b") { |json| h.to_msgpack(json) }
      end
    end
  end

  # Register to the runner for the given rows of output data.
  #
  # @param runner [OpenStudio::Measure::OSRunner] Object typically used to display warnings
  # @param results_out [Array] Rows of output data
  # @return [nil]
  def self.register_results_out_to_runner(runner, results_out)
    results_out.each do |name, value|
      next if name.nil? || value.nil?

      name = OpenStudio::toUnderscoreCase(name).chomp('_')

      runner.registerValue(name, value)
      runner.registerInfo("Registering #{value} for #{name}.")
    end
  end

  # Creates custom output meters that are used across reporting measures.
  #
  # @param model [OpenStudio::Model::Model] OpenStudio Model object
  # @param custom_unit_meter [OpenStudio::Model::MeterCustom] optional OpenStudio custom meter object
  # @return [nil]
  def self.create_custom_electricity_meters(model, custom_unit_meter = nil)
    # Create custom meters:
    # - Total Electricity (Electricity:Facility plus EV charging, batteries, generators)
    # - Net Electricity (above plus PV)
    # - PV Electricity
    # - Critical Electricity (Electricity:Facility plus generators)
    # - Net Critical Electricity (Electricity:Facility plus PV, generators)

    total_key_vars = []
    net_key_vars = []
    pv_key_vars = []
    gen_key_vars = []
    model.getElectricLoadCenterDistributions.each do |elcd|
      # Batteries & EV charging output variables
      if elcd.electricalStorage.is_initialized
        elcs = elcd.electricalStorage.get
        if elcs.additionalProperties.getFeatureAsString('ObjectType').to_s == Constants::ObjectTypeVehicle
          net_key_vars << [elcs.name.to_s.upcase, 'Electric Storage Production Decrement Energy']
          total_key_vars << net_key_vars[-1]
        elsif elcs.additionalProperties.getFeatureAsString('ObjectType').to_s == Constants::ObjectTypeBattery
          net_key_vars << [elcs.name.to_s.upcase, 'Electric Storage Production Decrement Energy']
          total_key_vars << net_key_vars[-1]
          net_key_vars << [elcs.name.to_s.upcase, 'Electric Storage Discharge Energy']
          total_key_vars << net_key_vars[-1]
        end
      end

      # PV output meters
      elcd.generators.each do |generator|
        next unless generator.additionalProperties.getFeatureAsString('ObjectType').to_s == Constants::ObjectTypePhotovoltaics

        if generator.to_GeneratorPVWatts.is_initialized
          net_key_vars << [generator.name.to_s.upcase, 'Generator Produced DC Electricity Energy']
          pv_key_vars << net_key_vars[-1]
        end
      end

      if elcd.inverter.is_initialized
        inv = elcd.inverter.get
        net_key_vars << [inv.name.to_s.upcase, 'Inverter Conversion Loss Decrement Energy']
        pv_key_vars << net_key_vars[-1]
      end

      # Generator output meter
      elcd.generators.each do |generator|
        next unless generator.additionalProperties.getFeatureAsString('ObjectType').to_s == Constants::ObjectTypeGenerator

        next unless generator.to_GeneratorMicroTurbine.is_initialized

        net_key_vars << [generator.name.to_s, 'Generator Produced AC Electricity Energy']
        total_key_vars << net_key_vars[-1]
        gen_key_vars << net_key_vars[-1]
      end
    end

    # Create Total/Net/Critical meters
    { MeterCustomElectricityTotal => total_key_vars,
      MeterCustomElectricityNet => net_key_vars,
      MeterCustomElectricityCritical => gen_key_vars,
      MeterCustomElectricityNetCritical => pv_key_vars + gen_key_vars }.each do |meter_name, key_vars|
      if key_vars.empty?
        # Avoid OpenStudio warnings if nothing to decrement
        if custom_unit_meter.nil?
          key_vars << ['', 'Electricity:Facility']
        else
          # Meter:Custom cannot reference another Meter:Custom,
          # so we pass key/variable groups from one to the other.
          # https://github.com/NatLabRockies/EnergyPlus/issues/11400
          key_vars = custom_unit_meter.keyVarGroups
        end
        Model.add_meter_custom(
          model,
          name: meter_name,
          fuel_type: EPlus::FuelTypeElectricity,
          key_var_pairs: key_vars
        )
      else
        if custom_unit_meter.nil?
          source_meter_name = 'Electricity:Facility'
        else
          source_meter_name = 'Electricity:DwellingUnit'
        end
        Model.add_meter_custom_decrement(
          model,
          name: meter_name,
          fuel_type: EPlus::FuelTypeElectricity,
          key_var_pairs: key_vars,
          source_meter_name: source_meter_name
        )
      end
    end

    # Create PV meter
    if not pv_key_vars.empty?
      Model.add_meter_custom(
        model,
        name: MeterCustomElectricityPV,
        fuel_type: EPlus::FuelTypeElectricity,
        key_var_pairs: pv_key_vars
      )
    end
  end

  # Create custom meters with fuel usage *for each unit*.
  #
  # @param model [OpenStudio::Model::Model] OpenStudio Model object
  # @param hpxml [HPXML] HPXML object
  # @return [nil]
  def self.create_custom_unit_meters(model, hpxml)
    return if hpxml.buildings.size == 1

    FT_to_EPlus_fuel_map.values.each do |fuel_type|
      key_vars = []
      model.getModelObjects.sort.each do |object|
        next if object.to_AdditionalProperties.is_initialized

        vars_by_key = get_object_outputs_by_key(object, EUT)
        vars_by_key.each do |key, output_vars|
          ft, eut = key

          next if FT_to_EPlus_fuel_map[ft] != fuel_type

          # The electricity meter should only include generation, so we exclude any outputs associated with production.
          if fuel_type == EPlus::FuelTypeElectricity
            next if [EUT::PV, EUT::Generator, EUT::Vehicle, EUT::Battery].include?(eut) &&
                    !output_vars.any? { |x| x.include?(Constants::ObjectTypeBatteryLossesAdjustment) || x.include?(Constants::ObjectTypeMiscElectricVehicleCharging) }
          end

          output_vars.each do |output_var|
            if object.to_EnergyManagementSystemOutputVariable.is_initialized
              varkey = 'EMS'
            else
              varkey = object.name.to_s.upcase
              varkey = '' if output_var.include?(':') # Avoid the "Output Variable or Meter Name="x:y:z" referenced multiple times warning by just not including key names for meters
            end

            key_vars << [varkey, output_var]
          end
        end
      end

      next if key_vars.empty?

      custom_unit_meter = Model.add_meter_custom(
        model,
        name: "#{fuel_type}:DwellingUnit",
        fuel_type: fuel_type,
        key_var_pairs: key_vars
      )

      # We're in the fuel types loop so that we can pass in custom_unit_meter from above.
      # But we don't want to call create_custom_electricity_meters multiple times.
      # We only need the electricity Total, Net, PV, Critical meters by unit when there are multiple units.
      if fuel_type == EPlus::FuelTypeElectricity
        create_custom_electricity_meters(model, custom_unit_meter)
      end
    end
  end

  # Returns all the Output:Variables or Output:Meters that are related to the
  # energy use of the given HPXML system (e.g., HeatPump, WaterHeatingSystem).
  #
  # @param model [OpenStudio::Model::Model] OpenStudio Model object
  # @param sys_id [String] HPXML System ID
  # @param eut_list [Array<String>] Optional list of EUT::XXX that we should filter down to
  # @return [Hash] Map of output key => (Map of OpenStudio model object => array of EnergyPlus output variable/meter names)
  def self.get_object_outputs_for_hpxml_system(model, sys_id, eut_filter = nil)
    vars = {}
    model.getModelObjects.sort.each do |object|
      next if object.to_AdditionalProperties.is_initialized

      obj_id = object.additionalProperties.getFeatureAsString('HPXML_ID')
      next unless obj_id.is_initialized
      next if sys_id != obj_id.get

      vars_by_key = get_object_outputs_by_key(object, EUT)
      vars_by_key.each do |key, object_vars|
        if eut_filter.nil? || eut_filter.include?(key[1])
          vars[key] = {} if vars[key].nil?
          vars[key][object] = object_vars
        end
      end
    end

    return vars
  end

  # For a given object, returns the Output:Variables or Output:Meters to be requested,
  # and associates them with the appropriate keys (e.g., [FT::Elec, EUT::Heating]).
  #
  # @param object [OpenStudio::Model::Foo] A given object in the OpenStudio Model
  # @param class_type [Module] The output class type
  # @return [Hash] Map of output key => array of EnergyPlus output variable/meter names
  def self.get_object_outputs_by_key(object, class_type)
    object_type = object.additionalProperties.getFeatureAsString('ObjectType')
    object_type = object_type.get if object_type.is_initialized

    # Map of EPlus => FT fuel
    to_ft = FT_to_EPlus_fuel_map.invert

    if class_type == EUT

      # End uses

      if object.to_CoilHeatingDXSingleSpeed.is_initialized || object.to_CoilHeatingDXMultiSpeed.is_initialized
        vars = { [FT::Elec, EUT::Heating] => ['Heating Coil Electricity Energy', 'Heating Coil Defrost Electricity Energy'] }
        return vars

      elsif object.to_CoilHeatingElectric.is_initialized || object.to_CoilHeatingElectricMultiStage.is_initialized
        if object.additionalProperties.getFeatureAsBoolean('IsHeatPumpBackup').is_initialized && object.additionalProperties.getFeatureAsBoolean('IsHeatPumpBackup').get
          return { [FT::Elec, EUT::HeatingHeatPumpBackup] => ['Heating Coil Electricity Energy'] }
        else
          return { [FT::Elec, EUT::Heating] => ['Heating Coil Electricity Energy'] }
        end

      elsif object.to_CoilHeatingGas.is_initialized
        fuel = object.to_CoilHeatingGas.get.fuelType
        if object.additionalProperties.getFeatureAsBoolean('IsHeatPumpBackup').is_initialized && object.additionalProperties.getFeatureAsBoolean('IsHeatPumpBackup').get
          return { [to_ft[fuel], EUT::HeatingHeatPumpBackup] => ["Heating Coil #{fuel} Energy", "Heating Coil Ancillary #{fuel} Energy"] }
        else
          return { [to_ft[fuel], EUT::Heating] => ["Heating Coil #{fuel} Energy", "Heating Coil Ancillary #{fuel} Energy"] }
        end

      elsif object.to_CoilHeatingWaterToAirHeatPumpEquationFit.is_initialized || object.to_CoilHeatingWaterToAirHeatPumpVariableSpeedEquationFit.is_initialized
        return { [FT::Elec, EUT::Heating] => ['Heating Coil Electricity Energy'] }

      elsif object.to_ZoneHVACBaseboardConvectiveElectric.is_initialized
        object = object.to_ZoneHVACBaseboardConvectiveElectric.get
        if object.additionalProperties.getFeatureAsBoolean('IsHeatPumpBackup').is_initialized && object.additionalProperties.getFeatureAsBoolean('IsHeatPumpBackup').get
          return { [FT::Elec, EUT::HeatingHeatPumpBackup] => ['Baseboard Electricity Energy'] }
        else
          return { [FT::Elec, EUT::Heating] => ['Baseboard Electricity Energy'] }
        end

      elsif object.to_BoilerHotWater.is_initialized
        is_combi_boiler = false
        if object.additionalProperties.getFeatureAsBoolean('IsCombiBoiler').is_initialized
          is_combi_boiler = object.additionalProperties.getFeatureAsBoolean('IsCombiBoiler').get
        end
        if not is_combi_boiler # Exclude combi boiler, whose heating & dhw energy is handled separately via EMS
          fuel = object.to_BoilerHotWater.get.fuelType
          if object.additionalProperties.getFeatureAsBoolean('IsHeatPumpBackup').is_initialized && object.additionalProperties.getFeatureAsBoolean('IsHeatPumpBackup').get
            return { [to_ft[fuel], EUT::HeatingHeatPumpBackup] => ["Boiler #{fuel} Energy", "Boiler Ancillary #{fuel} Energy"] }
          else
            return { [to_ft[fuel], EUT::Heating] => ["Boiler #{fuel} Energy", "Boiler Ancillary #{fuel} Energy"] }
          end
        else
          fuel = object.to_BoilerHotWater.get.fuelType
          return { [to_ft[fuel], EUT::HotWater] => ["Boiler #{fuel} Energy", "Boiler Ancillary #{fuel} Energy"] }
        end

      elsif object.to_CoilCoolingDXSingleSpeed.is_initialized || object.to_CoilCoolingDXMultiSpeed.is_initialized
        return { [FT::Elec, EUT::Cooling] => ['Cooling Coil Electricity Energy'] }

      elsif object.to_CoilCoolingWaterToAirHeatPumpEquationFit.is_initialized || object.to_CoilCoolingWaterToAirHeatPumpVariableSpeedEquationFit.is_initialized
        return { [FT::Elec, EUT::Cooling] => ['Cooling Coil Electricity Energy'] }

      elsif object.to_EvaporativeCoolerDirectResearchSpecial.is_initialized
        return { [FT::Elec, EUT::Cooling] => ['Evaporative Cooler Electricity Energy'] }

      elsif object.to_CoilWaterHeatingAirToWaterHeatPumpWrapped.is_initialized
        return { [FT::Elec, EUT::HotWater] => ['Cooling Coil Water Heating Electricity Energy'] }

      elsif object.to_FanSystemModel.is_initialized
        if object_type == Constants::ObjectTypeWaterHeater
          return { [FT::Elec, EUT::HotWater] => ['Fan Electricity Energy'] }
        end

      elsif object.to_PumpConstantSpeed.is_initialized
        if object_type == Constants::ObjectTypeSolarHotWater
          return { [FT::Elec, EUT::HotWaterSolarThermalPump] => ['Pump Electricity Energy'] }
        end

      elsif object.to_WaterHeaterMixed.is_initialized
        fuel = object.to_WaterHeaterMixed.get.heaterFuelType
        return { [to_ft[fuel], EUT::HotWater] => ["Water Heater #{fuel} Energy", 'Water Heater Off Cycle Parasitic Electricity Energy', 'Water Heater On Cycle Parasitic Electricity Energy'] }

      elsif object.to_WaterHeaterStratified.is_initialized
        fuel = object.to_WaterHeaterStratified.get.heaterFuelType
        return { [to_ft[fuel], EUT::HotWater] => ["Water Heater #{fuel} Energy", 'Water Heater Off Cycle Parasitic Electricity Energy', 'Water Heater On Cycle Parasitic Electricity Energy'] }

      elsif object.to_Lights.is_initialized
        object = object.to_Lights.get
        subcategory = object.endUseSubcategory
        end_use = { Constants::ObjectTypeLightingInterior => EUT::LightsInterior,
                    Constants::ObjectTypeLightingGarage => EUT::LightsGarage }[subcategory]
        fail 'Unexpected error: InteriorLights:Electricity without a space.' unless object.space.is_initialized

        zone_name = object.space.get.thermalZone.get.name.to_s.upcase
        return { [FT::Elec, end_use] => ["#{subcategory}:InteriorLights:Electricity:Zone:#{zone_name}"] }

      elsif object.to_ElectricLoadCenterInverterPVWatts.is_initialized
        return { [FT::Elec, EUT::PV] => ['Inverter Conversion Loss Decrement Energy'] }

      elsif object.to_GeneratorPVWatts.is_initialized
        return { [FT::Elec, EUT::PV] => ['Generator Produced DC Electricity Energy'] }

      elsif object.to_GeneratorMicroTurbine.is_initialized
        fuel = object.to_GeneratorMicroTurbine.get.fuelType
        return { [FT::Elec, EUT::Generator] => ['Generator Produced AC Electricity Energy'],
                 [to_ft[fuel], EUT::Generator] => ["Generator #{fuel} HHV Basis Energy"] }

      elsif object.to_ElectricLoadCenterStorageLiIonNMCBattery.is_initialized
        if object_type == Constants::ObjectTypeVehicle
          return { [FT::Elec, EUT::Vehicle] => ['Electric Storage Charge Energy'] }
        elsif object_type == Constants::ObjectTypeBattery
          return { [FT::Elec, EUT::Battery] => ['Electric Storage Production Decrement Energy', 'Electric Storage Discharge Energy'] }
        else
          fail "Unexpected elcs: #{object.name}"
        end

      elsif object.to_ElectricEquipment.is_initialized
        object = object.to_ElectricEquipment.get
        subcategory = object.endUseSubcategory
        end_use = nil
        { Constants::ObjectTypeHotWaterRecircPump => EUT::HotWaterRecircPump,
          Constants::ObjectTypeClothesWasher => EUT::ClothesWasher,
          Constants::ObjectTypeClothesDryer => EUT::ClothesDryer,
          Constants::ObjectTypeDishwasher => EUT::Dishwasher,
          Constants::ObjectTypeRefrigerator => EUT::Refrigerator,
          Constants::ObjectTypeFreezer => EUT::Freezer,
          Constants::ObjectTypeCookingRange => EUT::RangeOven,
          Constants::ObjectTypeCeilingFan => EUT::CeilingFan,
          Constants::ObjectTypeWholeHouseFan => EUT::WholeHouseFan,
          Constants::ObjectTypeMechanicalVentilation => EUT::MechVent,
          Constants::ObjectTypeMiscPlugLoads => EUT::PlugLoads,
          Constants::ObjectTypeMiscTelevision => EUT::Television,
          Constants::ObjectTypeMiscPoolHeater => EUT::PoolHeater,
          Constants::ObjectTypeMiscPoolPump => EUT::PoolPump,
          Constants::ObjectTypeMiscPermanentSpaHeater => EUT::PermanentSpaHeater,
          Constants::ObjectTypeMiscPermanentSpaPump => EUT::PermanentSpaPump,
          Constants::ObjectTypeMiscElectricVehicleCharging => EUT::Vehicle,
          Constants::ObjectTypeMiscWellPump => EUT::WellPump,
          Constants::ObjectTypeLightingExterior => EUT::LightsExterior,
          Constants::ObjectTypeLightingExteriorHoliday => EUT::LightsExterior }.each do |obj_name, eut|
          next unless subcategory.start_with? obj_name
          fail "Unexpected error: multiple matches for #{eut}." unless end_use.nil?

          end_use = eut
        end

        if not end_use.nil?
          # Use Output:Meter instead of Output:Variable because they incorporate thermal zone multipliers
          fail 'Unexpected error: InteriorEquipment:Electricity without a space.' unless object.space.is_initialized

          zone_name = object.space.get.thermalZone.get.name.to_s.upcase
          return { [FT::Elec, end_use] => ["#{subcategory}:InteriorEquipment:Electricity:Zone:#{zone_name}"] }
        end

      elsif object.to_OtherEquipment.is_initialized
        object = object.to_OtherEquipment.get
        subcategory = object.endUseSubcategory
        fuel = object.fuelType
        end_use = nil
        { Constants::ObjectTypeClothesDryer => EUT::ClothesDryer,
          Constants::ObjectTypeCookingRange => EUT::RangeOven,
          Constants::ObjectTypeMiscGrill => EUT::Grill,
          Constants::ObjectTypeMiscLighting => EUT::Lighting,
          Constants::ObjectTypeMiscFireplace => EUT::Fireplace,
          Constants::ObjectTypeMiscPoolHeater => EUT::PoolHeater,
          Constants::ObjectTypeMiscPermanentSpaHeater => EUT::PermanentSpaHeater,
          Constants::ObjectTypeMechanicalVentilationPreheating => EUT::MechVentPreheat,
          Constants::ObjectTypeMechanicalVentilationPrecooling => EUT::MechVentPrecool,
          Constants::ObjectTypeHPDefrostSupplHeat => EUT::HeatingHeatPumpBackup,
          Constants::ObjectTypeCrankcaseHeater => [EUT::Heating, EUT::Cooling],
          Constants::ObjectTypePanHeater => EUT::Heating,
          Constants::ObjectTypeWaterHeaterAdjustment => EUT::HotWater,
          Constants::ObjectTypeDSEHeating => EUT::Heating,
          Constants::ObjectTypeDSEHeatingHeatPumpBackup => EUT::HeatingHeatPumpBackup,
          Constants::ObjectTypeDSEHeatingFanPump => EUT::HeatingFanPump,
          Constants::ObjectTypeDSEHeatingHeatPumpBackupFanPump => EUT::HeatingHeatPumpBackupFanPump,
          Constants::ObjectTypeDSECooling => EUT::Cooling,
          Constants::ObjectTypeDSECoolingFanPump => EUT::CoolingFanPump,
          Constants::ObjectTypeBatteryLossesAdjustment => EUT::Battery }.each do |obj_name, eut|
          next unless subcategory.start_with? obj_name
          fail "Unexpected error: multiple matches for #{eut}." unless end_use.nil?

          if obj_name == Constants::ObjectTypeCrankcaseHeater
            if object.additionalProperties.getFeatureAsDouble('FractionHeatLoadServed').get <= 0
              # Allocate crankcase to cooling end use (cooling system or HP only provides cooling)
              eut = eut[1]
            else
              eut = eut[0]
            end
          end

          end_use = eut
        end

        if not end_use.nil?
          # Use Output:Meter instead of Output:Variable because they incorporate thermal zone multipliers
          fail "Unexpected error: InteriorEquipment:#{fuel} without a space." unless object.space.is_initialized

          zone_name = object.space.get.thermalZone.get.name.to_s.upcase
          return { [to_ft[fuel], end_use] => ["#{subcategory}:InteriorEquipment:#{fuel}:Zone:#{zone_name}"] }
        end

      elsif object.to_ZoneHVACDehumidifierDX.is_initialized
        return { [FT::Elec, EUT::Dehumidifier] => ['Zone Dehumidifier Electricity Energy'] }

      elsif object.to_EnergyManagementSystemOutputVariable.is_initialized
        if object_type == Constants::ObjectTypeFanPumpDisaggregatePrimaryHeat
          return { [FT::Elec, EUT::HeatingFanPump] => [object.name.to_s] }
        elsif object_type == Constants::ObjectTypeFanPumpDisaggregateBackupHeat
          return { [FT::Elec, EUT::HeatingHeatPumpBackupFanPump] => [object.name.to_s] }
        elsif object_type == Constants::ObjectTypeFanPumpDisaggregateCool
          return { [FT::Elec, EUT::CoolingFanPump] => [object.name.to_s] }
        else
          return { ems: [object.name.to_s] }
        end

      end

    elsif class_type == HWT

      # Hot Water Use

      if object.to_WaterUseEquipment.is_initialized
        hot_water_use = { Constants::ObjectTypeFixtures => HWT::Fixtures,
                          Constants::ObjectTypeDistributionWaste => HWT::DistributionWaste,
                          Constants::ObjectTypeClothesWasher => HWT::ClothesWasher,
                          Constants::ObjectTypeDishwasher => HWT::Dishwasher }[object.to_WaterUseEquipment.get.waterUseEquipmentDefinition.endUseSubcategory]
        return { hot_water_use => ['Water Use Equipment Hot Water Volume'] }

      end

    elsif class_type == LT

      # Load

      if object.to_WaterHeaterMixed.is_initialized || object.to_WaterHeaterStratified.is_initialized
        if object.to_WaterHeaterMixed.is_initialized
          capacity = object.to_WaterHeaterMixed.get.heaterMaximumCapacity.get
          object_type = object.to_WaterHeaterMixed.get.additionalProperties.getFeatureAsString('ObjectType')
        else
          capacity = object.to_WaterHeaterStratified.get.heater1Capacity.get
          object_type = object.to_WaterHeaterStratified.get.additionalProperties.getFeatureAsString('ObjectType')
        end
        object_type = object_type.get if object_type.is_initialized
        is_combi_boiler = false
        if object.additionalProperties.getFeatureAsBoolean('IsCombiBoiler').is_initialized
          is_combi_boiler = object.additionalProperties.getFeatureAsBoolean('IsCombiBoiler').get
        end
        if capacity == 0 && object_type == Constants::ObjectTypeSolarHotWater
          return { LT::HotWaterSolarThermal => ['Water Heater Use Side Heat Transfer Energy'] }
        elsif capacity > 0 || is_combi_boiler # Active water heater only (e.g., exclude desuperheater and solar thermal storage tanks)
          return { LT::HotWaterTankLosses => ['Water Heater Heat Loss Energy'] }
        end

      elsif object.to_WaterUseConnections.is_initialized
        return { LT::HotWaterDelivered => ['Water Use Connections Plant Hot Water Energy'] }

      elsif object.to_CoilWaterHeatingDesuperheater.is_initialized
        return { LT::HotWaterDesuperheater => ['Water Heater Heating Energy'] }

      elsif object.to_CoilHeatingGas.is_initialized || object.to_CoilHeatingElectric.is_initialized
        if object.additionalProperties.getFeatureAsBoolean('IsHeatPumpBackup').is_initialized && object.additionalProperties.getFeatureAsBoolean('IsHeatPumpBackup').get
          return { LT::HeatingHeatPumpBackup => ['Heating Coil Heating Energy'] }
        end

      elsif object.to_ZoneHVACBaseboardConvectiveElectric.is_initialized || object.to_ZoneHVACBaseboardConvectiveWater.is_initialized
        if object.additionalProperties.getFeatureAsBoolean('IsHeatPumpBackup').is_initialized && object.additionalProperties.getFeatureAsBoolean('IsHeatPumpBackup').get
          return { LT::HeatingHeatPumpBackup => ['Baseboard Total Heating Energy'] }
        end

      elsif object.to_EnergyManagementSystemOutputVariable.is_initialized
        object_type = object.to_EnergyManagementSystemOutputVariable.get.additionalProperties.getFeatureAsString('ObjectType')
        object_type = object_type.get if object_type.is_initialized
        if object_type == Constants::ObjectTypeFanPumpDisaggregateBackupHeat
          # Fan/pump energy is contributing to the load
          return { LT::HeatingHeatPumpBackup => [object.name.to_s] }
        end

      end

    elsif class_type == RT

      # Resilience

      if object.to_ElectricLoadCenterStorageLiIonNMCBattery.is_initialized
        if object.additionalProperties.getFeatureAsString('ObjectType').to_s == Constants::ObjectTypeBattery
          return { RT::Battery => ['Electric Storage Charge Fraction'] }
        end

      end
    end

    return {}
  end
end