openstudio-standards 0.2.10.rc2 → 0.2.10.rc3

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

@@ -18,6 +18,8 @@ module CoilDX
       sub_category = 'Single Package'
     elsif coil_dx.name.get.to_s.include?('Split System')
       sub_category = 'Split System'
+    elsif coil_dx.name.get.to_s.include?('Minisplit')
+      sub_category = 'Split System'
     elsif coil_dx.name.get.to_s.include?('CRAC')
       sub_category = 'CRAC'
     end
@@ -73,6 +75,10 @@ module CoilDX
         containing_comp = coil_dx.containingHVACComponent.get
         if containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAir.is_initialized
           htg_type = 'Electric Resistance or None'
+        elsif containing_comp.to_AirLoopHVACUnitarySystem.is_initialized
+          if containing_comp.name.to_s.include? 'Minisplit'
+            htg_type = 'All Other'
+          end
         end # TODO: Add other unitary systems
       elsif coil_dx.containingZoneHVACComponent.is_initialized
         containing_comp = coil_dx.containingZoneHVACComponent.get
@@ -101,6 +107,10 @@ module CoilDX
                    'All Other'
                  elsif !air_loop.supplyComponents('OS:Coil:Heating:DX:SingleSpeed'.to_IddObjectType).empty?
                    'All Other'
+                 elsif !air_loop.supplyComponents('OS:Coil:Heating:DX:MultiSpeed'.to_IddObjectType).empty?
+                   'All Other'
+                 elsif !air_loop.supplyComponents('OS:Coil:Heating:DX:VariableSpeed'.to_IddObjectType).empty?
+                   'All Other'
                  elsif !air_loop.supplyComponents('OS:Coil:Heating:Gas:MultiStage'.to_IddObjectType).empty?
                    'All Other'
                  elsif !air_loop.supplyComponents('OS:Coil:Heating:Desuperheater'.to_IddObjectType).empty?

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

