urbanopt-cli 0.6.4 → 0.7.0

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

@@ -7,6 +7,7 @@ require 'pathname'
 require 'csv'
 require 'oga'
 require_relative 'resources/airflow'
+require_relative 'resources/battery'
 require_relative 'resources/constants'
 require_relative 'resources/constructions'
 require_relative 'resources/energyplus'
@@ -32,8 +33,6 @@ require_relative 'resources/version'
 require_relative 'resources/waterheater'
 require_relative 'resources/weather'
 require_relative 'resources/xmlhelper'
-require_relative '../BuildResidentialHPXML/resources/constants'
-require_relative '../BuildResidentialHPXML/resources/schedules'
 
 # start the measure
 class HPXMLtoOpenStudio < OpenStudio::Measure::ModelMeasure
@@ -223,8 +222,9 @@ class OSModel
     add_simulation_params(model)
 
     @schedules_file = nil
-    unless @hpxml.header.schedules_path.nil?
-      @schedules_file = SchedulesFile.new(runner: runner, model: model, schedules_path: @hpxml.header.schedules_path, col_names: ScheduleGenerator.col_names.keys)
+    unless @hpxml.header.schedules_filepath.nil?
+      @schedules_file = SchedulesFile.new(runner: runner, model: model, year: hpxml.header.sim_calendar_year,
+                                          schedules_path: @hpxml.header.schedules_filepath)
     end
 
     # Conditioned space/zone
@@ -232,6 +232,7 @@ class OSModel
     spaces = {}
     create_or_get_space(model, spaces, HPXML::LocationLivingSpace)
     set_foundation_and_walls_top()
+    set_heating_and_cooling_seasons()
     add_setpoints(runner, model, weather, spaces)
 
     # Geometry/Envelope
@@ -246,19 +247,19 @@ class OSModel
     add_skylights(runner, model, spaces, weather)
     add_conditioned_floor_area(runner, model, spaces)
     add_thermal_mass(runner, model, spaces)
-    update_conditioned_basement(runner, model, spaces)
+    update_conditioned_below_grade_spaces(runner, model, spaces)
     Geometry.set_zone_volumes(runner, model, spaces, @hpxml, @apply_ashrae140_assumptions)
     Geometry.explode_surfaces(runner, model, @hpxml, @walls_top)
     add_num_occupants(model, runner, spaces)
 
     # HVAC
 
+    airloop_map = {} # Map of HPXML System ID -> AirLoopHVAC (or ZoneHVACFourPipeFanCoil)
     add_ideal_system(runner, model, spaces, epw_path)
-    add_cooling_system(runner, model, spaces)
-    add_heating_system(runner, model, spaces)
-    add_heat_pump(runner, model, weather, spaces)
+    add_cooling_system(runner, model, spaces, airloop_map)
+    add_heating_system(runner, model, spaces, airloop_map)
+    add_heat_pump(runner, model, weather, spaces, airloop_map)
     add_dehumidifiers(runner, model, spaces)
-    add_residual_ideal_system(runner, model, spaces)
     add_ceiling_fans(runner, model, weather, spaces)
 
     # Hot Water
@@ -276,9 +277,10 @@ class OSModel
 
     # Other
 
-    add_airflow(runner, model, weather, spaces)
+    add_airflow(runner, model, weather, spaces, airloop_map)
     add_photovoltaics(runner, model)
     add_generators(runner, model)
+    add_batteries(runner, model, spaces)
     add_additional_properties(runner, model, hpxml_path, building_id)
 
     # Output
@@ -288,11 +290,6 @@ class OSModel
     # Uncomment to debug EMS
     # add_ems_debug_output(runner, model)
 
-    # Vacancy
-    unless @schedules_file.nil?
-      @schedules_file.set_vacancy
-    end
-
     if debug
       osm_output_path = File.join(output_dir, 'in.osm')
       File.write(osm_output_path, model.to_s)
@@ -306,16 +303,16 @@ class OSModel
     # Initialize
     @remaining_heat_load_frac = 1.0
     @remaining_cool_load_frac = 1.0
-    @hvac_map = {} # mapping between HPXML HVAC systems and model objects
-    @dhw_map = {}  # mapping between HPXML Water Heating systems and model objects
-    @cond_bsmnt_surfaces = [] # list of surfaces in conditioned basement, used for modification of some surface properties, eg. solar absorptance, view factor, etc.
+    @cond_below_grade_surfaces = [] # list of surfaces in conditioned basement, used for modification of some surface properties, eg. solar absorptance, view factor, etc.
 
     # Set globals
     @cfa = @hpxml.building_construction.conditioned_floor_area
+    @gfa = @hpxml.slabs.select { |s| s.interior_adjacent_to == HPXML::LocationGarage }.map { |s| s.area }.sum(0.0)
+    @ubfa = @hpxml.slabs.select { |s| s.interior_adjacent_to == HPXML::LocationBasementUnconditioned }.map { |s| s.area }.sum(0.0)
     @ncfl = @hpxml.building_construction.number_of_conditioned_floors
     @ncfl_ag = @hpxml.building_construction.number_of_conditioned_floors_above_grade
     @nbeds = @hpxml.building_construction.number_of_bedrooms
-    @default_azimuths = get_default_azimuths()
+    @default_azimuths = HPXMLDefaults.get_default_azimuths(@hpxml)
 
     # Apply defaults to HPXML object
     HPXMLDefaults.apply(@hpxml, @eri_version, weather, epw_file: epw_file)
@@ -323,8 +320,8 @@ class OSModel
     @frac_windows_operable = @hpxml.fraction_of_windows_operable()
 
     # Write updated HPXML object (w/ defaults) to file for inspection
-    hpxml_defaults_path = File.join(output_dir, 'in.xml')
-    XMLHelper.write_file(@hpxml.to_oga, hpxml_defaults_path)
+    @hpxml_defaults_path = File.join(output_dir, 'in.xml')
+    XMLHelper.write_file(@hpxml.to_oga, @hpxml_defaults_path)
 
     # Now that we've written in.xml, ensure that no capacities/airflows
     # are zero in order to prevent potential E+ errors.
@@ -335,20 +332,20 @@ class OSModel
     SimControls.apply(model, @hpxml)
   end
 
-  def self.update_conditioned_basement(runner, model, spaces)
-    return if @cond_bsmnt_surfaces.empty?
+  def self.update_conditioned_below_grade_spaces(runner, model, spaces)
+    return if @cond_below_grade_surfaces.empty?
 
-    # Update @cond_bsmnt_surfaces to include subsurfaces
-    new_cond_bsmnt_surfaces = @cond_bsmnt_surfaces.dup
-    @cond_bsmnt_surfaces.each do |cond_bsmnt_surface|
+    # Update @cond_below_grade_surfaces to include subsurfaces
+    new_cond_below_grade_surfaces = @cond_below_grade_surfaces.dup
+    @cond_below_grade_surfaces.each do |cond_bsmnt_surface|
       next if cond_bsmnt_surface.is_a? OpenStudio::Model::InternalMassDefinition
       next if cond_bsmnt_surface.subSurfaces.empty?
 
       cond_bsmnt_surface.subSurfaces.each do |ss|
-        new_cond_bsmnt_surfaces << ss
+        new_cond_below_grade_surfaces << ss
       end
     end
-    @cond_bsmnt_surfaces = new_cond_bsmnt_surfaces.dup
+    @cond_below_grade_surfaces = new_cond_below_grade_surfaces.dup
 
     update_solar_absorptances(runner, model)
     assign_view_factors(runner, model, spaces)
@@ -358,7 +355,7 @@ class OSModel
     # modify conditioned basement surface properties
     # zero out interior solar absorptance in conditioned basement
 
-    @cond_bsmnt_surfaces.each do |cond_bsmnt_surface|
+    @cond_below_grade_surfaces.each do |cond_bsmnt_surface|
       # skip windows because windows don't have such property to change.
       next if cond_bsmnt_surface.is_a?(OpenStudio::Model::SubSurface) && (cond_bsmnt_surface.subSurfaceType.downcase == 'fixedwindow')
 
@@ -401,11 +398,12 @@ class OSModel
       innermost_material.setVisibleAbsorptance(0.0)
       next if adj_surface.nil?
 
-      # Create new construction in case of shared construciton.
+      # Create new construction in case of shared construction.
       layered_const_adj = OpenStudio::Model::Construction.new(model)
       layered_const_adj.setName(cond_bsmnt_surface.construction.get.name.get + ' Reversed Bsmnt')
-      adj_surface.setConstruction(layered_const_adj)
       layered_const_adj.setLayers(cond_bsmnt_surface.construction.get.to_LayeredConstruction.get.layers.reverse())
+      adj_surface.construction.get.remove if adj_surface.construction.get.directUseCount == 1
+      adj_surface.setConstruction(layered_const_adj)
     end
   end
 
@@ -426,8 +424,8 @@ class OSModel
     end
 
     all_surfaces.each do |surface|
-      if @cond_bsmnt_surfaces.include?(surface) ||
-         ((@cond_bsmnt_surfaces.include? surface.internalMassDefinition) if surface.is_a? OpenStudio::Model::InternalMass)
+      if @cond_below_grade_surfaces.include?(surface) ||
+         ((@cond_below_grade_surfaces.include? surface.internalMassDefinition) if surface.is_a? OpenStudio::Model::InternalMass)
         cond_base_surfaces << surface
       else
         lv_surfaces << surface
@@ -547,50 +545,14 @@ class OSModel
     num_occ = @hpxml.building_occupancy.number_of_residents
     return if num_occ <= 0
 
-    Geometry.apply_occupants(model, num_occ, @cfa, spaces[HPXML::LocationLivingSpace], @schedules_file)
+    Geometry.apply_occupants(model, @hpxml, num_occ, @cfa, spaces[HPXML::LocationLivingSpace], @schedules_file)
   end
 
-  def self.get_default_azimuths()
-    def self.sanitize_azimuth(azimuth)
-      # Ensure 0 <= orientation < 360
-      while azimuth < 0
-        azimuth += 360
-      end
-      while azimuth >= 360
-        azimuth -= 360
-      end
-      return azimuth
+  def self.create_or_get_space(model, spaces, location)
+    if spaces[location].nil?
+      Geometry.create_space_and_zone(model, spaces, location)
     end
