openstudio-standards 0.8.0 → 0.8.1

data/lib/openstudio-standards/infiltration/data/convert_infiltration_data.rb

@@ -0,0 +1,87 @@
+# These methods convert infiltration data to and from .csv for editing.
+private
+
+require 'csv'
+require 'json'
+
+def infiltration_csv_to_json(input_csv = 'NISTInfiltrationCorrelations.csv',
+                             output_json = 'NISTInfiltrationCorrelations.json')
+  # Initialize the structure
+  result = {
+    infiltration: []
+  }
+
+  # Read the CSV file
+  CSV.foreach(input_csv, headers: true, header_converters: :symbol) do |row|
+    building_type = row[:building_type]
+    climate_zone = row[:climate_zone]
+    air_barrier = row[:air_barrier]
+    hvac_status = row[:hvac_status]
+    a = row[:a]&.to_f
+    b = row[:b]&.to_f
+    d = row[:d]&.to_f
+
+    infiltration_hash = {
+      building_type: building_type,
+      climate_zone: climate_zone,
+      air_barrier: air_barrier,
+      hvac_status: hvac_status,
+      a: a,
+      b: b,
+      d: d
+    }
+
+    # Add the space_type_hash to the result array
+    result[:infiltration] << infiltration_hash
+  end
+
+  # Write to the output JSON file
+  File.write(output_json, JSON.pretty_generate(result))
+
+  puts "Data has been converted to JSON and saved to #{output_json}"
+end
+
+# convert to json
+infiltration_csv_to_json
+
+def infiltration_json_to_csv(input_json = 'NISTInfiltrationCorrelations.json',
+                             output_csv = 'NISTInfiltrationCorrelations.csv')
+  # Read the JSON file
+  data = JSON.parse(File.read(input_json), symbolize_names: true)
+
+  # Prepare the CSV headers
+  headers = [
+    :building_type,
+    :climate_zone,
+    :air_barrier,
+    :hvac_status,
+    :a,
+    :b,
+    :d
+  ]
+
+  # Write the CSV file
+  CSV.open(output_csv, 'w', write_headers: true, headers: headers) do |csv|
+    data[:infiltration].each do |infiltration_entry|
+      building_type = infiltration_entry[:building_type]
+      climate_zone = infiltration_entry[:climate_zone]
+      air_barrier = infiltration_entry[:air_barrier]
+      hvac_status = infiltration_entry[:hvac_status]
+      a = infiltration_entry[:a]
+      b = infiltration_entry[:b]
+      d = infiltration_entry[:d]
+
+      csv << [
+        building_type,
+        climate_zone,
+        air_barrier,
+        hvac_status,
+        a,
+        b,
+        d
+      ]
+    end
+  end
+
+  puts "Data has been converted to CSV and saved to #{output_csv}"
+end

data/lib/openstudio-standards/infiltration/infiltration.rb

@@ -96,7 +96,7 @@ module OpenstudioStandards
           infil_rate_cfm_per_ft2 = component_infil_rates_cfm_per_ft2[type]['slab_on_grade']
         end
       else
-        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.Infiltration', "Could not determine infiltration surface type for #{surface.name}, defaulting to 0 component infiltration rate.")
+        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.Infiltration.infiltration', "Could not determine infiltration surface type for #{surface.name}, defaulting to 0 component infiltration rate.")
         return 0.0
       end
 
@@ -156,14 +156,14 @@ module OpenstudioStandards
       when 'OverheadDoor'
         infil_rate_cfm_per_ft2 = component_infil_rates_cfm_per_ft2[type]['loading_dock_door']
       when 'GlassDoor'
-        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Infiltration', "Assuming swinging_or_revolving_glass_door for #{sub_surface.name} for component infiltration rate.")
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Infiltration.infiltration', "Assuming swinging_or_revolving_glass_door for #{sub_surface.name} for component infiltration rate.")
         infil_rate_cfm_per_ft2 = component_infil_rates_cfm_per_ft2[type]['swinging_or_revolving_glass_door']
       when 'FixedWindow', 'OperableWindow'
         infil_rate_cfm_per_ft2 = component_infil_rates_cfm_per_ft2[type]['window']
       when 'Skylight', 'TubularDaylightDome', 'TubularDaylightDiffuser'
         infil_rate_cfm_per_ft2 = component_infil_rates_cfm_per_ft2[type]['skylight']
       else