@@ -0,0 +1,176 @@
+class Standard
+  # @!group CoilHeatingWaterToAirHeatPumpEquationFit
+
+  # Finds capacity in W.
+  # This is the cooling capacity of the paired cooling coil.
+  #
+  # @return [Double] capacity in W to be used for find object
+  def coil_heating_water_to_air_heat_pump_find_capacity(coil_heating_water_to_air_heat_pump)
+    capacity_w = nil
+
+    # Get the paired cooling coil
+    clg_coil = nil
+
+    # Unitary and zone equipment
+    if coil_heating_water_to_air_heat_pump.airLoopHVAC.empty?
+      if coil_heating_water_to_air_heat_pump.containingHVACComponent.is_initialized
+        containing_comp = coil_heating_water_to_air_heat_pump.containingHVACComponent.get
+        if containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAir.is_initialized
+          clg_coil = containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAir.get.coolingCoil
+        elsif containing_comp.to_AirLoopHVACUnitarySystem.is_initialized
+          unitary = containing_comp.to_AirLoopHVACUnitarySystem.get
+          if unitary.coolingCoil.is_initialized
+            clg_coil = unitary.coolingCoil.get
+          end
+        end
+      elsif coil_heating_water_to_air_heat_pump.containingZoneHVACComponent.is_initialized
+        containing_comp = coil_heating_water_to_air_heat_pump.containingZoneHVACComponent.get
+        # PTHP
+        if containing_comp.to_ZoneHVACPackagedTerminalHeatPump.is_initialized
+          clg_coil = containing_comp.to_ZoneHVACPackagedTerminalHeatPump.get.coolingCoil
+        # WSHP
+        elsif containing_comp.to_ZoneHVACWaterToAirHeatPump.is_initialized
+          clg_coil = containing_comp.to_ZoneHVACWaterToAirHeatPump.get.coolingCoil
+        end
+      end
+    end
+
+    # On AirLoop directly
+    if coil_heating_water_to_air_heat_pump.airLoopHVAC.is_initialized
+      air_loop = coil_heating_water_to_air_heat_pump.airLoopHVAC.get
+      # Check for the presence of any other type of cooling coil
+      clg_types = ['OS:Coil:Cooling:DX:SingleSpeed',
+                   'OS:Coil:Cooling:DX:TwoSpeed',
+                   'OS:Coil:Cooling:DX:MultiSpeed']
+      clg_types.each do |ct|
+        coils = air_loop.supplyComponents(ct.to_IddObjectType)
+        next if coils.empty?
+
+        clg_coil = coils[0]
+        break # Stop on first cooling coil found
+      end
+    end
+
+    # If no paired cooling coil was found,
+    # throw an error and fall back to the heating capacity of the heating coil
+    if clg_coil.nil?
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingWaterToAirHeatPumpEquationFit', "For #{coil_heating_water_to_air_heat_pump.name}, the paired cooling coil could not be found to determine capacity. Efficiency will incorrectly be based on coil's heating capacity.")
+      if coil_heating_water_to_air_heat_pump.ratedTotalHeatingCapacity.is_initialized
+        capacity_w = coil_heating_water_to_air_heat_pump.ratedTotalHeatingCapacity.get
+      elsif coil_heating_water_to_air_heat_pump.autosizedRatedTotalHeatingCapacity.is_initialized
+        capacity_w = coil_heating_water_to_air_heat_pump.autosizedRatedTotalHeatingCapacity.get
+      else
+        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingWaterToAirHeatPumpEquationFit', "For #{coil_heating_water_to_air_heat_pump.name} capacity is not available, cannot apply efficiency standard to paired heating coil.")
+        return 0.0
+      end
+      return capacity_w
+    end
+
+    # If a coil was found, cast to the correct type
+    if clg_coil.to_CoilCoolingDXSingleSpeed.is_initialized
+      clg_coil = clg_coil.to_CoilCoolingDXSingleSpeed.get
+      capacity_w = coil_cooling_dx_single_speed_find_capacity(clg_coil)
+    elsif clg_coil.to_CoilCoolingDXTwoSpeed.is_initialized
+      clg_coil = clg_coil.to_CoilCoolingDXTwoSpeed.get
+      capacity_w = coil_cooling_dx_two_speed_find_capacity(clg_coil)
+    elsif clg_coil.to_CoilCoolingDXMultiSpeed.is_initialized
+      clg_coil = clg_coil.to_CoilCoolingDXMultiSpeed.get
+      capacity_w = coil_cooling_dx_multi_speed_find_capacity(clg_coil)
+    elsif clg_coil.to_CoilCoolingWaterToAirHeatPumpEquationFit.is_initialized
+      clg_coil = clg_coil.to_CoilCoolingWaterToAirHeatPumpEquationFit.get
+      capacity_w = coil_cooling_water_to_air_heat_pump_find_capacity(clg_coil)
+    end
+
+    return capacity_w
+  end
+
+  # Finds lookup object in standards and return efficiency
+  #
+  # @param rename [Bool] if true, object will be renamed to include capacity and efficiency level
+  # @return [Double] full load efficiency (COP)
+  def coil_heating_water_to_air_heat_pump_standard_minimum_cop(coil_heating_water_to_air_heat_pump, rename = false)
+    search_criteria = {}
+    search_criteria['template'] = template
+    capacity_w = coil_heating_water_to_air_heat_pump_find_capacity(coil_heating_water_to_air_heat_pump)
+    capacity_btu_per_hr = OpenStudio.convert(capacity_w, 'W', 'Btu/hr').get
+    capacity_kbtu_per_hr = OpenStudio.convert(capacity_w, 'W', 'kBtu/hr').get
+
+    # Look up the efficiency characteristics
+    coil_props = model_find_object(standards_data['water_source_heat_pumps_heating'], search_criteria, capacity_btu_per_hr, Date.today)
+
+    # Check to make sure properties were found
+    if coil_props.nil?
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingWaterToAirHeatPumpEquationFit', "For #{coil_heating_water_to_air_heat_pump.name}, cannot find efficiency info using #{search_criteria}, cannot apply efficiency standard.")
+      successfully_set_all_properties = false
+      return successfully_set_all_properties
+    end
+
+    # Get the minimum efficiency standards
+    cop = nil
+
+    # If specified as EER
+    unless coil_props['minimum_coefficient_of_performance_heating'].nil?
+      cop = coil_props['minimum_coefficient_of_performance_heating']
+      new_comp_name = "#{coil_heating_water_to_air_heat_pump.name} #{capacity_kbtu_per_hr.round} Clg kBtu/hr #{cop.round(1)}COPH"
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilHeatingWaterToAirHeatPumpEquationFit', "For #{template}: #{coil_heating_water_to_air_heat_pump.name}: Cooling Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; COPH = #{cop}")
+    end
+
+    # Rename
+    if rename
+      coil_heating_water_to_air_heat_pump.setName(new_comp_name)
+    end
+
+    return cop
+  end
+
+  # Applies the standard efficiency ratings and typical performance curves to this object.
+  #
+  # @return [Bool] true if successful, false if not
+  def coil_heating_water_to_air_heat_pump_apply_efficiency_and_curves(coil_heating_water_to_air_heat_pump, sql_db_vars_map)
+    successfully_set_all_properties = true
+
+    # Get the search criteria
+    search_criteria = {}
+    search_criteria['template'] = template
+    capacity_w = coil_heating_water_to_air_heat_pump_find_capacity(coil_heating_water_to_air_heat_pump)
+    capacity_btu_per_hr = OpenStudio.convert(capacity_w, 'W', 'Btu/hr').get
+
+    # Look up the efficiency characteristics
+    coil_props = model_find_object(standards_data['water_source_heat_pumps_heating'], search_criteria, capacity_btu_per_hr, Date.today)
+
+    # Check to make sure properties were found
+    if coil_props.nil?
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingWaterToAirHeatPumpEquationFit', "For #{coil_heating_water_to_air_heat_pump.name}, cannot find efficiency info using #{search_criteria}, cannot apply efficiency standard.")
+      successfully_set_all_properties = false
+      return sql_db_vars_map
+    end
+
+    # TODO: Add methods to set coefficients, and add coefficients to data spreadsheet
+    # using OS defaults for now
+    # heat_cap_coeff1 = coil_props['heat_cap_coeff1']
+    # if heat_cap_coeff1
+    #   coil_heating_water_to_air_heat_pump.setHeatingCapacityCoefficient1(heat_cap_coeff1)
+    # else
+    #   OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilHeatingWaterToAirHeatPumpEquationFit', "For #{coil_heating_water_to_air_heat_pump.name}, cannot find heat_cap_coeff1, will not be set.")
+    #   successfully_set_all_properties = false
+    # end
+
+    # Preserve the original name
+    orig_name = coil_heating_water_to_air_heat_pump.name.to_s
+
+    # Find the minimum COP and rename with efficiency rating
+    cop = coil_heating_water_to_air_heat_pump_standard_minimum_cop(coil_heating_water_to_air_heat_pump, true)
+
+    # Map the original name to the new name
+    sql_db_vars_map[coil_heating_water_to_air_heat_pump.name.to_s] = orig_name
+
+    # Set the efficiency values
+    unless cop.nil?
+      coil_heating_water_to_air_heat_pump.setRatedHeatingCoefficientofPerformance(cop)
+    end
+
+    return sql_db_vars_map
+  end
+
+
+end

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