-
-    # Returns a list of four azimuths (facing each direction). Determined based
-    # on the primary azimuth, as defined by the azimuth with the largest surface
-    # area, plus azimuths that are offset by 90/180/270 degrees. Used for
-    # surfaces that may not have an azimuth defined (e.g., walls).
-    azimuth_areas = {}
-    (@hpxml.roofs + @hpxml.rim_joists + @hpxml.walls + @hpxml.foundation_walls +
-     @hpxml.windows + @hpxml.skylights + @hpxml.doors).each do |surface|
-      az = surface.azimuth
-      next if az.nil?
-
-      azimuth_areas[az] = 0 if azimuth_areas[az].nil?
-      azimuth_areas[az] += surface.area
-    end
-    if azimuth_areas.empty?
-      primary_azimuth = 0
-    else
-      primary_azimuth = azimuth_areas.max_by { |k, v| v }[0]
-    end
-    return [primary_azimuth,
-            sanitize_azimuth(primary_azimuth + 90),
-            sanitize_azimuth(primary_azimuth + 180),
-            sanitize_azimuth(primary_azimuth + 270)].sort
-  end
-
-  def self.create_or_get_space(model, spaces, spacetype)
-    if spaces[spacetype].nil?
-      Geometry.create_space_and_zone(model, spaces, spacetype)
-    end
-    return spaces[spacetype]
+    return spaces[location]
   end
 
   def self.add_roofs(runner, model, spaces)
@@ -636,8 +598,6 @@ class OSModel
       next if surfaces.empty?
 
       # Apply construction
-      solar_abs = roof.solar_absorptance
-      emitt = roof.emittance
       has_radiant_barrier = roof.radiant_barrier
       if has_radiant_barrier
         radiant_barrier_grade = roof.radiant_barrier_grade
@@ -645,23 +605,30 @@ class OSModel
       # FUTURE: Create Constructions.get_air_film(surface) method; use in measure.rb and hpxml_translator_test.rb
       inside_film = Material.AirFilmRoof(Geometry.get_roof_pitch([surfaces[0]]))
       outside_film = Material.AirFilmOutside
-      mat_roofing = Material.RoofMaterial(roof.roof_type, emitt, solar_abs)
+      mat_roofing = Material.RoofMaterial(roof.roof_type)
       if @apply_ashrae140_assumptions
         inside_film = Material.AirFilmRoofASHRAE140
         outside_film = Material.AirFilmOutsideASHRAE140
       end
+      mat_int_finish = Material.InteriorFinishMaterial(roof.interior_finish_type, roof.interior_finish_thickness)
+      if mat_int_finish.nil?
+        fallback_mat_int_finish = nil
+      else
+        fallback_mat_int_finish = Material.InteriorFinishMaterial(mat_int_finish.name, 0.1) # Try thin material
+      end
 
       install_grade = 1
       assembly_r = roof.insulation_assembly_r_value
 
-      if roof.is_thermal_boundary
+      if not mat_int_finish.nil?
+        # Closed cavity
         constr_sets = [
-          WoodStudConstructionSet.new(Material.Stud2x(8.0), 0.07, 20.0, 0.75, 0.5, mat_roofing), # 2x8, 24" o.c. + R20
-          WoodStudConstructionSet.new(Material.Stud2x(8.0), 0.07, 10.0, 0.75, 0.5, mat_roofing), # 2x8, 24" o.c. + R10
-          WoodStudConstructionSet.new(Material.Stud2x(8.0), 0.07, 0.0, 0.75, 0.5, mat_roofing),  # 2x8, 24" o.c.
-          WoodStudConstructionSet.new(Material.Stud2x6, 0.07, 0.0, 0.75, 0.5, mat_roofing),      # 2x6, 24" o.c.
-          WoodStudConstructionSet.new(Material.Stud2x4, 0.07, 0.0, 0.5, 0.5, mat_roofing),       # 2x4, 16" o.c.
-          WoodStudConstructionSet.new(Material.Stud2x4, 0.01, 0.0, 0.0, 0.0, mat_roofing),       # Fallback
+          WoodStudConstructionSet.new(Material.Stud2x(8.0), 0.07, 20.0, 0.75, mat_int_finish, mat_roofing),    # 2x8, 24" o.c. + R20
+          WoodStudConstructionSet.new(Material.Stud2x(8.0), 0.07, 10.0, 0.75, mat_int_finish, mat_roofing),    # 2x8, 24" o.c. + R10
+          WoodStudConstructionSet.new(Material.Stud2x(8.0), 0.07, 0.0, 0.75, mat_int_finish, mat_roofing),     # 2x8, 24" o.c.
+          WoodStudConstructionSet.new(Material.Stud2x6, 0.07, 0.0, 0.75, mat_int_finish, mat_roofing),         # 2x6, 24" o.c.
+          WoodStudConstructionSet.new(Material.Stud2x4, 0.07, 0.0, 0.5, mat_int_finish, mat_roofing),          # 2x4, 16" o.c.
+          WoodStudConstructionSet.new(Material.Stud2x4, 0.01, 0.0, 0.0, fallback_mat_int_finish, mat_roofing), # Fallback
         ]
         match, constr_set, cavity_r = Constructions.pick_wood_stud_construction_set(assembly_r, constr_sets, inside_film, outside_film, roof.id)
 
@@ -669,15 +636,17 @@ class OSModel
                                                cavity_r, install_grade,
                                                constr_set.stud.thick_in,
                                                true, constr_set.framing_factor,
-                                               constr_set.drywall_thick_in,
+                                               constr_set.mat_int_finish,
                                                constr_set.osb_thick_in, constr_set.rigid_r,
-                                               constr_set.exterior_material, has_radiant_barrier,
-                                               inside_film, outside_film, radiant_barrier_grade)
+                                               constr_set.mat_ext_finish, has_radiant_barrier,
+                                               inside_film, outside_film, radiant_barrier_grade,
+                                               roof.solar_absorptance, roof.emittance)
       else
+        # Open cavity
         constr_sets = [
-          GenericConstructionSet.new(10.0, 0.5, 0.0, mat_roofing), # w/R-10 rigid
-          GenericConstructionSet.new(0.0, 0.5, 0.0, mat_roofing),  # Standard
-          GenericConstructionSet.new(0.0, 0.0, 0.0, mat_roofing),  # Fallback
+          GenericConstructionSet.new(10.0, 0.5, nil, mat_roofing), # w/R-10 rigid
+          GenericConstructionSet.new(0.0, 0.5, nil, mat_roofing),  # Standard
+          GenericConstructionSet.new(0.0, 0.0, nil, mat_roofing),  # Fallback
         ]
         match, constr_set, layer_r = Constructions.pick_generic_construction_set(assembly_r, constr_sets, inside_film, outside_film, roof.id)
 
@@ -690,8 +659,9 @@ class OSModel
                                              cavity_r, install_grade, cavity_ins_thick_in,
                                              framing_factor, framing_thick_in,
                                              constr_set.osb_thick_in, layer_r + constr_set.rigid_r,
-                                             mat_roofing, has_radiant_barrier,
-                                             inside_film, outside_film, radiant_barrier_grade)
+                                             constr_set.mat_ext_finish, has_radiant_barrier,
+                                             inside_film, outside_film, radiant_barrier_grade,
+                                             roof.solar_absorptance, roof.emittance)
       end
       Constructions.check_surface_assembly_rvalue(runner, surfaces, inside_film, outside_film, assembly_r, match)
     end
@@ -745,15 +715,10 @@ class OSModel
       # The code below constructs a reasonable wall construction based on the
       # wall type while ensuring the correct assembly R-value.
 
-      if wall.is_thermal_boundary
-        drywall_thick_in = 0.5
-      else
-        drywall_thick_in = 0.0
-      end
       inside_film = Material.AirFilmVertical
       if wall.is_exterior
         outside_film = Material.AirFilmOutside
-        mat_ext_finish = Material.ExteriorFinishMaterial(wall.siding, wall.emittance, wall.solar_absorptance)
+        mat_ext_finish = Material.ExteriorFinishMaterial(wall.siding)
       else
         outside_film = Material.AirFilmVertical
         mat_ext_finish = nil
@@ -762,9 +727,11 @@ class OSModel
         inside_film = Material.AirFilmVerticalASHRAE140
         outside_film = Material.AirFilmOutsideASHRAE140
       end
+      mat_int_finish = Material.InteriorFinishMaterial(wall.interior_finish_type, wall.interior_finish_thickness)
 
-      Constructions.apply_wall_construction(runner, model, surfaces, wall, wall.id, wall.wall_type, wall.insulation_assembly_r_value,
-                                            drywall_thick_in, inside_film, outside_film, mat_ext_finish)
+      Constructions.apply_wall_construction(runner, model, surfaces, wall.id, wall.wall_type, wall.insulation_assembly_r_value,
+                                            mat_int_finish, inside_film, outside_film, mat_ext_finish, wall.solar_absorptance,
+                                            wall.emittance)
     end
   end
 
@@ -810,15 +777,10 @@ class OSModel
 
       # Apply construction
 
-      if rim_joist.is_thermal_boundary
-        drywall_thick_in = 0.5
-      else
-        drywall_thick_in = 0.0
-      end
       inside_film = Material.AirFilmVertical
       if rim_joist.is_exterior
         outside_film = Material.AirFilmOutside
-        mat_ext_finish = Material.ExteriorFinishMaterial(rim_joist.siding, rim_joist.emittance, rim_joist.solar_absorptance)
+        mat_ext_finish = Material.ExteriorFinishMaterial(rim_joist.siding)
       else
         outside_film = Material.AirFilmVertical
         mat_ext_finish = nil
@@ -827,19 +789,20 @@ class OSModel
       assembly_r = rim_joist.insulation_assembly_r_value
 
       constr_sets = [
-        WoodStudConstructionSet.new(Material.Stud2x(2.0), 0.17, 20.0, 2.0, drywall_thick_in, mat_ext_finish),  # 2x4 + R20
-        WoodStudConstructionSet.new(Material.Stud2x(2.0), 0.17, 10.0, 2.0, drywall_thick_in, mat_ext_finish),  # 2x4 + R10
-        WoodStudConstructionSet.new(Material.Stud2x(2.0), 0.17, 0.0, 2.0, drywall_thick_in, mat_ext_finish),   # 2x4
-        WoodStudConstructionSet.new(Material.Stud2x(2.0), 0.01, 0.0, 0.0, 0.0, mat_ext_finish),                # Fallback
+        WoodStudConstructionSet.new(Material.Stud2x(2.0), 0.17, 20.0, 2.0, nil, mat_ext_finish),  # 2x4 + R20
+        WoodStudConstructionSet.new(Material.Stud2x(2.0), 0.17, 10.0, 2.0, nil, mat_ext_finish),  # 2x4 + R10
+        WoodStudConstructionSet.new(Material.Stud2x(2.0), 0.17, 0.0, 2.0, nil, mat_ext_finish),   # 2x4
+        WoodStudConstructionSet.new(Material.Stud2x(2.0), 0.01, 0.0, 0.0, nil, mat_ext_finish),   # Fallback
       ]
       match, constr_set, cavity_r = Constructions.pick_wood_stud_construction_set(assembly_r, constr_sets, inside_film, outside_film, rim_joist.id)
       install_grade = 1
 
