openstudio-standards 0.2.16 → 0.2.17.rc1

data/lib/openstudio-standards/prototypes/common/objects/Prototype.Fan.rb

@@ -174,6 +174,7 @@ module PrototypeFan
                                   motor_in_airstream_fraction: motor_in_airstream_fraction,
                                   end_use_subcategory: end_use_subcategory)
     elsif fan_json['type'] == 'VariableVolume'
+      fan_power_coefficient_1, fan_power_coefficient_2, fan_power_coefficient_3, fan_power_coefficient_4, fan_power_coefficient_5 = lookup_fan_curve_coefficients_from_json(fan_json['fan_curve']) if fan_json['fan_curve']
       create_fan_variable_volume_from_json(model,
                                            fan_json,
                                            fan_name: fan_name,
@@ -199,4 +200,15 @@ module PrototypeFan
                                         end_use_subcategory: end_use_subcategory)
     end
   end
+
+  # Lookup fan curve coefficients
+  #
+  # @param fan_curve [String] name of the fan curve
+  # @return [Array] an array of fan curve coefficients
+  def lookup_fan_curve_coefficients_from_json(fan_curve)
+    search_criteria = {}
+    search_criteria['name'] = fan_curve
+    fan_curve = model_find_object(@standards_data['curves'], search_criteria)
+    return [fan_curve['coeff_1'], fan_curve['coeff_2'], fan_curve['coeff_3'], fan_curve['coeff_4'], fan_curve['coeff_5']]
+  end
 end

data/lib/openstudio-standards/prototypes/common/objects/Prototype.Model.rb

@@ -597,7 +597,7 @@ Standard.class_eval do
       next unless surface.surfaceType == 'Wall'
 
       boundary_condition = surface.outsideBoundaryCondition
-      next unless boundary_condition == 'OtherSideCoefficients' || boundary_condition == 'Ground'
+      next unless boundary_condition == 'OtherSideCoefficients' || boundary_condition.to_s.downcase.include?('ground')
 
       # calculate wall height as difference of maximum and minimum z values, assuming square, vertical walls
       z_values = []
@@ -677,7 +677,7 @@ Standard.class_eval do
 
     # Find space's floors
     space.surfaces.each do |surface|
-      if surface.surfaceType == 'Floor' && surface.outsideBoundaryCondition == 'Ground'
+      if surface.surfaceType == 'Floor' && surface.outsideBoundaryCondition.to_s.downcase.include?('ground')
         floors << surface
       end
     end
@@ -1794,7 +1794,7 @@ Standard.class_eval do
   #
   # @param model [OpenStudio::Model::Model] the model
   def model_apply_prototype_hvac_efficiency_adjustments(model)
-    building_data = model_get_building_climate_zone_and_building_type(model)
+    building_data = model_get_building_properties(model)
     building_type = building_data['building_type']
     climate_zone = building_data['climate_zone']
 
@@ -2700,7 +2700,6 @@ Standard.class_eval do
   # @param wwr [Boolean]
   # @return [Numeric] Returns window to wall ratio (percentage) or window area.
   def model_get_window_area_info(model, wwr = true)
-
     window_area = 0
     wall_area = 0
 

data/lib/openstudio-standards/prototypes/common/objects/Prototype.SizingSystem.rb

@@ -62,7 +62,7 @@ class Standard
     air_loop_hvac.thermalZones.sort.each do |zone|
       sizing_zone = zone.sizingZone
       if air_loop_hvac.model.version < OpenStudio::VersionString.new('3.0.0')
-        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.prototype.SizingSystem', "The design minimum zone ventilation efficiency cannot be set for #{sizing_system.name.to_s}. It can only be set OpenStudio 3.0.0 and later.")
+        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.prototype.SizingSystem', "The design minimum zone ventilation efficiency cannot be set for #{sizing_system.name}. It can only be set OpenStudio 3.0.0 and later.")
       else
         sizing_zone.setDesignMinimumZoneVentilationEfficiency(0.6)
       end

data/lib/openstudio-standards/prototypes/common/objects/Prototype.hvac_systems.rb

@@ -226,32 +226,12 @@ class Standard
       chilled_water_loop.setName(system_name)
     end
 
-    # chilled water loop sizing and controls
     if dsgn_sup_wtr_temp.nil?