-        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.Infiltration', "Could not determine infiltration sub surface type for #{sub_surface.name}, defaulting to 0 component infiltration rate.")
+        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.Infiltration.infiltration', "Could not determine infiltration sub surface type for #{sub_surface.name}, defaulting to 0 component infiltration rate.")
         return 0.0
       end
 

data/lib/openstudio-standards/infiltration/nist_infiltration.rb

@@ -51,11 +51,11 @@ module OpenstudioStandards
         else
           nist_building_type = 'RetailStripmall'
         end
-      when 'RetailStripmall', 'StripMall', 'Warehouse', 'QuickServiceRestaurant', 'FullServiceRestaurant', 'RtS', 'RSD', 'RFF', 'SCn', 'SUn', 'WRf'
+      when 'RetailStripmall', 'StripMall', 'Warehouse', 'QuickServiceRestaurant', 'FullServiceRestaurant', 'RtS', 'RSD', 'RFF', 'SCn', 'SUn', 'WRf', 'Asm', 'MLI'
         nist_building_type = 'RetailStripmall'
-      when 'RetailStandalone', 'SuperMarket', 'RtL', 'Gro'
+      when 'RetailStandalone', 'SuperMarket', 'RtL', 'Rt3', 'Gro'
         nist_building_type = 'RetailStandalone'
-      when 'PrimarySchool', 'EPr'
+      when 'PrimarySchool', 'EPr', 'ERC'
         nist_building_type = 'PrimarySchool'
       when 'SecondarySchool', 'ESe'
         nist_building_type = 'SecondarySchool'
@@ -63,26 +63,26 @@ module OpenstudioStandards
         nist_building_type = 'SmallHotel'
       when 'LargeHotel', 'Htl'
         nist_building_type = 'LargeHotel'
-      when 'Hospital', 'Hsp'
+      when 'Hospital', 'Hsp', 'Nrs'
         nist_building_type = 'Hospital'
-      when 'MidriseApartment'
+      when 'MidriseApartment', 'MFm'
         nist_building_type = 'MidriseApartment'
       when 'HighriseApartment'
         nist_building_type = 'HighriseApartment'
       when 'TallBuilding', 'SuperTallBuilding'
         nist_building_type = 'LargeHotel'
-        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.Infiltration', "NIST coefficients aren't available for model building type #{model_building_type}. Since the building type is for a tall building, using nist building type #{nist_building_type} to best represent infiltration coefficients.")
-      when 'College', 'Laboratory'
+        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.Infiltration.nist_infiltration', "NIST coefficients aren't available for model building type #{model_building_type}. Since the building type is for a tall building, using nist building type #{nist_building_type} to best represent infiltration coefficients.")
+      when 'College', 'Laboratory', 'EUn', 'ECC', 'MBT'
         nist_building_type = 'SecondarySchool'
-        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.Infiltration', "NIST coefficients aren't available for model building type #{model_building_type}. Since the building may involve complex geometry, using nist building type #{nist_building_type} to best represent infiltration coefficients.")
+        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.Infiltration.nist_infiltration', "NIST coefficients aren't available for model building type #{model_building_type}. Since the building may involve complex geometry, using nist building type #{nist_building_type} to best represent infiltration coefficients.")
       when 'Courthouse'
         nist_building_type = 'MediumOffice'
-        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.Infiltration', "NIST coefficients aren't available for model building type #{model_building_type}. Using nist building type #{nist_building_type} to best represent infiltration coefficients.")
+        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.Infiltration.nist_infiltration', "NIST coefficients aren't available for model building type #{model_building_type}. Using nist building type #{nist_building_type} to best represent infiltration coefficients.")
       else
         nist_building_type = model_building_type
       end
 
-      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Infiltration', "Using building type #{nist_building_type} for model building type #{model_building_type}.")
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Infiltration.nist_infiltration', "Using building type #{nist_building_type} for model building type #{model_building_type}.")
 
       return nist_building_type
     end
@@ -112,18 +112,18 @@ module OpenstudioStandards
                                          nist_building_type: nil)
       # validate airtightness value and pressure
       if airtightness_value < 0.0
-        OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Infiltration', 'Airtightness value must be postive.')
+        OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Infiltration.nist_infiltration', 'Airtightness value must be postive.')
         return false
       end
 
       if airtightness_pressure < 0.0
