openstudio-standards 0.7.1 → 0.8.0.rc1

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

@@ -0,0 +1,66 @@
+class Standard
+  # @!group Motor
+
+  # Determine the type of motor to model
+  #
+  # @param nominal_hp [Float] nominal or nameplate motor horsepower
+  # @return [String] motor type
+  def motor_type(nominal_hp)
+    return 'PSC'
+  end
+
+  # Determine the efficiency of fractional horsepower motors
+  #
+  # @param nominal_hp [Float] nominal or nameplate motor horsepower
+  # @param motor_type [String] motor type, either 'PSC' or 'ECM'
+  # @return [Hash, NilClass] motor efficiency
+  def motor_fractional_hp_efficiencies(nominal_hp, motor_type = 'PSC')
+    # Unless specified otherwise, the efficiencies are calculated from
+    # Table 5-3 from Energy Savings Potential and Research & Development Opportunities for Commercial Refrigeration, Navigant, 2009
+    # https://www1.eere.energy.gov/buildings/pdfs/commercial_refrigeration_equipment_research_opportunities.pdf
+    #
+    # efficiency = (rated shaft output) / (input power)
+    case motor_type
+    when 'PSC'
+      if nominal_hp <= 1.0 / 20.0
+        efficiency = 37.0 / 70.0
+      elsif nominal_hp <= 1.0 / 15.0
+        efficiency = 50.0 / 90.0
+      elsif nominal_hp <= 1.0 / 6.0
+        efficiency = 125.0 / 202.0
+      elsif nominal_hp <= 1.0 / 3.0
+        efficiency = 249.0 / 370.0
+      elsif nominal_hp <= 1.0 / 2.0
+        efficiency = 373.0 / 530.0
+      elsif nominal_hp <= 3.0 / 4.0
+        efficiency = 560.0 / 699.0 # data obtained from motorboss.com
+      else
+        return nil
+      end
+    when 'ECM'
+      if nominal_hp <= 1.0 / 20.0
+        efficiency = 37.0 / 49.0
+      elsif nominal_hp <= 1.0 / 15.0
+        efficiency = 50.0 / 65.0
+      elsif nominal_hp <= 1.0 / 6.0
+        efficiency = 125.0 / 155.0
+      elsif nominal_hp <= 1.0 / 3.0
+        efficiency = 249.0 / 304.0
+      elsif nominal_hp <= 1.0 / 2.0
+        efficiency = 373.0 / 450.0
+      elsif nominal_hp <= 3.0 / 4.0
+        efficiency = 560.0 / 674.0 # data obtained from motorboss.com
+      else
+        return nil
+      end
+    else
+      OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.motor', "#{motor_type} was passed as a motor_type, it should either be ECM or PSC.")
+      return nil
+    end
+    motor_properties = {
+      'nominal_full_load_efficiency' => efficiency,
+      'maximum_capacity' => nominal_hp
+    }
+    return motor_properties
+  end
+end

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

@@ -190,7 +190,8 @@ class Standard
                                                          stds_type,
                                                          occ_type,
                                                          wwr_building_type: surface_std_wwr_type,
-                                                         wwr_info: wwr_info)
+                                                         wwr_info: wwr_info,
+                                                         surface: planar_surface)
       if !new_construction == false
         previous_construction_map[type] = new_construction
       end

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

@@ -113,7 +113,7 @@ module Pump
   # Determines the minimum pump motor efficiency and nominal size
   # for a given motor bhp.  This should be the total brake horsepower with
   # any desired safety factor already included.  This method picks
-  # the next nominal motor catgory larger than the required brake
+  # the next nominal motor category larger than the required brake
   # horsepower, and the efficiency is based on that size.  For example,
   # if the bhp = 6.3, the nominal size will be 7.5HP and the efficiency
   # for 90.1-2010 will be 91.7% from Table 10.8B.  This method assumes
@@ -125,24 +125,47 @@ module Pump
   # @return [Array<Double>] minimum motor efficiency (0.0 to 1.0), nominal horsepower
   def pump_standard_minimum_motor_efficiency_and_size(pump, motor_bhp)
     motor_eff = 0.85
-    nominal_hp = motor_bhp
+    # 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.
+    # Source: Thornton et al. (2011), Achieving the 30% Goal: Energy and Cost Savings Analysis of ASHRAE Standard 90.1-2010, Section 4.5.4
+    nominal_hp = motor_bhp * 1.1
 
     # Don't attempt to look up motor efficiency
     # for zero-hp pumps (required for circulation-pump-free
     # service water heating systems).
     return [1.0, 0] if motor_bhp < 0.0001 # under 1 watt
 
