openstudio-standards 0.8.3 → 0.8.5.rc1

data/lib/openstudio-standards/standards/necb/NECB2011/necb_2011.rb

@@ -6,37 +6,52 @@ class NECB2011 < Standard
 
   @template = new.class.name
   register_standard(@template)
-  attr_reader :tbd
   attr_reader :template
+  attr_reader :tbd
+  attr_reader :osut
+  attr_reader :activity
+  attr_reader :structure
   attr_accessor :standards_data
   attr_accessor :space_type_map
   attr_accessor :space_multiplier_map
   attr_accessor :fuel_type_set
 
-  # This is a helper method to convert arguments that may support 'NECB_Default, and nils to convert to float'
+  # This is a helper method to convert arguments to float.
+  #   If variable undefined set to the default
+  #   If already a numeric then return it
+  #   If variable is a string then convert to a float, using the default if 'NECB_Default'
+  #   If that all fails then return the default.
   def convert_arg_to_f(variable:, default:)
+    return default if variable.nil?
     return variable if variable.kind_of?(Numeric)
-    return default if variable.nil? || (variable.to_s == 'NECB_Default')
-    return unless variable.kind_of?(String)
-
-    variable = variable.strip
-    return variable.to_f
+    if variable.is_a? String
+      return default if variable.to_s.downcase == 'necb_default'
+      variable = variable.strip
+      return variable.to_f
+    end
+    return default
   end
 
-  # This method converts arguments to bool.  Anything other than a bool false or string 'false' is converted
-  # to a bool true.  Bool false and case insesitive string false are turned into bool false.
+  # This method converts arguments to bool.
+  #   If variable undefined set to the default
+  #   If already a bool then return it
+  #   If variable is a string then convert to a bool, using the default if 'NECB_Default'
+  #   If that all fails then return the default.
   def convert_arg_to_bool(variable:, default:)
     return default if variable.nil?
+    return variable if variable.is_a?(TrueClass) || variable.is_a?(FalseClass)
     if variable.is_a? String
+      return default if variable.to_s.downcase == 'necb_default'
+      return false if variable.to_s.downcase == 'false'
       return true if variable.to_s.downcase == 'true'
-      return false
     end
-    return true if variable == true
     return default
   end
 
-  # This method checks if a variable is a string.  If it is anything but a string it returns the default.  If it is a
-  # string set to "NECB_Default" it return the default.  Otherwise it returns the strirng set to it.
+  # This method checks if a variable is a string.
+  #   If variable undefined set to the default
+  #   If variable is a string then return it, using the default if 'NECB_Default'
+  #   If that all fails then return the default.
   def convert_arg_to_string(variable:, default:)
     return default if variable.nil?
     if variable.is_a? String
@@ -148,6 +163,10 @@ class NECB2011 < Standard
     @standards_data = load_standards_database_new
     corrupt_standards_database
     @tbd = nil
+    @activity = nil
+    @structure = nil
+    @osut = {gra0: 0, graX: 0, status: 0, logs: []} # "gra": "gross roof area"
+
     # puts "loaded these tables..."
     # puts @standards_data.keys.size
     # raise("tables not all loaded in parent #{}") if @standards_data.keys.size < 24
@@ -179,6 +198,22 @@ class NECB2011 < Standard
     min_distance = 100000000000000.0
     necb_closest = nil
     weather_file_path = model.weatherFile.get.path.get.to_s
+
+    # Check if weather file exists at the specified path
+    unless File.exist?(weather_file_path)
+      # Try to find the file in the data/weather folder
+      weather_file_name = File.basename(weather_file_path)
+      data_weather_path = File.absolute_path(File.join(__FILE__, '..', '..', '..', '..', '..', '..', 'data', 'weather', weather_file_name))
+
+      if File.exist?(data_weather_path)
+        weather_file_path = data_weather_path
+        # Update the model's weather file path to point to the found file
+        OpenstudioStandards::Weather.model_set_building_location(model, weather_file_path: weather_file_path)
+      else
+        raise "Weather file not found at #{weather_file_path} or #{data_weather_path}"
+      end
+    end
+
     epw_file = model.weatherFile.get.file.get
     stat_file_path = weather_file_path.gsub('.epw', '.stat')
     stat_file = OpenstudioStandards::Weather::StatFile.new(stat_file_path)
@@ -210,10 +245,16 @@ class NECB2011 < Standard
   # This method is a wrapper to create the 16 archetypes easily. # 55 args
   def model_create_prototype_model(template:,
                                    building_type:,
+                                   construction_opt: '',
                                    epw_file:,
                                    custom_weather_folder: nil,
                                    debug: false,
                                    sizing_run_dir: Dir.pwd,
+                                   hvac_system_primary: nil,
+                                   hvac_system_dwelling_units: nil,
+                                   hvac_system_washrooms: nil,
+                                   hvac_system_corridor: nil,
+                                   hvac_system_storage: nil,
                                    primary_heating_fuel: 'Electricity',
                                    swh_fuel: nil,
                                    dcv_type: 'NECB_Default',
@@ -244,6 +285,7 @@ class NECB2011 < Standard
                                    rotation_degrees: nil,
                                    fdwr_set: -1.0,
                                    srr_set: -1.0,
+                                   srr_opt: '',
                                    nv_type: nil,
                                    nv_opening_fraction: nil,
                                    nv_temp_out_min: nil,
@@ -266,19 +308,26 @@ class NECB2011 < Standard
                                    output_meters: nil,
                                    airloop_economizer_type: nil,
                                    baseline_system_zones_map_option: nil,
-                                   tbd_option: nil,
-                                   tbd_interpolate: false,
+                                   tbd_option: 'none',
+                                   tbd_interpolate: true,
                                    necb_hdd: true,
                                    boiler_fuel: nil,
                                    boiler_cap_ratio: nil,
+                                   airloop_fancoils_heating: nil,
                                    oerd_utility_pricing: nil)
     model = load_building_type_from_library(building_type: building_type)
     return model_apply_standard(model: model,
+                                construction_opt: construction_opt,
                                 tbd_option: tbd_option,
                                 tbd_interpolate: tbd_interpolate,
                                 epw_file: epw_file,
                                 custom_weather_folder: custom_weather_folder,
                                 sizing_run_dir: sizing_run_dir,
+                                hvac_system_primary: nil,
+                                hvac_system_dwelling_units: nil,
+                                hvac_system_washrooms: nil,
+                                hvac_system_corridor: nil,
+                                hvac_system_storage: nil,
                                 primary_heating_fuel: primary_heating_fuel,
                                 swh_fuel: swh_fuel,
                                 dcv_type: dcv_type, # Four options: (1) 'NECB_Default', (2) 'No_DCV', (3) 'Occupancy_based_DCV' , (4) 'CO2_based_DCV'
@@ -309,6 +358,7 @@ class NECB2011 < Standard
                                 rotation_degrees: rotation_degrees,
                                 fdwr_set: fdwr_set,
                                 srr_set: srr_set,
+                                srr_opt: srr_opt,
                                 nv_type: nv_type, # Two options: (1) nil/none/false/'NECB_Default', (2) 'add_nv'
                                 nv_opening_fraction: nv_opening_fraction, # options: (1) nil/none/false (2) 'NECB_Default' (i.e. 0.1), (3) opening fraction of windows, which can be a float number between 0.0 and 1.0
                                 nv_temp_out_min: nv_temp_out_min, # options: (1) nil/none/false(2) 'NECB_Default' (i.e. 13.0 based on inputs from Michel Tardif re a real school in QC), (3) minimum outdoor air temperature (in Celsius) below which natural ventilation is shut down
@@ -334,6 +384,7 @@ class NECB2011 < Standard
                                 necb_hdd: necb_hdd,
                                 boiler_fuel: boiler_fuel,
                                 boiler_cap_ratio: boiler_cap_ratio,
+                                airloop_fancoils_heating: airloop_fancoils_heating,
                                 oerd_utility_pricing: oerd_utility_pricing
                                 )
   end
