urbanopt-cli 0.4.1 → 0.6.1

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

@@ -0,0 +1,249 @@
+## OpenStudio-HPXML v1.2.0 (Pending)
+
+__New Features__
+- Updates to OpenStudio 3.2.0/EnergyPlus 9.5.0.
+- **Breaking change**: Heating/cooling component loads no longer calculated by default for faster performance; use `--add-component-loads` argument if desired.
+- **Breaking change**: Replaces `Site/extension/ShelterCoefficient` with `Site/ShieldingofHome`.
+- **Breaking change**: `AirDistributionType` is now required for all air distribution systems.
+- Allows additional fuel types for generators.
+- Allows `DuctLeakageMeasurement` & `ConditionedFloorAreaServed` to not be specified for ductless fan coil systems.
+- Allows `Slab/ExposedPerimeter` to be zero.
+- Removes `ClothesDryer/ControlType` from being a required input, it is not used.
+- Switches room air conditioner model to use Cutler performance curves.
+- Adds an `--ep-input-format` argument to run_simulation.rb to choose epJSON as the EnergyPlus input file format instead of IDF.
+- Relaxes tolerance for duct leakage to outside warning when ducts solely in conditioned space.
+- Moves additional error-checking from the ruby measure to the schematron validator. 
+
+__Bugfixes__
+- Improves ground reflectance when there is shading of windows/skylights.
+- Fixes room air conditioner performance curve.
+- Fixes ruby error if elements (e.g., `SystemIdentifier`) exist without the proper 'id'/'idref' attribute.
+- Fixes error if boiler/GSHP pump power is zero
+- Fixes possible "Electricity category end uses do not sum to total" error due to boiler pump energy.
+- Fixes possible "Construction R-value ... does not match Assembly R-value" error for highly insulated enclosure elements.
+- Adds error-checking for negative SEEReq results for shared cooling systems.
+- Adds more detail to error messages regarding the wrong data type in the HPXML file.
+- Prevents a solar hot water system w/ SolarFraction=1.
+
+## OpenStudio-HPXML v1.1.0
+
+__New Features__
+- **Breaking change**: `Type` is now a required input for dehumidifiers; can be "portable" or "whole-home".
+- **Breaking change**: `Location` is now a required input for dehumidifiers; must be "living space" as dehumidifiers are currently modeled as located in living space.
+- **Breaking change**: `Type` is now a required input for Pool, PoolPump, HotTub, and HotTubPump.
+- **Breaking change**: Both supply and return duct leakage to outside are now required inputs for AirDistribution systems.
+- **Breaking change**: Simplifies inputs for fan coils and water loop heat pumps by A) removing HydronicAndAirDistribution element and B) moving WLHP inputs from extension elements to HeatPump element.
+- Allows modeling airflow/charge defects for air conditioners, heat pumps, and furnaces (RESNET Standard 310).
+- Allows modeling *multiple* dehumidifiers (previously only one allowed).
+- Allows modeling generators (generic on-site power production).
+- Allows detailed heating/cooling setpoints to be specified: 24-hour weekday & weekend values.
+- Allows modeling window/skylight *exterior* shading via summer/winter shading coefficients.
+- Allows JSON annual/timeseries output files to be generated instead of CSV. **Breaking change**: For CSV outputs, the first two sections in the results_annual.csv file are now prefixed with "Fuel Use:" and "End Use:", respectively.
+- Allows more defaulting (optional inputs) for a variety of HPXML elements.
+- Allows requesting timeseries unmet heating/cooling loads.
+- Allows skipping schema/schematron validation (for speed); should only be used if the HPXML was already validated upstream.
+- Allows HPXML files w/ multiple `Building` elements; requires providing the ID of the single building to be simulated.
+- Includes hot water loads (in addition to heating/cooling loads) when timeseries total loads are requested.
+- The `in.xml` HPXML file is now always produced for inspection of default values (e.g., autosized HVAC capacities). **Breaking change**: The `output_dir` HPXMLtoOpenStudio measure argument is now required.
+- Overhauls documentation to be more comprehensive and standardized.
+- `run_simulation.rb` now returns exit code 1 if not successful (i.e., either invalid inputs or simulation fails).
+
+__Bugfixes__
+- Improved modeling of window/skylight interior shading -- better reflects shading coefficient inputs.
+- Adds error-checking on the HPXML schemaVersion.
+- Adds various error-checking to the schematron validator.
+- Adds error-checking for empty IDs in the HPXML file.
+- Fixes heat pump water heater fan energy not included in SimulationOutputReport outputs.
+- Fixes possibility of incorrect "A neighbor building has an azimuth (XXX) not equal to the azimuth of any wall" error.
+- Fixes possibility of errors encountered before schematron validation has occurred.
+- Small bugfixes related to basement interior surface solar absorptances.
+- Allows NumberofConditionedFloors/NumberofConditionedFloorsAboveGrade to be non-integer values per the HPXML schema.
+- HVAC sizing design load improvements for floors above crawlspaces/basements, walls, ducts, and heat pumps.
+- Now recognizes Type="none" to prevent modeling of pools and hot tubs (pumps and heaters).
+- Fixes error for overhangs with zero depth.
+- Fixes possible error where the normalized flue height for the AIM-2 infiltration model is negative.
+- Slight adjustment of default water heater recovery efficiency equation to prevent errors from values being too high.
+- Fixes schematron file not being valid per ISO Schematron standard.
+
+## OpenStudio-HPXML v1.0.0
+
+__New Features__
+- Updates to OpenStudio 3.1.0/EnergyPlus 9.4.0.
+- **Breaking change**: Deprecates `WeatherStation/WMO` HPXML input, use `WeatherStation/extension/EPWFilePath` instead; also removes `weather_dir` argument from HPXMLtoOpenStudio measure.
+- Implements water heater Uniform Energy Factor (UEF) model; replaces RESNET UEF->EF regression. **Breaking change**: `FirstHourRating` is now a required input for storage water heaters when UEF is provided.
+- Adds optional HPXML fan power inputs for most HVAC system types. **Breaking change**: Removes ElectricAuxiliaryEnergy input for non-boiler heating systems.
+- Uses air-source heat pump cooling performance curves for central air conditioners.
+- Updates rated fan power assumption for mini-split heat pump models.
+- Allows coal fuel type for non-boiler heating systems.
+- Accommodates common walls adjacent to unconditioned space by using HPXML surfaces where InteriorAdjacentTo == ExteriorAdjacentTo.
+- Adds optional HPXML inputs to define whether a clothes dryer is vented and its ventilation rate.
+- Adds optional HPXML input for `SimulationControl/CalendarYear` for TMY weather files.
+- Schematron validation improvements.
+- Adds some HPXML XSD schema validation and additional error-checking.
+- Various small updates to ASHRAE 140 test files.
+- Reduces number of EnergyPlus output files produced by using new OutputControlFiles object.
+- Release packages now include ASHRAE 140 test files/results.
+
+__Bugfixes__
+- EnergyPlus 9.4.0 fix for negative window solar absorptances at certain hours.
+- Fixes airflow timeseries outputs to be averaged instead of summed.
+- Updates HVAC sizing methodology for slab-on-grade foundation types.
+- Fixes an error that could prevent schematron validation errors from being produced.
+- Skips weather caching if filesystem is read only.
+
+## OpenStudio-HPXML v0.11.0 Beta
+
+__New Features__
+- New [Schematron](http://schematron.com) validation (EPvalidator.xml) replaces custom ruby validation (EPvalidator.rb)
+- **[Breaking Change]** `BuildingConstruction/ResidentialFacilityType` ("single-family detached", "single-family attached", "apartment unit", or "manufactured home") is a required input
+- Ability to model shared systems for Attached/Multifamily dwelling units
+  - Shared HVAC systems (cooling towers, chillers, central boilers, water loop heat pumps, fan coils, ground source heat pumps on shared hydronic circulation loops)
+  - Shared water heaters serving either A) multiple dwelling units' service hot water or B) a shared laundry/equipment room, as well as hot water recirculation systems
+  - Shared appliances (e.g., clothes dryer in a shared laundry room)
+  - Shared hot water recirculation systems
+  - Shared ventilation systems (optionally with preconditioning equipment and recirculation)
+  - Shared PV systems
+  - **[Breaking Change]** Appliances located in MF spaces (i.e., "other") must now be specified in more detail (i.e., "other heated space", "other non-freezing space", "other multifamily buffer space", or "other housing unit")
+- Enclosure
+  - New optional inputs: `Roof/RoofType`, `Wall/Siding`, and `RimJoist/Siding`
+  - New optional inputs: `Skylight/InteriorShading/SummerShadingCoefficient` and `Skylight/InteriorShading/SummerShadingCoefficient`
+  - New optional inputs: `Roof/RoofColor`, `Wall/Color`, and `RimJoist/Color` can be provided instead of `SolarAbsorptance`
+  - New optional input to specify presence of flue/chimney, which results in increased infiltration
+  - Allows adobe wall type
+  - Allows `AirInfiltrationMeasurement/HousePressure` to be any value (previously required to be 50 Pa)
+  - **[Breaking Change]** `Roof/RadiantBarrierGrade` input now required when there is a radiant barrier
+- HVAC
+  - Adds optional high-level HVAC autosizing controls
+    - `AllowIncreasedFixedCapacities`: Describes how HVAC equipment with fixed capacities are handled. If true, the maximum of the user-specified fixed capacity and the heating/cooling design load will be used to reduce potential for unmet loads. Defaults to false.
+    - `UseMaxLoadForHeatPumps`: Describes how autosized heat pumps are handled. If true, heat pumps are sized based on the maximum of heating and cooling design loads. If false, heat pumps are sized per ACCA Manual J/S based on cooling design loads with some oversizing allowances for heating design loads. Defaults to true.
+  - Additional HVAC types: mini-split air conditioners and fixed (non-portable) space heaters
+  - Adds optional inputs for ground-to-air heat pumps: `extension/PumpPowerWattsPerTon` and `extension/FanPowerWattsPerCFM`
+- Ventilation
+  - Allows _multiple_ whole-home ventilation, spot ventilation, and/or whole house fans
+- Appliances & Plug Loads
+  - Allows _multiple_ `Refrigerator` and `Freezer`
+  - Allows `Pool`, `HotTub`, `PlugLoad` of type "electric vehicle charging" and "well pump", and `FuelLoad` of type "grill", "lighting", and "fireplace"
+  - **[Breaking Change]** "other" and "TV other" plug loads now required
+- Lighting
+  - Allows lighting schedules and holiday lighting
+- **[Breaking Change]** For hydronic distributions, `HydronicDistributionType` is now required
+- **[Breaking Change]** For DSE distributions, `AnnualHeatingDistributionSystemEfficiency` and `AnnualCoolingDistributionSystemEfficiency` are both always required
+- Allows more HPXML fuel types to be used for HVAC, water heating, appliances, etc.
+- New inputs to define Daylight Saving period; defaults to enabled
+- Adds more reporting of warnings/errors to run.log
+
+__Bugfixes__
+- Fixes pump energy for boilers and ground source heat pumps
+- Fixes incorrect gallons of hot water use reported when there are multiple water heaters
+- No longer report unmet load for buildings where the HVAC system only meets part of the load (e.g., room AC serving 33% of the load)
+- Schedule bugfix for leap years
+
+## OpenStudio-HPXML v0.10.0 Beta
+
+__New Features__
+- Dwelling units of single-family attached/multifamily buildings:
+  - Adds new generic space types "other heated space", "other multifamily buffer space", and "other non-freezing space" for surface `ExteriorAdjacentTo` elements. "other housing unit", i.e. adiabatic surfaces, was already supported.
+  - **[Breaking Change]** For `FrameFloors`, replaces "other housing unit above" and "other housing unit below" enumerations with "other housing unit". All four "other ..." spaces must have an `extension/OtherSpaceAboveOrBelow` property set to either "above" or "below".
+  - Allows ducts and water heaters to be located in all "other ..." spaces.
+  - Allows all appliances to be located in "other", in which internal gains are neglected.
+- Allows `Fireplace` and `FloorFurnace` for heating system types.
+- Allows "exterior wall", "under slab", and "roof deck" for `DuctLocation`.
+- Allows "wood" and "wood pellets" as fuel types for additional HVAC systems, water heaters, and appliances.
+- Allows `Location` to be provided for `Dishwasher` and `CookingRange`.
+- Allows `BuildingSummary/Site/SiteType` ("urban", "suburban", or "rural") to be provided.
+- Allows user-specified `Refrigerator` and `CookingRange` schedules to be provided.
+- HVAC capacity elements are no longer required; if not provided, ACCA Manual J autosizing calculations will be used (-1 can continue to be used for capacity elements but is discouraged).
+- Duct locations/areas can be defaulted by specifying supply/return `Duct` elements without `DuctSurfaceArea` and `DuctLocation`. `HVACDistribution/DistributionSystemType/AirDistribution/NumberofReturnRegisters` can be optionally provided to inform the default duct area calculations.
+- **[Breaking Change]** Lighting inputs now use `LightingType[LightEmittingDiode | CompactFluorescent | FluorescentTube]` instead of `ThirdPartyCertification="ERI Tier I" or ThirdPartyCertification="ERI Tier II"`.
+- **[Breaking Change]** `HVACDistribution/ConditionedFloorAreaServed` is now required for air distribution systems.
+- **[Breaking Change]** Infiltration and attic ventilation specified using natural air changes per hour now uses `ACHnatural` instead of `extension/ConstantACHnatural`.
+- **[Breaking Change]** The optional `PerformanceAdjustment` input for instantaneous water heaters is now treated as a performance multiplier (e.g., 0.92) instead of derate (e.g., 0.08).
+- Adds ASHRAE 140 Class II test files.
+- SimulationOutputReport reporting measure:
+  - New optional timeseries outputs:  airflows (e.g., infiltration, mechanical ventilation, natural ventilation, whole house fan) and weather (e.g., temperatures, wind speed, solar).
+  - Timeseries frequency can now be set to 'none' as an alternative to setting all include_timeseries_foo variables to false.
+  - **[Breaking Change]** Renames "Wood" to "Wood Cord" to better distinguish from "Wood Pellets".
+- Modeling improvements:
+  - Improved calculation for infiltration height
+  - Infiltration & mechanical ventilation now combined using ASHRAE 62.2 Normative Appendix C.
+- Runtime improvements: 
+  - Optimized ruby require calls.
+  - Skip ViewFactor calculations when not needed (i.e., no conditioned basement).
+- Error-checking:
+  - Adds more space type-specific error checking of adjacent surfaces.
+  - Adds additional HPXML datatype checks.
+  - Adds a warning if a `HVACDistribution` system has ducts entirely within conditioned space and non-zero leakage to the outside.
+  - Adds warnings if appliance inputs may be inappropriate and result in negative energy or hot water use.
+
+__Bugfixes__
+- Fixes error if there's a `FoundationWall` whose height is less than 0.5 ft.
+- Fixes HVAC defrost control in EnergyPlus model to use "Timed" instead of "OnDemand".
+- Fixes exterior air film and wind exposure for a `FrameFloor` over ambient conditions.
+- Fixes air films for a `FrameFloor` ceiling.
+- Fixes error if there are additional `LightingGroup` elements beyond the ones required.
+- Fixes vented attic ventilation rate.
+- Reported unmet heating/cooling load now correctly excludes latent energy.
+- Ground-source heat pump backup fuel is now correctly honored instead of always using electricity.
+
+## OpenStudio-HPXML v0.9.0 Beta
+
+__New Features__
+- **[Breaking Change]** Updates to OpenStudio v3.0.0 and EnergyPlus 9.3
+- Numerous HPXML inputs are now optional with built-in defaulting, particularly for water heating, appliances, and PV. Set the `debug` argument to true to output a in.xml HPXML file with defaults applied for inspection. See the documentation for defaulting equations/assumptions/references.
+- **[Breaking Change]** If clothes washer efficiency inputs are provided, `LabelUsage` is now required.
+- **[Breaking Change]** If dishwasher efficiency inputs are provided, `LabelElectricRate`, `LabelGasRate`, `LabelAnnualGasCost`, and `LabelUsage` are now required.
+- Adds optional specification of simulation controls including timestep and begin/end dates.
+- Adds optional `extension/UsageMultiplier` inputs for appliances, plug loads, lighting, and water fixtures. Can be used to, e.g., reflect high/low usage occupants.
+- Adds ability to model a dehumidifier.
+- Adds ability to model kitchen/bath fans (spot ventilation).
+- Improved desuperheater model; desuperheater can now be connected to heat pump water heaters.
+- Updated clothes washer/dryer and dishwasher models per ANSI/RESNET/ICC 301-2019 Addendum A.
+- Solar thermal systems modeled with `SolarFraction` can now be connected to combi water heating systems.
+- **[Breaking Change]** Replaces optional `epw_output_path` and `osm_output_path` arguments with a single optional `output_dir` argument; adds an optional `debug` argument.
+- **[Breaking Change]** Replaces optional `BuildingConstruction/extension/FractionofOperableWindowArea` with optional `Window/FractionOperable`.
+- **[Breaking Change]** Replaces optional `extension/EPWFileName` with optional `extension/EPWFilePath` to allow absolute paths to be provided as an alternative to just the file name.
+- Replaces REXML xml library with Oga for better runtime performance.
+- Additional error-checking.
+- SimulationOutputReport reporting measure:
+  - Now reports wood and wood pellets
+  - Can report monthly timeseries values if requested
+  - Adds hot water outputs (gallons) for clothes washer, dishwasher, fixtures, and distribution waste.
+  - Small improvement to calculation of component loads
+
+__Bugfixes__
+- Fixes possible simulation error for buildings with complex HVAC/duct systems.
+- Fixes handling of infiltration induced by duct leakage imbalance (i.e., supply leakage != return leakage). Only affects ducts located in a vented crawlspace or vented attic.
+- Fixes an unsuccessful simulation for buildings where the sum of multiple HVAC systems' fraction load served was slightly above 1 due to rounding.
+- Small fix for interior partition wall thermal mass model.
+- Skip building surfaces with areas that are extremely small.
+
+## OpenStudio-HPXML v0.8.0 Beta
+
+__Breaking Changes__
+- Weather cache files are now in .csv instead of .cache format.
+- `extension/StandbyLoss` changed to `StandbyLoss` for indirect water heaters.
+- `Site/extension/DisableNaturalVentilation` changed to `BuildingConstruction/extension/FractionofOperableWindowArea` for more granularity.
+
+__New Features__
+- Adds a SimulationOutputReport reporting measure that provides a variety of annual/timeseries outputs in CSV format.
+- Allows modeling of whole-house fans to address cooling.
+- Improved natural ventilation algorithm that reduces the potential for incurring additional heating energy.
+- Optional `HotWaterTemperature` input for water heaters.
+- Optional `CompressorType` input for air conditioners and air-source heat pumps.
+- Allows specifying the EnergyPlus simulation timestep.
+- Runtime performance improvements.
+- Additional HPXML error-checking.
+
+__Bugfixes__
+- Fix for central fan integrated supply (CFIS) fan energy.
+- Fix simulation error when `FractionHeatLoadServed` (or `FractionCoolLoadServed`) sums to slightly greater than 1.
+- Fix for running simulations on a different drive (either local or remote network).
+- Fix for HVAC sizing error when latitude is exactly 64 (Big Delta, Alaska).
+- Fixes running simulations when there is no weather cache file.
+- Fixes view factors when conditioned basement foundation walls have a window/door.
+- Fixes weather file download.
+- Allow a building with ceiling fans and without lighting.
+
+## OpenStudio-HPXML v0.7.0 Beta
+
+- Initial beta release

