openstudio-standards 0.4.0 → 0.5.0.rc1

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

@@ -10,7 +10,7 @@ class Standard
   # @param type [String] the type of unit to reference for the correct curve set
   # @param cooling_cop [Double] rated cooling coefficient of performance
   # @param heating_cop [Double] rated heating coefficient of performance
-  # @param heat_recovery [Bool] does the unit have heat recovery
+  # @param heat_recovery [Boolean] does the unit have heat recovery
   # @param defrost_strategy [String] type of defrost strategy. options are ReverseCycle or Resistive
   # @param condenser_type [String] type of condenser
   #   options are AirCooled (default), WaterCooled, and EvaporativelyCooled.

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

@@ -7,7 +7,7 @@ class Standard
   #
   # @param air_terminal_single_duct_vav_reheat [OpenStudio::Model::AirTerminalSingleDuctVAVReheat] the air terminal object
   # @param zone_oa_per_area [Double] the zone outdoor air per area in m^3/s*m^2
-  # @return [Bool] returns true if successful, false if not
+  # @return [Boolean] returns true if successful, false if not
   def air_terminal_single_duct_vav_reheat_apply_initial_prototype_damper_position(air_terminal_single_duct_vav_reheat, zone_oa_per_area)
     min_damper_position = 0.3
 

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

@@ -62,22 +62,90 @@ class Standard
         clg_coil.setCoolingPowerConsumptionCoefficient4(0.141605667000125)
         clg_coil.setCoolingPowerConsumptionCoefficient5(-0.168727936032429)
       else