@@ -351,13 +402,20 @@ class NECB2011 < Standard
   # Created this method so that additional methods can be addded for bulding the prototype model in later
   # code versions without modifying the build_protoype_model method or copying it wholesale for a few changes.
   def model_apply_standard(model:,
-                           tbd_option: nil,
-                           tbd_interpolate: nil,
+                           construction_opt: '',
+                           tbd_option: 'none',
+                           tbd_interpolate: true,
                            epw_file:,
                            custom_weather_folder: nil,
+                           btap_weather: true,
                            sizing_run_dir: Dir.pwd,
                            necb_reference_hp: false,
                            necb_reference_hp_supp_fuel: 'DefaultFuel',
+                           hvac_system_primary: 'NECB_Default',
+                           hvac_system_dwelling_units: 'NECB_Default',
+                           hvac_system_washrooms: 'NECB_Default',
+                           hvac_system_corridor: 'NECB_Default',
+                           hvac_system_storage: 'NECB_Default',
                            primary_heating_fuel: 'Electricity',
                            swh_fuel: nil,
                            dcv_type: 'NECB_Default',
@@ -387,6 +445,7 @@ class NECB2011 < Standard
                            skylight_solar_trans: nil,
                            fdwr_set: nil,
                            srr_set: nil,
+                           srr_opt: '',
                            rotation_degrees: nil,
                            scale_x: nil,
                            scale_y: nil,
@@ -413,24 +472,43 @@ class NECB2011 < Standard
                            necb_hdd: true,
                            boiler_fuel: nil,
                            boiler_cap_ratio: nil,
+                           airloop_fancoils_heating: nil,
                            oerd_utility_pricing: nil)
 
-    apply_weather_data(model: model, epw_file: epw_file, custom_weather_folder: custom_weather_folder)
+    apply_weather_data(model: model,
+                       epw_file: epw_file,
+                       custom_weather_folder: custom_weather_folder,
+                       btap_weather: btap_weather)
     primary_heating_fuel = validate_primary_heating_fuel(primary_heating_fuel: primary_heating_fuel, model: model)
     self.fuel_type_set = SystemFuels.new()
     self.fuel_type_set.set_defaults(standards_data: @standards_data, primary_heating_fuel: primary_heating_fuel)
     clean_and_scale_model(model: model, rotation_degrees: rotation_degrees, scale_x: scale_x, scale_y: scale_y, scale_z: scale_z)
     fdwr_set = convert_arg_to_f(variable: fdwr_set, default: -1)
     srr_set = convert_arg_to_f(variable: srr_set, default: -1)
+    srr_opt = convert_arg_to_string(variable: srr_opt, default: '')
+    construction_opt = convert_arg_to_string(variable: construction_opt, default: '')
+    massive = construction_opt == 'structure'
+    tbd_option = convert_arg_to_string(variable: tbd_option, default: 'none')
+    tbd_interpolate = convert_arg_to_bool(variable: tbd_interpolate, default: true)
     necb_hdd = convert_arg_to_bool(variable: necb_hdd, default: true)
     boiler_fuel = convert_arg_to_string(variable: boiler_fuel, default: nil)
     boiler_cap_ratio = convert_arg_to_string(variable: boiler_cap_ratio, default: nil)
     swh_fuel = convert_arg_to_string(variable: swh_fuel, default: nil)
+    airloop_fancoils_heating = convert_arg_to_bool(variable: airloop_fancoils_heating, default: false)
+
+    # Check if custom systems are assigned to dwelling units, washrooms, corridors, and storage rooms.  If they are, set
+    # them to be the same as the primary system type.  If no primary system type is defined then set them to be nil.
+    hvac_system_dwelling_units, hvac_system_corridor, hvac_system_storage, hvac_system_washrooms = reset_hvac_system_if_required(hvac_system_primary: hvac_system_primary,
+                                                                                                                                 hvac_system_dwelling_units: hvac_system_dwelling_units,
+                                                                                                                                 hvac_system_corridor: hvac_system_corridor,
+                                                                                                                                 hvac_system_storage: hvac_system_storage,
+                                                                                                                                 hvac_system_washrooms: hvac_system_washrooms)
     oerd_utility_pricing = convert_arg_to_bool(variable: oerd_utility_pricing, default: false)
 
     boiler_cap_ratios = set_boiler_cap_ratios(boiler_cap_ratio: boiler_cap_ratio, boiler_fuel: boiler_fuel) unless boiler_cap_ratio.nil? && boiler_fuel.nil?
     self.fuel_type_set.set_boiler_fuel(standards_data: @standards_data, boiler_fuel: boiler_fuel, boiler_cap_ratios: boiler_cap_ratios) unless boiler_fuel.nil?
     self.fuel_type_set.set_swh_fuel(swh_fuel: swh_fuel) unless swh_fuel.nil? || swh_fuel.to_s.downcase == 'defaultfuel'