data/example_files/resources/hpxml-measures/Gemfile

@@ -4,11 +4,8 @@ source 'http://rubygems.org'
 
 gem 'nokogiri', '~> 1.10'
 gem 'oga'
-gem 'schematron-nokogiri', git: 'http://github.com/shorowit/schematron.git', branch: 'return_context_path'
+gem 'schematron-nokogiri'
 gem 'rake'
 gem 'minitest', '~> 5.9'
-gem 'ci_reporter_minitest', '~> 1.0.0'
-gem 'simplecov'
-gem 'codecov'
 gem 'minitest-reporters'
-gem 'minitest-ci' # For CircleCI Automatic test metadata collection
+gem 'parallel'

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

@@ -3,7 +3,6 @@
 # Require all gems up front; this is much faster than multiple resource
 # files lazy loading as needed, as it prevents multiple lookups for the
 # same gem.
-require 'openstudio'
 require 'pathname'
 require 'csv'
 require 'oga'
@@ -11,6 +10,7 @@ require_relative 'resources/airflow'
 require_relative 'resources/constants'
 require_relative 'resources/constructions'
 require_relative 'resources/energyplus'
+require_relative 'resources/generator'
 require_relative 'resources/geometry'
 require_relative 'resources/hotwater_appliances'
 require_relative 'resources/hpxml'
@@ -61,17 +61,34 @@ class HPXMLtoOpenStudio < OpenStudio::Measure::ModelMeasure
     arg.setDescription('Absolute/relative path of the HPXML file.')
     args << arg
 
-    arg = OpenStudio::Measure::OSArgument.makeStringArgument('output_dir', false)
+    arg = OpenStudio::Measure::OSArgument.makeStringArgument('output_dir', true)
     arg.setDisplayName('Directory for Output Files')
     arg.setDescription('Absolute/relative path for the output files directory.')
     args << arg
 
     arg = OpenStudio::Measure::OSArgument.makeBoolArgument('debug', false)
     arg.setDisplayName('Debug Mode?')
-    arg.setDescription('If enabled: 1) Writes in.osm file, 2) Writes in.xml HPXML file with defaults populated, and 3) Generates additional log output. Any files written will be in the output path specified above.')
+    arg.setDescription('If true: 1) Writes in.osm file, 2) Generates additional log output, and 3) Creates all EnergyPlus output files.')
     arg.setDefaultValue(false)
     args << arg
 
+    arg = OpenStudio::Measure::OSArgument.makeBoolArgument('add_component_loads', false)
+    arg.setDisplayName('Add component loads?')
+    arg.setDescription('If true, adds the calculation of heating/cooling component loads (not enabled by default for faster performance).')
+    arg.setDefaultValue(false)
+    args << arg
+
+    arg = OpenStudio::Measure::OSArgument.makeBoolArgument('skip_validation', false)
+    arg.setDisplayName('Skip Validation?')
+    arg.setDescription('If true, bypasses HPXML input validation for faster performance. WARNING: This should only be used if the supplied HPXML file has already been validated against the Schema & Schematron documents.')
+    arg.setDefaultValue(false)
+    args << arg
+
+    arg = OpenStudio::Measure::OSArgument.makeStringArgument('building_id', false)
+    arg.setDisplayName('BuildingID')
+    arg.setDescription('The ID of the HPXML Building. Only required if there are multiple Building elements in the HPXML file.')
+    args << arg
+
     return args
   end
 
@@ -84,14 +101,17 @@ class HPXMLtoOpenStudio < OpenStudio::Measure::ModelMeasure
       return false
     end
 
-    tear_down_model(model, runner)
+    Geometry.tear_down_model(model, runner)
 
     Version.check_openstudio_version()
 
     # assign the user inputs to variables
     hpxml_path = runner.getStringArgumentValue('hpxml_path', user_arguments)
-    output_dir = runner.getOptionalStringArgumentValue('output_dir', user_arguments)
+    output_dir = runner.getStringArgumentValue('output_dir', user_arguments)
+    add_component_loads = runner.getBoolArgumentValue('add_component_loads', user_arguments)
     debug = runner.getBoolArgumentValue('debug', user_arguments)
+    skip_validation = runner.getBoolArgumentValue('skip_validation', user_arguments)
+    building_id = runner.getOptionalStringArgumentValue('building_id', user_arguments)
 
     unless (Pathname.new hpxml_path).absolute?
       hpxml_path = File.expand_path(File.join(File.dirname(__FILE__), hpxml_path))
@@ -100,25 +120,41 @@ class HPXMLtoOpenStudio < OpenStudio::Measure::ModelMeasure
       fail "'#{hpxml_path}' does not exist or is not an .xml file."
     end
 
-    if output_dir.is_initialized
-      output_dir = output_dir.get
-      unless (Pathname.new output_dir).absolute?
-        output_dir = File.expand_path(File.join(File.dirname(__FILE__), output_dir))
-      end
+    unless (Pathname.new output_dir).absolute?
+      output_dir = File.expand_path(File.join(File.dirname(__FILE__), output_dir))
+    end
+
+    if building_id.is_initialized
+      building_id = building_id.get
     else
-      output_dir = nil
+      building_id = nil
     end
 
     begin
-      hpxml = HPXML.new(hpxml_path: hpxml_path)
-
-      if not validate_hpxml(runner, hpxml_path, hpxml)
-        return false
+      if skip_validation
+        stron_paths = []
+      else
+        stron_paths = [File.join(File.dirname(__FILE__), 'resources', 'HPXMLvalidator.xml'),
+                       File.join(File.dirname(__FILE__), 'resources', 'EPvalidator.xml')]
+      end
+      hpxml = HPXML.new(hpxml_path: hpxml_path, schematron_validators: stron_paths, building_id: building_id)
+      hpxml.errors.each do |error|
+        runner.registerError(error)
+      end
+      hpxml.warnings.each do |warning|
+        runner.registerWarning(warning)
       end
+      return false unless hpxml.errors.empty?
 
-      epw_path, cache_path = process_weather(hpxml, runner, model, output_dir, hpxml_path)
+      epw_path, cache_path = process_weather(hpxml, runner, model, hpxml_path)
 
-      OSModel.create(hpxml, runner, model, hpxml_path, epw_path, cache_path, output_dir, debug)
+      if debug
+        epw_output_path = File.join(output_dir, 'in.epw')
+        FileUtils.cp(epw_path, epw_output_path)
+      end
+
+      OSModel.create(hpxml, runner, model, hpxml_path, epw_path, cache_path, output_dir,
+                     add_component_loads, building_id, debug)
     rescue Exception => e
       runner.registerError("#{e.message}\n#{e.backtrace.join("\n")}")
       return false
@@ -127,49 +163,7 @@ class HPXMLtoOpenStudio < OpenStudio::Measure::ModelMeasure
     return true
   end
 
-  def tear_down_model(model, runner)
-    # Tear down the existing model if it exists
-    has_existing_objects = (model.getThermalZones.size > 0)
-    handles = OpenStudio::UUIDVector.new
-    model.objects.each do |obj|
-      handles << obj.handle
-    end
-    model.removeObjects(handles)
-    if has_existing_objects
-      runner.registerWarning('The model contains existing objects and is being reset.')
-    end
-  end
-
-  def validate_hpxml(runner, hpxml_path, hpxml)
-    schemas_dir = File.join(File.dirname(__FILE__), 'resources')
-
-    is_valid = true
-
-    # Validate input HPXML against schema
-    XMLHelper.validate(hpxml.doc.to_xml, File.join(schemas_dir, 'HPXML.xsd'), runner).each do |error|
-      runner.registerError("#{hpxml_path}: #{error}")
-      is_valid = false
-    end
-
-    # Validate input HPXML against EnergyPlus Use Case
-    stron_path = File.join(File.dirname(__FILE__), 'resources', 'EPvalidator.xml')
-    errors = Validator.run_validator(hpxml.doc, stron_path)
-    errors.each do |error|
-      runner.registerError("#{hpxml_path}: #{error}")
-      is_valid = false
-    end
-
-    # Check for additional errors
-    errors = hpxml.check_for_errors()
-    errors.each do |error|
-      runner.registerError("#{hpxml_path}: #{error}")
-      is_valid = false
-    end
-
-    return is_valid
-  end
-
-  def process_weather(hpxml, runner, model, output_dir, hpxml_path)
+  def process_weather(hpxml, runner, model, hpxml_path)
     epw_path = hpxml.climate_and_risk_zones.weather_station_epw_filepath
 
     if not File.exist? epw_path
@@ -180,6 +174,10 @@ class HPXMLtoOpenStudio < OpenStudio::Measure::ModelMeasure
       test_epw_path = File.join(File.dirname(__FILE__), '..', 'weather', epw_path)
       epw_path = test_epw_path if File.exist? test_epw_path
     end
+    if not File.exist? epw_path
+      test_epw_path = File.join(File.dirname(__FILE__), '..', '..', 'weather', epw_path)
+      epw_path = test_epw_path if File.exist? test_epw_path
+    end
     if not File.exist?(epw_path)
       fail "'#{epw_path}' could not be found."
     end
@@ -205,7 +203,8 @@ class HPXMLtoOpenStudio < OpenStudio::Measure::ModelMeasure
 end
 
 class OSModel
-  def self.create(hpxml, runner, model, hpxml_path, epw_path, cache_path, output_dir, debug)
+  def self.create(hpxml, runner, model, hpxml_path, epw_path, cache_path, output_dir,
+                  add_component_loads, building_id, debug)
     @hpxml = hpxml
     @debug = debug
 
@@ -216,19 +215,18 @@ class OSModel
     @apply_ashrae140_assumptions = @hpxml.header.apply_ashrae140_assumptions # Hidden feature
     @apply_ashrae140_assumptions = false if @apply_ashrae140_assumptions.nil?
 
-    @schedules_file = nil
-    if not @hpxml.header.schedules_path.nil?
-      @schedules_file = SchedulesFile.new(runner: runner, model: model, schedules_path: @hpxml.header.schedules_path, col_names: ScheduleGenerator.col_names)
-    end
-
     # Init
 
     weather, epw_file = Location.apply_weather_file(model, runner, epw_path, cache_path)
-    check_for_errors()
-    set_defaults_and_globals(runner, output_dir, epw_file)
-    weather = Location.apply(model, runner, weather, epw_file, @hpxml)
+    set_defaults_and_globals(runner, output_dir, epw_file, weather)
+    Location.apply(model, runner, weather, epw_file, @hpxml)
     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)
+    end
+
     # Conditioned space/zone
 
     spaces = {}
@@ -242,25 +240,24 @@ class OSModel
     add_rim_joists(runner, model, spaces)
     add_frame_floors(runner, model, spaces)
     add_foundation_walls_slabs(runner, model, spaces)
-    add_interior_shading_schedule(runner, model, weather)
+    add_shading_schedule(runner, model, weather)
     add_windows(runner, model, spaces, weather)
     add_doors(runner, model, spaces)
     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)
-    set_zone_volumes(runner, model, spaces)
-    explode_surfaces(runner, model)
+    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
 
-    update_shared_hvac_systems()
     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_dehumidifier(runner, model, spaces)
+    add_dehumidifiers(runner, model, spaces)
     add_residual_ideal_system(runner, model, spaces)
     add_ceiling_fans(runner, model, weather, spaces)
 
@@ -280,97 +277,32 @@ class OSModel
     # Other
 
     add_airflow(runner, model, weather, spaces)
-    add_hvac_sizing(runner, model, weather, spaces)
-    add_furnace_eae(runner, model)
     add_photovoltaics(runner, model)
