openstudio-standards 0.7.1 → 0.8.0.rc1

data/lib/openstudio-standards/exterior_lighting/data/typical_exterior_lighting.json

@@ -0,0 +1,37 @@
+{
+  "exterior_lighting": [
+    {
+      "lighting_zone": 3,
+      "exterior_lighting_zone_name": "All Other Areas",
+      "lighting_generation": "default",
+      "control_option": "AstronomicalClock",
+      "building_facade_and_landscape_automatic_shut_off": 1,
+      "occupancy_setback_reduction": null,
+      "base_site_allowance_power": 750.0,
+      "base_site_allowance_fraction": null,
+      "parking_areas_and_drives": 0.041,
+      "walkways_less_than_10ft_wide": 0.8,
+      "walkways_10ft_wide_or_greater": 0.16,
+      "stairways": 1.0,
+      "pedestrian_tunnels": 0.2,
+      "landscaping": 0.05,
+      "main_entries": 30.0,
+      "other_doors": 20.0,
+      "entry_canopies": 0.4,
+      "loading_docks": 0.5,
+      "sales_canopies": 0.8,
+      "outdoor_sales_open_areas": 0.5,
+      "outdoor_sales_street_frontage_for_vehicle_sales": 10.0,
+      "building_facades": 0.15,
+      "building_facades_alt_perim": 3.75,
+      "automated_teller_machines_per_location": 270.0,
+      "automated_teller_machines_per_machine": 90.0,
+      "entries_and_gates": 0.75,
+      "loading_areas_for_emergency_vehicles": 0.5,
+      "drive_through_windows_and_doors": 400.0,
+      "parking_near_24_hour_entrances": 800.0,
+      "roadway_parking": 0.0,
+      "notes": "Parking Areas and Drives lpd updated based on values derived from 2015 U.S. Lighting Market Characterization report."
+    }
+  ]
+}

data/lib/openstudio-standards/exterior_lighting/information.rb