@@ -0,0 +1,124 @@
+class Standard
+  # @!group FluidCooler
+
+  # Set the fluid cooler fan power such that the tower
+  # hits the minimum performance (gpm/hp) specified by the standard.
+  # Note that in this case hp is motor nameplate hp, per 90.1.
+  # This method assumes that the fan brake horsepower is 90%
+  # of the motor nameplate hp.
+  # This method determines the minimum motor efficiency
+  # for the nameplate motor hp and sets the actual
+  # fan power by multiplying the brake horsepower
+  # by the efficiency.  Thus the fan power used as
+  # an input to the simulation divided by the design flow
+  # rate will not (and should not)
+  # exactly equal the minimum tower performance.
+  #
+  # @return [Bool] true if successful, false if not
+  def fluid_cooler_apply_minimum_power_per_flow(fluid_cooler)
+    # Get the design water flow rate
+    if fluid_cooler.designWaterFlowRate.is_initialized
+      design_water_flow_m3_per_s = fluid_cooler.designWaterFlowRate.get
+    elsif fluid_cooler.autosizedDesignWaterFlowRate.is_initialized
+      design_water_flow_m3_per_s = fluid_cooler.autosizedDesignWaterFlowRate.get
+    else
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.FluidCooler', "For #{fluid_cooler.name} design water flow rate is not available, cannot apply efficiency standard.")
+      return false
+    end
+    design_water_flow_gpm = OpenStudio.convert(design_water_flow_m3_per_s, 'm^3/s', 'gal/min').get
+
+    # Get the table of fluid cooler efficiencies
+    heat_rejection = standards_data['heat_rejection']
+
+    # Define the criteria to find the fluid cooler properties
+    # in the hvac standards data set.
+    search_criteria = {}
+    search_criteria['template'] = template
+
+    # Closed cooling towers are fluidcooler objects.
+    search_criteria['equipment_type'] = 'Closed Cooling Tower'
+
+    # TODO: Standards replace this with a mechanism to store this
+    # data in the fluid cooler object itself.
+    # For now, retrieve the fan type from the name
+    name = fluid_cooler.name.get
+    if name.include?('Centrifugal')
+      fan_type = 'Centrifugal'
+    elsif name.include?('Propeller or Axial')
+      fan_type = 'Propeller or Axial'
+    else
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.FluidCooler', "Cannot find fan type for #{fluid_cooler.name}. Assuming propeller or axial.")
+      fan_type = 'Propeller or Axial'
+    end
+    unless fan_type.nil?
+      search_criteria['fan_type'] = fan_type
+    end
+
+    # Get the fluid cooler properties
+    ct_props = model_find_object(heat_rejection, search_criteria)
+    unless ct_props
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.FluidCooler', "For #{fluid_cooler.name}, cannot find heat rejection properties, cannot apply standard efficiencies or curves.")
+      return false
+    end
+
+    # Get fluid cooler efficiency
+    min_gpm_per_hp = ct_props['minimum_performance']
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.FluidCooler', "For #{fluid_cooler.name}, design water flow = #{design_water_flow_gpm.round} gpm, minimum performance = #{min_gpm_per_hp} gpm/hp (nameplate).")
+
+    # Calculate the allowed fan brake horsepower
+    # per method used in PNNL prototype buildings.
+    # Assumes that the fan brake horsepower is 90%
+    # of the fan nameplate rated motor power.
+    fan_motor_nameplate_hp = design_water_flow_gpm / min_gpm_per_hp
+    fan_bhp = 0.9 * fan_motor_nameplate_hp
+
+    # Lookup the minimum motor efficiency
+    motors = standards_data['motors']
+
+    # Assuming all fan motors are 4-pole Enclosed
+    search_criteria = {
+      'template' => template,
+      'number_of_poles' => 4.0,
+      'type' => 'Enclosed'
+    }
+
+    motor_properties = model_find_object(motors, search_criteria, fan_motor_nameplate_hp)
+    if motor_properties.nil?
+      OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.FluidCooler', "For #{fluid_cooler.name}, could not find motor properties using search criteria: #{search_criteria}, motor_hp = #{motor_hp} hp.")
+      return false
+    end
+
+    fan_motor_eff = motor_properties['nominal_full_load_efficiency']
+    nominal_hp = motor_properties['maximum_capacity'].to_f.round(1)
+    # Round to nearest whole HP for niceness
+    if nominal_hp >= 2
+      nominal_hp = nominal_hp.round
+    end
+
+    # Calculate the fan motor power
+    fan_motor_actual_power_hp = fan_bhp / fan_motor_eff
+    # Convert to W
+    fan_motor_actual_power_w = fan_motor_actual_power_hp * 745.7 # 745.7 W/HP
+
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.FluidCooler', "For #{fluid_cooler.name}, allowed fan motor nameplate hp = #{fan_motor_nameplate_hp.round(1)} hp, fan brake horsepower = #{fan_bhp.round(1)}, and fan motor actual power = #{fan_motor_actual_power_hp.round(1)} hp (#{fan_motor_actual_power_w.round} W) at #{fan_motor_eff} motor efficiency.")
+
+    # Append the efficiency to the name
+    fluid_cooler.setName("#{fluid_cooler.name} #{min_gpm_per_hp.round(1)} gpm/hp")
+
+    # Hard size the design fan power.
+    # Leave the water flow and air flow autosized.
+    if fluid_cooler.to_FluidCoolerSingleSpeed.is_initialized
+      fluid_cooler.setDesignAirFlowRateFanPower(fan_motor_actual_power_w)
+    elsif fluid_cooler.to_FluidCoolerTwoSpeed.is_initialized
+      fluid_cooler.setHighFanSpeedFanPower(fan_motor_actual_power_w)
+      fluid_cooler.setLowFanSpeedFanPower(0.3 * fan_motor_actual_power_w)
+    elsif fluid_cooler.to_EvaporativeFluidCoolerSingleSpeed.is_initialized
+      fluid_cooler.setFanPoweratDesignAirFlowRate(fan_motor_actual_power_w)
+    elsif fluid_cooler.to_EvaporativeFluidCoolerTwoSpeed.is_initialized
+      fluid_cooler.setHighFanSpeedFanPower(fan_motor_actual_power_w)
+      fluid_cooler.setLowFanSpeedFanPower(0.3 * fan_motor_actual_power_w)
+    end
+
+    return true
+  end
+end

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