-        OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Infiltration', 'Airtightness pressure must be postive.')
+        OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Infiltration.nist_infiltration', 'Airtightness pressure must be postive.')
         return false
       end
 
       # calculate infiltration design value at 4 Pa
       airtightness_value_4pa_per_hr = airtightness_value * ((4.0 / airtightness_pressure)**0.65)
-      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Infiltration', "User-inputed airtightness design value #{airtightness_value} (m^3/h-m^2) at #{airtightness_pressure} Pa converts to #{airtightness_value_4pa_per_hr.round(7)} (m^3/h-m^2) at 4 Pa")
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Infiltration.nist_infiltration', "User-inputed airtightness design value #{airtightness_value} (m^3/h-m^2) at #{airtightness_pressure} Pa converts to #{airtightness_value_4pa_per_hr.round(7)} (m^3/h-m^2) at 4 Pa")
 
       # convert to m^3/s-m^2
       airtightness_value_4pa_per_s = airtightness_value_4pa_per_hr / 3600.0
@@ -150,19 +150,19 @@ module OpenstudioStandards
       five_sided_area = exterior_wall_area + ground_wall_area + exterior_roof_area + ground_roof_area
       six_sided_area = exterior_wall_area + ground_wall_area + exterior_roof_area + ground_roof_area + exterior_floor_area + ground_floor_area
       energy_plus_area = exterior_wall_area + exterior_roof_area
-      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Infiltration', "4-sided area = #{four_sided_area.round(2)} m^2, 5-sided area = #{five_sided_area.round(2)} m^2, 6-sided area = #{six_sided_area.round(2)} m^2.")
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Infiltration.nist_infiltration', "4-sided area = #{four_sided_area.round(2)} m^2, 5-sided area = #{five_sided_area.round(2)} m^2, 6-sided area = #{six_sided_area.round(2)} m^2.")
 
       # The SpaceInfiltrationDesignFlowRate object FlowperExteriorSurfaceArea method only counts surfaces with the 'Outdoors' boundary conditions towards exterior surface area, not surfaces with the 'Ground' boundary conditions.  That means all values need to be normalized to exterior wall and roof area.
       case airtightness_area_covered
       when '4-sided'
         design_infiltration_4pa = airtightness_value_4pa_per_s * (four_sided_area / energy_plus_area)
-        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Infiltration', "#{airtightness_area_covered} infiltration design value #{airtightness_value_4pa_per_s.round(7)} (m^3/s-m^2) converted to #{design_infiltration_4pa.round(7)} (m^3/s-m^2) based on 4-sided area #{four_sided_area.round(2)} m^2 and 5-sided area #{energy_plus_area.round(2)} m^2 excluding ground boundary surfaces for energyplus.")
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Infiltration.nist_infiltration', "#{airtightness_area_covered} infiltration design value #{airtightness_value_4pa_per_s.round(7)} (m^3/s-m^2) converted to #{design_infiltration_4pa.round(7)} (m^3/s-m^2) based on 4-sided area #{four_sided_area.round(2)} m^2 and 5-sided area #{energy_plus_area.round(2)} m^2 excluding ground boundary surfaces for energyplus.")
       when '5-sided'
         design_infiltration_4pa = airtightness_value_4pa_per_s * (five_sided_area / energy_plus_area)
-        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Infiltration', "#{airtightness_area_covered} infiltration design value #{airtightness_value_4pa_per_s.round(7)} (m^3/s-m^2) converted to #{design_infiltration_4pa.round(7)} (m^3/s-m^2) based on 5-sided area #{five_sided_area.round(2)} m^2 and 5-sided area #{energy_plus_area.round(2)} m^2 excluding ground boundary surfaces for energyplus.")
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Infiltration.nist_infiltration', "#{airtightness_area_covered} infiltration design value #{airtightness_value_4pa_per_s.round(7)} (m^3/s-m^2) converted to #{design_infiltration_4pa.round(7)} (m^3/s-m^2) based on 5-sided area #{five_sided_area.round(2)} m^2 and 5-sided area #{energy_plus_area.round(2)} m^2 excluding ground boundary surfaces for energyplus.")
       when '6-sided'
         design_infiltration_4pa = airtightness_value_4pa_per_s * (six_sided_area / energy_plus_area)
