openstudio-standards 0.2.12.rc4 → 0.2.12.rc5

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

@@ -52,7 +52,7 @@ class NECB2011
   # Some expections are dwelling units wet zone and wild zones.  These spaces will have special considerations when autozoning a
   # building.
 
-  def apply_auto_zoning(model:, sizing_run_dir: Dir.pwd)
+  def apply_auto_zoning(model:, sizing_run_dir: Dir.pwd, lights_type: 'NECB_Default', lights_scale: 1.0)
     raise('validation of model failed.') unless validate_initial_model(model)
 
     # Check to see if model is using another vintage of spacetypes. If so overwrite the @standards for the object with the
@@ -82,9 +82,9 @@ class NECB2011
     # Remove any Thermal zones assigned again to start fresh.
     model.getThermalZones.each(&:remove)
     self.auto_zone_dwelling_units(model)
-    self.auto_zone_wet_spaces(model)
+    self.auto_zone_wet_spaces(model: model, lights_type: lights_type, lights_scale: lights_scale)
     self.auto_zone_all_other_spaces(model)
-    self.auto_zone_wild_spaces(model)
+    self.auto_zone_wild_spaces(model: model, lights_type: lights_type, lights_scale: lights_scale)
     #THis will color the spaces and zones.
     random = Random.new(1234)
     #Set ideal hvac in case we want to not implement the hvac yet and still run osm right after this function.
@@ -193,6 +193,7 @@ class NECB2011
     # set a larger tolerance for unmet hours from default 0.2 to 1.0C
     model.getOutputControlReportingTolerances.setToleranceforTimeHeatingSetpointNotMet(1.0)
     model.getOutputControlReportingTolerances.setToleranceforTimeCoolingSetpointNotMet(1.0)
+
   end
 
   # Method to store space sizing loads. This is needed because later when the zones are destroyed this information will be lost.
@@ -283,7 +284,8 @@ class NECB2011
   # Something that the code is silent on are smelly humid areas that should not be on the same system as the rest of the
   #  building.. These are the 'wet' spaces and have been defined as locker and washroom areas.. These will be put under
   # their own single system 4 system. These will be set to the dominant floor schedule.
-  def auto_zone_wet_spaces(model)
+
+  def auto_zone_wet_spaces(model:, lights_type: 'NECB_Default', lights_scale: 1.0)
     wet_zone_array = Array.new
     model.getSpaces.select {|space| is_an_necb_wet_space?(space)}.each do |space|
       #if this space was already assigned to something skip it.
@@ -302,7 +304,8 @@ class NECB2011
 
       #this method will determine if the right schedule was used for this wet & wild space if not.. it will reset the space
       # to use the correct schedule version of the wet and wild space type.
-      adjust_wildcard_spacetype_schedule(space, dominant_schedule)
+      adjust_wildcard_spacetype_schedule(space: space, schedule: dominant_schedule, lights_type: lights_type, lights_scale: lights_scale)
+
       #Find spacetype thermostat and assign it to the zone.
       thermostat_name = space.spaceType.get.name.get + ' Thermostat'
       thermostat = model.getThermostatSetpointDualSetpointByName(thermostat_name)
@@ -320,7 +323,7 @@ class NECB2011
       model.getSpaces.select {|s| is_an_necb_wet_space?(s)}.each do |space_target|
         if space_target.thermalZone.empty?
           if are_space_loads_similar?(space_1: space, space_2: space_target) && space.buildingStory().get == space_target.buildingStory().get # added since chris needs zones to not span floors for costing.
-            adjust_wildcard_spacetype_schedule(space_target, dominant_schedule)
+            adjust_wildcard_spacetype_schedule(space_target, dominant_schedule, lights_type, lights_scale, space_height)
             space_target.setThermalZone(zone)
           end
         end
@@ -379,7 +382,7 @@ class NECB2011
 
   # This will take all the wildcard spaces and merge them to be supported by a system 4. The control zone will be the
   # zone that has the largest heating load per area.
-  def auto_zone_wild_spaces(model)
+  def auto_zone_wild_spaces(model:, lights_type: 'NECB_Default', lights_scale: 1.0)
     other_tz_array = Array.new
     #iterate through wildcard spaces.
     model.getSpaces.select {|space| is_an_necb_wildcard_space?(space) and not is_an_necb_wet_space?(space)}.each do |space|
@@ -396,10 +399,13 @@ class NECB2011
       #Assign space to the new zone.
       space.setThermalZone(zone)
 
-      #lets keep the wild schedules to be the same as what dominate the floor.
+      # lets keep the wild schedules to be the same as what dominate the floor.
       dominant_floor_schedule = determine_dominant_schedule(space.model.getSpaces)
 