@@ -1511,6 +1511,11 @@ class Standard
     model.getCoilCoolingDXTwoSpeeds.sort.each { |obj| sql_db_vars_map = coil_cooling_dx_two_speed_apply_efficiency_and_curves(obj, sql_db_vars_map) }
     model.getCoilCoolingDXSingleSpeeds.sort.each { |obj| sql_db_vars_map = coil_cooling_dx_single_speed_apply_efficiency_and_curves(obj, sql_db_vars_map) }
 
+    # WSHPs
+    # set WSHP heating coils before cooling coils to get cooling coil capacities before they are renamed
+    model.getCoilHeatingWaterToAirHeatPumpEquationFits.sort.each { |obj| sql_db_vars_map = coil_heating_water_to_air_heat_pump_apply_efficiency_and_curves(obj, sql_db_vars_map) }
+    model.getCoilCoolingWaterToAirHeatPumpEquationFits.sort.each { |obj| sql_db_vars_map = coil_cooling_water_to_air_heat_pump_apply_efficiency_and_curves(obj, sql_db_vars_map) }
+
     # Chillers
     clg_tower_objs = model.getCoolingTowerSingleSpeeds
     model.getChillerElectricEIRs.sort.each { |obj| chiller_electric_eir_apply_efficiency_and_curves(obj, clg_tower_objs) }