-        clg_coil.totalCoolingCapacityCurve.setCoefficient1Constant(-4.30266987344639)
-        clg_coil.totalCoolingCapacityCurve.setCoefficient2w(7.18536990534372)
-        clg_coil.totalCoolingCapacityCurve.setCoefficient3x(-2.23946714486189)
-        clg_coil.totalCoolingCapacityCurve.setCoefficient4y(0.139995928440879)
-        clg_coil.totalCoolingCapacityCurve.setCoefficient5z(0.102660179888915)
-        clg_coil.sensibleCoolingCapacityCurve.setCoefficient1Constant(6.0019444814887)
-        clg_coil.sensibleCoolingCapacityCurve.setCoefficient2v(22.6300677244073)
-        clg_coil.sensibleCoolingCapacityCurve.setCoefficient3w(-26.7960783730934)
-        clg_coil.sensibleCoolingCapacityCurve.setCoefficient4x(-1.72374720346819)
-        clg_coil.sensibleCoolingCapacityCurve.setCoefficient5y(0.490644802367817)
-        clg_coil.sensibleCoolingCapacityCurve.setCoefficient6z(0.0693119353468141)
-        clg_coil.coolingPowerConsumptionCurve.setCoefficient1Constant(-5.67775976415698)
-        clg_coil.coolingPowerConsumptionCurve.setCoefficient2w(0.438988156976704)
-        clg_coil.coolingPowerConsumptionCurve.setCoefficient3x(5.845277342193)
-        clg_coil.coolingPowerConsumptionCurve.setCoefficient4y(0.141605667000125)
-        clg_coil.coolingPowerConsumptionCurve.setCoefficient5z(-0.168727936032429)
+        if model.getCurveByName('Water to Air Heat Pump Total Cooling Capacity Curve').is_initialized
+          total_cooling_capacity_curve = model.getCurveByName('Water to Air Heat Pump Total Cooling Capacity Curve').get
+          total_cooling_capacity_curve = total_cooling_capacity_curve.to_CurveQuadLinear.get
+        else
+          total_cooling_capacity_curve = OpenStudio::Model::CurveQuadLinear.new(model)
+          total_cooling_capacity_curve.setName('Water to Air Heat Pump Total Cooling Capacity Curve')
+          total_cooling_capacity_curve.setCoefficient1Constant(-4.30266987344639)
+          total_cooling_capacity_curve.setCoefficient2w(7.18536990534372)
+          total_cooling_capacity_curve.setCoefficient3x(-2.23946714486189)
+          total_cooling_capacity_curve.setCoefficient4y(0.139995928440879)
+          total_cooling_capacity_curve.setCoefficient5z(0.102660179888915)
+          total_cooling_capacity_curve.setMinimumValueofw(-100)
+          total_cooling_capacity_curve.setMaximumValueofw(100)
+          total_cooling_capacity_curve.setMinimumValueofx(-100)
+          total_cooling_capacity_curve.setMaximumValueofx(100)
+          total_cooling_capacity_curve.setMinimumValueofy(0)
+          total_cooling_capacity_curve.setMaximumValueofy(100)
+          total_cooling_capacity_curve.setMinimumValueofz(0)
+          total_cooling_capacity_curve.setMaximumValueofz(100)
+        end
+        clg_coil.setTotalCoolingCapacityCurve(total_cooling_capacity_curve)
+
+        if model.getCurveByName('Water to Air Heat Pump Sensible Cooling Capacity Curve').is_initialized
+          sensible_cooling_capacity_curve = model.getCurveByName('Water to Air Heat Pump Sensible Cooling Capacity Curve').get
+          sensible_cooling_capacity_curve = sensible_cooling_capacity_curve.to_CurveQuintLinear.get
+        else
+          sensible_cooling_capacity_curve = OpenStudio::Model::CurveQuintLinear.new(model)
+          sensible_cooling_capacity_curve.setName('Water to Air Heat Pump Sensible Cooling Capacity Curve')
+          sensible_cooling_capacity_curve.setCoefficient1Constant(6.0019444814887)
+          sensible_cooling_capacity_curve.setCoefficient2v(22.6300677244073)
+          sensible_cooling_capacity_curve.setCoefficient3w(-26.7960783730934)
+          sensible_cooling_capacity_curve.setCoefficient4x(-1.72374720346819)
+          sensible_cooling_capacity_curve.setCoefficient5y(0.490644802367817)
+          sensible_cooling_capacity_curve.setCoefficient6z(0.0693119353468141)
+          sensible_cooling_capacity_curve.setMinimumValueofw(-100)
+          sensible_cooling_capacity_curve.setMaximumValueofw(100)
+          sensible_cooling_capacity_curve.setMinimumValueofx(-100)
+          sensible_cooling_capacity_curve.setMaximumValueofx(100)
+          sensible_cooling_capacity_curve.setMinimumValueofy(0)
+          sensible_cooling_capacity_curve.setMaximumValueofy(100)
+          sensible_cooling_capacity_curve.setMinimumValueofz(0)
+          sensible_cooling_capacity_curve.setMaximumValueofz(100)
+        end
+        clg_coil.setSensibleCoolingCapacityCurve(sensible_cooling_capacity_curve)
+
+        if model.getCurveByName('Water to Air Heat Pump Cooling Power Consumption Curve').is_initialized
+          cooling_power_consumption_curve = model.getCurveByName('Water to Air Heat Pump Cooling Power Consumption Curve').get
+          cooling_power_consumption_curve = cooling_power_consumption_curve.to_CurveQuadLinear.get
+        else
+          cooling_power_consumption_curve = OpenStudio::Model::CurveQuadLinear.new(model)
+          cooling_power_consumption_curve.setName('Water to Air Heat Pump Cooling Power Consumption Curve')
+          cooling_power_consumption_curve.setCoefficient1Constant(-5.67775976415698)
+          cooling_power_consumption_curve.setCoefficient2w(0.438988156976704)
+          cooling_power_consumption_curve.setCoefficient3x(5.845277342193)
+          cooling_power_consumption_curve.setCoefficient4y(0.141605667000125)
+          cooling_power_consumption_curve.setCoefficient5z(-0.168727936032429)
+          cooling_power_consumption_curve.setMinimumValueofw(-100)
+          cooling_power_consumption_curve.setMaximumValueofw(100)
+          cooling_power_consumption_curve.setMinimumValueofx(-100)
+          cooling_power_consumption_curve.setMaximumValueofx(100)
+          cooling_power_consumption_curve.setMinimumValueofy(0)
+          cooling_power_consumption_curve.setMaximumValueofy(100)
+          cooling_power_consumption_curve.setMinimumValueofz(0)
+          cooling_power_consumption_curve.setMaximumValueofz(100)
+        end
+        clg_coil.setCoolingPowerConsumptionCurve(cooling_power_consumption_curve)
+      end
+
+      # part load fraction correlation curve added as a required curve in OS v3.7.0
+      if model.version > OpenStudio::VersionString.new('3.6.1')
+        if model.getCurveByName('Water to Air Heat Pump Part Load Fraction Correlation Curve').is_initialized
+          part_load_correlation_curve = model.getCurveByName('Water to Air Heat Pump Part Load Fraction Correlation Curve').get
+          part_load_correlation_curve = part_load_correlation_curve.to_CurveLinear.get
+        else
+          part_load_correlation_curve = OpenStudio::Model::CurveLinear.new(model)
+          part_load_correlation_curve.setName('Water to Air Heat Pump Part Load Fraction Correlation Curve')
+          part_load_correlation_curve.setCoefficient1Constant(0.833746458696111)
+          part_load_correlation_curve.setCoefficient2x(0.166253541303889)
+          part_load_correlation_curve.setMinimumValueofx(0)
+          part_load_correlation_curve.setMaximumValueofx(1)
+          part_load_correlation_curve.setMinimumCurveOutput(0)
+          part_load_correlation_curve.setMaximumCurveOutput(1)
+        end
+        clg_coil.setPartLoadFractionCorrelationCurve(part_load_correlation_curve)
       end
     end
 

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

@@ -200,7 +200,7 @@ class Standard
   # sets defrost curve limits
   #
   # @param htg_coil [OpenStudio::Model::CoilHeatingDXSingleSpeed] a DX heating coil