-      adjust_wildcard_spacetype_schedule(space, dominant_floor_schedule)
+      adjust_wildcard_spacetype_schedule(space: space,
+                                         schedule: dominant_floor_schedule,
+                                         lights_type: lights_type,
+                                         lights_scale: lights_scale)
 
       # Add a thermostat
       space_type_name = space.spaceType.get.name.get
@@ -464,7 +470,7 @@ class NECB2011
         schedule_type = determine_dominant_schedule(space.buildingStory.get.spaces)
         zone = other_adjacent_spaces.first.thermalZone.get
         wild_adjacent_spaces.each do |space|
-          adjust_wildcard_spacetype_schedule(space, schedule_type)
+          adjust_wildcard_spacetype_schedule(space, schedule_type, @lights_type, @lights_scale, @space_height)
           space.setThermalZone(zone)
         end
       end
@@ -483,7 +489,7 @@ class NECB2011
       dominant_floor_schedule = determine_dominant_schedule(space.buildingStory().get.spaces)
       #this method will determine if the right schedule was used for this wet & wild space if not.. it will reset the space
       # to use the correct schedule version of the wet and wild space type.
-      adjust_wildcard_spacetype_schedule(space, dominant_floor_schedule)
+      adjust_wildcard_spacetype_schedule(space, dominant_floor_schedule, @lights_type, @lights_scale, @space_height)
       #Find spacetype thermostat and assign it to the zone.
       thermostat_name = space.spaceType.get.name.get + ' Thermostat'
       thermostat = model.getThermostatSetpointDualSetpointByName(thermostat_name)
@@ -502,7 +508,7 @@ class NECB2011
         if space_target.thermalZone.empty?
           if are_space_loads_similar?(space_1: space, space_2: space_target) &&
               space.buildingStory().get == space_target.buildingStory().get # added since chris needs zones to not span floors for costing.
-            adjust_wildcard_spacetype_schedule(space_target, dominant_floor_schedule)
+            adjust_wildcard_spacetype_schedule(space_target, dominant_floor_schedule, @lights_type, @lights_scale, @space_height)
             space_target.setThermalZone(zone)
           end
         end
@@ -708,7 +714,7 @@ class NECB2011
   end
 
   # Set wildcard spactype schedule to NECB letter index.
-  def adjust_wildcard_spacetype_schedule(space, schedule)
+  def adjust_wildcard_spacetype_schedule(space:, schedule:, lights_type: 'NECB_Default', lights_scale: 1.0)
     if space.spaceType.empty?
       OpenStudio.logFree(OpenStudio::Error, 'Error: No spacetype assigned for #{space.name.get}. This must be assigned. Aborting.')
     end
@@ -733,7 +739,7 @@ class NECB2011
         new_spacetype.setStandardsBuildingType(space.spaceType.get.standardsBuildingType.get)
         new_spacetype.setStandardsSpaceType(new_spacetype_name)
         new_spacetype.setName("#{space.spaceType.get.standardsBuildingType.get} #{new_spacetype_name}")
-        space_type_apply_internal_loads(new_spacetype, true, true, true, true, true, true)
+        space_type_apply_internal_loads(space_type: new_spacetype, lights_type: lights_type, lights_scale: lights_scale)
         space_type_apply_internal_load_schedules(new_spacetype, true, true, true, true, true, true, true)
       end
       space.setSpaceType(new_spacetype)
@@ -881,7 +887,8 @@ class NECB2011
                                                                mau_type: mau_type,
                                                                mau_heating_coil_type: mau_heating_coil_type,
                                                                baseboard_type: baseboard_type,
-                                                               hw_loop: @hw_loop)
+                                                               hw_loop: @hw_loop,
+                                                               multispeed: false)
         end
       when 2
         group_similar_zones_together(zones).each do |zones|
@@ -894,11 +901,12 @@ class NECB2011
         end
       when 3
         group_similar_zones_together(zones).each do |zones|
-          add_sys3and8_single_zone_packaged_rooftop_unit_with_baseboard_heating_single_speed(model: model,
-                                                                                             zones: zones,
-                                                                                             heating_coil_type: heating_coil_type_sys3,
-                                                                                             baseboard_type: baseboard_type,
-                                                                                             hw_loop: @hw_loop)
+          add_sys3and8_single_zone_packaged_rooftop_unit_with_baseboard_heating(model: model,
+                                                                                zones: zones,
+                                                                                heating_coil_type: heating_coil_type_sys3,
+                                                                                baseboard_type: baseboard_type,
+                                                                                hw_loop: @hw_loop,
+                                                                                multispeed: false)
         end
       when 4
         group_similar_zones_together(zones).each do |zones|