-      Constructions.apply_rim_joist(runner, model, surfaces, rim_joist, "#{rim_joist.id} construction",
+      Constructions.apply_rim_joist(runner, model, surfaces, "#{rim_joist.id} construction",
                                     cavity_r, install_grade, constr_set.framing_factor,
-                                    constr_set.drywall_thick_in, constr_set.osb_thick_in,
-                                    constr_set.rigid_r, constr_set.exterior_material,
-                                    inside_film, outside_film)
+                                    constr_set.mat_int_finish, constr_set.osb_thick_in,
+                                    constr_set.rigid_r, constr_set.mat_ext_finish,
+                                    inside_film, outside_film, rim_joist.solar_absorptance,
+                                    rim_joist.emittance)
       Constructions.check_surface_assembly_rvalue(runner, surfaces, inside_film, outside_film, assembly_r, match)
     end
   end
@@ -886,10 +849,20 @@ class OSModel
           inside_film = Material.AirFilmFloorAverage
           outside_film = Material.AirFilmFloorAverage
         end
+        mat_int_finish = Material.InteriorFinishMaterial(frame_floor.interior_finish_type, frame_floor.interior_finish_thickness)
+        if mat_int_finish.nil?
+          fallback_mat_int_finish = nil
+        else
+          fallback_mat_int_finish = Material.InteriorFinishMaterial(mat_int_finish.name, 0.1) # Try thin material
+        end
         constr_sets = [
-          WoodStudConstructionSet.new(Material.Stud2x6, 0.10, 0.0, 0.0, 0.5, nil),  # 2x6, 24" o.c.
-          WoodStudConstructionSet.new(Material.Stud2x4, 0.13, 0.0, 0.0, 0.5, nil),  # 2x4, 16" o.c.
-          WoodStudConstructionSet.new(Material.Stud2x4, 0.01, 0.0, 0.0, 0.0, nil), # Fallback
+          WoodStudConstructionSet.new(Material.Stud2x6, 0.10, 50.0, 0.0, mat_int_finish, nil),         # 2x6, 24" o.c. + R50
+          WoodStudConstructionSet.new(Material.Stud2x6, 0.10, 40.0, 0.0, mat_int_finish, nil),         # 2x6, 24" o.c. + R40
+          WoodStudConstructionSet.new(Material.Stud2x6, 0.10, 30.0, 0.0, mat_int_finish, nil),         # 2x6, 24" o.c. + R30
+          WoodStudConstructionSet.new(Material.Stud2x6, 0.10, 20.0, 0.0, mat_int_finish, nil),         # 2x6, 24" o.c. + R20
+          WoodStudConstructionSet.new(Material.Stud2x6, 0.10, 10.0, 0.0, mat_int_finish, nil),         # 2x6, 24" o.c. + R10
+          WoodStudConstructionSet.new(Material.Stud2x4, 0.13, 0.0, 0.0, mat_int_finish, nil),          # 2x4, 16" o.c.
+          WoodStudConstructionSet.new(Material.Stud2x4, 0.01, 0.0, 0.0, fallback_mat_int_finish, nil), # Fallback
         ]
       else # Floor
         if @apply_ashrae140_assumptions
@@ -909,12 +882,17 @@ class OSModel
             covering = Material.CoveringBare
           end
         end
+        if covering.nil?
+          fallback_covering = nil
+        else
+          fallback_covering = Material.CoveringBare(0.8, 0.01) # Try thin material
+        end
         constr_sets = [
-          WoodStudConstructionSet.new(Material.Stud2x6, 0.10, 20.0, 0.75, 0.0, covering), # 2x6, 24" o.c. + R20
-          WoodStudConstructionSet.new(Material.Stud2x6, 0.10, 10.0, 0.75, 0.0, covering), # 2x6, 24" o.c. + R10
-          WoodStudConstructionSet.new(Material.Stud2x6, 0.10, 0.0, 0.75, 0.0, covering),  # 2x6, 24" o.c.
-          WoodStudConstructionSet.new(Material.Stud2x4, 0.13, 0.0, 0.5, 0.0, covering),   # 2x4, 16" o.c.
-          WoodStudConstructionSet.new(Material.Stud2x4, 0.01, 0.0, 0.0, 0.0, nil), # Fallback
+          WoodStudConstructionSet.new(Material.Stud2x6, 0.10, 20.0, 0.75, nil, covering),        # 2x6, 24" o.c. + R20
+          WoodStudConstructionSet.new(Material.Stud2x6, 0.10, 10.0, 0.75, nil, covering),        # 2x6, 24" o.c. + R10
+          WoodStudConstructionSet.new(Material.Stud2x6, 0.10, 0.0, 0.75, nil, covering),         # 2x6, 24" o.c.
+          WoodStudConstructionSet.new(Material.Stud2x4, 0.13, 0.0, 0.5, nil, covering),          # 2x4, 16" o.c.
+          WoodStudConstructionSet.new(Material.Stud2x4, 0.01, 0.0, 0.0, nil, fallback_covering), # Fallback
         ]
       end
       assembly_r = frame_floor.insulation_assembly_r_value
@@ -923,10 +901,11 @@ class OSModel
 
       install_grade = 1
       if frame_floor.is_ceiling
+
         Constructions.apply_ceiling(runner, model, [surface], "#{frame_floor.id} construction",
                                     cavity_r, install_grade,
-                                    constr_set.stud.thick_in, constr_set.framing_factor,
-                                    constr_set.stud.thick_in, constr_set.drywall_thick_in,
+                                    constr_set.rigid_r, constr_set.framing_factor,
+                                    constr_set.stud.thick_in, constr_set.mat_int_finish,
                                     inside_film, outside_film)
 
       else # Floor
@@ -934,7 +913,7 @@ class OSModel
                                   cavity_r, install_grade,
                                   constr_set.framing_factor, constr_set.stud.thick_in,
                                   constr_set.osb_thick_in, constr_set.rigid_r,
-                                  constr_set.exterior_material, inside_film, outside_film)
+                                  constr_set.mat_ext_finish, inside_film, outside_film)
       end
 
       Constructions.check_surface_assembly_rvalue(runner, [surface], inside_film, outside_film, assembly_r, match)
@@ -1069,24 +1048,22 @@ class OSModel
         # Apply construction
 
         wall_type = HPXML::WallTypeConcrete
-        if foundation_wall.is_thermal_boundary
-          drywall_thick_in = 0.5
-        else
-          drywall_thick_in = 0.0
-        end
         inside_film = Material.AirFilmVertical
         outside_film = Material.AirFilmVertical
         assembly_r = foundation_wall.insulation_assembly_r_value
+        mat_int_finish = Material.InteriorFinishMaterial(foundation_wall.interior_finish_type, foundation_wall.interior_finish_thickness)
         if assembly_r.nil?
           concrete_thick_in = foundation_wall.thickness
           int_r = foundation_wall.insulation_interior_r_value
           ext_r = foundation_wall.insulation_exterior_r_value
-          assembly_r = int_r + ext_r + Material.Concrete(concrete_thick_in).rvalue + Material.GypsumWall(drywall_thick_in).rvalue + inside_film.rvalue + outside_film.rvalue
+          mat_concrete = Material.Concrete(concrete_thick_in)
+          mat_int_finish_rvalue = mat_int_finish.nil? ? 0.0 : mat_int_finish.rvalue
+          assembly_r = int_r + ext_r + mat_concrete.rvalue + mat_int_finish_rvalue + inside_film.rvalue + outside_film.rvalue
         end
         mat_ext_finish = nil
 
-        Constructions.apply_wall_construction(runner, model, [surface], foundation_wall, foundation_wall.id, wall_type, assembly_r,
-                                              drywall_thick_in, inside_film, outside_film, mat_ext_finish)
+        Constructions.apply_wall_construction(runner, model, [surface], foundation_wall.id, wall_type, assembly_r,
+                                              mat_int_finish, inside_film, outside_film, mat_ext_finish, nil, nil)
       end
     end
   end
@@ -1130,22 +1107,20 @@ class OSModel
     set_surface_interior(model, spaces, surface, foundation_wall)
     set_surface_exterior(model, spaces, surface, foundation_wall)
 
-    if foundation_wall.is_thermal_boundary
-      drywall_thick_in = 0.5
-    else
-      drywall_thick_in = 0.0
-    end
-    concrete_thick_in = foundation_wall.thickness
     assembly_r = foundation_wall.insulation_assembly_r_value
+    mat_int_finish = Material.InteriorFinishMaterial(foundation_wall.interior_finish_type, foundation_wall.interior_finish_thickness)
+    mat_wall = Material.FoundationWallMaterial(foundation_wall.type, foundation_wall.thickness)
     if not assembly_r.nil?
       ext_rigid_height = height
       ext_rigid_offset = 0.0
       inside_film = Material.AirFilmVertical
-      ext_rigid_r = assembly_r - Material.Concrete(concrete_thick_in).rvalue - Material.GypsumWall(drywall_thick_in).rvalue - inside_film.rvalue
+
+      mat_int_finish_rvalue = mat_int_finish.nil? ? 0.0 : mat_int_finish.rvalue
+      ext_rigid_r = assembly_r - mat_wall.rvalue - mat_int_finish_rvalue - inside_film.rvalue
       int_rigid_r = 0.0
-      if ext_rigid_r < 0 # Try without drywall
-        drywall_thick_in = 0.0
-        ext_rigid_r = assembly_r - Material.Concrete(concrete_thick_in).rvalue - Material.GypsumWall(drywall_thick_in).rvalue - inside_film.rvalue
+      if ext_rigid_r < 0 # Try without interior finish
+        mat_int_finish = nil
+        ext_rigid_r = assembly_r - mat_wall.rvalue - inside_film.rvalue
       end
       if (ext_rigid_r > 0) && (ext_rigid_r < 0.1)
         ext_rigid_r = 0.0 # Prevent tiny strip of insulation
