urbanopt-cli 0.4.1 → 0.6.1

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

@@ -41,34 +41,6 @@ class Constants
     return 'ERI Index Adjustment Reference Home'
   end
 
-  def self.BoreConfigSingle
-    return 'single'
-  end
-
-  def self.BoreConfigLine
-    return 'line'
-  end
-
-  def self.BoreConfigOpenRectangle
-    return 'open-rectangle'
-  end
-
-  def self.BoreConfigRectangle
-    return 'rectangle'
-  end
-
-  def self.BoreConfigLconfig
-    return 'l-config'
-  end
-
-  def self.BoreConfigL2config
-    return 'l2-config'
-  end
-
-  def self.BoreConfigUconfig
-    return 'u-config'
-  end
-
   def self.BuildingAmericaClimateZone
     return 'Building America'
   end
@@ -281,8 +253,8 @@ class Constants
     return 'mech vent range fan'
   end
 
-  def self.ObjectNameMechanicalVentilationAirflow
-    return 'Qfan'
+  def self.ObjectNameMiniSplitAirConditioner
+    return 'mini split air conditioner'
   end
 
   def self.ObjectNameMiniSplitHeatPump
@@ -373,6 +345,10 @@ class Constants
     return "#{hvac_name} shared pump"
   end
 
+  def self.ObjectNameSkylightShade
+    return 'skylight shade'
+  end
+
   def self.ObjectNameSolarHotWater
     return 'solar hot water'
   end
@@ -381,6 +357,10 @@ class Constants
     return 'dhw source hx'
   end
 
+  def self.ObjectNameTotalLoadsProgram
+    return 'total loads program'
+  end
+
   def self.ObjectNameUnitHeater
     return 'unit heater'
   end
@@ -409,6 +389,10 @@ class Constants
     return 'whole house fan'
   end
 
+  def self.ObjectNameWindowShade
+    return 'window shade'
+  end
+
   def self.ScheduleTypeLimitsFraction
     return 'Fractional'
   end
@@ -420,160 +404,4 @@ class Constants
   def self.ScheduleTypeLimitsTemperature
     return 'Temperature'
   end
-
-  def self.SizingInfoDuctExist
-    return __method__.to_s
-  end
-
-  def self.SizingInfoDuctSides
-    return __method__.to_s
-  end
-
-  def self.SizingInfoDuctLocations
-    return __method__.to_s
-  end
-
-  def self.SizingInfoDuctLeakageFracs
-    return __method__.to_s
-  end
-
-  def self.SizingInfoDuctLeakageCFM25s
-    return __method__.to_s
-  end
-
-  def self.SizingInfoDuctAreas
-    return __method__.to_s
-  end
-
-  def self.SizingInfoDuctRvalues
-    return __method__.to_s
-  end
-
-  def self.SizingInfoHVACFracHeatLoadServed
-    return __method__.to_s
-  end
-
-  def self.SizingInfoHVACFracCoolLoadServed
-    return __method__.to_s
-  end
-
-  def self.SizingInfoHVACCoolType
-    return __method__.to_s
-  end
-
-  def self.SizingInfoHVACHeatType
-    return __method__.to_s
-  end
-
-  def self.SizingInfoHVACPumpPower
-    return __method__.to_s
-  end
-
-  def self.SizingInfoHVACSystemIsDucted # Only needed for optionally ducted systems
-    return __method__.to_s
-  end
-
-  def self.SizingInfoGSHPBoreConfig
-    return __method__.to_s
-  end
-
-  def self.SizingInfoGSHPBoreDepth
-    return __method__.to_s
-  end
-
-  def self.SizingInfoGSHPBoreHoles
-    return __method__.to_s
-  end
-
-  def self.SizingInfoGSHPBoreSpacing
-    return __method__.to_s
-  end
-
-  def self.SizingInfoGSHPCoil_BF_FT_SPEC
-    return __method__.to_s
-  end
-
-  def self.SizingInfoGSHPCoilBF
-    return __method__.to_s
-  end
-
-  def self.SizingInfoGSHPUTubeSpacingType
-    return __method__.to_s
-  end
-
-  def self.SizingInfoHVACCapacityRatioCooling
-    return __method__.to_s
-  end
-
-  def self.SizingInfoHVACCapacityRatioHeating
-    return __method__.to_s
-  end
-
-  def self.SizingInfoHVACCoolingCFMs
-    return __method__.to_s
-  end
-
-  def self.SizingInfoHVACHeatingCapacityOffset
-    return __method__.to_s
-  end
-
-  def self.SizingInfoHVACHeatingCFMs
-    return __method__.to_s
-  end
-
-  def self.SizingInfoHVACRatedCFMperTonHeating
-    return __method__.to_s
-  end
-
-  def self.SizingInfoHVACRatedCFMperTonCooling
-    return __method__.to_s
-  end
-
-  def self.SizingInfoHVACSHR
-    return __method__.to_s
-  end
-
-  def self.SizingInfoMechVentExist
-    return __method__.to_s
-  end
-
-  def self.SizingInfoMechVentApparentSensibleEffectiveness
-    return __method__.to_s
-  end
-
-  def self.SizingInfoMechVentLatentEffectiveness
-    return __method__.to_s
-  end
-
-  def self.SizingInfoMechVentWholeHouseRateBalanced
-    return __method__.to_s
-  end
-
-  def self.SizingInfoMechVentWholeHouseRateUnbalanced
-    return __method__.to_s
-  end
-
-  def self.SizingInfoMechVentWholeHouseRatePreHeated
-    return __method__.to_s
-  end
-
-  def self.SizingInfoMechVentWholeHouseRatePreCooled
-    return __method__.to_s
-  end
-
-  def self.SizingInfoMechVentWholeHouseRateRecirculated
-    return __method__.to_s
-  end
-
-  def self.SizingInfoSIPWallInsThickness
-    return __method__.to_s
-  end
-
-  def self.SizingInfoZoneInfiltrationACH
-    return __method__.to_s
-  end
-
-  def self.SizingInfoZoneInfiltrationCFM
-    return __method__.to_s
-  end
 end

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

