openstudio-standards 0.2.16 → 0.2.17.rc2

data/lib/openstudio-standards/standards/Standards.AirLoopHVAC.rb

@@ -75,7 +75,8 @@ class Standard
           plr_req = fan_variable_volume_part_load_fan_power_limitation?(fan)
           # Part Load Fan Pressure Control
           if plr_req
-            fan_variable_volume_set_control_type(fan, 'Multi Zone VAV with VSD and SP Setpoint Reset')
+            vsd_curve_type = air_loop_hvac_set_vsd_curve_type
+            fan_variable_volume_set_control_type(fan, vsd_curve_type)
           # No Part Load Fan Pressure Control
           else
             fan_variable_volume_set_control_type(fan, 'Multi Zone VAV with discharge dampers')
@@ -194,6 +195,12 @@ class Standard
     # Economizers
     if air_loop_hvac_prm_baseline_economizer_required?(air_loop_hvac, climate_zone)
       air_loop_hvac_apply_prm_baseline_economizer(air_loop_hvac, climate_zone)
+    else
+      # Make sure if economizer is not required then the OA controller should have No Economizer
+      oa_sys = air_loop_hvac.airLoopHVACOutdoorAirSystem
+      if oa_sys.is_initialized
+        oa_sys.get.getControllerOutdoorAir.setEconomizerControlType('NoEconomizer')
+      end
     end
 
     # Multizone VAV Systems
@@ -216,7 +223,8 @@ class Standard
     end
 
     # Unoccupied shutdown
-    air_loop_hvac_enable_unoccupied_fan_shutoff(air_loop_hvac)
+    occ_threshold = air_loop_hvac_unoccupied_threshold
+    air_loop_hvac_enable_unoccupied_fan_shutoff(air_loop_hvac, occ_threshold)
 
     return true
   end
@@ -349,6 +357,12 @@ class Standard
     return true
   end
 
+  # Set default fan curve to be VSD with static pressure reset
+  # @return [string] name of appropriate curve for this code version
+  def air_loop_hvac_set_vsd_curve_type
+    return 'Multi Zone VAV with VSD and SP Setpoint Reset'
+  end
+
   # Calculate and apply the performance rating method baseline fan power to this air loop.
   # Fan motor efficiency will be set, and then fan pressure rise adjusted so that the
   # fan power is the maximum allowable.
@@ -1128,7 +1142,7 @@ class Standard
   # Determine if the airloop includes hydronic cooling coils
   #
   # @param air_loop_hvac [OpenStudio::Model::AirLoopHVAC] air loop
-  # @return [Bool] returns true if hydronic coolings coils are included on the airloop
+  # @return [Bool] returns true if hydronic cooling coils are included on the airloop
   def air_loop_hvac_include_hydronic_cooling_coil?(air_loop_hvac)
     air_loop_hvac.supplyComponents.each do |comp|
       return true if comp.to_CoilCoolingWater.is_initialized
@@ -1136,6 +1150,82 @@ class Standard
     return false
   end
 
