openstudio-standards 0.2.12 → 0.2.13.rc3

data/lib/openstudio-standards/standards/necb/ECMS/data/unitary_acs.json

@@ -0,0 +1,50 @@
+{
+  "tables": {
+    "unitary_cop_ecm": {
+      "refs": [
+        "assumption"
+      ],
+      "table": [
+        {
+          "name": "Carrier WeatherExpert",
+          "minimum_capacity": 0.0,
+          "maximum_capacity": 19044.8,
+          "minimum_energy_efficiency_ratio": null,
+          "minimum_seasonal_energy_efficiency_ratio": 17.3,
+          "cool_cap_ft": null,
+          "cool_cap_fflow": null,
+          "cool_eir_ft": null,
+          "cool_eir_fflow": null,
+          "cool_plf_fplr": null,
+          "notes": "Carrier WeatherExpert 3-5 Nominal Tons average"
+        },
+        {
+          "name": "Carrier WeatherExpert",
+          "minimum_capacity": 19044.8,
+          "maximum_capacity": 77960.0,
+          "minimum_energy_efficiency_ratio": 13.1,
+          "minimum_seasonal_energy_efficiency_ratio": null,
+          "cool_cap_ft": null,
+          "cool_cap_fflow": null,
+          "cool_eir_ft": null,
+          "cool_eir_fflow": null,
+          "cool_plf_fplr": null,
+          "notes": "Carrier WeatherExpert 6-10 Nominal Tons average"
+        },
+        {
+          "name": "Carrier WeatherExpert",
+          "minimum_capacity": 77960.0,
+          "maximum_capacity": 9999999.0,
+          "minimum_energy_efficiency_ratio": 12.0,
+          "minimum_seasonal_energy_efficiency_ratio": null,
+          "cool_cap_ft": null,
+          "cool_cap_fflow": null,
+          "cool_eir_ft": null,
+          "cool_eir_fflow": null,
+          "cool_plf_fplr": null,
+          "notes": "Carrier WeatherExpert 12.5-23 Tons average"
+        }
+      ]
+    }
+  }
+}

data/lib/openstudio-standards/standards/necb/ECMS/ecms.rb

@@ -41,7 +41,7 @@ class ECMS < NECB2011
     @standards_data['curves'] = standards_data['tables']["curves"]['table']
   end
 
-  def apply_system_ecm(model:, ecm_system_name: nil, template_standard:, runner: nil)
+  def apply_system_ecm(model:, ecm_system_name: nil, template_standard:, runner: nil, primary_heating_fuel: nil)
     # Do nothing if nil or other usual suspects.. covering all bases for now.
     return if ecm_system_name.nil? || ecm_system_name == 'none' || ecm_system_name == 'NECB_Default'
 
@@ -59,19 +59,32 @@ class ECMS < NECB2011
     ecm_std.remove_hw_loops(model)
     ecm_std.remove_chw_loops(model)
     ecm_std.remove_cw_loops(model)
-    ecm_std.send(ecm_add_method_name,
-                 model: model,
-                 system_zones_map: map_system_to_zones,
-                 system_doas_flags: system_doas_flags,
-                 zone_clg_eqpt_type: zone_clg_eqpt_type,
-                 standard: template_standard)
+
+    # Rather than go through every add_ecm class to add 'the primary_heating_fuel' argument I added this statement to
+    # only include it when it is used (for now in the add_ecm_remove_airloops_add_zone_baseboards method).
+    unless (ecm_add_method_name == "add_ecm_remove_airloops_add_zone_baseboards")
+      ecm_std.send(ecm_add_method_name,
+                   model: model,
+                   system_zones_map: map_system_to_zones,
+                   system_doas_flags: system_doas_flags,
+                   zone_clg_eqpt_type: zone_clg_eqpt_type,
+                   standard: template_standard)
+    else
+      ecm_std.send(ecm_add_method_name,
+                   model: model,
+                   system_zones_map: map_system_to_zones,
+                   system_doas_flags: system_doas_flags,
+                   zone_clg_eqpt_type: zone_clg_eqpt_type,
+                   standard: template_standard,
+                   primary_heating_fuel: primary_heating_fuel)
+    end
     #ecm_std.add_ecm_hs09_ccashpsys(model:model,system_zones_map:,system_doas_flags:,zone_clg_eqpt_type: nil,standard:,baseboard_flag: true)
 
   end
 
   def apply_system_efficiencies_ecm(model:, ecm_system_name: nil)
     # Do nothing if nil.