-        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Infiltration', "#{airtightness_area_covered} infiltration design value #{airtightness_value_4pa_per_s.round(7)} (m^3/s-m^2) converted to #{design_infiltration_4pa.round(7)} (m^3/s-m^2) based on 6-sided area #{six_sided_area.round(2)} m^2 and 5-sided area #{energy_plus_area.round(2)} m^2 excluding ground boundary surfaces for energyplus.")
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Infiltration.nist_infiltration', "#{airtightness_area_covered} infiltration design value #{airtightness_value_4pa_per_s.round(7)} (m^3/s-m^2) converted to #{design_infiltration_4pa.round(7)} (m^3/s-m^2) based on 6-sided area #{six_sided_area.round(2)} m^2 and 5-sided area #{energy_plus_area.round(2)} m^2 excluding ground boundary surfaces for energyplus.")
       end
 
       # validate hvac schedule
@@ -171,7 +171,7 @@ module OpenstudioStandards
       else
         hvac_schedule = model.getScheduleByName(hvac_schedule_name)
         unless hvac_schedule.is_initialized
-          OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Infiltration', "HVAC schedule argument #{hvac_schedule} not found in the model. It may have been removed by another measure.")
+          OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Infiltration.nist_infiltration', "HVAC schedule argument #{hvac_schedule} not found in the model. It may have been removed by another measure.")
           return false
         end
         hvac_schedule = hvac_schedule.get
@@ -180,16 +180,16 @@ module OpenstudioStandards
         elsif hvac_schedule.to_ScheduleConstant.is_initialized
           hvac_schedule = hvac_schedule.to_ScheduleConstant.get
         else
-          OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Infiltration', "HVAC schedule argument #{hvac_schedule} is not a Schedule Constant or Schedule Ruleset object.")
+          OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Infiltration.nist_infiltration', "HVAC schedule argument #{hvac_schedule} is not a Schedule Constant or Schedule Ruleset object.")
           return false
         end
 
-        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Infiltration', "Using HVAC schedule #{hvac_schedule.name} from user arguments to determine infiltration on/off schedule.")
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Infiltration.nist_infiltration', "Using HVAC schedule #{hvac_schedule.name} from user arguments to determine infiltration on/off schedule.")
       end
 
       # creating infiltration schedules based on hvac schedule
       if hvac_schedule.nil?
-        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.Infiltration', 'Unable to determine the building HVAC schedule. Treating the building as if there is no HVAC system with outdoor air. This may be appropriate for design sizing, particularly heating design sizing. If this is not the case, input a schedule argument, or assign one to an air loop in the model.')
+        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.Infiltration.nist_infiltration', 'Unable to determine the building HVAC schedule. Treating the building as if there is no HVAC system with outdoor air. This may be appropriate for design sizing, particularly heating design sizing. If this is not the case, input a schedule argument, or assign one to an air loop in the model.')
         on_schedule = OpenStudio::Model::ScheduleConstant.new(model)
         on_schedule.setName('Infiltration HVAC On Schedule')
         on_schedule.setValue(0.0)
@@ -228,26 +228,26 @@ module OpenstudioStandards
 
       # check that model building type is supported
       unless nist_building_types.include? nist_building_type
-        OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Infiltration', "NIST coefficients are not available for model building type #{nist_building_type}.")
+        OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Infiltration.nist_infiltration', "NIST coefficients are not available for model building type #{nist_building_type}.")
         return false
       end
 
       # remove existing infiltration objects
-      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Infiltration', "The modeled started with #{model.getSpaceInfiltrationDesignFlowRates.size} infiltration objects and #{model.getSpaceInfiltrationEffectiveLeakageAreas.size} effective leakage area objects.")
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Infiltration.nist_infiltration', "The modeled started with #{model.getSpaceInfiltrationDesignFlowRates.size} infiltration objects and #{model.getSpaceInfiltrationEffectiveLeakageAreas.size} effective leakage area objects.")
       model.getSpaceInfiltrationDesignFlowRates.each(&:remove)
       model.getSpaceInfiltrationEffectiveLeakageAreas.each(&:remove)
 
       # load NIST infiltration correlations file and convert to hash table