+  # Determine if the airloop includes cooling coils
+  #
+  # @return [Bool] returns true if cooling coils are included on the airloop
+  def air_loop_hvac_include_cooling_coil?(air_loop_hvac)
+    air_loop_hvac.supplyComponents.each do |comp|
+      return true if comp.to_CoilCoolingWater.is_initialized
+      return true if comp.to_CoilCoolingWater.is_initialized
+      return true if comp.to_CoilCoolingCooledBeam.is_initialized
+      return true if comp.to_CoilCoolingDXMultiSpeed.is_initialized
+      return true if comp.to_CoilCoolingDXSingleSpeed.is_initialized
+      return true if comp.to_CoilCoolingDXTwoSpeed.is_initialized
+      return true if comp.to_CoilCoolingDXTwoStageWithHumidityControlMode.is_initialized
+      return true if comp.to_CoilCoolingDXVariableRefrigerantFlow.is_initialized
+      return true if comp.to_CoilCoolingDXVariableSpeed.is_initialized
+      return true if comp.to_CoilCoolingFourPipeBeam.is_initialized
+      return true if comp.to_CoilCoolingLowTempRadiantConstFlow.is_initialized
+      return true if comp.to_CoilCoolingLowTempRadiantVarFlow.is_initialized
+      return true if comp.to_CoilCoolingWater.is_initialized
+      return true if comp.to_CoilCoolingWaterToAirHeatPumpEquationFit.is_initialized
+      return true if comp.to_CoilCoolingWaterToAirHeatPumpVariableSpeedEquationFit.is_initialized
+
+      if comp.to_AirLoopHVACUnitarySystem.is_initialized
+        unitary_system = comp.to_AirLoopHVACUnitarySystem.get
+        if unitary_system.coolingCoil.is_initialized
+          cooling_coil = unitary_system.coolingCoil.get
+          return true if cooling_coil.to_CoilCoolingWater.is_initialized
+          return true if cooling_coil.to_CoilCoolingWater.is_initialized
+          return true if cooling_coil.to_CoilCoolingCooledBeam.is_initialized
+          return true if cooling_coil.to_CoilCoolingDXMultiSpeed.is_initialized
+          return true if cooling_coil.to_CoilCoolingDXSingleSpeed.is_initialized
+          return true if cooling_coil.to_CoilCoolingDXTwoSpeed.is_initialized
+          return true if cooling_coil.to_CoilCoolingDXTwoStageWithHumidityControlMode.is_initialized
+          return true if cooling_coil.to_CoilCoolingDXVariableRefrigerantFlow.is_initialized
+          return true if cooling_coil.to_CoilCoolingDXVariableSpeed.is_initialized
+          return true if cooling_coil.to_CoilCoolingFourPipeBeam.is_initialized
+          return true if cooling_coil.to_CoilCoolingLowTempRadiantConstFlow.is_initialized
+          return true if cooling_coil.to_CoilCoolingLowTempRadiantVarFlow.is_initialized
+          return true if cooling_coil.to_CoilCoolingWater.is_initialized
+          return true if cooling_coil.to_CoilCoolingWaterToAirHeatPumpEquationFit.is_initialized
+          return true if cooling_coil.to_CoilCoolingWaterToAirHeatPumpVariableSpeedEquationFit.is_initialized
+        end
+      end
+    end
+    return false
+  end
+
+  # Determine if the airloop includes evaporative coolers
+  #
+  # @return [Bool] returns true if evaporative coolers are included on the airloop
+  def air_loop_hvac_include_evaporative_cooler?(air_loop_hvac)
+    air_loop_hvac.supplyComponents.each do |comp|
+      return true if comp.to_EvaporativeCoolerDirectResearchSpecial.is_initialized
+      return true if comp.to_EvaporativeCoolerIndirectResearchSpecial.is_initialized
+    end
+    return false
+  end
+
+  # Determine if the airloop includes an air-economizer
+  #
+  # @return [Bool] returns true if the airloop has an air-economizer
+  def air_loop_hvac_include_economizer?(air_loop_hvac)
+    return false unless air_loop_hvac.airLoopHVACOutdoorAirSystem.is_initialized
+
+    # Get OA system
+    air_loop_hvac_oa_system = air_loop_hvac.airLoopHVACOutdoorAirSystem.get
+
+    # Get OA controller
+    air_loop_hvac_oa_controller = air_loop_hvac_oa_system.getControllerOutdoorAir
+
+    # Get economizer type
+    economizer_type = air_loop_hvac_oa_controller.getEconomizerControlType.to_s
+    return false if economizer_type == 'NoEconomizer'
+
+    return true
+  end
+
   # Determine if the airloop includes WSHP cooling coils
   #
   # @param air_loop_hvac [OpenStudio::Model::AirLoopHVAC] air loop
@@ -1805,7 +1895,11 @@ class Standard
       oa_system = air_loop_hvac.airLoopHVACOutdoorAirSystem.get
       controller_oa = oa_system.getControllerOutdoorAir
       controller_mv = controller_oa.controllerMechanicalVentilation