@@ -1167,7 +1142,7 @@ class OSModel
 
     Constructions.apply_foundation_wall(runner, model, [surface], "#{foundation_wall.id} construction",
                                         ext_rigid_offset, int_rigid_offset, ext_rigid_height, int_rigid_height,
-                                        ext_rigid_r, int_rigid_r, drywall_thick_in, concrete_thick_in, height_ag)
+                                        ext_rigid_r, int_rigid_r, mat_int_finish, mat_wall, height_ag)
 
     if not assembly_r.nil?
       Constructions.check_surface_assembly_rvalue(runner, [surface], inside_film, nil, assembly_r, match)
@@ -1219,7 +1194,11 @@ class OSModel
       end
       slab_whole_r = 0
     end
-    slab_gap_r = slab_under_r
+    if slab_under_r + slab_whole_r > 0
+      slab_gap_r = 5.0 # Assume gap insulation when insulation under slab is present
+    else
+      slab_gap_r = 0
+    end
 
     mat_carpet = nil
     if (slab.carpet_fraction > 0) && (slab.carpet_r_value > 0)
@@ -1290,9 +1269,9 @@ class OSModel
     ceiling_surface.additionalProperties.setFeature('SurfaceType', 'InferredCeiling')
     ceiling_surface.additionalProperties.setFeature('Tilt', 0.0)
 
-    if not @cond_bsmnt_surfaces.empty?
+    if not @cond_below_grade_surfaces.empty?
       # assuming added ceiling is in conditioned basement
-      @cond_bsmnt_surfaces << ceiling_surface
+      @cond_below_grade_surfaces << ceiling_surface
     end
 
     # Apply Construction
@@ -1301,36 +1280,30 @@ class OSModel
 
   def self.add_thermal_mass(runner, model, spaces)
     cfa_basement = @hpxml.slabs.select { |s| s.interior_adjacent_to == HPXML::LocationBasementConditioned }.map { |s| s.area }.sum(0.0)
+    basement_frac_of_cfa = cfa_basement / @cfa
     if @apply_ashrae140_assumptions
       # 1024 ft2 of interior partition wall mass, no furniture mass
-      drywall_thick_in = 0.5
-      partition_frac_of_cfa = (1024.0 * 2) / @cfa # Ratio of exposed partition wall area (both sides) to conditioned floor area
-      basement_frac_of_cfa = cfa_basement / @cfa
-      Constructions.apply_partition_walls(runner, model, 'PartitionWallConstruction', drywall_thick_in, partition_frac_of_cfa,
-                                          basement_frac_of_cfa, @cond_bsmnt_surfaces, spaces[HPXML::LocationLivingSpace])
+      mat_int_finish = Material.InteriorFinishMaterial(HPXML::InteriorFinishGypsumBoard, 0.5)
+      partition_wall_area = 1024.0 * 2 # Exposed partition wall area (both sides)
+      Constructions.apply_partition_walls(runner, model, 'PartitionWallConstruction', mat_int_finish, partition_wall_area,
+                                          basement_frac_of_cfa, @cond_below_grade_surfaces, spaces[HPXML::LocationLivingSpace])
     else
-      drywall_thick_in = 0.5
-      partition_frac_of_cfa = 1.0 # Ratio of exposed partition wall area (both sides) to conditioned floor area
-      basement_frac_of_cfa = cfa_basement / @cfa
-      Constructions.apply_partition_walls(runner, model, 'PartitionWallConstruction', drywall_thick_in, partition_frac_of_cfa,
-                                          basement_frac_of_cfa, @cond_bsmnt_surfaces, spaces[HPXML::LocationLivingSpace])
+      mat_int_finish = Material.InteriorFinishMaterial(@hpxml.partition_wall_mass.interior_finish_type, @hpxml.partition_wall_mass.interior_finish_thickness)
+      partition_wall_area = @hpxml.partition_wall_mass.area_fraction * @cfa # Exposed partition wall area (both sides)
+      Constructions.apply_partition_walls(runner, model, 'PartitionWallConstruction', mat_int_finish, partition_wall_area,
+                                          basement_frac_of_cfa, @cond_below_grade_surfaces, spaces[HPXML::LocationLivingSpace])
 
-      mass_lb_per_sqft = 8.0
-      density_lb_per_cuft = 40.0
-      mat = BaseMaterial.Wood
-      Constructions.apply_furniture(runner, model, mass_lb_per_sqft, density_lb_per_cuft, mat,
-                                    basement_frac_of_cfa, @cond_bsmnt_surfaces, spaces[HPXML::LocationLivingSpace])
+      Constructions.apply_furniture(runner, model, @hpxml.furniture_mass, @cfa, @ubfa, @gfa,
+                                    basement_frac_of_cfa, @cond_below_grade_surfaces, spaces[HPXML::LocationLivingSpace])
     end
   end
 
-  def self.add_neighbors(runner, model, length)
-  end
-
   def self.add_shading_schedule(runner, model, weather)
-    heating_season, @cooling_season = HVAC.get_default_heating_and_cooling_seasons(weather)
+    # Use BAHSP cooling season, and not year-round or user-specified cooling season, to ensure windows use appropriate interior shading factors
+    default_heating_months, @default_cooling_months = HVAC.get_default_heating_and_cooling_seasons(weather)
 
     # Create cooling season schedule
-    clg_season_sch = MonthWeekdayWeekendSchedule.new(model, 'cooling season schedule', Array.new(24, 1), Array.new(24, 1), @cooling_season, Constants.ScheduleTypeLimitsFraction)
+    clg_season_sch = MonthWeekdayWeekendSchedule.new(model, 'cooling season schedule', Array.new(24, 1), Array.new(24, 1), @default_cooling_months, Constants.ScheduleTypeLimitsFraction)
     @clg_ssn_sensor = OpenStudio::Model::EnergyManagementSystemSensor.new(model, 'Schedule Value')
     @clg_ssn_sensor.setName('cool_season')
     @clg_ssn_sensor.setKeyName(clg_season_sch.schedule.name.to_s)
@@ -1399,7 +1372,7 @@ class OSModel
         # Apply interior/exterior shading (as needed)
         shading_vertices = Geometry.create_wall_vertices(window_length, window_height, z_origin, window.azimuth)
         shading_group = Constructions.apply_window_skylight_shading(model, window, i, shading_vertices, surface, sub_surface, shading_group,
-                                                                    shading_schedules, shading_ems, Constants.ObjectNameWindowShade, @cooling_season)
+                                                                    shading_schedules, shading_ems, Constants.ObjectNameWindowShade, @default_cooling_months)
       else
         # Window is on an interior surface, which E+ does not allow. Model
         # as a door instead so that we can get the appropriate conduction
@@ -1475,7 +1448,7 @@ class OSModel
       # Apply interior/exterior shading (as needed)
       shading_vertices = Geometry.create_roof_vertices(length, width, z_origin, skylight.azimuth, tilt)
       shading_group = Constructions.apply_window_skylight_shading(model, skylight, i, shading_vertices, surface, sub_surface, shading_group,
-                                                                  shading_schedules, shading_ems, Constants.ObjectNameSkylightShade, @cooling_season)
+                                                                  shading_schedules, shading_ems, Constants.ObjectNameSkylightShade, @default_cooling_months)
     end
 
     apply_adiabatic_construction(runner, model, surfaces, 'roof')
@@ -1530,24 +1503,20 @@ class OSModel
     return if surfaces.empty?
 
     if type == 'wall'
-      Constructions.apply_wood_stud_wall(runner, model, surfaces, nil, 'AdiabaticWallConstruction',
-                                         0, 1, 3.5, true, 0.1, 0.5, 0, 99,
-                                         Material.ExteriorFinishMaterial(HPXML::SidingTypeWood, 0.90, 0.75),
-                                         0,
-                                         Material.AirFilmVertical,
-                                         Material.AirFilmVertical)
+      mat_int_finish = Material.InteriorFinishMaterial(HPXML::InteriorFinishGypsumBoard, 0.5)
+      mat_ext_finish = Material.ExteriorFinishMaterial(HPXML::SidingTypeWood)
+      Constructions.apply_wood_stud_wall(runner, model, surfaces, 'AdiabaticWallConstruction',
+                                         0, 1, 3.5, true, 0.1, mat_int_finish, 0, 99, mat_ext_finish,
+                                         Material.AirFilmVertical, Material.AirFilmVertical)
     elsif type == 'floor'
       Constructions.apply_floor(runner, model, surfaces, 'AdiabaticFloorConstruction',
-                                0, 1, 0.07, 5.5, 0.75, 99,
-                                Material.CoveringBare,
-                                Material.AirFilmFloorReduced,
-                                Material.AirFilmFloorReduced)
+                                0, 1, 0.07, 5.5, 0.75, 99, Material.CoveringBare,
+                                Material.AirFilmFloorReduced, Material.AirFilmFloorReduced)
     elsif type == 'roof'
       Constructions.apply_open_cavity_roof(runner, model, surfaces, 'AdiabaticRoofConstruction',
                                            0, 1, 7.25, 0.07, 7.25, 0.75, 99,
-                                           Material.RoofMaterial(HPXML::RoofTypeAsphaltShingles, 0.90, 0.75),
-                                           false,
-                                           Material.AirFilmOutside,
+                                           Material.RoofMaterial(HPXML::RoofTypeAsphaltShingles),
+                                           false, Material.AirFilmOutside,
                                            Material.AirFilmRoof(Geometry.get_roof_pitch(surfaces)), nil)
     end
   end
@@ -1585,55 +1554,42 @@ class OSModel
     end
 
     # Water Heater
-    has_uncond_bsmnt = @hpxml.has_space_type(HPXML::LocationBasementUnconditioned)
+    has_uncond_bsmnt = @hpxml.has_location(HPXML::LocationBasementUnconditioned)
+    plantloop_map = {}
     @hpxml.water_heating_systems.each do |water_heating_system|
       loc_space, loc_schedule = get_space_or_schedule_from_location(water_heating_system.location, 'WaterHeatingSystem', model, spaces)
 
       ec_adj = HotWaterAndAppliances.get_dist_energy_consumption_adjustment(has_uncond_bsmnt, @cfa, @ncfl, water_heating_system, hot_water_distribution)
 
+      sys_id = water_heating_system.id
       if water_heating_system.water_heater_type == HPXML::WaterHeaterTypeStorage