@@ -0,0 +1,202 @@
+module OpenstudioStandards
+  # The Exterior Lighting module provides methods create, modify, and get information about model exterior lighting
+  module ExteriorLighting
+    # @!group Information
+
+    # get exterior lighting areas, distances, and counts
+    #
+    # @param model [OpenStudio::Model::Model] OpenStudio model object
+    # @return [Hash] hash of exterior lighting value types and building type and model specific values
+    def self.model_get_exterior_lighting_sizes(model)
+      # load parking file and convert to hash table
+      parking_csv = "#{__dir__}/data/parking.csv"
+      unless File.exist?(parking_csv)
+        OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.ExteriorLighting', "Unable to find file: #{parking_csv}")
+        return false
+      end
+      parking_tbl = CSV.table(parking_csv, encoding: 'ISO8859-1:utf-8')
+      parking_hsh = parking_tbl.map(&:to_hash)
+
+      # load entryways file and convert to hash table
+      entryways_csv = "#{__dir__}/data/entryways.csv"
+      unless File.exist?(entryways_csv)
+        OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.ExteriorLighting', "Unable to find file: #{entryways_csv}")
+        return false
+      end
+      entryways_tbl = CSV.table(entryways_csv, encoding: 'ISO8859-1:utf-8')
+      entryways_hsh = entryways_tbl.map(&:to_hash)
+
+      # get space properties from the model
+      space_type_hash = OpenstudioStandards::CreateTypical.model_get_space_type_information(model)
+
+      # populate building_type_hashes from space_type_hash
+      building_type_hashes = {}
+      space_type_hash.each do |space_type, hash|
+        # if space type standards building type already exists,
+        # add data to that standards building type in building_type_hashes
+        if building_type_hashes.key?(hash[:standards_building_type])
+          building_type_hashes[hash[:standards_building_type]][:effective_number_of_spaces] += hash[:effective_number_of_spaces]
+          building_type_hashes[hash[:standards_building_type]][:floor_area] += hash[:floor_area]
+          building_type_hashes[hash[:standards_building_type]][:number_of_people] += hash[:number_of_people]
+          building_type_hashes[hash[:standards_building_type]][:number_of_students] += hash[:number_of_students]
+          building_type_hashes[hash[:standards_building_type]][:number_of_units] += hash[:number_of_units]
+          building_type_hashes[hash[:standards_building_type]][:number_of_beds] += hash[:number_of_beds]
+        else
+          # initialize hash for this building type
+          building_type_hash = {}
+          building_type_hash[:effective_number_of_spaces] = hash[:effective_number_of_spaces]
+          building_type_hash[:floor_area] = hash[:floor_area]
+          building_type_hash[:number_of_people] = hash[:number_of_people]
+          building_type_hash[:number_of_students] = hash[:number_of_students]
+          building_type_hash[:number_of_units] = hash[:number_of_units]
+          building_type_hash[:number_of_beds] = hash[:number_of_beds]
+          building_type_hashes[hash[:standards_building_type]] = building_type_hash
+        end
+      end
+
+      # rename Office to SmallOffice, MediumOffice or LargeOffice depending on size
+      if building_type_hashes.key?('Office')
+        floor_area = building_type_hashes['Office'][:floor_area]
+        office_type = if floor_area < 2750
+                        'SmallOffice'
+                      elsif floor_area < 25_250
+                        'MediumOffice'
+                      else
+                        'LargeOffice'
+                      end
+        building_type_hashes[office_type] = building_type_hashes.delete('Office')
+      end
+
+      # initialize parking areas and drives area variables
+      parking_area_and_drives_area = 0.0
+      main_entries = 0.0
+      other_doors = 0.0
+      rollup_doors = 0.0
+      drive_through_windows = 0.0
+      canopy_entry_area = 0.0
+      canopy_emergency_area = 0.0
+      ground_story_ext_wall_area = 0.0
+
+      # temporary std for model_effective_num_stories method
+      std = Standard.build('90.1-2013')
+
+      # calculate exterior lighting properties for each building type
+      building_type_hashes.each do |building_type, hash|
+        # calculate floor area and ground floor area in IP units
+        floor_area_ft2 = OpenStudio.convert(hash[:floor_area], 'm^2', 'ft^2').get
+        effective_num_stories = std.model_effective_num_stories(model)
+        ground_floor_area_ft2 = floor_area_ft2 / effective_num_stories[:above_grade]
+
+        # load parking area properties for standards building type
+        parking_properties = parking_hsh.select { |h| h[:building_type] == building_type }
+
+        if parking_properties.nil? || parking_properties.empty?
+          OpenStudio.logFree(OpenStudio::Warn, 'openstudio.prototype.ExteriorLighting', "Could not find parking data for #{building_type}. Will not add exterior parking lighting. The building type data needs to be added to the parking lighting data.")
+          return {}
+        end
+        parking_properties = parking_properties[0]
+
+        # calculate number of parking spots
+        num_spots = 0.0
+        if !parking_properties[:building_area_per_spot].nil?
+          num_spots += floor_area_ft2 / parking_properties[:building_area_per_spot].to_f
+        elsif !parking_properties[:units_per_spot].nil?
+          num_spots += hash[:number_of_units] / parking_properties[:units_per_spot].to_f
+        elsif !parking_properties[:students_per_spot].nil?
+          num_spots += hash[:number_of_students] / parking_properties[:students_per_spot].to_f
+        elsif !parking_properties[:beds_per_spot].nil?
+          num_spots += hash[:number_of_beds] / parking_properties[:beds_per_spot].to_f
+        end
+
+        # add to cumulative parking area
+        parking_area_and_drives_area += num_spots * parking_properties[:parking_area_per_spot]
+
+        # load entryways properties for standards building type
+        entryways_properties = entryways_hsh.select { |eh| eh[:building_type] == building_type }
+
+        if entryways_properties.nil? || entryways_properties.empty?
+          OpenStudio.logFree(OpenStudio::Error, 'openstudio.prototype.ExteriorLighting', "Could not find entryway data for #{building_type}.")
+          return {}
+        end
+        entryways_properties = entryways_properties[0]
+
+        # calculate door, window, and canopy length properties for exterior lighting
+        # main entries
+        unless entryways_properties[:entrance_doors_per_10000_ft2].nil?
+          main_entries += (ground_floor_area_ft2 / 10_000.0) * entryways_properties[:entrance_doors_per_10000_ft2]
+        end
+
+        # other doors
+        unless entryways_properties[:other_doors_per_10000_ft2].nil?
+          other_doors += (ground_floor_area_ft2 / 10_000.0) * entryways_properties[:other_doors_per_10000_ft2]
+        end
+
+        # rollup doors
+        unless entryways_properties[:rollup_doors_per_10000_ft2].nil?
+          rollup_doors += (ground_floor_area_ft2 / 10_000.0) / entryways_properties[:rollup_doors_per_10000_ft2].to_f
+        end
+
+        # drive through windows
+        unless entryways_properties[:floor_area_per_drive_through_window].nil?
+          drive_through_windows += ground_floor_area_ft2 / entryways_properties[:floor_area_per_drive_through_window].to_f
+        end
+
+        # entrance canopies
+        if !entryways_properties[:entrance_canopies].nil? && !entryways_properties[:canopy_size].nil?
+          canopy_entry_area += entryways_properties[:entrance_canopies] * entryways_properties[:canopy_size]
+        end
+
+        # emergency canopies
+        if !entryways_properties[:emergency_canopies].nil? && !entryways_properties[:canopy_size].nil?
+          canopy_emergency_area += entryways_properties[:emergency_canopies] * entryways_properties[:canopy_size]
+        end
+
+        # building_facades
+        # determine effective number of stories to find first above grade story exterior wall area
+        ground_story = effective_num_stories[:story_hash].keys[effective_num_stories[:below_grade]]
+        ground_story_ext_wall_area_m2 = effective_num_stories[:story_hash][ground_story][:ext_wall_area]
+        ground_story_ext_wall_area += OpenStudio.convert(ground_story_ext_wall_area_m2, 'm^2', 'ft^2').get
+      end
+
+      # no source for width of different entry types
+      main_entry_width_ft = 8.0
+      other_doors_width_ft = 4.0
+      rollup_door_width_ft = 8.0
+
+      # ensure the building has at least 1 main entry
+      main_entries = [1.0, main_entries].max
+
+      # populate hash
+      area_length_count_hash = {}
+      area_length_count_hash[:parking_area_and_drives_area] = parking_area_and_drives_area
+      area_length_count_hash[:main_entries] = main_entries * main_entry_width_ft
+      area_length_count_hash[:other_doors] = other_doors * other_doors_width_ft
+      area_length_count_hash[:rollup_doors] = rollup_doors * rollup_door_width_ft
+      area_length_count_hash[:drive_through_windows] = drive_through_windows
+      area_length_count_hash[:canopy_entry_area] = canopy_entry_area
+      area_length_count_hash[:canopy_emergency_area] = canopy_emergency_area
+      area_length_count_hash[:building_facades] = ground_story_ext_wall_area
+
+      return area_length_count_hash
+    end
+
+    # get exterior lighting properties by lighting generation
+    #
+    # @param lighting_generation [String] lighting generation
+    # @return [Hash] hash of exterior lighting properties
+    def self.model_get_exterior_lighting_properties(lighting_generation: 'default',
+                                                    lighting_zone: 3)
+      # load typical exterior lighting data
+      data = JSON.parse(File.read("#{__dir__}/data/typical_exterior_lighting.json"))
+      exterior_lighting_properties = data['exterior_lighting'].select { |hash| (hash['lighting_generation'] == lighting_generation) && (hash['lighting_zone'] == lighting_zone) }[0]
+
+      # make sure lighting properties were found
+      if exterior_lighting_properties.nil?
+        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.ExteriorLighting', "Exterior lighting properties not found for lighting generation #{lighting_generation}, exterior lighting zone #{lighting_zone}.")
+        return nil
+      end
+
+      return exterior_lighting_properties
+    end
+  end
+end