-      nist_infiltration_correlations_csv = "#{__dir__}/data/NISTInfiltrationCorrelations.csv"
-      unless File.exist?(nist_infiltration_correlations_csv)
-        OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Infiltration', "Unable to find file: #{nist_infiltration_correlations_csv}")
+      nist_infiltration_correlations_json = "#{File.dirname(__FILE__)}/data/NISTInfiltrationCorrelations.json"
+      unless File.exist?(nist_infiltration_correlations_json)
+        OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Infiltration.nist_infiltration', "Unable to find file: #{nist_infiltration_correlations_json}")
         return false
       end
-      coefficients_tbl = CSV.table(nist_infiltration_correlations_csv, encoding: "ISO8859-1:utf-8" )
-      coefficients_hsh = coefficients_tbl.map(&:to_hash)
+      coefficients_hsh = JSON.parse(File.read("#{File.dirname(__FILE__)}/data/NISTInfiltrationCorrelations.json"), symbolize_names: true)
+      coefficients_hsh = coefficients_hsh[:infiltration]
 
       # select down to building type and climate zone
-      coefficients = coefficients_hsh.select { |r| (r[:building_type] == nist_building_type) && (r[:climate_zone] == climate_zone_number) }
+      coefficients = coefficients_hsh.select { |r| (r[:building_type] == nist_building_type) && (r[:climate_zone].to_i == climate_zone_number) }
 
       # filter by air barrier
       if air_barrier
@@ -258,14 +258,14 @@ module OpenstudioStandards
 
       # determine coefficients
       # if no off coefficients are defined, use 0 for a and the on coefficients for b and d
-      on_coefficients = coefficients.select { |r| r[:hvac_status] == 'on' }
-      off_coefficients = coefficients.select { |r| r[:hvac_status] == 'off' }
-      a_on = on_coefficients[0][:a]
-      b_on = on_coefficients[0][:b]
-      d_on = on_coefficients[0][:d]
-      a_off = off_coefficients[0][:a].nil? ? on_coefficients[0][:a] : off_coefficients[0][:a]
-      b_off = off_coefficients[0][:b].nil? ? on_coefficients[0][:b] : off_coefficients[0][:b]
-      d_off = off_coefficients[0][:d].nil? ? on_coefficients[0][:d] : off_coefficients[0][:d]
+      on_coefficients = coefficients.select { |r| r[:hvac_status] == 'on' }[0]
+      off_coefficients = coefficients.select { |r| r[:hvac_status] == 'off' }[0]
+      a_on = on_coefficients[:a]
+      b_on = on_coefficients[:b]
+      d_on = on_coefficients[:d]
+      a_off = off_coefficients[:a].nil? ? on_coefficients[:a] : off_coefficients[:a]
+      b_off = off_coefficients[:b].nil? ? on_coefficients[:b] : off_coefficients[:b]
+      d_off = off_coefficients[:d].nil? ? on_coefficients[:d] : off_coefficients[:d]
 
       # add new infiltration objects
       # define infiltration as flow per exterior area
@@ -293,7 +293,7 @@ module OpenstudioStandards
         hvac_off_infiltration.setSchedule(off_schedule)
       end
 
-      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Infiltration', "The modeled finished with #{model.getSpaceInfiltrationDesignFlowRates.size} infiltration objects.")
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Infiltration.nist_infiltration', "The modeled finished with #{model.getSpaceInfiltrationDesignFlowRates.size} infiltration objects.")
 
       return true
     end
@@ -315,7 +315,7 @@ module OpenstudioStandards
         hvac_schedule = OpenstudioStandards::Schedules.model_get_hvac_schedule(model)
       else
         unless hvac_schedule.to_Schedule.is_initialized
-          OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Infiltration', "HVAC schedule argument #{hvac_schedule} not found in the model or is not a Schedule object. It may have been removed by another measure.")
+          OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Infiltration.nist_infiltration', "HVAC schedule argument #{hvac_schedule} not found in the model or is not a Schedule object. It may have been removed by another measure.")
           return false
         end
         hvac_schedule = hvac_schedule.to_Schedule.get
@@ -324,16 +324,16 @@ module OpenstudioStandards
         elsif hvac_schedule.to_ScheduleConstant.is_initialized
           hvac_schedule = hvac_schedule.to_ScheduleConstant.get
         else
-          OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Infiltration', "HVAC schedule argument #{hvac_schedule} is not a Schedule Constant or Schedule Ruleset object.")
+          OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Infiltration.nist_infiltration', "HVAC schedule argument #{hvac_schedule} is not a Schedule Constant or Schedule Ruleset object.")
           return false
         end
 