-    add_additional_properties(runner, model, hpxml_path)
-    add_component_loads_output(runner, model, spaces)
+    add_generators(runner, model)
+    add_additional_properties(runner, model, hpxml_path, building_id)
+
+    # Output
+
+    add_loads_output(runner, model, spaces, add_component_loads)
+    add_output_control_files(runner, model)
+    # Uncomment to debug EMS
+    # add_ems_debug_output(runner, model)
 
     # Vacancy
-    set_vacancy(runner, model)
+    unless @schedules_file.nil?
+      @schedules_file.set_vacancy
+    end
 
-    if debug && (not output_dir.nil?)
+    if debug
       osm_output_path = File.join(output_dir, 'in.osm')
       File.write(osm_output_path, model.to_s)
       runner.registerInfo("Wrote file: #{osm_output_path}")
     end
-
-    # Uncomment to debug EMS
-    # oems = model.getOutputEnergyManagementSystem
-    # oems.setActuatorAvailabilityDictionaryReporting('Verbose')
-    # oems.setInternalVariableAvailabilityDictionaryReporting('Verbose')
-    # oems.setEMSRuntimeLanguageDebugOutputLevel('Verbose')
   end
 
   private
 
-  def self.check_for_errors()
-    # Conditioned space
-    location = HPXML::LocationLivingSpace
-    if (@hpxml.roofs.select { |s| s.interior_adjacent_to == location }.size +
-        @hpxml.frame_floors.select { |s| s.is_ceiling && (s.interior_adjacent_to == location) }.size) == 0
-      fail 'There must be at least one ceiling/roof adjacent to conditioned space.'
-    end
-    if @hpxml.walls.select { |s| (s.interior_adjacent_to == location) && s.is_exterior }.size == 0
-      fail 'There must be at least one exterior wall adjacent to conditioned space.'
-    end
-    if (@hpxml.slabs.select { |s| [location, HPXML::LocationBasementConditioned].include? s.interior_adjacent_to }.size +
-        @hpxml.frame_floors.select { |s| s.is_floor && (s.interior_adjacent_to == location) }.size) == 0
-      fail 'There must be at least one floor/slab adjacent to conditioned space.'
-    end
-
-    # Basement/Crawlspace
-    [HPXML::LocationBasementConditioned,
-     HPXML::LocationBasementUnconditioned,
-     HPXML::LocationCrawlspaceVented,
-     HPXML::LocationCrawlspaceUnvented].each do |location|
-      next unless @hpxml.has_space_type(location)
-
-      if location != HPXML::LocationBasementConditioned # HPXML file doesn't need to have FrameFloor between living and conditioned basement
-        if @hpxml.frame_floors.select { |s| s.is_floor && (s.interior_adjacent_to == HPXML::LocationLivingSpace) && (s.exterior_adjacent_to == location) }.size == 0
-          fail "There must be at least one ceiling adjacent to #{location}."
-        end
-      end
-      if @hpxml.foundation_walls.select { |s| (s.interior_adjacent_to == location) && s.is_exterior }.size == 0
-        fail "There must be at least one exterior foundation wall adjacent to #{location}."
-      end
-      if @hpxml.slabs.select { |s| s.interior_adjacent_to == location }.size == 0
-        fail "There must be at least one slab adjacent to #{location}."
-      end
-    end
-
-    # Garage
-    location = HPXML::LocationGarage
-    if @hpxml.has_space_type(location)
-      if (@hpxml.roofs.select { |s| s.interior_adjacent_to == location }.size +
-          @hpxml.frame_floors.select { |s| [s.interior_adjacent_to, s.exterior_adjacent_to].include? location }.size) == 0
-        fail "There must be at least one roof/ceiling adjacent to #{location}."
-      end
-      if (@hpxml.walls.select { |s| (s.interior_adjacent_to == location) && s.is_exterior }.size +
-         @hpxml.foundation_walls.select { |s| [s.interior_adjacent_to, s.exterior_adjacent_to].include?(location) && s.is_exterior }.size) == 0
-        fail "There must be at least one exterior wall/foundation wall adjacent to #{location}."
-      end
-      if @hpxml.slabs.select { |s| s.interior_adjacent_to == location }.size == 0
-        fail "There must be at least one slab adjacent to #{location}."
-      end
-    end
-
-    # Attic
-    [HPXML::LocationAtticVented,
-     HPXML::LocationAtticUnvented].each do |location|
-      next unless @hpxml.has_space_type(location)
-
-      if @hpxml.roofs.select { |s| s.interior_adjacent_to == location }.size == 0
-        fail "There must be at least one roof adjacent to #{location}."
-      end
-
-      if @hpxml.frame_floors.select { |s| s.is_ceiling && [s.interior_adjacent_to, s.exterior_adjacent_to].include?(location) }.size == 0
-        fail "There must be at least one floor adjacent to #{location}."
-      end
-    end
-  end
-
-  def self.set_defaults_and_globals(runner, output_dir, epw_file)
+  def self.set_defaults_and_globals(runner, output_dir, epw_file, weather)
     # Initialize
     @remaining_heat_load_frac = 1.0
     @remaining_cool_load_frac = 1.0
@@ -383,207 +315,40 @@ class OSModel
     @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
-    @min_neighbor_distance = get_min_neighbor_distance()
     @default_azimuths = get_default_azimuths()
-    @has_uncond_bsmnt = @hpxml.has_space_type(HPXML::LocationBasementUnconditioned)
-
-    if @hpxml.building_construction.use_only_ideal_air_system.nil?
-      @hpxml.building_construction.use_only_ideal_air_system = false
-    end
 
     # Apply defaults to HPXML object
-    HPXMLDefaults.apply(@hpxml, @cfa, @nbeds, @ncfl, @ncfl_ag, @has_uncond_bsmnt, @eri_version, epw_file, runner)
+    HPXMLDefaults.apply(@hpxml, @eri_version, weather, epw_file: epw_file)
 
     @frac_windows_operable = @hpxml.fraction_of_windows_operable()
 
-    if @debug && (not output_dir.nil?)
-      # Write updated HPXML object to file
-      hpxml_defaults_path = File.join(output_dir, 'in.xml')
-      XMLHelper.write_file(@hpxml.to_oga, hpxml_defaults_path)
-      runner.registerInfo("Wrote file: #{hpxml_defaults_path}")
-    end
-  end
+    # 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)
 
-  def self.add_simulation_params(model)
-    SimControls.apply(model, @hpxml.header)
+    # Now that we've written in.xml, ensure that no capacities/airflows
+    # are zero in order to prevent potential E+ errors.
+    HVAC.ensure_nonzero_sizing_values(@hpxml)
   end
 
-  def self.set_zone_volumes(runner, model, spaces)
-    # Living space
-    spaces[HPXML::LocationLivingSpace].thermalZone.get.setVolume(UnitConversions.convert(@hpxml.building_construction.conditioned_building_volume, 'ft^3', 'm^3'))
-
-    # Basement, crawlspace, garage
-    spaces.keys.each do |space_type|
-      next unless [HPXML::LocationBasementUnconditioned, HPXML::LocationCrawlspaceUnvented, HPXML::LocationCrawlspaceVented, HPXML::LocationGarage].include? space_type
-
-      floor_area = @hpxml.slabs.select { |s| s.interior_adjacent_to == space_type }.map { |s| s.area }.sum(0.0)
-      if space_type == HPXML::LocationGarage
-        height = 8.0
-      else
-        height = @hpxml.foundation_walls.select { |w| w.interior_adjacent_to == space_type }.map { |w| w.height }.max
-      end
-
-      spaces[space_type].thermalZone.get.setVolume(UnitConversions.convert(floor_area * height, 'ft^3', 'm^3'))
-    end
-
-    # Attic
-    spaces.keys.each do |space_type|
-      next unless [HPXML::LocationAtticUnvented, HPXML::LocationAtticVented].include? space_type
-
-      floor_area = @hpxml.frame_floors.select { |f| [f.interior_adjacent_to, f.exterior_adjacent_to].include? space_type }.map { |s| s.area }.sum(0.0)
-      roofs = @hpxml.roofs.select { |r| r.interior_adjacent_to == space_type }
-      avg_pitch = roofs.map { |r| r.pitch }.sum(0.0) / roofs.size
-
-      # Assume square hip roof for volume calculations; energy results are very insensitive to actual volume
-      length = floor_area**0.5
-      height = 0.5 * Math.sin(Math.atan(avg_pitch / 12.0)) * length
-      volume = [floor_area * height / 3.0, 0.01].max
-
-      spaces[space_type].thermalZone.get.setVolume(UnitConversions.convert(volume, 'ft^3', 'm^3'))
-    end
+  def self.add_simulation_params(model)
+    SimControls.apply(model, @hpxml)
   end
 
-  def self.explode_surfaces(runner, model)
-    # Re-position surfaces so as to not shade each other and to make it easier to visualize the building.
-    # FUTURE: Might be able to use the new self-shading options in E+ 8.9 ShadowCalculation object instead?
-
-    gap_distance = UnitConversions.convert(10.0, 'ft', 'm') # distance between surfaces of the same azimuth
-    rad90 = UnitConversions.convert(90, 'deg', 'rad')
-
-    # Determine surfaces to shift and distance with which to explode surfaces horizontally outward
-    surfaces = []
-    azimuth_lengths = {}
-    model.getSurfaces.sort.each do |surface|
-      next unless ['wall', 'roofceiling'].include? surface.surfaceType.downcase
-      next unless ['outdoors', 'foundation'].include? surface.outsideBoundaryCondition.downcase
-      next if surface.additionalProperties.getFeatureAsDouble('Tilt').get <= 0 # skip flat roofs
-
-      surfaces << surface
-      azimuth = surface.additionalProperties.getFeatureAsInteger('Azimuth').get
-      if azimuth_lengths[azimuth].nil?
-        azimuth_lengths[azimuth] = 0.0
-      end
-      azimuth_lengths[azimuth] += surface.additionalProperties.getFeatureAsDouble('Length').get + gap_distance
-    end
-    max_azimuth_length = azimuth_lengths.values.max
-
-    # Using the max length for a given azimuth, calculate the apothem (radius of the incircle) of a regular
-    # n-sided polygon to create the smallest polygon possible without self-shading. The number of polygon
-    # sides is defined by the minimum difference between two azimuths.
-    min_azimuth_diff = 360
-    azimuths_sorted = azimuth_lengths.keys.sort
-    azimuths_sorted.each_with_index do |az, idx|
-      diff1 = (az - azimuths_sorted[(idx + 1) % azimuths_sorted.size]).abs
-      diff2 = 360.0 - diff1 # opposite direction
-      if diff1 < min_azimuth_diff
-        min_azimuth_diff = diff1
-      end
-      if diff2 < min_azimuth_diff
-        min_azimuth_diff = diff2
-      end
-    end
-    if min_azimuth_diff > 0
-      nsides = [(360.0 / min_azimuth_diff).ceil, 4].max # assume rectangle at the minimum
-    else
-      nsides = 4
-    end
-    explode_distance = max_azimuth_length / (2.0 * Math.tan(UnitConversions.convert(180.0 / nsides, 'deg', 'rad')))
-
-    add_neighbors(runner, model, max_azimuth_length)
-
-    # Initial distance of shifts at 90-degrees to horizontal outward
-    azimuth_side_shifts = {}
-    azimuth_lengths.keys.each do |azimuth|
-      azimuth_side_shifts[azimuth] = max_azimuth_length / 2.0
-    end
-
-    # Explode neighbors
-    model.getShadingSurfaceGroups.each do |shading_surface_group|
-      next if shading_surface_group.name.to_s != Constants.ObjectNameNeighbors
-
-      shading_surface_group.shadingSurfaces.each do |shading_surface|
-        azimuth = shading_surface.additionalProperties.getFeatureAsInteger('Azimuth').get
-        azimuth_rad = UnitConversions.convert(azimuth, 'deg', 'rad')
-        distance = shading_surface.additionalProperties.getFeatureAsDouble('Distance').get
-
-        unless azimuth_lengths.keys.include? azimuth
-          fail "A neighbor building has an azimuth (#{azimuth}) not equal to the azimuth of any wall."
-        end
-
-        # Push out horizontally
-        distance += explode_distance
-        transformation = get_surface_transformation(distance, Math::sin(azimuth_rad), Math::cos(azimuth_rad), 0)
-
-        shading_surface.setVertices(transformation * shading_surface.vertices)
-      end
-    end
-
-    # Explode walls, windows, doors, roofs, and skylights
-    surfaces_moved = []
-
-    surfaces.sort.each do |surface|
-      next if surface.additionalProperties.getFeatureAsDouble('Tilt').get <= 0 # skip flat roofs
-
-      if surface.adjacentSurface.is_initialized
-        next if surfaces_moved.include? surface.adjacentSurface.get
-      end
-
-      azimuth = surface.additionalProperties.getFeatureAsInteger('Azimuth').get
-      azimuth_rad = UnitConversions.convert(azimuth, 'deg', 'rad')
-
-      # Push out horizontally
-      distance = explode_distance
-
-      if surface.surfaceType.downcase == 'roofceiling'
-        # Ensure pitched surfaces are positioned outward justified with walls, etc.
-        tilt = surface.additionalProperties.getFeatureAsDouble('Tilt').get
-        width = surface.additionalProperties.getFeatureAsDouble('Width').get
-        distance -= 0.5 * Math.cos(Math.atan(tilt)) * width
-      end
-      transformation = get_surface_transformation(distance, Math::sin(azimuth_rad), Math::cos(azimuth_rad), 0)
-
-      surface.setVertices(transformation * surface.vertices)
-      if surface.adjacentSurface.is_initialized
-        surface.adjacentSurface.get.setVertices(transformation * surface.adjacentSurface.get.vertices)
-      end
-      surface.subSurfaces.each do |subsurface|
-        subsurface.setVertices(transformation * subsurface.vertices)
-        next unless subsurface.subSurfaceType.downcase == 'fixedwindow'
-
-        subsurface.shadingSurfaceGroups.each do |overhang_group|
-          overhang_group.shadingSurfaces.each do |overhang|
-            overhang.setVertices(transformation * overhang.vertices)
-          end
-        end
-      end
-
-      # Shift at 90-degrees to previous transformation
-      azimuth_side_shifts[azimuth] -= surface.additionalProperties.getFeatureAsDouble('Length').get / 2.0
-      transformation_shift = get_surface_transformation(azimuth_side_shifts[azimuth], Math::sin(azimuth_rad + rad90), Math::cos(azimuth_rad + rad90), 0)
+  def self.update_conditioned_basement(runner, model, spaces)
+    return if @cond_bsmnt_surfaces.empty?
 
-      surface.setVertices(transformation_shift * surface.vertices)
-      if surface.adjacentSurface.is_initialized
-        surface.adjacentSurface.get.setVertices(transformation_shift * surface.adjacentSurface.get.vertices)
-      end
-      surface.subSurfaces.each do |subsurface|
-        subsurface.setVertices(transformation_shift * subsurface.vertices)
-        next unless subsurface.subSurfaceType.downcase == 'fixedwindow'
+    # Update @cond_bsmnt_surfaces to include subsurfaces
+    new_cond_bsmnt_surfaces = @cond_bsmnt_surfaces.dup
+    @cond_bsmnt_surfaces.each do |cond_bsmnt_surface|
+      next if cond_bsmnt_surface.is_a? OpenStudio::Model::InternalMassDefinition
+      next if cond_bsmnt_surface.subSurfaces.empty?
 
-        subsurface.shadingSurfaceGroups.each do |overhang_group|
-          overhang_group.shadingSurfaces.each do |overhang|
-            overhang.setVertices(transformation_shift * overhang.vertices)
-          end
-        end
+      cond_bsmnt_surface.subSurfaces.each do |ss|
+        new_cond_bsmnt_surfaces << ss
       end
