openstudio-standards 0.2.12.rc4 → 0.2.12.rc5

data/lib/openstudio-standards/standards/necb/NECB2011/led_lighting.md

@@ -0,0 +1,51 @@
+# High Performance LED Lighting Measure
+This measure adds a new lighting definition regarding LED lighting in each space of the model, 
+and replace the existing lighting definition with the LED lighting definition in each space.
+
+# Description
+The workflow of this measure is as follows:
+1. Define a new LED lighting definition for each space.
+2. Use the new LED lighting definition instead of the existing lighting definition in each space.
+
+# Approach
+This measure follows the functions already existed in the BTAP environment with respect to setting lights in spaces.<br>
+However, a new function called **set_lighting_per_area_led_lighting** has been created in necb_2011.rb to set lighting power density (LPD) for LED lighting.<br>
+Moreover, the **apply_standard_lights** function (in lighting.rb) has been modified to set the three fields of 
+fraction radiant, fraction visible, and return air fraction for LED lighting.<br> 
+Furthermore, two variables have been added to the **apply_standard_lights** function:
+(1) **lights_type** to specify which lighting type to be used in the model. The lighting types that a user can choose are: CFL, LED.
+(2) **scale** to specify whether LPD default values are used or a fraction of LPD default values are used in the model.
+
+# Testing Plan
+* This measure has been called in the **apply_loads** function (in necb_2011.rb) -> **model_add_loads** function (in necb_2011.rb) 
+-> **space_type_apply_internal_loads** function (in beps_compliance_path.rb) -> **apply_standard_lights** function (in lighting.rb).
+* This measure was tested for NECB 2011 full service restaurant archetype.
+* Note that regarding atriums' heights, since none of the archetypes has atriums, 
+the testing procedure was performed for the space type including the "Dining" term and with some tweaks in the LPD equations.
+
+# Waiting On
+* There are four fields in the OS:Lights:Definition object that need to be updated in standards/lib/openstudio-standards/standards/necb/NECB2011/**data/led_lighting_data.json**, as follows:
+  1. LPD (W/m<sup>2</sup>)
+  2. Fraction Radiant
+  3. Fraction Visible
+  4. Return Air Fraction
+
+* Note that three xlsx files (**led_lighting_data_necb2011.xlsx**, **led_lighting_data_necb2015.xlsx**, **led_lighting_data_necb2017.xlsx**) 
+should be updated as per Mike Lubun's xlsx files for lighting sets.
+* To this end, openstudio-standards/lib/openstudio-standards/utilities/**LEDLightingData_xlsx_to_json.rb** can be used to convert the xlsx files to json format.
+* Once the openstudio-standards/lib/openstudio-standards/**btap/led_lighting_data.json** file is generated using LEDLightingData_xlsx_to_json.rb, 
+openstudio-standards/lib/openstudio-standards/standards/necb/NECB2011/**data/led_lighting_data.json** should be updated manually (copy and paste from **btap/led_lighting_data.json**). 
+ 
+# Files Added/Modified
+* Files have been modified: 
+  * **necb_2011.rb**
+  * **beps_compliance_path.rb**
+  * **lighting.rb**
+* Files have been added: 
+  * **led_lighting.md**
+  * openstudio-standards/lib/openstudio-standards/utilities/**LEDLightingData_xlsx_to_json.rb**
+  * openstudio-standards/lib/openstudio-standards/btap/**led_lighting_data_necb2011.xlsx**
+  * openstudio-standards/lib/openstudio-standards/btap/**led_lighting_data_necb2015.xlsx**
+  * openstudio-standards/lib/openstudio-standards/btap/**led_lighting_data_necb2017.xlsx**
+  * openstudio-standards/lib/openstudio-standards/**btap/led_lighting_data.json**
+  * openstudio-standards/lib/openstudio-standards/standards/necb/NECB2011/**data/led_lighting_data.json**

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

@@ -1,5 +1,10 @@
 class NECB2011
-  def apply_standard_lights(set_lights, space_type, space_type_properties)
+
+  def apply_standard_lights(set_lights: true,
+                            space_type:, space_type_properties:,
+                            lights_type: 'NECB_Default',
+                            lights_scale: 1.0)
+
     lights_have_info = false
     lighting_per_area = space_type_properties['lighting_per_area'].to_f
     lighting_per_person = space_type_properties['lighting_per_person'].to_f
@@ -7,8 +12,27 @@ class NECB2011
     lights_frac_radiant = space_type_properties['lighting_fraction_radiant'].to_f
     lights_frac_visible = space_type_properties['lighting_fraction_visible'].to_f
     lights_frac_replaceable = space_type_properties['lighting_fraction_replaceable'].to_f
-    lights_have_info = true unless lighting_per_area.zero?
-    lights_have_info = true unless lighting_per_person.zero?
+    lights_have_info = true if !lighting_per_area.zero? or !lighting_per_person.zero?
+
+
+    ##### NOTE: Reference for LED lighting's return air, radiant, and visible fraction values is: page 142, NREL (2014), "Proven Energy-Saving Technologies for Commercial Properties", available at https://www.nrel.gov/docs/fy15osti/63807.pdf
+    if lights_type == 'LED'
+      led_lights_have_info = false
+      led_spacetype_data = @standards_data['tables']['led_lighting_data']['table']
+      standards_building_type = space_type.standardsBuildingType.is_initialized ? space_type.standardsBuildingType.get : nil
+      standards_space_type = space_type.standardsSpaceType.is_initialized ? space_type.standardsSpaceType.get : nil
+      led_space_type_properties = led_spacetype_data.detect { |s| (s['building_type'] == standards_building_type) && (s['space_type'] == standards_space_type) }
+      if led_space_type_properties.nil?
+        raise("#{standards_building_type} for #{standards_space_type} was not found please verify the led lighting database names match the space type names.")
+      end
+
+      lighting_per_area_led_lighting = led_space_type_properties['lighting_per_area'].to_f
+      lights_frac_to_return_air_led_lighting = led_space_type_properties['lighting_fraction_to_return_air'].to_f
+      lights_frac_radiant_led_lighting = led_space_type_properties['lighting_fraction_radiant'].to_f
+      lights_frac_visible_led_lighting = led_space_type_properties['lighting_fraction_visible'].to_f
+      led_lights_have_info = true unless lighting_per_area_led_lighting.zero?
+
+    end
 
     if set_lights && lights_have_info
 
@@ -16,9 +40,15 @@ class NECB2011
       instances = space_type.lights.sort
       if instances.size.zero?
         definition = OpenStudio::Model::LightsDefinition.new(space_type.model)
-        definition.setName("#{space_type.name} Lights Definition")
+        if lights_type == 'NECB_Default'
+          definition.setName("#{space_type.name} Lights Definition")
+        elsif lights_type == 'LED'
+          definition.setName("#{space_type.name} Lights Definition - LED lighting")
+        end
+        # puts definition.name().to_s
         instance = OpenStudio::Model::Lights.new(definition)
         instance.setName("#{space_type.name} Lights")
+        # puts instance.name.to_s
         instance.setSpaceType(space_type)
         OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "#{space_type.name} had no lights, one has been created.")
         instances << instance
@@ -34,20 +64,39 @@ class NECB2011
       space_type.lights.sort.each do |inst|
         definition = inst.lightsDefinition
         unless lighting_per_area.zero?
-          set_lighting_per_area(space_type, definition, lighting_per_area)
+          if lights_type == 'NECB_Default'
+            set_lighting_per_area(space_type, definition, lighting_per_area)
+          elsif lights_type == 'LED'
+            set_lighting_per_area_led_lighting(space_type: space_type,
+                                               definition: definition,
+                                               lighting_per_area_led_lighting: lighting_per_area_led_lighting,
+                                               lights_scale: lights_scale)
+          end
         end
         unless lighting_per_person.zero?
           definition.setWattsperPerson(OpenStudio.convert(lighting_per_person.to_f, 'W/person', 'W/person').get)
           OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "#{space_type.name} set lighting to #{lighting_per_person} W/person.")
         end
         unless lights_frac_to_return_air.zero?
-          definition.setReturnAirFraction(lights_frac_to_return_air)
+          if lights_type == 'NECB_Default'
+            definition.setReturnAirFraction(lights_frac_to_return_air)
+          elsif lights_type == 'LED'
+            definition.setReturnAirFraction(lights_frac_to_return_air_led_lighting)
+          end
         end
         unless lights_frac_radiant.zero?
-          definition.setFractionRadiant(lights_frac_radiant)
+          if lights_type == 'NECB_Default'
+            definition.setFractionRadiant(lights_frac_radiant)
+          elsif lights_type == 'LED'
+            definition.setFractionRadiant(lights_frac_radiant_led_lighting)
+          end
         end
         unless lights_frac_visible.zero?
-          definition.setFractionVisible(lights_frac_visible)
+          if lights_type == 'NECB_Default'
+            definition.setFractionVisible(lights_frac_visible)
+          elsif lights_type == 'LED'
+            definition.setFractionVisible(lights_frac_visible_led_lighting)
+          end
         end
         # unless lights_frac_replaceable.zero?
         #  definition.setFractionReplaceable(lights_frac_replaceable)
@@ -70,7 +119,6 @@ class NECB2011
         additional_lights.setName("#{space_type.name} Additional Lights")
         additional_lights.setSpaceType(space_type)
       end
-
     end
   end
 

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

@@ -40,7 +40,7 @@ class NECB2011 < Standard
     else
       path = "#{File.dirname(__FILE__)}/../common/"
       raise ('Could not find common folder') unless Dir.exist?(path)
-      files = Dir.glob("#{path}/*.json").select {|e| File.file? e}
+      files = Dir.glob("#{path}/*.json").select { |e| File.file? e }
       files.each do |file|
         data = JSON.parse(File.read(file))
         if not data["tables"].nil?
@@ -62,7 +62,7 @@ class NECB2011 < Standard
         end
       end
     else
-      files = Dir.glob("#{File.dirname(__FILE__)}/data/*.json").select {|e| File.file? e}
+      files = Dir.glob("#{File.dirname(__FILE__)}/data/*.json").select { |e| File.file? e }
       files.each do |file|
         data = JSON.parse(File.read(file))
         if not data["tables"].nil?
@@ -117,7 +117,7 @@ class NECB2011 < Standard
   end
 
   def get_all_spacetype_names
-    return @standards_data['space_types'].map {|space_types| [space_types['building_type'], space_types['space_type']]}
+    return @standards_data['space_types'].map { |space_types| [space_types['building_type'], space_types['space_type']] }
   end
 
   # Enter in [latitude, longitude] for each loc and this method will return the distance.
@@ -129,8 +129,8 @@ class NECB2011 < Standard
     dlat_rad = (loc2[0] - loc1[0]) * rad_per_deg # Delta, converted to rad
     dlon_rad = (loc2[1] - loc1[1]) * rad_per_deg
 
-    lat1_rad, lon1_rad = loc1.map {|i| i * rad_per_deg}
-    lat2_rad, lon2_rad = loc2.map {|i| i * rad_per_deg}
+    lat1_rad, lon1_rad = loc1.map { |i| i * rad_per_deg }
+    lat2_rad, lon2_rad = loc2.map { |i| i * rad_per_deg }
 
     a = Math.sin(dlat_rad / 2) ** 2 + Math.cos(lat1_rad) * Math.cos(lat2_rad) * Math.sin(dlon_rad / 2) ** 2
     c = 2 * Math::atan2(Math::sqrt(a), Math::sqrt(1 - a))
@@ -169,13 +169,67 @@ class NECB2011 < Standard
                                    epw_file:,
                                    debug: false,
                                    sizing_run_dir: Dir.pwd,
-                                   primary_heating_fuel: 'DefaultFuel')
+                                   primary_heating_fuel: 'DefaultFuel',
+                                   dcv_type: 'NECB_Default',
+                                   lights_type: 'NECB_Default',
+                                   lights_scale: 1.0,
+                                   daylighting_type: 'NECB_Default',
+                                   ecm_system_name: 'NECB_Default',
+                                   erv_package: 'NECB_Default',
+                                   boiler_eff: nil,
+                                   furnace_eff: nil,
+                                   shw_eff: nil,
+                                   ext_wall_cond: nil,
+                                   ext_floor_cond: nil,
+                                   ext_roof_cond: nil,
+                                   ground_wall_cond: nil,
+                                   ground_floor_cond: nil,
+                                   ground_roof_cond: nil,
+                                   door_construction_cond: nil,
+                                   fixed_window_cond: nil,
+                                   glass_door_cond: nil,
+                                   overhead_door_cond: nil,
+                                   skylight_cond: nil,
+                                   glass_door_solar_trans: nil,
+                                   fixed_wind_solar_trans: nil,
+                                   skylight_solar_trans: nil,
+                                   fdwr_set: -1.0,
+                                   srr_set: -1.0
+
+  )
 
     model = load_building_type_from_library(building_type: building_type)
     return model_apply_standard(model: model,
                                 epw_file: epw_file,
                                 sizing_run_dir: sizing_run_dir,
-                                primary_heating_fuel: primary_heating_fuel)
+                                primary_heating_fuel: primary_heating_fuel,
+                                dcv_type: dcv_type, # Four options: (1) 'NECB_Default', (2) 'No_DCV', (3) 'Occupancy_based_DCV' , (4) 'CO2_based_DCV'
+                                lights_type: lights_type, # Two options: (1) 'NECB_Default', (2) 'LED'
+                                lights_scale: lights_scale,
+                                daylighting_type: daylighting_type, # Two options: (1) 'NECB_Default', (2) 'add_daylighting_controls'
+                                ecm_system_name: ecm_system_name,
+                                erv_package: erv_package,
+                                boiler_eff: boiler_eff,
+                                furnace_eff: furnace_eff,
+                                shw_eff: shw_eff,
+                                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,
+                                fdwr_set: fdwr_set,
+                                srr_set: srr_set
+
+    )
   end
 
   def load_building_type_from_library(building_type:)
@@ -191,25 +245,146 @@ class NECB2011 < Standard
   def model_apply_standard(model:,
                            epw_file:,
                            sizing_run_dir: Dir.pwd,
-                           primary_heating_fuel: 'DefaultFuel')
+                           primary_heating_fuel: 'DefaultFuel',
+                           dcv_type: 'NECB_Default',
+                           lights_type: 'NECB_Default',
+                           lights_scale: 1.0,
+                           daylighting_type: 'NECB_Default',
+                           ecm_system_name: 'NECB_Default',
+                           erv_package: 'NECB_Default',
+                           boiler_eff: nil,
+                           furnace_eff: nil,
+                           shw_eff: nil,
+                           ext_wall_cond: nil,
+                           ext_floor_cond: nil,
+                           ext_roof_cond: nil,
+                           ground_wall_cond: nil,
+                           ground_floor_cond: nil,
+                           ground_roof_cond: nil,
+                           door_construction_cond: nil,
+                           fixed_window_cond: nil,
+                           glass_door_cond: nil,
+                           overhead_door_cond: nil,
+                           skylight_cond: nil,
+                           glass_door_solar_trans: nil,
+                           fixed_wind_solar_trans: nil,
+                           skylight_solar_trans: nil,
+                           fdwr_set: -1,
+                           srr_set: -1,
+                           rotation_degrees: nil,
+                           scale_x: nil,
+                           scale_y: nil,
+                           scale_z: nil
+  )
+
+    BTAP::Geometry::rotate_building(model: model,degrees: rotation_degrees) unless rotation_degrees.nil?
+    unless scale_x.nil? && scale_y.nil? && scale_z.nil?
+      scale_x = 1 if scale_x.nil?
+      scale_y = 1 if scale_y.nil?
+      scale_z = 1 if scale_y.nil?
+      BTAP::Geometry::scale_model(model, scale_x, scale_y, scale_z)
+    end
+
     apply_weather_data(model: model, epw_file: epw_file)
-    apply_loads(model: model)
-    apply_envelope(model: model)
-    apply_fdwr_srr_daylighting(model: model)
-    apply_auto_zoning(model: model, sizing_run_dir: sizing_run_dir)
+    apply_loads(model: model, lights_type: lights_type, lights_scale: lights_scale)
+    apply_envelope(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)
+    apply_fdwr_srr_daylighting(model: model,
+                               fdwr_set: fdwr_set,
+                               srr_set: srr_set)
+    apply_auto_zoning(model: model,
+                      sizing_run_dir: sizing_run_dir,
+                      lights_type: lights_type,
+                      lights_scale: lights_scale)
+    apply_systems_and_efficiencies(model: model,
+                                   primary_heating_fuel: primary_heating_fuel,
+                                   sizing_run_dir: sizing_run_dir,
+                                   dcv_type: dcv_type,
+                                   ecm_system_name: ecm_system_name,
+                                   erv_package: erv_package,
+                                   boiler_eff: boiler_eff,
+                                   furnace_eff: furnace_eff,
+                                   shw_eff: shw_eff,
+                                   daylighting_type: daylighting_type
+    )
+    return model
+  end
+
+
+  def apply_systems_and_efficiencies(model:,
+                                     primary_heating_fuel:,
+                                     sizing_run_dir:,
+                                     dcv_type: 'NECB_Default',
+                                     ecm_system_name: 'NECB_Default',
+                                     erv_package: 'NECB_Default',
+                                     boiler_eff: nil,
+                                     furnace_eff: nil,
+                                     shw_eff: nil,
+                                     daylighting_type: 'NECB_Default')
+    # Create ECM object.
+    ecm = ECMS.new
+
+    # -------- Systems Layout-----------
+
+    # Create Default Systems.
     apply_systems(model: model, primary_heating_fuel: primary_heating_fuel, sizing_run_dir: sizing_run_dir)
+
+    # Apply new ECM system. Overwrite standard as required.
+    ecm.apply_system_ecm(model: model, ecm_system_name: ecm_system_name, template_standard: self)
+
+    # Apply ERV equipment as required.
+    ecm.apply_erv_ecm(model: model, erv_package: erv_package)
+
+
+    # -------- Performace, Efficiencies, Controls and Sensors ------------
+    #
+    # Set code standard equipment charecteristics.
     apply_standard_efficiencies(model: model, sizing_run_dir: sizing_run_dir)
-    model = apply_loop_pump_power(model: model, sizing_run_dir: sizing_run_dir)
-    return model
+    # 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.
+    ecm.apply_erv_ecm_efficiency(model: model, erv_package: erv_package)
+    # Apply DCV as required
+    model_enable_demand_controlled_ventilation(model, dcv_type)
+    # Apply Boiler Efficiency
+    ecm.modify_boiler_efficiency(model: model, boiler_eff: boiler_eff)
+    # Apply Furnace Efficiency
+    ecm.modify_furnace_efficiency(model: model, furnace_eff: furnace_eff)
+    # Apply SHW Efficiency
+    ecm.modify_shw_efficiency(model: model, shw_eff: shw_eff)
+    # Apply daylight controls.
+    model_add_daylighting_controls(model) if daylighting_type == 'add_daylighting_controls'
+
+
+    # -------Pump sizing required by some vintages----------------
+    # Apply Pump power as required.
+    apply_loop_pump_power(model: model, sizing_run_dir: sizing_run_dir)
   end
 
-  def apply_loads(model:)
-    raise('validation of model failed.') unless validate_initial_model(model)
-    raise('validation of spacetypes failed.') unless validate_and_upate_space_types(model)
+
+  def apply_loads(model:, lights_type: 'NECB_Default', lights_scale: 1.0, validate: true)
+    if validate
+      raise('validation of model failed.') unless validate_initial_model(model)
+      raise('validation of spacetypes failed.') unless validate_and_upate_space_types(model)
+    end
     #this sets/stores the template version loads that the model uses.
     model.getBuilding.setStandardsTemplate(self.class.name)
     set_occ_sensor_spacetypes(model, @space_type_map)
-    model_add_loads(model)
+    model_add_loads(model, lights_type, lights_scale)
   end
 
   def apply_weather_data(model:, epw_file:)
@@ -223,23 +398,44 @@ class NECB2011 < Standard
   end
 
   def apply_envelope(model:,
-                     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
-                     })
+                     ext_wall_cond: nil,
+                     ext_floor_cond: nil,
+                     ext_roof_cond: nil,
+                     ground_wall_cond: nil,
+                     ground_floor_cond: nil,
+                     ground_roof_cond: nil,
+                     door_construction_cond: nil,
+                     fixed_window_cond: nil,
+                     glass_door_cond: nil,
+                     overhead_door_cond: nil,
+                     skylight_cond: nil,
+                     glass_door_solar_trans: nil,
+                     fixed_wind_solar_trans: nil,
+                     skylight_solar_trans: nil)
     raise('validation of model failed.') unless validate_initial_model(model)
     model_apply_infiltration_standard(model)
     model.getInsideSurfaceConvectionAlgorithm.setAlgorithm('TARP')
     model.getOutsideSurfaceConvectionAlgorithm.setAlgorithm('TARP')
     model_add_constructions(model)
-    apply_standard_construction_properties(model: model, properties: properties)
+    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)
+
+
     model_create_thermal_zones(model, @space_multiplier_map)
+
   end
 
   # Thermal zones need to be set to determine conditioned spaces when applying fdwr and srr limits.
@@ -254,19 +450,20 @@ class NECB2011 < Standard
   def apply_fdwr_srr_daylighting(model:, fdwr_set: -1.0, srr_set: -1.0)
     apply_standard_window_to_wall_ratio(model: model, fdwr_set: fdwr_set)
     apply_standard_skylight_to_roof_ratio(model: model, srr_set: srr_set)
-    model_add_daylighting_controls(model) # to be removed after refactor.
+    # model_add_daylighting_controls(model) # to be removed after refactor.
   end
 
-  def apply_standard_efficiencies(model:, sizing_run_dir:)
+  def apply_standard_efficiencies(model:, sizing_run_dir:, dcv_type: 'NECB_Default')
     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
-    model.getAirTerminalSingleDuctVAVReheats.each {|iobj| air_terminal_single_duct_vav_reheat_set_heating_cap(iobj)}
+    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
     model_apply_hvac_efficiency_standard(model, climate_zone)
+    model_enable_demand_controlled_ventilation(model, dcv_type)
   end
 
   def apply_loop_pump_power(model:, sizing_run_dir:)
@@ -294,7 +491,7 @@ class NECB2011 < Standard
     #Now iterate though each vintage
     space_type_vintage_list.each do |template|
       #Create the standard object and get a list of all the spacetypes available for that vintage.
-      standard_space_type_list = Standard.build(template).get_all_spacetype_names.map {|spacetype| [spacetype[0].to_s + '-' + spacetype[1].to_s]}
+      standard_space_type_list = Standard.build(template).get_all_spacetype_names.map { |spacetype| [spacetype[0].to_s + '-' + spacetype[1].to_s] }
       # set array to contain unknown spacetypes.
       unknown_spacetypes = []
       # iterate though all space types that the model is using
@@ -331,7 +528,7 @@ class NECB2011 < Standard
       bt_target_vintage_string = "#{self.class.name}_building_type"
       space_type_upgrade_map = @standards_data['space_type_upgrade_map']
       model.getSpaceTypes.sort.each do |st|
-        space_type_map = space_type_upgrade_map.detect {|row| (row[st_model_vintage_string] == st.standardsSpaceType.get.to_s) && (row[bt_model_vintage_string] == st.standardsBuildingType.get.to_s)}
+        space_type_map = space_type_upgrade_map.detect { |row| (row[st_model_vintage_string] == st.standardsSpaceType.get.to_s) && (row[bt_model_vintage_string] == st.standardsBuildingType.get.to_s) }
         st.setStandardsBuildingType(space_type_map[bt_target_vintage_string].to_s.strip)
         raise('could not set buildingtype') unless st.setStandardsBuildingType(space_type_map[bt_target_vintage_string].to_s.strip)
         raise('could not set this') unless st.setStandardsSpaceType(space_type_map[st_target_vintage_string].to_s.strip)
@@ -518,4 +715,833 @@ class NECB2011 < Standard
   end
 
 
+  def model_add_daylighting_controls(model)
+
+    ##### Ask user's inputs for daylighting controls illuminance setpoint and number of stepped control steps.
+    ##### Note that the minimum number of stepped control steps is two steps as per NECB2011.
+    def daylighting_controls_settings(illuminance_setpoint: 500.0,
+                                      number_of_stepped_control_steps: 2)
+      return illuminance_setpoint, number_of_stepped_control_steps
+    end
+
+    ##### Find spaces with exterior fenestration including fixed window, operable window, and skylight.
+    daylight_spaces = []
+    model.getSpaces.sort.each do |space|
+      space.surfaces.sort.each do |surface|
+        surface.subSurfaces.sort.each do |subsurface|
+          if subsurface.outsideBoundaryCondition == "Outdoors" &&
+              (subsurface.subSurfaceType == "FixedWindow" ||
+                  subsurface.subSurfaceType == "OperableWindow" ||
+                  subsurface.subSurfaceType == "Skylight")
+            daylight_spaces << space
+          end #subsurface.outsideBoundaryCondition == "Outdoors" && (subsurface.subSurfaceType == "FixedWindow" || "OperableWindow")
+        end #surface.subSurfaces.each do |subsurface|
+      end #space.surfaces.each do |surface|
+    end #model.getSpaces.sort.each do |space|
+
+    ##### Remove duplicate spaces from the "daylight_spaces" array, as a daylighted space may have various fenestration types.
+    daylight_spaces = daylight_spaces.uniq
+    # puts daylight_spaces
+
+    ##### Create hashes for "Primary Sidelighted Areas", "Sidelighting Effective Aperture", "Daylighted Area Under Skylights",
+    ##### and "Skylight Effective Aperture" for the whole model.
+    ##### Each of these hashes will be used later in this function (i.e. model_add_daylighting_controls)
+    ##### to provide a dictionary of daylighted space names and the associated value (i.e. daylighted area or effective aperture).
+    primary_sidelighted_area_hash = {}
+    sidelighting_effective_aperture_hash = {}
+    daylighted_area_under_skylights_hash = {}
+    skylight_effective_aperture_hash = {}
+
+    ##### Calculate "Primary Sidelighted Areas" AND "Sidelighting Effective Aperture" as per NECB2011. #TODO: consider removing overlapped sidelighted area
+    daylight_spaces.sort.each do |daylight_space|
+      # puts daylight_space.name.to_s
+      primary_sidelighted_area = 0.0
+      area_weighted_vt_handle = 0.0
+      area_weighted_vt = 0.0
+      window_area_sum = 0.0
+
+      ##### Calculate floor area of the daylight_space and get floor vertices of the daylight_space (to be used for the calculation of daylight_space depth)
+      floor_surface = nil
+      floor_area = 0.0
+      floor_vertices = []
+      daylight_space.surfaces.sort.each do |surface|
+        if surface.surfaceType == "Floor"
+          floor_surface = surface
+          floor_area += surface.netArea
+          floor_vertices << surface.vertices
+        end
+      end
+
+      ##### Loop through the surfaces of each daylight_space to calculate primary_sidelighted_area and
+      ##### area-weighted visible transmittance and window_area_sum which are used to calculate sidelighting_effective_aperture
+      primary_sidelighted_area, area_weighted_vt_handle, window_area_sum =
+          get_parameters_sidelighting(daylight_space: daylight_space,
+                                      floor_surface: floor_surface,
+                                      floor_vertices: floor_vertices,
+                                      floor_area: floor_area,
+                                      primary_sidelighted_area: primary_sidelighted_area,
+                                      area_weighted_vt_handle: area_weighted_vt_handle,
+                                      window_area_sum: window_area_sum)
+
+      primary_sidelighted_area_hash[daylight_space.name.to_s] = primary_sidelighted_area
+
+      ##### Calculate area-weighted VT of glazing (this is used to calculate sidelighting effective aperture; see NECB2011: 4.2.2.10.).
+      area_weighted_vt = area_weighted_vt_handle / window_area_sum
+      sidelighting_effective_aperture_hash[daylight_space.name.to_s] = window_area_sum * area_weighted_vt / primary_sidelighted_area
+
+    end #daylight_spaces.each do |daylight_space|
+
+
+    ##### Calculate "Daylighted Area Under Skylights" AND "Skylight Effective Aperture"
+    daylight_spaces.sort.each do |daylight_space|
+      # puts daylight_space.name.to_s
+      skylight_area = 0.0
+      skylight_area_weighted_vt_handle = 0.0
+      skylight_area_weighted_vt = 0.0
+      skylight_area_sum = 0.0
+      daylighted_under_skylight_area = 0.0
+
+      ##### Loop through the surfaces of each daylight_space to calculate daylighted_area_under_skylights and skylight_effective_aperture for each daylight_space
+      daylighted_under_skylight_area, skylight_area_weighted_vt_handle, skylight_area_sum =
+          get_parameters_skylight(daylight_space: daylight_space,
+                                  skylight_area_weighted_vt_handle: skylight_area_weighted_vt_handle,
+                                  skylight_area_sum: skylight_area_sum,
+                                  daylighted_under_skylight_area: daylighted_under_skylight_area)
+
+      daylighted_area_under_skylights_hash[daylight_space.name.to_s] = daylighted_under_skylight_area
+
+      ##### Calculate skylight_effective_aperture as per NECB2011: 4.2.2.7.
+      ##### Note that it was assumed that the skylight is flush with the ceiling. Therefore, area-weighted average well factor (WF) was set to 0.9 in the below Equation.
+      skylight_area_weighted_vt = skylight_area_weighted_vt_handle / skylight_area_sum
+      skylight_effective_aperture_hash[daylight_space.name.to_s] = 0.85 * skylight_area_sum * skylight_area_weighted_vt * 0.9 / daylighted_under_skylight_area
+
+    end #daylight_spaces.each do |daylight_space|
+
+    # puts primary_sidelighted_area_hash
+    # puts sidelighting_effective_aperture_hash
+    # puts daylighted_area_under_skylights_hash
+    # puts skylight_effective_aperture_hash
+
+    ##### Find office spaces >= 25m2 among daylight_spaces
+    offices_larger_25m2 = []
+    daylight_spaces.sort.each do |daylight_space|
+
+      ## The following steps are for in case an office has multiple floors at various heights
+      ## 1. Calculate number of floors of each daylight_space
+      ## 2. Find the lowest z among all floors of each daylight_space
+      ## 3. Find lowest floors of each daylight_space (these floors are at the same level)
+      ## 4. Calculate 'daylight_space_area' as sum of area of all the lowest floors of each daylight_space, and gather the vertices of all the lowest floors of each daylight_space
+
+      ## 1. Calculate number of floors of daylight_space
+      floor_vertices = []
+      number_floor = 0
+      daylight_space.surfaces.sort.each do |surface|
+        if surface.surfaceType == 'Floor'
+          floor_vertices << surface.vertices
+          number_floor += 1
+        end
+      end
+
+      ## 2. Loop through all floors of daylight_space, and find the lowest z among all floors of daylight_space
+      lowest_floor_z = []
+      highest_floor_z = []
+      for i in 0..number_floor - 1
+        if i == 0
+          lowest_floor_z = floor_vertices[i][0].z
+          highest_floor_z = floor_vertices[i][0].z
+        else
+          if lowest_floor_z > floor_vertices[i][0].z
+            lowest_floor_z = floor_vertices[i][0].z
+          else
+            lowest_floor_z = lowest_floor_z
+          end
+          if highest_floor_z < floor_vertices[i][0].z
+            highest_floor_z = floor_vertices[i][0].z
+          else
+            highest_floor_z = highest_floor_z
+          end
+        end
+      end
+
+      ## 3 and 4. Loop through all floors of daylight_space, and calculate the sum of area of all the lowest floors of daylight_space,
+      ## and gather the vertices of all the lowest floors of daylight_space
+      daylight_space_area = 0
+      lowest_floors_vertices = []
+      floor_vertices = []
+      daylight_space.surfaces.sort.each do |surface|
+        if surface.surfaceType == 'Floor'
+          floor_vertices = surface.vertices
+          if floor_vertices[0].z == lowest_floor_z
+            lowest_floors_vertices << floor_vertices
+            daylight_space_area = daylight_space_area + surface.netArea
+          end
+        end
+      end
+
+      if daylight_space.spaceType.get.standardsSpaceType.get.to_s == "Office - enclosed" && daylight_space_area >= 25.0
+        offices_larger_25m2 << daylight_space.name.to_s
+      end
+    end
+
+    ##### find daylight_spaces which do not need daylight sensor controls based on the primary_sidelighted_area as per NECB2011: 4.2.2.8.
+    ##### Note: Office spaces >= 25m2 are excluded (i.e. they should have daylighting controls even if their primary_sidelighted_area <= 100m2), as per NECB2011: 4.2.2.2.
+    daylight_spaces_exception = []
+    primary_sidelighted_area_hash.sort.each do |key_daylight_space_name, value_primary_sidelighted_area|
+      if value_primary_sidelighted_area <= 100.0 && [key_daylight_space_name].any? { |word| offices_larger_25m2.include?(word) } == false
+        daylight_spaces_exception << key_daylight_space_name
+      end
+    end
+
+    ##### find daylight_spaces which do not need daylight sensor controls based on the sidelighting_effective_aperture as per NECB2011: 4.2.2.8.
+    ##### Note: Office spaces >= 25m2 are excluded (i.e. they should have daylighting controls even if their sidelighting_effective_aperture <= 10%), as per NECB2011: 4.2.2.2.
+    sidelighting_effective_aperture_hash.sort.each do |key_daylight_space_name, value_sidelighting_effective_aperture|
+      if value_sidelighting_effective_aperture <= 0.1 && [key_daylight_space_name].any? { |word| offices_larger_25m2.include?(word) } == false
+        daylight_spaces_exception << key_daylight_space_name
+      end
+    end
+
+    ##### find daylight_spaces which do not need daylight sensor controls based on the daylighted_area_under_skylights as per NECB2011: 4.2.2.4.
+    ##### Note: Office spaces >= 25m2 are excluded (i.e. they should have daylighting controls even if their daylighted_area_under_skylights <= 400m2), as per NECB2011: 4.2.2.2.
+    daylighted_area_under_skylights_hash.sort.each do |key_daylight_space_name, value_daylighted_area_under_skylights|
+      if value_daylighted_area_under_skylights <= 400.0 && [key_daylight_space_name].any? { |word| offices_larger_25m2.include?(word) } == false
+        daylight_spaces_exception << key_daylight_space_name
+      end
+    end
+
+    ##### find daylight_spaces which do not need daylight sensor controls based on the skylight_effective_aperture criterion as per NECB2011: 4.2.2.4.
+    ##### Note: Office spaces >= 25m2 are excluded (i.e. they should have daylighting controls even if their skylight_effective_aperture <= 0.6%), as per NECB2011: 4.2.2.2.
+    skylight_effective_aperture_hash.sort.each do |key_daylight_space_name, value_skylight_effective_aperture|
+      if value_skylight_effective_aperture <= 0.006 && [key_daylight_space_name].any? { |word| offices_larger_25m2.include?(word) } == false
+        daylight_spaces_exception << key_daylight_space_name
+      end
+    end
+    # puts daylight_spaces_exception
+
+    ##### Loop through the daylight_spaces and exclude the daylight_spaces that do not meet the criteria (see above) as per NECB2011: 4.2.2.4. and 4.2.2.8.
+    daylight_spaces_exception.sort.each do |daylight_space_exception|
+      daylight_spaces.sort.each do |daylight_space|
+        if daylight_space.name.to_s == daylight_space_exception
+          daylight_spaces.delete(daylight_space)
+        end
+      end
+    end
+    # puts daylight_spaces
+
+    ##### Create one daylighting sensor and put it at the center of each daylight_space if the space area < 250m2;
+    ##### otherwise, create two daylight sensors, divide the space into two parts and put each of the daylight sensors at the center of each part of the space.
+    daylight_spaces.sort.each do |daylight_space|
+      # puts daylight_space.name.to_s
+      ##### 1. Calculate number of floors of each daylight_space
+      ##### 2. Find the lowest z among all floors of each daylight_space
+      ##### 3. Find lowest floors of each daylight_space (these floors are at the same level)
+      ##### 4. Calculate 'daylight_space_area' as sum of area of all the lowest floors of each daylight_space, and gather the vertices of all the lowest floors of each daylight_space
+      ##### 5. Find min and max of x and y among vertices of all the lowest floors of each daylight_space
+
+      ##### Calculate number of floors of daylight_space
+      floor_vertices = []
+      number_floor = 0
+      daylight_space.surfaces.sort.each do |surface|
+        if surface.surfaceType == 'Floor'
+          floor_vertices << surface.vertices
+          number_floor += 1
+        end
+      end
+
+      ##### Loop through all floors of daylight_space, and find the lowest z among all floors of daylight_space
+      lowest_floor_z = []
+      highest_floor_z = []
+      for i in 0..number_floor - 1
+        if i == 0
+          lowest_floor_z = floor_vertices[i][0].z
+          highest_floor_z = floor_vertices[i][0].z
+        else
+          if lowest_floor_z > floor_vertices[i][0].z
+            lowest_floor_z = floor_vertices[i][0].z
+          else
+            lowest_floor_z = lowest_floor_z
+          end
+          if highest_floor_z < floor_vertices[i][0].z
+            highest_floor_z = floor_vertices[i][0].z
+          else
+            highest_floor_z = highest_floor_z
+          end
+        end
+      end
+      # puts lowest_floor_z
+
+      ##### Loop through all floors of daylight_space, and calculate the sum of area of all the lowest floors of daylight_space,
+      ##### and gather the vertices of all the lowest floors of daylight_space
+      daylight_space_area = 0
+      lowest_floors_vertices = []
+      floor_vertices = []
+      daylight_space.surfaces.sort.each do |surface|
+        if surface.surfaceType == 'Floor'
+          floor_vertices = surface.vertices
+          if floor_vertices[0].z == lowest_floor_z
+            lowest_floors_vertices << floor_vertices
+            daylight_space_area = daylight_space_area + surface.netArea
+          end
+        end
+      end
+      # puts daylight_space.name.to_s
+      # puts number_floor
+      # puts lowest_floors_vertices
+      # puts daylight_space_area
+
+      ##### Loop through all lowest floors of daylight_space and find the min and max of x and y among their vertices
+      xmin = lowest_floors_vertices[0][0].x
+      ymin = lowest_floors_vertices[0][0].y
+      xmax = lowest_floors_vertices[0][0].x
+      ymax = lowest_floors_vertices[0][0].y
+      zmin = lowest_floor_z
+      for i in 0..lowest_floors_vertices.count - 1 #this loops through each of the lowers floors of daylight_space
+        for j in 0..lowest_floors_vertices[i].count - 1 #this loops through each of vertices of each of the lowers floors of daylight_space
+
+          if xmin > lowest_floors_vertices[i][j].x
+            xmin = lowest_floors_vertices[i][j].x
+          end
+          if ymin > lowest_floors_vertices[i][j].y
+            ymin = lowest_floors_vertices[i][j].y
+          end
+          if xmax < lowest_floors_vertices[i][j].x
+            xmax = lowest_floors_vertices[i][j].x
+          end
+          if ymax < lowest_floors_vertices[i][j].y
+            ymax = lowest_floors_vertices[i][j].y
+          end
+        end
+      end
+      # puts daylight_space.name.to_s
+      # puts xmin
+      # puts xmax
+      # puts ymin
+      # puts ymax
+
+      ##### Get the thermal zone of daylight_space (this is used later to assign daylighting sensor)
+      zone = daylight_space.thermalZone
+      if !zone.empty?
+        zone = daylight_space.thermalZone.get
+        ##### Get the floor of the daylight_space
+        floors = []
+        daylight_space.surfaces.sort.each do |surface|
+          if surface.surfaceType == "Floor"
+            floors << surface
+          end
+        end
+
+        ##### Get user's input for daylighting controls illuminance setpoint and number of stepped control steps
+        illuminance_setpoint, number_of_stepped_control_steps = daylighting_controls_settings(illuminance_setpoint: 500.0, number_of_stepped_control_steps: 2)
+
+        ##### Create daylighting sensor control
+        ##### NOTE: NECB2011 has some requirements on the number of sensors in spaces based on the area of the spaces.
+        ##### However, EnergyPlus/OpenStudio allows to put maximum two built-in sensors in each thermal zone rather than in each space.
+        ##### Since a thermal zone may include several spaces which are not next to each other on the same floor, or
+        ##### a thermal zone may include spaces on different floors, a simplified method has been used to create a daylighting sensor.
+        ##### So, in each thermal zone, only one daylighting sensor has been created even if the area of that thermal zone requires more than one daylighting sensor.
+        ##### Also, it has been assumed that a thermal zone includes spaces which are next to each other and are on the same floor.
+        ##### Furthermore, the one daylighting sensor in each thermal zone (where the thermal zone needs daylighting sensor),
+        ##### the sensor has been put at the intersection of the minimum and maximum x and y of the lowest floor of that thermal zones.
+        sensor = OpenStudio::Model::DaylightingControl.new(daylight_space.model)
+        sensor.setName("#{daylight_space.name.to_s} daylighting control")
+        sensor.setSpace(daylight_space)
+        sensor.setIlluminanceSetpoint(illuminance_setpoint)
+        sensor.setLightingControlType('Stepped')
+        sensor.setNumberofSteppedControlSteps(number_of_stepped_control_steps)
+        x_pos = (xmin + xmax) / 2.0
+        y_pos = (ymin + ymax) / 2.0
+        z_pos = zmin + 0.8 #put it 0.8 meter above the floor
+        sensor_vertex = OpenStudio::Point3d.new(x_pos, y_pos, z_pos)
+        sensor.setPosition(sensor_vertex)
+        zone.setPrimaryDaylightingControl(sensor)
+        zone.setFractionofZoneControlledbyPrimaryDaylightingControl(1.0)
+
+      end #if !zone.empty?
+    end #daylight_spaces.each do |daylight_space|
+  end
+
+  #def model_add_daylighting_controls(model)
+
+
+  def model_enable_demand_controlled_ventilation(model, dcv_type = 'No_DCV') # Note: Values for dcv_type are: 'Occupancy_based_DCV', 'CO2_based_DCV', 'No_DCV', 'NECB_Default'
+    if dcv_type != 'NECB_Default'
+      if dcv_type == 'Occupancy_based_DCV' || dcv_type == 'CO2_based_DCV'
+        #TODO: IMPORTANT: (upon other BTAP tasks) Set a value for the "Outdoor Air Flow per Person" field of the "OS:DesignSpecification:OutdoorAir" object
+        # Note: The "Outdoor Air Flow per Person" field is required for occupancy-based DCV.
+        # Note: The "Outdoor Air Flow per Person" values should be based on ASHRAE 62.1: Article 6.2.2.1.
+        # Note: The "Outdoor Air Flow per Person" should be entered for "ventilation_per_person" in "lib/openstudio-standards/standards/necb/NECB2011/data/space_types.json"
+
+        ##### Define ScheduleTypeLimits for Any_Number_ppm
+        ##### TODO: (upon other BTAP tasks) This function can be added to btap/schedules.rb > module StandardScheduleTypeLimits
+        def self.get_any_number_ppm(model)
+          name = 'Any_Number_ppm'
+          any_number_ppm_schedule_type_limits = model.getScheduleTypeLimitsByName(name)
+          if any_number_ppm_schedule_type_limits.empty?
+            any_number_ppm_schedule_type_limits = OpenStudio::Model::ScheduleTypeLimits.new(model)
+            any_number_ppm_schedule_type_limits.setName(name)
+            any_number_ppm_schedule_type_limits.setNumericType('CONTINUOUS')
+            any_number_ppm_schedule_type_limits.setUnitType('Dimensionless')
+            any_number_ppm_schedule_type_limits.setLowerLimitValue(400.0)
+            any_number_ppm_schedule_type_limits.setUpperLimitValue(1000.0)
+            return any_number_ppm_schedule_type_limits
+          else
+            return any_number_ppm_schedule_type_limits.get
+          end
+        end
+
+        ##### Define indoor CO2 availability schedule (required for CO2-based DCV)
+        ##### Reference: see page B.13 of PNNL (2017), "Impacts of Commercial Building Controls on Energy Savings and Peak Load Reduction", available a: https://www.energy.gov/eere/buildings/downloads/impacts-commercial-building-controls-energy-savings-and-peak-load-reduction
+        ##### Note: the defined schedule here is redundant as the schedule says it is always on AND
+        ##### the "ZoneControl:ContaminantController" object says that "If this field is left blank, the schedule has a value of 1 for all time periods".
+        indoor_co2_availability_schedule = OpenStudio::Model::ScheduleCompact.new(model)
+        indoor_co2_availability_schedule.setName('indoor_co2_availability_schedule')
+        indoor_co2_availability_schedule.setScheduleTypeLimits(BTAP::Resources::Schedules::StandardScheduleTypeLimits::get_fraction(model))
+        indoor_co2_availability_schedule.to_ScheduleCompact.get
+        # indoor_co2_availability_schedule.setString(1,"indoor_co2_availability_schedule")
+        indoor_co2_availability_schedule.setString(3, "Through: 12/31")
+        indoor_co2_availability_schedule.setString(4, "For: Weekdays SummerDesignDay")
+        indoor_co2_availability_schedule.setString(5, "Until: 07:00")
+        indoor_co2_availability_schedule.setString(6, "0.0")
+        indoor_co2_availability_schedule.setString(7, "Until: 22:00")
+        indoor_co2_availability_schedule.setString(8, "1.0")
+        indoor_co2_availability_schedule.setString(9, "Until: 24:00")
+        indoor_co2_availability_schedule.setString(10, "0.0")
+        indoor_co2_availability_schedule.setString(11, "For: Saturday WinterDesignDay")
+        indoor_co2_availability_schedule.setString(12, "Until: 07:00")
+        indoor_co2_availability_schedule.setString(13, "0.0")
+        indoor_co2_availability_schedule.setString(14, "Until: 18:00")
+        indoor_co2_availability_schedule.setString(15, "1.0")
+        indoor_co2_availability_schedule.setString(16, "Until: 24:00")
+        indoor_co2_availability_schedule.setString(17, "0.0")
+        indoor_co2_availability_schedule.setString(18, "For: AllOtherDays")
+        indoor_co2_availability_schedule.setString(19, "Until: 24:00")
+        indoor_co2_availability_schedule.setString(20, "0.0")
+
+        ##### Define indoor CO2 setpoint schedule (required for CO2-based DCV)
+        ##### Reference: see page B.13 of PNNL (2017), "Impacts of Commercial Building Controls on Energy Savings and Peak Load Reduction", available a: https://www.energy.gov/eere/buildings/downloads/impacts-commercial-building-controls-energy-savings-and-peak-load-reduction
+        indoor_co2_setpoint_schedule = OpenStudio::Model::ScheduleCompact.new(model)
+        indoor_co2_setpoint_schedule.setName('indoor_co2_setpoint_schedule')
+        indoor_co2_setpoint_schedule.setScheduleTypeLimits(get_any_number_ppm(model))
+        indoor_co2_setpoint_schedule.to_ScheduleCompact.get
+        indoor_co2_setpoint_schedule.setString(3, "Through: 12/31")
+        indoor_co2_setpoint_schedule.setString(4, "For: AllDays")
+        indoor_co2_setpoint_schedule.setString(5, "Until: 24:00")
+        indoor_co2_setpoint_schedule.setString(6, "1000.0")
+        # indoor_co2_setpoint_schedule.setToConstantValue(1000.0) #1000 ppm
+
+
+        ##### Define outdoor CO2 schedule (required for CO2-based DCV
+        ##### Reference: see page B.13 of PNNL (2017), "Impacts of Commercial Building Controls on Energy Savings and Peak Load Reduction", available a: https://www.energy.gov/eere/buildings/downloads/impacts-commercial-building-controls-energy-savings-and-peak-load-reduction
+        outdoor_co2_schedule = OpenStudio::Model::ScheduleCompact.new(model)
+        outdoor_co2_schedule.setName('outdoor_co2_schedule')
+        outdoor_co2_schedule.setScheduleTypeLimits(get_any_number_ppm(model))
+        outdoor_co2_schedule.to_ScheduleCompact.get
+        outdoor_co2_schedule.setString(3, "Through: 12/31")
+        outdoor_co2_schedule.setString(4, "For: AllDays")
+        outdoor_co2_schedule.setString(5, "Until: 24:00")
+        outdoor_co2_schedule.setString(6, "400.0")
+        # outdoor_co2_schedule.setToConstantValue(400.0) #400 ppm
+
+        ##### Define ZoneAirContaminantBalance (required for CO2-based DCV)
+        zone_air_contaminant_balance = model.getZoneAirContaminantBalance()
+        zone_air_contaminant_balance.setCarbonDioxideConcentration(true)
+        zone_air_contaminant_balance.setOutdoorCarbonDioxideSchedule(outdoor_co2_schedule)
+
+        ##### Set CO2 controller in each space (required for CO2-based DCV)
+        model.getSpaces.sort.each do |space|
+          # puts space.name.to_s
+          zone = space.thermalZone
+          if !zone.empty?
+            zone = space.thermalZone.get
+          end
+          zone_control_co2 = OpenStudio::Model::ZoneControlContaminantController.new(zone.model)
+          zone_control_co2.setName("#{space.name.to_s} Zone Control Contaminant Controller")
+          zone_control_co2.setCarbonDioxideControlAvailabilitySchedule(indoor_co2_availability_schedule)
+          zone_control_co2.setCarbonDioxideSetpointSchedule(indoor_co2_setpoint_schedule)
+          zone.setZoneControlContaminantController(zone_control_co2)
+        end
+
+      end #if dcv_type == "Occupancy_based_DCV" || dcv_type == "CO2_based_DCV"
+
+      ##### Loop through AirLoopHVACs
+      model.getAirLoopHVACs.sort.each do |air_loop|
+        ##### Loop through AirLoopHVAC's supply nodes to:
+        ##### (1) Find its AirLoopHVAC:OutdoorAirSystem using the supply node;
+        ##### (2) Find Controller:OutdoorAir using AirLoopHVAC:OutdoorAirSystem;
+        ##### (3) Get "Controller Mechanical Ventilation" from Controller:OutdoorAir.
+        air_loop.supplyComponents.sort.each do |supply_component|
+          ##### Find AirLoopHVAC:OutdoorAirSystem of AirLoopHVAC using the supply node.
+          hvac_component = supply_component.to_AirLoopHVACOutdoorAirSystem
+
+          if !hvac_component.empty?
+            ##### Find Controller:OutdoorAir using AirLoopHVAC:OutdoorAirSystem.
+            hvac_component = hvac_component.get
+            controller_oa = hvac_component.getControllerOutdoorAir
+
+            ##### Get "Controller Mechanical Ventilation" from Controller:OutdoorAir.
+            controller_mv = controller_oa.controllerMechanicalVentilation
+
+            ##### Set "Demand Controlled Ventilation" to "Yes" or "No" in Controller:MechanicalVentilation depending on dcv_type.
+            if (dcv_type == 'CO2_based_DCV') || (dcv_type == 'Occupancy_based_DCV') #Occupancy
+              controller_mv.setDemandControlledVentilation(true)
+              ##### Set the "System Outdoor Air Method" field based on dcv_type in the Controller:MechanicalVentilation object
+              if dcv_type == 'CO2_based_DCV'
+                controller_mv.setSystemOutdoorAirMethod('IndoorAirQualityProcedure')
+              else #dcv_type == 'Occupancy_based_DCV'
+                controller_mv.setSystemOutdoorAirMethod('ZoneSum')
+              end
+            elsif dcv_type == 'No_DCV'
+              controller_mv.setDemandControlledVentilation(false)
+            end
+            # puts controller_mv
+
+          end #if !hvac_component.empty?
+
+        end #air_loop.supplyComponents.each do |supply_component|
+      end #model.getAirLoopHVACs.each do |air_loop|
+    end #if dcv_type != 'NECB_Default'
+  end
+
+  #def model_enable_demand_controlled_ventilation
+
+
+  def set_lighting_per_area_led_lighting(space_type:, definition:, lighting_per_area_led_lighting:, lights_scale:)
+    # puts "#{space_type.name.to_s} - 'space_height' - #{space_height.to_s}"
+    occ_sens_lpd_frac = 1.0
+    # NECB2011 space types that require a reduction in the LPD to account for
+    # the requirement of an occupancy sensor (8.4.4.6(3) and 4.2.2.2(2))
+    reduce_lpd_spaces = ['Classroom/lecture/training', 'Conf./meet./multi-purpose', 'Lounge/recreation',
+                         'Conf./meet./multi-purpose', 'Washroom-sch-A', 'Washroom-sch-B', 'Washroom-sch-C', 'Washroom-sch-D',
+                         'Washroom-sch-E', 'Washroom-sch-F', 'Washroom-sch-G', 'Washroom-sch-H', 'Washroom-sch-I',
+                         'Dress./fitt. - performance arts', 'Locker room', 'Locker room-sch-A', 'Locker room-sch-B',
+                         'Locker room-sch-C', 'Locker room-sch-D', 'Locker room-sch-E', 'Locker room-sch-F', 'Locker room-sch-G',
+                         'Locker room-sch-H', 'Locker room-sch-I', 'Retail - dressing/fitting']
+    if reduce_lpd_spaces.include?(space_type.standardsSpaceType.get)
+      # Note that "Storage area", "Storage area - refrigerated", "Hospital - medical supply" and "Office - enclosed"
+      # LPD should only be reduced if their space areas are less than specific area values.
+      # This is checked in a space loop after this function in the calling routine.
+      occ_sens_lpd_frac = 0.9
+    end
+
+    # ##### Since Atrium's LPD for LED lighting depends on atrium's height, the height of the atrium (if applicable) should be found.
+    standards_space_type = space_type.standardsSpaceType.is_initialized ? space_type.standardsSpaceType.get : nil
+    if standards_space_type.include? 'Atrium' #TODO: Note that since none of the archetypes has Atrium, this was tested for 'Dining'. #Atrium
+      puts "#{standards_space_type} - has atrium" #space_type.name.to_s
+      # Get the max height for the spacetype.
+      max_space_height_for_spacetype = get_max_space_height_for_space_type(space_type: space_type)
+      if max_space_height_for_spacetype < 12.0 #TODO: Note that since none of the archetypes has Atrium, this was tested for 'Dining' with the threshold of 5.0 m for space_height.
+        # TODO: Regarding the below equations, identify which version of ASHRAE 90.1 was used in NECB2015.
+        atrium_lpd_eq_smaller_12_intercept = 0
+        atrium_lpd_eq_smaller_12_slope = 1.06
+        atrium_lpd_eq_larger_12_intercept = 4.3
+        atrium_lpd_eq_larger_12_slope = 1.06
+        lighting_per_area_led_lighting_atrium = (atrium_lpd_eq_smaller_12_intercept + atrium_lpd_eq_smaller_12_slope * 12.0) * 0.092903 # W/ft2 TODO: Note that for NECB2011, a constant LPD is used for atrium based on NECB2015's equations. NECB2011's threshold for height is 13.0 m.
+      elsif max_space_height_for_spacetype >= 12.0 && max_space_height_for_spacetype < 13.0
+        lighting_per_area_led_lighting_atrium = (atrium_lpd_eq_larger_12_intercept + atrium_lpd_eq_larger_12_slope * 12.5) * 0.092903 # W/ft2
+      else #i.e. space_height >= 13.0
+        lighting_per_area_led_lighting_atrium = (atrium_lpd_eq_larger_12_intercept + atrium_lpd_eq_larger_12_slope * 13.0) * 0.092903 # W/ft2
+      end
+      puts "#{standards_space_type} - has lighting_per_area_led_lighting_atrium - #{lighting_per_area_led_lighting_atrium}"
+      lighting_per_area_led_lighting = lighting_per_area_led_lighting_atrium
+    end
+    lighting_per_area_led_lighting = lighting_per_area_led_lighting * lights_scale
+    definition.setWattsperSpaceFloorArea(OpenStudio.convert(lighting_per_area_led_lighting.to_f * occ_sens_lpd_frac, 'W/ft^2', 'W/m^2').get)
+
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.SpaceType', "#{space_type.name} set LPD to #{lighting_per_area_led_lighting} W/ft^2.")
+  end
+
+  # Adds the loads and associated schedules for each space type
+  # as defined in the OpenStudio_Standards_space_types.json file.
+  # This includes lights, plug loads, occupants, ventilation rate requirements,
+  # infiltration, gas equipment (for kitchens, etc.) and typical schedules for each.
+  # Some loads are governed by the standard, others are typical values
+  # pulled from sources such as the DOE Reference and DOE Prototype Buildings.
+  #
+  # @return [Bool] returns true if successful, false if not
+  def model_add_loads(model, lights_type, lights_scale)
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.Model', 'Started applying space types (loads)')
+
+    # Loop through all the space types currently in the model,
+    # which are placeholders, and give them appropriate loads and schedules
+    model.getSpaceTypes.sort.each do |space_type|
+      # Rendering color
+      space_type_apply_rendering_color(space_type)
+
+      # Loads
+      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, true)
+    end
+
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.Model', 'Finished applying space types (loads)')
+
+    return true
+  end
+
+  ##### This method is needed to the space_type_apply_internal_loads space needed for the calculation of atriums' LPD when LED lighting is used in atriums. ***END***
+  def get_max_space_height_for_space_type(space_type:)
+    # initialize return value to zero.
+    max_space_height_for_space_type = 0.0
+    # Interate through all spaces in model.. not just ones that have space type defined.. Is this right sara?
+    space_type.spaces.sort.each do |space|
+      # Get only the wall type surfaces and iterate throught them.
+      space.surfaces.sort.select(&:surfaceType == 'Wall').each do |wall_surface|
+        # Find the vertex with the max z value.
+        vertex_with_max_height = wall_surface.vertices.max_by(&:z)
+        # replace max if this surface has something bigger.
+        max_space_height_for_space_type = vertex_with_max_height.z if vertex_with_max_height.z > max_space_height_for_space_type
+      end
+    end
+    return max_space_height_for_space_type
+  end
+
+  ##### The below method is for the 'model_add_daylighting_controls' method
+  def get_parameters_sidelighting(daylight_space:, floor_surface:, floor_vertices:, floor_area:, primary_sidelighted_area:, area_weighted_vt_handle:, window_area_sum:)
+
+    daylight_space.surfaces.sort.each do |surface|
+
+      ##### Get the vertices of each exterior wall of the daylight_space on the floor
+      ##### (these vertices will be used to calculate daylight_space depth in relation to the exterior wall, and
+      ##### the distance of the window to vertical walls on each side of the window)
+      if surface.outsideBoundaryCondition == "Outdoors" && surface.surfaceType == "Wall"
+        wall_vertices_x_on_floor = []
+        wall_vertices_y_on_floor = []
+        surface_z_min = [surface.vertices[0].z, surface.vertices[1].z, surface.vertices[2].z, surface.vertices[3].z].min
+        surface.vertices.each do |vertex|
+          # puts vertex.z
+          if vertex.z == surface_z_min && surface_z_min == floor_vertices[0][0].z
+            wall_vertices_x_on_floor << vertex.x
+            wall_vertices_y_on_floor << vertex.y
+          end
+        end
+      end
+
+      if surface.outsideBoundaryCondition == "Outdoors" && surface.surfaceType == "Wall" && surface_z_min == floor_vertices[0][0].z
+
+        ##### Calculate the daylight_space depth in relation to the considered exterior wall.
+        ##### To calculate daylight_space depth, first get the floor vertices which are on the opposite side of the considered exterior wall.
+        floor_vertices_x_wall_opposite = []
+        floor_vertices_y_wall_opposite = []
+        floor_vertices[0].each do |floor_vertex|
+          if (floor_vertex.x != wall_vertices_x_on_floor[0] && floor_vertex.y != wall_vertices_y_on_floor[0]) || (floor_vertex.x != wall_vertices_x_on_floor[1] && floor_vertex.y != wall_vertices_y_on_floor[1])
+            floor_vertices_x_wall_opposite << floor_vertex.x
+            floor_vertices_y_wall_opposite << floor_vertex.y
+          end
+        end
+
+        ##### To calculate daylight_space depth, second calculate floor length on both sides: (1) exterior wall side, (2) on the opposite side of the exterior wall
+        floor_width_wall_side = Math.sqrt((wall_vertices_x_on_floor[0] - wall_vertices_x_on_floor[1]) ** 2 + (wall_vertices_y_on_floor[0] - wall_vertices_y_on_floor[1]) ** 2)
+        floor_width_wall_opposite = Math.sqrt((floor_vertices_x_wall_opposite[0] - floor_vertices_x_wall_opposite[1]) ** 2 + (floor_vertices_y_wall_opposite[0] - floor_vertices_y_wall_opposite[1]) ** 2)
+
+        ##### Now, daylight_space depth can be calculated using the floor area and two lengths of the floor (note that these two lengths are in parallel to each other).
+        daylight_space_depth = 2 * floor_area / (floor_width_wall_side + floor_width_wall_opposite)
+
+        ##### Loop through the windows (including fixed and operable ones) to get window specification (width, height, area, visible transmittance (VT)), and area-weighted VT
+        surface.subSurfaces.sort.each do |subsurface|
+          # puts subsurface.name.to_s
+          if subsurface.subSurfaceType == "FixedWindow" || subsurface.subSurfaceType == "OperableWindow"
+            window_vt = subsurface.visibleTransmittance
+            window_vt = window_vt.get
+            window_area = subsurface.netArea
+            window_area_sum += window_area
+            area_weighted_vt_handle += window_area * window_vt
+            window_vertices = subsurface.vertices
+            if window_vertices[0].z.round(2) == window_vertices[1].z.round(2)
+              window_width = Math.sqrt((window_vertices[0].x - window_vertices[1].x) ** 2.0 + (window_vertices[0].y - window_vertices[1].y) ** 2.0)
+            else
+              window_width = Math.sqrt((window_vertices[1].x - window_vertices[2].x) ** 2.0 + (window_vertices[1].y - window_vertices[2].y) ** 2.0)
+            end
+            window_head_height = [window_vertices[0].z, window_vertices[1].z, window_vertices[2].z, window_vertices[3].z].max.round(2)
+            primary_sidelighted_area_depth = [window_head_height, daylight_space_depth].min #as per NECB2011: 4.2.2.9.
+
+            ##### Calculate the  distance of the window to vertical walls on each side of the window (this is used to determine the sidelighted area's width).
+            window_vertices_on_floor = []
+            window_vertices.each do |vertex|
+              window_vertices_on_floor << floor_surface.plane.project(vertex)
+            end
+            window_wall_distance_side1 = [Math.sqrt((wall_vertices_x_on_floor[0] - window_vertices_on_floor[0].x) ** 2.0 + (wall_vertices_y_on_floor[0] - window_vertices_on_floor[0].y) ** 2.0),
+                                          Math.sqrt((wall_vertices_x_on_floor[0] - window_vertices_on_floor[2].x) ** 2.0 + (wall_vertices_y_on_floor[0] - window_vertices_on_floor[2].y) ** 2.0),
+                                          0.6].min # 0.6 m as per NECB2011: 4.2.2.9.
+            window_wall_distance_side2 = [Math.sqrt((wall_vertices_x_on_floor[1] - window_vertices_on_floor[0].x) ** 2.0 + (wall_vertices_y_on_floor[1] - window_vertices_on_floor[0].y) ** 2.0),
+                                          Math.sqrt((wall_vertices_x_on_floor[1] - window_vertices_on_floor[2].x) ** 2.0 + (wall_vertices_y_on_floor[1] - window_vertices_on_floor[2].y) ** 2.0),
+                                          0.6].min # 0.6 m as per NECB2011: 4.2.2.9.
+            primary_sidelighted_area_width = window_wall_distance_side1 + window_width + window_wall_distance_side2
+            primary_sidelighted_area = primary_sidelighted_area + primary_sidelighted_area_depth * primary_sidelighted_area_width
+          end #if subsurface.subSurfaceType == "FixedWindow" || subsurface.subSurfaceType == "OperableWindow"
+        end #surface.subSurfaces.each do |subsurface|
+      end #if surface.outsideBoundaryCondition == "Outdoors" && surface.surfaceType == "Wall" && surface_z_min == floor_vertices[0][0].z
+    end #daylight_space.surfaces.each do |surface|
+
+    return primary_sidelighted_area, area_weighted_vt_handle, window_area_sum
+  end
+
+  ##### The below method is for the 'model_add_daylighting_controls' method
+  def get_parameters_skylight(daylight_space:, skylight_area_weighted_vt_handle:, skylight_area_sum:, daylighted_under_skylight_area:)
+
+    daylight_space.surfaces.sort.each do |surface|
+      ##### Get roof vertices
+      if surface.outsideBoundaryCondition == "Outdoors" && surface.surfaceType == "RoofCeiling"
+        roof_vertices = surface.vertices
+      end
+
+      ##### Loop through each subsurafce to calculate daylighted_area_under_skylights and skylight_effective_aperture for each daylight_space
+      surface.subSurfaces.sort.each do |subsurface|
+        if subsurface.subSurfaceType == "Skylight"
+          skylight_vt = subsurface.visibleTransmittance
+          skylight_vt = skylight_vt.get
+          skylight_area = subsurface.netArea
+          skylight_area_sum += skylight_area
+          skylight_area_weighted_vt_handle += skylight_area * skylight_vt
+
+          ##### Get skylight vertices
+          skylight_vertices = subsurface.vertices
+
+          ##### Calculate skylight width and height
+          skylight_width = Math.sqrt((skylight_vertices[0].x - skylight_vertices[1].x) ** 2.0 + (skylight_vertices[0].y - skylight_vertices[1].y) ** 2.0)
+          skylight_length = Math.sqrt((skylight_vertices[0].x - skylight_vertices[3].x) ** 2.0 + (skylight_vertices[0].y - skylight_vertices[3].y) ** 2.0)
+
+          ##### Get ceiling height assuming the skylight is flush with the ceiling
+          ceiling_height = skylight_vertices[0].z
+
+          ##### Calculate roof lengths
+          ##### (Note: used OpenStudio BCL measure called "assign_ashrae_9012010_daylighting_controls" with some changes/correcctions)
+          roof_length_0 = Math.sqrt((roof_vertices[0].x - roof_vertices[1].x) ** 2.0 + (roof_vertices[0].y - roof_vertices[1].y) ** 2.0)
+          roof_length_1 = Math.sqrt((roof_vertices[1].x - roof_vertices[2].x) ** 2.0 + (roof_vertices[1].y - roof_vertices[2].y) ** 2.0)
+          roof_length_2 = Math.sqrt((roof_vertices[2].x - roof_vertices[3].x) ** 2.0 + (roof_vertices[2].y - roof_vertices[3].y) ** 2.0)
+          roof_length_3 = Math.sqrt((roof_vertices[3].x - roof_vertices[0].x) ** 2.0 + (roof_vertices[3].y - roof_vertices[0].y) ** 2.0)
+
+          ##### Find the skylight point that is the closest one to roof_vertex_0
+          ##### (Note: used OpenStudio BCL measure called "assign_ashrae_9012010_daylighting_controls" with some changes/correcctions)
+          roof_vertex_0_skylight_vertex_0 = Math.sqrt((roof_vertices[0].x - skylight_vertices[0].x) ** 2.0 + (roof_vertices[0].y - skylight_vertices[0].y) ** 2.0)
+          roof_vertex_0_skylight_vertex_1 = Math.sqrt((roof_vertices[0].x - skylight_vertices[1].x) ** 2.0 + (roof_vertices[0].y - skylight_vertices[1].y) ** 2.0)
+          roof_vertex_0_skylight_vertex_2 = Math.sqrt((roof_vertices[0].x - skylight_vertices[2].x) ** 2.0 + (roof_vertices[0].y - skylight_vertices[2].y) ** 2.0)
+          roof_vertex_0_skylight_vertex_3 = Math.sqrt((roof_vertices[0].x - skylight_vertices[3].x) ** 2.0 + (roof_vertices[0].y - skylight_vertices[3].y) ** 2.0)
+          roof_vertex_0_closest_distance = [roof_vertex_0_skylight_vertex_0, roof_vertex_0_skylight_vertex_1, roof_vertex_0_skylight_vertex_2, roof_vertex_0_skylight_vertex_3].min
+          if roof_vertex_0_closest_distance == roof_vertex_0_skylight_vertex_0
+            roof_vertex_0_closest_point = skylight_vertices[0]
+          elsif roof_vertex_0_closest_distance == roof_vertex_0_skylight_vertex_1
+            roof_vertex_0_closest_point = skylight_vertices[1]
+          elsif roof_vertex_0_closest_distance == roof_vertex_0_skylight_vertex_2
+            roof_vertex_0_closest_point = skylight_vertices[2]
+          elsif roof_vertex_0_closest_distance == roof_vertex_0_skylight_vertex_3
+            roof_vertex_0_closest_point = skylight_vertices[3]
+          end
+
+          ##### Find the skylight point that is the closest one to roof_vertex_2
+          ##### (Note: used OpenStudio BCL measure called "assign_ashrae_9012010_daylighting_controls" with some changes/correcctions)
+          roof_vertex_2_skylight_vertex_0 = Math.sqrt((roof_vertices[2].x - skylight_vertices[0].x) ** 2.0 + (roof_vertices[2].y - skylight_vertices[0].y) ** 2.0)
+          roof_vertex_2_skylight_vertex_1 = Math.sqrt((roof_vertices[2].x - skylight_vertices[1].x) ** 2.0 + (roof_vertices[2].y - skylight_vertices[1].y) ** 2.0)
+          roof_vertex_2_skylight_vertex_2 = Math.sqrt((roof_vertices[2].x - skylight_vertices[2].x) ** 2.0 + (roof_vertices[2].y - skylight_vertices[2].y) ** 2.0)
+          roof_vertex_2_skylight_vertex_3 = Math.sqrt((roof_vertices[2].x - skylight_vertices[3].x) ** 2.0 + (roof_vertices[2].y - skylight_vertices[3].y) ** 2.0)
+          roof_vertex_2_closest_distance = [roof_vertex_2_skylight_vertex_0, roof_vertex_2_skylight_vertex_1, roof_vertex_2_skylight_vertex_2, roof_vertex_2_skylight_vertex_3].min
+          if roof_vertex_2_closest_distance == roof_vertex_2_skylight_vertex_0
+            roof_vertex_2_closest_point = skylight_vertices[0]
+          elsif roof_vertex_2_closest_distance == roof_vertex_2_skylight_vertex_1
+            roof_vertex_2_closest_point = skylight_vertices[1]
+          elsif roof_vertex_2_closest_distance == roof_vertex_2_skylight_vertex_2
+            roof_vertex_2_closest_point = skylight_vertices[2]
+          elsif roof_vertex_2_closest_distance == roof_vertex_2_skylight_vertex_3
+            roof_vertex_2_closest_point = skylight_vertices[3]
+          end
+
+          ##### Calculate the vertical distance from the closest skylight points (projection onto the roof) to the wall (projection onto the roof) for roof_vertex_0 and roof_vertex_2
+          ##### (Note: used OpenStudio BCL measure called "assign_ashrae_9012010_daylighting_controls" with some changes/correcctions)
+          ##### For the calculation of each vertical distance: (1) first the area of the triangle is calculated knowing the cooridantes of its three corners;
+          ##### (2) the vertical distance (i.e. triangle height) is calculated knowing the triangle area and the associated roof length.
+          rv_0_triangle_0_area = 0.5 * (((roof_vertex_0_closest_point.x - roof_vertices[1].x) * (roof_vertex_0_closest_point.y - roof_vertices[0].y)) -
+              ((roof_vertex_0_closest_point.x - roof_vertices[0].x) * (roof_vertex_0_closest_point.y - roof_vertices[1].y))).abs
+          rv_0_distance_0 = (2.0 * rv_0_triangle_0_area) / roof_length_0
+          rv_0_triangle_3_area = 0.5 * (((roof_vertex_0_closest_point.x - roof_vertices[3].x) * (roof_vertex_0_closest_point.y - roof_vertices[0].y)) -
+              ((roof_vertex_0_closest_point.x - roof_vertices[0].x) * (roof_vertex_0_closest_point.y - roof_vertices[3].y))).abs
+          rv_0_distance_3 = (2.0 * rv_0_triangle_3_area) / roof_length_3
+
+          rv_2_triangle_1_area = 0.5 * (((roof_vertex_2_closest_point.x - roof_vertices[1].x) * (roof_vertex_2_closest_point.y - roof_vertices[2].y)) -
+              ((roof_vertex_2_closest_point.x - roof_vertices[2].x) * (roof_vertex_2_closest_point.y - roof_vertices[1].y))).abs
+          rv_2_distance_1 = (2.0 * rv_2_triangle_1_area) / roof_length_1
+          rv_2_triangle_2_area = 0.5 * (((roof_vertex_2_closest_point.x - roof_vertices[3].x) * (roof_vertex_2_closest_point.y - roof_vertices[2].y)) -
+              ((roof_vertex_2_closest_point.x - roof_vertices[2].x) * (roof_vertex_2_closest_point.y - roof_vertices[3].y))).abs
+          rv_2_distance_2 = (2.0 * rv_2_triangle_2_area) / roof_length_2
+
+          ##### Set the vertical distances from the closest skylight points (projection onto the roof) to the wall (projection onto the roof) for roof_vertex_0 and roof_vertex_2
+          distance_1 = rv_0_distance_0
+          distance_2 = rv_0_distance_3
+          distance_3 = rv_2_distance_1
+          distance_4 = rv_2_distance_2
+
+          ##### Calculate the width and length of the daylighted area under the skylight as per NECB2011: 4.2.2.5.
+          ##### Note: In the below loops, if any exterior walls has window(s), the width and length of the daylighted area under the skylight are re-calculated as per NECB2011: 4.2.2.5.
+          daylighted_under_skylight_width = skylight_width + [0.7 * ceiling_height, distance_1].min + [0.7 * ceiling_height, distance_4].min
+          daylighted_under_skylight_length = skylight_length + [0.7 * ceiling_height, distance_2].min + [0.7 * ceiling_height, distance_3].min
+
+          ##### As noted above, the width and length of the daylighted area under the skylight are re-calculated (as per NECB2011: 4.2.2.5.), if any exterior walls has window(s).
+          ##### To this end, the window_head_height should be calculated, as below:
+          daylight_space.surfaces.sort.each do |surface|
+            if surface.outsideBoundaryCondition == "Outdoors" && surface.surfaceType == "Wall"
+              wall_vertices_on_floor_x = []
+              wall_vertices_on_floor_y = []
+              wall_vertices = surface.vertices
+              if wall_vertices[0].z == wall_vertices[1].z
+                wall_vertices_on_floor_x << wall_vertices[0].x
+                wall_vertices_on_floor_x << wall_vertices[1].x
+                wall_vertices_on_floor_y << wall_vertices[0].y
+                wall_vertices_on_floor_y << wall_vertices[1].y
+              elsif wall_vertices[0].z == wall_vertices[3].z
+                wall_vertices_on_floor_x << wall_vertices[0].x
+                wall_vertices_on_floor_x << wall_vertices[3].x
+                wall_vertices_on_floor_y << wall_vertices[0].y
+                wall_vertices_on_floor_y << wall_vertices[3].y
+              end
+              window_vertices = subsurface.vertices
+              window_head_height = [window_vertices[0].z, window_vertices[1].z, window_vertices[2].z, window_vertices[3].z].max.round(2)
+
+              ##### Calculate the exterior wall length (on the floor)
+              exterior_wall_length = Math.sqrt((wall_vertices_on_floor_x[0] - wall_vertices_on_floor_x[1]) ** 2.0 + (wall_vertices_on_floor_y[0] - wall_vertices_on_floor_y[1]) ** 2.0)
+
+              ##### Calculate the vertical distance of skylight_vertices[0] projection onto the roof/floor to the exterior wall
+              skylight_vertex_0_triangle_area = 0.5 * (((wall_vertices_on_floor_x[0] - wall_vertices_on_floor_x[1]) * (wall_vertices_on_floor_y[0] - skylight_vertices[0].y)) -
+                  ((wall_vertices_on_floor_x[0] - skylight_vertices[0].x) * (wall_vertices_on_floor_y[0] - wall_vertices_on_floor_y[1]))).abs
+              skylight_vertex_0_distance = (2.0 * skylight_vertex_0_triangle_area) / exterior_wall_length
+
+              ##### Calculate the vertical distance of skylight_vertices[1] projection onto the roof/floor to the exterior wall
+              skylight_vertex_1_triangle_area = 0.5 * (((wall_vertices_on_floor_x[0] - wall_vertices_on_floor_x[1]) * (wall_vertices_on_floor_y[0] - skylight_vertices[1].y)) -
+                  ((wall_vertices_on_floor_x[0] - skylight_vertices[1].x) * (wall_vertices_on_floor_y[0] - wall_vertices_on_floor_y[1]))).abs
+              skylight_vertex_1_distance = (2.0 * skylight_vertex_1_triangle_area) / exterior_wall_length
+
+              ##### Calculate the vertical distance of skylight_vertices[3] projection onto the roof/floor to the exterior wall
+              skylight_vertex_3_triangle_area = 0.5 * (((wall_vertices_on_floor_x[0] - wall_vertices_on_floor_x[1]) * (wall_vertices_on_floor_y[0] - skylight_vertices[3].y)) -
+                  ((wall_vertices_on_floor_x[0] - skylight_vertices[3].x) * (wall_vertices_on_floor_y[0] - wall_vertices_on_floor_y[1]))).abs
+              skylight_vertex_3_distance = (2.0 * skylight_vertex_3_triangle_area) / exterior_wall_length
+
+              ##### Loop through the subsurfaces that has exterior windows to re-calculate the width and length of the daylighted area under the skylight
+              surface.subSurfaces.sort.each do |subsurface|
+                if subsurface.subSurfaceType == "FixedWindow" || subsurface.subSurfaceType == "OperableWindow"
+
+                  if skylight_vertex_0_distance == skylight_vertex_1_distance #skylight_01 is in parellel to the exterior wall
+                    if skylight_vertex_0_distance.round(2) == distance_2.round(2)
+                      daylighted_under_skylight_length = skylight_length + [0.7 * ceiling_height, distance_2, distance_2 - window_head_height].min + [0.7 * ceiling_height, distance_3].min
+                    elsif skylight_vertex_0_distance.round(2) == distance_3.round(2)
+                      daylighted_under_skylight_length = skylight_length + [0.7 * ceiling_height, distance_2].min + [0.7 * ceiling_height, distance_3, distance_3 - window_head_height].min
+                    end
+                  elsif skylight_vertex_0_distance == skylight_vertex_3_distance #skylight_03 is in parellel to the exterior wall
+                    if skylight_vertex_0_distance.round(2) == distance_1.round(2)
+                      daylighted_under_skylight_width = skylight_width + [0.7 * ceiling_height, distance_1, distance_1 - window_head_height].min + [0.7 * ceiling_height, distance_4].min
+                    elsif skylight_vertex_0_distance.round(2) == distance_4.round(2)
+                      daylighted_under_skylight_width = skylight_width + [0.7 * ceiling_height, distance_1].min + [0.7 * ceiling_height, distance_4, distance_4 - window_head_height].min
+                    end
+                  end #if skylight_vertex_0_distance == skylight_vertex_1_distance
+
+                  daylighted_under_skylight_area += daylighted_under_skylight_length * daylighted_under_skylight_width
+
+                end #if subsurface.subSurfaceType == "FixedWindow" || subsurface.subSurfaceType == "OperableWindow"
+              end #surface.subSurfaces.each do |subsurface|
+            end #if surface.outsideBoundaryCondition == "Outdoors" && surface.surfaceType == "Wall"
+          end #daylight_space.surfaces.each do |surface|
+
+        end #if subsurface.subSurfaceType == "Skylight"
+      end #surface.subSurfaces.each do |subsurface|
+    end #daylight_space.surfaces.each do |surface|
+
+    return daylighted_under_skylight_area, skylight_area_weighted_vt_handle, skylight_area_sum
+  end
+
 end