-    return if ecm_system_name.nil? || ecm_system_name == 'none' || ecm_system_name == 'NECB_Default'
+    return if ecm_system_name.nil? || ecm_system_name == 'none' || ecm_system_name == 'NECB_Default' || ecm_system_name.to_s.downcase == 'remove_airloops_add_zone_baseboards'
     ecm_std = Standard.build("ECMS")
     # Get method name that should be present in the ECM class.
     ecm_apply_eff_method_name = "apply_efficiency_ecm_#{ecm_system_name.downcase}"

data/lib/openstudio-standards/standards/necb/ECMS/erv.rb

@@ -1,12 +1,24 @@
 class ECMS
-  # This method will add a skeleton erv to all air loops.
+  # This method will add a skeleton erv to all air loops if requested.
   def apply_erv_ecm(model:, erv_package: nil)
     # If erv is nil.. do nothing.
     return if erv_package.nil? || erv_package == 'none' || erv_package == 'NECB_Default'
-
-    model.getAirLoopHVACs.each do |air_loop|
-      # Adds default erv to all air_loops
-      air_loop_hvac_apply_energy_recovery_ventilator(air_loop, nil)
+    erv_info = @standards_data['tables']['erv']['table'].detect { |item| item['erv_name'] == erv_package }
+    # Check if we were able to get data.
+    if erv_info.nil?
+      # Get name of ERVs in erv.json.
+      valid = @standards_data['tables']['erv']['table'].map{|x| x['erv_name']}
+      #tell user.
+      raise("ERV package name #{erv_package} does not exist. must be #{valid} /n Stopping.")
+    end
+    if erv_info['application'] ==  "Add_ERVs_To_All_Airloops"
+      #remove all existing ERVs
+      model.getHeatExchangerAirToAirSensibleAndLatents.each { |erv| erv.remove}
+      #add ervs
+      model.getAirLoopHVACs.each do |air_loop|
+        # Adds default erv to all air_loops. This will be changed in the set efficiency methods.
+        air_loop_hvac_apply_energy_recovery_ventilator(air_loop, nil)
+      end
     end
   end
 
@@ -15,7 +27,6 @@ class ECMS
   def apply_erv_ecm_efficiency(model:, erv_package: nil)
     # If erv is nil.. do nothing.
     return if erv_package.nil? || erv_package == 'none' || erv_package == 'NECB_Default'
-
     # This calls the NECB2011 implementation of the method.
     model.getHeatExchangerAirToAirSensibleAndLatents.each { |erv| heat_exchanger_air_to_air_sensible_and_latent_apply_efficiency(erv, erv_package) }
   end

data/lib/openstudio-standards/standards/necb/ECMS/hvac_systems.rb

@@ -404,7 +404,7 @@ class ECMS
       system_data[:ZoneCoolingSizingFactor] = 1.1
       system_data[:ZoneHeatingSizingFactor] = 1.3
       if system_doas_flags[sys_name.to_s]
-        system_data[:name] = "CCASHP Makeup Air Unit"
+        system_data[:name] = sys_name.to_s
         system_data[:AllOutdoorAirinCooling] = true
         system_data[:AllOutdoorAirinHeating] = true
         system_data[:TypeofLoadtoSizeOn] = 'VentilationRequirement'
@@ -416,7 +416,7 @@ class ECMS
         sat_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, 24, 0, 0), system_data[:system_supply_air_temperature])
         setpoint_mgr = OpenStudio::Model::SetpointManagerScheduled.new(model, sat_sch)
       else
-        system_data[:name] = "CCASHP System"
+        system_data[:name] = sys_name.to_s
         system_data[:AllOutdoorAirinCooling] = false
         system_data[:AllOutdoorAirinHeating] = false
         system_data[:TypeofLoadtoSizeOn] = 'Sensible'
@@ -445,16 +445,16 @@ class ECMS
       sys_supply_fan.setName("System Supply Fan")
       # Cooling coil
       sys_clg_coil = OpenStudio::Model::CoilCoolingDXVariableSpeed.new(model)
