openstudio-standards 0.2.12.rc5 → 0.2.13

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

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

@@ -0,0 +1,104 @@
+class ECMS
+
+  def apply_pv_ground(model:, pv_ground_type:, pv_ground_total_area_pv_panels_m2:, pv_ground_tilt_angle:, pv_ground_azimuth_angle:, pv_ground_module_description:)
+
+    ##### Remove leading or trailing whitespace in case users add them in inputs
+    if pv_ground_total_area_pv_panels_m2.instance_of?(String)
+      pv_ground_total_area_pv_panels_m2 = pv_ground_total_area_pv_panels_m2.strip
+    end
+    if pv_ground_tilt_angle.instance_of?(String)
+      pv_ground_tilt_angle = pv_ground_tilt_angle.strip
+    end
+    if pv_ground_azimuth_angle.instance_of?(String)
+      pv_ground_azimuth_angle = pv_ground_azimuth_angle.strip
+    end
+
+    ##### If any of users' inputs are nil/false do nothing.
+    return if pv_ground_type.nil? || pv_ground_type == false || pv_ground_type == 'none' || pv_ground_type == 'NECB_Default'
+    return if pv_ground_total_area_pv_panels_m2 == nil? || pv_ground_total_area_pv_panels_m2 == false || pv_ground_total_area_pv_panels_m2 == 'none'
+    return if pv_ground_tilt_angle == nil? || pv_ground_tilt_angle == false || pv_ground_tilt_angle == 'none'
+    return if pv_ground_azimuth_angle == nil? || pv_ground_azimuth_angle == false || pv_ground_azimuth_angle == 'none'
+    return if pv_ground_module_description == nil? || pv_ground_module_description == false || pv_ground_module_description == 'none'
+
+    ##### Convert a string to a float (except for pv_ground_type and pv_ground_module_description)
+    if pv_ground_total_area_pv_panels_m2.instance_of?(String) && pv_ground_total_area_pv_panels_m2 != 'NECB_Default'
+      pv_ground_total_area_pv_panels_m2 = pv_ground_total_area_pv_panels_m2.to_f
+    end
+    if pv_ground_tilt_angle.instance_of?(String) && pv_ground_tilt_angle != 'NECB_Default'
+      pv_ground_tilt_angle = pv_ground_tilt_angle.to_f
+    end
+    if pv_ground_azimuth_angle.instance_of?(String) && pv_ground_azimuth_angle != 'NECB_Default'
+      pv_ground_azimuth_angle = pv_ground_azimuth_angle.to_f
+    end
+
+    ##### Calculate footprint of the building model (this is used as default value for pv_ground_total_area_pv_panels_m2)
+    building_footprint_m2_array = []
+    lowest_floor = 10000000000.0 #dummy number as initialization to find the lowest floor among spaces #TODO: Question:it it fine that it has been assumed that the floor of all lowest spaces are at the same level?
+    model.getSpaces.sort.each do |space|
+      space.surfaces.sort.select{ |surface| (surface.surfaceType == 'Floor') &&  (surface.outsideBoundaryCondition != 'Surface') &&  (surface.outsideBoundaryCondition != 'Adiabatic')}.each do |surface|
+        floor_vertices = surface.vertices
+        floor_z = floor_vertices[0].z.round(1)
+        if floor_z <= lowest_floor
+          lowest_floor = floor_z
+          building_footprint_m2_array << surface.netArea
+        end
+      end
+    end
+    building_footprint_m2 = building_footprint_m2_array.sum
+    puts "building_footprint_m2 is #{building_footprint_m2}"
+
+    ##### Set default PV panels' total area as the building footprint
+    if pv_ground_total_area_pv_panels_m2 == 'NECB_Default'
+      pv_ground_total_area_pv_panels_m2 = building_footprint_m2
+    end
+
+    ##### Set default PV panels' tilt angle as the latitude
+    if pv_ground_tilt_angle == 'NECB_Default'
+      epw = BTAP::Environment::WeatherFile.new(model.weatherFile.get.path.get)
+      pv_ground_tilt_angle = epw.latitude.to_f
+    end
+
+    ##### Set default PV panels' azimuth angle as south-facing arrays
+    if pv_ground_azimuth_angle == 'NECB_Default'
+      pv_ground_azimuth_angle = 180 # EnergyPlus I/O Reference: "An azimuth angle of 180° is for a south-facing array, and an azimuth angle of 0° is for a north-facing array."
+    end
+
+    ##### Set default PV module type as the the below one
+    if pv_ground_module_description == 'NECB_Default'
+      pv_ground_module_description = 'HES-160-36PV 26.6  x 58.3 x 1.38' # Note: As per Mike Lubun's comment, assuming a typical panel is 5 ft x 2 ft, the closest standard type PV panel in the spreadsheet would be the 160W HES.
+    end
+
+    ##### Calculate number of PV panels
+    # Note: assuming 5 ft x 2 ft as PV panel's size since it seems to fit the racking system used for ground mounts as per Mike Lubun's comment.
+    pv_area_each_ft2 = 5.0 * 2.0
+    pv_area_each_m2 = (OpenStudio.convert(pv_area_each_ft2, 'ft^2', 'm^2').get) #convert pv_area_each_ft2 to m2
+    pv_number_panels = pv_ground_total_area_pv_panels_m2/pv_area_each_m2
+
+    ##### Get data of the PV panel from the json file
+    pv_info = @standards_data['tables']['pv']['table'].detect { |item| item['pv_module_description'] == pv_ground_module_description }
+    pv_ground_module_type = pv_info['pv_module_type']
+    pv_watt = pv_info['pv_module_wattage']
+
+    ##### Create the generator
+    # Assuming one PVWatts generator in E+ as per Mike Lubun's comment for simplification, however exact number of PVWatts generators (and inverters) are calculated for costing.
+    dc_system_capacity = pv_number_panels * pv_watt
+    generator = OpenStudio::Model::GeneratorPVWatts.new(model,dc_system_capacity)
+    generator.setModuleType(pv_ground_module_type)
+    generator.setArrayType('OneAxis')   # Note: "tilt and azimuth are fixed" for this array type (see E+ I/O Reference). This array type has been chosen as per Mike Lubun's costing spec.
+    generator.setTiltAngle(pv_ground_tilt_angle)
+    generator.setAzimuthAngle(pv_ground_azimuth_angle)
+
+    ##### Create the inverter
+    inverter = OpenStudio::Model::ElectricLoadCenterInverterPVWatts.new(model)
+    inverter.setDCToACSizeRatio(1.1) # Note: This is EnergyPlus' default value; This default value has been chosen for ground-mounted PV, assuming no storage as per Mike Lubun's costing spec.
+    inverter.setInverterEfficiency(0.96) # Note: This is EnergyPlus' default value; This default value has been chosen as per Mike Lubun's costing spec.
+
+    ##### Get distribution systems and set relevant parameters
+    model.getElectricLoadCenterDistributions.sort.each  do |elc_distribution|
+      elc_distribution.setInverter(inverter)
+      elc_distribution.setGeneratorOperationSchemeType('Baseload')  # E+ I/O Reference: "The Baseload scheme requests all generators scheduled ON (available) to operate, even if the amount of electric power generated exceeds the total facility electric power demand." This scheme type has been chosen as per Mike Lubun's costing spec.
+    end
+
+  end
+
+end