-      controller_mv.setSystemOutdoorAirMethod('VentilationRateProcedure')
+      if air_loop_hvac.model.version < OpenStudio::VersionString.new('3.3.0')
+        controller_mv.setSystemOutdoorAirMethod('VentilationRateProcedure')
+      else
+        controller_mv.setSystemOutdoorAirMethod('Standard62.1VentilationRateProcedureWithLimit')
+      end
       # Change the min flow rate in the controller outdoor air
       controller_oa.setMinimumOutdoorAirFlowRate(0.0)
     else
@@ -1834,6 +1928,16 @@ class Standard
     end
   end
 
+  # Determine minimum ventilation efficiency for zones.
+  # This is used to decrease the overall system minimum OA flow rate
+  # such that a few zones do not drive the overall system OA flow rate too
+  # high.
+  def air_loop_hvac_minimum_zone_ventilation_efficiency(air_loop_hvac)
+    min_ventilation_efficiency = 0.6
+
+    return min_ventilation_efficiency
+  end
+
   # Set the minimum VAV damper positions.
   #
   # @param air_loop_hvac [OpenStudio::Model::AirLoopHVAC] air loop
@@ -3159,11 +3263,26 @@ class Standard
     return 0.15
   end
 
+  # Determine if the air loop serves parallel PIU air terminals
+  #
+  # @param air_loop_hvac [OpenStudio::Model::AirLoopHVAC] air loop
+  def air_loop_hvac_has_parallel_piu_air_terminals?(air_loop_hvac)
+    has_parallel_piu_terminals = false
+    air_loop_hvac.thermalZones.each do |zone|
+      zone.equipment.each do |equipment|
+        # Get the object type
+        obj_type = equipment.iddObjectType.valueName.to_s
+        if obj_type == 'OS_AirTerminal_SingleDuct_ParallelPIU_Reheat'
+          return true
+        end
+      end
+    end
+
+    return has_parallel_piu_terminals
+  end
+
   # Shut off the system during unoccupied periods.
   # During these times, systems will cycle on briefly if temperature drifts below setpoint.
-  # For systems with fan-powered terminals, the whole system (not just the terminal fans) will cycle on.
-  # Terminal-only night cycling is not used because the terminals cannot provide cooling,
-  # so terminal-only night cycling leads to excessive unmet cooling hours during unoccupied periods.
   # If the system already has a schedule other than Always-On, no change will be made.
   # If the system has an Always-On schedule assigned, a new schedule will be created.
   # In this case, occupied is defined as the total percent occupancy for the loop for all zones served.
@@ -3173,7 +3292,37 @@ class Standard
   # @return [Bool] returns true if successful, false if not
   def air_loop_hvac_enable_unoccupied_fan_shutoff(air_loop_hvac, min_occ_pct = 0.05)
     # Set the system to night cycle
+    # The fan of a parallel PIU terminal are set to only cycle during heating operation
+    # This is achieved using the CycleOnAnyCoolingOrHeatingZone; During cooling operation
+    # the load is met by running the central system which stays off during heating
+    # operation
     air_loop_hvac.setNightCycleControlType('CycleOnAny')