-        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Infiltration', "Using HVAC schedule #{hvac_schedule.name} from user arguments to determine infiltration on/off schedule.")
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Infiltration.nist_infiltration', "Using HVAC schedule #{hvac_schedule.name} from user arguments to determine infiltration on/off schedule.")
       end
 
       # creating infiltration schedules based on hvac schedule
       if hvac_schedule.nil?
-        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.Infiltration', 'Unable to determine the HVAC schedule. Treating the building as if there is no HVAC system with outdoor air.  If this is not the case, input a schedule argument, or assign one to an air loop in the model.')
+        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.Infiltration.nist_infiltration', 'Unable to determine the HVAC schedule. Treating the building as if there is no HVAC system with outdoor air.  If this is not the case, input a schedule argument, or assign one to an air loop in the model.')
         on_schedule = OpenStudio::Model::ScheduleConstant.new(model)
         on_schedule.setName('Infiltration HVAC On Schedule')
         on_schedule.setValue(0.0)

data/lib/openstudio-standards/refrigeration/create_case.rb

@@ -96,8 +96,8 @@ module OpenstudioStandards
 
       # Dripdown schedule
       dripdown_sch = OpenStudio::Model::ScheduleRuleset.new(model)
-      dripdown_sch.setName("#{ref_case.name} Defrost")
-      dripdown_sch.defaultDaySchedule.setName("#{ref_case.name} Defrost Default")
+      dripdown_sch.setName("#{ref_case.name} Dripdown")
+      dripdown_sch.defaultDaySchedule.setName("#{ref_case.name} Dripdown Default")
       dripdown_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, i, 0, 0), 0)
       dripdown_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, i, 59, 0), 1)
       dripdown_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, 24, 0, 0), 0)

data/lib/openstudio-standards/refrigeration/create_typical_refrigeration.rb

@@ -8,11 +8,11 @@ module OpenstudioStandards
     #
     # @param model [OpenStudio::Model::Model] OpenStudio model object
     # @param template [String] Technology or standards level, either 'old', 'new', or 'advanced'
-    # @param separate_system_size_limit [Float] The area in square feet above which a refrigeration system will be split into multiple systems
+    # @param separate_system_size_limit [Float] The area in square feet above which a refrigeration system will be split into multiple systems. Currently not used.
     # @return [Boolean] returns true if successful, false if not
     def self.create_typical_refrigeration(model,
                                           template: 'new',
-                                          separate_system_size_limit: 20000.0)
+                                          separate_system_size_limit: 0.0)
       # get refrigeration equipment list based on space types and area
       ref_equip_list = OpenstudioStandards::Refrigeration.typical_refrigeration_equipment_list(model)
 
@@ -71,25 +71,26 @@ module OpenstudioStandards
         end
       end
 