@@ -907,6 +915,12 @@ class NECB2011
                                                                        heating_coil_type: heating_coil_type_sys4,
                                                                        baseboard_type: baseboard_type,
                                                                        hw_loop: @hw_loop)
+#          add_sys3and8_single_zone_packaged_rooftop_unit_with_baseboard_heating(model: model,
+#                                                                                zones: zones,
+#                                                                                heating_coil_type: heating_coil_type_sys4,
+#                                                                                baseboard_type: baseboard_type,
+#                                                                                hw_loop: @hw_loop,
+#                                                                                multispeed: false)
         end
       when 5
         group_similar_zones_together(zones).each do |zones|
@@ -1024,7 +1038,8 @@ class NECB2011
                                                 mau_type: mau_type,
                                                 mau_heating_coil_type: mau_heating_coil_type,
                                                 baseboard_type: baseboard_type,
-                                                hw_loop: @hw_loop)
+                                                hw_loop: @hw_loop,
+                                                multispeed: false)
         else
           #Create a separate air loop for each unit.
           zones.each do |zone|
@@ -1033,27 +1048,29 @@ class NECB2011
                                                   mau_type: mau_type,
                                                   mau_heating_coil_type: mau_heating_coil_type,
                                                   baseboard_type: baseboard_type,
-                                                  hw_loop: @hw_loop)
+                                                  hw_loop: @hw_loop,
+                                                  multispeed: false)
 
           end
         end
 
       when 3
         if dwelling_shared_ahu
-          add_sys3and8_single_zone_packaged_rooftop_unit_with_baseboard_heating_single_speed(model: model,
-                                                                                             zones: zones,
-                                                                                             heating_coil_type: heating_coil_type_sys3,
-                                                                                             baseboard_type: baseboard_type,
-                                                                                             hw_loop: @hw_loop)
+          add_sys3and8_single_zone_packaged_rooftop_unit_with_baseboard_heating(model: model,
+                                                                                zones: zones,
+                                                                                heating_coil_type: heating_coil_type_sys3,
+                                                                                baseboard_type: baseboard_type,
+                                                                                hw_loop: @hw_loop,
+                                                                                multispeed: false)
         else
           #Create a separate air loop for each unit.
           zones.each do |zone|
-            add_sys3and8_single_zone_packaged_rooftop_unit_with_baseboard_heating_single_speed(model: model,
-                                                                                               zones: [zone],
-                                                                                               heating_coil_type: heating_coil_type_sys3,
-                                                                                               baseboard_type: baseboard_type,
-                                                                                               hw_loop: @hw_loop)
-
+            add_sys3and8_single_zone_packaged_rooftop_unit_with_baseboard_heating(model: model,
+                                                                                  zones: [zone],
+                                                                                  heating_coil_type: heating_coil_type_sys3,
+                                                                                  baseboard_type: baseboard_type,
+                                                                                  hw_loop: @hw_loop,
+                                                                                  multispeed: false)
           end
         end
       end
@@ -1079,6 +1096,12 @@ class NECB2011
                                                                    heating_coil_type: heating_coil_type_sys4,
                                                                    baseboard_type: baseboard_type,
                                                                    hw_loop: @hw_loop)
+#      add_sys3and8_single_zone_packaged_rooftop_unit_with_baseboard_heating(model: model,
+#                                                                            zones: wet_tz,
+#                                                                            heating_coil_type: heating_coil_type_sys4,
+#                                                                            baseboard_type: baseboard_type,
+#                                                                            hw_loop: @hw_loop,
+#                                                                            multispeed: false)
     end
   end
 
@@ -1102,6 +1125,12 @@ class NECB2011
                                                                    heating_coil_type: heating_coil_type_sys4,
                                                                    baseboard_type: baseboard_type,
                                                                    hw_loop: @hw_loop)
+#      add_sys3and8_single_zone_packaged_rooftop_unit_with_baseboard_heating(model: model,
+#                                                                            zones: tz,
+#                                                                            heating_coil_type: heating_coil_type_sys4,
+#                                                                            baseboard_type: baseboard_type,
+#                                                                            hw_loop: @hw_loop,
+#                                                                            multispeed: true)
     end
   end
 
@@ -1125,6 +1154,12 @@ class NECB2011
                                                                    heating_coil_type: heating_coil_type_sys4,
                                                                    baseboard_type: baseboard_type,
                                                                    hw_loop: @hw_loop)