@@ -1526,11 +1531,18 @@ class Standard
     model.getCoolingTowerTwoSpeeds.sort.each { |obj| cooling_tower_two_speed_apply_efficiency_and_curves(obj) }
     model.getCoolingTowerVariableSpeeds.sort.each { |obj| cooling_tower_variable_speed_apply_efficiency_and_curves(obj) }
 
+    # Fluid Coolers
+    # TODO: enable when evaportive fluid cooler methods and data are available
+    # model.getFluidCoolerSingleSpeeds.sort.each { |obj| fluid_cooler_apply_minimum_power_per_flow(obj) }
+    # model.getFluidCoolerTwoSpeeds.sort.each { |obj| fluid_cooler_apply_minimum_power_per_flow(obj) }
+    # model.getEvaporativeFluidCoolerSingleSpeeds.sort.each { |obj| fluid_cooler_apply_minimum_power_per_flow(obj) }
+    # model.getEvaporativeFluidCoolerTwoSpeeds.sort.each { |obj| fluid_cooler_apply_minimum_power_per_flow(obj) }
+
     # ERVs
     model.getHeatExchangerAirToAirSensibleAndLatents.each { |obj| heat_exchanger_air_to_air_sensible_and_latent_apply_efficiency(obj) }
 
     # Gas Heaters
-    model.getCoilHeatingGass.sort.each {|obj| coil_heating_gas_apply_efficiency_and_curves(obj)}
+    model.getCoilHeatingGass.sort.each { |obj| coil_heating_gas_apply_efficiency_and_curves(obj) }
 
     OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.Model', 'Finished applying HVAC efficiency standards.')
   end

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

@@ -37,7 +37,7 @@ class Standard
       OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.WaterHeaterMixed', "For #{water_heater_mixed.name}, cannot find volume, standard will not be applied.")
       return false
     else
-	  volume_m3 = @instvarbuilding_type == 'MidriseApartment' ? volume_m3.get / 23 : volume_m3.get / water_heater_mixed.component_quantity
+    volume_m3 = @instvarbuilding_type == 'MidriseApartment' ? volume_m3.get / 23 : volume_m3.get / water_heater_mixed.component_quantity
     end
     volume_gal = OpenStudio.convert(volume_m3, 'm^3', 'gal').get
 
@@ -82,7 +82,7 @@ class Standard
       # differently depending on the fuel type
       if fuel_type == 'Electricity'
         # Fixed water heater efficiency per PNNL