+    if air_loop_hvac_has_parallel_piu_air_terminals?(air_loop_hvac)
+      avail_mgrs = air_loop_hvac.availabilityManagers
+      if !avail_mgrs.nil?
+        avail_mgrs.each do |avail_mgr|
+          if avail_mgr.to_AvailabilityManagerNightCycle.is_initialized
+            avail_mgr_nc = avail_mgr.to_AvailabilityManagerNightCycle.get
+            avail_mgr_nc.setControlType('CycleOnAnyCoolingOrHeatingZone')
+            zones = air_loop_hvac.thermalZones
+            avail_mgr_nc.setCoolingControlThermalZones(zones)
+            avail_mgr_nc.setHeatingZoneFansOnlyThermalZones(zones)
+          end
+        end
+      end
+    end
+
+    model = air_loop_hvac.model
+    # Check if schedule was stored in an additionalProperties field of the air loop
+    air_loop_name = air_loop_hvac.name
+    if air_loop_hvac.hasAdditionalProperties
+      if air_loop_hvac.additionalProperties.hasFeature('fan_sched_name')
+        fan_sched_name = air_loop_hvac.additionalProperties.getFeatureAsString('fan_sched_name').get
+        fan_sched = model.getScheduleRulesetByName(fan_sched_name).get
+        air_loop_hvac.setAvailabilitySchedule(fan_sched)
+        return true
+      end
+    end
 
     # Check if already using a schedule other than always on
     avail_sch = air_loop_hvac.availabilitySchedule
@@ -3534,6 +3683,118 @@ class Standard
     return dx_clg
   end
 
+  # Get return fan power for airloop
+  #
+  # @param model [OpenStudio::model::AirLoopHVAC] AirLoopHVAC object
+  # @return [Float] Fan power
+  def air_loop_hvac_get_return_fan_power(air_loop)
+    return_fan_power = 0
+
+    if air_loop.returnFan.is_initialized
+      # Get return fan
+      fan = air_loop.returnFan.get
+
+      # Get fan object
+      if fan.to_FanConstantVolume.is_initialized
+        fan = fan.to_FanConstantVolume.get
+      elsif fan.to_FanVariableVolume.is_initialized
+        fan = fan.to_FanVariableVolume.get
+      elsif fan.to_FanOnOff.is_initialized
+        fan = fan.to_FanOnOff.get
+      end
+
+      # Get fan power
+      return_fan_power += fan_fanpower(fan)
+    end
+
+    return return_fan_power
+  end
+
+  # Get supply fan power for airloop
+  #
+  # @param model [OpenStudio::model::AirLoopHVAC] AirLoopHVAC object
+  # @return [Float] Fan power
+  def air_loop_hvac_get_supply_fan_power(air_loop)
+    supply_fan_power = 0
+
+    # Get fan
+    fan = air_loop_hvac_get_supply_fan(air_loop)
+
+    if !fan.nil?
+      # Get fan power
+      supply_fan_power += fan_fanpower(fan)
+    end
+
+    return supply_fan_power
+  end
+
+  # Get supply fan for airloop
+  #
+  # @param model [OpenStudio::model::AirLoopHVAC] AirLoopHVAC object
+  # @return fan
+  def air_loop_hvac_get_supply_fan(air_loop)
+    fan = nil
+    if air_loop.supplyFan.is_initialized
+      # Get return fan
+      fan = air_loop.supplyFan.get
+
+      # Get fan object
+      if fan.to_FanConstantVolume.is_initialized
+        fan = fan.to_FanConstantVolume.get
+      elsif fan.to_FanVariableVolume.is_initialized
+        fan = fan.to_FanVariableVolume.get
+      elsif fan.to_FanOnOff.is_initialized
+        fan = fan.to_FanOnOff.get
+      end
+
+    else
+      air_loop.supplyComponents.each do |comp|
+        if comp.to_AirLoopHVACUnitarySystem.is_initialized
+          fan = comp.to_AirLoopHVACUnitarySystem.get.supplyFan
+          next if fan.empty?
+
+          # Get fan object
+          fan = fan.get
+          if fan.to_FanConstantVolume.is_initialized
+            fan = fan.to_FanConstantVolume.get
+          elsif fan.to_FanVariableVolume.is_initialized
+            fan = fan.to_FanVariableVolume.get
+          elsif fan.to_FanOnOff.is_initialized
+            fan = fan.to_FanOnOff.get
+          end
+        end
+      end
+    end
+    return fan
+  end
+
+  # Get relief fan power for airloop
+  #
+  # @param model [OpenStudio::model::AirLoopHVAC] AirLoopHVAC object
+  # @return [Float] Fan power
+  def air_loop_hvac_get_relief_fan_power(air_loop)
+    relief_fan_power = 0
+
+    if air_loop.reliefFan.is_initialized
+      # Get return fan
+      fan = air_loop.reliefFan.get
+
+      # Get fan object
+      if fan.to_FanConstantVolume.is_initialized
+        fan = fan.to_FanConstantVolume.get
+      elsif fan.to_FanVariableVolume.is_initialized
+        fan = fan.to_FanVariableVolume.get
+      elsif fan.to_FanOnOff.is_initialized
+        fan = fan.to_FanOnOff.get
+      end
+
+      # Get fan power
+      relief_fan_power += fan_fanpower(fan)
+    end
+
+    return relief_fan_power
+  end
+
   # Add occupant standby controls to air loop
   # When the thermostat schedule is setup or setback
   # the ventilation is shutoff. Currently this is done