-  # @return [Bool] returns true if successful, false if not
+  # @return [Boolean] returns true if successful, false if not
   def coil_heating_dx_single_speed_apply_defrost_eir_curve_limits(htg_coil)
     return false unless htg_coil.defrostEnergyInputRatioFunctionofTemperatureCurve.is_initialized
 

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

@@ -61,7 +61,7 @@ class Standard
   # Defaults to making no changes.
   #
   # @param coil_heating_gas [OpenStudio::Model::CoilHeatingGas] a gas heating coil
-  # @return [Bool] returns true if successful, false if not
+  # @return [Boolean] returns true if successful, false if not
   def coil_heating_gas_apply_prototype_efficiency(coil_heating_gas)
     # do nothing
     return true

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

@@ -56,16 +56,67 @@ class Standard
         htg_coil.setHeatingPowerConsumptionCoefficient4(-0.177653510577989)
         htg_coil.setHeatingPowerConsumptionCoefficient5(-0.103079864171839)
       else
-        htg_coil.heatingCapacityCurve.setCoefficient1Constant(0.237847462869254)
-        htg_coil.heatingCapacityCurve.setCoefficient2w(-3.35823796081626)
-        htg_coil.heatingCapacityCurve.setCoefficient3x(3.80640467406376)
-        htg_coil.heatingCapacityCurve.setCoefficient4y(0.179200417311554)
-        htg_coil.heatingCapacityCurve.setCoefficient5z(0.12860719846082)
-        htg_coil.heatingPowerConsumptionCurve.setCoefficient1Constant(-3.79175529243238)
-        htg_coil.heatingPowerConsumptionCurve.setCoefficient2w(3.38799239505527)
-        htg_coil.heatingPowerConsumptionCurve.setCoefficient3x(1.5022612076303)
-        htg_coil.heatingPowerConsumptionCurve.setCoefficient4y(-0.177653510577989)
-        htg_coil.heatingPowerConsumptionCurve.setCoefficient5z(-0.103079864171839)
+        if model.getCurveByName('Water to Air Heat Pump Heating Capacity Curve').is_initialized
+          heating_capacity_curve = model.getCurveByName('Water to Air Heat Pump Heating Capacity Curve').get
+          heating_capacity_curve = heating_capacity_curve.to_CurveQuadLinear.get
+        else
+          heating_capacity_curve = OpenStudio::Model::CurveQuadLinear.new(model)
+          heating_capacity_curve.setName('Water to Air Heat Pump Heating Capacity Curve')
+          heating_capacity_curve.setCoefficient1Constant(0.237847462869254)
+          heating_capacity_curve.setCoefficient2w(-3.35823796081626)
+          heating_capacity_curve.setCoefficient3x(3.80640467406376)
+          heating_capacity_curve.setCoefficient4y(0.179200417311554)
+          heating_capacity_curve.setCoefficient5z(0.12860719846082)
+          heating_capacity_curve.setMinimumValueofw(-100)
+          heating_capacity_curve.setMaximumValueofw(100)
+          heating_capacity_curve.setMinimumValueofx(-100)
+          heating_capacity_curve.setMaximumValueofx(100)
+          heating_capacity_curve.setMinimumValueofy(0)
+          heating_capacity_curve.setMaximumValueofy(100)
+          heating_capacity_curve.setMinimumValueofz(0)
+          heating_capacity_curve.setMaximumValueofz(100)
+        end
+        htg_coil.setHeatingCapacityCurve(heating_capacity_curve)
+
+        if model.getCurveByName('Water to Air Heat Pump Heating Power Consumption Curve').is_initialized
+          heating_power_consumption_curve = model.getCurveByName('Water to Air Heat Pump Heating Power Consumption Curve').get
+          heating_power_consumption_curve = heating_power_consumption_curve.to_CurveQuadLinear.get
+        else
+          heating_power_consumption_curve = OpenStudio::Model::CurveQuadLinear.new(model)
+          heating_power_consumption_curve.setName('Water to Air Heat Pump Heating Power Consumption Curve')
+          heating_power_consumption_curve.setCoefficient1Constant(-3.79175529243238)
+          heating_power_consumption_curve.setCoefficient2w(3.38799239505527)
+          heating_power_consumption_curve.setCoefficient3x(1.5022612076303)
+          heating_power_consumption_curve.setCoefficient4y(-0.177653510577989)
+          heating_power_consumption_curve.setCoefficient5z(-0.103079864171839)
+          heating_power_consumption_curve.setMinimumValueofw(-100)
+          heating_power_consumption_curve.setMaximumValueofw(100)
+          heating_power_consumption_curve.setMinimumValueofx(-100)
+          heating_power_consumption_curve.setMaximumValueofx(100)
+          heating_power_consumption_curve.setMinimumValueofy(0)
+          heating_power_consumption_curve.setMaximumValueofy(100)
+          heating_power_consumption_curve.setMinimumValueofz(0)
+          heating_power_consumption_curve.setMaximumValueofz(100)
+        end
+        htg_coil.setHeatingPowerConsumptionCurve(heating_power_consumption_curve)
+      end
+      
+      # part load fraction correlation curve added as a required curve in OS v3.7.0
+      if model.version > OpenStudio::VersionString.new('3.6.1')
+        if model.getCurveByName('Water to Air Heat Pump Part Load Fraction Correlation Curve').is_initialized
+          part_load_correlation_curve = model.getCurveByName('Water to Air Heat Pump Part Load Fraction Correlation Curve').get
+          part_load_correlation_curve = part_load_correlation_curve.to_CurveLinear.get
+        else
+          part_load_correlation_curve = OpenStudio::Model::CurveLinear.new(model)
+          part_load_correlation_curve.setName('Water to Air Heat Pump Part Load Fraction Correlation Curve')
+          part_load_correlation_curve.setCoefficient1Constant(0.833746458696111)
+          part_load_correlation_curve.setCoefficient2x(0.166253541303889)
+          part_load_correlation_curve.setMinimumValueofx(0)
+          part_load_correlation_curve.setMaximumValueofx(1)
+          part_load_correlation_curve.setMinimumCurveOutput(0)
+          part_load_correlation_curve.setMaximumCurveOutput(1)
+        end
+        htg_coil.setPartLoadFractionCorrelationCurve(part_load_correlation_curve)
       end
     end
 

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