-    # Lookup the minimum motor efficiency
-    motors = standards_data['motors']
+    if nominal_hp <= 0.75
+      motor_type = motor_type(nominal_hp)
+      motor_properties = motor_fractional_hp_efficiencies(nominal_hp, motor_type = motor_type)
+    else
+      # Lookup the minimum motor efficiency
+      motors = standards_data['motors']
+
+      # Assuming all pump motors are 4-pole ODP
+      search_criteria = {
+        'template' => template,
+        'number_of_poles' => 4.0,
+        'type' => 'Enclosed'
+      }
+
+      # Use the efficiency largest motor efficiency when BHP is greater than the largest size for which a requirement is provided
+      data = model_find_objects(motors, search_criteria)
+      maximum_capacity = model_find_maximum_value(data, 'maximum_capacity')
+      if motor_bhp > maximum_capacity
+        motor_bhp = maximum_capacity
+      end
+
+      motor_properties = model_find_object(motors, search_criteria, capacity = nil, date = Date.today, area = nil, num_floors = nil, fan_motor_bhp = motor_bhp)
 
-    # Assuming all pump motors are 4-pole ODP
-    search_criteria = {
-      'template' => template,
-      'number_of_poles' => 4.0,
-      'type' => 'Enclosed'
-    }
+      if motor_properties.nil?
+        # Retry without the date
+        motor_properties = model_find_object(motors, search_criteria, capacity = nil, date = nil, area = nil, num_floors = nil, fan_motor_bhp = motor_bhp)
+      end
+    end
 
-    motor_properties = model_find_object(motors, search_criteria, motor_bhp)
     if motor_properties.nil?
       OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Pump', "For #{pump.name}, could not find motor properties using search criteria: #{search_criteria}, motor_bhp = #{motor_bhp} hp.")
       return [motor_eff, nominal_hp]
@@ -155,15 +178,6 @@ module Pump
       nominal_hp = nominal_hp.round
     end
 
-    # Get the efficiency based on the nominal horsepower
-    # Add 0.01 hp to avoid search errors.
-    motor_properties = model_find_object(motors, search_criteria, nominal_hp + 0.01)
-    if motor_properties.nil?
-      OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Fan', "For #{pump.name}, could not find nominal motor properties using search criteria: #{search_criteria}, motor_hp = #{nominal_hp} hp.")
-      return [motor_eff, nominal_hp]
-    end
-    motor_eff = motor_properties['nominal_full_load_efficiency']
-
     return [motor_eff, nominal_hp]
   end
 

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

@@ -221,285 +221,6 @@ class Standard
     return true
   end
 