@@ -3584,4 +3845,30 @@ class Standard
     end
     return simple_transfer_air
   end
+
+  # Get the return air plenum zone object for an air loop, if it exists
+  #
+  # @param air_loop_hvac [OpenStudio::Model::AirLoopHVAC] OpenStudio AirLoopHVAC object
+  # @return [OpenStudio::Model::ThermalZone] OpenStudio thermal zone object of the return air plenum zone
+  #                                          when an air loop uses a return air plenum, nil otherwise
+  def air_loop_hvac_return_air_plenum(air_loop_hvac)
+    # Get return air node
+    return_air_node = air_loop_hvac.demandOutletNode
+
+    # Check if node is connected to a return plenum object
+    air_loop_hvac.model.getAirLoopHVACReturnPlenums.each do |return_plenum|
+      air_loop_hvac.model.getAirLoopHVACZoneMixers.each do |zone_air_mixer|
+        inlets = zone_air_mixer.inletModelObjects
+        inlets.each do |inlet|
+          if inlet.to_Node.get == return_plenum.outletModelObject.get.to_Node.get
+            if zone_air_mixer.outletModelObject.get.to_Node.get == return_air_node
+              return return_plenum.thermalZone.get
+            end
+          end
+        end
+      end
+    end
+
+    return nil
+  end
 end

data/lib/openstudio-standards/standards/Standards.AirTerminalSingleDuctParallelPIUReheat.rb

@@ -11,9 +11,14 @@ class Standard
     # Determine the fan sizing flow rate, min flow rate,
     # and W/cfm
     sec_flow_frac = 0.5
-    min_flow_frac = 0.3
+    min_flow_frac = air_terminal_single_duct_parallel_reheat_piu_minimum_primary_airflow_fraction(air_terminal_single_duct_parallel_piu_reheat)
     fan_efficacy_w_per_cfm = 0.35
 
+    # Set the fan on flow fraction
+    unless air_terminal_single_duct_parallel_piu_reheat_fan_on_flow_fraction.nil?
+      air_terminal_single_duct_parallel_piu_reheat.setFanOnFlowFraction(air_terminal_single_duct_parallel_piu_reheat_fan_on_flow_fraction)
+    end
+
     # Convert efficacy to metric
     # 1 cfm = 0.0004719 m^3/s
     fan_efficacy_w_per_m3_per_s = fan_efficacy_w_per_cfm / 0.0004719
@@ -32,7 +37,6 @@ class Standard
     max_sec_flow_rate_cfm = OpenStudio.convert(max_sec_flow_rate_m3_per_s, 'm^3/s', 'ft^3/min').get
 
     # Set the minimum flow fraction
-    # @todo Also compare to min OA requirement
     air_terminal_single_duct_parallel_piu_reheat.setMinimumPrimaryAirFlowFraction(min_flow_frac)
 
     # Get the fan
@@ -58,4 +62,48 @@ class Standard
 
     return true
   end
