openstudio-standards 0.2.17.rc2 → 0.3.1.rc1

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

@@ -3,11 +3,13 @@
 class NECB2011 < Standard
   @template = new.class.name
   register_standard(@template)
+  attr_reader :tbd
   attr_reader :template
   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'
   def convert_arg_to_f(variable:, default:)
     return variable if variable.kind_of?(Numeric)
@@ -119,6 +121,7 @@ class NECB2011 < Standard
     @template = self.class.name
     @standards_data = load_standards_database_new
     corrupt_standards_database
+    @tbd = nil
     # puts "loaded these tables..."
     # puts @standards_data.keys.size
     # raise("tables not all loaded in parent #{}") if @standards_data.keys.size < 24
@@ -166,7 +169,7 @@ class NECB2011 < Standard
       return epw.hdd18.to_f
     else
       dist_clause = "%.2f % #{(min_distance / 1000.0)}"
-      puts "INFO:NECB HDD18 of #{necb_closest['degree_days_below_18_c'].to_f}  at nearest city #{necb_closest['city']},#{necb_closest['province']}, at a distance of " + dist_clause + 'km from epw location. Ref:necb_2015_table_c1'
+      puts "INFO:NECB HDD18 of #{necb_closest['degree_days_below_18_c'].to_f}  at nearest city #{necb_closest['city']},#{necb_closest['province']}, at a distance of " + dist_clause + 'km from epw location. Ref: nbc_2015_table_c1'
       return necb_closest['degree_days_below_18_c'].to_f
     end
   end
@@ -177,7 +180,7 @@ class NECB2011 < Standard
                                    epw_file:,
                                    debug: false,
                                    sizing_run_dir: Dir.pwd,
-                                   primary_heating_fuel: 'DefaultFuel',
+                                   primary_heating_fuel: 'Electricity',
                                    dcv_type: 'NECB_Default',
                                    lights_type: 'NECB_Default',
                                    lights_scale: 1.0,
@@ -227,10 +230,11 @@ class NECB2011 < Standard
                                    shw_scale: nil,
                                    output_meters: nil,
                                    airloop_economizer_type: nil,
-                                   baseline_system_zones_map_option: nil)
-
+                                   baseline_system_zones_map_option: nil,
+                                   tbd_option: nil)
     model = load_building_type_from_library(building_type: building_type)
     return model_apply_standard(model: model,
+                                tbd_option: tbd_option,
                                 epw_file: epw_file,
                                 sizing_run_dir: sizing_run_dir,
                                 primary_heating_fuel: primary_heating_fuel,
@@ -301,8 +305,11 @@ 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,
                            epw_file:,
                            sizing_run_dir: Dir.pwd,
+                           necb_reference_hp: false,
+                           necb_reference_hp_supp_fuel: 'DefaultFuel',
                            primary_heating_fuel: 'DefaultFuel',
                            dcv_type: 'NECB_Default',
                            lights_type: 'NECB_Default',
@@ -353,9 +360,9 @@ class NECB2011 < Standard
                            shw_scale: nil,
                            output_meters: nil,
                            airloop_economizer_type: nil,
-                           baseline_system_zones_map_option: nil
-                           )
-
+                           baseline_system_zones_map_option: nil)
+    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)
@@ -386,13 +393,15 @@ class NECB2011 < Standard
     apply_fdwr_srr_daylighting(model: model,
                                fdwr_set: fdwr_set,
                                srr_set: srr_set)
+    apply_thermal_bridging(model: model, tbd_option: tbd_option)
     apply_auto_zoning(model: model,
                       sizing_run_dir: sizing_run_dir,
                       lights_type: lights_type,
                       lights_scale: lights_scale)