-
-      azimuth_side_shifts[azimuth] -= (surface.additionalProperties.getFeatureAsDouble('Length').get / 2.0 + gap_distance)
-
-      surfaces_moved << surface
     end
-  end
-
-  def self.update_conditioned_basement(runner, model, spaces)
-    return if @cond_bsmnt_surfaces.empty?
+    @cond_bsmnt_surfaces = new_cond_bsmnt_surfaces.dup
 
     update_solar_absorptances(runner, model)
     assign_view_factors(runner, model, spaces)
@@ -592,7 +357,19 @@ class OSModel
   def self.update_solar_absorptances(runner, model)
     # modify conditioned basement surface properties
     # zero out interior solar absorptance in conditioned basement
+
     @cond_bsmnt_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')
+
+      adj_surface = nil
+      if not cond_bsmnt_surface.is_a? OpenStudio::Model::InternalMassDefinition
+        if not cond_bsmnt_surface.is_a? OpenStudio::Model::SubSurface
+          adj_surface = cond_bsmnt_surface.adjacentSurface.get if cond_bsmnt_surface.adjacentSurface.is_initialized
+        else
+          adj_surface = cond_bsmnt_surface.adjacentSubSurface.get if cond_bsmnt_surface.adjacentSubSurface.is_initialized
+        end
+      end
       const = cond_bsmnt_surface.construction.get
       layered_const = const.to_LayeredConstruction.get
       innermost_material = layered_const.layers[layered_const.numLayers() - 1].to_StandardOpaqueMaterial.get
@@ -622,6 +399,13 @@ class OSModel
       innermost_material = layered_const.layers[layered_const.numLayers() - 1].to_StandardOpaqueMaterial.get
       innermost_material.setSolarAbsorptance(0.0)
       innermost_material.setVisibleAbsorptance(0.0)
+      next if adj_surface.nil?
+
+      # Create new construction in case of shared construciton.
+      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())
     end
   end
 
@@ -643,8 +427,7 @@ class OSModel
 
     all_surfaces.each do |surface|
       if @cond_bsmnt_surfaces.include?(surface) ||
-         ((@cond_bsmnt_surfaces.include? surface.internalMassDefinition) if surface.is_a? OpenStudio::Model::InternalMass) ||
-         ((@cond_bsmnt_surfaces.include? surface.surface.get) if surface.is_a? OpenStudio::Model::SubSurface)
+         ((@cond_bsmnt_surfaces.include? surface.internalMassDefinition) if surface.is_a? OpenStudio::Model::InternalMass)
         cond_base_surfaces << surface
       else
         lv_surfaces << surface
@@ -669,7 +452,7 @@ class OSModel
         else
           vf = vf_map_cb[from_surface][to_surface]
         end
-        next if vf < 0.01
+        next if vf < 0.05 # Skip small view factors to reduce runtime
 
         os_vf = OpenStudio::Model::ViewFactor.new(from_surface, to_surface, vf.round(10))
         zone_prop.addViewFactor(os_vf)
@@ -759,160 +542,26 @@ class OSModel
     return vf_map
   end
 
-  # FUTURE: Move this method and many below to geometry.rb
-  def self.create_space_and_zone(model, spaces, space_type)
-    if not spaces.keys.include? space_type
-      thermal_zone = OpenStudio::Model::ThermalZone.new(model)
-      thermal_zone.setName(space_type)
-
-      space = OpenStudio::Model::Space.new(model)
-      space.setName(space_type)
-
-      st = OpenStudio::Model::SpaceType.new(model)
-      st.setStandardsSpaceType(space_type)
-      space.setSpaceType(st)
-
-      space.setThermalZone(thermal_zone)
-      spaces[space_type] = space
-    end
-  end
-
-  def self.get_surface_transformation(offset, x, y, z)
-    x = UnitConversions.convert(x, 'ft', 'm')
-    y = UnitConversions.convert(y, 'ft', 'm')
-    z = UnitConversions.convert(z, 'ft', 'm')
-
-    m = OpenStudio::Matrix.new(4, 4, 0)
-    m[0, 0] = 1
-    m[1, 1] = 1
-    m[2, 2] = 1
-    m[3, 3] = 1
-    m[0, 3] = x * offset
-    m[1, 3] = y * offset
-    m[2, 3] = z.abs * offset
-
-    return OpenStudio::Transformation.new(m)
-  end
-
-  def self.add_floor_polygon(x, y, z)
-    x = UnitConversions.convert(x, 'ft', 'm')
-    y = UnitConversions.convert(y, 'ft', 'm')
-    z = UnitConversions.convert(z, 'ft', 'm')
-
-    vertices = OpenStudio::Point3dVector.new
-    vertices << OpenStudio::Point3d.new(0 - x / 2, 0 - y / 2, z)
-    vertices << OpenStudio::Point3d.new(0 - x / 2, y / 2, z)
-    vertices << OpenStudio::Point3d.new(x / 2, y / 2, z)
-    vertices << OpenStudio::Point3d.new(x / 2, 0 - y / 2, z)
-
-    return vertices
-  end
-
-  def self.add_wall_polygon(x, y, z, azimuth = 0, offsets = [0] * 4, subsurface_area = 0)
-    x = UnitConversions.convert(x, 'ft', 'm')
-    y = UnitConversions.convert(y, 'ft', 'm')
-    z = UnitConversions.convert(z, 'ft', 'm')
-
-    vertices = OpenStudio::Point3dVector.new
-    vertices << OpenStudio::Point3d.new(0 - (x / 2) - offsets[1], 0, z - offsets[0])
-    vertices << OpenStudio::Point3d.new(0 - (x / 2) - offsets[1], 0, z + y + offsets[2])
-    if subsurface_area > 0
-      subsurface_area = UnitConversions.convert(subsurface_area, 'ft^2', 'm^2')
-      sub_length = x / 10.0
-      sub_height = subsurface_area / sub_length
-      if sub_height >= y
-        sub_height = y - 0.1
-        sub_length = subsurface_area / sub_height
-      end
-      vertices << OpenStudio::Point3d.new(x - (x / 2) + offsets[3] - sub_length, 0, z + y + offsets[2])
-      vertices << OpenStudio::Point3d.new(x - (x / 2) + offsets[3] - sub_length, 0, z + y + offsets[2] - sub_height)
-      vertices << OpenStudio::Point3d.new(x - (x / 2) + offsets[3], 0, z + y + offsets[2] - sub_height)
-    else
-      vertices << OpenStudio::Point3d.new(x - (x / 2) + offsets[3], 0, z + y + offsets[2])
-    end
-    vertices << OpenStudio::Point3d.new(x - (x / 2) + offsets[3], 0, z - offsets[0])
-
-    # Rotate about the z axis
-    azimuth_rad = UnitConversions.convert(azimuth, 'deg', 'rad')
-    m = OpenStudio::Matrix.new(4, 4, 0)
-    m[0, 0] = Math::cos(-azimuth_rad)
-    m[1, 1] = Math::cos(-azimuth_rad)
-    m[0, 1] = -Math::sin(-azimuth_rad)
-    m[1, 0] = Math::sin(-azimuth_rad)
-    m[2, 2] = 1
-    m[3, 3] = 1
-    transformation = OpenStudio::Transformation.new(m)
-
-    return transformation * vertices
-  end
-
-  def self.add_roof_polygon(x, y, z, azimuth = 0, tilt = 0.5)
-    x = UnitConversions.convert(x, 'ft', 'm')
-    y = UnitConversions.convert(y, 'ft', 'm')
-    z = UnitConversions.convert(z, 'ft', 'm')
-
-    vertices = OpenStudio::Point3dVector.new
-    vertices << OpenStudio::Point3d.new(x / 2, -y / 2, 0)
-    vertices << OpenStudio::Point3d.new(x / 2, y / 2, 0)
-    vertices << OpenStudio::Point3d.new(-x / 2, y / 2, 0)
-    vertices << OpenStudio::Point3d.new(-x / 2, -y / 2, 0)
-
-    # Rotate about the x axis
-    m = OpenStudio::Matrix.new(4, 4, 0)
-    m[0, 0] = 1
-    m[1, 1] = Math::cos(Math::atan(tilt))
-    m[1, 2] = -Math::sin(Math::atan(tilt))
-    m[2, 1] = Math::sin(Math::atan(tilt))
-    m[2, 2] = Math::cos(Math::atan(tilt))
-    m[3, 3] = 1
-    transformation = OpenStudio::Transformation.new(m)
-    vertices = transformation * vertices
-
-    # Rotate about the z axis
-    azimuth_rad = UnitConversions.convert(azimuth, 'deg', 'rad')
-    rad180 = UnitConversions.convert(180, 'deg', 'rad')
-    m = OpenStudio::Matrix.new(4, 4, 0)
-    m[0, 0] = Math::cos(rad180 - azimuth_rad)
-    m[1, 1] = Math::cos(rad180 - azimuth_rad)
-    m[0, 1] = -Math::sin(rad180 - azimuth_rad)
-    m[1, 0] = Math::sin(rad180 - azimuth_rad)
-    m[2, 2] = 1
-    m[3, 3] = 1
-    transformation = OpenStudio::Transformation.new(m)
-    vertices = transformation * vertices
-
-    # Shift up by z
-    new_vertices = OpenStudio::Point3dVector.new
-    vertices.each do |vertex|
-      new_vertices << OpenStudio::Point3d.new(vertex.x, vertex.y, vertex.z + z)
-    end
-
-    return new_vertices
-  end
-
-  def self.add_ceiling_polygon(x, y, z)
-    return OpenStudio::reverse(add_floor_polygon(x, y, z))
-  end
-
   def self.add_num_occupants(model, runner, spaces)
     # Occupants
     num_occ = @hpxml.building_occupancy.number_of_residents
-    if num_occ > 0
-      occ_gain, hrs_per_day, sens_frac, lat_frac = Geometry.get_occupancy_default_values()
-      weekday_sch = Schedule.OccupantsWeekdayFractions
-      weekday_sch_sum = weekday_sch.split(',').map(&:to_f).sum(0.0)
-      if (weekday_sch_sum - hrs_per_day).abs > 0.1
-        fail 'Occupancy schedule inconsistent with hrs_per_day.'
-      end
+    return if num_occ <= 0
 
-      weekend_sch = Schedule.OccupantsWeekendFractions
-      monthly_sch = Schedule.OccupantsMonthlyMultipliers
-
-      Geometry.process_occupants(model, num_occ, occ_gain, sens_frac, lat_frac, weekday_sch, weekend_sch, monthly_sch, @cfa, @nbeds, spaces[HPXML::LocationLivingSpace], @schedules_file)
-    end
+    Geometry.apply_occupants(model, 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
+    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
@@ -937,33 +586,22 @@ class OSModel
             sanitize_azimuth(primary_azimuth + 270)].sort
   end
 
-  def self.sanitize_azimuth(azimuth)
-    # Ensure 0 <= orientation < 360
-    while azimuth < 0
-      azimuth += 360
-    end
-    while azimuth >= 360
-      azimuth -= 360
-    end
-    return azimuth
-  end
-
   def self.create_or_get_space(model, spaces, spacetype)
     if spaces[spacetype].nil?
-      create_space_and_zone(model, spaces, spacetype)
+      Geometry.create_space_and_zone(model, spaces, spacetype)
     end
     return spaces[spacetype]
   end
 
   def self.add_roofs(runner, model, spaces)
     @hpxml.roofs.each do |roof|
-      next if roof.net_area < 0.1 # skip modeling net surface area for surfaces comprised entirely of subsurface area
+      next if roof.net_area < 1.0 # skip modeling net surface area for surfaces comprised entirely of subsurface area
 
       if roof.azimuth.nil?
         if roof.pitch > 0
           azimuths = @default_azimuths # Model as four directions for average exterior incident solar
         else
-          azimuths = [90] # Arbitrary azimuth for flat roof
+          azimuths = [@default_azimuths[0]] # Arbitrary azimuth for flat roof
         end
       else
         azimuths = [roof.azimuth]
@@ -977,7 +615,8 @@ class OSModel
         tilt = roof.pitch / 12.0
         z_origin = @walls_top + 0.5 * Math.sin(Math.atan(tilt)) * width
 
-        surface = OpenStudio::Model::Surface.new(add_roof_polygon(length, width, z_origin, azimuth, tilt), model)
+        vertices = Geometry.create_roof_vertices(length, width, z_origin, azimuth, tilt)
+        surface = OpenStudio::Model::Surface.new(vertices, model)
         surfaces << surface
         surface.additionalProperties.setFeature('Length', length)
         surface.additionalProperties.setFeature('Width', width)
@@ -1003,6 +642,7 @@ class OSModel
       if has_radiant_barrier
         radiant_barrier_grade = roof.radiant_barrier_grade
       end
+      # 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)
@@ -1016,14 +656,14 @@ class OSModel
 
       if roof.is_thermal_boundary
         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, 5.0, 0.75, 0.5, mat_roofing),  # 2x8, 24" o.c. + R5
           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
         ]
-        match, constr_set, cavity_r = pick_wood_stud_construction_set(assembly_r, constr_sets, inside_film, outside_film, roof.id)
+        match, constr_set, cavity_r = Constructions.pick_wood_stud_construction_set(assembly_r, constr_sets, inside_film, outside_film, roof.id)
 
         Constructions.apply_closed_cavity_roof(runner, model, surfaces, "#{roof.id} construction",
                                                cavity_r, install_grade,
@@ -1039,7 +679,7 @@ class OSModel
           GenericConstructionSet.new(0.0, 0.5, 0.0, mat_roofing),  # Standard
           GenericConstructionSet.new(0.0, 0.0, 0.0, mat_roofing),  # Fallback
         ]
-        match, constr_set, layer_r = pick_generic_construction_set(assembly_r, constr_sets, inside_film, outside_film, roof.id)
+        match, constr_set, layer_r = Constructions.pick_generic_construction_set(assembly_r, constr_sets, inside_film, outside_film, roof.id)
 
         cavity_r = 0
         cavity_ins_thick_in = 0
@@ -1053,13 +693,13 @@ class OSModel
                                              mat_roofing, has_radiant_barrier,
                                              inside_film, outside_film, radiant_barrier_grade)
       end
-      check_surface_assembly_rvalue(runner, surfaces, inside_film, outside_film, assembly_r, match)
+      Constructions.check_surface_assembly_rvalue(runner, surfaces, inside_film, outside_film, assembly_r, match)
     end
   end
 
   def self.add_walls(runner, model, spaces)
     @hpxml.walls.each do |wall|
-      next if wall.net_area < 0.1 # skip modeling net surface area for surfaces comprised entirely of subsurface area
+      next if wall.net_area < 1.0 # skip modeling net surface area for surfaces comprised entirely of subsurface area
 
       if wall.azimuth.nil?
         if wall.is_exterior
@@ -1078,7 +718,8 @@ class OSModel
         length = (wall.net_area / height) / azimuths.size
         z_origin = @foundation_top
 
-        surface = OpenStudio::Model::Surface.new(add_wall_polygon(length, height, z_origin, azimuth), model)
+        vertices = Geometry.create_wall_vertices(length, height, z_origin, azimuth)
+        surface = OpenStudio::Model::Surface.new(vertices, model)
         surfaces << surface
         surface.additionalProperties.setFeature('Length', length)
         surface.additionalProperties.setFeature('Azimuth', azimuth)
@@ -1122,8 +763,8 @@ class OSModel
         outside_film = Material.AirFilmOutsideASHRAE140
       end
 