-      dsgn_sup_wtr_temp = 44.0
-      dsgn_sup_wtr_temp_c = OpenStudio.convert(dsgn_sup_wtr_temp, 'F', 'C').get
-    else
-      dsgn_sup_wtr_temp_c = OpenStudio.convert(dsgn_sup_wtr_temp, 'F', 'C').get
-    end
-    if dsgn_sup_wtr_temp_delt.nil?
-      dsgn_sup_wtr_temp_delt_k = OpenStudio.convert(10.1, 'R', 'K').get
-    else
-      dsgn_sup_wtr_temp_delt_k = OpenStudio.convert(dsgn_sup_wtr_temp_delt, 'R', 'K').get
+      dsgn_sup_wtr_temp = 44
     end
-    chilled_water_loop.setMinimumLoopTemperature(1.0)
-    chilled_water_loop.setMaximumLoopTemperature(40.0)
-    sizing_plant = chilled_water_loop.sizingPlant
-    sizing_plant.setLoopType('Cooling')
-    sizing_plant.setDesignLoopExitTemperature(dsgn_sup_wtr_temp_c)
-    sizing_plant.setLoopDesignTemperatureDifference(dsgn_sup_wtr_temp_delt_k)
-    chw_temp_sch = model_add_constant_schedule_ruleset(model,
-                                                       dsgn_sup_wtr_temp_c,
-                                                       name = "#{chilled_water_loop.name} Temp - #{dsgn_sup_wtr_temp.round(0)}F")
-    chw_stpt_manager = OpenStudio::Model::SetpointManagerScheduled.new(model, chw_temp_sch)
-    chw_stpt_manager.setName("#{chilled_water_loop.name} Setpoint Manager")
-    chw_stpt_manager.addToNode(chilled_water_loop.supplyOutletNode)
-    # @todo Yixing check the CHW Setpoint from standards
-    # @todo Should be a OutdoorAirReset, see the changes I've made in Standards.PlantLoop.apply_prm_baseline_temperatures
+
+    # chilled water loop sizing and controls
+    chw_sizing_control(model, chilled_water_loop, dsgn_sup_wtr_temp, dsgn_sup_wtr_temp_delt)
 
     # create chilled water pumps
     if chw_pumping_type == 'const_pri'
@@ -269,28 +249,86 @@ class Standard
       pri_chw_pump.setPumpControlType('Intermittent')
       pri_chw_pump.addToNode(chilled_water_loop.supplyInletNode)
     elsif chw_pumping_type == 'const_pri_var_sec'