@@ -4,7 +4,7 @@ class Standard
   # Sets the convergence tolerance to 0.0001 deltaC for all hot water coils.
   #
   # @param controller_water_coil [OpenStudio::Model::ControllerWaterCoil] controller water coil object
-  # @return [Bool] returns true if successful, false if not
+  # @return [Boolean] returns true if successful, false if not
   # @todo Figure out what the reason for this is, because it seems like a workaround for an E+ bug that was probably addressed long ago.
   def controller_water_coil_set_convergence_limits(controller_water_coil)
     controller_action = controller_water_coil.action

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

@@ -5,7 +5,7 @@ class Standard
   #
   # @param condenser_loop [<OpenStudio::Model::PlantLoop>] a condenser loop served by a cooling tower
   # @param design_wet_bulb_c [Double] the outdoor design wetbulb conditions in degrees Celsius
-  # @return [Bool] returns true if successful, false if not
+  # @return [Boolean] returns true if successful, false if not
   def prototype_apply_condenser_water_temperatures(condenser_loop,
                                                    design_wet_bulb_c: nil)
     sizing_plant = condenser_loop.sizingPlant

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

@@ -9,7 +9,7 @@ module PrototypeFan
   #
   # @param fan [OpenStudio::Model::StraightComponent] fan object of type:
   #   FanConstantVolume, FanOnOff, FanVariableVolume, and FanZoneExhaust
-  # @return [Bool] returns true if successful, false if not
+  # @return [Boolean] returns true if successful, false if not
   def prototype_fan_apply_prototype_fan_efficiency(fan)
     # Do not modify dummy exhaust fans
     return true unless !fan.name.to_s.downcase.include? 'dummy'

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

@@ -7,7 +7,7 @@ class Standard
   # and whether the fan lives inside a unit heater, PTAC, etc.
   #
   # @param fan_constant_volume [OpenStudio::Model::FanConstantVolume] constant volume fan object
-  # @return [Bool] returns true if successful, false if not
+  # @return [Boolean] returns true if successful, false if not
   def fan_constant_volume_apply_prototype_fan_pressure_rise(fan_constant_volume)
     # Don't modify unit heater fans
     return true if fan_constant_volume.name.to_s.include?('UnitHeater Fan')

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

@@ -8,7 +8,7 @@ class Standard
   # and whether the fan lives inside a unit heater, PTAC, etc.
   #
   # @param fan_on_off [OpenStudio::Model::FanOnOff] on off fan object
-  # @return [Bool] returns true if successful, false if not
+  # @return [Boolean] returns true if successful, false if not
   def fan_on_off_apply_prototype_fan_pressure_rise(fan_on_off)
     # Get the max flow rate from the fan.
     maximum_flow_rate_m3_per_s = nil

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

@@ -8,7 +8,7 @@ class Standard
   # and whether the fan lives inside a unit heater, PTAC, etc.
   #
   # @param fan_variable_volume [OpenStudio::Model::FanVariableVolume] variable volume fan object
-  # @return [Bool] returns true if successful, false if not
+  # @return [Boolean] returns true if successful, false if not
   def fan_variable_volume_apply_prototype_fan_pressure_rise(fan_variable_volume)
     # Get the max flow rate from the fan.
     maximum_flow_rate_m3_per_s = nil

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