-      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, wall.id, wall.wall_type, wall.insulation_assembly_r_value,
+                                            drywall_thick_in, inside_film, outside_film, mat_ext_finish)
     end
   end
 
@@ -1146,7 +787,8 @@ class OSModel
         length = (rim_joist.area / height) / azimuths.size
         z_origin = @foundation_top
 
-        surface = OpenStudio::Model::Surface.new(add_wall_polygon(length, height, z_origin, azimuth), model)
+        vertices = Geometry.create_wall_vertices(length, height, z_origin, azimuth)
+        surface = OpenStudio::Model::Surface.new(vertices, model)
         surfaces << surface
         surface.additionalProperties.setFeature('Length', length)
         surface.additionalProperties.setFeature('Azimuth', azimuth)
@@ -1185,12 +827,12 @@ 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, 5.0, 2.0, drywall_thick_in, mat_ext_finish),   # 2x4 + R5
         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
       ]
-      match, constr_set, cavity_r = pick_wood_stud_construction_set(assembly_r, constr_sets, inside_film, outside_film, rim_joist.id)
+      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",
@@ -1198,7 +840,7 @@ class OSModel
                                     constr_set.drywall_thick_in, constr_set.osb_thick_in,
                                     constr_set.rigid_r, constr_set.exterior_material,
                                     inside_film, outside_film)
-      check_surface_assembly_rvalue(runner, surfaces, inside_film, outside_film, assembly_r, match)
+      Constructions.check_surface_assembly_rvalue(runner, surfaces, inside_film, outside_film, assembly_r, match)
     end
   end
 
@@ -1214,12 +856,15 @@ class OSModel
       end
 
       if frame_floor.is_ceiling
-        surface = OpenStudio::Model::Surface.new(add_ceiling_polygon(length, width, z_origin), model)
+        vertices = Geometry.create_ceiling_vertices(length, width, z_origin, @default_azimuths)
+        surface = OpenStudio::Model::Surface.new(vertices, model)
         surface.additionalProperties.setFeature('SurfaceType', 'Ceiling')
       else
-        surface = OpenStudio::Model::Surface.new(add_floor_polygon(length, width, z_origin), model)
+        vertices = Geometry.create_floor_vertices(length, width, z_origin, @default_azimuths)
+        surface = OpenStudio::Model::Surface.new(vertices, model)
         surface.additionalProperties.setFeature('SurfaceType', 'Floor')
       end
+      surface.additionalProperties.setFeature('Tilt', 0.0)
       set_surface_interior(model, spaces, surface, frame_floor)
       set_surface_exterior(model, spaces, surface, frame_floor)
       surface.setName(frame_floor.id)
@@ -1265,6 +910,7 @@ class OSModel
           end
         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.
@@ -1273,7 +919,7 @@ class OSModel
       end
       assembly_r = frame_floor.insulation_assembly_r_value
 
-      match, constr_set, cavity_r = pick_wood_stud_construction_set(assembly_r, constr_sets, inside_film, outside_film, frame_floor.id)
+      match, constr_set, cavity_r = Constructions.pick_wood_stud_construction_set(assembly_r, constr_sets, inside_film, outside_film, frame_floor.id)
 
       install_grade = 1
       if frame_floor.is_ceiling
@@ -1291,7 +937,7 @@ class OSModel
                                   constr_set.exterior_material, inside_film, outside_film)
       end
 
-      check_surface_assembly_rvalue(runner, [surface], inside_film, outside_film, assembly_r, match)
+      Constructions.check_surface_assembly_rvalue(runner, [surface], inside_film, outside_film, assembly_r, match)
     end
   end
 
@@ -1304,7 +950,7 @@ class OSModel
       slabs = []
       @hpxml.foundation_walls.each do |foundation_wall|
         next unless foundation_wall.interior_adjacent_to == foundation_type
-        next if foundation_wall.net_area < 0.1 # skip modeling net surface area for surfaces comprised entirely of subsurface area
+        next if foundation_wall.net_area < 1.0 # skip modeling net surface area for surfaces comprised entirely of subsurface area
 
         fnd_walls << foundation_wall
       end
@@ -1312,6 +958,7 @@ class OSModel
         next unless slab.interior_adjacent_to == foundation_type
 
         slabs << slab
+        slab.exposed_perimeter = [slab.exposed_perimeter, 1.0].max # minimum value to prevent error if no exposed slab
       end
 
       # Calculate combinations of slabs/walls for each Kiva instance
@@ -1379,7 +1026,7 @@ class OSModel
 
       # For each slab, create a no-wall Kiva slab instance if needed.
       slabs.each do |slab|
-        next unless no_wall_slab_exp_perim[slab] > 0.1
+        next unless no_wall_slab_exp_perim[slab] > 1.0
 
         z_origin = 0
         slab_area = total_slab_area * no_wall_slab_exp_perim[slab] / total_slab_exp_perim
@@ -1396,7 +1043,7 @@ class OSModel
 
         ag_height = foundation_wall.height - foundation_wall.depth_below_grade
         ag_net_area = foundation_wall.net_area * ag_height / foundation_wall.height
-        next if ag_net_area < 0.1
+        next if ag_net_area < 1.0
 
         length = ag_net_area / ag_height
         z_origin = -1 * ag_height
@@ -1406,7 +1053,8 @@ class OSModel
           azimuth = foundation_wall.azimuth
         end
 
-        surface = OpenStudio::Model::Surface.new(add_wall_polygon(length, ag_height, z_origin, azimuth), model)
+        vertices = Geometry.create_wall_vertices(length, ag_height, z_origin, azimuth)
+        surface = OpenStudio::Model::Surface.new(vertices, model)
         surface.additionalProperties.setFeature('Length', length)
         surface.additionalProperties.setFeature('Azimuth', azimuth)
         surface.additionalProperties.setFeature('Tilt', 90.0)
@@ -1437,8 +1085,8 @@ class OSModel
         end
         mat_ext_finish = nil
 
-        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, foundation_wall.id, wall_type, assembly_r,
+                                              drywall_thick_in, inside_film, outside_film, mat_ext_finish)
       end
     end
   end
@@ -1471,7 +1119,8 @@ class OSModel
       subsurface_area = 0
     end
 
-    surface = OpenStudio::Model::Surface.new(add_wall_polygon(length, height, z_origin, azimuth, [0] * 4, subsurface_area), model)
+    vertices = Geometry.create_wall_vertices(length, height, z_origin, azimuth, subsurface_area: subsurface_area)
+    surface = OpenStudio::Model::Surface.new(vertices, model)
     surface.additionalProperties.setFeature('Length', length)
     surface.additionalProperties.setFeature('Azimuth', azimuth)
     surface.additionalProperties.setFeature('Tilt', 90.0)
@@ -1521,7 +1170,7 @@ class OSModel
                                         ext_rigid_r, int_rigid_r, drywall_thick_in, concrete_thick_in, height_ag)
 
     if not assembly_r.nil?
-      check_surface_assembly_rvalue(runner, [surface], inside_film, nil, assembly_r, match)
+      Constructions.check_surface_assembly_rvalue(runner, [surface], inside_film, nil, assembly_r, match)
     end
 
     return surface.adjacentFoundation.get
@@ -1540,7 +1189,8 @@ class OSModel
     slab_length = slab_tot_perim / 4.0 + Math.sqrt(sqrt_term) / 4.0
     slab_width = slab_tot_perim / 4.0 - Math.sqrt(sqrt_term) / 4.0
 
-    surface = OpenStudio::Model::Surface.new(add_floor_polygon(slab_length, slab_width, z_origin), model)
+    vertices = Geometry.create_floor_vertices(slab_length, slab_width, z_origin, @default_azimuths)
+    surface = OpenStudio::Model::Surface.new(vertices, model)
     surface.setName(slab.id)
     surface.setSurfaceType('Floor')
     surface.setOutsideBoundaryCondition('Foundation')
@@ -1593,7 +1243,8 @@ class OSModel
     sum_cfa = 0.0
     @hpxml.frame_floors.each do |frame_floor|
       next unless frame_floor.is_floor
-      next unless frame_floor.interior_adjacent_to == HPXML::LocationLivingSpace
+      next unless [HPXML::LocationLivingSpace, HPXML::LocationBasementConditioned].include?(frame_floor.interior_adjacent_to) ||
+                  [HPXML::LocationLivingSpace, HPXML::LocationBasementConditioned].include?(frame_floor.exterior_adjacent_to)
 
       sum_cfa += frame_floor.area
     end
@@ -1604,14 +1255,18 @@ class OSModel
     end
 
     addtl_cfa = @cfa - sum_cfa
-    return unless addtl_cfa > 0.1
+
+    fail if addtl_cfa < -1.0 # Allow some rounding; EPvalidator.xml should prevent this
+
+    return unless addtl_cfa > 1.0 # Allow some rounding
 
     floor_width = Math::sqrt(addtl_cfa)
     floor_length = addtl_cfa / floor_width
     z_origin = @foundation_top + 8.0 * (@ncfl_ag - 1)
 
     # Add floor surface
-    floor_surface = OpenStudio::Model::Surface.new(add_floor_polygon(-floor_width, -floor_length, z_origin), model)
+    vertices = Geometry.create_floor_vertices(floor_length, floor_width, z_origin, @default_azimuths)
+    floor_surface = OpenStudio::Model::Surface.new(vertices, model)
 
     floor_surface.setSunExposure('NoSun')
     floor_surface.setWindExposure('NoWind')
@@ -1620,9 +1275,11 @@ class OSModel
     floor_surface.setSpace(create_or_get_space(model, spaces, HPXML::LocationLivingSpace))
     floor_surface.setOutsideBoundaryCondition('Adiabatic')
     floor_surface.additionalProperties.setFeature('SurfaceType', 'InferredFloor')
+    floor_surface.additionalProperties.setFeature('Tilt', 0.0)
 
     # Add ceiling surface
-    ceiling_surface = OpenStudio::Model::Surface.new(add_ceiling_polygon(-floor_width, -floor_length, z_origin), model)
+    vertices = Geometry.create_ceiling_vertices(floor_length, floor_width, z_origin, @default_azimuths)
+    ceiling_surface = OpenStudio::Model::Surface.new(vertices, model)
 
     ceiling_surface.setSunExposure('NoSun')
     ceiling_surface.setWindExposure('NoWind')
@@ -1631,6 +1288,7 @@ class OSModel
     ceiling_surface.setSpace(create_or_get_space(model, spaces, HPXML::LocationLivingSpace))
     ceiling_surface.setOutsideBoundaryCondition('Adiabatic')
     ceiling_surface.additionalProperties.setFeature('SurfaceType', 'InferredCeiling')
+    ceiling_surface.additionalProperties.setFeature('Tilt', 0.0)
 
     if not @cond_bsmnt_surfaces.empty?
       # assuming added ceiling is in conditioned basement
@@ -1646,13 +1304,13 @@ class OSModel
     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 / @cfa # Ratio of partition wall area to conditioned floor area
+      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])
     else
       drywall_thick_in = 0.5
-      partition_frac_of_cfa = 1.0 # Ratio of partition wall area to conditioned floor area
+      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])
@@ -1666,36 +1324,16 @@ class OSModel
   end
 
   def self.add_neighbors(runner, model, length)
-    z_origin = 0 # shading surface always starts at grade
-
-    shading_surfaces = []
-    @hpxml.neighbor_buildings.each do |neighbor_building|
-      height = neighbor_building.height.nil? ? @walls_top : neighbor_building.height
-
-      shading_surface = OpenStudio::Model::ShadingSurface.new(add_wall_polygon(length, height, z_origin, neighbor_building.azimuth), model)
-      shading_surface.additionalProperties.setFeature('Azimuth', neighbor_building.azimuth)
-      shading_surface.additionalProperties.setFeature('Distance', neighbor_building.distance)
-      shading_surface.setName("Neighbor azimuth #{neighbor_building.azimuth} distance #{neighbor_building.distance}")
-
-      shading_surfaces << shading_surface
-    end
-
-    unless shading_surfaces.empty?
-      shading_surface_group = OpenStudio::Model::ShadingSurfaceGroup.new(model)
-      shading_surface_group.setName(Constants.ObjectNameNeighbors)
-      shading_surfaces.each do |shading_surface|
-        shading_surface.setShadingSurfaceGroup(shading_surface_group)
-      end
-    end
   end
 
-  def self.add_interior_shading_schedule(runner, model, weather)
-    heating_season, cooling_season = HVAC.get_default_heating_and_cooling_seasons(weather)
-    @clg_season_sch = MonthWeekdayWeekendSchedule.new(model, 'cooling season schedule', Array.new(24, 1), Array.new(24, 1), cooling_season, Constants.ScheduleTypeLimitsFraction)
+  def self.add_shading_schedule(runner, model, weather)
+    heating_season, @cooling_season = 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_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)
+    @clg_ssn_sensor.setKeyName(clg_season_sch.schedule.name.to_s)
   end
 
   def self.add_windows(runner, model, spaces, weather)
@@ -1708,28 +1346,32 @@ class OSModel
     end
     @hpxml.collapse_enclosure_surfaces()
 
+    shading_group = nil
+    shading_schedules = {}
+    shading_ems = { sensors: {}, program: nil }
+
     surfaces = []
-    @hpxml.windows.each do |window|
+    @hpxml.windows.each_with_index do |window, i|
       window_height = 4.0 # ft, default
 
       overhang_depth = nil
-      if not window.overhangs_depth.nil?
+      if (not window.overhangs_depth.nil?) && (window.overhangs_depth > 0)
         overhang_depth = window.overhangs_depth
         overhang_distance_to_top = window.overhangs_distance_to_top_of_window
         overhang_distance_to_bottom = window.overhangs_distance_to_bottom_of_window
         window_height = overhang_distance_to_bottom - overhang_distance_to_top
       end
 
-      window_width = window.area / window_height
+      window_length = window.area / window_height
       z_origin = @foundation_top
 
       if window.is_exterior
 
         # Create parent surface slightly bigger than window
-        surface = OpenStudio::Model::Surface.new(add_wall_polygon(window_width, window_height, z_origin,
-                                                                  window.azimuth, [0, 0.001, 0.001, 0.001]), model)
+        vertices = Geometry.create_wall_vertices(window_length, window_height, z_origin, window.azimuth, add_buffer: true)
+        surface = OpenStudio::Model::Surface.new(vertices, model)
 
-        surface.additionalProperties.setFeature('Length', window_width)
+        surface.additionalProperties.setFeature('Length', window_length)
         surface.additionalProperties.setFeature('Azimuth', window.azimuth)
         surface.additionalProperties.setFeature('Tilt', 90.0)
         surface.additionalProperties.setFeature('SurfaceType', 'Window')
@@ -1737,8 +1379,8 @@ class OSModel
         surface.setSurfaceType('Wall')
         set_surface_interior(model, spaces, surface, window.wall)
 
-        sub_surface = OpenStudio::Model::SubSurface.new(add_wall_polygon(window_width, window_height, z_origin,
-                                                                         window.azimuth, [-0.001, 0, 0.001, 0]), model)
+        vertices = Geometry.create_wall_vertices(window_length, window_height, z_origin, window.azimuth)
+        sub_surface = OpenStudio::Model::SubSurface.new(vertices, model)
         sub_surface.setName(window.id)
         sub_surface.setSurface(surface)
         sub_surface.setSubSurfaceType('FixedWindow')
@@ -1752,22 +1394,22 @@ class OSModel
         end
 
         # Apply construction