+#      add_sys3and8_single_zone_packaged_rooftop_unit_with_baseboard_heating(model: model,
+#                                                                            zones: zones,
+#                                                                            heating_coil_type: heating_coil_type_sys4,
+#                                                                            baseboard_type: baseboard_type,
+#                                                                            hw_loop: @hw_loop,
+#                                                                            multispeed: true)
     end
   end
 

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

@@ -14,13 +14,7 @@ class NECB2011
       space_type.setStandardsBuildingType(spacedata["building_type"])
       space_type.setName("#{spacedata['building_type']} #{spacedata['space_type']}")
       # Loads
-      self.space_type_apply_internal_loads(space_type,
-                                           true,
-                                           true,
-                                           true,
-                                           true,
-                                           true,
-                                           true)
+      self.space_type_apply_internal_loads(space_type: space_type)
 
       # Schedules
       self.space_type_apply_internal_load_schedules(space_type,
@@ -36,8 +30,6 @@ class NECB2011
   end
 
 
-
-
   # Sets the selected internal loads to standards-based or typical values.
   # For each category that is selected get all load instances. Remove all
   # but the first instance if multiple instances.  Add a new instance/definition
@@ -55,13 +47,23 @@ class NECB2011
   # @param set_ventilation [Bool] if true, set the ventilation rates (per-person and per-area)
   # @param set_infiltration [Bool] if true, set the infiltration rates
   # @return [Bool] returns true if successful, false if not
-  def space_type_apply_internal_loads(space_type, set_people, set_lights, set_electric_equipment, set_gas_equipment, set_ventilation, set_infiltration)
+  def space_type_apply_internal_loads(space_type:,
+                                      set_people: true,
+                                      set_lights: true,
+                                      set_electric_equipment: true,
+                                      set_gas_equipment: true,
+                                      set_ventilation: true,
+                                      set_infiltration: true,
+                                      lights_type: 'NECB_Default',
+                                      lights_scale: 1.0)
+
     # Skip plenums
     # Check if the space type name
     # contains the word plenum.
     if space_type.name.get.to_s.downcase.include?('plenum')
       return false
     end
+
     if space_type.standardsSpaceType.is_initialized
       if space_type.standardsSpaceType.get.downcase.include?('plenum')
         return false
@@ -163,7 +165,11 @@ class NECB2011
     end
 
     # Lights
-    apply_standard_lights(set_lights, space_type, space_type_properties)
+    apply_standard_lights(set_lights: set_lights,
+                          space_type: space_type,
+                          space_type_properties: space_type_properties,
+                          lights_type: lights_type,
+                          lights_scale: lights_scale)
 
     # Electric Equipment
     elec_equip_have_info = false
@@ -266,6 +272,7 @@ class NECB2011
     ventilation_per_area = space_type_properties['ventilation_per_area'].to_f
     ventilation_per_person = space_type_properties['ventilation_per_person'].to_f
     ventilation_ach = space_type_properties['ventilation_air_changes'].to_f
+    ventilation_occupancy_per_area = space_type_properties['ventilation_occupancy_rate_people_per_1000ft2'].to_f
     ventilation_have_info = true unless ventilation_per_area.zero?
     ventilation_have_info = true unless ventilation_per_person.zero?
     ventilation_have_info = true unless ventilation_ach.zero?
@@ -290,8 +297,12 @@ class NECB2011
         OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "#{space_type.name} set ventilation per area to #{ventilation_per_area} cfm/ft^2.")
       end
       unless ventilation_per_person.zero?
-        ventilation.setOutdoorAirFlowperPerson(OpenStudio.convert(ventilation_per_person.to_f, 'ft^3/min*person', 'm^3/s*person').get)
-        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "#{space_type.name} set ventilation per person to #{ventilation_per_person} cfm/person.")
+        # For BTAP we often use an occupancy per area rate for ventilation which is different from the one used for
+        # everything else.  The mod_ventilation_per_person rate adjusts the per person ventilation rate so that the
+        # proper ventilation rate is calculated when using the general occupant per area rate.
+        mod_ventilation_per_person = ventilation_per_person*ventilation_occupancy_per_area/occupancy_per_area
+        ventilation.setOutdoorAirFlowperPerson(OpenStudio.convert(mod_ventilation_per_person.to_f, 'ft^3/min*person', 'm^3/s*person').get)
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "#{space_type.name} set ventilation per person to #{mod_ventilation_per_person} cfm/person.")
       end
       unless ventilation_ach.zero?
         ventilation.setOutdoorAirFlowAirChangesperHour(ventilation_ach)

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