-      # primary chilled water pump
-      pri_chw_pump = OpenStudio::Model::PumpConstantSpeed.new(model)
-      pri_chw_pump.setName("#{chilled_water_loop.name} Primary Pump")
-      pri_chw_pump.setRatedPumpHead(OpenStudio.convert(15.0, 'ftH_{2}O', 'Pa').get)
-      pri_chw_pump.setMotorEfficiency(0.9)
-      pri_chw_pump.setPumpControlType('Intermittent')
-      pri_chw_pump.addToNode(chilled_water_loop.supplyInletNode)
-      # secondary chilled water pump
-      sec_chw_pump = OpenStudio::Model::PumpVariableSpeed.new(model)
-      sec_chw_pump.setName("#{chilled_water_loop.name} Secondary Pump")
-      sec_chw_pump.setRatedPumpHead(OpenStudio.convert(45.0, 'ftH_{2}O', 'Pa').get)
-      sec_chw_pump.setMotorEfficiency(0.9)
-      # curve makes it perform like variable speed pump
-      sec_chw_pump.setFractionofMotorInefficienciestoFluidStream(0)
-      sec_chw_pump.setCoefficient1ofthePartLoadPerformanceCurve(0)
-      sec_chw_pump.setCoefficient2ofthePartLoadPerformanceCurve(0.0205)
-      sec_chw_pump.setCoefficient3ofthePartLoadPerformanceCurve(0.4101)
-      sec_chw_pump.setCoefficient4ofthePartLoadPerformanceCurve(0.5753)
-      sec_chw_pump.setPumpControlType('Intermittent')
-      sec_chw_pump.addToNode(chilled_water_loop.demandInletNode)
-      # Change the chilled water loop to have a two-way common pipes
-      chilled_water_loop.setCommonPipeSimulation('CommonPipe')
+      pri_sec_config = plant_loop_set_chw_pri_sec_configuration(model)
+
+      if pri_sec_config == 'common_pipe'
+        # primary chilled water pump
+        pri_chw_pump = OpenStudio::Model::PumpConstantSpeed.new(model)
+        pri_chw_pump.setName("#{chilled_water_loop.name} Primary Pump")
+        pri_chw_pump.setRatedPumpHead(OpenStudio.convert(15.0, 'ftH_{2}O', 'Pa').get)
+        pri_chw_pump.setMotorEfficiency(0.9)
+        pri_chw_pump.setPumpControlType('Intermittent')
+        pri_chw_pump.addToNode(chilled_water_loop.supplyInletNode)
+        # secondary chilled water pump
+        sec_chw_pump = OpenStudio::Model::PumpVariableSpeed.new(model)
+        sec_chw_pump.setName("#{chilled_water_loop.name} Secondary Pump")
+        sec_chw_pump.setRatedPumpHead(OpenStudio.convert(45.0, 'ftH_{2}O', 'Pa').get)
+        sec_chw_pump.setMotorEfficiency(0.9)
+        # curve makes it perform like variable speed pump
+        sec_chw_pump.setFractionofMotorInefficienciestoFluidStream(0)
+        sec_chw_pump.setCoefficient1ofthePartLoadPerformanceCurve(0)
+        sec_chw_pump.setCoefficient2ofthePartLoadPerformanceCurve(0.0205)
+        sec_chw_pump.setCoefficient3ofthePartLoadPerformanceCurve(0.4101)
+        sec_chw_pump.setCoefficient4ofthePartLoadPerformanceCurve(0.5753)
+        sec_chw_pump.setPumpControlType('Intermittent')
+        sec_chw_pump.addToNode(chilled_water_loop.demandInletNode)
+        # Change the chilled water loop to have a two-way common pipes
+        chilled_water_loop.setCommonPipeSimulation('CommonPipe')
+      elsif pri_sec_config == 'heat_exchanger'
+        # NOTE: PRECONDITIONING for `const_pri_var_sec` pump type is only applicable for PRM routine and only applies to System Type 7 and System Type 8
+        # See: model_add_prm_baseline_system under Model object.
+        # In this scenario, we will need to create a primary and secondary configuration:
+        # chilled_water_loop is the primary loop
+        # Primary: demand: heat exchanger, supply: chillers, name: Chilled Water Loop_Primary, additionalProperty: secondary_loop_name
+        # Secondary: demand: Coils, supply: heat exchanger, name: Chilled Water Loop, additionalProperty: is_secondary_loop
+        secondary_chilled_water_loop = OpenStudio::Model::PlantLoop.new(model)
+        secondary_loop_name = system_name.nil? ? 'Chilled Water Loop' : system_name
+        # Reset primary loop name
+        chilled_water_loop.setName("#{secondary_loop_name}_Primary")
+        secondary_chilled_water_loop.setName(secondary_loop_name)
+        chw_sizing_control(model, secondary_chilled_water_loop, dsgn_sup_wtr_temp, dsgn_sup_wtr_temp_delt)
+        chilled_water_loop.additionalProperties.setFeature('is_primary_loop', true)
+        secondary_chilled_water_loop.additionalProperties.setFeature('is_secondary_loop', true)
+        # primary chilled water pump
+        # Add Constant pump, in plant loop, the number of chiller adjustment will assign pump to each chiller
+        pri_chw_pump = OpenStudio::Model::PumpConstantSpeed.new(model)
+        pri_chw_pump.setName("#{chilled_water_loop.name} Primary Pump")
+        # Will need to adjust the pump power after a sizing run
+        pri_chw_pump.setRatedPumpHead(OpenStudio.convert(15.0, 'ftH_{2}O', 'Pa').get / num_chillers)
+        pri_chw_pump.setMotorEfficiency(0.9)
+        pri_chw_pump.setPumpControlType('Intermittent')
+        # chiller_inlet_node = chiller.connectedObject(chiller.supplyInletPort).get.to_Node.get
+        pri_chw_pump.addToNode(chilled_water_loop.supplyInletNode)
+
+        # secondary chilled water pump
+        sec_chw_pump = OpenStudio::Model::PumpVariableSpeed.new(model)
+        sec_chw_pump.setName("#{secondary_chilled_water_loop.name} Pump")
+        sec_chw_pump.setRatedPumpHead(OpenStudio.convert(45.0, 'ftH_{2}O', 'Pa').get)
+        sec_chw_pump.setMotorEfficiency(0.9)
+        # curve makes it perform like variable speed pump
+        sec_chw_pump.setFractionofMotorInefficienciestoFluidStream(0)
+        sec_chw_pump.setCoefficient1ofthePartLoadPerformanceCurve(0)
+        sec_chw_pump.setCoefficient2ofthePartLoadPerformanceCurve(0.0205)
+        sec_chw_pump.setCoefficient3ofthePartLoadPerformanceCurve(0.4101)
+        sec_chw_pump.setCoefficient4ofthePartLoadPerformanceCurve(0.5753)
+        sec_chw_pump.setPumpControlType('Intermittent')
+        sec_chw_pump.addToNode(secondary_chilled_water_loop.demandInletNode)
+
+        # Add HX to connect secondary and primary loop
+        heat_exchanger = OpenStudio::Model::HeatExchangerFluidToFluid.new(model)
+        secondary_chilled_water_loop.addSupplyBranchForComponent(heat_exchanger)
+        chilled_water_loop.addDemandBranchForComponent(heat_exchanger)
+
+        # Clean up connections
+        hx_bypass_pipe = OpenStudio::Model::PipeAdiabatic.new(model)
+        hx_bypass_pipe.setName("#{secondary_chilled_water_loop.name} HX Bypass")
+        secondary_chilled_water_loop.addSupplyBranchForComponent(hx_bypass_pipe)
+        outlet_pipe = OpenStudio::Model::PipeAdiabatic.new(model)
+        outlet_pipe.setName("#{secondary_chilled_water_loop.name} Supply Outlet")
+        outlet_pipe.addToNode(secondary_chilled_water_loop.supplyOutletNode)
+      else
+        OpenStudio.logFree(OpenStudio::Error, 'openstudio.Model.Model', 'No primary/secondary configuration specified for the chilled water loop.')
+      end
     else
       OpenStudio.logFree(OpenStudio::Error, 'openstudio.Model.Model', 'No pumping type specified for the chilled water loop.')
     end