-  # add typical swh demand and supply to model
-  #
-  # @param model [OpenStudio::Model::Model] OpenStudio model object
-  # @param water_heater_fuel [String] water heater fuel. Valid choices are NaturalGas, Electricity, and HeatPump.
-  #   If not supplied, a smart default will be determined based on building type.
-  # @param pipe_insul_in [Double] thickness of the pipe insulation, in inches.
-  # @param circulating [String] whether the (circulating, noncirculating, nil) nil is smart
-  # @return [Array<OpenStudio::Model::PlantLoop>] hot water loops
-  # @todo - add in losses from tank and pipe insulation, etc.
-  def model_add_typical_swh(model,
-                            water_heater_fuel: nil,
-                            pipe_insul_in: nil,
-                            circulating: nil)
-    # array of hot water loops
-    swh_systems = []
-
-    # hash of general water use equipment awaiting loop
-    water_use_equipment_hash = {} # key is standards building type value is array of water use equipment
-
-    # create space type hash (need num_units for MidriseApartment and RetailStripmall)
-    space_type_hash = model_create_space_type_hash(model, trust_effective_num_spaces = false)
-
-    # loop through space types adding demand side of swh
-    model.getSpaceTypes.sort.each do |space_type|
-      next unless space_type.standardsBuildingType.is_initialized
-      next unless space_type_hash.key?(space_type) # this is used for space types without any floor area
-
-      stds_bldg_type = space_type.standardsBuildingType.get
-
-      # lookup space_type_properties
-      space_type_properties = space_type_get_standards_data(space_type)
-      peak_flow_rate_gal_per_hr_per_ft2 = space_type_properties['service_water_heating_peak_flow_per_area'].to_f
-      peak_flow_rate_gal_per_hr = space_type_properties['service_water_heating_peak_flow_rate'].to_f
-      swh_system_type = space_type_properties['service_water_heating_system_type']
-      flow_rate_fraction_schedule = model_add_schedule(model, space_type_properties['service_water_heating_schedule'])
-      service_water_temperature_f = space_type_properties['service_water_heating_target_temperature'].to_f
-      service_water_temperature_c = OpenStudio.convert(service_water_temperature_f, 'F', 'C').get
-      booster_water_temperature_f = space_type_properties['booster_water_heating_target_temperature'].to_f
-      booster_water_temperature_c = OpenStudio.convert(booster_water_temperature_f, 'F', 'C').get
-      booster_water_heater_fraction = space_type_properties['booster_water_heater_fraction'].to_f
-      service_water_fraction_sensible = space_type_properties['service_water_heating_fraction_sensible']
-      service_water_fraction_latent = space_type_properties['service_water_heating_fraction_latent']
-      floor_area_m2 = space_type_hash[space_type][:floor_area]
-      floor_area_ft2 = OpenStudio.convert(floor_area_m2, 'm^2', 'ft^2').get
-
-      # next if no service water heating demand
-      next unless peak_flow_rate_gal_per_hr_per_ft2 > 0.0 || peak_flow_rate_gal_per_hr > 0.0
-
-      # If there is no SWH schedule specified, assume
-      # that there should be no SWH consumption for this space type.
-      unless flow_rate_fraction_schedule
-        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.model.Model', "No service water heating schedule was specified for #{space_type.name}, an always off schedule will be used and no water will be used.")
-        flow_rate_fraction_schedule = model.alwaysOffDiscreteSchedule
-      end
-
-      # Determine flow rate
-      case swh_system_type
-      when 'One Per Unit'
-        water_heater_fuel = 'Electricity' if water_heater_fuel.nil?
-        num_units = space_type_hash[space_type][:num_units].round # First try number of units
-        num_units = space_type_hash[space_type][:effective_num_spaces].round if num_units.zero? # Fall back on number of spaces
-        peak_flow_rate_gal_per_hr = num_units * peak_flow_rate_gal_per_hr
-        peak_flow_rate_m3_per_s = OpenStudio.convert(peak_flow_rate_gal_per_hr, 'gal/hr', 'm^3/s').get
-        use_name = "#{space_type.name} #{num_units} units"
-      else
-        # @todo add building type or sice specific logic or just assume Gas?
-        #   (SmallOffice and Warehouse are only non unit prototypes with Electric heating)
-        water_heater_fuel = 'NaturalGas' if water_heater_fuel.nil?
-        num_units = 1
-        peak_flow_rate_gal_per_hr = peak_flow_rate_gal_per_hr_per_ft2 * floor_area_ft2
-        peak_flow_rate_m3_per_s = OpenStudio.convert(peak_flow_rate_gal_per_hr, 'gal/hr', 'm^3/s').get
-        use_name = space_type.name.to_s
-      end
-
-      # Split flow rate between main and booster uses if specified
-      booster_water_use_equip = nil
-      if booster_water_heater_fraction > 0.0
-        booster_peak_flow_rate_m3_per_s = peak_flow_rate_m3_per_s * booster_water_heater_fraction
-        peak_flow_rate_m3_per_s -= booster_peak_flow_rate_m3_per_s
-
-        # Add booster water heater equipment and connections
-        booster_water_use_equip = OpenstudioStandards::ServiceWaterHeating.create_water_use(model,
-                                                                                            name: "Booster #{use_name}",
-                                                                                            flow_rate: booster_peak_flow_rate_m3_per_s,
-                                                                                            flow_rate_fraction_schedule: flow_rate_fraction_schedule,
-                                                                                            water_use_temperature: booster_water_temperature_c,
-                                                                                            sensible_fraction: service_water_fraction_sensible,
-                                                                                            latent_fraction: service_water_fraction_latent)
-      end
-
-      # Add water use equipment and connections
-      water_use_equip = OpenstudioStandards::ServiceWaterHeating.create_water_use(model,
-                                                                                  name: use_name,
-                                                                                  flow_rate: peak_flow_rate_m3_per_s,
-                                                                                  flow_rate_fraction_schedule: flow_rate_fraction_schedule,
-                                                                                  water_use_temperature: service_water_temperature_c,
-                                                                                  sensible_fraction: service_water_fraction_sensible,
-                                                                                  latent_fraction: service_water_fraction_latent)
-
-      # Water heater sizing
-      case swh_system_type
-      when 'One Per Unit'
-        water_heater_capacity_w = num_units * OpenStudio.convert(20.0, 'kBtu/hr', 'W').get
-        water_heater_volume_m3 = num_units * OpenStudio.convert(50.0, 'gal', 'm^3').get
-        num_water_heaters = num_units
-      else
-        water_use_equips = [water_use_equip]
-        water_use_equips << booster_water_use_equip unless booster_water_use_equip.nil? # Include booster in sizing since flows will be preheated by main water heater
-        water_heater_sizing = model_find_water_heater_capacity_volume_and_parasitic(model, water_use_equips)
-        water_heater_capacity_w = water_heater_sizing[:water_heater_capacity]
-        water_heater_volume_m3 = water_heater_sizing[:water_heater_volume]
-        num_water_heaters = 1
-      end
-
-      # Add either a dedicated SWH loop or save to add to shared SWH loop
-      case swh_system_type
-      when 'Shared'
-
-        # Store water use equip by building type to add to shared building hot water loop
-        if water_use_equipment_hash.key?(stds_bldg_type)
-          water_use_equipment_hash[stds_bldg_type] << water_use_equip
-        else
-          water_use_equipment_hash[stds_bldg_type] = [water_use_equip]
-        end
-
-      when 'One Per Unit', 'Dedicated'
-        pipe_insul_in = 0.0 if pipe_insul_in.nil?
-
-        # Add service water loop with water heater
-        swh_loop = OpenstudioStandards::ServiceWaterHeating.create_service_water_heating_loop(model,
-                                                                                              system_name: "#{space_type.name} Service Water Loop",
-                                                                                              service_water_temperature: service_water_temperature_c,
-                                                                                              service_water_pump_head: 0.01,
-                                                                                              service_water_pump_motor_efficiency: 1.0,
-                                                                                              water_heater_capacity: water_heater_capacity_w,
-                                                                                              water_heater_volume: water_heater_volume_m3,
-                                                                                              water_heater_fuel: water_heater_fuel,
-                                                                                              number_of_water_heaters: num_water_heaters,
-                                                                                              add_piping_losses: true,
-                                                                                              pipe_insulation_thickness: OpenStudio.convert(pipe_insul_in, 'in', 'm').get,
-                                                                                              floor_area: OpenStudio.convert(950, 'ft^2', 'm^2').get,
-                                                                                              number_of_stories: 1)
-
-        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.Model.Model', "In model_add_typical, num_water_heaters = #{num_water_heaters}")
-        # Add loop to list
-        swh_systems << swh_loop
-
-        # Attach water use equipment to the loop
-        swh_connection = water_use_equip.waterUseConnections
-        swh_loop.addDemandBranchForComponent(swh_connection.get) if swh_connection.is_initialized
-
-        # If a booster fraction is specified, some percentage of the water
-        # is assumed to be heated beyond the normal temperature by a separate
-        # booster water heater.  This booster water heater is fed by the
-        # main water heater, so the booster is responsible for a smaller delta-T.
-        if booster_water_heater_fraction > 0
-          # find_water_heater_capacity_volume_and_parasitic
-          booster_water_heater_sizing = model_find_water_heater_capacity_volume_and_parasitic(model,
-                                                                                              [booster_water_use_equip],
-                                                                                              htg_eff: 1.0,
-                                                                                              inlet_temp_f: service_water_temperature_f,
-                                                                                              target_temp_f: booster_water_temperature_f)
-
-          # Add service water booster loop with water heater
-          # Note that booster water heaters are always assumed to be electric resistance
-          swh_booster_loop = OpenstudioStandards::ServiceWaterHeating.create_booster_water_heating_loop(model,
-                                                                                                        water_heater_capacity: booster_water_heater_sizing[:water_heater_capacity],
-                                                                                                        service_water_temperature: booster_water_temperature_c,
-                                                                                                        service_water_loop: swh_loop)
-
-          # Rename the service water booster loop
-          swh_booster_loop.setName("#{space_type.name} Service Water Booster Loop")
-
-          # Attach booster water use equipment to the booster loop
-          booster_swh_connection = booster_water_use_equip.waterUseConnections
-          swh_booster_loop.addDemandBranchForComponent(booster_swh_connection.get) if booster_swh_connection.is_initialized
-        end
-
-      else
-        OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.Model', "'#{swh_system_type}' is not a valid Service Water Heating System Type, cannot add SWH to #{space_type.name}.  Valid choices are One Per Unit, Dedicated, and Shared.")
-      end
-    end
-
-    # get building floor area and effective number of stories
-    bldg_floor_area_m2 = model.getBuilding.floorArea
-    bldg_effective_num_stories_hash = model_effective_num_stories(model)
-    bldg_effective_num_stories = bldg_effective_num_stories_hash[:below_grade] + bldg_effective_num_stories_hash[:above_grade]
-
-    # add non-dedicated system(s) here. Separate systems for water use equipment from different building types
-    water_use_equipment_hash.sort.each do |stds_bldg_type, water_use_equipment_array|
-      # @todo find the water use equipment with the highest temperature
-      water_heater_temp_f = 140.0
-      water_heater_temp_c = OpenStudio.convert(water_heater_temp_f, 'F', 'C').get
-
-      # find pump values
-      # Table A.2 in PrototypeModelEnhancements_2014_0.pdf shows 10ft on everything except SecondarySchool which has 11.4ft
-      # @todo Remove hard-coded building-type-based lookups for circulating vs. non-circulating SWH systems
-      circulating_bldg_types = [
-        # DOE building types
-        'Office',
-        'PrimarySchool',
-        'Outpatient',
-        'Hospital',
-        'SmallHotel',
-        'LargeHotel',
-        'FullServiceRestaurant',
-        'HighriseApartment',
-        # DEER building types
-        'Asm', # 'Assembly'
-        'ECC', # 'Education - Community College'
-        'EPr', # 'Education - Primary School'
-        'ERC', # 'Education - Relocatable Classroom'
-        'ESe', # 'Education - Secondary School'
-        'EUn', # 'Education - University'
-        'Gro', # 'Grocery'
-        'Hsp', # 'Health/Medical - Hospital'
-        'Htl', # 'Lodging - Hotel'
-        'MBT', # 'Manufacturing Biotech'
-        'MFm', # 'Residential Multi-family'
-        'Mtl', # 'Lodging - Motel'
-        'Nrs', # 'Health/Medical - Nursing Home'
-        'OfL', # 'Office - Large'
-        # 'RFF', # 'Restaurant - Fast-Food'
-        'RSD' # 'Restaurant - Sit-Down'
-      ]
-      if circulating_bldg_types.include?(stds_bldg_type)
-        service_water_pump_head_pa = OpenStudio.convert(10.0, 'ftH_{2}O', 'Pa').get
-        service_water_pump_motor_efficiency = 0.3
-        circulating = true if circulating.nil?
-        pipe_insul_in = 0.5 if pipe_insul_in.nil?
-      else # values for non-circulating pump
-        service_water_pump_head_pa = 0.01
-        service_water_pump_motor_efficiency = 1.0
-        circulating = false if circulating.nil?
-        pipe_insul_in = 0.0 if pipe_insul_in.nil?
-      end
-
-      bldg_type_floor_area_m2 = 0.0
-      space_type_hash.sort.each do |space_type, space_type_props|
-        bldg_type_floor_area_m2 += space_type_props[:floor_area] if space_type_props[:stds_bldg_type] == stds_bldg_type
-      end
-
-      # Calculate the number of stories covered by this building type
-      num_stories = bldg_effective_num_stories * (bldg_type_floor_area_m2 / bldg_floor_area_m2)
-
-      # Water heater sizing
-      water_heater_sizing = model_find_water_heater_capacity_volume_and_parasitic(model, water_use_equipment_array)
-      water_heater_capacity_w = water_heater_sizing[:water_heater_capacity]
-      water_heater_volume_m3 = water_heater_sizing[:water_heater_volume]
-
-      # Add a shared service water heating loop with water heater
-      shared_swh_loop = OpenstudioStandards::ServiceWaterHeating.create_service_water_heating_loop(model,
-                                                                                                   system_name: "#{stds_bldg_type} Shared Service Water Loop",
-                                                                                                   service_water_temperature: water_heater_temp_c,
-                                                                                                   service_water_pump_head: service_water_pump_head_pa,
-                                                                                                   service_water_pump_motor_efficiency: service_water_pump_motor_efficiency,
-                                                                                                   water_heater_capacity: water_heater_capacity_w,
-                                                                                                   water_heater_volume: water_heater_volume_m3,
-                                                                                                   water_heater_fuel: water_heater_fuel,
-                                                                                                   add_piping_losses: true,
-                                                                                                   pipe_insulation_thickness: OpenStudio.convert(pipe_insul_in, 'in', 'm').get,
-                                                                                                   floor_area: bldg_type_floor_area_m2,
-                                                                                                   number_of_stories: num_stories)
-
-      # Attach all water use equipment to the shared loop
-      water_use_equipment_array.sort.each do |water_use_equip|
-        swh_connection = water_use_equip.waterUseConnections
-        shared_swh_loop.addDemandBranchForComponent(swh_connection.get) if swh_connection.is_initialized
-      end
-
-      # add to list of systems
-      swh_systems << shared_swh_loop
-
-      OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.Model', "Adding shared water heating loop for #{stds_bldg_type}.")
-    end
-
-    return swh_systems
-  end
-
   # This method will add a swh water fixture to the model for the space.
   # It will return a water fixture object, or NIL if there is no water load at all.
   #