-      refrigeration_space_type_area = OpenStudio.convert(model.getBuilding.floorArea, 'm^2', 'ft^2').get
-      if refrigeration_space_type_area < separate_system_size_limit
-        # each case is self-contained
-        medium_temperature_cases.each { |ref_equip| OpenstudioStandards::Refrigeration.create_compressor_rack(model, ref_equip, template: template) }
-        low_temperature_cases.each { |ref_equip| OpenstudioStandards::Refrigeration.create_compressor_rack(model, ref_equip, template: template) }
-
-        # each walkin gets its own refrigeration system
-        medium_temperature_walkins.each { |ref_equip| OpenstudioStandards::Refrigeration.create_refrigeration_system(model, [ref_equip], template: template, operation_type: 'MT') }
-        low_temperature_walkins.each { |ref_equip| OpenstudioStandards::Refrigeration.create_refrigeration_system(model, [ref_equip], template: template, operation_type: 'LT') }
-      else
-        medium_temperature_equip = medium_temperature_cases + medium_temperature_walkins
-        OpenstudioStandards::Refrigeration.create_refrigeration_system(model, medium_temperature_equip,
-                                                                       template: template,
-                                                                       operation_type: 'MT')
-        low_temperature_equip = low_temperature_cases + low_temperature_walkins
-        OpenstudioStandards::Refrigeration.create_refrigeration_system(model, low_temperature_equip,
-                                                                       template: template,
-                                                                       operation_type: 'LT')
-      end
+      # @todo Disable self-contained refrigeration units until we have efficiency data and cases and walkins can connect to those systems and simulate correctly.
+      # refrigeration_space_type_area = OpenStudio.convert(model.getBuilding.floorArea, 'm^2', 'ft^2').get
+      # if refrigeration_space_type_area < separate_system_size_limit
+      #   # each case is self-contained
+      #   medium_temperature_cases.each { |ref_equip| OpenstudioStandards::Refrigeration.create_compressor_rack(model, ref_equip, template: template) }
+      #   low_temperature_cases.each { |ref_equip| OpenstudioStandards::Refrigeration.create_compressor_rack(model, ref_equip, template: template) }
+
+      #   # each walkin gets its own refrigeration system
+      #   medium_temperature_walkins.each { |ref_equip| OpenstudioStandards::Refrigeration.create_refrigeration_system(model, [ref_equip], template: template, operation_type: 'MT') }
+      #   low_temperature_walkins.each { |ref_equip| OpenstudioStandards::Refrigeration.create_refrigeration_system(model, [ref_equip], template: template, operation_type: 'LT') }
+      # else
+      medium_temperature_equip = medium_temperature_cases + medium_temperature_walkins
+      OpenstudioStandards::Refrigeration.create_refrigeration_system(model, medium_temperature_equip,
+                                                                     template: template,
+                                                                     operation_type: 'MT')
+      low_temperature_equip = low_temperature_cases + low_temperature_walkins
+      OpenstudioStandards::Refrigeration.create_refrigeration_system(model, low_temperature_equip,
+                                                                     template: template,
+                                                                     operation_type: 'LT')
+      # end
 
       return true
     end

data/lib/openstudio-standards/service_water_heating/create_typical.rb

@@ -41,7 +41,7 @@ module OpenstudioStandards
         standards_building_type = space_type.standardsBuildingType.get
 
         # load typical water use equipment data
-        data = JSON.parse(File.read("#{__dir__}/data/typical_water_use_equipment.json"), symbolize_names: true)
+        data = JSON.parse(File.read("#{File.dirname(__FILE__)}/data/typical_water_use_equipment.json"), symbolize_names: true)
         space_type_properties = data[:space_types].select { |hash| (hash[:space_type] == standards_space_type) && (hash[:building_type] == standards_building_type) }
 
         # skip spaces with no equipment defined

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

@@ -1254,6 +1254,9 @@ class Standard
 
     # Get climate zone
     climate_zone = OpenstudioStandards::Weather.model_get_climate_zone(space.model)
+    if climate_zone.empty?
+      OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Space', 'Model has no climate zone assigned, cannot determine space conditioning category.')
+    end
 
     # Get the zone this space is inside
     zone = space.thermalZone

data/lib/openstudio-standards/standards/ashrae_90_1/ashrae_90_1_2013/ashrae_90_1_2013.AirLoopHVAC.rb

@@ -29,7 +29,7 @@ class ASHRAE9012013 < ASHRAE901
       # Moisture regime is not needed for climate zone 8
       climate_zone = climate_zone.split('-')[-1]
       climate_zone = '8' if climate_zone.include?('8')
-      
+
       search_criteria = {
         'template' => template,
         'climate_zone' => climate_zone
@@ -455,6 +455,13 @@ class ASHRAE9012013 < ASHRAE901
     # Moisture regime is not needed for climate zone 8
     climate_zone = climate_zone.split('-')[-1]
     climate_zone = '8' if climate_zone.include?('8')
+    # Default to use values for cooling for climate zones 0, 1, 2, and 3 and heating for all others.
+    case climate_zone
+    when '0A', '0B', '1A', '1A', '1B', '2A', '2B', '3A', '3B', '3C'
+      design_conditions = 'Cooling'
+    else
+      design_conditions = 'Heating'
+    end
 
     # Check annual operating hours
     if ann_op_hrs < 8000.0
@@ -469,7 +476,8 @@ class ASHRAE9012013 < ASHRAE901
     search_criteria = {
       'template' => template,
       'climate_zone' => climate_zone,
-      'under_8000_hours' => under_8000_hours
+      'under_8000_hours' => under_8000_hours,
+      'design_conditions' => design_conditions
     }
     energy_recovery_limits = model_find_object(standards_data['energy_recovery'], search_criteria)
     if energy_recovery_limits.nil?