-
-        Waterheater.apply_tank(model, loc_space, loc_schedule, water_heating_system, ec_adj,
-                               @dhw_map, @hvac_map, solar_thermal_system)
-
+        plantloop_map[sys_id] = Waterheater.apply_tank(model, loc_space, loc_schedule, water_heating_system, ec_adj, solar_thermal_system)
       elsif water_heating_system.water_heater_type == HPXML::WaterHeaterTypeTankless
-
-        Waterheater.apply_tankless(model, loc_space, loc_schedule, water_heating_system, ec_adj,
-                                   @nbeds, @dhw_map, @hvac_map, solar_thermal_system)
-
+        plantloop_map[sys_id] = Waterheater.apply_tankless(model, loc_space, loc_schedule, water_heating_system, ec_adj, @nbeds, solar_thermal_system)
       elsif water_heating_system.water_heater_type == HPXML::WaterHeaterTypeHeatPump
-
         living_zone = spaces[HPXML::LocationLivingSpace].thermalZone.get
-
-        Waterheater.apply_heatpump(model, runner, loc_space, loc_schedule, weather, water_heating_system, ec_adj,
-                                   @dhw_map, @hvac_map, solar_thermal_system, living_zone)
-
+        plantloop_map[sys_id] = Waterheater.apply_heatpump(model, runner, loc_space, loc_schedule, weather, water_heating_system, ec_adj, solar_thermal_system, living_zone)
       elsif [HPXML::WaterHeaterTypeCombiStorage, HPXML::WaterHeaterTypeCombiTankless].include? water_heating_system.water_heater_type
-
-        Waterheater.apply_combi(model, runner, loc_space, loc_schedule, water_heating_system, ec_adj,
-                                @dhw_map, @hvac_map, solar_thermal_system)
-
+        plantloop_map[sys_id] = Waterheater.apply_combi(model, runner, loc_space, loc_schedule, water_heating_system, ec_adj, solar_thermal_system)
       else
-
         fail "Unhandled water heater (#{water_heating_system.water_heater_type})."
-
       end
     end
 
     # Hot water fixtures and appliances
     HotWaterAndAppliances.apply(model, runner, @hpxml, weather, spaces, hot_water_distribution,
-                                solar_thermal_system, @eri_version, @dhw_map, @schedules_file)
+                                solar_thermal_system, @eri_version, @schedules_file, plantloop_map)
 
     if (not solar_thermal_system.nil?) && (not solar_thermal_system.collector_area.nil?) # Detailed solar water heater
       loc_space, loc_schedule = get_space_or_schedule_from_location(solar_thermal_system.water_heating_system.location, 'WaterHeatingSystem', model, spaces)
-      Waterheater.apply_solar_thermal(model, loc_space, loc_schedule, solar_thermal_system, @dhw_map)
+      Waterheater.apply_solar_thermal(model, loc_space, loc_schedule, solar_thermal_system, plantloop_map)
     end
 
     # Add combi-system EMS program with water use equipment information
-    Waterheater.apply_combi_system_EMS(model, @dhw_map, @hpxml.water_heating_systems)
+    Waterheater.apply_combi_system_EMS(model, @hpxml.water_heating_systems, plantloop_map)
   end
 
-  def self.add_cooling_system(runner, model, spaces)
+  def self.add_cooling_system(runner, model, spaces, airloop_map)
     living_zone = spaces[HPXML::LocationLivingSpace].thermalZone.get
 
     HVAC.get_hpxml_hvac_systems(@hpxml).each do |hvac_system|
@@ -1645,40 +1601,37 @@ class OSModel
 
       check_distribution_system(cooling_system.distribution_system, cooling_system.cooling_system_type)
 
-      if [HPXML::HVACTypeCentralAirConditioner].include? cooling_system.cooling_system_type
-
-        HVAC.apply_central_air_conditioner_furnace(model, runner, cooling_system, heating_system,
-                                                   @remaining_cool_load_frac, @remaining_heat_load_frac,
-                                                   living_zone, @hvac_map)
+      # Calculate cooling sequential load fractions
+      sequential_cool_load_fracs = HVAC.calc_sequential_load_fractions(cooling_system.fraction_cool_load_served.to_f, @remaining_cool_load_frac, @cooling_days)
+      @remaining_cool_load_frac -= cooling_system.fraction_cool_load_served.to_f
 
-        if not heating_system.nil?
-          @remaining_heat_load_frac -= heating_system.fraction_heat_load_served
-        end
+      # Calculate heating sequential load fractions
+      if not heating_system.nil?
+        sequential_heat_load_fracs = HVAC.calc_sequential_load_fractions(heating_system.fraction_heat_load_served, @remaining_heat_load_frac, @heating_days)
+        @remaining_heat_load_frac -= heating_system.fraction_heat_load_served
+      else
+        sequential_heat_load_fracs = [0]
+      end
 
-      elsif [HPXML::HVACTypeRoomAirConditioner].include? cooling_system.cooling_system_type
+      sys_id = cooling_system.id
+      if [HPXML::HVACTypeCentralAirConditioner,
+          HPXML::HVACTypeRoomAirConditioner,
+          HPXML::HVACTypeMiniSplitAirConditioner,
+          HPXML::HVACTypePTAC].include? cooling_system.cooling_system_type
 
-        HVAC.apply_room_air_conditioner(model, runner, cooling_system,
-                                        @remaining_cool_load_frac, living_zone,
-                                        @hvac_map)
+        airloop_map[sys_id] = HVAC.apply_air_source_hvac_systems(model, runner, cooling_system, heating_system,
+                                                                 sequential_cool_load_fracs, sequential_heat_load_fracs,
+                                                                 living_zone)
 
       elsif [HPXML::HVACTypeEvaporativeCooler].include? cooling_system.cooling_system_type
 
-        HVAC.apply_evaporative_cooler(model, runner, cooling_system,
-                                      @remaining_cool_load_frac, living_zone,
-                                      @hvac_map)
-
-      elsif [HPXML::HVACTypeMiniSplitAirConditioner].include? cooling_system.cooling_system_type
-
-        HVAC.apply_mini_split_air_conditioner(model, runner, cooling_system,
-                                              @remaining_cool_load_frac,
-                                              living_zone, @hvac_map)
+        airloop_map[sys_id] = HVAC.apply_evaporative_cooler(model, runner, cooling_system,
+                                                            sequential_cool_load_fracs, living_zone)
       end
-
-      @remaining_cool_load_frac -= cooling_system.fraction_cool_load_served
     end
   end
 
-  def self.add_heating_system(runner, model, spaces)
+  def self.add_heating_system(runner, model, spaces, airloop_map)
     living_zone = spaces[HPXML::LocationLivingSpace].thermalZone.get
 
     HVAC.get_hpxml_hvac_systems(@hpxml).each do |hvac_system|
@@ -1690,25 +1643,48 @@ class OSModel
 
       check_distribution_system(heating_system.distribution_system, heating_system.heating_system_type)
 
-      if [HPXML::HVACTypeFurnace].include? heating_system.heating_system_type
+      if (heating_system.heating_system_type == HPXML::HVACTypeFurnace) && (not cooling_system.nil?)
+        next # Already processed combined AC+furnace
+      end
+      if (heating_system.heating_system_type == HPXML::HVACTypePTACHeating) && (not cooling_system.nil?)
+        fail 'Unhandled ducted PTAC/PTHP system.'
+      end
+
+      # Calculate heating sequential load fractions
+      if heating_system.is_heat_pump_backup_system
+        # Heating system will be last in the EquipmentList and should meet entirety of
+        # remaining load during the heating season.
+        sequential_heat_load_fracs = @heating_days.map(&:to_f)
+        if not heating_system.fraction_heat_load_served.nil?
+          fail 'Heat pump backup system cannot have a fraction heat load served specified.'
+        end
+      else
+        sequential_heat_load_fracs = HVAC.calc_sequential_load_fractions(heating_system.fraction_heat_load_served, @remaining_heat_load_frac, @heating_days)
+        @remaining_heat_load_frac -= heating_system.fraction_heat_load_served
+      end
+
+      sys_id = heating_system.id
+      if [HPXML::HVACTypeFurnace, HPXML::HVACTypePTACHeating].include? heating_system.heating_system_type
 
-        if not cooling_system.nil?
-          next # Already processed combined AC+furnace
+        if heating_system.is_heat_pump_backup_system
+          # If we ever want to support this in the future, we have to address HVAC
+          # sizing related to 1) distribution losses and 2) calculating the airflow rate.
+          fail "Heat pump backup system cannot be of type '#{heating_system.heating_system_type}'."
         end
 
-        HVAC.apply_central_air_conditioner_furnace(model, runner, nil, heating_system,
-                                                   nil, @remaining_heat_load_frac,
-                                                   living_zone, @hvac_map)
+        airloop_map[sys_id] = HVAC.apply_air_source_hvac_systems(model, runner, nil, heating_system,
+                                                                 [0], sequential_heat_load_fracs,
+                                                                 living_zone)
 
       elsif [HPXML::HVACTypeBoiler].include? heating_system.heating_system_type
 
-        HVAC.apply_boiler(model, runner, heating_system,
-                          @remaining_heat_load_frac, living_zone, @hvac_map)
+        airloop_map[sys_id] = HVAC.apply_boiler(model, runner, heating_system,
+                                                sequential_heat_load_fracs, living_zone)
 
       elsif [HPXML::HVACTypeElectricResistance].include? heating_system.heating_system_type
 
         HVAC.apply_electric_baseboard(model, runner, heating_system,
-                                      @remaining_heat_load_frac, living_zone, @hvac_map)
+                                      sequential_heat_load_fracs, living_zone)
 
       elsif [HPXML::HVACTypeStove,
              HPXML::HVACTypePortableHeater,
@@ -1718,14 +1694,18 @@ class OSModel
              HPXML::HVACTypeFireplace].include? heating_system.heating_system_type
 
         HVAC.apply_unit_heater(model, runner, heating_system,
-                               @remaining_heat_load_frac, living_zone, @hvac_map)
+                               sequential_heat_load_fracs, living_zone)
       end
 
-      @remaining_heat_load_frac -= heating_system.fraction_heat_load_served
+      next unless heating_system.is_heat_pump_backup_system
+
+      # Store OS object for later use
+      equipment_list = model.getZoneHVACEquipmentLists.select { |el| el.thermalZone == living_zone }[0]
+      @heat_pump_backup_system_object = equipment_list.equipment[-1]
     end
   end
 