@@ -63,12 +63,6 @@ class Constructions
 
     # Create and assign construction to surfaces
     constr.create_and_assign_constructions(runner, surfaces, model)
-
-    # Store info for HVAC Sizing measure
-    if not wall.nil?
-      wall.insulation_cavity_r_value = cavity_r
-      wall.insulation_continuous_r_value = rigid_r
-    end
   end
 
   def self.apply_double_stud_wall(runner, model, surfaces, wall, constr_name,
@@ -137,9 +131,6 @@ class Constructions
 
     # Create and assign construction to surfaces
     constr.create_and_assign_constructions(runner, surfaces, model)
-
-    # Store info for HVAC Sizing measure
-    wall.insulation_continuous_r_value = rigid_r
   end
 
   def self.apply_cmu_wall(runner, model, surfaces, wall, constr_name,
@@ -207,10 +198,6 @@ class Constructions
 
     # Create and assign construction to surfaces
     constr.create_and_assign_constructions(runner, surfaces, model)
-
-    # Store info for HVAC Sizing measure
-    wall.insulation_cavity_r_value = furring_r
-    wall.insulation_continuous_r_value = rigid_r
   end
 
   def self.apply_icf_wall(runner, model, surfaces, wall, constr_name,
@@ -260,9 +247,6 @@ class Constructions
 
     # Create and assign construction to surfaces
     constr.create_and_assign_constructions(runner, surfaces, model)
-
-    # Store info for HVAC Sizing measure
-    wall.insulation_continuous_r_value = rigid_r
   end
 
   def self.apply_sip_wall(runner, model, surfaces, wall, constr_name, sip_r,
@@ -378,10 +362,6 @@ class Constructions
 
     # Create and assign construction to surfaces
     constr.create_and_assign_constructions(runner, surfaces, model)
-
-    # Store info for HVAC Sizing measure
-    wall.insulation_cavity_r_value = cavity_r
-    wall.insulation_continuous_r_value = rigid_r
   end
 
   def self.apply_generic_layered_wall(runner, model, surfaces, wall, constr_name,
@@ -448,9 +428,6 @@ class Constructions
 
     # Create and assign construction to surfaces
     constr.create_and_assign_constructions(runner, surfaces, model)
-
-    # Store info for HVAC Sizing measure
-    wall.insulation_continuous_r_value = rigid_r
   end
 
   def self.apply_rim_joist(runner, model, surfaces, rim_joist, constr_name,
@@ -508,10 +485,6 @@ class Constructions
 
     # Create and assign construction to surfaces
     constr.create_and_assign_constructions(runner, surfaces, model)
-
-    # Store info for HVAC Sizing measure
-    rim_joist.insulation_continuous_r_value = rigid_r
-    rim_joist.insulation_cavity_r_value = cavity_r
   end
 
   def self.apply_open_cavity_roof(runner, model, surfaces, constr_name,
@@ -839,11 +812,11 @@ class Constructions
     surface.createSurfacePropertyExposedFoundationPerimeter('TotalExposedPerimeter', UnitConversions.convert(exposed_perimeter, 'ft', 'm'))
   end
 
-  def self.apply_door(runner, model, subsurfaces, constr_name, ufactor)
+  def self.apply_door(runner, model, subsurfaces, constr_name, ufactor, inside_film, outside_film)
     return if subsurfaces.empty?
 
     # Define materials
-    door_Rvalue = 1.0 / ufactor - Material.AirFilmOutside.rvalue - Material.AirFilmVertical.rvalue
+    door_Rvalue = 1.0 / ufactor - inside_film.rvalue - outside_film.rvalue
     door_thickness = 1.75 # in
     fin_door_mat = Material.new(name = 'DoorMaterial', thick_in = door_thickness, mat_base = BaseMaterial.Wood, k_in = 1.0 / door_Rvalue * door_thickness)
 
@@ -858,18 +831,12 @@ class Constructions
     constr.create_and_assign_constructions(runner, subsurfaces, model)
   end
 
-  def self.apply_window(runner, model, subsurfaces, constr_name, weather,
-                        is_sch, ufactor, shgc, heat_shade_mult, cool_shade_mult)
-
-    apply_window_skylight(runner, model, 'Window', subsurfaces, constr_name, weather,
-                          is_sch, ufactor, shgc, heat_shade_mult, cool_shade_mult)
+  def self.apply_window(runner, model, subsurface, constr_name, ufactor, shgc)
+    apply_window_skylight(runner, model, 'Window', subsurface, constr_name, ufactor, shgc)
   end
 
-  def self.apply_skylight(runner, model, subsurfaces, constr_name, weather,
-                          is_sch, ufactor, shgc, heat_shade_mult, cool_shade_mult)
-
-    apply_window_skylight(runner, model, 'Skylight', subsurfaces, constr_name, weather,
-                          is_sch, ufactor, shgc, heat_shade_mult, cool_shade_mult)
+  def self.apply_skylight(runner, model, subsurface, constr_name, ufactor, shgc)
+    apply_window_skylight(runner, model, 'Skylight', subsurface, constr_name, ufactor, shgc)
   end
 
   def self.apply_partition_walls(runner, model, constr_name, drywall_thick_in, frac_of_ffa,
@@ -972,7 +939,8 @@ class Constructions
   end
 
   def self.create_os_int_mass_and_def(model, object_name, space, area)
-    # create internal mass objects
+    # EnergyPlus documentation: If both sides of the surface exchange energy with the zone
+    # then the user should input twice the area when defining the Internal Mass object.
     imdef = OpenStudio::Model::InternalMassDefinition.new(model)
     imdef.setName(object_name)
     imdef.setSurfaceArea(area)
@@ -1178,57 +1146,7 @@ class Constructions
     return mat
   end
 
-  def self.apply_window_skylight(runner, model, type, subsurfaces, constr_name, weather,
-                                 is_sch, ufactor, shgc, heat_shade_mult, cool_shade_mult)
-
-    return if subsurfaces.empty?
-
-    # Define shade and schedule
-    sc = nil
-    if (cool_shade_mult < 1) || (heat_shade_mult < 1)
-      # EnergyPlus doesn't like shades that absorb no heat, transmit no heat or reflect no heat.
-      if cool_shade_mult == 1
-        cool_shade_mult = 0.999
-      end
-      if heat_shade_mult == 1
-        heat_shade_mult = 0.999
-      end
-
-      total_shade_trans = cool_shade_mult / heat_shade_mult * 0.999
-      total_shade_abs = 0.00001
-      total_shade_ref = 1 - total_shade_trans - total_shade_abs
-
-      # CoolingShade
-      sm = OpenStudio::Model::Shade.new(model)
-      sm.setName("#{type}CoolingShade")
-      sm.setSolarTransmittance(total_shade_trans)
-      sm.setSolarReflectance(total_shade_ref)
-      sm.setVisibleTransmittance(total_shade_trans)
-      sm.setVisibleReflectance(total_shade_ref)
-      sm.setThermalHemisphericalEmissivity(total_shade_abs)
-      sm.setThermalTransmittance(total_shade_trans)
-      sm.setThickness(0.0001)
-      sm.setConductivity(10000)
-      sm.setShadetoGlassDistance(0.001)
-      sm.setTopOpeningMultiplier(0)
-      sm.setBottomOpeningMultiplier(0)
-      sm.setLeftSideOpeningMultiplier(0)
-      sm.setRightSideOpeningMultiplier(0)
-      sm.setAirflowPermeability(0)
-
-      # ShadingControl
-      sc = OpenStudio::Model::ShadingControl.new(sm)
-      sc.setName("#{type}ShadingControl")
-      sc.setShadingType('InteriorShade')
-      sc.setShadingControlType('OnIfScheduleAllows')
-      sc.setSchedule(is_sch.schedule)
-
-      # Add shading controls
-      subsurfaces.each do |subsurface|
-        subsurface.setShadingControl(sc)
-      end
-    end
-
+  def self.apply_window_skylight(runner, model, type, subsurface, constr_name, ufactor, shgc)
     # Define materials
     if type == 'Skylight'
       # As of 2004, NFRC skylights are rated at a 20-degree slope (instead of vertical), but
@@ -1238,7 +1156,7 @@ class Constructions
       # by 1.20." Thus we divide by 1.2 to get the vertical position value.
       ufactor /= 1.2
     end
-    glaz_mat = GlazingMaterial.new("#{type}Material", ufactor, shgc * heat_shade_mult)
+    glaz_mat = GlazingMaterial.new("#{type}Material", ufactor, shgc)
 
     # Set paths
     path_fracs = [1]
@@ -1248,7 +1166,458 @@ class Constructions
     constr.add_layer(glaz_mat)
 
     # Create and assign construction to subsurfaces
-    constr.create_and_assign_constructions(runner, subsurfaces, model)
+    constr.create_and_assign_constructions(runner, [subsurface], model)
+  end
+
+  def self.apply_window_skylight_shading(model, window_or_skylight, index, shading_vertices, parent_surface, sub_surface, shading_group,
+                                         shading_schedules, shading_ems, name, cooling_season)
+    sf_summer = window_or_skylight.interior_shading_factor_summer * window_or_skylight.exterior_shading_factor_summer
+    sf_winter = window_or_skylight.interior_shading_factor_winter * window_or_skylight.exterior_shading_factor_winter
+    if (sf_summer < 1.0) || (sf_winter < 1.0)
+      # Apply shading
+      # We use a ShadingSurface instead of a Shade so that we perfectly get the result we want.
+      # The latter object is complex and it is essentially impossible to achieve the target reduction in transmitted
+      # solar (due to, e.g., re-reflectance, absorptance, angle modifiers, effects on convection, etc.).
+
+      # Shading surface is used to reduce beam solar and sky diffuse solar
+      shading_surface = OpenStudio::Model::ShadingSurface.new(shading_vertices, model)
+      shading_surface.setName("#{window_or_skylight.id} shading surface")
+      shading_surface.additionalProperties.setFeature('Azimuth', window_or_skylight.azimuth)
+      shading_surface.additionalProperties.setFeature('ParentSurface', parent_surface.name.to_s)
+
+      # Create transmittance schedule for heating/cooling seasons
+      trans_values = cooling_season.map { |c| c == 1 ? sf_summer : sf_winter }
+      if shading_schedules[trans_values].nil?
+        trans_sch = MonthWeekdayWeekendSchedule.new(model, "trans schedule winter=#{sf_winter} summer=#{sf_summer}", Array.new(24, 1), Array.new(24, 1), trans_values, Constants.ScheduleTypeLimitsFraction, false)
+        shading_schedules[trans_values] = trans_sch
+      end
+      shading_surface.setTransmittanceSchedule(shading_schedules[trans_values].schedule)
+
+      # EMS to actuate view factor to ground
+      sub_surface_type = sub_surface.subSurfaceType.downcase.to_s
+      actuator = OpenStudio::Model::EnergyManagementSystemActuator.new(sub_surface, *EPlus::EMSActuatorSurfaceViewFactorToGround)
+      actuator.setName("#{sub_surface_type}#{index}_actuator")
+
+      if shading_ems[:sensors][trans_values].nil?
+        shading_schedule_name = shading_schedules[trans_values].schedule.name.to_s
+        shading_coeff_sensor = OpenStudio::Model::EnergyManagementSystemSensor.new(model, 'Schedule Value')
+        shading_coeff_sensor.setName("#{sub_surface_type}_shading_coefficient")
+        shading_coeff_sensor.setKeyName(shading_schedule_name)
+        shading_ems[:sensors][trans_values] = shading_coeff_sensor
+      end
+
+      default_vf_to_ground = ((1.0 - Math::cos(sub_surface.tilt)) / 2.0).round(2)
+      shading_coeff = shading_ems[:sensors][trans_values].name
+      if shading_ems[:program].nil?
+        program = OpenStudio::Model::EnergyManagementSystemProgram.new(model)
+        program.setName("#{sub_surface_type}_view_factor_to_ground_program")
+        program.addLine("Set #{actuator.name} = #{default_vf_to_ground}*#{shading_coeff}")
+        shading_ems[:program] = program
+
+        program_cm = OpenStudio::Model::EnergyManagementSystemProgramCallingManager.new(model)
+        program_cm.setName("#{program.name} calling manager")
+        program_cm.setCallingPoint('BeginZoneTimestepAfterInitHeatBalance') # https://github.com/NREL/EnergyPlus/pull/8477#discussion_r567320478
+        program_cm.addProgram(program)
+      else
+        shading_ems[:program].addLine("Set #{actuator.name} = #{default_vf_to_ground}*#{shading_coeff}")
+      end
+
+      if shading_group.nil?
+        shading_group = OpenStudio::Model::ShadingSurfaceGroup.new(model)
+        shading_group.setName(name)
+      end
+      shading_surface.setShadingSurfaceGroup(shading_group)
+    end
+    return shading_group
+  end
+
+  def self.calc_non_cavity_r(film_r, constr_set)
+    # Calculate R-value for all non-cavity layers
+    non_cavity_r = film_r
+    if not constr_set.exterior_material.nil?
+      non_cavity_r += constr_set.exterior_material.rvalue
+    end
+    if not constr_set.rigid_r.nil?
+      non_cavity_r += constr_set.rigid_r
+    end
+    if not constr_set.osb_thick_in.nil?
+      non_cavity_r += Material.Plywood(constr_set.osb_thick_in).rvalue
+    end
+    if not constr_set.drywall_thick_in.nil?
+      non_cavity_r += Material.GypsumWall(constr_set.drywall_thick_in).rvalue
+    end
+    return non_cavity_r
+  end
+
+  def self.apply_wall_construction(runner, model, surfaces, wall, wall_id, wall_type, assembly_r,
+                                   drywall_thick_in, inside_film, outside_film, mat_ext_finish)
+
+    film_r = inside_film.rvalue + outside_film.rvalue
+    if mat_ext_finish.nil?
+      fallback_mat_ext_finish = nil
+    else
+      fallback_mat_ext_finish = Material.ExteriorFinishMaterial(mat_ext_finish.name, mat_ext_finish.tAbs, mat_ext_finish.sAbs, 0.1)
+    end
+
+    if wall_type == HPXML::WallTypeWoodStud
+      install_grade = 1
+      cavity_filled = true
+
+      constr_sets = [
+        WoodStudConstructionSet.new(Material.Stud2x6, 0.20, 20.0, 0.5, drywall_thick_in, mat_ext_finish), # 2x6, 24" o.c. + R20
+        WoodStudConstructionSet.new(Material.Stud2x6, 0.20, 10.0, 0.5, drywall_thick_in, mat_ext_finish), # 2x6, 24" o.c. + R10
+        WoodStudConstructionSet.new(Material.Stud2x6, 0.20, 0.0, 0.5, drywall_thick_in, mat_ext_finish),  # 2x6, 24" o.c.
+        WoodStudConstructionSet.new(Material.Stud2x4, 0.23, 0.0, 0.5, drywall_thick_in, mat_ext_finish),  # 2x4, 16" o.c.
+        WoodStudConstructionSet.new(Material.Stud2x4, 0.01, 0.0, 0.0, 0.0, fallback_mat_ext_finish),      # Fallback
+      ]
+      match, constr_set, cavity_r = pick_wood_stud_construction_set(assembly_r, constr_sets, inside_film, outside_film, wall_id)
+
+      apply_wood_stud_wall(runner, model, surfaces, wall, "#{wall_id} construction",
+                           cavity_r, install_grade, constr_set.stud.thick_in,
+                           cavity_filled, constr_set.framing_factor,
+                           constr_set.drywall_thick_in, constr_set.osb_thick_in,
+                           constr_set.rigid_r, constr_set.exterior_material,
+                           0, inside_film, outside_film)
+    elsif wall_type == HPXML::WallTypeSteelStud
+      install_grade = 1
+      cavity_filled = true
+      corr_factor = 0.45
+
+      constr_sets = [
+        SteelStudConstructionSet.new(5.5, corr_factor, 0.20, 10.0, 0.5, drywall_thick_in, mat_ext_finish), # 2x6, 24" o.c. + R20
+        SteelStudConstructionSet.new(5.5, corr_factor, 0.20, 10.0, 0.5, drywall_thick_in, mat_ext_finish), # 2x6, 24" o.c. + R10
+        SteelStudConstructionSet.new(5.5, corr_factor, 0.20, 0.0, 0.5, drywall_thick_in, mat_ext_finish),  # 2x6, 24" o.c.
+        SteelStudConstructionSet.new(3.5, corr_factor, 0.23, 0.0, 0.5, drywall_thick_in, mat_ext_finish),  # 2x4, 16" o.c.
+        SteelStudConstructionSet.new(3.5, 1.0, 0.01, 0.0, 0.0, 0.0, fallback_mat_ext_finish),              # Fallback
+      ]
+      match, constr_set, cavity_r = pick_steel_stud_construction_set(assembly_r, constr_sets, inside_film, outside_film, wall_id)
+
+      apply_steel_stud_wall(runner, model, surfaces, wall, "#{wall_id} construction",
+                            cavity_r, install_grade, constr_set.cavity_thick_in,
+                            cavity_filled, constr_set.framing_factor,
+                            constr_set.corr_factor, constr_set.drywall_thick_in,
+                            constr_set.osb_thick_in, constr_set.rigid_r,
+                            constr_set.exterior_material, inside_film, outside_film)
+    elsif wall_type == HPXML::WallTypeDoubleWoodStud
+      install_grade = 1
+      is_staggered = false
+
+      constr_sets = [
+        DoubleStudConstructionSet.new(Material.Stud2x4, 0.23, 24.0, 0.0, 0.5, drywall_thick_in, mat_ext_finish),  # 2x4, 24" o.c.
+        DoubleStudConstructionSet.new(Material.Stud2x4, 0.01, 16.0, 0.0, 0.0, 0.0, fallback_mat_ext_finish),      # Fallback
+      ]
+      match, constr_set, cavity_r = pick_double_stud_construction_set(assembly_r, constr_sets, inside_film, outside_film, wall_id)
+
+      apply_double_stud_wall(runner, model, surfaces, wall, "#{wall_id} construction",
+                             cavity_r, install_grade, constr_set.stud.thick_in,
+                             constr_set.stud.thick_in, constr_set.framing_factor,
+                             constr_set.framing_spacing, is_staggered,
+                             constr_set.drywall_thick_in, constr_set.osb_thick_in,
+                             constr_set.rigid_r, constr_set.exterior_material,
+                             inside_film, outside_film)
+    elsif wall_type == HPXML::WallTypeCMU
+      density = 119.0 # lb/ft^3
+      furring_r = 0
+      furring_cavity_depth_in = 0 # in
+      furring_spacing = 0
+
+      constr_sets = [
+        CMUConstructionSet.new(8.0, 1.4, 0.08, 0.5, drywall_thick_in, mat_ext_finish),  # 8" perlite-filled CMU
+        CMUConstructionSet.new(6.0, 5.29, 0.01, 0.0, 0.0, fallback_mat_ext_finish),     # Fallback (6" hollow CMU)
+      ]
+      match, constr_set, rigid_r = pick_cmu_construction_set(assembly_r, constr_sets, inside_film, outside_film, wall_id)
+
+      apply_cmu_wall(runner, model, surfaces, wall, "#{wall_id} construction",
+                     constr_set.thick_in, constr_set.cond_in, density,
+                     constr_set.framing_factor, furring_r,
+                     furring_cavity_depth_in, furring_spacing,
+                     constr_set.drywall_thick_in, constr_set.osb_thick_in,
+                     rigid_r, constr_set.exterior_material, inside_film,
+                     outside_film)
+    elsif wall_type == HPXML::WallTypeSIP
+      sheathing_thick_in = 0.44
+
+      constr_sets = [
+        SIPConstructionSet.new(10.0, 0.16, 0.0, sheathing_thick_in, 0.5, drywall_thick_in, mat_ext_finish), # 10" SIP core
+        SIPConstructionSet.new(5.0, 0.16, 0.0, sheathing_thick_in, 0.5, drywall_thick_in, mat_ext_finish),  # 5" SIP core
+        SIPConstructionSet.new(1.0, 0.01, 0.0, sheathing_thick_in, 0.0, 0.0, fallback_mat_ext_finish),      # Fallback
+      ]
+      match, constr_set, cavity_r = pick_sip_construction_set(assembly_r, constr_sets, inside_film, outside_film, wall_id)
+
+      apply_sip_wall(runner, model, surfaces, wall, "#{wall_id} construction",
+                     cavity_r, constr_set.thick_in, constr_set.framing_factor,
+                     constr_set.sheath_thick_in, constr_set.drywall_thick_in,
+                     constr_set.osb_thick_in, constr_set.rigid_r,
+                     constr_set.exterior_material, inside_film, outside_film)
+    elsif wall_type == HPXML::WallTypeICF
+      constr_sets = [
+        ICFConstructionSet.new(2.0, 4.0, 0.08, 0.0, 0.5, drywall_thick_in, mat_ext_finish), # ICF w/4" concrete and 2" rigid ins layers
+        ICFConstructionSet.new(1.0, 1.0, 0.01, 0.0, 0.0, 0.0, fallback_mat_ext_finish),     # Fallback
+      ]
+      match, constr_set, icf_r = pick_icf_construction_set(assembly_r, constr_sets, inside_film, outside_film, wall_id)
+
+      apply_icf_wall(runner, model, surfaces, wall, "#{wall_id} construction",
+                     icf_r, constr_set.ins_thick_in,
+                     constr_set.concrete_thick_in, 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)
+    elsif [HPXML::WallTypeConcrete, HPXML::WallTypeBrick, HPXML::WallTypeAdobe, HPXML::WallTypeStrawBale, HPXML::WallTypeStone, HPXML::WallTypeLog].include? wall_type
+      constr_sets = [
+        GenericConstructionSet.new(10.0, 0.5, drywall_thick_in, mat_ext_finish), # w/R-10 rigid
+        GenericConstructionSet.new(0.0, 0.5, drywall_thick_in, mat_ext_finish),  # Standard
+        GenericConstructionSet.new(0.0, 0.0, 0.0, fallback_mat_ext_finish),      # Fallback
+      ]
+      match, constr_set, layer_r = pick_generic_construction_set(assembly_r, constr_sets, inside_film, outside_film, wall_id)
+
+      if wall_type == HPXML::WallTypeConcrete
+        thick_in = 6.0
+        base_mat = BaseMaterial.Concrete
+      elsif wall_type == HPXML::WallTypeBrick
+        thick_in = 8.0
+        base_mat = BaseMaterial.Brick
+      elsif wall_type == HPXML::WallTypeAdobe
+        thick_in = 10.0
+        base_mat = BaseMaterial.Soil
+      elsif wall_type == HPXML::WallTypeStrawBale
+        thick_in = 23.0
+        base_mat = BaseMaterial.StrawBale
+      elsif wall_type == HPXML::WallTypeStone
+        thick_in = 6.0
+        base_mat = BaseMaterial.Stone
+      elsif wall_type == HPXML::WallTypeLog
+        thick_in = 6.0
+        base_mat = BaseMaterial.Wood
+      end
+      thick_ins = [thick_in]
+      if layer_r == 0
+        conds = [99]
+      else
+        conds = [thick_in / layer_r]
+      end
+      denss = [base_mat.rho]
+      specheats = [base_mat.cp]
+
+      apply_generic_layered_wall(runner, model, surfaces, wall, "#{wall_id} construction",
+                                 thick_ins, conds, denss, specheats,
+                                 constr_set.drywall_thick_in, constr_set.osb_thick_in,
+                                 constr_set.rigid_r, constr_set.exterior_material,
+                                 inside_film, outside_film)
+    else
+      fail "Unexpected wall type '#{wall_type}'."
+    end
+
+    check_surface_assembly_rvalue(runner, surfaces, inside_film, outside_film, assembly_r, match)
+  end
+
+  def self.pick_wood_stud_construction_set(assembly_r, constr_sets, inside_film, outside_film, surface_name)
+    # Picks a construction set from supplied constr_sets for which a positive R-value
+    # can be calculated for the unknown insulation to achieve the assembly R-value.
+
+    constr_sets.each do |constr_set|
+      fail 'Unexpected object.' unless constr_set.is_a? WoodStudConstructionSet
+
+      film_r = inside_film.rvalue + outside_film.rvalue
+      non_cavity_r = calc_non_cavity_r(film_r, constr_set)
+
+      # Calculate effective cavity R-value
+      # Assumes installation quality 1
+      cavity_frac = 1.0 - constr_set.framing_factor
+      cavity_r = cavity_frac / (1.0 / assembly_r - constr_set.framing_factor / (constr_set.stud.rvalue + non_cavity_r)) - non_cavity_r
+      if cavity_r > 0 # Choose this construction set
+        return true, constr_set, cavity_r
+      end
+    end
+
+    return false, constr_sets[-1], 0.0 # Pick fallback construction with minimum R-value
+  end
+
+  def self.pick_steel_stud_construction_set(assembly_r, constr_sets, inside_film, outside_film, surface_name)
+    # Picks a construction set from supplied constr_sets for which a positive R-value
+    # can be calculated for the unknown insulation to achieve the assembly R-value.
+
+    constr_sets.each do |constr_set|
+      fail 'Unexpected object.' unless constr_set.is_a? SteelStudConstructionSet
+
+      film_r = inside_film.rvalue + outside_film.rvalue
+      non_cavity_r = calc_non_cavity_r(film_r, constr_set)
+
+      # Calculate effective cavity R-value
+      # Assumes installation quality 1
+      cavity_r = (assembly_r - non_cavity_r) / constr_set.corr_factor
+      if cavity_r > 0 # Choose this construction set
+        return true, constr_set, cavity_r
+      end
+    end
+
+    return false, constr_sets[-1], 0.0 # Pick fallback construction with minimum R-value
+  end
+
+  def self.pick_double_stud_construction_set(assembly_r, constr_sets, inside_film, outside_film, surface_name)
+    # Picks a construction set from supplied constr_sets for which a positive R-value
+    # can be calculated for the unknown insulation to achieve the assembly R-value.
+
+    constr_sets.each do |constr_set|
+      fail 'Unexpected object.' unless constr_set.is_a? DoubleStudConstructionSet
+
+      film_r = inside_film.rvalue + outside_film.rvalue
+      non_cavity_r = calc_non_cavity_r(film_r, constr_set)
+
+      # Calculate effective cavity R-value
+      # Assumes installation quality 1, not staggered, gap depth == stud depth
+      # Solved in Wolfram Alpha: https://www.wolframalpha.com/input/?i=1%2FA+%3D+B%2F(2*C%2Bx%2BD)+%2B+E%2F(3*C%2BD)+%2B+(1-B-E)%2F(3*x%2BD)
+      stud_frac = 1.5 / constr_set.framing_spacing
+      misc_framing_factor = constr_set.framing_factor - stud_frac
+      cavity_frac = 1.0 - (2 * stud_frac + misc_framing_factor)
+      a = assembly_r
+      b = stud_frac
+      c = constr_set.stud.rvalue
+      d = non_cavity_r
+      e = misc_framing_factor
+      cavity_r = ((3 * c + d) * Math.sqrt(4 * a**2 * b**2 + 12 * a**2 * b * e + 4 * a**2 * b + 9 * a**2 * e**2 - 6 * a**2 * e + a**2 - 48 * a * b * c - 16 * a * b * d - 36 * a * c * e + 12 * a * c - 12 * a * d * e + 4 * a * d + 36 * c**2 + 24 * c * d + 4 * d**2) + 6 * a * b * c + 2 * a * b * d + 3 * a * c * e + 3 * a * c + 3 * a * d * e + a * d - 18 * c**2 - 18 * c * d - 4 * d**2) / (2 * (-3 * a * e + 9 * c + 3 * d))
+      cavity_r = 3 * cavity_r
+      if cavity_r > 0 # Choose this construction set
+        return true, constr_set, cavity_r
+      end
+    end
+
+    return false, constr_sets[-1], 0.0 # Pick fallback construction with minimum R-value
+  end
+
+  def self.pick_sip_construction_set(assembly_r, constr_sets, inside_film, outside_film, surface_name)
+    # Picks a construction set from supplied constr_sets for which a positive R-value
+    # can be calculated for the unknown insulation to achieve the assembly R-value.
+
+    constr_sets.each do |constr_set|
+      fail 'Unexpected object.' unless constr_set.is_a? SIPConstructionSet
+
+      film_r = inside_film.rvalue + outside_film.rvalue
+      non_cavity_r = calc_non_cavity_r(film_r, constr_set)
+      non_cavity_r += Material.new(nil, constr_set.sheath_thick_in, BaseMaterial.Wood).rvalue
+
+      # Calculate effective SIP core R-value
+      # Solved in Wolfram Alpha: https://www.wolframalpha.com/input/?i=1%2FA+%3D+B%2F(C%2BD)+%2B+E%2F(2*F%2BG%2FH*x%2BD)+%2B+(1-B-E)%2F(x%2BD)
+      spline_thick_in = 0.5 # in
+      ins_thick_in = constr_set.thick_in - (2.0 * spline_thick_in) # in
+      framing_r = Material.new(nil, constr_set.thick_in, BaseMaterial.Wood).rvalue
+      spline_r = Material.new(nil, spline_thick_in, BaseMaterial.Wood).rvalue
+      spline_frac = 4.0 / 48.0 # One 4" spline for every 48" wide panel
+      cavity_frac = 1.0 - (spline_frac + constr_set.framing_factor)
+      a = assembly_r
+      b = constr_set.framing_factor
+      c = framing_r
+      d = non_cavity_r
+      e = spline_frac
+      f = spline_r
+      g = ins_thick_in
+      h = constr_set.thick_in
+      cavity_r = (Math.sqrt((a * b * c * g - a * b * d * h - 2 * a * b * f * h + a * c * e * g - a * c * e * h - a * c * g + a * d * e * g - a * d * e * h - a * d * g + c * d * g + c * d * h + 2 * c * f * h + d**2 * g + d**2 * h + 2 * d * f * h)**2 - 4 * (-a * b * g + c * g + d * g) * (a * b * c * d * h + 2 * a * b * c * f * h - a * c * d * h + 2 * a * c * e * f * h - 2 * a * c * f * h - a * d**2 * h + 2 * a * d * e * f * h - 2 * a * d * f * h + c * d**2 * h + 2 * c * d * f * h + d**3 * h + 2 * d**2 * f * h)) - a * b * c * g + a * b * d * h + 2 * a * b * f * h - a * c * e * g + a * c * e * h + a * c * g - a * d * e * g + a * d * e * h + a * d * g - c * d * g - c * d * h - 2 * c * f * h - g * d**2 - d**2 * h - 2 * d * f * h) / (2 * (-a * b * g + c * g + d * g))
+      if cavity_r > 0 # Choose this construction set
+        return true, constr_set, cavity_r
+      end
+    end
+
+    return false, constr_sets[-1], 0.0 # Pick fallback construction with minimum R-value
+  end
+
+  def self.pick_cmu_construction_set(assembly_r, constr_sets, inside_film, outside_film, surface_name)
+    # Picks a construction set from supplied constr_sets for which a positive R-value
+    # can be calculated for the unknown insulation to achieve the assembly R-value.
+
+    constr_sets.each do |constr_set|
+      fail 'Unexpected object.' unless constr_set.is_a? CMUConstructionSet
+
+      film_r = inside_film.rvalue + outside_film.rvalue
+      non_cavity_r = calc_non_cavity_r(film_r, constr_set)
+
+      # Calculate effective other CMU R-value
+      # Assumes no furring strips
+      # Solved in Wolfram Alpha: https://www.wolframalpha.com/input/?i=1%2FA+%3D+B%2F(C%2BE%2Bx)+%2B+(1-B)%2F(D%2BE%2Bx)
+      a = assembly_r
+      b = constr_set.framing_factor
+      c = Material.new(nil, constr_set.thick_in, BaseMaterial.Wood).rvalue # Framing
+      d = Material.new(nil, constr_set.thick_in, BaseMaterial.Concrete, constr_set.cond_in).rvalue # Concrete
+      e = non_cavity_r
+      rigid_r = 0.5 * (Math.sqrt(a**2 - 4 * a * b * c + 4 * a * b * d + 2 * a * c - 2 * a * d + c**2 - 2 * c * d + d**2) + a - c - d - 2 * e)
+      if rigid_r > 0 # Choose this construction set
+        return true, constr_set, rigid_r
+      end
+    end
+
+    return false, constr_sets[-1], 0.0 # Pick fallback construction with minimum R-value
+  end
+
+  def self.pick_icf_construction_set(assembly_r, constr_sets, inside_film, outside_film, surface_name)
+    # Picks a construction set from supplied constr_sets for which a positive R-value
+    # can be calculated for the unknown insulation to achieve the assembly R-value.
+
+    constr_sets.each do |constr_set|
+      fail 'Unexpected object.' unless constr_set.is_a? ICFConstructionSet
+
+      film_r = inside_film.rvalue + outside_film.rvalue
+      non_cavity_r = calc_non_cavity_r(film_r, constr_set)
+
+      # Calculate effective ICF rigid ins R-value
+      # Solved in Wolfram Alpha: https://www.wolframalpha.com/input/?i=1%2FA+%3D+B%2F(C%2BE)+%2B+(1-B)%2F(D%2BE%2B2*x)
+      a = assembly_r
+      b = constr_set.framing_factor
+      c = Material.new(nil, 2 * constr_set.ins_thick_in + constr_set.concrete_thick_in, BaseMaterial.Wood).rvalue # Framing
+      d = Material.new(nil, constr_set.concrete_thick_in, BaseMaterial.Concrete).rvalue # Concrete
+      e = non_cavity_r
+      icf_r = (a * b * c - a * b * d - a * c - a * e + c * d + c * e + d * e + e**2) / (2 * (a * b - c - e))
+      if icf_r > 0 # Choose this construction set
+        return true, constr_set, icf_r
+      end
+    end
+
+    return false, constr_sets[-1], 0.0 # Pick fallback construction with minimum R-value
+  end
+
+  def self.pick_generic_construction_set(assembly_r, constr_sets, inside_film, outside_film, surface_name)
+    # Picks a construction set from supplied constr_sets for which a positive R-value
+    # can be calculated for the unknown insulation to achieve the assembly R-value.
+
+    constr_sets.each do |constr_set|
+      fail 'Unexpected object.' unless constr_set.is_a? GenericConstructionSet
+
+      film_r = inside_film.rvalue + outside_film.rvalue
+      non_cavity_r = calc_non_cavity_r(film_r, constr_set)
+
+      # Calculate effective ins layer R-value
+      layer_r = assembly_r - non_cavity_r
+      if layer_r > 0 # Choose this construction set
+        return true, constr_set, layer_r
+      end
+    end
+
+    return false, constr_sets[-1], 0.0 # Pick fallback construction with minimum R-value
+  end
+
+  def self.check_surface_assembly_rvalue(runner, surfaces, inside_film, outside_film, assembly_r, match)
+    # Verify that the actual OpenStudio construction R-value matches our target assembly R-value
+
+    film_r = 0.0
+    film_r += inside_film.rvalue unless inside_film.nil?
+    film_r += outside_film.rvalue unless outside_film.nil?
+    surfaces.each do |surface|
+      constr_r = UnitConversions.convert(1.0 / surface.construction.get.uFactor(0.0).get, 'm^2*k/w', 'hr*ft^2*f/btu') + film_r
+
+      if surface.adjacentFoundation.is_initialized
+        foundation = surface.adjacentFoundation.get
+        foundation.customBlocks.each do |custom_block|
+          ins_mat = custom_block.material.to_StandardOpaqueMaterial.get
+          constr_r += UnitConversions.convert(ins_mat.thickness, 'm', 'ft') / UnitConversions.convert(ins_mat.thermalConductivity, 'W/(m*K)', 'Btu/(hr*ft*R)')
+        end
+      end
+
+      if (assembly_r - constr_r).abs > 0.1
+        if match
+          fail "Construction R-value (#{constr_r}) does not match Assembly R-value (#{assembly_r}) for '#{surface.name}'."
+        else
+          runner.registerWarning("Assembly R-value (#{assembly_r}) for '#{surface.name}' below minimum expected value. Construction R-value increased to #{constr_r.round(2)}.")
+        end
+      end
+    end
   end
 end
 
@@ -1566,3 +1935,90 @@ class Construction
     return mat
   end
 end
+
+class WoodStudConstructionSet
+  def initialize(stud, framing_factor, rigid_r, osb_thick_in, drywall_thick_in, exterior_material)
+    @stud = stud
+    @framing_factor = framing_factor
+    @rigid_r = rigid_r
+    @osb_thick_in = osb_thick_in
+    @drywall_thick_in = drywall_thick_in
+    @exterior_material = exterior_material
+  end
+  attr_accessor(:stud, :framing_factor, :rigid_r, :osb_thick_in, :drywall_thick_in, :exterior_material)
+end
+
+class SteelStudConstructionSet
+  def initialize(cavity_thick_in, corr_factor, framing_factor, rigid_r, osb_thick_in, drywall_thick_in, exterior_material)
+    @cavity_thick_in = cavity_thick_in
+    @corr_factor = corr_factor
+    @framing_factor = framing_factor
+    @rigid_r = rigid_r
+    @osb_thick_in = osb_thick_in
+    @drywall_thick_in = drywall_thick_in
+    @exterior_material = exterior_material
+  end
+  attr_accessor(:cavity_thick_in, :corr_factor, :framing_factor, :rigid_r, :osb_thick_in, :drywall_thick_in, :exterior_material)
+end
+
+class DoubleStudConstructionSet
+  def initialize(stud, framing_factor, framing_spacing, rigid_r, osb_thick_in, drywall_thick_in, exterior_material)
+    @stud = stud
+    @framing_factor = framing_factor
+    @framing_spacing = framing_spacing
+    @rigid_r = rigid_r
+    @osb_thick_in = osb_thick_in
+    @drywall_thick_in = drywall_thick_in
+    @exterior_material = exterior_material
+  end
+  attr_accessor(:stud, :framing_factor, :framing_spacing, :rigid_r, :osb_thick_in, :drywall_thick_in, :exterior_material)
+end
+
+class SIPConstructionSet
+  def initialize(thick_in, framing_factor, rigid_r, sheath_thick_in, osb_thick_in, drywall_thick_in, exterior_material)
+    @thick_in = thick_in
+    @framing_factor = framing_factor
+    @rigid_r = rigid_r
+    @sheath_thick_in = sheath_thick_in
+    @osb_thick_in = osb_thick_in
+    @drywall_thick_in = drywall_thick_in
+    @exterior_material = exterior_material
+  end
+  attr_accessor(:thick_in, :framing_factor, :rigid_r, :sheath_thick_in, :osb_thick_in, :drywall_thick_in, :exterior_material)
+end
+
+class CMUConstructionSet
+  def initialize(thick_in, cond_in, framing_factor, osb_thick_in, drywall_thick_in, exterior_material)
+    @thick_in = thick_in
+    @cond_in = cond_in
+    @framing_factor = framing_factor
+    @osb_thick_in = osb_thick_in
+    @drywall_thick_in = drywall_thick_in
+    @exterior_material = exterior_material
+    @rigid_r = nil # solved for
+  end
+  attr_accessor(:thick_in, :cond_in, :framing_factor, :rigid_r, :osb_thick_in, :drywall_thick_in, :exterior_material)
+end
+
+class ICFConstructionSet
+  def initialize(ins_thick_in, concrete_thick_in, framing_factor, rigid_r, osb_thick_in, drywall_thick_in, exterior_material)
+    @ins_thick_in = ins_thick_in
+    @concrete_thick_in = concrete_thick_in
+    @framing_factor = framing_factor
+    @rigid_r = rigid_r
+    @osb_thick_in = osb_thick_in
+    @drywall_thick_in = drywall_thick_in
+    @exterior_material = exterior_material
+  end
+  attr_accessor(:ins_thick_in, :concrete_thick_in, :framing_factor, :rigid_r, :osb_thick_in, :drywall_thick_in, :exterior_material)
+end
+
+class GenericConstructionSet
+  def initialize(rigid_r, osb_thick_in, drywall_thick_in, exterior_material)
+    @rigid_r = rigid_r
+    @osb_thick_in = osb_thick_in
+    @drywall_thick_in = drywall_thick_in
+    @exterior_material = exterior_material
+  end
+  attr_accessor(:rigid_r, :osb_thick_in, :drywall_thick_in, :exterior_material)
+end