@@ -1,4 +1,5 @@
 class NECB2011
+
   # Reduces the WWR to the values specified by the NECB
   # NECB 3.2.1.4
   def apply_standard_window_to_wall_ratio(model:, fdwr_set: -1.0)
@@ -141,7 +142,6 @@ class NECB2011
     red_res = wwr_res > wwr_lim
     red_sh = wwr_sh > wwr_lim
 
-
     # puts "Current FDWR is #{fdwr}, must be less than #{fdwr_lim}."
     # puts "Current subsurf area is #{total_subsurface_m2} and gross surface area is #{total_wall_m2}"
     # Stop here unless windows / doors need reducing
@@ -271,7 +271,6 @@ class NECB2011
     srr = ((total_subsurface_m2 / total_roof_m2) * 100.0).round(1)
     OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Model', "The skylight to roof ratios (SRRs) are: NonRes: #{srr_nr.round}%, Res: #{srr_res.round}%.")
 
-
     # Check against SRR limit
     red_nr = srr_nr > srr_lim
     red_res = srr_res > srr_lim
@@ -307,8 +306,8 @@ class NECB2011
   # @param hdd [Float]
   # @return [Double] a constant float
   def max_fwdr(hdd)
-    #get formula from json database.
-    return eval(self.get_standards_formula('fdwr_formula'))
+    #  get formula from json database.
+    return eval(get_standards_formula('fdwr_formula'))
   end
 
   # Go through the default construction sets and hard-assigned