-  def self.add_heat_pump(runner, model, weather, spaces)
+  def self.add_heat_pump(runner, model, weather, spaces, airloop_map)
     living_zone = spaces[HPXML::LocationLivingSpace].thermalZone.get
 
     HVAC.get_hpxml_hvac_systems(@hpxml).each do |hvac_system|
@@ -1736,44 +1716,50 @@ class OSModel
 
       check_distribution_system(heat_pump.distribution_system, heat_pump.heat_pump_type)
 
-      if [HPXML::HVACTypeHeatPumpWaterLoopToAir].include? heat_pump.heat_pump_type
-
-        HVAC.apply_water_loop_to_air_heat_pump(model, runner, heat_pump,
-                                               @remaining_heat_load_frac,
-                                               @remaining_cool_load_frac,
-                                               living_zone, @hvac_map)
-
-      elsif [HPXML::HVACTypeHeatPumpAirToAir].include? heat_pump.heat_pump_type
+      # Calculate heating sequential load fractions
+      sequential_heat_load_fracs = HVAC.calc_sequential_load_fractions(heat_pump.fraction_heat_load_served, @remaining_heat_load_frac, @heating_days)
+      @remaining_heat_load_frac -= heat_pump.fraction_heat_load_served
 
-        HVAC.apply_central_air_to_air_heat_pump(model, runner, heat_pump,
-                                                @remaining_heat_load_frac,
-                                                @remaining_cool_load_frac,
-                                                living_zone, @hvac_map)
+      # Calculate cooling sequential load fractions
+      sequential_cool_load_fracs = HVAC.calc_sequential_load_fractions(heat_pump.fraction_cool_load_served, @remaining_cool_load_frac, @cooling_days)
+      @remaining_cool_load_frac -= heat_pump.fraction_cool_load_served
 
-      elsif [HPXML::HVACTypeHeatPumpMiniSplit].include? heat_pump.heat_pump_type
+      sys_id = heat_pump.id
+      if [HPXML::HVACTypeHeatPumpWaterLoopToAir].include? heat_pump.heat_pump_type
 
-        HVAC.apply_mini_split_heat_pump(model, runner, heat_pump,
-                                        @remaining_heat_load_frac,
-                                        @remaining_cool_load_frac,
-                                        living_zone, @hvac_map)
+        airloop_map[sys_id] = HVAC.apply_water_loop_to_air_heat_pump(model, runner, heat_pump,
+                                                                     sequential_heat_load_fracs, sequential_cool_load_fracs,
+                                                                     living_zone)
 
+      elsif [HPXML::HVACTypeHeatPumpAirToAir,
+             HPXML::HVACTypeHeatPumpMiniSplit,
+             HPXML::HVACTypeHeatPumpPTHP].include? heat_pump.heat_pump_type
+        airloop_map[sys_id] = HVAC.apply_air_source_hvac_systems(model, runner, heat_pump, heat_pump,
+                                                                 sequential_cool_load_fracs, sequential_heat_load_fracs,
+                                                                 living_zone)
       elsif [HPXML::HVACTypeHeatPumpGroundToAir].include? heat_pump.heat_pump_type
 
-        HVAC.apply_ground_to_air_heat_pump(model, runner, weather, heat_pump,
-                                           @remaining_heat_load_frac,
-                                           @remaining_cool_load_frac,
-                                           living_zone, @hvac_map)
+        airloop_map[sys_id] = HVAC.apply_ground_to_air_heat_pump(model, runner, weather, heat_pump,
+                                                                 sequential_heat_load_fracs, sequential_cool_load_fracs,
+                                                                 living_zone)
 
       end
 
-      @remaining_heat_load_frac -= heat_pump.fraction_heat_load_served
-      @remaining_cool_load_frac -= heat_pump.fraction_cool_load_served
+      next unless not heat_pump.backup_system.nil?
+
+      equipment_list = model.getZoneHVACEquipmentLists.select { |el| el.thermalZone == living_zone }[0]
+
+      # Set priority to be last (i.e., after the heat pump that it is backup for)
+      equipment_list.setHeatingPriority(@heat_pump_backup_system_object, 99)
+      equipment_list.setCoolingPriority(@heat_pump_backup_system_object, 99)
     end
   end
 
   def self.add_ideal_system(runner, model, spaces, epw_path)
-    # Adds an ideal air system as needed to meet the load (i.e., because the sum of fractions load
-    # served is less than 1 or because we're using an ideal air system for e.g. ASHRAE 140 loads).
+    # Adds an ideal air system as needed to meet the load under certain circumstances:
+    # 1. the sum of fractions load served is less than 1, or
+    # 2. there are non-year-round HVAC seasons, or
+    # 3. we're using an ideal air system for e.g. ASHRAE 140 loads calculation.
     living_zone = spaces[HPXML::LocationLivingSpace].thermalZone.get
     obj_name = Constants.ObjectNameIdealAirSystem
 
@@ -1789,53 +1775,35 @@ class OSModel
           fail 'Unexpected weather file for ASHRAE 140 run.'
         end
       end
-      HVAC.apply_ideal_air_loads(model, runner, obj_name, cooling_load_frac, heating_load_frac, living_zone)
+      HVAC.apply_ideal_air_loads(model, runner, obj_name, [cooling_load_frac], [heating_load_frac],
+                                 living_zone)
       return
     end
 
-    # Only fraction of heating load is met
     if (@hpxml.total_fraction_heat_load_served < 1.0) && (@hpxml.total_fraction_heat_load_served > 0.0)
       sequential_heat_load_frac = @remaining_heat_load_frac - @hpxml.total_fraction_heat_load_served
       @remaining_heat_load_frac -= sequential_heat_load_frac
     else
       sequential_heat_load_frac = 0.0
     end
-    # Only fraction of cooling load is met
+
     if (@hpxml.total_fraction_cool_load_served < 1.0) && (@hpxml.total_fraction_cool_load_served > 0.0)
       sequential_cool_load_frac = @remaining_cool_load_frac - @hpxml.total_fraction_cool_load_served
       @remaining_cool_load_frac -= sequential_cool_load_frac
     else
       sequential_cool_load_frac = 0.0
     end
-    if (sequential_heat_load_frac > 0.0) || (sequential_cool_load_frac > 0.0)
-      HVAC.apply_ideal_air_loads(model, runner, obj_name, sequential_cool_load_frac, sequential_heat_load_frac,
-                                 living_zone)
-    end
-  end
 
-  def self.add_residual_ideal_system(runner, model, spaces)
-    # Adds an ideal air system to meet unexpected load (i.e., because the HVAC systems are undersized to meet the load)
-    #
-    # Addressing unmet load ensures we can correctly calculate total heating/cooling loads without having
-    # to run an additional EnergyPlus simulation solely for that purpose, as well as allows us to report
-    # the unmet load (i.e., the energy delivered by the ideal air system).
+    return if @heating_days.nil?
 
-    living_zone = spaces[HPXML::LocationLivingSpace].thermalZone.get
-    obj_name = Constants.ObjectNameIdealAirSystemResidual
-
-    if @remaining_cool_load_frac < 1.0
-      sequential_cool_load_frac = 1.0
-    else
-      sequential_cool_load_frac = 0.0 # no cooling system, don't add ideal air for cooling either
-    end
+    # For periods of the year outside the HVAC season, operate this ideal air system to meet
+    # 100% of the load; for all other periods, operate to meet the fraction of the load not
+    # met by the HVAC system(s).
+    sequential_heat_load_fracs = @heating_days.map { |d| d == 0 ? 1.0 : sequential_heat_load_frac }
+    sequential_cool_load_fracs = @cooling_days.map { |d| d == 0 ? 1.0 : sequential_cool_load_frac }
 
-    if @remaining_heat_load_frac < 1.0
-      sequential_heat_load_frac = 1.0
-    else
-      sequential_heat_load_frac = 0.0 # no heating system, don't add ideal air for heating either
-    end
-    if (sequential_heat_load_frac > 0.0) || (sequential_cool_load_frac > 0.0)
-      HVAC.apply_ideal_air_loads(model, runner, obj_name, sequential_cool_load_frac, sequential_heat_load_frac,
+    if (sequential_heat_load_fracs.sum > 0.0) || (sequential_cool_load_fracs.sum > 0.0)
+      HVAC.apply_ideal_air_loads(model, runner, obj_name, sequential_cool_load_fracs, sequential_heat_load_fracs,
                                  living_zone)
     end
   end
@@ -1847,7 +1815,7 @@ class OSModel
     living_zone = spaces[HPXML::LocationLivingSpace].thermalZone.get
     has_ceiling_fan = (@hpxml.ceiling_fans.size > 0)
 
-    HVAC.apply_setpoints(model, runner, weather, hvac_control, living_zone, has_ceiling_fan)
+    HVAC.apply_setpoints(model, runner, weather, hvac_control, living_zone, has_ceiling_fan, @heating_days, @cooling_days, @hpxml.header.sim_calendar_year)
   end
 
   def self.add_ceiling_fans(runner, model, weather, spaces)
@@ -1860,7 +1828,7 @@ class OSModel
   def self.add_dehumidifiers(runner, model, spaces)
     return if @hpxml.dehumidifiers.size == 0
 
-    HVAC.apply_dehumidifiers(model, runner, @hpxml.dehumidifiers, spaces[HPXML::LocationLivingSpace], @hvac_map)
+    HVAC.apply_dehumidifiers(model, runner, @hpxml.dehumidifiers, spaces[HPXML::LocationLivingSpace])
   end
 
   def self.check_distribution_system(hvac_distribution, system_type)
@@ -1925,7 +1893,7 @@ class OSModel
 
   def self.add_lighting(runner, model, epw_file, spaces)
     Lighting.apply(runner, model, epw_file, spaces, @hpxml.lighting_groups,
-                   @hpxml.lighting, @eri_version, @schedules_file)
+                   @hpxml.lighting, @eri_version, @schedules_file, @cfa, @gfa)
   end
 
   def self.add_pools_and_hot_tubs(runner, model, spaces)
@@ -1944,7 +1912,7 @@ class OSModel
     end
   end
 
-  def self.add_airflow(runner, model, weather, spaces)
+  def self.add_airflow(runner, model, weather, spaces, airloop_map)
     # Ducts
     duct_systems = {}
     @hpxml.hvac_distributions.each do |hvac_distribution|