+
+  # Return the fan on flow fraction for a parallel PIU terminal.
+  #
+  # When returning nil, the fan on flow fraction will be set to
+  # be autosize in the EnergyPlus model; OpenStudio assumes that
+  # the default is "autosize". When autosized, this input is set
+  # to be the same as the minimum primary air flow fraction which
+  # means that the secondary fan will be on when the primary air
+  # flow is at the minimum flow fraction.
+  #
+  # @return [Float] returns nil or a float representing the fraction
+  def air_terminal_single_duct_parallel_piu_reheat_fan_on_flow_fraction
+    return nil
+  end
+
+  # Specifies the minimum primary air flow fraction for PFB boxes.
+  #
+  # @param air_terminal_single_duct_parallel_piu_reheat [OpenStudio::Model::AirTerminalSingleDuctParallelPIUReheat] air terminal object
+  # @return [Double] minimum primaru air flow fraction
+  def air_terminal_single_duct_parallel_reheat_piu_minimum_primary_airflow_fraction(air_terminal_single_duct_parallel_piu_reheat)
+    min_primary_airflow_fraction = 0.3
+    return min_primary_airflow_fraction
+  end
+
+  # Set the minimum primary air flow fraction based on OA rate of the space and the template.
+  #
+  # @param air_terminal_single_duct_parallel_piu_reheat [OpenStudio::Model::AirTerminalSingleDuctParallelPIUReheat] the air terminal object
+  # @param zone_min_oa [Double] the zone outdoor air flow rate, in m^3/s.
+  # @return [Bool] returns true if successful, false if not
+  def air_terminal_single_duct_parallel_piu_reheat_apply_minimum_primary_airflow_fraction(air_terminal_single_duct_parallel_piu_reheat, zone_min_oa = nil)
+    # Minimum primary air flow
+    min_primary_airflow_frac = air_terminal_single_duct_parallel_reheat_piu_minimum_primary_airflow_fraction(air_terminal_single_duct_parallel_piu_reheat)
+    air_terminal_single_duct_parallel_piu_reheat.setMinimumPrimaryAirFlowFraction(min_primary_airflow_frac)
+    OpenStudio.logFree(OpenStudio::Debug, 'openstudio.standards.AirTerminalSingleDuctParallelPIUReheat', "For #{air_terminal_single_duct_parallel_piu_reheat.name}: set minimum primary air flow fraction to #{min_primary_airflow_frac}.")
+
+    # Minimum OA flow rate
+    # If specified, set the primary air flow fraction as
+    unless zone_min_oa.nil?
+      min_primary_airflow_frac = [min_primary_airflow_frac, zone_min_oa / air_terminal_single_duct_parallel_piu_reheat.autosizedMaximumPrimaryAirFlowRate.get].max
+      air_terminal_single_duct_parallel_piu_reheat.setMinimumPrimaryAirFlowFraction(min_primary_airflow_frac)
+    end
+
+    return true
+  end
 end

data/lib/openstudio-standards/standards/Standards.ChillerElectricEIR.rb

@@ -25,11 +25,15 @@ class Standard
     name = chiller_electric_eir.name.get
     condenser_type = nil
     compressor_type = nil
+    absorption_type = nil
     if cooling_type == 'AirCooled'
       if name.include?('WithCondenser')
         condenser_type = 'WithCondenser'
       elsif name.include?('WithoutCondenser')
         condenser_type = 'WithoutCondenser'
+      else
+        # default to 'WithCondenser' if not an absorption chiller
+        condenser_type = 'WithCondenser' if absorption_type.nil?
       end
     elsif cooling_type == 'WaterCooled'
       if name.include?('Reciprocating')

data/lib/openstudio-standards/standards/Standards.CoilCoolingWaterToAirHeatPumpEquationFit.rb

@@ -103,7 +103,6 @@ class Standard
   # @param sql_db_vars_map [Hash] hash map
   # @return [Hash] hash of coil objects
   def coil_cooling_water_to_air_heat_pump_apply_efficiency_and_curves(coil_cooling_water_to_air_heat_pump, sql_db_vars_map)
-
     # Get the search criteria
     search_criteria = {}
     search_criteria['template'] = template