@@ -583,78 +304,4 @@ class Standard
 
     return water_fixture
   end
-
-  # Use rules from DOE Prototype Building documentation to determine water heater capacity,
-  # volume, pipe dump losses, and pipe thermal losses.
-  #
-  # @param model [OpenStudio::Model::Model] OpenStudio model object
-  # @param water_use_equipment_array [Array] array of water use equipment objects that will be using this water heater
-  # @param storage_to_cap_ratio_gal_to_kbtu_per_hr [Double] storage volume gal to kBtu/hr of capacity
-  # @param htg_eff [Double] water heater thermal efficiency, fraction
-  # @param inlet_temp_f [Double] inlet cold water temperature, degrees Fahrenheit
-  # @param target_temp_f [Double] target supply water temperature from the tank, degrees Fahrenheit
-  # @return [Hash] hash with values needed to size water heater made with downstream method
-  def model_find_water_heater_capacity_volume_and_parasitic(model,
-                                                            water_use_equipment_array,
-                                                            storage_to_cap_ratio_gal_to_kbtu_per_hr: 1.0,
-                                                            htg_eff: 0.8,
-                                                            inlet_temp_f: 40.0,
-                                                            target_temp_f: 140.0,
-                                                            peak_flow_fraction: 1.0)
-    # A.1.4 Total Storage Volume and Water Heater Capacity of PrototypeModelEnhancements_2014_0.pdf shows 1 gallon of storage to 1 kBtu/h of capacity
-
-    water_heater_sizing = {}
-
-    # Get the maximum flow rates for all pieces of water use equipment
-    adjusted_max_flow_rates_gal_per_hr = [] # gallons per hour
-    water_use_equipment_array.sort.each do |water_use_equip|
-      water_use_equip_sch = water_use_equip.flowRateFractionSchedule
-      next if water_use_equip_sch.empty?
-
-      water_use_equip_sch = water_use_equip_sch.get
-      if water_use_equip_sch.to_ScheduleRuleset.is_initialized
-        water_use_equip_sch = water_use_equip_sch.to_ScheduleRuleset.get
-        max_sch_value = OpenstudioStandards::Schedules.schedule_ruleset_get_min_max(water_use_equip_sch)['max']
-      elsif water_use_equip_sch.to_ScheduleConstant.is_initialized
-        water_use_equip_sch = water_use_equip_sch.to_ScheduleConstant.get
-        max_sch_value = OpenstudioStandards::Schedules.schedule_constant_get_min_max(water_use_equip_sch)['max']
-      elsif water_use_equip_sch.to_ScheduleCompact.is_initialized
-        water_use_equip_sch = water_use_equip_sch.to_ScheduleCompact.get
-        max_sch_value = OpenstudioStandards::Schedules.schedule_compact_get_min_max(water_use_equip_sch)['max']
-      else
-        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.model.Model', "The peak flow rate fraction for #{water_use_equip_sch.name} could not be determined, assuming 1 for water heater sizing purposes.")
-        max_sch_value = 1.0
-      end
-
-      # Get peak flow rate from water use equipment definition
-      peak_flow_rate_m3_per_s = water_use_equip.waterUseEquipmentDefinition.peakFlowRate
-
-      # Calculate adjusted flow rate based on the peak fraction found in the flow rate fraction schedule
-      adjusted_peak_flow_rate_m3_per_s = max_sch_value * peak_flow_rate_m3_per_s
-      adjusted_max_flow_rates_gal_per_hr << OpenStudio.convert(adjusted_peak_flow_rate_m3_per_s, 'm^3/s', 'gal/hr').get
-    end
-
-    # Sum gph values from water use equipment to use in formula
-    total_adjusted_flow_rate_gal_per_hr = adjusted_max_flow_rates_gal_per_hr.inject(:+)
-
-    # Calculate capacity based on analysis of combined water use equipment maximum flow rates and schedules
-    # Max gal/hr * 8.4 lb/gal * 1 Btu/lb F * (120F - 40F)/0.8 = Btu/hr
-    water_heater_capacity_btu_per_hr = peak_flow_fraction * total_adjusted_flow_rate_gal_per_hr * 8.4 * 1.0 * (target_temp_f - inlet_temp_f) / htg_eff
-    OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.Model', "Capacity of #{water_heater_capacity_btu_per_hr.round} Btu/hr = #{peak_flow_fraction} peak fraction * #{total_adjusted_flow_rate_gal_per_hr.round} gal/hr * 8.4 lb/gal * 1.0 Btu/lb F * (#{target_temp_f.round} - #{inlet_temp_f.round} deltaF / #{htg_eff} htg eff).")
-    water_heater_capacity_m3_per_s = OpenStudio.convert(water_heater_capacity_btu_per_hr, 'Btu/hr', 'W').get
-
-    # Calculate volume based on capacity
-    # Default assumption is 1 gal of volume per 1 kBtu/hr of heating capacity
-    water_heater_capacity_kbtu_per_hr = OpenStudio.convert(water_heater_capacity_btu_per_hr, 'Btu/hr', 'kBtu/hr').get
-    water_heater_volume_gal = water_heater_capacity_kbtu_per_hr * storage_to_cap_ratio_gal_to_kbtu_per_hr
-    # increase tank size to 40 galons if calculated value is smaller
-    water_heater_volume_gal = 40.0 if water_heater_volume_gal < 40.0 # gal
-    water_heater_volume_m3 = OpenStudio.convert(water_heater_volume_gal, 'gal', 'm^3').get
-
-    # Populate return hash
-    water_heater_sizing[:water_heater_capacity] = water_heater_capacity_m3_per_s
-    water_heater_sizing[:water_heater_volume] = water_heater_volume_m3
-
-    return water_heater_sizing
-  end
 end

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