@@ -1956,19 +1924,18 @@ class OSModel
       # Connect AirLoopHVACs to ducts
       added_ducts = false
       hvac_distribution.hvac_systems.each do |hvac_system|
-        @hvac_map[hvac_system.id].each do |object|
-          next unless object.is_a?(OpenStudio::Model::AirLoopHVAC) || object.is_a?(OpenStudio::Model::ZoneHVACFourPipeFanCoil)
-
-          if duct_systems[air_ducts].nil?
-            duct_systems[air_ducts] = object
-            added_ducts = true
-          elsif duct_systems[air_ducts] != object
-            # Multiple air loops associated with this duct system, treat
-            # as separate duct systems.
-            air_ducts2 = create_ducts(runner, model, hvac_distribution, spaces)
-            duct_systems[air_ducts2] = object
-            added_ducts = true
-          end
+        next if airloop_map[hvac_system.id].nil?
+
+        object = airloop_map[hvac_system.id]
+        if duct_systems[air_ducts].nil?
+          duct_systems[air_ducts] = object
+          added_ducts = true
+        elsif duct_systems[air_ducts] != object
+          # Multiple air loops associated with this duct system, treat
+          # as separate duct systems.
+          air_ducts2 = create_ducts(runner, model, hvac_distribution, spaces)
+          duct_systems[air_ducts2] = object
+          added_ducts = true
         end
       end
       if not added_ducts
@@ -1977,7 +1944,7 @@ class OSModel
     end
 
     Airflow.apply(model, runner, weather, spaces, @hpxml, @cfa, @nbeds,
-                  @ncfl_ag, duct_systems, @clg_ssn_sensor, @hvac_map, @eri_version,
+                  @ncfl_ag, duct_systems, airloop_map, @clg_ssn_sensor, @eri_version,
                   @frac_windows_operable, @apply_ashrae140_assumptions, @schedules_file)
   end
 
@@ -1988,7 +1955,7 @@ class OSModel
     leakage_to_outside = { HPXML::DuctTypeSupply => [0.0, nil],
                            HPXML::DuctTypeReturn => [0.0, nil] }
     hvac_distribution.duct_leakage_measurements.each do |duct_leakage_measurement|
-      next unless [HPXML::UnitsCFM25, HPXML::UnitsPercent].include?(duct_leakage_measurement.duct_leakage_units) && (duct_leakage_measurement.duct_leakage_total_or_to_outside == 'to outside')
+      next unless [HPXML::UnitsCFM25, HPXML::UnitsCFM50, HPXML::UnitsPercent].include?(duct_leakage_measurement.duct_leakage_units) && (duct_leakage_measurement.duct_leakage_total_or_to_outside == 'to outside')
       next if duct_leakage_measurement.duct_type.nil?
 
       leakage_to_outside[duct_leakage_measurement.duct_type] = [duct_leakage_measurement.duct_leakage_value, duct_leakage_measurement.duct_leakage_units]
@@ -1998,7 +1965,7 @@ class OSModel
     total_unconditioned_duct_area = { HPXML::DuctTypeSupply => 0.0,
                                       HPXML::DuctTypeReturn => 0.0 }
     hvac_distribution.ducts.each do |ducts|
-      next if [HPXML::LocationLivingSpace, HPXML::LocationBasementConditioned].include? ducts.duct_location
+      next if HPXML::conditioned_locations_this_unit.include? ducts.duct_location
       next if ducts.duct_type.nil?
 
       # Calculate total duct area in unconditioned spaces
@@ -2007,7 +1974,7 @@ class OSModel
 
     # Create duct objects
     hvac_distribution.ducts.each do |ducts|
-      next if [HPXML::LocationLivingSpace, HPXML::LocationBasementConditioned].include? ducts.duct_location
+      next if HPXML::conditioned_locations_this_unit.include? ducts.duct_location
       next if ducts.duct_type.nil?
       next if total_unconditioned_duct_area[ducts.duct_type] <= 0
 
@@ -2020,14 +1987,16 @@ class OSModel
       duct_leakage_cfm = nil
       duct_leakage_frac = nil
       if duct_leakage_units == HPXML::UnitsCFM25
-        duct_leakage_cfm = duct_leakage_value
+        duct_leakage_cfm25 = duct_leakage_value
+      elsif duct_leakage_units == HPXML::UnitsCFM50
+        duct_leakage_cfm50 = duct_leakage_value
       elsif duct_leakage_units == HPXML::UnitsPercent
         duct_leakage_frac = duct_leakage_value
       else
         fail "#{ducts.duct_type.capitalize} ducts exist but leakage was not specified for distribution system '#{hvac_distribution.id}'."
       end
 
-      air_ducts << Duct.new(ducts.duct_type, duct_loc_space, duct_loc_schedule, duct_leakage_frac, duct_leakage_cfm, ducts.duct_surface_area, ducts.duct_insulation_r_value)
+      air_ducts << Duct.new(ducts.duct_type, duct_loc_space, duct_loc_schedule, duct_leakage_frac, duct_leakage_cfm25, duct_leakage_cfm50, ducts.duct_surface_area, ducts.duct_insulation_r_value)
     end
 
     # If all ducts are in conditioned space, model leakage as going to outside
@@ -2044,14 +2013,16 @@ class OSModel
       duct_leakage_cfm = nil
       duct_leakage_frac = nil
       if duct_leakage_units == HPXML::UnitsCFM25
-        duct_leakage_cfm = duct_leakage_value
+        duct_leakage_cfm25 = duct_leakage_value
+      elsif duct_leakage_units == HPXML::UnitsCFM50
+        duct_leakage_cfm50 = duct_leakage_value
       elsif duct_leakage_units == HPXML::UnitsPercent
         duct_leakage_frac = duct_leakage_value
       else
         fail "#{duct_side.capitalize} ducts exist but leakage was not specified for distribution system '#{hvac_distribution.id}'."
       end
 
-      air_ducts << Duct.new(duct_side, duct_loc_space, duct_loc_schedule, duct_leakage_frac, duct_leakage_cfm, duct_area, duct_rvalue)
+      air_ducts << Duct.new(duct_side, duct_loc_space, duct_loc_schedule, duct_leakage_frac, duct_leakage_cfm25, duct_leakage_cfm50, duct_area, duct_rvalue)
     end
 
     return air_ducts
@@ -2069,13 +2040,24 @@ class OSModel
     end
   end
 
+  def self.add_batteries(runner, model, spaces)
+    return if @hpxml.pv_systems.empty?
+
+    @hpxml.batteries.each do |battery|
+      # Assign space
+      if battery.location != HPXML::LocationOutside
+        battery.additional_properties.space = get_space_from_location(battery.location, 'Battery', model, spaces)
+      end
+      Battery.apply(runner, model, battery)
+    end
+  end
+
   def self.add_additional_properties(runner, model, hpxml_path, building_id)
     # Store some data for use in reporting measure
     additionalProperties = model.getBuilding.additionalProperties
     additionalProperties.setFeature('hpxml_path', hpxml_path)
+    additionalProperties.setFeature('hpxml_defaults_path', @hpxml_defaults_path)
     additionalProperties.setFeature('building_id', building_id.to_s)
-    additionalProperties.setFeature('hvac_map', map_to_string(@hvac_map))
-    additionalProperties.setFeature('dhw_map', map_to_string(@dhw_map))
   end
 
   def self.map_to_string(map)
@@ -2100,12 +2082,14 @@ class OSModel
   end
 
   def self.add_total_loads_output(runner, model, living_zone)
+    # Energy transferred in the conditioned space, used for determining heating (winter) vs cooling (summer)
     liv_load_sensors = {}
     liv_load_sensors[:htg] = OpenStudio::Model::EnergyManagementSystemSensor.new(model, "Heating:EnergyTransfer:Zone:#{living_zone.name.to_s.upcase}")
     liv_load_sensors[:htg].setName('htg_load_liv')
     liv_load_sensors[:clg] = OpenStudio::Model::EnergyManagementSystemSensor.new(model, "Cooling:EnergyTransfer:Zone:#{living_zone.name.to_s.upcase}")
     liv_load_sensors[:clg].setName('clg_load_liv')
 
+    # Total energy transferred (above plus ducts)
     tot_load_sensors = {}
     tot_load_sensors[:htg] = OpenStudio::Model::EnergyManagementSystemSensor.new(model, 'Heating:EnergyTransfer')
     tot_load_sensors[:htg].setName('htg_load_tot')
@@ -2261,64 +2245,54 @@ class OSModel
     end
 
     # EMS Sensors: Infiltration, Mechanical Ventilation, Natural Ventilation, Whole House Fan
+    infil_sensors = []
+    natvent_sensors = []
+    whf_sensors = []
+    { Constants.ObjectNameInfiltration => infil_sensors,
+      Constants.ObjectNameNaturalVentilation => natvent_sensors,
+      Constants.ObjectNameWholeHouseFan => whf_sensors }.each do |prefix, array|
+      model.getSpaceInfiltrationDesignFlowRates.sort.each do |i|
+        next unless i.name.to_s.start_with? prefix
+        next unless i.space.get.thermalZone.get.name.to_s == living_zone.name.to_s
+
+        { 'Infiltration Sensible Heat Gain Energy' => prefix.gsub(' ', '_') + '_' + 'gain',
+          'Infiltration Sensible Heat Loss Energy' => prefix.gsub(' ', '_') + '_' + 'loss' }.each do |var, name|
+          airflow_sensor = OpenStudio::Model::EnergyManagementSystemSensor.new(model, var)
+          airflow_sensor.setName(name)
+          airflow_sensor.setKeyName(i.name.to_s)
+          array << airflow_sensor
+        end
+      end
+    end
 
-    air_gain_sensor = OpenStudio::Model::EnergyManagementSystemSensor.new(model, 'Zone Infiltration Sensible Heat Gain Energy')
-    air_gain_sensor.setName('airflow_gain')
-    air_gain_sensor.setKeyName(living_zone.name.to_s)
-
-    air_loss_sensor = OpenStudio::Model::EnergyManagementSystemSensor.new(model, 'Zone Infiltration Sensible Heat Loss Energy')
-    air_loss_sensor.setName('airflow_loss')
-    air_loss_sensor.setKeyName(living_zone.name.to_s)
-
-    mechvent_sensors = []
+    mechvents_sensors = []
     model.getElectricEquipments.sort.each do |o|
       next unless o.name.to_s.start_with? Constants.ObjectNameMechanicalVentilation
 