+    apply_kiva_foundation(model)
     apply_systems_and_efficiencies(model: model,
-                                   primary_heating_fuel: primary_heating_fuel,
                                    sizing_run_dir: sizing_run_dir,
+                                   primary_heating_fuel: primary_heating_fuel,
                                    dcv_type: dcv_type,
                                    ecm_system_name: ecm_system_name,
                                    ecm_system_zones_map_option: ecm_system_zones_map_option,
@@ -463,8 +472,8 @@ class NECB2011 < Standard
   end
 
   def apply_systems_and_efficiencies(model:,
-                                     primary_heating_fuel:,
                                      sizing_run_dir:,
+                                     primary_heating_fuel:,
                                      dcv_type: 'NECB_Default',
                                      ecm_system_name: 'NECB_Default',
                                      ecm_system_zones_map_option: 'NECB_Default',
@@ -494,17 +503,25 @@ class NECB2011 < Standard
     # -------- Systems Layout-----------
 
     # Create Default Systems.
-    apply_systems(model: model, primary_heating_fuel: primary_heating_fuel, sizing_run_dir: sizing_run_dir, shw_scale: shw_scale,
+    apply_systems(model: model,
+                  primary_heating_fuel: primary_heating_fuel,
+                  sizing_run_dir: sizing_run_dir,
+                  shw_scale: shw_scale,
                   baseline_system_zones_map_option: baseline_system_zones_map_option)
 
     # Apply new ECM system. Overwrite standard as required.
-    ecm.apply_system_ecm(model: model, ecm_system_name: ecm_system_name, template_standard: self, primary_heating_fuel: primary_heating_fuel, 
+    ecm.apply_system_ecm(model: model,
+                         ecm_system_name: ecm_system_name,
+                         template_standard: self,
+                         primary_heating_fuel: self.fuel_type_set.ecm_fueltype,
                          ecm_system_zones_map_option: ecm_system_zones_map_option)
 
     # -------- Performace, Efficiencies, Controls and Sensors ------------
     #
     # Set code standard equipment charecteristics.
-    sql_db_vars_map = apply_standard_efficiencies(model: model, sizing_run_dir: sizing_run_dir)
+    sql_db_vars_map = apply_standard_efficiencies(model: model,
+                                                  sizing_run_dir: sizing_run_dir,
+                                                  necb_reference_hp: self.fuel_type_set.necb_reference_hp)
     # Apply System
     ecm.apply_system_efficiencies_ecm(model: model, ecm_system_name: ecm_system_name)
     # Apply ECM ERV charecteristics as required. Part 2 of above ECM.
@@ -515,8 +532,8 @@ class NECB2011 < Standard
     ecm.modify_boiler_efficiency(model: model, boiler_eff: boiler_eff)
     # Apply Furnace Efficiency
     ecm.modify_furnace_efficiency(model: model, furnace_eff: furnace_eff)
-    # Apply Unitary efficiency
-    ecm.modify_unitary_cop(model: model, unitary_cop: unitary_cop, sql_db_vars_map: sql_db_vars_map)
+    # Apply Unitary curves
+    ecm.modify_unitary_cop(model: model, unitary_cop: unitary_cop, sizing_done: false, sql_db_vars_map: sql_db_vars_map)
     # Apply SHW Efficiency
     ecm.modify_shw_efficiency(model: model, shw_eff: shw_eff)
     # Apply daylight controls.
@@ -525,6 +542,16 @@ class NECB2011 < Standard
     ecm.modify_chiller_efficiency(model: model, chiller_type: chiller_type)
     # Apply airloop economizer
     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") == false
+        raise('sizing run 2 failed!')
+      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)
+    # set capacities of district heating and cooling equipment for ground-source heat pump ecm
+    ecm.set_ghx_loop_district_cap(model) if (!model.getDistrictHeatings.empty? && !model.getDistrictCoolings.empty?)
 
     # -------Pump sizing required by some vintages----------------
     # Apply Pump power as required.
@@ -628,6 +655,224 @@ class NECB2011 < Standard
     model_create_thermal_zones(model, @space_multiplier_map)
   end
 
+  # apply the Kiva foundation model to floors and walls with ground boundary condition
+  # created by: Kamel Haddad (kamel.haddad@nrcan-rncan.gc.ca)
+  def apply_kiva_foundation(model)
+    # 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")
+    bldg_kiva_model.setWallHeightAboveGrade(0.0)
+    bldg_kiva_model.setWallDepthBelowSlab(0.0)
+    model.getThermalZones.sort.each do |zone|
+      zone_kiva_models = [bldg_kiva_model]
+      zone_grd_flr_counter = 0
+      zone.spaces.sort.each do |space|
+        # store space floors and walls in contact with ground and exterior walls
+        space_ground_floors = []
+        space_ground_walls = []
+        space_ext_walls = []
+        space_ground_floors += space.surfaces.select {|surf| surf.surfaceType.downcase == 'floor' && surf.isGroundSurface }
+        space_ground_walls += space.surfaces.select {|surf| surf.surfaceType.downcase == 'wall' && surf.isGroundSurface }
+        space_ext_walls += space.surfaces.select {|surf| surf.surfaceType.downcase == 'wall' && surf.outsideBoundaryCondition.downcase == 'outdoors'}
+        # loop through space floors in contact with ground and assing a Kiva model for each
+        space_ground_floors.each do |gfloor|
+          zone_grd_flr_counter += 1
+          if zone_grd_flr_counter > 1
+            # a new Kiva model is needed for each additional floor in contact with the ground in the zone
+            kiva_model = OpenStudio::Model::FoundationKiva.new(model)
+            kiva_model.setName("#{gfloor.name.to_s} Kiva Foundation")
+            kiva_model.setWallHeightAboveGrade(0.0)
+            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)
+          # Set the exposed perimeter for space floors in contact with the ground.
+          floor_exp_per = 0.0
+          if !space_ground_walls.empty?
+            floor_exp_per += get_surface_exp_per(gfloor,space_ground_walls)
+          elsif !space_ext_walls.empty?
+            floor_exp_per += get_surface_exp_per(gfloor,space_ext_walls)
+          end
+          gfloor.createSurfacePropertyExposedFoundationPerimeter('TotalExposedPerimeter',floor_exp_per)
+          # specify a foundation boundary condition for space walls in contact with the ground and in
+          # 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)
+            end
+          end
+        end
+      end
+    end
+    kiva_settings = model.getFoundationKivaSettings if !model.getFoundationKivas.empty?
+  end
+
+  # check if two surfaces are in contact. For every two consecutive vertices on surface 1, 
+  # loop through two consecutive vertices of surface two. Then check whether the vertices 
+  # of surfaces 2 are on the same line as the vertices from surface 1. If the two vectors 
+  # defined by the two vertices on surface 1 and those on surface 2 overlap, then the two 
+  # surfaces are in contact. If a side from surface 2 is in contact with a side from surface 1,
+  # the length of the side from surface 2 is limited to the length of the side from surface 1.
+  # created by: Kamel Haddad (kamel.haddad@nrcan-rncan.gc.ca)
+  def surfaces_are_in_contact?(surf1,surf2)
+    surfaces_in_contact = false
+    vert1 = surf1.vertices[0]
+    for index1 in 1..surf1.vertices.size
+      if index1 < surf1.vertices.size
+        vert2 = surf1.vertices[index1]
+      else
+        vert2 = surf1.vertices[0]
+      end
+      seg12_length = ((vert2.x-vert1.x)**2+(vert2.y-vert1.y)**2+(vert2.z-vert1.z)**2)**0.5
+      surf2_seg_length = 0.0
+      vert3 = surf2.vertices[0]
+      for index2 in 1..surf2.vertices.size
+        if index2 < surf2.vertices.size
+          vert4 = surf2.vertices[index2]
+        else
+          vert4 = surf2.vertices[0]
+        end
+        vert1_2_3_same_line_and_dir = three_vertices_same_line_and_dir?(vert1,vert2,vert3)
+        if vert1_2_3_same_line_and_dir
+          vert1_2_4_same_line_and_dir = three_vertices_same_line_and_dir?(vert1,vert2,vert4)
+          if vert1_2_4_same_line_and_dir
+            surfaces_in_contact = true
+            seg34_length = ((vert4.x-vert3.x)**2+(vert4.y-vert3.y)**2+(vert4.z-vert3.z)**2)**0.5
+            surf2_seg_length += seg34_length
+            raise("Surface #{surf2.name.to_s} has sides in contact with surface #{surf1.name.to_s} but with a length greater than the max.") if surf2_seg_length > seg12_length
+          end
+        end
+        vert3 = vert4
+      end
+      vert1 = vert2
+    end
+
+    return surfaces_in_contact
+  end
+
+  # Loop through the layers of the construction of the surface and replace any massless material with 
+  # a standard one. The material used instead is from the EnergyPlus dataset file 'ASHRAE_2005_HOF_Materials.idf' 
+  # with the name: 'Insulation: Expanded polystyrene - extruded (smooth skin surface) (HCFC-142b exp.)'. 
+  # The thickness of the new material is based on the thermal resistance of the massless material it replaces.
+  # created by: Kamel Haddad (kamel.haddad@nrcan-rncan.gc.ca)
+  def replace_massless_material_with_std_material(model,surf)
+    std_const_name = "#{surf.construction.get.name.to_s}_std"
+    std_const = model.getLayeredConstructions.select {|const| const.name.to_s == std_const_name}
+    new_const = nil
+    if !std_const.empty?
+      new_const = std_const[0]
+    else
+      new_layers = {}
+      has_massless_mat = false
+      layer_index = 0
+      surf.construction.get.to_LayeredConstruction.get.layers.each do |layer|
+        if layer.to_MasslessOpaqueMaterial.is_initialized then
+          has_massless_mat = true
+          new_mat = OpenStudio::Model::StandardOpaqueMaterial.new(model)
+          new_mat.setName("Expanded Polystyrene")
+          new_mat.setThermalConductivity(0.029)
+          new_mat.setDensity(29.0)
+          new_mat.setSpecificHeat(1210.0)
+          new_mat.setRoughness('MediumSmooth')
+          new_mat.setThickness(layer.to_MasslessOpaqueMaterial.get.thermalResistance.to_f * new_mat.thermalConductivity.to_f)
+        else
+          new_mat = layer
+        end
+        new_layers[layer_index] = new_mat
+        layer_index += 1
+      end
+      if has_massless_mat
+        new_const = OpenStudio::Model::Construction.new(model)
+        new_layers.keys.sort.each {|layer_index| new_const.to_LayeredConstruction.get.insertLayer(layer_index,new_layers[layer_index])}
+        new_const.setName("#{surf.construction.get.name.to_s}_std")
+      end
+    end
+    surf.setConstruction(new_const) if !new_const.nil?
+
+  end
+
+  # Find the exposed perimeter of a floor surface. For each side of the floor loop through 
+  # the walls and find the walls that share sides with the floor. Then sum the lengths of 
+  # the sides of the walls that come in contact with sides of the floor.
+  # created by: Kamel Haddad (kamel.haddad@nrcan-rncan.gc.ca)
+  def get_surface_exp_per(floor,walls)
+    floor_exp_per = 0.0
+    vert1 = floor.vertices[0]
+    # loop through the indices of the floor surface
+    for index in 1..floor.vertices.size
+      if index < floor.vertices.size
+        vert2 = floor.vertices[index]
+      else
+        vert2 = floor.vertices[0]
+      end
+      side_length = ((vert2.x-vert1.x)**2+(vert2.y-vert1.y)**2+(vert2.z-vert1.z)**2)**0.5
+      walls_exp_per = 0.0
+      walls.each do |wall|
+        vert3 = wall.vertices[0]
+        # loop through the indices of the wall surface
+        for index2 in 1..wall.vertices.size-1
+          if index2 < wall.vertices.size
+            vert4 = wall.vertices[index2]
+          else
+            vert4 = wall.vertices[0]
+          end
+          vert1_2_3_on_same_line = three_vertices_same_line_and_dir?(vert1,vert2,vert3)
+          if vert1_2_3_on_same_line
+            vert1_2_4_on_same_line = three_vertices_same_line_and_dir?(vert1,vert2,vert4)
+            if vert1_2_4_on_same_line
+              wall_width = ((vert4.x-vert3.x)**2+(vert4.y-vert3.y)**2+(vert4.z-vert3.z)**2)**0.5
+              walls_exp_per += wall_width
+            end
+          end
+          vert3 = vert4
+        end
+      end
+      # increment the exposed perimeter of the floor. Limit the length of the walls in contact with the 
+      # side of the floor to the length of the side of the floor.
+      floor_exp_per += [walls_exp_per,side_length].min
+      vert1 = vert2
+    end
+
+    return floor_exp_per
+  end
+
+  # check that three vertices are on the same line. Also check that the vectors 
+  # from vert1 and vert2 and from vert1 and vert3 are in the same direction.
+  # created by: Kamel Haddad (kamel.haddad@nrcan-rncan.gc.ca)
+  def three_vertices_same_line_and_dir?(vert1,vert2,vert3)
+    tol = 1.0e-5
+    vec12x,vec12y,vec12z = -vert1.x+vert2.x,-vert1.y+vert2.y,-vert1.z+vert2.z # x,y,z of vector 12
+    vec12x = 0.0 if vec12x.abs < tol
+    vec12y = 0.0 if vec12y.abs < tol
+    vec12z = 0.0 if vec12z.abs < tol
+    vec13x,vec13y,vec13z = -vert1.x+vert3.x,-vert1.y+vert3.y,-vert1.z+vert3.z # x,y,z of vector 13
+    vec13x = 0.0 if vec13x.abs < tol
+    vec13y = 0.0 if vec13y.abs < tol
+    vec13z = 0.0 if vec13z.abs < tol
+    # x,y,z of the cross product of the vectors 12 and 13
+    cross_12_13_x = vec12y*vec13z-vec12z*vec13y
+    cross_12_13_y = vec12z*vec13x-vec12x*vec13z
+    cross_12_13_z = vec12x*vec13y-vec12y*vec13x
+    # vectors are in parallel when x,y,z of cross product are 0.0
+    vertices_on_same_line = false
+    vertices_on_same_line = true if (cross_12_13_x == 0.0) && (cross_12_13_y == 0.0) && (cross_12_13_z == 0.0)
+    vectors_same_direction = false
+    if vertices_on_same_line
+      vec12_13_x_factor = vec13x*vec12x
+      vec12_13_y_factor = vec13y*vec12y
+      vec12_13_z_factor = vec13z*vec12z
+      vectors_same_direction = true if (vec12_13_x_factor >= 0.0) && (vec12_13_y_factor >= 0.0) && (vec12_13_z_factor >= 0.0)
+    end
+    same_line_same_dir = vertices_on_same_line && vectors_same_direction
+
+    return same_line_same_dir
+  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
@@ -647,19 +892,66 @@ class NECB2011 < Standard
     # model_add_daylighting_controls(model) # to be removed after refactor.
   end
 
-  def apply_standard_efficiencies(model:, sizing_run_dir:, dcv_type: 'NECB_Default')
+  ##
+  # 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.
+  #
+  # @param model [OpenStudio::Model::Model] an OpenStudio model
+  # @param tbd_option [String] BTAP/TBD option
+  #
+  # @return [Bool] true if successful, e.g. no errors, compliant if uprated
+  def apply_thermal_bridging(model: nil, tbd_option: 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:
+    #  - nil or '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)
+
+    # Do nothing if nil or none or NECB_Default.
+    return true  if tbd_option.nil? || tbd_option == 'none' || tbd_option =='NECB_Default'
+    unless tbd_option == 'bad' || tbd_option == 'good' || tbd_option == 'uprate'
+      puts("invalid input for thermal bridging. Must be good, bad, uprate or nil")
+      return false
+    end
+
+    argh          = {} # BTAP/TBD arguments
+    argh[:walls ] = { uo: nil }
+    argh[:floors] = { uo: nil }
+    argh[:roofs ] = { uo: nil }
+
+    if tbd_option == 'uprate'
+      argh[:walls  ][:ut] = nil
+      argh[:floors ][:ut] = nil
+      argh[:roofs  ][:ut] = nil
+    elsif tbd_option == 'good'
+      argh[:quality] = :good
+    end    # default == :bad
+
+    @tbd = BTAP::Bridging.new(model, argh)
+    true
+  end
+
+  # @param necb_ref_hp [Bool] 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)
 
     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") == false
 
-    # This is needed for NECB2011 as a workaround for sizing the reheat boxes
+    # 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) }
     # Apply the prototype HVAC assumptions
     model_apply_prototype_hvac_assumptions(model, nil, climate_zone)
     # Apply the HVAC efficiency standard
     sql_db_vars_map = {}
-    model_apply_hvac_efficiency_standard(model, climate_zone, sql_db_vars_map: sql_db_vars_map)
+    model_apply_hvac_efficiency_standard(model, climate_zone, sql_db_vars_map: sql_db_vars_map, necb_ref_hp: necb_reference_hp)
+
     model_enable_demand_controlled_ventilation(model, dcv_type)
     return sql_db_vars_map
   end
@@ -699,8 +991,12 @@ class NECB2011 < Standard
 
     # Set HVAC availability schedule to follow occupancy
     air_loop_hvac.setAvailabilitySchedule(loop_occ_sch)
-    air_loop_hvac.supplyComponents('OS:AirLoopHVAC:UnitaryHeatPump:AirToAir:MultiSpeed'.to_IddObjectType).each do |comp|
-      comp.to_AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed.get.setAvailabilitySchedule(loop_occ_sch)
+    air_loop_hvac.supplyComponents.each do |comp|
+      if comp.to_AirLoopHVACUnitaryHeatPumpAirToAir.is_initialized
+        comp.to_AirLoopHVACUnitaryHeatPumpAirToAir.get.setSupplyAirFanOperatingModeSchedule(loop_occ_sch)
+      elsif comp.to_AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed.is_initialized
+        comp.to_AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed.get.setAvailabilitySchedule(loop_occ_sch)
+      end
     end
 
     return true

data/lib/openstudio-standards/standards/necb/NECB2011/qaqc/necb_qaqc.rb

@@ -200,7 +200,7 @@ class NECB2011
     outdoor_floors = BTAP::Geometry::Surfaces.filter_by_surface_types(outdoor_surfaces, 'Floor')
     outdoor_subsurfaces = BTAP::Geometry::Surfaces.get_subsurfaces_from_surfaces(outdoor_surfaces)
 
-    ground_surfaces = BTAP::Geometry::Surfaces.filter_by_boundary_condition(surfaces, 'Ground')
+    ground_surfaces = BTAP::Geometry::Surfaces.filter_by_boundary_condition(surfaces, ['Ground', 'Foundation'])
     ground_walls = BTAP::Geometry::Surfaces.filter_by_surface_types(ground_surfaces, 'Wall')
     ground_roofs = BTAP::Geometry::Surfaces.filter_by_surface_types(ground_surfaces, 'RoofCeiling')
     ground_floors = BTAP::Geometry::Surfaces.filter_by_surface_types(ground_surfaces, 'Floor')

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

@@ -197,7 +197,6 @@ class NECB2011
 
     # Convert to SI
     ua_btu_per_hr_per_c = OpenStudio.convert(ua_btu_per_hr_per_f, 'Btu/hr*R', 'W/K').get
-
     # Set the water heater properties
     # Efficiency
     water_heater_mixed.setHeaterThermalEfficiency(water_heater_eff)
@@ -222,7 +221,7 @@ class NECB2011
 
     # Append the name with standards information
     water_heater_mixed.setName("#{water_heater_mixed.name} #{water_heater_eff.round(3)} Therm Eff")
-    OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.WaterHeaterMixed', "For #{template}: #{water_heater_mixed.name}; thermal efficiency = #{water_heater_eff.round(3)}, skin-loss UA = #{ua_btu_per_hr_per_f.round}Btu/hr")
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.WaterHeaterMixed', "For #{template}: #{water_heater_mixed.name}; thermal efficiency = #{water_heater_eff.round(3)}, skin-loss UA = #{ua_btu_per_hr_per_f.round}Btu/hr-R")
     return true
   end
 
@@ -263,14 +262,14 @@ class NECB2011
     model.getSpaces.sort.each do |space|
       space_peak_flow = 0
       data = nil
-      space_type_name = space.spaceType.get.nameString
+      space_type_name = space.spaceType.get.standardsSpaceType.get.to_s
       tank_temperature = 60
       # find the specific space_type properties from standard.json
       space_types_table.each do |space_type|
-        if space_type_name == (space_type['building_type'] + ' ' + space_type['space_type'])
+        if (space_type['building_type'] + ' ' + space_type_name) == (space_type['building_type'] + ' ' + space_type['space_type'])
           break if space_type['necb_hvac_system_selection_type'] == '- undefined -'
           # If there is no service hot water load.. Don't bother adding anything.
-          break if space_type['service_water_heating_peak_flow_per_area'].to_f == 0.0 && space_type['service_water_heating_peak_flow_rate'].to_f == 0.0 || space_type['service_water_heating_schedule'].nil?
+          break if (space_type['service_water_heating_peak_flow_per_area'].to_f == 0.0 && space_type['service_water_heating_peak_flow_rate'].to_f == 0.0) || space_type['service_water_heating_schedule'].nil?
 
           # If there is a service hot water load collect the space information
           data = space_type
@@ -280,7 +279,6 @@ class NECB2011
       # If there is no service hot water load.. Don't bother adding anything.
       # Skip space types with no data
       next if data.nil?
-
       space_area = OpenStudio.convert(space.floorArea, 'm^2', 'ft^2').get # ft2
       # Calculate the peak shw flow rate for the space.  Peak flow from JSON file is in US Gal/hr/ft^2
       # space_peak_flow_ind is the peak flow rate for the space while space_peak_flow is the peak flow

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

@@ -0,0 +1,38 @@
+class SystemFuels
+  attr_accessor :name
+  attr_accessor :boiler_fueltype
+  attr_accessor :baseboard_type
+  attr_accessor :mau_type
+  attr_accessor :mau_heating_coil_type
+  attr_accessor :mau_cooling_type
+  attr_accessor :chiller_type
+  attr_accessor :heating_coil_type_sys3
+  attr_accessor :heating_coil_type_sys4
+  attr_accessor :heating_coil_type_sys6
+  attr_accessor :necb_reference_hp
+  attr_accessor :necb_reference_hp_supp_fuel
+  attr_accessor :fan_type
+  attr_accessor :swh_fueltype
+  attr_accessor :ecm_fueltype
+  def set_defaults(standards_data:, primary_heating_fuel:)
+    # Get fuelset.
+    system_fuel_defaults = standards_data['fuel_type_sets'].detect { |fuel_type_set| fuel_type_set['name'] == primary_heating_fuel }
+    raise("fuel_type_sets named #{primary_heating_fuel} not found in fuel_type_sets table.") if system_fuel_defaults.nil?
+    # Assign fuel sources.
+    @name = system_fuel_defaults['name']
+    @boiler_fueltype = system_fuel_defaults['boiler_fueltype']
+    @baseboard_type = system_fuel_defaults['baseboard_type']
+    @mau_type = system_fuel_defaults['mau_type']
+    @mau_cooling_type = system_fuel_defaults['mau_cooling_type']
+    @chiller_type = system_fuel_defaults['chiller_type']
+    @mau_heating_coil_type = system_fuel_defaults['mau_heating_coil_type']
+    @heating_coil_type_sys3 = system_fuel_defaults['heating_coil_type_sys3']
+    @heating_coil_type_sys4 = system_fuel_defaults['heating_coil_type_sys4']
+    @heating_coil_type_sys6 = system_fuel_defaults['heating_coil_type_sys6']
+    @necb_reference_hp = system_fuel_defaults['necb_reference_hp']
+    @necb_reference_hp_supp_fuel = system_fuel_defaults['necb_reference_hp_supp_fuel']
+    @fan_type = system_fuel_defaults['fan_type']
+    @swh_fueltype = system_fuel_defaults['swh_fueltype']
+    @ecm_fueltype = system_fuel_defaults['ecm_fueltype']
+  end
+end