@@ -1243,110 +1243,6 @@ class Standard
     return [sensor_1_frac, sensor_2_frac, sensor_1_window, sensor_2_window]
   end
 
-  # Set the infiltration rate for this space to include the impact of air leakage requirements in the standard.
-  #
-  # @param space [OpenStudio::Model::Space] space object
-  # @return [Double] true if successful, false if not
-  # @todo handle doors and vestibules
-  def space_apply_infiltration_rate(space)
-    # data center keeps positive pressure all the time, so no infiltration
-    if space.spaceType.is_initialized && space.spaceType.get.standardsSpaceType.is_initialized
-      std_space_type = space.spaceType.get.standardsSpaceType.get
-      if std_space_type.downcase.include?('data center') || std_space_type.downcase.include?('datacenter')
-        return true
-      end
-
-      if space.spaceType.get.standardsBuildingType.is_initialized
-        std_bldg_type = space.spaceType.get.standardsBuildingType.get
-        if std_bldg_type.downcase.include?('datacenter') && std_space_type.downcase.include?('computerroom')
-          return true
-        end
-      end
-    end
-
-    # Determine the total building baseline infiltration rate in cfm per ft2 of exterior above grade wall area at 75 Pa
-    # exterior above grade envelope area includes any surface with boundary condition 'Outdoors' in OpenStudio/EnergyPlus
-    basic_infil_rate_cfm_per_ft2 = space_infiltration_rate_75_pa(space)
-
-    # Do nothing if no infiltration
-    return true if basic_infil_rate_cfm_per_ft2.zero?
-
-    # Conversion factor
-    # 1 m^3/s*m^2 = 196.85 cfm/ft2
-    conv_fact = 196.85
-
-    # Adjust the infiltration rate to the average pressure for the prototype buildings.
-    adj_infil_rate_cfm_per_ft2 = OpenstudioStandards::Infiltration.adjust_infiltration_to_prototype_building_conditions(basic_infil_rate_cfm_per_ft2)
-    adj_infil_rate_m3_per_s_per_m2 = adj_infil_rate_cfm_per_ft2 / conv_fact
-    # Get the exterior wall area
-    exterior_wall_and_window_area_m2 =  OpenstudioStandards::Geometry.space_get_exterior_wall_and_subsurface_area(space)
-
-    # Don't create an object if there is no exterior wall area
-    if exterior_wall_and_window_area_m2 <= 0.0
-      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Space', "For #{space.name}, no exterior wall area was found, no infiltration will be added.")
-      return true
-    end
-    OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Space', "For #{space.name}, set infiltration rate to #{adj_infil_rate_cfm_per_ft2.round(3)} cfm/ft2 exterior wall area (aka #{basic_infil_rate_cfm_per_ft2} cfm/ft2 @75Pa).")
-
-    # Calculate the total infiltration, assuming
-    # that it only occurs through exterior walls
-    tot_infil_m3_per_s = adj_infil_rate_m3_per_s_per_m2 * exterior_wall_and_window_area_m2
-
-    # Now spread the total infiltration rate over all
-    # exterior surface areas (for the E+ input field)
-    all_ext_infil_m3_per_s_per_m2 = tot_infil_m3_per_s / space.exteriorArea
-
-    OpenStudio.logFree(OpenStudio::Debug, 'openstudio.standards.Space', "For #{space.name}, adj infil = #{all_ext_infil_m3_per_s_per_m2.round(8)} m^3/s*m^2.")
-
-    # Get any infiltration schedule already assigned to this space or its space type
-    # If not, the always on schedule will be applied.
-    infil_sch = nil
-    unless space.spaceInfiltrationDesignFlowRates.empty?
-      old_infil = space.spaceInfiltrationDesignFlowRates[0]
-      if old_infil.schedule.is_initialized
-        infil_sch = old_infil.schedule.get
-      end
-    end
-
-    if infil_sch.nil? && space.spaceType.is_initialized
-      space_type = space.spaceType.get
-      unless space_type.spaceInfiltrationDesignFlowRates.empty?
-        old_infil = space_type.spaceInfiltrationDesignFlowRates[0]
-        if old_infil.schedule.is_initialized
-          infil_sch = old_infil.schedule.get
-        end
-      end
-    end
-
-    if infil_sch.nil?
-      infil_sch = space.model.alwaysOnDiscreteSchedule
-    end
-
-    # Create an infiltration rate object for this space
-    infiltration = OpenStudio::Model::SpaceInfiltrationDesignFlowRate.new(space.model)
-    infiltration.setName("#{space.name} Infiltration")
-    # infiltration.setFlowperExteriorWallArea(adj_infil_rate_m3_per_s_per_m2)
-    infiltration.setFlowperExteriorSurfaceArea(all_ext_infil_m3_per_s_per_m2.round(13))
-    infiltration.setSchedule(infil_sch)
-    infiltration.setConstantTermCoefficient(0.0)
-    infiltration.setTemperatureTermCoefficient 0.0
-    infiltration.setVelocityTermCoefficient(0.224)
-    infiltration.setVelocitySquaredTermCoefficient(0.0)
-
-    infiltration.setSpace(space)
-
-    return true
-  end
-
-  # Baseline infiltration rate
-  #
-  # @param space [OpenStudio::Model::Space] space object
-  # @return [Double] the baseline infiltration rate, in cfm/ft^2 exterior above grade wall area at 75 Pa
-  def space_infiltration_rate_75_pa(space = nil)
-    basic_infil_rate_cfm_per_ft2 = 1.8
-    return basic_infil_rate_cfm_per_ft2
-  end
-
   # Determines whether the space is conditioned per 90.1, which is based on heating and cooling loads.
   #
   # @param space [OpenStudio::Model::Space] space object