+      mechvents_sensors << []
       { 'Electric Equipment Convective Heating Energy' => 'mv_conv',
         'Electric Equipment Radiant Heating Energy' => 'mv_rad' }.each do |var, name|
         mechvent_sensor = OpenStudio::Model::EnergyManagementSystemSensor.new(model, var)
         mechvent_sensor.setName(name)
         mechvent_sensor.setKeyName(o.name.to_s)
-        mechvent_sensors << mechvent_sensor
+        mechvents_sensors[-1] << mechvent_sensor
         objects_already_processed << o
       end
     end
     model.getOtherEquipments.sort.each do |o|
       next unless o.name.to_s.start_with? Constants.ObjectNameMechanicalVentilationHouseFan
 
+      mechvents_sensors << []
       { 'Other Equipment Convective Heating Energy' => 'mv_conv',
         'Other Equipment Radiant Heating Energy' => 'mv_rad' }.each do |var, name|
         mechvent_sensor = OpenStudio::Model::EnergyManagementSystemSensor.new(model, var)
         mechvent_sensor.setName(name)
         mechvent_sensor.setKeyName(o.name.to_s)
-        mechvent_sensors << mechvent_sensor
+        mechvents_sensors[-1] << mechvent_sensor
         objects_already_processed << o
       end
     end
 
-    infil_flow_actuators = []
-    natvent_flow_actuators = []
-    whf_flow_actuators = []
-
-    model.getEnergyManagementSystemActuators.each do |actuator|
-      next unless (actuator.actuatedComponentType == 'Zone Infiltration') && (actuator.actuatedComponentControlType == 'Air Exchange Flow Rate')
-
-      if actuator.name.to_s.start_with? Constants.ObjectNameInfiltration.gsub(' ', '_')
-        infil_flow_actuators << actuator
-      elsif actuator.name.to_s.start_with? Constants.ObjectNameNaturalVentilation.gsub(' ', '_')
-        natvent_flow_actuators << actuator
-      elsif actuator.name.to_s.start_with? Constants.ObjectNameWholeHouseFan.gsub(' ', '_')
-        whf_flow_actuators << actuator
-      end
-    end
-    if (infil_flow_actuators.size != 1) || (natvent_flow_actuators.size != 1) || (whf_flow_actuators.size != 1)
-      fail 'Could not find actuator for component loads.'
-    end
-
-    infil_flow_actuator = infil_flow_actuators[0]
-    natvent_flow_actuator = natvent_flow_actuators[0]
-    whf_flow_actuator = whf_flow_actuators[0]
-
     # EMS Sensors: Ducts
 
     ducts_sensors = []
@@ -2492,28 +2466,30 @@ class OSModel
     end
 
     # EMS program: Infiltration, Natural Ventilation, Mechanical Ventilation, Ducts
-    program.addLine("Set hr_airflow_rate = #{infil_flow_actuator.name} + #{natvent_flow_actuator.name} + #{whf_flow_actuator.name}")
-    program.addLine('If hr_airflow_rate > 0')
-    program.addLine("  Set hr_infil = (#{air_loss_sensor.name} - #{air_gain_sensor.name}) * #{infil_flow_actuator.name} / hr_airflow_rate") # Airflow heat attributed to infiltration
-    program.addLine("  Set hr_natvent = (#{air_loss_sensor.name} - #{air_gain_sensor.name}) * #{natvent_flow_actuator.name} / hr_airflow_rate") # Airflow heat attributed to natural ventilation
-    program.addLine("  Set hr_whf = (#{air_loss_sensor.name} - #{air_gain_sensor.name}) * #{whf_flow_actuator.name} / hr_airflow_rate") # Airflow heat attributed to whole house fan
-    program.addLine('Else')
-    program.addLine('  Set hr_infil = 0')
-    program.addLine('  Set hr_natvent = 0')
-    program.addLine('  Set hr_whf = 0')
-    program.addLine('  Set hr_mechvent = 0')
-    program.addLine('EndIf')
-    program.addLine('Set hr_mechvent = 0')
-    mechvent_sensors.each do |sensor|
-      program.addLine("Set hr_mechvent = hr_mechvent - #{sensor.name}")
-    end
-    program.addLine('Set hr_ducts = 0')
-    ducts_sensors.each do |duct_sensors|
-      s = 'Set hr_ducts = hr_ducts'
-      duct_sensors.each do |sensor|
-        s += " - #{sensor.name}"
+    { infil_sensors => 'infil',
+      natvent_sensors => 'natvent',
+      whf_sensors => 'whf' }.each do |sensors, loadtype|
+      program.addLine("Set hr_#{loadtype} = 0")
+      s = "Set hr_#{loadtype} = hr_#{loadtype}"
+      sensors.each do |sensor|
+        if sensor.name.to_s.include? 'gain'
+          s += " - #{sensor.name}"
+        elsif sensor.name.to_s.include? 'loss'
+          s += " + #{sensor.name}"
+        end
+      end
+      program.addLine(s) if sensors.size > 0
+    end
+    { mechvents_sensors => 'mechvent',
+      ducts_sensors => 'ducts' }.each do |all_sensors, loadtype|
+      program.addLine("Set hr_#{loadtype} = 0")
+      all_sensors.each do |sensors|
+        s = "Set hr_#{loadtype} = hr_#{loadtype}"
+        sensors.each do |sensor|
+          s += " - #{sensor.name}"
+        end
+        program.addLine(s) if sensors.size > 0
       end
-      program.addLine(s) if duct_sensors.size > 0
     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})")
@@ -2579,9 +2555,9 @@ class OSModel
 
   def self.set_surface_interior(model, spaces, surface, hpxml_surface)
     interior_adjacent_to = hpxml_surface.interior_adjacent_to
-    if [HPXML::LocationBasementConditioned].include? interior_adjacent_to
+    if HPXML::conditioned_below_grade_locations.include? interior_adjacent_to
       surface.setSpace(create_or_get_space(model, spaces, HPXML::LocationLivingSpace))
-      @cond_bsmnt_surfaces << surface
+      @cond_below_grade_surfaces << surface
     else
       surface.setSpace(create_or_get_space(model, spaces, interior_adjacent_to))
     end
@@ -2600,9 +2576,9 @@ class OSModel
     elsif [HPXML::LocationOtherHeatedSpace, HPXML::LocationOtherMultifamilyBufferSpace,
            HPXML::LocationOtherNonFreezingSpace, HPXML::LocationOtherHousingUnit].include? exterior_adjacent_to
       set_surface_otherside_coefficients(surface, exterior_adjacent_to, model, spaces)
-    elsif exterior_adjacent_to == HPXML::LocationBasementConditioned
+    elsif HPXML::conditioned_below_grade_locations.include? exterior_adjacent_to
       surface.createAdjacentSurface(create_or_get_space(model, spaces, HPXML::LocationLivingSpace))
-      @cond_bsmnt_surfaces << surface.adjacentSurface.get
+      @cond_below_grade_surfaces << surface.adjacentSurface.get
     else
       surface.createAdjacentSurface(create_or_get_space(model, spaces, exterior_adjacent_to))
     end
@@ -2660,7 +2636,7 @@ class OSModel
     if space_values[:indoor_weight] > 0
       sensor_ia = OpenStudio::Model::EnergyManagementSystemSensor.new(model, 'Zone Air Temperature')
       sensor_ia.setName('cond_zone_temp')
-      sensor_ia.setKeyName(spaces[HPXML::LocationLivingSpace].name.to_s)
+      sensor_ia.setKeyName(spaces[HPXML::LocationLivingSpace].thermalZone.get.name.to_s)
     end
 
     if space_values[:outdoor_weight] > 0
@@ -2712,12 +2688,18 @@ class OSModel
   # Should be called when the object's energy use is sensitive to ambient temperature
   # (e.g., water heaters and ducts).
   def self.get_space_or_schedule_from_location(location, object_name, model, spaces)
-    return if [HPXML::LocationOtherExterior, HPXML::LocationOutside, HPXML::LocationRoofDeck].include? location
+    return if [HPXML::LocationOtherExterior,
+               HPXML::LocationOutside,
+               HPXML::LocationRoofDeck].include? location
 
     sch = nil
     space = nil
-    if [HPXML::LocationOtherHeatedSpace, HPXML::LocationOtherHousingUnit, HPXML::LocationOtherMultifamilyBufferSpace,
-        HPXML::LocationOtherNonFreezingSpace, HPXML::LocationExteriorWall, HPXML::LocationUnderSlab].include? location
+    if [HPXML::LocationOtherHeatedSpace,
+        HPXML::LocationOtherHousingUnit,
+        HPXML::LocationOtherMultifamilyBufferSpace,
+        HPXML::LocationOtherNonFreezingSpace,
+        HPXML::LocationExteriorWall,
+        HPXML::LocationUnderSlab].include? location
       # if located in spaces where we don't model a thermal zone, create and return temperature schedule
       sch = get_space_temperature_schedule(model, location, spaces)
     else
@@ -2738,7 +2720,7 @@ class OSModel
 
     num_orig_spaces = spaces.size
 
-    if location == HPXML::LocationBasementConditioned
+    if HPXML::conditioned_locations.include? location
       space = create_or_get_space(model, spaces, HPXML::LocationLivingSpace)
     else
       space = create_or_get_space(model, spaces, location)
@@ -2786,6 +2768,24 @@ class OSModel
     end
     @walls_top = @foundation_top + 8.0 * @ncfl_ag
   end
+
+  def self.set_heating_and_cooling_seasons()
+    return if @hpxml.hvac_controls.size == 0
+
+    hvac_control = @hpxml.hvac_controls[0]
+
+    htg_start_month = hvac_control.seasons_heating_begin_month
+    htg_start_day = hvac_control.seasons_heating_begin_day
+    htg_end_month = hvac_control.seasons_heating_end_month
+    htg_end_day = hvac_control.seasons_heating_end_day
+    clg_start_month = hvac_control.seasons_cooling_begin_month
+    clg_start_day = hvac_control.seasons_cooling_begin_day
+    clg_end_month = hvac_control.seasons_cooling_end_month
+    clg_end_day = hvac_control.seasons_cooling_end_day
+
+    @heating_days = Schedule.get_daily_season(@hpxml.header.sim_calendar_year, htg_start_month, htg_start_day, htg_end_month, htg_end_day)
+    @cooling_days = Schedule.get_daily_season(@hpxml.header.sim_calendar_year, clg_start_month, clg_start_day, clg_end_month, clg_end_day)
+  end
 end
 
 # register the measure to be used by the application