@@ -6,7 +6,7 @@ class Standard
   # Sets the fan pressure rise based on the Prototype buildings inputs
   #
   # @param fan_zone_exhaust [OpenStudio::Model::FanZoneExhaust] the exhaust fan
-  # @return [Bool] returns true if successful, false if not
+  # @return [Boolean] returns true if successful, false if not
   def fan_zone_exhaust_apply_prototype_fan_pressure_rise(fan_zone_exhaust)
     # Do not modify dummy exhaust fans
     return true if fan_zone_exhaust.name.to_s.downcase.include? 'dummy'

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

@@ -11,7 +11,7 @@ class Standard
 
   # Sets the motor power to account for the extra fan energy from the increase in fan total static pressure
   #
-  # @return [Bool] returns true if successful, false if not
+  # @return [Boolean] returns true if successful, false if not
   def heat_exchanger_air_to_air_sensible_and_latent_apply_prototype_nominal_electric_power(heat_exchanger_air_to_air_sensible_and_latent)
     # Get the nominal supply air flow rate
     supply_air_flow_m3_per_s = nil
@@ -77,7 +77,7 @@ class Standard
   # which assume that an enthalpy wheel is used, which exceeds the 50% effectiveness minimum actually defined by 90.1.
   #
   # @param heat_exchanger_air_to_air_sensible_and_latent [OpenStudio::Model::HeatExchangerAirToAirSensibleAndLatent] hx
-  # @return [Bool] returns true if successful, false if not
+  # @return [Boolean] returns true if successful, false if not
   def heat_exchanger_air_to_air_sensible_and_latent_apply_prototype_efficiency(heat_exchanger_air_to_air_sensible_and_latent)
     heat_exchanger_air_to_air_sensible_and_latent.setSensibleEffectivenessat100HeatingAirFlow(0.7)
     heat_exchanger_air_to_air_sensible_and_latent.setLatentEffectivenessat100HeatingAirFlow(0.6)

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

@@ -4,8 +4,8 @@ class Standard
   # @param model [OpenStudio::Model::Model] OpenStudio model object
   # @param exterior_lighting_zone_number [Integer] exterior lighting zone number, 0-4
   # @param onsite_parking_fraction [Double] onsite parking fraction, 0-1
-  # @param add_base_site_allowance [Bool] whether to include the base site allowance
-  # @param use_model_for_entries_and_canopies [Bool] use building geometry for number of entries and canopy size
+  # @param add_base_site_allowance [Boolean] whether to include the base site allowance
+  # @param use_model_for_entries_and_canopies [Boolean] use building geometry for number of entries and canopy size
   # @return [Hash] a hash of OpenStudio::Model::ExteriorLights objects
   # @todo would be nice to add argument for some building types (SmallHotel, MidriseApartment, PrimarySchool, SecondarySchool, RetailStripmall) if it has interior or exterior circulation.
   def model_add_typical_exterior_lights(model, exterior_lighting_zone_number, onsite_parking_fraction = 1.0, add_base_site_allowance = false, use_model_for_entries_and_canopies = false)
@@ -286,8 +286,8 @@ class Standard
   #
   # @param model [OpenStudio::Model::Model] OpenStudio model object
   # @param space_type_hash [Hash] hash of space types
-  # @param use_model_for_entries_and_canopies [Bool] use building geometry for number of entries and canopy size
-  # @return [hash] hash of exterior lighting value types and building type and model specific values
+  # @param use_model_for_entries_and_canopies [Boolean] use building geometry for number of entries and canopy size
+  # @return [Hhash] hash of exterior lighting value types and building type and model specific values
   # @todo add code in to determine number of entries and canopy area from model geoemtry
   # @todo come up with better logic for entry widths
   def model_create_exterior_lighting_area_length_count_hash(model, space_type_hash, use_model_for_entries_and_canopies)

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

@@ -5,7 +5,7 @@ class Standard
   # @param building_type [String] the building type
   # @param climate_zone [String] ASHRAE climate zone, e.g. 'ASHRAE 169-2013-4A'
   # @param prototype_input [Hash] hash of prototype inputs
-  # @return [Bool] returns true if successful, false if not
+  # @return [Boolean] returns true if successful, false if not
   def model_add_hvac(model, building_type, climate_zone, prototype_input)
     OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.Model', 'Started Adding HVAC')
 
@@ -449,7 +449,7 @@ class Standard
 
       when 'Fan Coil'
         case system['heating_type']
-        when 'Gas', 'DistrictHeating', 'Electricity'
+        when 'Gas', 'DistrictHeating', 'DistrictHeatingWater', 'DistrictHeatingSteam', 'Electricity'
           hot_water_loop = model_get_or_add_hot_water_loop(model, system['heating_type'])
         when nil
           hot_water_loop = nil
@@ -468,7 +468,7 @@ class Standard
 
       when 'Baseboards'
         case system['heating_type']