@@ -322,6 +360,7 @@ class Standard
         chiller = OpenStudio::Model::ChillerElectricEIR.new(model)
         chiller.setName("#{template} #{chiller_cooling_type} #{chiller_condenser_type} #{chiller_compressor_type} Chiller #{i}")
         chilled_water_loop.addSupplyBranchForComponent(chiller)
+        dsgn_sup_wtr_temp_c = OpenStudio.convert(dsgn_sup_wtr_temp, 'F', 'C').get
         chiller.setReferenceLeavingChilledWaterTemperature(dsgn_sup_wtr_temp_c)
         chiller.setLeavingChilledWaterLowerTemperatureLimit(OpenStudio.convert(36.0, 'F', 'C').get)
         chiller.setReferenceEnteringCondenserFluidTemperature(OpenStudio.convert(95.0, 'F', 'C').get)
@@ -1660,25 +1699,28 @@ class Standard
     # create heating coil
     if hot_water_loop.nil?
       if heating_type == 'Electricity'
-        create_coil_heating_electric(model,
-                                     air_loop_node: air_loop.supplyInletNode,
-                                     name: "#{air_loop.name} Main Electric Htg Coil")
+        htg_coil = create_coil_heating_electric(model,
+                                                air_loop_node: air_loop.supplyInletNode,
+                                                name: "#{air_loop.name} Main Electric Htg Coil")
       else # default to NaturalGas
-        create_coil_heating_gas(model,
-                                air_loop_node: air_loop.supplyInletNode,
-                                name: "#{air_loop.name} Main Gas Htg Coil")
+        htg_coil = create_coil_heating_gas(model,
+                                           air_loop_node: air_loop.supplyInletNode,
+                                           name: "#{air_loop.name} Main Gas Htg Coil")
       end
     else
-      create_coil_heating_water(model,
-                                hot_water_loop,
-                                air_loop_node: air_loop.supplyInletNode,
-                                name: "#{air_loop.name} Main Htg Coil",
-                                rated_inlet_water_temperature: hw_temp_c,
-                                rated_outlet_water_temperature: (hw_temp_c - hw_delta_t_k),
-                                rated_inlet_air_temperature: dsgn_temps['prehtg_dsgn_sup_air_temp_c'],
-                                rated_outlet_air_temperature: dsgn_temps['htg_dsgn_sup_air_temp_c'])
+      htg_coil = create_coil_heating_water(model,
+                                           hot_water_loop,
+                                           air_loop_node: air_loop.supplyInletNode,
+                                           name: "#{air_loop.name} Main Htg Coil",
+                                           rated_inlet_water_temperature: hw_temp_c,
+                                           rated_outlet_water_temperature: (hw_temp_c - hw_delta_t_k),
+                                           rated_inlet_air_temperature: dsgn_temps['prehtg_dsgn_sup_air_temp_c'],
+                                           rated_outlet_air_temperature: dsgn_temps['htg_dsgn_sup_air_temp_c'])
     end
 