@@ -322,93 +321,104 @@ class NECB2011
 
   def apply_standard_construction_properties(model:,
                                              runner: nil,
-                                             properties: {
-                                                 'outdoors_wall_conductance' => nil,
-                                                 'outdoors_floor_conductance' => nil,
-                                                 'outdoors_roofceiling_conductance' => nil,
-                                                 'ground_wall_conductance' => nil,
-                                                 'ground_floor_conductance' => nil,
-                                                 'ground_roofceiling_conductance' => nil,
-                                                 'outdoors_door_conductance' => nil,
-                                                 'outdoors_fixedwindow_conductance' => nil
-                                             })
-
-    model.getDefaultConstructionSets.sort.each do |set|
-      set_construction_set_to_necb!(model: model,
-                                    default_surface_construction_set: set,
-                                    runner: nil,
-                                    properties: properties)
+                                             # ext surfaces
+                                             ext_wall_cond: nil,
+                                             ext_floor_cond: nil,
+                                             ext_roof_cond: nil,
+                                             # ground surfaces
+                                             ground_wall_cond: nil,
+                                             ground_floor_cond: nil,
+                                             ground_roof_cond: nil,
+                                             # fixed Windows
+                                             fixed_window_cond: nil,
+                                             fixed_wind_solar_trans: nil,
+                                             fixed_wind_vis_trans: nil,
+                                             # operable windows
+                                             operable_wind_solar_trans: nil,
+                                             operable_window_cond: nil,
+                                             operable_wind_vis_trans: nil,
+                                             # glass doors
+                                             glass_door_cond: nil,
+                                             glass_door_solar_trans: nil,
+                                             glass_door_vis_trans: nil,
+                                             # opaque doors
+                                             door_construction_cond: nil,
+                                             overhead_door_cond: nil,
+                                             # skylights
+                                             skylight_cond: nil,
+                                             skylight_solar_trans: nil,
+                                             skylight_vis_trans: nil,
+                                             # tubular daylight dome
+                                             tubular_daylight_dome_cond: nil,
+                                             tubular_daylight_dome_solar_trans: nil,
+                                             tubular_daylight_dome_vis_trans: nil,
+                                             # tubular daylight diffuser
+                                             tubular_daylight_diffuser_cond: nil,
+                                             tubular_daylight_diffuser_solar_trans: nil,
+                                             tubular_daylight_diffuser_vis_trans: nil)
+
+    model.getDefaultConstructionSets.sort.each do |default_surface_construction_set|
+      BTAP.runner_register('Info', 'apply_standard_construction_properties', runner)
+      if model.weatherFile.empty? || model.weatherFile.get.path.empty? || !File.exist?(model.weatherFile.get.path.get.to_s)
+
+        BTAP.runner_register('Error', 'Weather file is not defined. Please ensure the weather file is defined and exists.', runner)
+        return false
+      end
+
+      # Lambdas are preferred over methods in methods for small utility methods.
+      correct_cond = lambda do |conductivity, surface_type|
+        # hdd required in scope for eval function.
+        hdd = get_necb_hdd18(model)
+        return conductivity.nil? || conductvity == 0.0 ? eval(model_find_objects(@standards_data['surface_thermal_transmittance'], surface_type)[0]['formula']) : conductivity
+      end
+
+      BTAP::Resources::Envelope::ConstructionSets.customize_default_surface_construction_set!(model: model,
+                                                                                              name: "#{default_surface_construction_set.name.get} at hdd = #{get_necb_hdd18(model)}",
+                                                                                              default_surface_construction_set: default_surface_construction_set,
+                                                                                              # ext surfaces
+                                                                                              ext_wall_cond: correct_cond.call(ext_wall_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'Wall'}),
+                                                                                              ext_floor_cond: correct_cond.call(ext_floor_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'Floor'}),
+                                                                                              ext_roof_cond: correct_cond.call(ext_roof_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'RoofCeiling'}),
+                                                                                              # ground surfaces
+                                                                                              ground_wall_cond: correct_cond.call(ground_wall_cond, {'boundary_condition' => 'Ground', 'surface' => 'Wall'}),
+                                                                                              ground_floor_cond: correct_cond.call(ground_floor_cond, {'boundary_condition' => 'Ground', 'surface' => 'Floor'}),
+                                                                                              ground_roof_cond: correct_cond.call(ground_roof_cond, {'boundary_condition' => 'Ground', 'surface' => 'RoofCeiling'}),
+                                                                                              # fixed Windows
+                                                                                              fixed_window_cond: correct_cond.call(fixed_window_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'Window'}),
+                                                                                              fixed_wind_solar_trans: fixed_wind_solar_trans,
+                                                                                              fixed_wind_vis_trans: fixed_wind_vis_trans,
+                                                                                              # operable windows
+                                                                                              operable_wind_solar_trans: operable_wind_solar_trans,
+                                                                                              operable_window_cond: correct_cond.call(fixed_window_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'Window'}),
+                                                                                              operable_wind_vis_trans: operable_wind_vis_trans,
+                                                                                              # glass doors
+                                                                                              glass_door_cond: correct_cond.call(glass_door_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'Window'}),
+                                                                                              glass_door_solar_trans: glass_door_solar_trans,
+                                                                                              glass_door_vis_trans: glass_door_vis_trans,
+                                                                                              # opaque doors
+                                                                                              door_construction_cond: correct_cond.call(door_construction_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'Door'}),
+                                                                                              overhead_door_cond: correct_cond.call(overhead_door_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'Door'}),
+                                                                                              # skylights
+                                                                                              skylight_cond: correct_cond.call(skylight_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'Window'}),
+                                                                                              skylight_solar_trans: skylight_solar_trans,
+                                                                                              skylight_vis_trans: skylight_vis_trans,
+                                                                                              # tubular daylight dome
+                                                                                              tubular_daylight_dome_cond: correct_cond.call(skylight_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'Window'}),
+                                                                                              tubular_daylight_dome_solar_trans: tubular_daylight_dome_solar_trans,
+                                                                                              tubular_daylight_dome_vis_trans: tubular_daylight_dome_vis_trans,
+                                                                                              # tubular daylight diffuser
+                                                                                              tubular_daylight_diffuser_cond: correct_cond.call(skylight_cond, {'boundary_condition' => 'Outdoors', 'surface' => 'Window'}),
+                                                                                              tubular_daylight_diffuser_solar_trans: tubular_daylight_diffuser_solar_trans,
+                                                                                              tubular_daylight_diffuser_vis_trans: tubular_daylight_diffuser_vis_trans)
+
+
     end
     # sets all surfaces to use default constructions sets except adiabatic, where it does a hard assignment of the interior wall construction type.
     model.getPlanarSurfaces.sort.each(&:resetConstruction)
     # if the default construction set is defined..try to assign the interior wall to the adiabatic surfaces
     BTAP::Resources::Envelope.assign_interior_surface_construction_to_adiabatic_surfaces(model, nil)
-  end
+    BTAP.runner_register('Info', ' apply_standard_construction_properties was sucessful.', runner)
 