-      sys_clg_coil.setName("CCASHP DX Clg Coil")
+      sys_clg_coil.setName("CoilCoolingDXVariableSpeed_CCASHP")
       sys_clg_coil_speeddata1 = OpenStudio::Model::CoilCoolingDXVariableSpeedSpeedData.new(model)
       sys_clg_coil.addSpeed(sys_clg_coil_speeddata1)
       sys_clg_coil.setNominalSpeedLevel(1)
       # Electric supplemental heating coil
       sys_elec_htg_coil = OpenStudio::Model::CoilHeatingElectric.new(model, always_on)
-      sys_elec_htg_coil.setName("CCASHP Elec Htg Coil")
+      sys_elec_htg_coil.setName("CoilHeatingElectric")
       # DX heating coil
       sys_dx_htg_coil = OpenStudio::Model::CoilHeatingDXVariableSpeed.new(model)
-      sys_dx_htg_coil.setName("CCASHP DX Htg Coil")
+      sys_dx_htg_coil.setName("CoilHeatingDXVariableSpeed_CCASHP")
       sys_dx_htg_coil_speed1 = OpenStudio::Model::CoilHeatingDXVariableSpeedSpeedData.new(model)
       sys_dx_htg_coil.addSpeed(sys_dx_htg_coil_speed1)
       sys_dx_htg_coil.setNominalSpeedLevel(1)
@@ -508,6 +508,16 @@ class ECMS
         airloop.addBranchForZone(zone, diffuser.to_StraightComponent)
         if baseboard_flag then standard.add_zone_baseboards(baseboard_type: 'Electric', hw_loop: nil, model: model, zone: zone) end
       end
+      update_sys_name(airloop,
+                      sys_abbr: nil,
+                      sys_oa: nil,
+                      sys_hr: nil,
+                      sys_htg: "ccashp",
+                      sys_clg: "ccashp",
+                      sys_sf: nil,
+                      zone_htg: "b-e",
+                      zone_clg: "none",
+                      sys_rf: nil)
       systems << airloop
     end
 
@@ -1590,4 +1600,130 @@ class ECMS
     shw_name = "#{shw_vol_gal} Gal #{shw_ecm_package_name} Water Heater - #{shw_capacity_kBtu_hr}kBtu/hr #{eff["efficiency"]} Therm Eff"
     component.setName(shw_name)
   end