+    self.fuel_type_set.set_airloop_fancoils_heating() if airloop_fancoils_heating
 
     # Ensure the volume calculation in all spaces is done automatically
     model.getSpaces.sort.each do |space|
@@ -439,6 +517,8 @@ class NECB2011 < Standard
 
     output_meters = check_output_meters(output_meters: output_meters) if oerd_utility_pricing
 
+    assign_building_activity(model: model)
+    assign_building_structure(model: model, activity: @activity, massive: massive)
     apply_loads(model: model,
                 lights_type: lights_type,
                 lights_scale: lights_scale,
@@ -446,6 +526,9 @@ class NECB2011 < Standard
                 electrical_loads_scale: electrical_loads_scale,
                 oa_scale: oa_scale)
     apply_envelope(model: model,
+                   construction_opt: construction_opt,
+                   bldg_category: @activity.category,
+                   bldg_structure: @structure.structure,
                    ext_wall_cond: ext_wall_cond,
                    ext_floor_cond: ext_floor_cond,
                    ext_roof_cond: ext_roof_cond,
@@ -465,20 +548,28 @@ class NECB2011 < Standard
     apply_fdwr_srr_daylighting(model: model,
                                fdwr_set: fdwr_set,
                                srr_set: srr_set,
+                               srr_opt: srr_opt,
                                necb_hdd: necb_hdd)
     apply_thermal_bridging(model: model,
-                           tbd_option: tbd_option,
-                           tbd_interpolate: tbd_interpolate,
-                           wall_U: ext_wall_cond,
-                           floor_U: ext_floor_cond,
-                           roof_U: ext_roof_cond)
+                           necb_hdd: necb_hdd,
+                           structure: @structure,
+                           option: tbd_option,
+                           interpolate: tbd_interpolate,
+                           wallU: ext_wall_cond,
+                           floorU: ext_floor_cond,
+                           roofU: ext_roof_cond)
     apply_auto_zoning(model: model,
                       sizing_run_dir: sizing_run_dir,
                       lights_type: lights_type,
                       lights_scale: lights_scale)