-        cool_shade_mult = window.interior_shading_factor_summer
-        heat_shade_mult = window.interior_shading_factor_winter
-        Constructions.apply_window(runner, model, [sub_surface],
-                                   'WindowConstruction',
-                                   weather, @clg_season_sch, window.ufactor, window.shgc,
-                                   heat_shade_mult, cool_shade_mult)
+        Constructions.apply_window(runner, model, sub_surface, 'WindowConstruction', window.ufactor, window.shgc)
+
+        # 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)
       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
         # heat transfer; there is no solar gains anyway.
 
         # Create parent surface slightly bigger than window
-        surface = OpenStudio::Model::Surface.new(add_wall_polygon(window_width, window_height, z_origin,
-                                                                  window.azimuth, [0, 0.001, 0.001, 0.001]), model)
+        vertices = Geometry.create_wall_vertices(window_length, window_height, z_origin, window.azimuth, add_buffer: true)
+        surface = OpenStudio::Model::Surface.new(vertices, model)
 
-        surface.additionalProperties.setFeature('Length', window_width)
+        surface.additionalProperties.setFeature('Length', window_length)
         surface.additionalProperties.setFeature('Azimuth', window.azimuth)
         surface.additionalProperties.setFeature('Tilt', 90.0)
         surface.additionalProperties.setFeature('SurfaceType', 'Door')
@@ -1775,8 +1417,8 @@ class OSModel
         surface.setSurfaceType('Wall')
         set_surface_interior(model, spaces, surface, window.wall)
 
-        sub_surface = OpenStudio::Model::SubSurface.new(add_wall_polygon(window_width, window_height, z_origin,
-                                                                         window.azimuth, [0, 0, 0, 0]), model)
+        vertices = Geometry.create_wall_vertices(window_length, window_height, z_origin, window.azimuth)
+        sub_surface = OpenStudio::Model::SubSurface.new(vertices, model)
         sub_surface.setName(window.id)
         sub_surface.setSurface(surface)
         sub_surface.setSubSurfaceType('Door')
@@ -1785,7 +1427,9 @@ class OSModel
         surfaces << surface
 
         # Apply construction
-        Constructions.apply_door(runner, model, [sub_surface], 'Window', window.ufactor)
+        inside_film = Material.AirFilmVertical
+        outside_film = Material.AirFilmVertical
+        Constructions.apply_door(runner, model, [sub_surface], 'Window', window.ufactor, inside_film, outside_film)
       end
     end
 
@@ -1794,16 +1438,20 @@ class OSModel
 
   def self.add_skylights(runner, model, spaces, weather)
     surfaces = []
-    @hpxml.skylights.each do |skylight|
+
+    shading_group = nil
+    shading_schedules = {}
+    shading_ems = { sensors: {}, program: nil }
+
+    @hpxml.skylights.each_with_index do |skylight, i|
       tilt = skylight.roof.pitch / 12.0
       width = Math::sqrt(skylight.area)
       length = skylight.area / width
       z_origin = @walls_top + 0.5 * Math.sin(Math.atan(tilt)) * width
 
       # Create parent surface slightly bigger than skylight
-      surface = OpenStudio::Model::Surface.new(add_roof_polygon(length + 0.001, width + 0.001, z_origin,
-                                                                skylight.azimuth, tilt), model)
-
+      vertices = Geometry.create_roof_vertices(length, width, z_origin, skylight.azimuth, tilt, add_buffer: true)
+      surface = OpenStudio::Model::Surface.new(vertices, model)
       surface.additionalProperties.setFeature('Length', length)
       surface.additionalProperties.setFeature('Width', width)
       surface.additionalProperties.setFeature('Azimuth', skylight.azimuth)
@@ -1815,21 +1463,19 @@ class OSModel
       surface.setOutsideBoundaryCondition('Outdoors') # cannot be adiabatic because subsurfaces won't be created
       surfaces << surface
 
-      sub_surface = OpenStudio::Model::SubSurface.new(add_roof_polygon(length, width, z_origin,
-                                                                       skylight.azimuth, tilt), model)
+      vertices = Geometry.create_roof_vertices(length, width, z_origin, skylight.azimuth, tilt)
+      sub_surface = OpenStudio::Model::SubSurface.new(vertices, model)
       sub_surface.setName(skylight.id)
       sub_surface.setSurface(surface)
       sub_surface.setSubSurfaceType('Skylight')
 
       # Apply construction
-      ufactor = skylight.ufactor
-      shgc = skylight.shgc
-      cool_shade_mult = skylight.interior_shading_factor_summer
-      heat_shade_mult = skylight.interior_shading_factor_winter
-      Constructions.apply_skylight(runner, model, [sub_surface],
-                                   'SkylightConstruction',
-                                   weather, @clg_season_sch, ufactor, shgc,
-                                   heat_shade_mult, cool_shade_mult)
+      Constructions.apply_skylight(runner, model, sub_surface, 'SkylightConstruction', skylight.ufactor, skylight.shgc)
+
+      # 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)
     end
 
     apply_adiabatic_construction(runner, model, surfaces, 'roof')
@@ -1839,14 +1485,14 @@ class OSModel
     surfaces = []
     @hpxml.doors.each do |door|
       door_height = 6.67 # ft
-      door_width = door.area / door_height
+      door_length = door.area / door_height
       z_origin = @foundation_top
 
       # Create parent surface slightly bigger than door
-      surface = OpenStudio::Model::Surface.new(add_wall_polygon(door_width, door_height, z_origin,
-                                                                door.azimuth, [0, 0.001, 0.001, 0.001]), model)
+      vertices = Geometry.create_wall_vertices(door_length, door_height, z_origin, door.azimuth, add_buffer: true)
+      surface = OpenStudio::Model::Surface.new(vertices, model)
 
-      surface.additionalProperties.setFeature('Length', door_width)
+      surface.additionalProperties.setFeature('Length', door_length)
       surface.additionalProperties.setFeature('Azimuth', door.azimuth)
       surface.additionalProperties.setFeature('Tilt', 90.0)
       surface.additionalProperties.setFeature('SurfaceType', 'Door')
@@ -1854,8 +1500,8 @@ class OSModel
       surface.setSurfaceType('Wall')
       set_surface_interior(model, spaces, surface, door.wall)
 
-      sub_surface = OpenStudio::Model::SubSurface.new(add_wall_polygon(door_width, door_height, z_origin,
-                                                                       door.azimuth, [0, 0, 0, 0]), model)
+      vertices = Geometry.create_wall_vertices(door_length, door_height, z_origin, door.azimuth)
+      sub_surface = OpenStudio::Model::SubSurface.new(vertices, model)
       sub_surface.setName(door.id)
       sub_surface.setSurface(surface)
       sub_surface.setSubSurfaceType('Door')
@@ -1865,7 +1511,13 @@ class OSModel
 
       # Apply construction
       ufactor = 1.0 / door.r_value
-      Constructions.apply_door(runner, model, [sub_surface], 'Door', ufactor)
+      inside_film = Material.AirFilmVertical
+      if door.wall.is_exterior
+        outside_film = Material.AirFilmOutside
+      else
+        outside_film = Material.AirFilmVertical
+      end
+      Constructions.apply_door(runner, model, [sub_surface], 'Door', ufactor, inside_film, outside_film)
     end
 
     apply_adiabatic_construction(runner, model, surfaces, 'wall')
@@ -1901,25 +1553,6 @@ class OSModel
   end
 
   def self.add_hot_water_and_appliances(runner, model, weather, spaces)
-    if @hpxml.clothes_washers.empty?
-      runner.registerWarning('No clothes washer specified, the model will not include clothes washer energy use.')
-    end
-    if @hpxml.clothes_dryers.empty?
-      runner.registerWarning('No clothes dryer specified, the model will not include clothes dryer energy use.')
-    end
-    if @hpxml.dishwashers.empty?
-      runner.registerWarning('No dishwasher specified, the model will not include dishwasher energy use.')
-    end
-    if @hpxml.refrigerators.empty?
-      runner.registerWarning('No refrigerator specified, the model will not include refrigerator energy use.')
-    end
-    if @hpxml.cooking_ranges.empty?
-      runner.registerWarning('No cooking range specified, the model will not include cooking range/oven energy use.')
-    end
-    if @hpxml.water_heating_systems.empty?
-      runner.registerWarning('No water heater specified, the model will not include water heating energy use.')
-    end
-
     # Assign spaces
     @hpxml.clothes_washers.each do |clothes_washer|
       clothes_washer.additional_properties.space = get_space_from_location(clothes_washer.location, 'ClothesWasher', model, spaces)
@@ -1952,10 +1585,11 @@ class OSModel
     end
 
     # Water Heater
+    has_uncond_bsmnt = @hpxml.has_space_type(HPXML::LocationBasementUnconditioned)
     @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)
+      ec_adj = HotWaterAndAppliances.get_dist_energy_consumption_adjustment(has_uncond_bsmnt, @cfa, @ncfl, water_heating_system, hot_water_distribution)
 
       if water_heating_system.water_heater_type == HPXML::WaterHeaterTypeStorage
 
@@ -1987,11 +1621,7 @@ class OSModel
     end
 
     # Hot water fixtures and appliances
-    HotWaterAndAppliances.apply(model, runner, weather, spaces[HPXML::LocationLivingSpace],
-                                @cfa, @nbeds, @ncfl, @has_uncond_bsmnt, @hpxml.clothes_washers,
-                                @hpxml.clothes_dryers, @hpxml.dishwashers, @hpxml.refrigerators,
-                                @hpxml.freezers, @hpxml.cooking_ranges, @hpxml.ovens, @hpxml.water_heating,
-                                @hpxml.water_heating_systems, hot_water_distribution, @hpxml.water_fixtures,
+    HotWaterAndAppliances.apply(model, runner, @hpxml, weather, spaces, hot_water_distribution,
                                 solar_thermal_system, @eri_version, @dhw_map, @schedules_file)
 
     if (not solar_thermal_system.nil?) && (not solar_thermal_system.collector_area.nil?) # Detailed solar water heater
@@ -2003,33 +1633,19 @@ class OSModel
     Waterheater.apply_combi_system_EMS(model, @dhw_map, @hpxml.water_heating_systems)
   end
 
-  def self.is_central_air_conditioner_and_furnace(heating_system, cooling_system)
-    if not (@hpxml.heating_systems.include?(heating_system) && (heating_system.heating_system_type == HPXML::HVACTypeFurnace))
-      return false
-    end
-    if not (@hpxml.cooling_systems.include?(cooling_system) && (cooling_system.cooling_system_type == HPXML::HVACTypeCentralAirConditioner))
-      return false
-    end
-
-    return true
-  end
-
-  def self.update_shared_hvac_systems()
-    HVAC.apply_shared_systems(@hpxml)
-  end
-
   def self.add_cooling_system(runner, model, spaces)
     living_zone = spaces[HPXML::LocationLivingSpace].thermalZone.get
 
-    @hpxml.cooling_systems.each do |cooling_system|
-      check_distribution_system(cooling_system.distribution_system, cooling_system.cooling_system_type)
+    HVAC.get_hpxml_hvac_systems(@hpxml).each do |hvac_system|
+      next if hvac_system[:cooling].nil?
+      next unless hvac_system[:cooling].is_a? HPXML::CoolingSystem
 
-      if cooling_system.cooling_system_type == HPXML::HVACTypeCentralAirConditioner
+      cooling_system = hvac_system[:cooling]
+      heating_system = hvac_system[:heating]
 
-        heating_system = cooling_system.attached_heating_system
-        if not is_central_air_conditioner_and_furnace(heating_system, cooling_system)
-          heating_system = nil
-        end
+      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,
@@ -2039,19 +1655,19 @@ class OSModel
           @remaining_heat_load_frac -= heating_system.fraction_heat_load_served
         end
 
-      elsif cooling_system.cooling_system_type == HPXML::HVACTypeRoomAirConditioner
+      elsif [HPXML::HVACTypeRoomAirConditioner].include? cooling_system.cooling_system_type
 
         HVAC.apply_room_air_conditioner(model, runner, cooling_system,
                                         @remaining_cool_load_frac, living_zone,
                                         @hvac_map)
 
-      elsif cooling_system.cooling_system_type == HPXML::HVACTypeEvaporativeCooler
+      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 cooling_system.cooling_system_type == HPXML::HVACTypeMiniSplitAirConditioner
+      elsif [HPXML::HVACTypeMiniSplitAirConditioner].include? cooling_system.cooling_system_type
 
         HVAC.apply_mini_split_air_conditioner(model, runner, cooling_system,
                                               @remaining_cool_load_frac,
@@ -2065,13 +1681,18 @@ class OSModel
   def self.add_heating_system(runner, model, spaces)
     living_zone = spaces[HPXML::LocationLivingSpace].thermalZone.get
 
-    @hpxml.heating_systems.each do |heating_system|
+    HVAC.get_hpxml_hvac_systems(@hpxml).each do |hvac_system|
+      next if hvac_system[:heating].nil?
+      next unless hvac_system[:heating].is_a? HPXML::HeatingSystem
+
+      cooling_system = hvac_system[:cooling]
+      heating_system = hvac_system[:heating]
+
       check_distribution_system(heating_system.distribution_system, heating_system.heating_system_type)
 
-      if heating_system.heating_system_type == HPXML::HVACTypeFurnace
+      if [HPXML::HVACTypeFurnace].include? heating_system.heating_system_type
 
-        cooling_system = heating_system.attached_cooling_system
-        if is_central_air_conditioner_and_furnace(heating_system, cooling_system)
+        if not cooling_system.nil?
           next # Already processed combined AC+furnace
         end
 
@@ -2079,22 +1700,22 @@ class OSModel
                                                    nil, @remaining_heat_load_frac,
                                                    living_zone, @hvac_map)
 
-      elsif heating_system.heating_system_type == HPXML::HVACTypeBoiler
+      elsif [HPXML::HVACTypeBoiler].include? heating_system.heating_system_type
 
         HVAC.apply_boiler(model, runner, heating_system,
                           @remaining_heat_load_frac, living_zone, @hvac_map)
 
-      elsif heating_system.heating_system_type == HPXML::HVACTypeElectricResistance
+      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)
 
-      elsif (heating_system.heating_system_type == HPXML::HVACTypeStove ||
-             heating_system.heating_system_type == HPXML::HVACTypePortableHeater ||
-             heating_system.heating_system_type == HPXML::HVACTypeFixedHeater ||
-             heating_system.heating_system_type == HPXML::HVACTypeWallFurnace ||
-             heating_system.heating_system_type == HPXML::HVACTypeFloorFurnace ||
-             heating_system.heating_system_type == HPXML::HVACTypeFireplace)
+      elsif [HPXML::HVACTypeStove,
+             HPXML::HVACTypePortableHeater,
+             HPXML::HVACTypeFixedHeater,
+             HPXML::HVACTypeWallFurnace,
+             HPXML::HVACTypeFloorFurnace,
+             HPXML::HVACTypeFireplace].include? heating_system.heating_system_type
 
         HVAC.apply_unit_heater(model, runner, heating_system,
                                @remaining_heat_load_frac, living_zone, @hvac_map)
@@ -2107,45 +1728,36 @@ class OSModel
   def self.add_heat_pump(runner, model, weather, spaces)
     living_zone = spaces[HPXML::LocationLivingSpace].thermalZone.get
 