data/lib/openstudio-standards/geometry/information.rb

@@ -262,7 +262,7 @@ module OpenstudioStandards
     # @!group Information:Space
 
     # Calculate the space envelope area.
-    # According to the 90.1 definition, building envelope include:
+    # According to the 90.1 definition, the building envelope includes:
     # 1. "the elements of a building that separate conditioned spaces from the exterior"
     # 2. "the elements of a building that separate conditioned space from unconditioned
     #    space or that enclose semiheated spaces through which thermal energy may be
@@ -912,7 +912,7 @@ module OpenstudioStandards
       model.getBuildingStorys.sort.each do |story|
         z = OpenstudioStandards::Geometry.building_story_get_minimum_height(story)
         if (minimum_height - z).abs < tolerance
-          OpenStudio.logFree(OpenStudio::Debug, 'openstudio.standards.Model', "The story with a min z value of #{minimum_height.round(2)} is #{story.name}.")
+          OpenStudio.logFree(OpenStudio::Debug, 'openstudio.standards.Geometry.Information', "The story with a min z value of #{minimum_height.round(2)} is #{story.name}.")
           matched_story = story
         end
       end
@@ -1172,6 +1172,53 @@ module OpenstudioStandards
       return perimeter
     end
 
+
+    # Calculate the model envelope area.
+    # According to the 90.1 definition, the building envelope includes:
+    # 1. "the elements of a building that separate conditioned spaces from the exterior"
+    # 2. "the elements of a building that separate conditioned space from unconditioned
+    #    space or that enclose semiheated spaces through which thermal energy may be
+    #    transferred to or from the exterior, to or from unconditioned spaces or to or
+    #    from conditioned spaces."
+    #
+    # Outside boundary conditions currently supported:
+    # - Adiabatic
+    # - Surface
+    # - Outdoors
+    # - Foundation
+    # - Ground
+    # - GroundFCfactorMethod
+    # - OtherSideCoefficients
+    # - OtherSideConditionsModel
+    # - GroundSlabPreprocessorAverage
+    # - GroundSlabPreprocessorCore
+    # - GroundSlabPreprocessorPerimeter
+    # - GroundBasementPreprocessorAverageWall
+    # - GroundBasementPreprocessorAverageFloor
+    # - GroundBasementPreprocessorUpperWall
+    # - GroundBasementPreprocessorLowerWall
+    #
+    # Surface type currently supported:
+    # - Floor
+    # - Wall
+    # - RoofCeiling
+    #
+    # @param model [OpenStudio::Model::Model] OpenStudio model object
+    # @param multiplier [Boolean] account for space multipliers
+    # @return [Double] area in m^2
+    def self.model_get_envelope_area(model, multiplier: true)
+      building_envelope_area_m2 = 0
+      model.getSpaces.each do |space|
+        building_envelope_area_m2 += OpenstudioStandards::Geometry.space_get_envelope_area(space)
+      end
+      if building_envelope_area_m2 < 0.01
+        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.Geometry.Information', 'Calculated building envelope area is 0 m2')
+        return 0.0
+      end
+
+      return building_envelope_area_m2
+    end
+
     # @!endgroup Information:Model
   end
 end