-        when 'Gas', 'DistrictHeating'
+        when 'Gas', 'DistrictHeating', 'DistrictHeatingWater', 'DistrictHeatingSteam'
           hot_water_loop = model_get_or_add_hot_water_loop(model, system['heating_type'])
         when 'Electricity'
           hot_water_loop = nil
@@ -498,7 +498,7 @@ class Standard
   # @param model [OpenStudio::Model::Model] OpenStudio model object
   # @param area_type [String] Valid choices are residential and nonresidential
   # @param delivery_type [String] Conditioning delivery type. Valid choices are air and hydronic
-  # @param heating_source [String] Valid choices are Electricity, NaturalGas, DistrictHeating, DistrictAmbient
+  # @param heating_source [String] Valid choices are Electricity, NaturalGas, DistrictHeating, DistrictHeatingWater, DistrictHeatingSteam, DistrictAmbient
   # @param cooling_source [String] Valid choices are Electricity, DistrictCooling, DistrictAmbient
   # @param area_m2 [Double] Area in m^2
   # @param num_stories [Integer] Number of stories

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

@@ -44,6 +44,12 @@ Standard.class_eval do
     model_create_thermal_zones(model, @space_multiplier_map)
     model_add_design_days_and_weather_file(model, climate_zone, epw_file)
     model_add_hvac(model, @instvarbuilding_type, climate_zone, @prototype_input)
+    model.getAirLoopHVACs.each do |air_loop|
+      next unless air_loop_hvac_multizone_vav_system?(air_loop)
+
+      model_system_outdoor_air_sizing_vrp_method(air_loop)
+      air_loop_hvac_apply_vav_damper_action(air_loop)
+    end
     model_add_constructions(model, @instvarbuilding_type, climate_zone)
     model_fenestration_orientation(model, climate_zone)
     model_custom_hvac_tweaks(model, building_type, climate_zone, @prototype_input)
@@ -131,7 +137,7 @@ Standard.class_eval do
   #
   # @param model [OpenStudio::Model::Model] OpenStudio model object
   # @param rel_path_to_osm [String] the path to an .osm file, relative to this file
-  # @return [Bool] returns true if successful, false if not
+  # @return [Boolean] returns true if successful, false if not
   def model_replace_model_from_osm(model, rel_path_to_osm)
     # Take the existing model and remove all the objects
     # (this is cheesy), but need to keep the same memory block
@@ -238,7 +244,7 @@ Standard.class_eval do
   # Some loads are governed by the standard, others are typical values
   # pulled from sources such as the DOE Reference and DOE Prototype Buildings.
   #
-  # @return [Bool] returns true if successful, false if not
+  # @return [Boolean] returns true if successful, false if not
   def model_add_loads(model)
     OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.Model', 'Started applying space types (loads)')
 
@@ -352,7 +358,7 @@ Standard.class_eval do
   # @param model[OpenStudio::Model::Model] OpenStudio Model
   # @param building_type [String] the building type
   # @param climate_zone [String] ASHRAE climate zone, e.g. 'ASHRAE 169-2013-4A'
-  # @return [Bool] returns true if successful, false if not
+  # @return [Boolean] returns true if successful, false if not
   def model_add_constructions(model, building_type, climate_zone)
     OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.Model', 'Started applying constructions')
     is_residential = 'No' # default is nonresidential for building level
@@ -537,8 +543,8 @@ Standard.class_eval do
   # CFactorUndergroundWallConstruction and require some additional parameters when compared to Construction
   #
   # @param model[OpenStudio::Model::Model] OpenStudio Model
-  # @param climate_zone [string] climate zone as described for prototype models. C-Factor is based on this parameter
-  # @param building_type [string] the building type
+  # @param climate_zone [String climate zone as described for prototype models. C-Factor is based on this parameter
+  # @param building_type [String the building type
   # @return [void]
   def model_set_below_grade_wall_constructions(model, building_type, climate_zone)
     # Find ground contact wall building category
@@ -615,8 +621,8 @@ Standard.class_eval do
   # calculated. Used for F-Factor floors that require additional parameters.
   #
   # @param model [OpenStudio Model] OpenStudio model being modified
-  # @param building_type [string] the building type
-  # @param climate_zone [string] climate zone as described for prototype models. F-Factor is based on this parameter
+  # @param building_type [String the building type
+  # @param climate_zone [String climate zone as described for prototype models. F-Factor is based on this parameter
   def model_set_floor_constructions(model, building_type, climate_zone)
     # Find ground contact wall building category
     construction_set_data = model_get_construction_set(building_type)
@@ -744,7 +750,8 @@ Standard.class_eval do
 
       # If the edge is parallel with the floor and in the same x-y plane as the floor, assume an intersection the
       # length of the wall edge
-      edge_vector = OpenStudio::Vector3d.new(wall_edge_p1 - wall_edge_p2)
+      intersect_vector = wall_edge_p1 - wall_edge_p2
+      edge_vector = OpenStudio::Vector3d.new(intersect_vector.x, intersect_vector.y, intersect_vector.z)
       return(edge_vector.length)
     end
 