-    @hpxml.heat_pumps.each do |heat_pump|
-      # FUTURE: Move these checks into hvac.rb
-      if not heat_pump.heating_capacity_17F.nil?
-        if heat_pump.heating_capacity.nil?
-          fail "HeatPump '#{heat_pump.id}' must have both HeatingCapacity and HeatingCapacity17F provided or not provided."
-        elsif heat_pump.heating_capacity == 0.0
-          heat_pump.heating_capacity_17F = nil
-        end
-      end
-      if not heat_pump.backup_heating_fuel.nil?
-        if heat_pump.backup_heating_capacity.nil? ^ heat_pump.heating_capacity.nil?
-          fail "HeatPump '#{heat_pump.id}' must have both HeatingCapacity and BackupHeatingCapacity provided or not provided."
-        end
-      end
+    HVAC.get_hpxml_hvac_systems(@hpxml).each do |hvac_system|
+      next if hvac_system[:cooling].nil?
+      next unless hvac_system[:cooling].is_a? HPXML::HeatPump
+
+      heat_pump = hvac_system[:cooling]
 
       check_distribution_system(heat_pump.distribution_system, heat_pump.heat_pump_type)
 
-      if heat_pump.heat_pump_type == HPXML::HVACTypeHeatPumpWaterLoopToAir
+      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 heat_pump.heat_pump_type == HPXML::HVACTypeHeatPumpAirToAir
+      elsif [HPXML::HVACTypeHeatPumpAirToAir].include? heat_pump.heat_pump_type
 
         HVAC.apply_central_air_to_air_heat_pump(model, runner, heat_pump,
                                                 @remaining_heat_load_frac,
                                                 @remaining_cool_load_frac,
                                                 living_zone, @hvac_map)
 
-      elsif heat_pump.heat_pump_type == HPXML::HVACTypeHeatPumpMiniSplit
+      elsif [HPXML::HVACTypeHeatPumpMiniSplit].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)
 
-      elsif heat_pump.heat_pump_type == HPXML::HVACTypeHeatPumpGroundToAir
+      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,
@@ -2165,7 +1777,7 @@ class OSModel
     living_zone = spaces[HPXML::LocationLivingSpace].thermalZone.get
     obj_name = Constants.ObjectNameIdealAirSystem
 
-    if @hpxml.building_construction.use_only_ideal_air_system
+    if @apply_ashrae140_assumptions && (@hpxml.total_fraction_heat_load_served + @hpxml.total_fraction_heat_load_served == 0.0)
       cooling_load_frac = 1.0
       heating_load_frac = 1.0
       if @apply_ashrae140_assumptions
@@ -2212,19 +1824,17 @@ class OSModel
     obj_name = Constants.ObjectNameIdealAirSystemResidual
 
     if @remaining_cool_load_frac < 1.0
-      sequential_cool_load_frac = 1
+      sequential_cool_load_frac = 1.0
     else
-      sequential_cool_load_frac = 0 # no cooling system, don't add ideal air for cooling either
-      runner.registerWarning('No cooling system specified, the model will not include space cooling energy use.')
+      sequential_cool_load_frac = 0.0 # no cooling system, don't add ideal air for cooling either
     end
 
     if @remaining_heat_load_frac < 1.0
-      sequential_heat_load_frac = 1
+      sequential_heat_load_frac = 1.0
     else
-      sequential_heat_load_frac = 0 # no heating system, don't add ideal air for heating either
-      runner.registerWarning('No heating system specified, the model will not include space heating energy use.')
+      sequential_heat_load_frac = 0.0 # no heating system, don't add ideal air for heating either
     end
-    if (sequential_heat_load_frac > 0) || (sequential_cool_load_frac > 0)
+    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
@@ -2235,8 +1845,9 @@ class OSModel
 
     hvac_control = @hpxml.hvac_controls[0]
     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)
+    HVAC.apply_setpoints(model, runner, weather, hvac_control, living_zone, has_ceiling_fan)
   end
 
   def self.add_ceiling_fans(runner, model, weather, spaces)
@@ -2246,25 +1857,24 @@ class OSModel
     HVAC.apply_ceiling_fans(model, runner, weather, ceiling_fan, spaces[HPXML::LocationLivingSpace], @schedules_file)
   end
 
-  def self.add_dehumidifier(runner, model, spaces)
+  def self.add_dehumidifiers(runner, model, spaces)
     return if @hpxml.dehumidifiers.size == 0
 
-    dehumidifier = @hpxml.dehumidifiers[0]
-    HVAC.apply_dehumidifier(model, runner, dehumidifier, spaces[HPXML::LocationLivingSpace], @hvac_map)
+    HVAC.apply_dehumidifiers(model, runner, @hpxml.dehumidifiers, spaces[HPXML::LocationLivingSpace], @hvac_map)
   end
 
   def self.check_distribution_system(hvac_distribution, system_type)
     return if hvac_distribution.nil?
 
     hvac_distribution_type_map = { HPXML::HVACTypeFurnace => [HPXML::HVACDistributionTypeAir, HPXML::HVACDistributionTypeDSE],
-                                   HPXML::HVACTypeBoiler => [HPXML::HVACDistributionTypeHydronic, HPXML::HVACDistributionTypeHydronicAndAir, HPXML::HVACDistributionTypeDSE],
+                                   HPXML::HVACTypeBoiler => [HPXML::HVACDistributionTypeHydronic, HPXML::HVACDistributionTypeAir, HPXML::HVACDistributionTypeDSE],
                                    HPXML::HVACTypeCentralAirConditioner => [HPXML::HVACDistributionTypeAir, HPXML::HVACDistributionTypeDSE],
                                    HPXML::HVACTypeEvaporativeCooler => [HPXML::HVACDistributionTypeAir, HPXML::HVACDistributionTypeDSE],
                                    HPXML::HVACTypeMiniSplitAirConditioner => [HPXML::HVACDistributionTypeAir, HPXML::HVACDistributionTypeDSE],
                                    HPXML::HVACTypeHeatPumpAirToAir => [HPXML::HVACDistributionTypeAir, HPXML::HVACDistributionTypeDSE],
                                    HPXML::HVACTypeHeatPumpMiniSplit => [HPXML::HVACDistributionTypeAir, HPXML::HVACDistributionTypeDSE],
                                    HPXML::HVACTypeHeatPumpGroundToAir => [HPXML::HVACDistributionTypeAir, HPXML::HVACDistributionTypeDSE],
-                                   HPXML::HVACTypeHeatPumpWaterLoopToAir => [HPXML::HVACDistributionTypeAir, HPXML::HVACDistributionTypeHydronicAndAir, HPXML::HVACDistributionTypeDSE] }
+                                   HPXML::HVACTypeHeatPumpWaterLoopToAir => [HPXML::HVACDistributionTypeAir, HPXML::HVACDistributionTypeDSE] }
 
     if not hvac_distribution_type_map[system_type].include? hvac_distribution.distribution_system_type
       # validator.rb only checks that a HVAC distribution system of the correct type (for the given HVAC system) exists
@@ -2275,7 +1885,6 @@ class OSModel
 
   def self.add_mels(runner, model, spaces)
     # Misc
-    modeled_mels = []
     @hpxml.plug_loads.each do |plug_load|
       if plug_load.plug_load_type == HPXML::PlugLoadTypeOther
         obj_name = Constants.ObjectNameMiscPlugLoads
@@ -2290,15 +1899,8 @@ class OSModel
         runner.registerWarning("Unexpected plug load type '#{plug_load.plug_load_type}'. The plug load will not be modeled.")
         next
       end
-      modeled_mels << plug_load.plug_load_type
 
-      MiscLoads.apply_plug(model, plug_load, obj_name, spaces[HPXML::LocationLivingSpace], @schedules_file)
-    end
-    if not modeled_mels.include? HPXML::PlugLoadTypeOther
-      runner.registerWarning("No '#{HPXML::PlugLoadTypeOther}' plug loads specified, the model will not include misc plug load energy use.")
-    end
-    if not modeled_mels.include? HPXML::PlugLoadTypeTelevision
-      runner.registerWarning("No '#{HPXML::PlugLoadTypeTelevision}' plug loads specified, the model will not include television plug load energy use.")
+      MiscLoads.apply_plug(model, plug_load, obj_name, spaces[HPXML::LocationLivingSpace], @apply_ashrae140_assumptions, @schedules_file)
     end
   end
 
@@ -2328,37 +1930,25 @@ class OSModel
 
   def self.add_pools_and_hot_tubs(runner, model, spaces)
     @hpxml.pools.each do |pool|
+      next if pool.type == HPXML::TypeNone
+
       MiscLoads.apply_pool_or_hot_tub_heater(model, pool, Constants.ObjectNameMiscPoolHeater, spaces[HPXML::LocationLivingSpace], @schedules_file)
       MiscLoads.apply_pool_or_hot_tub_pump(model, pool, Constants.ObjectNameMiscPoolPump, spaces[HPXML::LocationLivingSpace], @schedules_file)
     end
 
     @hpxml.hot_tubs.each do |hot_tub|
+      next if hot_tub.type == HPXML::TypeNone
+
       MiscLoads.apply_pool_or_hot_tub_heater(model, hot_tub, Constants.ObjectNameMiscHotTubHeater, spaces[HPXML::LocationLivingSpace], @schedules_file)
       MiscLoads.apply_pool_or_hot_tub_pump(model, hot_tub, Constants.ObjectNameMiscHotTubPump, spaces[HPXML::LocationLivingSpace], @schedules_file)
     end
   end
 
   def self.add_airflow(runner, model, weather, spaces)
-    # Vented Attic
-    vented_attic = nil
-    @hpxml.attics.each do |attic|
-      next unless attic.attic_type == HPXML::AtticTypeVented
-
-      vented_attic = attic
-    end
-
-    # Vented Crawlspace
-    vented_crawl = nil
-    @hpxml.foundations.each do |foundation|
-      next unless foundation.foundation_type == HPXML::FoundationTypeCrawlspaceVented
-
-      vented_crawl = foundation
-    end
-
     # Ducts
     duct_systems = {}
     @hpxml.hvac_distributions.each do |hvac_distribution|
-      next unless [HPXML::HVACDistributionTypeAir, HPXML::HVACDistributionTypeHydronicAndAir].include? hvac_distribution.distribution_system_type
+      next unless hvac_distribution.distribution_system_type == HPXML::HVACDistributionTypeAir
 
       air_ducts = create_ducts(runner, model, hvac_distribution, spaces)
       next if air_ducts.empty?
@@ -2367,7 +1957,7 @@ class OSModel
       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
+          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
@@ -2381,37 +1971,14 @@ class OSModel
           end
         end
       end
-      if not added_ducts
-        # Check if ducted fan coil, which doesn't have an AirLoopHVAC;
-        # assign to FanCoil instead.
-        if hvac_distribution.distribution_system_type && hvac_distribution.hydronic_and_air_type == HPXML::HydronicAndAirTypeFanCoil
-          hvac_distribution.hvac_systems.each do |hvac_system|
-            @hvac_map[hvac_system.id].each do |object|
-              next unless object.is_a? OpenStudio::Model::ZoneHVACFourPipeFanCoil
-
-              duct_systems[air_ducts] = object
-              added_ducts = true
-            end
-          end
-        end
-      end
       if not added_ducts
         fail 'Unexpected error adding ducts to model.'
       end
     end
 
-    air_infils = @hpxml.air_infiltration_measurements
-    window_area = @hpxml.windows.map { |w| w.area }.sum(0.0)
-    open_window_area = window_area * @frac_windows_operable * 0.5 * 0.2 # Assume A) 50% of the area of an operable window can be open, and B) 20% of openable window area is actually open
-    site_type = @hpxml.site.site_type
-    shelter_coef = @hpxml.site.shelter_coefficient
-    @infil_volume = air_infils.select { |i| !i.infiltration_volume.nil? }[0].infiltration_volume
-    infil_height = @hpxml.inferred_infiltration_height(@infil_volume)
-    Airflow.apply(model, runner, weather, spaces, air_infils, @hpxml.ventilation_fans, @hpxml.clothes_dryers, @nbeds,
-                  duct_systems, @infil_volume, infil_height, open_window_area,
-                  @clg_ssn_sensor, @min_neighbor_distance, vented_attic, vented_crawl,
-                  site_type, shelter_coef, @hpxml.building_construction.has_flue_or_chimney, @hvac_map, @eri_version,
-                  @apply_ashrae140_assumptions, @schedules_file)
+    Airflow.apply(model, runner, weather, spaces, @hpxml, @cfa, @nbeds,
+                  @ncfl_ag, duct_systems, @clg_ssn_sensor, @hvac_map, @eri_version,
+                  @frac_windows_operable, @apply_ashrae140_assumptions, @schedules_file)
   end
 
   def self.create_ducts(runner, model, hvac_distribution, spaces)
@@ -2464,14 +2031,9 @@ class OSModel
     end
 
     # If all ducts are in conditioned space, model leakage as going to outside
-    registered_warning = false
     [HPXML::DuctTypeSupply, HPXML::DuctTypeReturn].each do |duct_side|
       next unless (leakage_to_outside[duct_side][0] > 0) && (total_unconditioned_duct_area[duct_side] == 0)
 
-      if not registered_warning
-        runner.registerWarning("HVACDistribution '#{hvac_distribution.id}' has ducts entirely within conditioned space but there is non-zero leakage to the outside. Leakage to the outside is typically zero in these situations; consider revising leakage values. Leakage will be modeled as heat lost to the ambient environment.")
-        registered_warning = true
-      end
       duct_area = 0.0
       duct_rvalue = 0.0
       duct_loc_space = nil # outside
@@ -2495,33 +2057,23 @@ class OSModel
     return air_ducts
   end
 
-  def self.add_hvac_sizing(runner, model, weather, spaces)
-    HVACSizing.apply(model, runner, weather, spaces, @hpxml, @infil_volume, @nbeds, @min_neighbor_distance, @debug)
-  end
-
-  def self.add_furnace_eae(runner, model)
-    # Needs to come after HVAC sizing (needs heating capacity and airflow rate)
-    # FUTURE: Could remove this method and simplify everything if we could autosize via the HPXML file
-
-    @hpxml.heating_systems.each do |heating_system|
-      next unless heating_system.fraction_heat_load_served > 0
-      next unless [HPXML::HVACTypeFurnace, HPXML::HVACTypeWallFurnace, HPXML::HVACTypeFloorFurnace, HPXML::HVACTypeStove].include? heating_system.heating_system_type
-      next unless heating_system.heating_system_fuel != HPXML::FuelTypeElectricity
-
-      HVAC.apply_eae_to_heating_fan(runner, @hvac_map[heating_system.id], heating_system)
-    end
-  end
-
   def self.add_photovoltaics(runner, model)
     @hpxml.pv_systems.each do |pv_system|
       PV.apply(model, @nbeds, pv_system)
     end
   end
 