-end
+
+  # ============================================================================================================================
+  # Method to update the cop and/or the performance curves of unitary dx coils. The method input 'unitary_cop' can either be a
+  # string or a hash. When it's a string it's used to find a hash in the json table 'unitary_cop_ecm'. When it's a hash it holds
+  # the parameters needed to update the cop and/or the performance curves of the unitary coil.
+  def modify_unitary_cop(model:, unitary_cop:,sql_db_vars_map:)
+    return if (unitary_cop.nil? || (unitary_cop.to_s == "NECB_Default"))
+    coils = model.getCoilCoolingDXSingleSpeeds + model.getCoilCoolingDXMultiSpeeds
+    unitary_cop_copy = unitary_cop.dup
+    coils.sort.each do |coil|
+      coil_type = "SingleSpeed"
+      coil_type = "MultiSpeed" if coil.class.name.to_s.include? 'CoilCoolingDXMultiSpeed'
+      # if the parameter 'unitary_cop' is a string then get the information on the new parameters for the coils from
+      # the json table 'unitary_cop_ecm'
+      if unitary_cop_copy.is_a?(String)
+        search_criteria = {}
+        search_criteria['name'] = unitary_cop_copy
+        coil_name = coil.name.to_s
+        coil.setName(sql_db_vars_map[coil_name])
+        if coil_type == "SingleSpeed"
+          capacity_w = coil_cooling_dx_single_speed_find_capacity(coil)
+        elsif coil_type == "MultiSpeed"
+          capacity_w = coil_cooling_dx_multi_speed_find_capacity(coil)
+        end
+        coil.setName(coil_name)
+        cop_package = model_find_object(@standards_data['tables']['unitary_cop_ecm'], search_criteria, capacity_w)
+        raise "Cannot not find #{unitary_cop_ecm} in the ECMS unitary_acs.json file.  Please check that the name is correctly spelled in the ECMS class unitary_acs.json file and in the code calling (directly or through another method) the ECMS class modify_unitary_eff method." if cop_package.empty?
+        ecm_name = unitary_cop_copy
+        unitary_cop = {
+          "name" => ecm_name,
+          "minimum_energy_efficiency_ratio" => cop_package['minimum_energy_efficiency_ratio'],
+          "minimum_seasonal_energy_efficiency_ratio" => cop_package['minimum_seasonal_energy_efficiency_ratio'],
+          "cool_cap_ft" => cop_package['cool_cap_ft'],
+          "cool_cap_fflow" => cop_package['cool_cap_fflow'],
+          "cool_eir_ft" => cop_package['cool_eir_ft'],
+          "cool_eir_fflow" => cop_package['cool_eir_fflow'],
+          "cool_plf_fplr" => cop_package['cool_eir_fplr']
+        }
+      end
+      next if (unitary_cop['minimum_energy_efficiency_ratio'].nil? && unitary_cop['minimum_seasonal_energy_efficiency_ratio'].nil? && unitary_cop['cool_cap_ft'].nil? &&
+          unitary_cop['cool_cap_fflow'].nil? && unitary_cop['cool_eir_ft'].nil? && unitary_cop['cool_eir_fflow'].nil? && unitary_cop['cool_plf_fplr'].nil?)
+
+      # If the dx coil is on an air loop then update its cop and the performance curves when these are specified in the ecm data
+      if (coil_type == "SingleSpeed" && coil.airLoopHVAC.is_initialized) ||
+          (coil_type == "MultiSpeed" && coil.containingHVACComponent.get.airLoopHVAC.is_initialized)
+        cop = nil
+        if unitary_cop['minimum_energy_efficiency_ratio']
+          cop = eer_to_cop(unitary_cop['minimum_energy_efficiency_ratio'].to_f)
+        elsif unitary_cop['minimum_seasonal_energy_efficiency_ratio']
+          cop = seer_to_cop_cooling_with_fan(unitary_cop['minimum_seasonal_energy_efficiency_ratio'].to_f)
+        end
+        cool_cap_ft = nil
+        cool_cap_ft = @standards_data['curves'].select { |curve| curve['name'] == unitary_cop['cool_cap_ft'] } if unitary_cop['cool_cap_ft']
+        cool_cap_fflow = nil
+        cool_cap_fflow = @standards_data['curves'].select { |curve| curve['name'] == unitary_cop['cool_cap_fflow'] } if unitary_cop['cool_cap_fflow']
+        cool_eir_ft = nil
+        cool_eir_ft = @standards_data['curves'].select { |curve| curve['name'] == unitary_cop['cool_eir_ft'] } if unitary_cop['cool_eir_ft']
+        cool_eir_fflow = nil
+        cool_eir_fflow = @standards_data['curves'].select { |curve| curve['name'] == unitary_cop['cool_eir_fflow'] } if unitary_cop['cool_eir_fflow']
+        cool_plf_fplr = nil
+        cool_plf_fplr = @standards_data['curves'].select { |curve| curve['name'] == unitary_cop['cool_plf_fplr'] } if unitary_cop['cool_plf_fplr']
+        if coil_type == "SingleSpeed"
+          coil.setRatedCOP(cop) if cop
+          coil.setTotalCoolingCapacityFunctionOfTemperatureCurve(cool_cap_ft) if cool_cap_ft
+          coil.setTotalCoolingCapacityFunctionOfFlowFractionCurve(cool_cap_fflow) if cool_cap_fflow
+          coil.setEnergyInputRatioFunctionOfTemperatureCurve(cool_eir_ft) if cool_eir_ft
+          coil.setEnergyInputRatioFunctionOfFlowFractionCurve(cool_eir_fflow) if cool_eir_fflow
+          coil.setPartLoadFractionCorrelationCurve(cool_plf_fplr) if cool_plf_fplr
+        elsif coil_type == "MultiSpeed"
+          coil.stages.sort.each do |stage|
+            stage.setGrossRatedCoolingCOP(cop) if cop
+            stage.setTotalCoolingCapacityFunctionofTemperatureCurve(cool_cap_ft) if cool_cap_ft
+            stage.setTotalCoolingCapacityFunctionofFlowFractionCurve(cool_cap_fflow) if cool_cap_fflow
+            stage.setEnergyInputRatioFunctionofTemperatureCurve(cool_eir_ft) if cool_eir_ft
+            stage.setEnergyInputRatioFunctionofFlowFractionCurve(cool_eir_fflow) if cool_eir_fflow
+            stage.setPartLoadFractionCorrelationCurve(cool_plf_fplr) if cool_plf_fplr
+          end
+        end
+        coil.setName("CoilCoolingDXSingleSpeed_dx-adv") if (cop && coil_type == "SingleSpeed")
+        coil.setName("CoilCoolingDXMultiSpeed_dx-adv") if (cop && coil_type == "MultiSpeed")
+      end
+    end
+  end
+
+  # ============================================================================================================================
+  # Despite the name, this method does not actually remove any air loops.  All air loops, hot water loops, cooling and
+  # any existing baseboard heaters should already be gone.  The name is an artifact of the way ECM methods are named and
+  # used.  With everything gone, this method adds a hot water loop (if required) and baseboard heating back in to all
+  # zones requiring heating.  Originally, code was included in the 'apply_systems' method which would prevent the air
+  # loops and other stuff from being created if someone did not want them.  But others felt that that was not a clear
+  # way of doing things and did not feel the performance penalty of creating objects, then removing them, then creating
+  # them again was significant.
+  def add_ecm_remove_airloops_add_zone_baseboards(model:,system_zones_map:, system_doas_flags: nil, zone_clg_eqpt_type: nil, standard:, primary_heating_fuel:)
+    # Set the primary fuel set to default to to specific fuel type.
+    standards_info = standard.standards_data
+
+    if primary_heating_fuel == 'DefaultFuel'
+      epw = BTAP::Environment::WeatherFile.new(model.weatherFile.get.path.get)
+      primary_heating_fuel = standards_info['regional_fuel_use'].detect {|fuel_sources| fuel_sources['state_province_regions'].include?(epw.state_province_region)}['fueltype_set']
+    end
+    # Get fuelset.
+    system_fuel_defaults = standards_info['fuel_type_sets'].detect {|fuel_type_set| fuel_type_set['name'] == primary_heating_fuel}
+    raise("fuel_type_sets named #{primary_heating_fuel} not found in fuel_type_sets table.") if system_fuel_defaults.nil?
+
+
+    # Assign fuel sources.
+    boiler_fueltype = system_fuel_defaults['boiler_fueltype']
+    baseboard_type = system_fuel_defaults['baseboard_type']
+    mau_heating_coil_type = "none"
+
+    # Create the hot water loop if necessary.
+    hw_loop = standard.create_hw_loop_if_required(baseboard_type,
+                                          boiler_fueltype,
+                                          mau_heating_coil_type,
+                                          model)
+
+    # Add baseboard heaters to each heated zone.
+    system_zones_map.sort.each do |sname,zones|
+      zones.each do |zone|
+        standard.add_zone_baseboards(baseboard_type: baseboard_type,
+                                     hw_loop: hw_loop,
+                                     model: model,
+                                     zone: zone)
+      end
+    end
+  end
+end