@@ -1378,7 +1274,7 @@ class Standard
     space.model.getAirLoopHVACReturnPlenums.each do |return_air_plenum|
       if return_air_plenum.thermalZone.get.name.to_s == zone.get.name.to_s
         # Determine if residential
-        res = OpenstudioStandards::ThermalZone.thermal_zone_residential?(zone.get) ? true : false
+        res = OpenstudioStandards::ThermalZone.thermal_zone_residential?(zone.get)
 
         OpenStudio.logFree(OpenStudio::Debug, 'openstudio.Standards.ThermalZone', "Zone #{zone.get.name} is (indirectly) conditioned (return air plenum).")
         cond_cat = res ? 'ResConditioned' : 'NonResConditioned'
@@ -1391,7 +1287,7 @@ class Standard
     space.model.getAirLoopHVACSupplyPlenums.each do |supply_air_plenum|
       if supply_air_plenum.thermalZone.get.name.to_s == zone.get.name.to_s
         # Determine if residential
-        res = OpenstudioStandards::ThermalZone.thermal_zone_residential?(zone.get) ? true : false
+        res = OpenstudioStandards::ThermalZone.thermal_zone_residential?(zone.get)
 
         OpenStudio.logFree(OpenStudio::Debug, 'openstudio.Standards.ThermalZone', "Zone #{zone.get.name} is (indirectly) conditioned (supply air plenum).")
         cond_cat = res ? 'ResConditioned' : 'NonResConditioned'
@@ -1454,7 +1350,7 @@ class Standard
       end
 
       # Determine if residential
-      res = OpenstudioStandards::ThermalZone.thermal_zone_residential?(zone.get) ? true : false
+      res = OpenstudioStandards::ThermalZone.thermal_zone_residential?(zone.get)
 
       return cond_cat unless cond_ua > otr_ua