-  def self.add_additional_properties(runner, model, hpxml_path)
+  def self.add_generators(runner, model)
+    @hpxml.generators.each do |generator|
+      Generator.apply(model, @nbeds, generator)
+    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('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
@@ -2538,31 +2090,71 @@ class OSModel
     return map_str.to_s
   end
 
-  def self.add_component_loads_output(runner, model, spaces)
+  def self.add_loads_output(runner, model, spaces, add_component_loads)
     living_zone = spaces[HPXML::LocationLivingSpace].thermalZone.get
 
-    # Prevent certain objects (e.g., OtherEquipment) from being counted towards both, e.g., ducts and internal gains
-    objects_already_processed = []
+    liv_load_sensors, intgain_dehumidifier = add_total_loads_output(runner, model, living_zone)
+    return unless add_component_loads
 
-    # EMS Sensors: Global
+    add_component_loads_output(runner, model, living_zone, liv_load_sensors, intgain_dehumidifier)
+  end
 
+  def self.add_total_loads_output(runner, model, living_zone)
     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')
 
     tot_load_sensors = {}
-
     tot_load_sensors[:htg] = OpenStudio::Model::EnergyManagementSystemSensor.new(model, 'Heating:EnergyTransfer')
     tot_load_sensors[:htg].setName('htg_load_tot')
-
     tot_load_sensors[:clg] = OpenStudio::Model::EnergyManagementSystemSensor.new(model, 'Cooling:EnergyTransfer')
     tot_load_sensors[:clg].setName('clg_load_tot')
 
-    load_adj_sensors = {} # Sensors used to adjust E+ EnergyTransfer meter, eg. dehumidifier as load in our program, but included in Heating:EnergyTransfer as HVAC equipment
+    # Need to adjusted E+ EnergyTransfer meters for dehumidifiers
+    intgain_dehumidifier = nil
+    model.getZoneHVACDehumidifierDXs.each do |e|
+      next unless e.thermalZone.get.name.to_s == living_zone.name.to_s
+
+      { 'Zone Dehumidifier Sensible Heating Energy' => 'ig_dehumidifier' }.each do |var, name|
+        intgain_dehumidifier = OpenStudio::Model::EnergyManagementSystemSensor.new(model, var)
+        intgain_dehumidifier.setName(name)
+        intgain_dehumidifier.setKeyName(e.name.to_s)
+      end
+    end
+
+    # EMS program
+    program = OpenStudio::Model::EnergyManagementSystemProgram.new(model)
+    program.setName(Constants.ObjectNameTotalLoadsProgram)
+    program.addLine('Set loads_htg_tot = 0')
+    program.addLine('Set loads_clg_tot = 0')
+    program.addLine("If #{liv_load_sensors[:htg].name} > 0")
+    s = "  Set loads_htg_tot = #{tot_load_sensors[:htg].name} - #{tot_load_sensors[:clg].name}"
+    if not intgain_dehumidifier.nil?
+      s += " - #{intgain_dehumidifier.name}"
+    end
+    program.addLine(s)
+    program.addLine("ElseIf #{liv_load_sensors[:clg].name} > 0")
+    s = "  Set loads_clg_tot = #{tot_load_sensors[:clg].name} - #{tot_load_sensors[:htg].name}"
+    if not intgain_dehumidifier.nil?
+      s += " + #{intgain_dehumidifier.name}"
+    end
+    program.addLine(s)
+    program.addLine('EndIf')
+
+    # EMS calling manager
+    program_calling_manager = OpenStudio::Model::EnergyManagementSystemProgramCallingManager.new(model)
+    program_calling_manager.setName("#{program.name} calling manager")
+    program_calling_manager.setCallingPoint('EndOfZoneTimestepAfterZoneReporting')
+    program_calling_manager.addProgram(program)
+
+    return liv_load_sensors, intgain_dehumidifier
+  end
+
+  def self.add_component_loads_output(runner, model, living_zone, liv_load_sensors, intgain_dehumidifier)
+    # Prevent certain objects (e.g., OtherEquipment) from being counted towards both, e.g., ducts and internal gains
+    objects_already_processed = []
 
     # EMS Sensors: Surfaces, SubSurfaces, InternalMass
 
@@ -2582,6 +2174,8 @@ class OSModel
     output_diagnostics = model.getOutputDiagnostics
     output_diagnostics.addKey('DisplayAdvancedReportVariables')
 
+    area_tolerance = UnitConversions.convert(1.0, 'ft^2', 'm^2')
+
     model.getSurfaces.sort.each_with_index do |s, idx|
       next unless s.space.get.thermalZone.get.name.to_s == living_zone.name.to_s
 
@@ -2624,7 +2218,7 @@ class OSModel
         end
       end
 
-      next if s.netArea < 0.1 # Skip parent surfaces (of subsurfaces) that have near zero net area
+      next if s.netArea < area_tolerance # Skip parent surfaces (of subsurfaces) that have near zero net area
 
       key = { 'FoundationWall' => :foundation_walls,
               'RimJoist' => :rim_joists,
@@ -2704,9 +2298,7 @@ class OSModel
 
     infil_flow_actuators = []
     natvent_flow_actuators = []
-    mechvent_flow_actuators = []
     whf_flow_actuators = []
-    cd_flow_actuators = []
 
     model.getEnergyManagementSystemActuators.each do |actuator|
       next unless (actuator.actuatedComponentType == 'Zone Infiltration') && (actuator.actuatedComponentControlType == 'Air Exchange Flow Rate')
@@ -2717,18 +2309,15 @@ class OSModel
         natvent_flow_actuators << actuator
       elsif actuator.name.to_s.start_with? Constants.ObjectNameWholeHouseFan.gsub(' ', '_')
         whf_flow_actuators << actuator
-      elsif actuator.name.to_s.start_with? Constants.ObjectNameClothesDryerExhaust.gsub(' ', '_')
-        cd_flow_actuators << actuator
       end
     end
-    if (infil_flow_actuators.size != 1) || (natvent_flow_actuators.size != 1) || (whf_flow_actuators.size != 1) || (cd_flow_actuators.size != 1)
+    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]
-    cd_flow_actuator = cd_flow_actuators[0]
 
     # EMS Sensors: Ducts
 
@@ -2755,27 +2344,7 @@ class OSModel
       ducts_mix_loss_sensor.setKeyName(living_zone.name.to_s)
     end
 
-    # Return duct losses
-    model.getOtherEquipments.sort.each do |o|
-      next if objects_already_processed.include? o
-
-      is_duct_load = o.additionalProperties.getFeatureAsBoolean(Constants.IsDuctLoadForReport)
-      next unless is_duct_load.is_initialized
-
-      objects_already_processed << o
-      next unless is_duct_load.get
-
-      ducts_sensors << []
-      { 'Other Equipment Convective Heating Energy' => 'ducts_conv',
-        'Other Equipment Radiant Heating Energy' => 'ducts_rad' }.each do |var, name|
-        ducts_sensor = OpenStudio::Model::EnergyManagementSystemSensor.new(model, var)
-        ducts_sensor.setName(name)
-        ducts_sensor.setKeyName(o.name.to_s)
-        ducts_sensors[-1] << ducts_sensor
-      end
-    end
-
-    # Supply duct losses
+    # Duct losses
     model.getOtherEquipments.sort.each do |o|
       next if objects_already_processed.include? o
 
@@ -2813,20 +2382,6 @@ class OSModel
       end
     end
 
-    model.getGasEquipments.sort.each do |o|
-      next unless o.space.get.thermalZone.get.name.to_s == living_zone.name.to_s
-      next if objects_already_processed.include? o
-
-      intgains_sensors << []
-      { 'Gas Equipment Convective Heating Energy' => 'ig_ge_conv',
-        'Gas Equipment Radiant Heating Energy' => 'ig_ge_rad' }.each do |var, name|
-        intgains_gas_equip_sensor = OpenStudio::Model::EnergyManagementSystemSensor.new(model, var)
-        intgains_gas_equip_sensor.setName(name)
-        intgains_gas_equip_sensor.setKeyName(o.name.to_s)
-        intgains_sensors[-1] << intgains_gas_equip_sensor
-      end
-    end
-
     model.getOtherEquipments.sort.each do |o|
       next unless o.space.get.thermalZone.get.name.to_s == living_zone.name.to_s
       next if objects_already_processed.include? o
@@ -2868,17 +2423,8 @@ class OSModel
       end
     end
 
-    model.getZoneHVACDehumidifierDXs.each do |e|
-      next unless e.thermalZone.get.name.to_s == living_zone.name.to_s
-
-      intgains_sensors << []
-      { 'Zone Dehumidifier Sensible Heating Energy' => 'ig_dehumidifier' }.each do |var, name|
-        intgain_dehumidifier = OpenStudio::Model::EnergyManagementSystemSensor.new(model, var)
-        intgain_dehumidifier.setName(name)
-        intgain_dehumidifier.setKeyName(e.name.to_s)
-        load_adj_sensors[:dehumidifier] = intgain_dehumidifier
-        intgains_sensors[-1] << intgain_dehumidifier
-      end
+    if not intgain_dehumidifier.nil?
+      intgains_sensors[-1] << intgain_dehumidifier
     end
 
     intgains_dhw_sensors = {}
@@ -2906,7 +2452,7 @@ class OSModel
       intgains_dhw_sensors[dhw_sensor] = [offcycle_loss, oncycle_loss, dhw_rtf_sensor]
     end
 
-    nonsurf_names = ['intgains', 'infil', 'mechvent', 'natvent', 'whf', 'ducts', 'cd']
+    nonsurf_names = ['intgains', 'infil', 'mechvent', 'natvent', 'whf', 'ducts']
 
     # EMS program
     program = OpenStudio::Model::EnergyManagementSystemProgram.new(model)
@@ -2946,18 +2492,16 @@ 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} + #{cd_flow_actuator.name}")
+    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("  Set hr_cd = ((#{air_loss_sensor.name} - #{air_gain_sensor.name}) * #{cd_flow_actuator.name} / hr_airflow_rate)") # Airflow heat attributed to clothes dryer exhaust
     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('  Set hr_cd = 0')
     program.addLine('EndIf')
     program.addLine('Set hr_mechvent = 0')
     mechvent_sensors.each do |sensor|
@@ -3002,27 +2546,6 @@ class OSModel
       end
     end
 
-    # EMS program: Total loads
-    program.addLine('Set loads_htg_tot = 0')
-    program.addLine('Set loads_clg_tot = 0')
-    program.addLine("If #{liv_load_sensors[:htg].name} > 0")
-    s = "  Set loads_htg_tot = #{tot_load_sensors[:htg].name} - #{tot_load_sensors[:clg].name}"
-    load_adj_sensors.each do |key, adj_sensor|
-      if ['dehumidifier'].include? key.to_s
-        s += " - #{adj_sensor.name}"
-      end
-    end
-    program.addLine(s)
-    program.addLine("ElseIf #{liv_load_sensors[:clg].name} > 0")
-    s = "  Set loads_clg_tot = #{tot_load_sensors[:clg].name} - #{tot_load_sensors[:htg].name}"
-    load_adj_sensors.each do |key, adj_sensor|
-      if ['dehumidifier'].include? key.to_s
-        s += " + #{adj_sensor.name}"
-      end
-    end
-    program.addLine(s)
-    program.addLine('EndIf')
-
     # EMS calling manager
     program_calling_manager = OpenStudio::Model::EnergyManagementSystemProgramCallingManager.new(model)
     program_calling_manager.setName("#{program.name} calling manager")
@@ -3030,400 +2553,28 @@ class OSModel
     program_calling_manager.addProgram(program)
   end
 
-  def self.set_vacancy(runner, model)
-    return if @schedules_file.nil?
-
-    @schedules_file.set_vacancy(col_names: ScheduleGenerator.col_names)
-  end
-
-  # FUTURE: Move all of these construction methods to constructions.rb
-  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, 10.0, 0.5, drywall_thick_in, mat_ext_finish), # 2x6, 24" o.c. + R10
-        WoodStudConstructionSet.new(Material.Stud2x6, 0.20, 5.0, 0.5, drywall_thick_in, mat_ext_finish),  # 2x6, 24" o.c. + R5
-        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)
-
-      Constructions.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. + R10
-        SteelStudConstructionSet.new(5.5, corr_factor, 0.20, 5.0, 0.5, drywall_thick_in, mat_ext_finish),  # 2x6, 24" o.c. + R5
-        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)
-
-      Constructions.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)
-
-      Constructions.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)
-
-      Constructions.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)
-
-      Constructions.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)
-
-      Constructions.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]
-
-      Constructions.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
+  def self.add_output_control_files(runner, model)
+    return if @debug
 
-    return false, constr_sets[-1], 0.0 # Pick fallback construction with minimum R-value
+    # Disable various output files
+    ocf = model.getOutputControlFiles
+    ocf.setOutputAUDIT(false)
+    ocf.setOutputBND(false)
+    ocf.setOutputEIO(false)
+    ocf.setOutputESO(false)
+    ocf.setOutputMDD(false)
+    ocf.setOutputMTD(false)
+    ocf.setOutputMTR(false)
+    ocf.setOutputRDD(false)
+    ocf.setOutputSHD(false)
+    ocf.setOutputTabular(false)
   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
+  def self.add_ems_debug_output(runner, model)
+    oems = model.getOutputEnergyManagementSystem
+    oems.setActuatorAvailabilityDictionaryReporting('Verbose')
+    oems.setInternalVariableAvailabilityDictionaryReporting('Verbose')
+    oems.setEMSRuntimeLanguageDebugOutputLevel('Verbose')
   end
 
   def self.set_surface_interior(model, spaces, surface, hpxml_surface)
@@ -3451,7 +2602,7 @@ class OSModel
       set_surface_otherside_coefficients(surface, exterior_adjacent_to, model, spaces)
     elsif exterior_adjacent_to == HPXML::LocationBasementConditioned
       surface.createAdjacentSurface(create_or_get_space(model, spaces, HPXML::LocationLivingSpace))
-      @cond_bsmnt_surfaces << surface
+      @cond_bsmnt_surfaces << surface.adjacentSurface.get
     else
       surface.createAdjacentSurface(create_or_get_space(model, spaces, exterior_adjacent_to))
     end
@@ -3462,8 +2613,7 @@ class OSModel
       # Create E+ other side coefficient object
       otherside_object = OpenStudio::Model::SurfacePropertyOtherSideCoefficients.new(model)
       otherside_object.setName(exterior_adjacent_to)
-      # Refer to: https://www.sciencedirect.com/science/article/pii/B9780123972705000066 6.1.2 Part: Wall and roof transfer functions
-      otherside_object.setCombinedConvectiveRadiativeFilmCoefficient(8.3)
+      otherside_object.setCombinedConvectiveRadiativeFilmCoefficient(UnitConversions.convert(1.0 / Material.AirFilmVertical.rvalue, 'Btu/(hr*ft^2*F)', 'W/(m^2*K)'))
       # Schedule of space temperature, can be shared with water heater/ducts
       sch = get_space_temperature_schedule(model, exterior_adjacent_to, spaces)
       otherside_object.setConstantTemperatureSchedule(sch)
@@ -3523,7 +2673,7 @@ class OSModel
       sensor_gnd.setName('ground_temp')
     end
 
-    actuator = OpenStudio::Model::EnergyManagementSystemActuator.new(sch, 'Schedule:Constant', 'Schedule Value')
+    actuator = OpenStudio::Model::EnergyManagementSystemActuator.new(sch, *EPlus::EMSActuatorScheduleConstantValue)
     actuator.setName("#{location.gsub(' ', '_').gsub('-', '_')}_temp_sch")
 
     # EMS to actuate schedule
@@ -3594,9 +2744,7 @@ class OSModel
       space = create_or_get_space(model, spaces, location)
     end
 
-    if spaces.size != num_orig_spaces
-      fail "#{object_name} location is '#{location}' but building does not have this location specified."
-    end
+    fail if spaces.size != num_orig_spaces # EPvalidator.xml should prevent this
 
     return space
   end
@@ -3613,19 +2761,6 @@ class OSModel
     end
   end
 
-  def self.get_min_neighbor_distance()
-    min_neighbor_distance = nil
-    @hpxml.neighbor_buildings.each do |neighbor_building|
-      if min_neighbor_distance.nil?
-        min_neighbor_distance = 9e99
-      end
-      if neighbor_building.distance < min_neighbor_distance
-        min_neighbor_distance = neighbor_building.distance
-      end
-    end
-    return min_neighbor_distance
-  end
-
   def self.get_kiva_instances(fnd_walls, slabs)
     # Identify unique Kiva foundations that are required.
     kiva_fnd_walls = []
@@ -3653,93 +2788,5 @@ class OSModel
   end
 end
 
-# FUTURE: Move all of these construction classes to constructions.rb
-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
-
 # register the measure to be used by the application
 HPXMLtoOpenStudio.new.registerWithApplication