data/lib/openstudio-standards/standards/necb/ECMS/nv.rb

@@ -0,0 +1,189 @@
+class ECMS
+
+  def apply_nv(model:, nv_type:, nv_opening_fraction:, nv_Tout_min:, nv_Delta_Tin_Tout:)
+
+    ##### If any of users' inputs are nil/false/none, do nothing.
+    ##### If users' input for 'nv_type' is 'NECB_Default', do nothing.
+    ##### If any of users' inputs for nv_opening_fraction/nv_Tout_min/nv_Delta_Tin_Tout is 'NECB_Default', use default values as defined here.
+    return if nv_type.nil? || nv_type == false || nv_type == 'none' || nv_type == 'NECB_Default'
+    return if nv_opening_fraction.nil? || nv_opening_fraction == false || nv_opening_fraction == 'none'
+    return if nv_Tout_min.nil? || nv_Tout_min == false || nv_Tout_min == 'none'
+    return if nv_Delta_Tin_Tout.nil? || nv_Delta_Tin_Tout == false || nv_Delta_Tin_Tout == 'none'
+
+    ##### Convert a string to a float (except for nv_type)
+    if nv_opening_fraction.instance_of?(String) && nv_opening_fraction != 'NECB_Default'
+      nv_opening_fraction = nv_opening_fraction.to_f
+    end
+    if nv_Tout_min.instance_of?(String) && nv_Tout_min != 'NECB_Default'
+      nv_Tout_min = nv_Tout_min.to_f
+    end
+    if nv_Delta_Tin_Tout.instance_of?(String) && nv_Delta_Tin_Tout != 'NECB_Default'
+      nv_Delta_Tin_Tout = nv_Delta_Tin_Tout.to_f
+    end
+
+    ##### Set default nv_opening_fraction as 0.1
+    if nv_opening_fraction == 'NECB_Default'
+      nv_opening_fraction = 0.1
+    end
+    ##### Set default nv_Tout_min as 13.0
+    if nv_Tout_min == 'NECB_Default'
+      nv_Tout_min = 13.0 #Note: 13.0 is based on inputs from Michel Tardif re a real school in QC
+    end
+    ##### Set default nv_Delta_Tin_Tout as 1.0
+    if nv_Delta_Tin_Tout == 'NECB_Default'
+      nv_Delta_Tin_Tout = 1.0 #Note: 1.0 is based on inputs from Michel Tardif re a real school in QC
+    end
+
+    setpoint_adjustment_for_nv = 2.0  #This is to adjust heating and cooling setpoint temperature as min and max indoor temperature to have NV
+
+    model.getZoneHVACEquipmentLists.sort.each do |zone_hvac_equipment_list|
+
+      thermal_zone = zone_hvac_equipment_list.thermalZone
+
+      thermal_zone.spaces.sort.each do |space|
+        number_of_windows = 0.0
+
+        ##### Gather OA per person and floor area of the space from the osm file
+        outdoor_air = space.designSpecificationOutdoorAir.get
+        outdoor_air_flow_per_person = outdoor_air.outdoorAirFlowperPerson
+        outdoor_air_flow_per_floor_area = outdoor_air.outdoorAirFlowperFloorArea
+
+        ##### Get heating/cooling setpoint temperature schedules from the osm file
+        # These schedules are used for min/max Tin schedules under the objects of "ZoneVentilation:DesignFlowRate" and "ZoneVentilation:WindandStackOpenArea".
+        # Note: as per E+ I/O Ref.: "If the user enters a valid schedule name, the minimum/maximum temperature values specified in this schedule will override the constant value specified in the Minimum/Maximum Indoor Temperature field." under the objects of "ZoneVentilation:DesignFlowRate" and "ZoneVentilation:WindandStackOpenArea".
+        if thermal_zone.thermostat.is_initialized
+          if thermal_zone.thermostat.get.to_ThermostatSetpointDualSetpoint.is_initialized
+            if thermal_zone.thermostat.get.to_ThermostatSetpointDualSetpoint.get.heatingSetpointTemperatureSchedule.is_initialized ||
+                thermal_zone.thermostat.get.to_ThermostatSetpointDualSetpoint.get.coolingSetpointTemperatureSchedule.is_initialized
+              zone_thermostat = thermal_zone.thermostatSetpointDualSetpoint.get
+              zone_clg_thermostat_sch = zone_thermostat.coolingSetpointTemperatureSchedule.get
+              zone_htg_thermostat_sch = zone_thermostat.heatingSetpointTemperatureSchedule.get
+
+              ##### Create schedule for max Tin to have NV on the basis of cooling setpoint temperature for default day
+              zone_clg_thermostat_sch_name = zone_clg_thermostat_sch.name
+              zone_clg_sp_schedule = zone_clg_thermostat_sch.to_ScheduleRuleset.get
+
+              max_Tin_schedule = zone_clg_sp_schedule.clone(model).to_ScheduleRuleset.get
+              max_Tin_schedule.setName('natural_ventilation_max_Tin_schedule')
+              ## default days/weekdays
+              max_Tin_schedule_defaultDay = max_Tin_schedule.defaultDaySchedule
+              max_Tin_schedule_defaultDay.setName('natural_ventilation_max_Tin_schedule_defaultDay')
+              max_Tin_schedule_defaultDay_times = max_Tin_schedule_defaultDay.times
+              max_Tin_schedule_defaultDay_values = max_Tin_schedule_defaultDay.values
+              max_Tin_schedule_defaultDay_values_adjusted = max_Tin_schedule_defaultDay_values.map { |i| i + setpoint_adjustment_for_nv }
+              i = 0.0
+              max_Tin_schedule_defaultDay_times.each do |time|
+                max_Tin_schedule_defaultDay.addValue(time, max_Tin_schedule_defaultDay_values_adjusted[i])
+                i += 1.0
+              end
+
+              ##### Create schedule for min Tin to have NV on the basis of cooling setpoint temperature for default day
+              zone_htg_thermostat_sch_name = zone_htg_thermostat_sch.name
+              zone_htg_sp_schedule = zone_htg_thermostat_sch.to_ScheduleRuleset.get
+              min_Tin_schedule = zone_htg_sp_schedule.clone(model).to_ScheduleRuleset.get
+              min_Tin_schedule.setName('natural_ventilation_min_Tin_schedule')
+              ## default days/weekdays
+              min_Tin_schedule_defaultDay = min_Tin_schedule.defaultDaySchedule
+              min_Tin_schedule_defaultDay.setName('natural_ventilation_min_Tin_schedule_defaultDay')
+              min_Tin_schedule_defaultDay_times = min_Tin_schedule_defaultDay.times
+              min_Tin_schedule_defaultDay_values = min_Tin_schedule_defaultDay.values
+              min_Tin_schedule_defaultDay_values_adjusted = min_Tin_schedule_defaultDay_values.map { |i| i - setpoint_adjustment_for_nv }
+              i = 0.0
+              min_Tin_schedule_defaultDay_times.each do |time|
+                min_Tin_schedule_defaultDay.addValue(time, min_Tin_schedule_defaultDay_values_adjusted[i])
+                i += 1.0
+              end
+
+
+            end
+          end
+        end
+
+        ##### Calculate how many windows a space has.
+        # The total number of windows is used to divide OA/person and OA/FloorArea of the space by it (i.e. number of windows).
+        # In this way, NV-driven OA in each space would be avoided to be more than required.
+        space.surfaces.sort.each do |surface|
+          surface.subSurfaces.sort.each do |subsurface|
+            if (subsurface.subSurfaceType == 'OperableWindow' || subsurface.subSurfaceType == 'FixedWindow') && subsurface.outsideBoundaryCondition == 'Outdoors'
+              number_of_windows += 1.0
+            end
+          end
+        end
+        oa_per_person_normalized_by_number_of_windows = outdoor_air_flow_per_person/number_of_windows
+        oa_per_floor_area_normalized_by_number_of_windows = outdoor_air_flow_per_floor_area/number_of_windows
+
+        ##### Add NV in each space that has window(s) using two objects: "ZoneVentilation:DesignFlowRate" and "ZoneVentilation:WindandStackOpenArea"
+        space.surfaces.sort.each do |surface|
+          surface.subSurfaces.sort.each do |subsurface|
+            if (subsurface.subSurfaceType == 'OperableWindow' || subsurface.subSurfaceType == 'FixedWindow') && subsurface.outsideBoundaryCondition == 'Outdoors'
+              window_azimuth_deg = OpenStudio::convert(subsurface.azimuth,"rad","deg").get
+              window_area = subsurface.netArea
+
+              ##### Define a constant schedule for operable windows
+              operable_window_schedule = OpenStudio::Model::ScheduleConstant.new(model)
+              operable_window_schedule.setName('operable_window_schedule_constant')
+              operable_window_schedule.setScheduleTypeLimits(BTAP::Resources::Schedules::StandardScheduleTypeLimits::get_on_off(model))
+
+              ##### Add a "ZoneVentilation:DesignFlowRate" object for NV to set OA per person.
+              zn_vent_design_flow_rate_1 = OpenStudio::Model::ZoneVentilationDesignFlowRate.new(model)
+              zn_vent_design_flow_rate_1.setDesignFlowRateCalculationMethod('Flow/Person')
+              zn_vent_design_flow_rate_1.setFlowRateperPerson(oa_per_person_normalized_by_number_of_windows)
+              zn_vent_design_flow_rate_1.setVentilationType('Natural')
+              zn_vent_design_flow_rate_1.setMinimumIndoorTemperatureSchedule(min_Tin_schedule)
+              zn_vent_design_flow_rate_1.setMaximumIndoorTemperatureSchedule(max_Tin_schedule)
+              zn_vent_design_flow_rate_1.setMinimumOutdoorTemperature(nv_Tout_min)
+              zn_vent_design_flow_rate_1.setMaximumOutdoorTemperatureSchedule(max_Tin_schedule)
+              zn_vent_design_flow_rate_1.setDeltaTemperature(nv_Delta_Tin_Tout) #E+ I/O Ref.: "This is the temperature difference between the indoor and outdoor air dry-bulb temperatures below which ventilation is shutoff."
+              zone_hvac_equipment_list.addEquipment(zn_vent_design_flow_rate_1)
+
+              ##### Add another "ZoneVentilation:DesignFlowRate" object for NV to set OA per floor area.
+              zn_vent_design_flow_rate_2 = OpenStudio::Model::ZoneVentilationDesignFlowRate.new(model)
+              zn_vent_design_flow_rate_2.setDesignFlowRateCalculationMethod('Flow/Area')
+              zn_vent_design_flow_rate_2.setFlowRateperZoneFloorArea(oa_per_floor_area_normalized_by_number_of_windows)
+              zn_vent_design_flow_rate_2.setVentilationType('Natural')
+              zn_vent_design_flow_rate_2.setMinimumIndoorTemperatureSchedule(min_Tin_schedule)
+              zn_vent_design_flow_rate_2.setMaximumIndoorTemperatureSchedule(max_Tin_schedule)
+              zn_vent_design_flow_rate_2.setMinimumOutdoorTemperature(nv_Tout_min)
+              zn_vent_design_flow_rate_2.setMaximumOutdoorTemperatureSchedule(max_Tin_schedule)
+              zn_vent_design_flow_rate_2.setDeltaTemperature(nv_Delta_Tin_Tout)
+              zone_hvac_equipment_list.addEquipment(zn_vent_design_flow_rate_2)
+
+              ##### Add the "ZoneVentilation:WindandStackOpenArea" for NV.
+              # Note: it has been assumed that 'Opening Effectiveness' and 'Discharge Coefficient for Opening' are autocalculated (which are the default assumptions).
+              zn_vent_wind_and_stack = OpenStudio::Model::ZoneVentilationWindandStackOpenArea.new(model)
+              zn_vent_wind_and_stack.setOpeningArea(window_area * nv_opening_fraction)
+              zn_vent_wind_and_stack.setOpeningAreaFractionSchedule(operable_window_schedule)
+              # (Ref: E+ I/O) The Effective Angle value "is used to calculate the angle between the wind direction and the opening outward normal to determine the opening effectiveness values when the input field Opening Effectiveness = Autocalculate."
+              # (Ref: E+ I/O) "Effective Angle is the angle in degrees counting from the North clockwise to the opening outward normal."
+              zn_vent_wind_and_stack.setEffectiveAngle(window_azimuth_deg)
+              zn_vent_wind_and_stack.setMinimumIndoorTemperatureSchedule(min_Tin_schedule)
+              zn_vent_wind_and_stack.setMaximumIndoorTemperatureSchedule(max_Tin_schedule)
+              zn_vent_wind_and_stack.setMinimumOutdoorTemperature(nv_Tout_min)
+              zn_vent_wind_and_stack.setMaximumOutdoorTemperatureSchedule(max_Tin_schedule)
+              zn_vent_wind_and_stack.setDeltaTemperature(nv_Delta_Tin_Tout)
+              zone_hvac_equipment_list.addEquipment(zn_vent_wind_and_stack)
+
+            end #if (subsurface.subSurfaceType == 'OperableWindow' || subsurface.subSurfaceType == 'FixedWindow') && subsurface.outsideBoundaryCondition == 'Outdoors'
+          end #surface.subSurfaces.sort.each do |subsurface|
+        end #space.surfaces.sort.each do |surface|
+
+
+      end #thermal_zone.spaces.sort.each do |space|
+
+    end #model.getZoneHVACEquipmentLists.sort.each do |zone_hvac_equipment_list|
+
+    ##### Add AvailabilityManagerHybridVentilation to "prevents simultaneous natural ventilation and HVAC system operation" (Ref: E+ I/O)
+    model.getAirLoopHVACs.sort.each do |air_loop|
+      air_loop.availabilityManagers.sort.each do |avail_mgr|
+        if avail_mgr.to_AvailabilityManagerHybridVentilation.empty?
+          avail_mgr_hybr_vent = OpenStudio::Model::AvailabilityManagerHybridVentilation.new(model)
+          avail_mgr_hybr_vent.setMinimumOutdoorTemperature(nv_Tout_min) #Note: since "Ventilation Control Mode" is by default set to "Temperature (i.e. 1)", only min and max Tout are needed. (see E+ I/O Ref.)  #Note: Tout_min is to avoid overcooling (see E+ I/O Ref).
+          avail_mgr_hybr_vent.setMaximumOutdoorTemperature(30.0) #Note: the AvailabilityManagerHybridVentilation obj does not have a schedule field for Tout, so it has been set to a fixed value of 30C.
+          air_loop.addAvailabilityManager(avail_mgr_hybr_vent)
+        end
+      end
+    end
+
+  end
+
+end