data/lib/openstudio-standards/hvac/components/create.rb

@@ -0,0 +1,169 @@
+module OpenstudioStandards
+  # The HVAC module provides methods create, modify, and get information about HVAC systems in the model
+  module HVAC
+    # @!group Component:Create
+    # Methods to create HVAC component objects
+
+    # creates HeatExchangerAirToAirSensibleAndLatent object with user-input effectiveness values
+    #
+    # @param model [<OpenStudio::Model::Model>] OpenStudio model
+    # @param name [String]
+    # @param type [String] Heat Exchanger Type. One of 'Plate', 'Rotary'
+    # @param economizer_lockout [Boolean] whether hx is locked out during economizing
+    # @param supply_air_outlet_temperature_control [Boolean]
+    # @param frost_control_type [String] HX frost control type. One of 'None', 'ExhaustAirRecirculation', 'ExhaustOnly', 'MinimumExhaustTemperature'
+    # @param nominal_electric_power [Float] Nominal electric power
+    # @param sensible_heating_100_eff [Float]
+    # @param sensible_heating_75_eff [Float]
+    # @param latent_heating_100_eff [Float]
+    # @param latent_heating_75_eff [Float]
+    # @param sensible_cooling_100_eff [Float]
+    # @param sensible_cooling_75_eff [Float]
+    # @param latent_cooling_100_eff [Float]
+    # @param latent_cooling_75_eff [Float]
+    # @return [<OpenStudio::Model::HeatExchangerAirToAirSensibleAndLatent>]
+    def self.create_hx_air_to_air_sensible_and_latent(model,
+                                                      name: nil,
+                                                      type: nil,
+                                                      economizer_lockout: nil,
+                                                      supply_air_outlet_temperature_control: nil,
+                                                      frost_control_type: nil,
+                                                      nominal_electric_power: nil,
+                                                      sensible_heating_100_eff: nil,
+                                                      sensible_heating_75_eff: nil,
+                                                      latent_heating_100_eff: nil,
+                                                      latent_heating_75_eff: nil,
+                                                      sensible_cooling_100_eff: nil,
+                                                      sensible_cooling_75_eff: nil,
+                                                      latent_cooling_100_eff: nil,
+                                                      latent_cooling_75_eff: nil)
+
+      hx = OpenStudio::Model::HeatExchangerAirToAirSensibleAndLatent.new(model)
+      hx.setName(name) unless name.nil?
+
+      unless type.nil?
+        if OpenStudio::Model::HeatExchangerAirToAirSensibleAndLatent.heatExchangerTypeValues.include?(type)
+          hx.setHeatExchangerType(type)
+        else
+          OpenStudio.logFree(OpenStudio::Warn, 'openstudio.model.Hvac', "Entered heat exchanger type #{type} not a valid type value. Enter one of #{OpenStudio::Model::HeatExchangerAirToAirSensibleAndLatent.heatExchangerTypeValues}")
+        end
+      end
+
+      unless frost_control_type.nil?
+        if OpenStudio::Model::HeatExchangerAirToAirSensibleAndLatent.frostControlTypeValues.include?(frost_control_type)
+          hx.setFrostControlType(frost_control_type)
+        else
+          OpenStudio.logFree(OpenStudio::Warn, 'openstudio.model.Hvac', "Entered heat exchanger frost control type #{frost_control_type} not a valid type value. Enter one of #{OpenStudio::Model::HeatExchangerAirToAirSensibleAndLatent.frostControlTypeValues}")
+        end
+      end
+
+      hx.setEconomizerLockout(economizer_lockout) unless economizer_lockout.nil?
+      hx.setSupplyAirOutletTemperatureControl(supply_air_outlet_temperature_control) unless supply_air_outlet_temperature_control.nil?
+      hx.setNominalElectricPower(nominal_electric_power) unless nominal_electric_power.nil?
+
+      if model.version < OpenStudio::VersionString.new('3.8.0')
+        hx.setSensibleEffectivenessat100HeatingAirFlow(sensible_heating_100_eff) unless sensible_heating_100_eff.nil?
+        hx.setSensibleEffectivenessat75HeatingAirFlow(sensible_heating_75_eff) unless sensible_heating_75_eff.nil?
+        hx.setLatentEffectivenessat100HeatingAirFlow(latent_heating_100_eff) unless latent_heating_100_eff.nil?
+        hx.setLatentEffectivenessat75HeatingAirFlow(latent_heating_75_eff) unless latent_heating_75_eff.nil?
+        hx.setSensibleEffectivenessat100CoolingAirFlow(sensible_cooling_100_eff) unless sensible_cooling_100_eff.nil?
+        hx.setSensibleEffectivenessat75CoolingAirFlow(sensible_cooling_75_eff) unless sensible_cooling_75_eff.nil?
+        hx.setLatentEffectivenessat100CoolingAirFlow(latent_cooling_100_eff) unless latent_cooling_100_eff.nil?
+        hx.setLatentEffectivenessat75CoolingAirFlow(latent_cooling_75_eff) unless latent_cooling_75_eff.nil?
+      else
+        effectiveness_inputs = Hash.new { |hash, key| hash[key] = {} }
+        effectiveness_inputs['Sensible Heating'][0.75] = sensible_heating_75_eff.to_f unless sensible_heating_75_eff.nil?
+        effectiveness_inputs['Sensible Heating'][1.0] = sensible_heating_100_eff.to_f unless sensible_heating_100_eff.nil?
+        effectiveness_inputs['Latent Heating'][0.75] = latent_heating_75_eff.to_f unless latent_heating_75_eff.nil?
+        effectiveness_inputs['Latent Heating'][1.0] = latent_heating_100_eff.to_f unless latent_heating_100_eff.nil?
+        effectiveness_inputs['Sensible Cooling'][0.75] = sensible_cooling_75_eff.to_f unless sensible_cooling_75_eff.nil?
+        effectiveness_inputs['Sensible Cooling'][1.0] = sensible_cooling_100_eff.to_f unless sensible_cooling_100_eff.nil?
+        effectiveness_inputs['Latent Cooling'][0.75] = latent_cooling_75_eff.to_f unless latent_cooling_75_eff.nil?
+        effectiveness_inputs['Latent Cooling'][1.0] = latent_cooling_100_eff.to_f unless latent_cooling_100_eff.nil?
+
+        if effectiveness_inputs.values.all?(&:empty?)
+          OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.Hvac', 'Creating HX with historical effectiveness curves')
+          defaults = true
+        else
+          defaults = false
+        end
+
+        OpenstudioStandards::HVAC.heat_exchanger_air_to_air_set_effectiveness_values(hx, defaults: defaults, values: effectiveness_inputs)
+      end
+
+      return hx
+    end
+
+    # creates LookupTable objects to define effectiveness of HeatExchangerAirToAirSensibleAndLatent objects
+    #
+    # @param hx [<OpenStudio::Model::HeatExchangerAirToAirSensibleAndLatent>] OpenStudio HX object to update
+    # @param type [String] type of curve to create. one of 'Sensible Heating', 'Latent Heating, 'Sensible Cooling', 'Latent Cooling'
+    # @param values_hash [Hash{Float=>Float}] user_input flow decimal fraction => effectiveness decimal fraction pairs, e.g. {0.75 => 0.81, 1.0 => 0.76}
+    # @return [<OpenStudio::Model::TableLookup>] lookup table object
+    def self.create_hx_effectiveness_table(hx, type, values_hash)
+      # validate inputs
+      types = ['Sensible Heating', 'Latent Heating', 'Sensible Cooling', 'Latent Cooling']
+      unless types.include? type
+        OpenStudio.logFree(OpenStudio::Error, 'openstudio.model.Hvac', "#{__method__} requires effectiveness type as one of #{types}")
+        return false
+      end
+
+      def self.validate_effectiveness_hash(values_hash)
+        values_hash.all? do |key, value|
+          key.is_a?(Float) && value.is_a?(Float) && key.between?(0.0, 1.0) && value.between?(0.0, 1.0)
+        end
+      end
+
+      if !validate_effectiveness_hash(values_hash)
+        OpenStudio.logFree(OpenStudio::Error, 'openstudio.model.Hvac', "#{__method__} require values_hash to have keys and values between 0.0 and 1.0: #{values_hash}")
+        return false
+      end
+
+      # look for existing curve
+      type_a = type.split
+      method_name = "#{type_a[0].downcase}Effectivenessof#{type_a[1]}AirFlowCurve"
+
+      # use existing independent variable object if found and matches inputs
+      iv = nil
+      table = OpenStudio::Model::OptionalTableLookup.new
+      if hx.send(method_name).is_initialized
+        table = hx.send(method_name).get.to_TableLookup
+        curve = table.get
+        iv_existing = curve.independentVariables.first
+        if values_hash.keys.sort == iv_existing.values.sort
+          iv = iv_existing
+        end
+      end
+
+      # otherwise create new independent variable
+      if iv.nil?
+        iv = OpenStudio::Model::TableIndependentVariable.new(hx.model)
+        iv.setName("#{hx.name.get}_#{type.gsub(' ', '')}_IndependentVariable")
+        iv.setInterpolationMethod('Linear')
+        iv.setExtrapolationMethod('Linear')
+        iv.setMinimumValue(0.0)
+        iv.setMaximumValue(10.0)
+        iv.setUnitType('Dimensionless')
+        values_hash.keys.sort.each { |k| iv.addValue(k) }
+      end
+
+      # create new lookup table
+      t = OpenStudio::Model::TableLookup.new(hx.model)
+      t.setName("#{hx.name.get}_#{type.gsub(/ible|ent|ing|\s/, '')}Eff")
+      t.addIndependentVariable(iv)
+      t.setNormalizationMethod('DivisorOnly')
+      t.setMinimumOutput(0.0)
+      t.setMaximumOutput(10.0)
+      t.setOutputUnitType('Dimensionless')
+      values = values_hash.sort.map { |a| a[1] }
+      # protect against setting normalization divisor to zero for zero effectiveness
+      values[-1].zero? ? t.setNormalizationDivisor(1) : t.setNormalizationDivisor(values[-1])
+      values.each { |v| t.addOutputValue(v) }
+
+      # remove curve if found
+      table.get.remove if table.is_initialized
+
+      return t
+    end
+  end
+end