+    # set the setpointmanager for the central/preheat coil if required
+    model_set_central_preheat_coil_spm(model, thermal_zones, htg_coil)
+
     # create cooling coil
     if chilled_water_loop.nil?
       create_coil_cooling_dx_two_speed(model,
@@ -1874,9 +1916,12 @@ class Standard
     fan.addToNode(air_loop.supplyInletNode)
 
     # create heating coil
-    create_coil_heating_electric(model,
-                                 air_loop_node: air_loop.supplyInletNode,
-                                 name: "#{air_loop.name} Htg Coil")
+    htg_coil = create_coil_heating_electric(model,
+                                            air_loop_node: air_loop.supplyInletNode,
+                                            name: "#{air_loop.name} Htg Coil")
+
+    # set the setpointmanager for the central/preheat coil if required
+    model_set_central_preheat_coil_spm(model, thermal_zones, htg_coil)
 
     # create cooling coil
     create_coil_cooling_water(model,
@@ -2018,25 +2063,27 @@ class Standard
     # create heating coil
     if hot_water_loop.nil?
       if heating_type == 'Electricity'
-        create_coil_heating_electric(model,
-                                     air_loop_node: air_loop.supplyInletNode,
-                                     name: "#{air_loop.name} Main Electric Htg Coil")
+        htg_coil = create_coil_heating_electric(model,
+                                                air_loop_node: air_loop.supplyInletNode,
+                                                name: "#{air_loop.name} Main Electric Htg Coil")
       else # default to NaturalGas
-        create_coil_heating_gas(model,
-                                air_loop_node: air_loop.supplyInletNode,
-                                name: "#{air_loop.name} Main Gas Htg Coil")
+        htg_coil = create_coil_heating_gas(model,
+                                           air_loop_node: air_loop.supplyInletNode,
+                                           name: "#{air_loop.name} Main Gas Htg Coil")
       end
     else
-      create_coil_heating_water(model,
-                                hot_water_loop,
-                                air_loop_node: air_loop.supplyInletNode,
-                                name: "#{air_loop.name} Main Htg Coil",
-                                rated_inlet_water_temperature: hw_temp_c,
-                                rated_outlet_water_temperature: (hw_temp_c - hw_delta_t_k),
-                                rated_inlet_air_temperature: dsgn_temps['prehtg_dsgn_sup_air_temp_c'],
-                                rated_outlet_air_temperature: dsgn_temps['htg_dsgn_sup_air_temp_c'])
+      htg_coil = create_coil_heating_water(model, hot_water_loop,
+                                           air_loop_node: air_loop.supplyInletNode,
+                                           name: "#{air_loop.name} Main Htg Coil",
+                                           rated_inlet_water_temperature: hw_temp_c,
+                                           rated_outlet_water_temperature: (hw_temp_c - hw_delta_t_k),
+                                           rated_inlet_air_temperature: dsgn_temps['prehtg_dsgn_sup_air_temp_c'],
+                                           rated_outlet_air_temperature: dsgn_temps['htg_dsgn_sup_air_temp_c'])
     end
 
+    # set the setpointmanager for the central/preheat coil if required
+    model_set_central_preheat_coil_spm(model, thermal_zones, htg_coil)
+
     # create cooling coil
     if chilled_water_loop.nil?
       create_coil_cooling_dx_two_speed(model,
@@ -2194,9 +2241,12 @@ class Standard
     fan.addToNode(air_loop.supplyInletNode)
 
     # create heating coil
-    create_coil_heating_electric(model,
-                                 air_loop_node: air_loop.supplyInletNode,
-                                 name: "#{air_loop.name} Main Htg Coil")
+    htg_coil = create_coil_heating_electric(model,
+                                            air_loop_node: air_loop.supplyInletNode,
+                                            name: "#{air_loop.name} Main Htg Coil")
+
+    # set the setpointmanager for the central/preheat coil if required
+    model_set_central_preheat_coil_spm(model, thermal_zones, htg_coil)
 
     # create cooling coil
     if chilled_water_loop.nil?
@@ -2710,9 +2760,14 @@ class Standard
                         thermal_zones,
                         system_name: nil,
                         heating_type: nil,
+                        cooling_type: 'AirCooled',
                         supplemental_heating_type: nil,
                         hvac_op_sch: nil,
-                        oa_damper_sch: nil)
+                        fan_type: 'VAV_System_Fan',
+                        oa_damper_sch: nil,
+                        hot_water_loop: nil,
+                        chilled_water_loop: nil,
+                        minimum_volume_setpoint: nil)
 
     # hvac operation schedule
     if hvac_op_sch.nil?
@@ -2767,7 +2822,7 @@ class Standard
       # create fan
       # @type [OpenStudio::Model::FanVariableVolume] fan
       fan = create_fan_by_name(model,
-                               'VAV_System_Fan',
+                               fan_type,
                                fan_name: "#{air_loop.name} Fan",
                                end_use_subcategory: 'VAV System Fans')
       fan.setAvailabilitySchedule(hvac_op_sch)
@@ -2780,6 +2835,11 @@ class Standard
       when 'Electricity', 'Electric'
         htg_coil = create_coil_heating_electric(model,
                                                 name: "#{air_loop.name} Electric Htg Coil")
+      when 'Water'
+        htg_coil = create_coil_heating_water(model,
+                                             hot_water_loop,
+                                             air_loop_node: air_loop.supplyOutletNode,
+                                             name: "#{air_loop.name} Water Htg Coil")
       else
         # Zero-capacity, always-off electric heating coil
         htg_coil = create_coil_heating_electric(model,
@@ -2805,14 +2865,21 @@ class Standard
       end
 
       # create cooling coil
-      clg_coil = OpenStudio::Model::CoilCoolingDXVariableSpeed.new(model)
-      clg_coil.setName("#{air_loop.name} Var spd DX AC Clg Coil")
-      clg_coil.setBasinHeaterCapacity(10.0)
-      clg_coil.setBasinHeaterSetpointTemperature(2.0)
-      # first speed level
-      clg_spd_1 = OpenStudio::Model::CoilCoolingDXVariableSpeedSpeedData.new(model)
-      clg_coil.addSpeed(clg_spd_1)
-      clg_coil.setNominalSpeedLevel(1)
+      case cooling_type
+      when 'WaterCooled'
+        clg_coil = create_coil_cooling_water(model,
+                                             chilled_water_loop,
+                                             name: "#{air_loop.name} Clg Coil")
+      else # 'AirCooled'
+        clg_coil = OpenStudio::Model::CoilCoolingDXVariableSpeed.new(model)
+        clg_coil.setName("#{air_loop.name} Var spd DX AC Clg Coil")
+        clg_coil.setBasinHeaterCapacity(10.0)
+        clg_coil.setBasinHeaterSetpointTemperature(2.0)
+        # first speed level
+        clg_spd_1 = OpenStudio::Model::CoilCoolingDXVariableSpeedSpeedData.new(model)
+        clg_coil.addSpeed(clg_spd_1)
+        clg_coil.setNominalSpeedLevel(1)
+      end
 
       # @todo enable economizer maximum fraction outdoor air schedule input
       # econ_eff_sch = model_add_schedule(model, 'RetailStandalone PSZ_Econ_MaxOAFrac_Sch')
@@ -2824,13 +2891,20 @@ class Standard
       unitary_system.setCoolingCoil(clg_coil)
       unitary_system.setSupplementalHeatingCoil(supplemental_htg_coil)
       unitary_system.setName("#{zone.name} Unitary PSZ-VAV")
-      unitary_system.setString(2, 'SingleZoneVAV') # @todo add setControlType() method
+      # The following control strategy can lead to "Developer Error: Component sizing incomplete."
+      # EnergyPlus severe (not fatal) errors if there is no heating design load
+      unitary_system.setControlType('SingleZoneVAV')
       unitary_system.setControllingZoneorThermostatLocation(zone)
       unitary_system.setMaximumSupplyAirTemperature(dsgn_temps['zn_htg_dsgn_sup_air_temp_c'])
       unitary_system.setFanPlacement('BlowThrough')
       unitary_system.setSupplyAirFlowRateMethodDuringCoolingOperation('SupplyAirFlowRate')
       unitary_system.setSupplyAirFlowRateMethodDuringHeatingOperation('SupplyAirFlowRate')
-      unitary_system.setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired('SupplyAirFlowRate')
+      if minimum_volume_setpoint.nil?
+        unitary_system.setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired('SupplyAirFlowRate')
+      else
+        unitary_system.setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired('FractionOfAutosizedCoolingValue')
+        unitary_system.setFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(minimum_volume_setpoint)
+      end
       unitary_system.setSupplyAirFanOperatingModeSchedule(model.alwaysOnDiscreteSchedule)
       unitary_system.addToNode(air_loop.supplyInletNode)
 
@@ -4415,7 +4489,7 @@ class Standard
   # @param model_occ_hr_end [Double] (Optional) Only applies if control_strategy is 'proportional_control'.
   #   Ending hour of building occupancy.
   # @param control_strategy [String] name of control strategy.  Options are 'proportional_control' and 'none'.
-  #   If control strategy is 'proportional_control', the method will apply the CBE radiant control sequences 
+  #   If control strategy is 'proportional_control', the method will apply the CBE radiant control sequences
   #   detailed in Raftery et al. (2017), “A new control strategy for high thermal mass radiant systems”.
   #   Otherwise no control strategy will be applied and the radiant system will assume the EnergyPlus default controls.
   # @param proportional_gain [Double] (Optional) Only applies if control_strategy is 'proportional_control'.

data/lib/openstudio-standards/prototypes/common/objects/Prototype.utilities.rb

@@ -470,8 +470,6 @@ class Standard
     # Calculate the typical pressure - same for all building types
     final_pressure_pa = 0.5 * cs * rho * uh**2
 
-    # OpenStudio::logFree(OpenStudio::Debug, "openstudio.Standards.Space", "Final pressure PA = #{final_pressure_pa.round(3)} Pa.")
-
     adjusted_infiltration_rate_m3_per_s = (1.0 + alpha) * initial_infiltration_rate_m3_per_s * (final_pressure_pa / intial_pressure_pa)**n
 
     return adjusted_infiltration_rate_m3_per_s
@@ -691,10 +689,10 @@ class Standard
     case intended_surface_type
     when 'AtticFloor'
       film_r_si += film_int_surf_ht_flow_up_r_si if ext_film # Outside
-      film_r_si += film_semi_ext_surf_r_si if int_film # Inside
+      film_r_si += film_semi_ext_surf_r_si if int_film # Inside @todo: this is only true if the attic is ventilated, interior film should be used otheriwse
     when 'AtticWall', 'AtticRoof'
       film_r_si += film_ext_surf_r_si if ext_film # Outside
-      film_r_si += film_semi_ext_surf_r_si if int_film # Inside
+      film_r_si += film_semi_ext_surf_r_si if int_film # Inside @todo: this is only true if the attic is ventilated, interior film should be used otherwise
     when 'DemisingFloor', 'InteriorFloor'
       film_r_si += film_int_surf_ht_flow_up_r_si if ext_film # Outside
       film_r_si += film_int_surf_ht_flow_dwn_r_si if int_film # Inside

data/lib/openstudio-standards/prototypes/common/prototype_metaprogramming.rb

@@ -39,6 +39,7 @@ def create_class_array
     'ASHRAE9012007' => '90.1-2007',
     'ASHRAE9012010' => '90.1-2010',
     'ASHRAE9012013' => '90.1-2013',
+    'ASHRAE901PRM2019' => '90.1-PRM-2019',
     'ASHRAE9012016' => '90.1-2016',
     'ASHRAE9012019' => '90.1-2019',
     'DOERef1980to2004' => 'DOE Ref 1980-2004',

data/lib/openstudio-standards/refs/references.rb

@@ -30,6 +30,9 @@ module References
   # @see https://www.techstreet.com/ashrae/standards/ashrae-90-1-2016-i-p?product_id=1931793 Purchase in the ASHRAE Bookstore
   class ASHRAE9012016; end
 
+  # ASHRAE 90.1-2019 Appendix G PRM
+  # @see https://www.techstreet.com/ashrae/standards/ashrae-90-1-2019-i-p?product_id=2088527 Purchase in the ASHRAE Bookstore
+  class ASHRAE901PRM2019; end
   # ASHRAE 90.1-2019
   # @see https://www.techstreet.com/ashrae/standards/ashrae-90-1-2019-i-p?product_id=2088527 Purchase in the ASHRAE Bookstore
   class ASHRAE9012019; end