@@ -782,7 +789,7 @@ Standard.class_eval do
   #
   # @param model[OpenStudio::Model::Model] OpenStudio Model
   # @param building_type [String] the building type
-  # @return [Bool] returns true if successful, false if not
+  # @return [Boolean] returns true if successful, false if not
   def model_add_internal_mass(model, building_type)
     # Assign a material to all internal mass objects
     material = OpenStudio::Model::StandardOpaqueMaterial.new(model)
@@ -841,7 +848,7 @@ Standard.class_eval do
   # e.g. (Prototype.secondary_school.rb) file.
   #
   # @param (see #add_constructions)
-  # @return [Bool] returns true if successful, false if not
+  # @return [Boolean] returns true if successful, false if not
   def model_create_thermal_zones(model, space_multiplier_map = nil)
     OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.Model', 'Started creating thermal zones')
 
@@ -1443,7 +1450,7 @@ Standard.class_eval do
   # the PNNL documentation.
   #
   # @param (see #add_constructions)
-  # @return [Bool] returns true if successful, false if not
+  # @return [Boolean] returns true if successful, false if not
   # @todo genericize and move this method to Standards.Space
   def model_add_occupancy_sensors(model, building_type, climate_zone)
     # Only add occupancy sensors for 90.1-2010
@@ -1547,7 +1554,7 @@ Standard.class_eval do
   # in OpenStudio_Standards_prototype_inputs
   #
   # @param (see #add_constructions)
-  # @return [Bool] returns true if successful, false if not
+  # @return [Boolean] returns true if successful, false if not
   # @todo translate w/linear foot of facade, door, parking, etc
   #   into lookup table and implement that way instead of hard-coding as
   #   inputs in the spreadsheet.
@@ -1622,7 +1629,7 @@ Standard.class_eval do
   # Changes the infiltration coefficients for the prototype vintages.
   #
   # @param (see #add_constructions)
-  # @return [Bool] returns true if successful, false if not
+  # @return [Boolean] returns true if successful, false if not
   # @todo Consistency - make prototype and reference vintages consistent
   def model_modify_infiltration_coefficients(model, building_type, climate_zone)
     # Select the terrain type, which
@@ -1667,7 +1674,7 @@ Standard.class_eval do
   # Sets the inside and outside convection algorithms for different vintages
   #
   # @param (see #add_constructions)
-  # @return [Bool] returns true if successful, false if not
+  # @return [Boolean] returns true if successful, false if not
   # @todo Consistency - make prototype and reference vintages consistent
   def model_modify_surface_convection_algorithm(model)
     inside = model.getInsideSurfaceConvectionAlgorithm
@@ -1715,7 +1722,7 @@ Standard.class_eval do
   # Changes the infiltration coefficients for the prototype vintages.
   #
   # @param (see #add_constructions)
-  # @return [Bool] returns true if successful, false if not
+  # @return [Boolean] returns true if successful, false if not
   # @todo Consistency - make sizing factors consistent
   #   between building types, climate zones, and vintages?
   def model_apply_sizing_parameters(model, building_type)
@@ -1792,7 +1799,7 @@ Standard.class_eval do
   # Applies the Prototype Building assumptions that contradict/supersede
   # the given standard.
   #
-  # @param model [OpenStudio::Model::Model] the model
+  # @param model [OpenStudio::Model::Model] OpenStudio model object
   def model_apply_prototype_hvac_efficiency_adjustments(model)
     building_data = model_get_building_properties(model)
     building_type = building_data['building_type']
@@ -2474,9 +2481,15 @@ Standard.class_eval do
   # end reduce schedule
 
   # Determine the prototypical economizer type for the model.
-  # Defaults to the pre-90.1-2010 assumption of DifferentialDryBulb.
+  # Defaults to FixedDryBulb based on anecdotal evidence of this being
+  # the most common type encountered in the field, combined
+  # with this being the default option for many equipment manufacturers,
+  # and being the strategy recommended in the 2010 ASHRAE journal article
+  # "Economizer High Limit Devices and Why Enthalpy Economizers Don't Work"
+  # by Steven Taylor and Hwakong Cheng.
+  # https://tayloreng.egnyte.com/dl/mN0c9t4WSO/ASHRAE_Journal_-_Economizer_High_Limit_Devices_and_Why_Enthalpy_Economizers_Dont_Work.pdf_
   #
-  # @param model [OpenStudio::Model::Model] the model
+  # @param model [OpenStudio::Model::Model] OpenStudio model object
   # @param climate_zone [String] ASHRAE climate zone, e.g. 'ASHRAE 169-2013-4A'
   # @return [String] the economizer type.  Possible values are:
   # 'NoEconomizer'