data/lib/openstudio-standards/hvac/components/modify.rb

@@ -0,0 +1,42 @@
+module OpenstudioStandards
+  # The HVAC module provides methods create, modify, and get information about HVAC systems in the model
+  module HVAC
+    # @!group Component:Modify
+    # Methods to modify HVAC Component objects
+
+    # Applies historical default or user-input effectiveness values to a HeatExchanger:AirToAir:SensibleAndLatent object
+    #
+    # @param hx [<OpenStudio::Model::HeatExchangerAirToAirSensibleAndLatent>] OpenStudio HX object to update
+    # @param defaults [Boolean] flag to apply historical default curves
+    # @param values [Hash{String=>Hash{Float=>Float}}] user-input effectiveness values, where keys are one of
+    #   'Sensible Heating', 'Latent Heating, 'Sensible Cooling', 'Latent Cooling'
+    #   and value is a hash of {flow decimal fraction => effectivess decimal fraction}, e.g. {0.75 => 0.81, 1.0 => 0.76}
+    # @return [<OpenStudio::Model::HeatExchangerAirToAirSensibleAndLatent>] modified OpenStudio HX object
+    def self.heat_exchanger_air_to_air_set_effectiveness_values(hx, defaults: false, values: nil)
+      if defaults
+        hx.assignHistoricalEffectivenessCurves
+        if values.nil?
+          return hx
+        end
+      elsif values.nil?
+        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.model.Hvac', "#{__method__} called with defaults=false and no values provided. #{hx.name.get} will not be modified")
+        return hx
+      end
+
+      values.each do |type, values_hash|
+        # ensure values_hash has one value at 100% flow
+        unless values_hash.key?(1.0)
+          OpenStudio.logFree(OpenStudio::Error, 'openstudio.model.Hvac', "Effectiveness Values for #{type} do not include 100% flow effectivenss. Cannot set effectiveness curves")
+          return false
+        end
+
+        lookup_table = OpenstudioStandards::HVAC.create_hx_effectiveness_table(hx, type, values_hash)
+        type_a = type.split
+        hx.send("set#{type_a[0]}Effectivenessat100#{type_a[1]}AirFlow", values_hash[1.0])
+        hx.send("set#{type_a[0]}Effectivenessof#{type_a[1]}AirFlowCurve", lookup_table)
+      end
+
+      return hx
+    end
+  end
+end