-  # this will create a copy and convert all construction sets to NECB reference conductances.
-  # @author phylroy.lopez@nrcan.gc.ca
-  # @param model [OpenStudio::model::Model] A model object
-  # @param default_surface_construction_set [String]
-  # @return [Boolean] returns true if sucessful, false if not
-  def set_construction_set_to_necb!(model:,
-                                    default_surface_construction_set:,
-                                    runner: nil,
-                                    properties: {
-                                        'outdoors_wall_conductance' => nil,
-                                        'outdoors_floor_conductance' => nil,
-                                        'outdoors_roofceiling_conductance' => nil,
-                                        'ground_wall_conductance' => nil,
-                                        'ground_floor_conductance' => nil,
-                                        'ground_roofceiling_conductance' => nil,
-                                        'outdoors_door_conductance' => nil,
-                                        'outdoors_fixedwindow_conductance' => nil
-                                    })
-    BTAP.runner_register('Info', 'set_construction_set_to_necb!', runner)
-    if model.weatherFile.empty? || model.weatherFile.get.path.empty? || !File.exist?(model.weatherFile.get.path.get.to_s)
-
-      BTAP.runner_register('Error', 'Weather file is not defined. Please ensure the weather file is defined and exists.', runner)
-      return false
-    end
-
-    #Note:hdd needs to be defined for eval to work on table eval below.
-    hdd = self.get_necb_hdd18(model)
-
-    old_name = default_surface_construction_set.name.get.to_s
-    new_name = "#{old_name} at hdd = #{hdd}"
-    # Get appropriate standards table
-    standards_table = @standards_data['surface_thermal_transmittance']
-
-    surface_types = [
-        {'boundary_condition' => 'Outdoors', 'surface' => 'Wall', 'conductance' => properties['outdoors_wall_conductance']},
-        {'boundary_condition' => 'Outdoors', 'surface' => 'Floor', 'conductance' => properties['outdoors_floor_conductance']},
-        {'boundary_condition' => 'Outdoors', 'surface' => 'RoofCeiling', 'conductance' => properties['outdoors_roofceiling_conductance']},
-        {'boundary_condition' => 'Ground', 'surface' => 'Wall', 'conductance' => properties['ground_wall_conductance']},
-        {'boundary_condition' => 'Ground', 'surface' => 'Floor', 'conductance' => properties['ground_floor_conductance']},
-        {'boundary_condition' => 'Ground', 'surface' => 'RoofCeiling', 'conductance' => properties['ground_roofceiling_conductance']},
-        {'boundary_condition' => 'Outdoors', 'surface' => 'Window', 'conductance' => properties['outdoors_fixedwindow_conductance']},
-        {'boundary_condition' => 'Outdoors', 'surface' => 'Door', 'conductance' => properties['outdoors_door_conductance']}
-    ]
-
-    surface_types_rsi = {}
-    surface_types.each do |surface_type|
-      surface_types_rsi["#{surface_type['boundary_condition'].downcase}_#{surface_type['surface'].downcase}_conductance"] = surface_type['conductance'].nil? ? 1.0 / (eval(self.model_find_objects(standards_table, surface_type)[0]['formula'])) : (1.0 / surface_type['conductance'])
-    end
-    puts surface_types_rsi
-
-    # convert conductance values to rsi values. (Note: we should really be only using conductances in)
-    BTAP::Resources::Envelope::ConstructionSets.customize_default_surface_construction_set_rsi!(model, new_name, default_surface_construction_set,
-                                                                                                surface_types_rsi['outdoors_wall_conductance'], surface_types_rsi['outdoors_floor_conductance'], surface_types_rsi['outdoors_roofceiling_conductance'],
-                                                                                                surface_types_rsi['ground_wall_conductance'], surface_types_rsi['ground_floor_conductance'], surface_types_rsi['ground_roofceiling_conductance'],
-                                                                                                surface_types_rsi['outdoors_window_conductance'], nil, nil,
-                                                                                                surface_types_rsi['outdoors_window_conductance'], nil, nil,
-                                                                                                surface_types_rsi['outdoors_door_conductance'],
-                                                                                                surface_types_rsi['outdoors_door_conductance'], nil, nil,
-                                                                                                surface_types_rsi['outdoors_door_conductance'],
-                                                                                                surface_types_rsi['outdoors_window_conductance'], nil, nil,
-                                                                                                surface_types_rsi['outdoors_window_conductance'], nil, nil,
-                                                                                                surface_types_rsi['outdoors_window_conductance'], nil, nil)
-    BTAP.runner_register('Info', 'set_construction_set_to_necb! was sucessful.', runner)
-    return true
   end
 
   # Set all external surface conductances to NECB values.
@@ -425,11 +435,11 @@ class NECB2011
 
       case surface.surfaceType.downcase
       when 'wall'
-        conductance_value = @standards_data['conductances']['Wall'].find {|i| i['hdd'] > hdd}['thermal_transmittance'] * scaling_factor
+        conductance_value = @standards_data['conductances']['Wall'].find { |i| i['hdd'] > hdd }['thermal_transmittance'] * scaling_factor
       when 'floor'