@@ -2488,7 +2501,7 @@ Standard.class_eval do
   # 'ElectronicEnthalpy'
   # 'DifferentialDryBulbAndEnthalpy'
   def model_economizer_type(model, climate_zone)
-    economizer_type = 'DifferentialDryBulb'
+    economizer_type = 'FixedDryBulb'
     return economizer_type
   end
 
@@ -2582,7 +2595,7 @@ Standard.class_eval do
   # @author Xuechen (Jerry) Lei, PNNL
   #
   # @param model [OpenStudio::Model::Model] OpenStudio Model
-  # @return [Bool] returns true if successful, false if not
+  # @return [Boolean] returns true if successful, false if not
   def model_add_lights_shutoff(model)
     return false
   end
@@ -2600,7 +2613,7 @@ Standard.class_eval do
   # Metal coiling door code minimum infiltration rate at 75 Pa
   #
   # @param [String] Climate zone
-  # @return [Float] Minimum infiltration rate for metal coiling doors
+  # @return [Double] Minimum infiltration rate for metal coiling doors
   def model_door_infil_flow_rate_metal_coiling_cfm_ft2(climate_zone)
     case climate_zone
       when 'ASHRAE 169-2006-7A',
@@ -2616,7 +2629,7 @@ Standard.class_eval do
   # Metal rollup door code minimum infiltration rate at 75 Pa
   #
   # @param [String] Climate zone
-  # @return [Float] Minimum infiltration rate for metal coiling doors
+  # @return [Double] Minimum infiltration rate for metal coiling doors
   def model_door_infil_flow_rate_rollup_cfm_ft2(climate_zone)
     return 0.4
   end
@@ -2624,7 +2637,7 @@ Standard.class_eval do
   # Open door infiltration rate at 75 Pa
   #
   # @param [String] Climate zone
-  # @return [Float] Open door infiltration rate
+  # @return [Double] Open door infiltration rate
   def model_door_infil_flow_rate_open_cfm_ft2(climate_zone)
     return 9.7875
   end
@@ -2811,7 +2824,7 @@ Standard.class_eval do
   # Add transfer to prototype for spaces that require it
   #
   # @param model [OpenStudio::Model::Model] OpenStudio model object
-  # @return [Boolean] true if successful, false otherwise
+  # @return [Boolean] returns true if successful, false if not
   def model_add_transfer_air(model)
     # Do not add transfer air if not required
     return true unless model_transfer_air_required?(model)
@@ -2872,8 +2885,8 @@ Standard.class_eval do
   # required to setup/back their thermostat setpoints
   #
   # @param time_offset_hash [Hash] Hash providing time (key) and schedule value offset (values)
-  # @param schedule [OpenStudio::model::ScheduleRuleset] OpenStudio schedule object
-  # @return [OpenStudio::model::ScheduleRuleset] Modified OpenStudio schedule object
+  # @param schedule [OpenStudio::Model::ScheduleRuleset] OpenStudio schedule object
+  # @return [OpenStudio::Model::ScheduleRuleset] Modified OpenStudio schedule object
   def model_offset_schedule_value(schedule, time_offset_hash)
     offset_sch = schedule.clone(schedule.model).to_ScheduleRuleset.get
 
@@ -2912,8 +2925,8 @@ Standard.class_eval do
   # required to setup/back their thermostat setpoints
   #
   # @param time_offset_hash [Hash] Hash providing time (key) and schedule value offset (values)
-  # @param schedule [OpenStudio::model::ScheduleRuleset] OpenStudio schedule object
-  # @return [OpenStudio::model::ScheduleRuleset] Modified OpenStudio schedule object
+  # @param schedule [OpenStudio::Model::ScheduleRuleset] OpenStudio schedule object
+  # @return [OpenStudio::Model::ScheduleRuleset] Modified OpenStudio schedule object
   def model_set_schedule_value(schedule, time_value_hash)
     return nil unless schedule.to_ScheduleRuleset.is_initialized
 
@@ -2950,8 +2963,8 @@ Standard.class_eval do
 
   # Modify thermostat schedule to account for a thermostat setback/up
   #
-  # @param thermostat [OpenStudio::model::ThermostatSetpointDualSetpoint] OpenStudio ThermostatSetpointDualSetpoint object
-  # @return [Boolean] true if success
+  # @param thermostat [OpenStudio::Model::ThermostatSetpointDualSetpoint] OpenStudio ThermostatSetpointDualSetpoint object
+  # @return [Boolean] returns true if successful, false if not
   def space_occupancy_standby_mode(thermostat)
     return false
   end

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

@@ -4,7 +4,7 @@ class Standard
   # @param model [OpenStudio::Model::Model] OpenStudio model object
   # @param building_type [String] building type
   # @param prototype_input [Hash] hash of prototype inputs
-  # @return [Bool] returns true if successful, false if not
+  # @return [Boolean] returns true if successful, false if not
   def model_add_swh(model, building_type, prototype_input)
     OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.Model', 'Started Adding Service Water Heating')