data/lib/openstudio-standards/hvac/exhaust/create_exhaust_fan.rb

@@ -0,0 +1,108 @@
+module OpenstudioStandards
+  # The HVAC module provides methods create, modify, and get information about HVAC systems in the model
+  module HVAC
+    # @!group Exhaust
+    # Methods to create exhaust fans
+
+    # Create and add an exhaust fan to a thermal zone.
+    #
+    # @param exhaust_zone [OpenStudio::Model::ThermalZone] The zone with the exhaust fan
+    # @param make_up_air_source_zone [OpenStudio::Model::ThermalZone] An optional source zone for make-up air
+    # @param make_up_air_fraction [Double] The fraction of make-up sourced from make_up_air_source_zone
+    # @return [OpenStudio::Model::FanZoneExhaust] The created exhaust fan
+    def self.create_exhaust_fan(exhaust_zone,
+                                make_up_air_source_zone: nil,
+                                make_up_air_fraction: 0.5)
+      # load exhaust fan data
+      data = JSON.parse(File.read("#{__dir__}/data/typical_exhaust.json"), symbolize_names: true)
+
+      # loop through spaces to get standards space information
+      space_type_hash = {}
+      exhaust_zone.spaces.each do |space|
+        next unless space.spaceType.is_initialized
+        next unless space.partofTotalFloorArea
+
+        space_type = space.spaceType.get
+        if space_type_hash.key?(space_type)
+          space_type_hash[space_type][:floor_area_m2] += space.floorArea * space.multiplier
+        else
+          next unless space_type.standardsBuildingType.is_initialized
+          next unless space_type.standardsSpaceType.is_initialized
+
+
+          standards_space_type = space_type.standardsSpaceType.get
+          standards_building_type = space_type.standardsBuildingType.get
+
+          exhaust_fan_properties = data[:space_types].select { |hash| (hash[:space_type] == standards_space_type) && (hash[:building_type] == standards_building_type) }
+
+          # skip spaces with no exhaust fan information defined
+          next if exhaust_fan_properties.empty?
+
+          exhaust_fan_properties = exhaust_fan_properties[0]
+
+          space_type_hash[space_type] = {}
+          space_type_hash[space_type][:floor_area_m2] = space.floorArea * space.multiplier
+          space_type_hash[space_type][:exhaust_cfm_per_area_ft2] = exhaust_fan_properties[:exhaust_per_area]
+        end
+      end
+
+      # total exhaust
+      exhaust_m3_per_s = 0.0
+      space_type_hash.each do |space_type, fields|
+        floor_area_ft2 = OpenStudio.convert(fields[:floor_area_m2], 'm^2', 'ft^2').get
+        cfm = fields[:exhaust_cfm_per_area_ft2].to_f * floor_area_ft2.to_f
+        exhaust_m3_per_s += OpenStudio.convert(cfm, 'cfm', 'm^3/s').get
+      end
+
+      if exhaust_m3_per_s.zero?
+        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.HVAC.create_exhaust_fan', "Calculated zero flow rate for thermal zone #{exhaust_zone.name}. No exhaust fan added.")
+        return nil
+      end
+
+      # placeholders for exhaust schedules
+      # @todo get the building HVAC schedule
+      exhaust_availability_schedule = exhaust_zone.model.alwaysOnDiscreteSchedule
+      exhaust_flow_fraction_schedule = exhaust_zone.model.alwaysOnDiscreteSchedule
+
+      # add exhaust fan
+      zone_exhaust_fan = OpenStudio::Model::FanZoneExhaust.new(exhaust_zone.model)
+      zone_exhaust_fan.setName("#{exhaust_zone.name} Exhaust Fan")
+      zone_exhaust_fan.setAvailabilitySchedule(exhaust_availability_schedule)
+      zone_exhaust_fan.setFlowFractionSchedule(exhaust_flow_fraction_schedule)
+      zone_exhaust_fan.setMaximumFlowRate(exhaust_m3_per_s)
+      zone_exhaust_fan.setEndUseSubcategory('Zone Exhaust Fans')
+      zone_exhaust_fan.addToThermalZone(exhaust_zone)
+
+      # add objects to account for makeup air
+      unless make_up_air_source_zone.nil?
+        # add balanced exhaust schedule to zone_exhaust_fan
+        balanced_exhaust_schedule = OpenstudioStandards::Schedules.create_constant_schedule_ruleset(make_up_air_source_zone.model, make_up_air_fraction,
+                                                                                                    name: "#{exhaust_zone.name} Balanced Exhaust Fraction Schedule",
+                                                                                                    schedule_type_limit: 'Fraction')
+        zone_exhaust_fan.setBalancedExhaustFractionSchedule(balanced_exhaust_schedule)
+
+        # use max value of balanced exhaust fraction schedule for maximum flow rate
+        max_sch_val = OpenstudioStandards::Schedules.schedule_get_min_max(balanced_exhaust_schedule)['max']
+        transfer_air_m3_per_s = exhaust_m3_per_s * max_sch_val
+
+        # add dummy exhaust fan to account for loss of transfer air
+        transfer_air_source_zone_exhaust = OpenStudio::Model::FanZoneExhaust.new(exhaust_zone.model)
+        transfer_air_source_zone_exhaust.setName("#{exhaust_zone.name} Transfer Air Source")
+        transfer_air_source_zone_exhaust.setAvailabilitySchedule(exhaust_availability_schedule)
+        transfer_air_source_zone_exhaust.setMaximumFlowRate(transfer_air_m3_per_s)
+        transfer_air_source_zone_exhaust.setFanEfficiency(1.0)
+        transfer_air_source_zone_exhaust.setPressureRise(0.0)
+        transfer_air_source_zone_exhaust.setEndUseSubcategory('Zone Exhaust Fans')
+        transfer_air_source_zone_exhaust.addToThermalZone(make_up_air_source_zone)
+
+        # add zone mixing
+        zone_mixing = OpenStudio::Model::ZoneMixing.new(exhaust_zone)
+        zone_mixing.setSchedule(exhaust_flow_fraction_schedule)
+        zone_mixing.setSourceZone(make_up_air_source_zone)
+        zone_mixing.setDesignFlowRate(transfer_air_m3_per_s)
+      end
+
+      return zone_exhaust_fan
+    end
+  end
+end