-        conductance_value = @standards_data['conductances']['Floor'].find {|i| i['hdd'] > hdd}['thermal_transmittance'] * scaling_factor
+        conductance_value = @standards_data['conductances']['Floor'].find { |i| i['hdd'] > hdd }['thermal_transmittance'] * scaling_factor
       when 'roofceiling'
-        conductance_value = @standards_data['conductances']['Roof'].find {|i| i['hdd'] > hdd}['thermal_transmittance'] * scaling_factor
+        conductance_value = @standards_data['conductances']['Roof'].find { |i| i['hdd'] > hdd }['thermal_transmittance'] * scaling_factor
       end
       if is_radiant
         conductance_value *= 0.80
@@ -440,11 +450,11 @@ class NECB2011
     if surface.outsideBoundaryCondition.downcase =~ /ground/
       case surface.surfaceType.downcase
       when 'wall'
-        conductance_value = @standards_data['conductances']['GroundWall'].find {|i| i['hdd'] > hdd}['thermal_transmittance'] * scaling_factor
+        conductance_value = @standards_data['conductances']['GroundWall'].find { |i| i['hdd'] > hdd }['thermal_transmittance'] * scaling_factor
       when 'floor'
-        conductance_value = @standards_data['conductances']['GroundFloor'].find {|i| i['hdd'] > hdd}['thermal_transmittance'] * scaling_factor
+        conductance_value = @standards_data['conductances']['GroundFloor'].find { |i| i['hdd'] > hdd }['thermal_transmittance'] * scaling_factor
       when 'roofceiling'
-        conductance_value = @standards_data['conductances']['GroundRoof'].find {|i| i['hdd'] > hdd}['thermal_transmittance'] * scaling_factor
+        conductance_value = @standards_data['conductances']['GroundRoof'].find { |i| i['hdd'] > hdd }['thermal_transmittance'] * scaling_factor
       end
       if is_radiant
         conductance_value *= 0.80
@@ -463,15 +473,14 @@ class NECB2011
     if subsurface.outsideBoundaryCondition.downcase.match('outdoors')
       case subsurface.subSurfaceType.downcase
       when /window/
-        conductance_value = @standards_data['conductances']['Window'].find {|i| i['hdd'] > hdd}['thermal_transmittance'] * scaling_factor
+        conductance_value = @standards_data['conductances']['Window'].find { |i| i['hdd'] > hdd }['thermal_transmittance'] * scaling_factor
       when /door/
-        conductance_value = @standards_data['conductances']['Door'].find {|i| i['hdd'] > hdd}['thermal_transmittance'] * scaling_factor
+        conductance_value = @standards_data['conductances']['Door'].find { |i| i['hdd'] > hdd }['thermal_transmittance'] * scaling_factor
       end
       subsurface.setRSI(1 / conductance_value)
     end
   end
 
-
   # Adds code-minimum constructions based on the building type
   # as defined in the OpenStudio_Standards_construction_sets.json file.
   # Where there is a separate construction set specified for the
@@ -491,7 +500,7 @@ class NECB2011
     # building types.
     apply_building_default_constructionset(model)
     # Make a construction set for each space type, if one is specified
-    #apply_default_constructionsets_to_spacetypes(climate_zone, model)
+    # apply_default_constructionsets_to_spacetypes(climate_zone, model)
     OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.Model', 'Finished applying constructions')
     return true
   end
@@ -536,7 +545,6 @@ class NECB2011
     end
   end
 
-
   def model_add_construction_set_from_osm(model:,
                                           construction_set_name: 'BTAP-Mass',
                                           osm_path: File.absolute_path(File.join(__FILE__, '..', '..', 'common/construction_defaults.osm')))
@@ -552,7 +560,6 @@ class NECB2011
     return new_construction_set
   end
 
-
   def assign_contruction_to_adiabatic_surfaces(model)
     cp02_carpet_pad = OpenStudio::Model::MasslessOpaqueMaterial.new(model)
     cp02_carpet_pad.setName('CP02 CARPET PAD')
@@ -678,7 +685,6 @@ class NECB2011
     construct_set = model.getBuilding.defaultConstructionSet.get
     fixed_window_construct_set = construct_set.defaultExteriorSubSurfaceConstructions.get.fixedWindowConstruction.get
 
-
     # IF FDWR is greater than 1 then something is wrong raise an error.  If it is less than 0.001 assume all the windows
     # should go.
     if fdwr_lim > 1
@@ -738,7 +744,6 @@ class NECB2011
       return false
     end
 
-
     # If the SRR is greater than one something is seriously wrong so raise an error.  If it is less than 0.001 assume
     # all the skylights should go.
     if srr_lim > 1