-    apply_kiva_foundation(model)
+    apply_kiva_foundation(model, massive)
     apply_systems_and_efficiencies(model: model,
                                    sizing_run_dir: sizing_run_dir,
+                                   hvac_system_primary: hvac_system_primary,
+                                   hvac_system_dwelling_units: hvac_system_dwelling_units,
+                                   hvac_system_washrooms: hvac_system_washrooms,
+                                   hvac_system_corridor: hvac_system_corridor,
+                                   hvac_system_storage: hvac_system_storage,
                                    primary_heating_fuel: primary_heating_fuel,
                                    dcv_type: dcv_type,
                                    ecm_system_name: ecm_system_name,
@@ -512,7 +603,7 @@ class NECB2011 < Standard
   def clean_and_scale_model(model:, rotation_degrees: nil, scale_x: nil, scale_y: nil, scale_z: nil)
     # clean model..
     BTAP::Resources::Envelope::remove_all_envelope_information(model)
-    model = remove_all_hvac(model)
+    model = OpenstudioStandards::HVAC.remove_all_hvac(model)
     model.getThermalZones.sort.each { |zone| zone.setUseIdealAirLoads(true) }
     model.getZoneHVACPackagedTerminalAirConditioners.each(&:remove)
     model.getCoilCoolingDXSingleSpeeds.each(&:remove)
@@ -551,6 +642,11 @@ class NECB2011 < Standard
 
   def apply_systems_and_efficiencies(model:,
                                      sizing_run_dir:,
+                                     hvac_system_primary: 'NECB_Default',
+                                     hvac_system_dwelling_units: 'NECB_Default',
+                                     hvac_system_washrooms: 'NECB_Default',
+                                     hvac_system_corridor: 'NECB_Default',
+                                     hvac_system_storage: 'NECB_Default',
                                      primary_heating_fuel:,
                                      dcv_type: 'NECB_Default',
                                      ecm_system_name: 'NECB_Default',
@@ -582,6 +678,11 @@ class NECB2011 < Standard
 
     # Create Default Systems.
     apply_systems(model: model,
+                  hvac_system_primary: hvac_system_primary,
+                  hvac_system_dwelling_units: hvac_system_dwelling_units,
+                  hvac_system_washrooms: hvac_system_washrooms,
+                  hvac_system_corridor: hvac_system_corridor,
+                  hvac_system_storage: hvac_system_storage,
                   sizing_run_dir: sizing_run_dir,
                   shw_scale: shw_scale,
                   baseline_system_zones_map_option: baseline_system_zones_map_option)
@@ -620,9 +721,9 @@ class NECB2011 < Standard
     ecm.add_airloop_economizer(model: model, airloop_economizer_type: airloop_economizer_type)
     # Perform a second sizing run if needed
     if (!unitary_cop.nil? && unitary_cop != 'NECB_Default') || !model.getPlantLoops.empty?
-      if model_run_sizing_run(model, "#{sizing_run_dir}/SR2", true) == false
-        raise('sizing run 2 failed!')
-      end
+      # Do a sizing run
+      try_sizing_run(model: model, sizing_run_dir: sizing_run_dir, sizing_run_subdir: 'SR2')
+      #end
     end
     # apply unitary cop
     ecm.modify_unitary_cop(model: model, unitary_cop: unitary_cop, sizing_done: true, sql_db_vars_map: sql_db_vars_map)
@@ -661,9 +762,8 @@ class NECB2011 < Standard
     end
 
     # Rename air loop and plant loop nodes to accommodate coming OpenStudio version
-    rename_air_loop_nodes(model)
-    rename_plant_loop_nodes(model)
-
+    OpenstudioStandards::HVAC.rename_air_loop_nodes(model)
+    OpenstudioStandards::HVAC.rename_plant_loop_nodes(model)
   end
 
   def apply_loads(model:,
@@ -689,7 +789,7 @@ class NECB2011 < Standard
     ecm.scale_oa_loads(model: model, scale: oa_scale)
   end
 
-  def apply_weather_data(model:, epw_file:, custom_weather_folder: nil)
+  def apply_weather_data(model:, epw_file:, custom_weather_folder: nil, btap_weather: true)
     # Create full path to weather file
     weather_files = File.absolute_path(File.join(__FILE__, '..', '..', '..', '..', '..' , '..', "data/weather"))
     weather_file = File.join(weather_files, epw_file)
@@ -699,7 +799,7 @@ class NECB2011 < Standard
       # Check if btap_batch transferred the weather file
       weather_transfer = check_datapoint_weather_folder(epw_file: epw_file, weather_folder: weather_files, custom_weather_folder: custom_weather_folder)
       # If btap_batch didn't transfer the weather file, download it.
-      get_weather_file_from_repo(epw_file: epw_file) unless weather_transfer
+      get_weather_file_from_repo(epw_file: epw_file, btap_weather: btap_weather) unless weather_transfer
     end
 
     # Fix EMS references. Temporary workaround for OS issue #2598
@@ -711,6 +811,9 @@ class NECB2011 < Standard
   end
 
   def apply_envelope(model:,
+                     construction_opt: '',
+                     bldg_category: '',
+                     bldg_structure: '',
                      ext_wall_cond: nil,
                      ext_floor_cond: nil,
                      ext_roof_cond: nil,
@@ -734,29 +837,61 @@ class NECB2011 < Standard
     ecm.scale_infiltration_loads(model: model, scale: infiltration_scale)
     model.getInsideSurfaceConvectionAlgorithm.setAlgorithm('TARP')
     model.getOutsideSurfaceConvectionAlgorithm.setAlgorithm('TARP')
-    model_add_constructions(model)
-    apply_standard_construction_properties(model: model,
-                                           ext_wall_cond: ext_wall_cond,
-                                           ext_floor_cond: ext_floor_cond,
-                                           ext_roof_cond: ext_roof_cond,
-                                           ground_wall_cond: ground_wall_cond,
-                                           ground_floor_cond: ground_floor_cond,
-                                           ground_roof_cond: ground_roof_cond,
-                                           door_construction_cond: door_construction_cond,
-                                           fixed_window_cond: fixed_window_cond,
-                                           glass_door_cond: glass_door_cond,
-                                           overhead_door_cond: overhead_door_cond,
-                                           skylight_cond: skylight_cond,
-                                           glass_door_solar_trans: glass_door_solar_trans,
-                                           fixed_wind_solar_trans: fixed_wind_solar_trans,
-                                           skylight_solar_trans: skylight_solar_trans,
-                                           necb_hdd: necb_hdd)
+
+    construction_opt = '' unless construction_opt.respond_to?(:to_sym)
+    bldg_structure   = '' unless bldg_structure.respond_to?(:to_sym)
+    construction_opt = construction_opt.to_s.downcase
+    bldg_structure   = bldg_structure.to_s.downcase.to_sym
+    bldg_structures  = @structure.data[:structure].keys
+
+    if construction_opt == 'structure' && bldg_structures.include?(bldg_structure)
+      argh            = {}
+      argh[:eWallU  ] = ext_wall_cond          if ext_wall_cond
+      argh[:eFloorU ] = ext_floor_cond         if ext_floor_cond
+      argh[:eRoofU  ] = ext_roof_cond          if ext_roof_cond
+      argh[:gWallU  ] = ground_wall_cond       if ground_wall_cond
+      argh[:gFloorU ] = ground_floor_cond      if ground_floor_cond
+      argh[:gRoofU  ] = ground_roof_cond       if ground_roof_cond
+      argh[:doorU   ] = door_construction_cond if door_construction_cond
+      argh[:fenU    ] = fixed_window_cond      if fixed_window_cond
+      argh[:skyU    ] = skylight_solar_trans   if skylight_solar_trans
+      argh[:doorSHGC] = glass_door_solar_trans if glass_door_solar_trans
+      argh[:fenSHGC ] = fixed_wind_solar_trans if fixed_wind_solar_trans
+      argh[:skySHGC ] = skylight_solar_trans   if skylight_solar_trans
+
+      assign_contruction_to_adiabatic_surfaces(model)
+      ok = add_construction_sets(model, necb_hdd, argh)
+
+      raise('NECB2011: Failed to assign default construction sets') unless ok
+    else
+      model_add_constructions(model)
+      apply_standard_construction_properties(model: model,
+                                             ext_wall_cond: ext_wall_cond,
+                                             ext_floor_cond: ext_floor_cond,
+                                             ext_roof_cond: ext_roof_cond,
+                                             ground_wall_cond: ground_wall_cond,
+                                             ground_floor_cond: ground_floor_cond,
+                                             ground_roof_cond: ground_roof_cond,
+                                             door_construction_cond: door_construction_cond,
+                                             fixed_window_cond: fixed_window_cond,
+                                             glass_door_cond: glass_door_cond,
+                                             overhead_door_cond: overhead_door_cond,
+                                             skylight_cond: skylight_cond,
+                                             glass_door_solar_trans: glass_door_solar_trans,
+                                             fixed_wind_solar_trans: fixed_wind_solar_trans,
+                                             skylight_solar_trans: skylight_solar_trans,
+                                             necb_hdd: necb_hdd)
+    end
+
     model_create_thermal_zones(model, @space_multiplier_map)
   end
 
-  # apply the Kiva foundation model to floors and walls with ground boundary condition
+  # Apply Kiva foundation model to floors/walls with ground boundary condition.
   # created by: Kamel Haddad (kamel.haddad@nrcan-rncan.gc.ca)
-  def apply_kiva_foundation(model)
+  # 'massive' edit: denis@rd2.ca
+  #
+  # @param massive [Boolean] whether opaque materials are standard (not massless)
+  def apply_kiva_foundation(model, massive = false)
     # define a Kiva model for the whole bldg that's used for the first floor in contact with ground in each zone
     bldg_kiva_model = OpenStudio::Model::FoundationKiva.new(model)
     bldg_kiva_model.setName("Bldg Kiva Foundation")
@@ -784,10 +919,21 @@ class NECB2011 < Standard
             kiva_model.setWallDepthBelowSlab(0.0)
             zone_kiva_models << kiva_model
           end
-          # Kiva model only works with standard materials. Replace constructions massless materials with standard ones.
-          replace_massless_material_with_std_material(model,gfloor)
-          gfloor.setOutsideBoundaryCondition('Foundation')
-          gfloor.setAdjacentFoundation(zone_kiva_models.last)
+          # Kiva model only works with standard materials. Replace constructions
+          # massless materials with standard ones.
+          # Kiva model only works with standard materials. Replace constructions
+          # massless materials with standard ones. Skip check if 'massive'.
+          if massive
+            c = gfloor.construction.get.to_LayeredConstruction.get
+            gfloor.setOutsideBoundaryCondition('Foundation')
+            gfloor.setAdjacentFoundation(zone_kiva_models.last)
+            gfloor.setConstruction(c)
+          else
+            replace_massless_material_with_std_material(model,gfloor)
+            gfloor.setOutsideBoundaryCondition('Foundation')
+            gfloor.setAdjacentFoundation(zone_kiva_models.last)
+          end
+
           # Set the exposed perimeter for space floors in contact with the ground.
           floor_exp_per = 0.0
           if !space_ground_walls.empty?
@@ -800,9 +946,16 @@ class NECB2011 < Standard
           # contact with the space floor in contact with ground 'gfloor'
           space_ground_walls.each do |gwall|
             if surfaces_are_in_contact?(gfloor,gwall)
-              replace_massless_material_with_std_material(model,gwall)
-              gwall.setOutsideBoundaryCondition('Foundation')
-              gwall.setAdjacentFoundation(zone_kiva_models.last)
+              if massive
+                c = gwall.construction.get.to_LayeredConstruction.get
+                gwall.setOutsideBoundaryCondition('Foundation')
+                gwall.setAdjacentFoundation(zone_kiva_models.last)
+                gwall.setConstruction(c)
+              else
+                replace_massless_material_with_std_material(model,gwall)
+                gwall.setOutsideBoundaryCondition('Foundation')
+                gwall.setAdjacentFoundation(zone_kiva_models.last)
+              end
             end
           end
         end
@@ -973,84 +1126,99 @@ class NECB2011 < Standard
   end
 
   # Thermal zones need to be set to determine conditioned spaces when applying fdwr and srr limits.
-  #     # fdwr_set/srr_set settings:
-  #     # 0-1:  Remove all windows/skylights and add windows/skylights to match this fdwr/srr
-  #     # -1:  Remove all windows/skylights and add windows/skylights to match max fdwr/srr from NECB
-  #     # -2:  Do not apply any fdwr/srr changes, leave windows/skylights alone (also works for fdwr/srr > 1)
-  #     # -3:  Use old method which reduces existing window/skylight size (if necessary) to meet maximum NECB fdwr/srr
-  #     # limit
-  #     # <-3.1:  Remove all the windows/skylights
-  #     # > 1:  Do nothing
-  def apply_fdwr_srr_daylighting(model:, fdwr_set: -1.0, srr_set: -1.0, necb_hdd: true)
+  #
+  # fdwr_set/srr_set settings:
+  #   0-1:  Remove all windows/skylights and add windows/skylights to match this fdwr/srr
+  #    -1:  Remove all windows/skylights and add windows/skylights to match max fdwr/srr from NECB
+  #    -2:  Do not apply any fdwr/srr changes, leave windows/skylights alone (also works for fdwr/srr > 1)
+  #    -3:  Use old method which reduces existing window/skylight size (if necessary) to meet maximum NECB fdwr/srr limit
+  # <-3.1:  Remove all the windows/skylights
+  #   > 1:  Do nothing
+  #
+  # By default, :srr_opt is an empty string (" "). If set to "osut", SRR is
+  # instead met using OSut's 'addSkylights' (:srr_set numeric values may apply).
+  def apply_fdwr_srr_daylighting(model:, fdwr_set: -1.0, srr_set: -1.0, necb_hdd: true, srr_opt: '')
     fdwr_set = -1.0 if (fdwr_set == 'NECB_default') || fdwr_set.nil?
     srr_set = -1.0 if (srr_set == 'NECB_default') || srr_set.nil?
     fdwr_set = fdwr_set.to_f
     srr_set = srr_set.to_f
     apply_standard_window_to_wall_ratio(model: model, fdwr_set: fdwr_set, necb_hdd: necb_hdd)
-    apply_standard_skylight_to_roof_ratio(model: model, srr_set: srr_set)
+    apply_standard_skylight_to_roof_ratio(model: model, srr_set: srr_set, srr_opt: srr_opt)
     # model_add_daylighting_controls(model) # to be removed after refactor.
   end
 
-  ##
-  # Optionally uprates, then derates, envelope surfaces due to MAJOR thermal
-  # bridges (e.g. roof parapets, corners, fenestration perimeters). See
-  # lib/openstudio-standards/btap/bridging.rb, which relies on the Thermal
-  # Bridging & Derating (TBD) gem.
+  # Initiates a BTAP building ACTIVITY.
   #
-  # @param model [OpenStudio::Model::Model] an OpenStudio model
-  # @param tbd_option [String] BTAP/TBD option
+  # @param model [OpenStudio::Model::Model] a model
   #
-  # @return [Boolean] true if successful, e.g. no errors, compliant if uprated
+  # @return [BTAP::Activity] a BTAP building ACTIVITY (see logs if failed)
+  def assign_building_activity(model: nil)
+    @activity = BTAP::Activity.new(model)
+  end
+
+  # Initiates a BTAP building STRUCTURE.
+  #
+  # @param model [OpenStudio::Model::Model] a model
+  # @param activity [BTAP::Activity] a BTAP building ACTIVITY object
+  # @param massive [Boolean] whether requesting internal mass generation
+  #
+  # @return [BTAP::Structure] a BTAP building STRUCTURE (see logs if failed)
+  def assign_building_structure(model: nil, activity: nil, massive: true)
+    @structure = BTAP::Structure.new(model, activity, massive)
+  end
 
   ##
-  # (Optionally) uprates, then derates, envelope surface constructions due to
+  # (Optionally) uprates - then derates - envelope surface constructions due to
   # MAJOR thermal bridges (e.g. roof parapets, corners, fenestration
   # perimeters). See lib/openstudio-standards/btap/bridging.rb, which relies on
   # the Thermal Bridging & Derating (TBD) gem.
   #
   # @param model [OpenStudio::Model::Model] an OpenStudio model
-  # @param tbd_option [String] BTAP/TBD option
-  # @param tbd_interpolate [Boolean] true if TBD interpolates between costed Uo
-  # @param wall_U [Double] wall conductance in W/m2.K (nil by default)
-  # @param floor_U [Double] floor conductance in W/m2.K (nil by default)
-  # @param roof_U [Double] roof conductance in W/m2.K (nil by default)
+  # @param necb_hdd [Boolean] whether to rely on BTAP to set HDD (vs stat file)
+  # @param structure [BTAP::Structure] BTAP Structure object
+  # @param option [#to_sym] BTAP/TBD option e.g. "uprate"
+  # @param interpolate [Boolean] true if TBD interpolates among Uo (uprating)
+  # @param wallU [Numeric] optional wall Ut in W/m2.K if uprating
+  # @param floorU [Numeric] optional floor Ut in W/m2.K if uprating
+  # @param roofU [Numeric] optional roof Ut in W/m2.K if uprating
   #
   # @return [Boolean] true if successful, e.g. no errors, compliant if uprated
   def apply_thermal_bridging(model: nil,
-                             tbd_option: 'none',
-                             tbd_interpolate: false,
-                             wall_U: nil,
-                             floor_U: nil,
-                             roof_U: nil)
-    return false unless model.is_a?(OpenStudio::Model::Model)
-    return false unless tbd_option.respond_to?(:to_s)
-
-    tbd_option = tbd_option.to_s
-    # 4x options:
-    #  - 'none' (TBD is ignored)
-    #  - derate using 'bad' PSI factors (BTAP-costed)
-    #  - derate using 'good' PSI factors (BTAP-costed)
-    #  - 'uprate' (then derate), i.e. iterative process (BTAP-costed)
-    ok = tbd_option == 'bad' || tbd_option == 'good' || tbd_option == 'uprate'
-    return true  if tbd_option == 'none'
-    return false unless ok
-
-    argh = {} # BTAP/TBD arguments
-    ok = tbd_interpolate == true || tbd_interpolate == false
-    argh[:interpolate] = tbd_interpolate if ok
-    argh[:interpolate] = false       unless ok
-
-    argh[:walls ] = { uo: wall_U  }
-    argh[:floors] = { uo: floor_U }
-    argh[:roofs ] = { uo: roof_U  }
-
-    if tbd_option == 'uprate'
-      argh[:walls  ][:ut] = wall_U
-      argh[:floors ][:ut] = floor_U
-      argh[:roofs  ][:ut] = roof_U
-    elsif tbd_option == 'good'
+                             necb_hdd: true,
+                             structure: nil,
+                             option: 'none',
+                             interpolate: false,
+                             wallU: nil,
+                             floorU: nil,
+                             roofU: nil)
+    necb_hdd = true unless [true, false].include?(necb_hdd)
+    return true unless option.respond_to?(:to_sym)
+    return true if option.to_s.downcase == 'none'
+
+    hdd    = get_necb_hdd18(model: model, necb_hdd: necb_hdd)
+    wallU  = wallU  ? wallU  : max_u_necb("wall", "outdoors", hdd)
+    floorU = floorU ? floorU : max_u_necb("floor", "outdoors", hdd)
+    roofU  = roofU  ? roofU  : max_u_necb("roofceiling", "outdoors", hdd)
+
+    argh             = {}
+    argh[:structure] = structure
+    argh[:walls    ] = { uo: wallU  }
+    argh[:floors   ] = { uo: floorU }
+    argh[:roofs    ] = { uo: roofU  }
+
+    case option.downcase
+    when 'uprate'
+      argh[:walls  ][:ut] = wallU
+      argh[:floors ][:ut] = floorU
+      argh[:roofs  ][:ut] = roofU
+    when 'good'
       argh[:quality] = :good
-    end    # default == :bad
+    else
+      argh[:quality] = :bad
+    end
+
+    argh[:interpolate] = interpolate
+    argh[:interpolate] = false unless [true, false].include?(interpolate)
 
     @tbd = BTAP::Bridging.new(model, argh)
 
@@ -1080,10 +1248,10 @@ class NECB2011 < Standard
 
   # @param necb_reference_hp [Boolean] if true, NECB reference model rules for heat pumps will be used.
   def apply_standard_efficiencies(model:, sizing_run_dir:, dcv_type: 'NECB_Default', necb_reference_hp: false)
-    raise('validation of model failed.') unless validate_initial_model(model)
+    # Do a sizing run
+    try_sizing_run(model: model, sizing_run_dir: sizing_run_dir, sizing_run_subdir: 'plant_loops')
 
     climate_zone = 'NECB HDD Method'
-    raise("sizing run 1 failed! check #{sizing_run_dir}") if model_run_sizing_run(model, "#{sizing_run_dir}/plant_loops", true) == false
 
     # This is needed for NECB2011 as a workaround for sizing the reheat boxes.
     model.getAirTerminalSingleDuctVAVReheats.each { |iobj| air_terminal_single_duct_vav_reheat_set_heating_cap(iobj) }
@@ -1962,7 +2130,8 @@ class NECB2011 < Standard
       space_type_apply_internal_loads(space_type: space_type, lights_type: lights_type, lights_scale: lights_scale)
 
       # Schedules
-      space_type_apply_internal_load_schedules(space_type, true, true, true, true, true, true)
+      space_type_apply_internal_load_schedules(space_type)
+      space_type_apply_thermostat_schedules(space_type)
     end
 
     OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.Model', 'Finished applying space types (loads)')
@@ -2286,28 +2455,42 @@ class NECB2011 < Standard
     return model
   end
 
-  # This method handles looking for the epw_file in the https://github.com/canmet-energy/btap_weather repository.  It
+  # This method handles looking for the epw_file in btap_weather or Climate.OneBuilding.Org. It
   # checks for the epw_file in the historical data first.  If it is not there then it looks in the future weather data.
   # If it is not there either, it throws an error.
-  # epw_file (String):  The name of the epw file.  The different weather files all share the same name as the epw file,
-  #                     only the extension changes.
-  def get_weather_file_from_repo(epw_file:)
+  # epw_file (String): The name of the epw file.  The different weather files all share the same name as the epw file,
+  #                    only the extension changes.
+  # btap_weather (Boolean): Determines whether to download from the btap_weather repository or Climate.OneBuilding.Org.
+  def get_weather_file_from_repo(epw_file:, btap_weather:)
     # Get just the weather file name without the extension
     weather_loc = epw_file[0..-5]
     # Get the url of the file containing the historical weather data file names in the repository and the repository
     # folder containing the files
-    historic_weather_files_loc = @standards_data['constants']['historic_weather_file_list']['value'].to_s
-    historic_git_folder = @standards_data['constants']['historic_weather_folder_url']['value'].to_s
+    if btap_weather
+      historic_weather_files_loc = @standards_data['constants']['historic_weather_file_list_btap']['value'].to_s
+      historic_folder = @standards_data['constants']['historic_weather_folder_url_btap']['value'].to_s
+      future_weather_files_loc = @standards_data['constants']['future_weather_file_list_btap']['value'].to_s
+      future_folder = @standards_data['constants']['future_weather_folder_url_btap']['value'].to_s
+    else
+      historic_weather_files_loc = @standards_data['constants']['historic_weather_file_list']['value'].to_s
+      historic_folder = @standards_data['constants']['historic_weather_folder_url']['value'].to_s
+      future_weather_files_loc = @standards_data['constants']['future_weather_file_list']['value'].to_s
+      future_folder = @standards_data['constants']['future_weather_folder_url']['value'].to_s
+    end
     # Get the files from the repository
-    success_flag = download_and_save_file(weather_list_url: historic_weather_files_loc, weather_loc: weather_loc, git_folder: historic_git_folder)
+    success_flag = download_and_save_file(weather_list_url: historic_weather_files_loc,
+                                          weather_loc: weather_loc,
+                                          download_folder: historic_folder,
+                                          btap_weather: btap_weather)
     return if success_flag
     # If the file could not be found in the historical data look for it with the future weather data.
     puts "Could not find #{epw_file} in historical weather data files, looking in future weather data files."
-    future_weather_files_loc = @standards_data['constants']['future_weather_file_list']['value'].to_s
-    future_git_folder = @standards_data['constants']['future_weather_folder_url']['value'].to_s
-    success_flag = download_and_save_file(weather_list_url: future_weather_files_loc, weather_loc: weather_loc, git_folder: future_git_folder)
+    success_flag = download_and_save_file(weather_list_url: future_weather_files_loc,
+                                          weather_loc: weather_loc,
+                                          download_folder: future_folder,
+                                          btap_weather: btap_weather)
     return if success_flag
-    raise("Could not locate the following file in the canmet/btap_weather repository or could not extract the data: #{epw_file}.  Please check the spelling of the file or visit https://github.com/canmet-energy/btap_weather to see if the file exists.")
+    raise("Could not locate the following file in #{btap_weather ? "btap_weather" : "Climate.OneBuilding.Org"} or could not extract the data: #{epw_file} Please check the spelling of the file or visit #{btap_weather ? "https://github.com/canmet-energy/btap_weather" : "https://climate.onebuilding.org/WMO_Region_4_North_and_Central_America/"} to see if the file exists.")
   end
 
   # This method actually looks for and downloads the zip file from the https://github.com/canmet-energy/btap_weather
@@ -2321,7 +2504,8 @@ class NECB2011 < Standard
   # weather_loc (string): the name of the epw file we are looking for without the .epw extension
   # git_folder (string): the url of the folder containing the weather files.  As of 2023-07-07 this this is either the
   #                      url of the historical weather data folder or the future weather data folder.
-  def download_and_save_file(weather_list_url:, weather_loc:, git_folder:)
+  # btap_weather (Boolean): Determines whether to download from the btap_weather repository or Climate.OneBuilding.Org.
+  def download_and_save_file(weather_list_url:, weather_loc:, download_folder:, btap_weather:)
     status = false
     attempt = 1
     # Try to download the list of weather files 5 times, waiting 5 seconds between each attempt.
@@ -2341,7 +2525,27 @@ class NECB2011 < Standard
           unless zip_name.nil?
             # Found the weather file on the list
             # Define the full url of the weather zip file we want to download
-            save_file_url = git_folder + zip_name
+            if btap_weather
+              save_file_url = download_folder + zip_name
+            else
+              # Used to resolve the Climate.OneBuilding.Org download link from using just the filename.
+              abbreviation_map = {
+                'AB' => 'AB_Alberta/',
+                'BC' => 'BC_British_Columbia/',
+                'MB' => 'MB_Manitoba/',
+                'NB' => 'NB_New_Brunswick/',
+                'NL' => 'NL_Newfoundland_and_Labrador/',
+                'NS' => 'NS_Nova_Scotia/',
+                'NT' => 'NT_Northwest_Territories/',
+                'NU' => 'NU_Nunavut/',
+                'ON' => 'ON_Ontario/',
+                'PE' => 'PE_Prince_Edward_Island/',
+                'QC' => 'QC_Quebec/',
+                'SK' => 'SK_Saskatchewan/',
+                'YT' => 'YT_Yukon/'
+              }
+              save_file_url = download_folder + abbreviation_map[zip_name[4..5]] + zip_name
+            end
             # Define the local location of where the weather zip file will be saved
             weather_dir = File.absolute_path(File.join(__FILE__, '..', '..', '..', '..', '..' , '..', "data/weather"))
             save_file = File.join(weather_dir, zip_name)
@@ -2417,6 +2621,9 @@ class NECB2011 < Standard
   def extract_weather_data(zipped_file:, weather_dir:)
     # Set a flag to check if the weather data is for future weather.
     future_file = false
+
+    # Data structure to determine if the weather file contains all necessary elements.
+    checklist = {'.epw' => false, '.stat' => false, '.ddy' => false}
     # Start expanding the data.
     Zip::File.open(zipped_file) do |zip_file|
       puts "Expanding #{zipped_file}"
@@ -2429,7 +2636,7 @@ class NECB2011 < Standard
         # to just '.ddy'. This is so the rest of BTAP uses the _ASHRAE.ddy file.
         entry_name = entry.name.to_s
         if entry_name.length > 11
-          future_file = true if entry_name[-11..-1] == '_ASHRAE.ddy'
+          future_file = true if entry_name.end_with?('_ASHRAE.ddy')
         end
         # entry.extract # This was required before but now it isn't.  I'm confused so am saving this comment to
         # remind me if there are problems later.
@@ -2437,6 +2644,12 @@ class NECB2011 < Standard
         content = entry.get_input_stream.read
         # Save the data locally
         File.open(curr_save_file, 'wb') { |save_f| save_f.write(content) }
+
+        # Add the file extension of the current entry to the checklist.
+        file_extension = entry_name[entry_name.rindex('.')..]
+        if checklist.key?(file_extension)
+          checklist[file_extension] = true
+        end
       end
     end
     if future_file
@@ -2453,6 +2666,13 @@ class NECB2011 < Standard
       FileUtils.cp(orig_ddy_name, rev_ddy_name)
       FileUtils.cp(ashrae_ddy_name, orig_ddy_name)
     end
+
+    # Return false if not all files are present:
+    if !checklist.values.all?()
+      puts "Error: Not all files present in #{zipped_file}. Missing #{checklist.select { |k, v| v == false}.keys.join(", ") } file(s). Exiting..."
+      exit(1)
+    end
+
     # Return true if everything worked out
     return true
   end
@@ -2521,6 +2741,24 @@ class NECB2011 < Standard
     return boiler_cap_ratios
   end
 
+  # Until someone has time to allow dwelling units, washrooms, cooridors, and storage rooms can get their own custom
+  # system types (beyond the default necb_system), this metod will set the system type for those rooms to either be
+  # their default or to the primary system type (if one is defined and the other sytems are not set to default)
+  def reset_hvac_system_if_required(hvac_system_primary: nil, hvac_system_dwelling_units: nil, hvac_system_corridor: nil, hvac_system_storage: nil, hvac_system_washrooms: nil)
+    if hvac_system_primary.nil? || hvac_system_primary.to_s.downcase == "necb_default"
+      hvac_system_dwelling_units = "NECB_Default"
+      hvac_system_corridor = "NECB_Default"
+      hvac_system_storage = "NECB_Default"
+      hvac_system_washrooms = "NECB_Default"
+    else
+      hvac_system_dwelling_units = hvac_system_primary unless hvac_system_dwelling_units.nil? || hvac_system_dwelling_units.to_s.downcase == "necb_default"
+      hvac_system_corridor = hvac_system_primary unless hvac_system_corridor.nil? || hvac_system_corridor.to_s.downcase == "necb_default"
+      hvac_system_storage = hvac_system_primary unless hvac_system_storage.nil? || hvac_system_storage.to_s.downcase == "necb_default"
+      hvac_system_washrooms = hvac_system_primary unless hvac_system_washrooms.nil? || hvac_system_washrooms.to_s.downcase == "necb_default"
+    end
+    return hvac_system_dwelling_units, hvac_system_corridor, hvac_system_storage, hvac_system_washrooms
+  end
+
   # This method checks if the output_meters argument contains a net electricity meter with 'timestep' frequency.  If one
   # is then the method does nothing.  If one is not then it is added.  This is used in conjunction with the
   # 'oerd_utility_pricing' argument.  If that argument is present then a net electricity meter with 'timestep' frequency
@@ -2531,17 +2769,89 @@ class NECB2011 < Standard
         {
           "name" => "ElectricityNet:Facility",
           "frequency" => "Hourly"
+        },
+        {
+          "name" => "Heating:Electricity",
+          "frequency" => "Hourly"
+        },
+        {
+          "name" => "WaterSystems:Electricity",
+          "frequency" => "Hourly"
         }
       ]
     else
-      electnet_facility = output_meters.select { |output_meter| (output_meter["name"].to_s.downcase == "electricitynet:facility") && (output_meter["frequency"].to_s.downcase == "zone timestep") }
+      electnet_facility = output_meters.select { |output_meter| (output_meter["name"].to_s.downcase == "electricitynet:facility") && (output_meter["frequency"].to_s.downcase == "hourly") }
       if electnet_facility.empty?
         output_meters << {
           "name" => "ElectricityNet:Facility",
           "frequency" => "Hourly"
         }
       end
+      heating_elec = output_meters.select { |output_meter| (output_meter["name"].to_s.downcase == "heating:electricity") && (output_meter["frequency"].to_s.downcase == "hourly") }
+      if electnet_facility.empty?
+        output_meters << {
+          "name" => "Heating:Electricity",
+          "frequency" => "Hourly"
+        }
+      end
+      watersys_elec = output_meters.select { |output_meter| (output_meter["name"].to_s.downcase == "watersystems:electricity") && (output_meter["frequency"].to_s.downcase == "hourly") }
+      if electnet_facility.empty?
+        output_meters << {
+          "name" => "WaterSystems:Electricity",
+          "frequency" => "Hourly"
+        }
+      end
     end
     return output_meters
   end
+
+  # This method is used to do a sizing run on the model.  It will return true if the sizing run was successful and
+  # will generate an error if it was not.  The method will also resize any DX heating coils that have a capacity less than 1.0 kW to
+  # 1.0 kW and rerun the sizing run until it succeeds or the sizing run continues to fail.
+  #
+  # Arguments:
+  # model (OpenStudio::Model::Model): The model to run the sizing run on.
+  # sizing_run_dir (String): The directory where the sizing run files will be saved.
+  def try_sizing_run(model:, sizing_run_dir:, sizing_run_subdir:)
+    raise('validation of model failed.') unless validate_initial_model(model)
+
+    # Do a sizing run to determine the system capacities.  If a sizing run fails, hard size any failing DX heating coils
+    # to 1.0 kW and rerun the sizing run until it succeeds.  If no DX heating coils are found, or none had a small
+    # capacity then raise an error.
+    loop do
+      sizing_run_success = model_run_sizing_run(model, "#{sizing_run_dir}/#{sizing_run_subdir}", true)
+      break if sizing_run_success
+
+      # Sizing run failed, check all DX heating coils and set their size to 1 if less than 1
+      dx_coil_changed = false
+
+      model.getCoilHeatingDXSingleSpeeds.each do |coil|
+        autosized_capacity = coil.autosizedRatedTotalHeatingCapacity
+        if autosized_capacity.is_initialized && autosized_capacity.get < 1.0
+          coil.setRatedTotalHeatingCapacity(1.0)
+          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.AirLoopHVAC',  "DX Heating Coil #{coil.name.to_s} has a rated capacity less than 1.0 kW and has been resized to 1.0 kW to avoid sizing run failure.")
+          puts "DX Heating Coil #{coil.name.to_s} has a rated capacity less than 1.0 kW and has been resized to 1.0 kW to avoid sizing run failure."
+          dx_coil_changed = true
+        end
+      end
+      model.getCoilHeatingDXMultiSpeeds.each do |coil|
+        coil.stages.each do |stage|
+          autosized_capacity = stage.autosizedGrossRatedHeatingCapacity
+          if autosized_capacity.is_initialized && autosized_capacity.get < 1.0
+            stage.setGrossRatedHeatingCapacity(1.0)
+            OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.AirLoopHVAC',  "A DX Heating Coil #{coil.name.to_s} stage has a rated capacity less than 1.0 kW and has been resized to 1.0 kW to avoid sizing run failure.")
+            puts "A DX Heating Coil #{coil.name.to_s} stage has a rated capacity less than 1.0 kW and has been resized to 1.0 kW to avoid sizing run failure."
+            dx_coil_changed = true
+          end
+        end
+      end
+
+      # If no DX coil was changed, break loop and raise error
+      if !dx_coil_changed
+        raise("sizing run failed! check #{sizing_run_dir}/#{sizing_run_subdir} (DX coil sizes adjusted, but no further changes possible)")
+      end
+      puts "Rerunning sizing run after adjusting DX heating coil capacity to 1.0 kW."
+      # Otherwise, loop will rerun sizing
+    end
+  end
 end