-        water_heater_eff = 1
+        water_heater_eff = 1.0
         ua_btu_per_hr_per_f = (41_094 * (1 / ef - 1)) / (24 * 67.5)
       elsif fuel_type == 'NaturalGas'
         # Fixed water heater thermal efficiency per PNNL
@@ -102,13 +102,13 @@ class Standard
         ua_btu_per_hr_per_f = (water_heater_eff - re) * capacity_btu_per_hr / 0.8 / 67.5
       end
       # Two booster water heaters
-	  ua_btu_per_hr_per_f = water_heater_mixed.name.to_s.include?('Booster') ? ua_btu_per_hr_per_f * 2 : ua_btu_per_hr_per_f
+    ua_btu_per_hr_per_f = water_heater_mixed.name.to_s.include?('Booster') ? ua_btu_per_hr_per_f * 2 : ua_btu_per_hr_per_f
     end
 
     # Typically specified this way for large electric water heaters
     if wh_props['standby_loss_base'] && wh_props['standby_loss_volume_allowance']
       # Fixed water heater efficiency per PNNL
-      water_heater_eff = 1
+      water_heater_eff = 1.0
       # Calculate the max allowable standby loss (SL)
       sl_base = wh_props['standby_loss_base']
       sl_drt = wh_props['standby_loss_volume_allowance']
@@ -121,11 +121,11 @@ class Standard
     # Typically specified this way for newer large electric water heaters
     if wh_props['hourly_loss_base'] && wh_props['hourly_loss_volume_allowance']
       # Fixed water heater efficiency per PNNL
-      water_heater_eff = 1
+      water_heater_eff = 1.0
       # Calculate the percent loss per hr
       hr_loss_base = wh_props['hourly_loss_base']
       hr_loss_allow = wh_props['hourly_loss_volume_allowance']
-      hrly_loss_pct = hr_loss_base + (hr_loss_allow / volume_gal) / 100
+      hrly_loss_pct = hr_loss_base + (hr_loss_allow / volume_gal) / 100.0
       # Convert to Btu/hr, assuming:
       # Water at 120F, density = 8.25 lb/gal
       # 1 Btu to raise 1 lb of water 1 F

data/lib/openstudio-standards/standards/ashrae_90_1/ashrae_90_1_2004/data/ashrae_90_1_2004.water_source_heat_pumps.json

@@ -0,0 +1,31 @@
+{
+  "water_source_heat_pumps": [
+    {
+      "template": "90.1-2004",
+      "minimum_capacity": 0.0,
+      "maximum_capacity": 16999.0,
+      "start_date": "1919-09-09T00:00:00+00:00",
+      "end_date": "2999-09-09T00:00:00+00:00",
+      "minimum_full_load_efficiency": 11.2,
+      "notes": "From 90.1-2004 Table 6.8.1B"
+    },
+    {
+      "template": "90.1-2004",
+      "minimum_capacity": 17000.0,
+      "maximum_capacity": 64999.0,
+      "start_date": "1919-09-09T00:00:00+00:00",
+      "end_date": "2999-09-09T00:00:00+00:00",
+      "minimum_full_load_efficiency": 12.0,
+      "notes": "From 90.1-2004 Table 6.8.1B"
+    },
+    {
+      "template": "90.1-2004",
+      "minimum_capacity": 65000.0,
+      "maximum_capacity": 134999.0,
+      "start_date": "1919-09-09T00:00:00+00:00",
+      "end_date": "2999-09-09T00:00:00+00:00",
+      "minimum_full_load_efficiency": 12.0,
+      "notes": "From 90.1-2004 Table 6.8.1B"
+    }
+  ]
+}

data/lib/openstudio-standards/standards/ashrae_90_1/ashrae_90_1_2004/data/ashrae_90_1_2004.water_source_heat_pumps_heating.json

@@ -0,0 +1,13 @@
+{
+  "water_source_heat_pumps_heating": [
+    {
+      "template": "90.1-2004",
+      "minimum_capacity": 0.0,
+      "maximum_capacity": 9999999.0,
+      "start_date": "1919-09-09T00:00:00+00:00",
+      "end_date": "2999-09-09T00:00:00+00:00",
+      "minimum_coefficient_of_performance_heating": 4.2,
+      "notes": "From 90.1-2004 Table 6.8.1B"
+    }
+  ]
+}