openstudio-standards 0.7.1 → 0.8.0.rc1

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

@@ -388,472 +388,6 @@ class Standard
     return compressor
   end
 
-  # Find the thermal zone that is best for adding refrigerated display cases into.
-  # First, check for space types that typically have refrigeration.
-  # Fall back to largest zone in the model if no typical space types are found.
-  #
-  # @param model [OpenStudio::Model::Model] OpenStudio model object
-  # @return [OpenStudio::Model::ThermalZone] returns a thermal zone if found, nil if not.
-  def model_typical_display_case_zone(model)
-    # Ideally, look for one of the space types
-    # that would typically have refrigeration.
-    display_case_zone = nil
-    display_case_zone_area_m2 = 0
-    model.getThermalZones.each do |zone|
-      space_type = OpenstudioStandards::ThermalZone.thermal_zone_get_space_type(zone)
-      next if space_type.empty?
-
-      space_type = space_type.get
-      next if space_type.standardsSpaceType.empty?
-      next if space_type.standardsBuildingType.empty?
-
-      stds_spc_type = space_type.standardsSpaceType.get
-      stds_bldg_type = space_type.standardsBuildingType.get
-      case "#{stds_bldg_type} #{stds_spc_type}"
-      when 'PrimarySchool Kitchen',
-          'SecondarySchool Kitchen',
-          'SuperMarket Sales',
-          'QuickServiceRestaurant Kitchen',
-          'FullServiceRestaurant Kitchen',
-          'LargeHotel Kitchen',
-          'Hospital Kitchen',
-          'EPr Kitchen',
-          'ESe Kitchen',
-          'Gro GrocSales',
-          'RFF StockRoom',
-          'RSD StockRoom',
-          'Htl Kitchen',
-          'Hsp Kitchen'
-        if zone.floorArea > display_case_zone_area_m2
-          display_case_zone = zone
-          display_case_zone_area_m2 = zone.floorArea
-        end
-      end
-    end
-
-    unless display_case_zone.nil?
-      OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.Model', "Display case zone is #{display_case_zone.name}, the largest zone with a space type typical for display cases.")
-      return display_case_zone
-    end
-
-    # If no typical space type was found,
-    # choose the largest zone in the model.
-    display_case_zone = nil
-    display_case_zone_area_m2 = 0
-    model.getThermalZones.each do |zone|
-      if zone.floorArea > display_case_zone_area_m2
-        display_case_zone = zone
-        display_case_zone_area_m2 = zone.floorArea
-      end
-    end
-
-    unless display_case_zone.nil?
-      OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.Model', "No space types typical for display cases were found, so the display cases will be placed in #{display_case_zone.name}, the largest zone.")
-      return display_case_zone
-    end
-
-    return display_case_zone
-  end
-
-  # Find the thermal zone that is best for adding refrigerated walkins into.
-  # First, check for space types that typically have refrigeration.
-  # Fall back to largest zone in the model if no typical space types are found.
-  #
-  # @param model [OpenStudio::Model::Model] OpenStudio model object
-  # @return [OpenStudio::Model::ThermalZone] returns a thermal zone if found, nil if not.
-  def model_typical_walkin_zone(model)
-    # Ideally, look for one of the space types
-    # that would typically have refrigeration walkins.
-    walkin_zone = nil
-    walkin_zone_area_m2 = 0
-    model.getThermalZones.each do |zone|
-      space_type = OpenstudioStandards::ThermalZone.thermal_zone_get_space_type(zone)
-      next if space_type.empty?
-
-      space_type = space_type.get
-      next if space_type.standardsSpaceType.empty?
-      next if space_type.standardsBuildingType.empty?
-
-      stds_spc_type = space_type.standardsSpaceType.get
-      stds_bldg_type = space_type.standardsBuildingType.get
-      case "#{stds_bldg_type} #{stds_spc_type}"
-      when 'PrimarySchool Kitchen',
-          'SecondarySchool Kitchen',
-          'SuperMarket DryStorage',
-          'QuickServiceRestaurant	Kitchen',
-          'FullServiceRestaurant Kitchen',
-          'LargeHotel Kitchen',
-          'Hospital Kitchen',
-          'EPr Kitchen',
-          'ESe Kitchen',
-          'Gro RefWalkInCool',
-          'Gro RefWalkInFreeze',
-          'RFF StockRoom',
-          'RSD StockRoom',
-          'Htl Kitchen',
-          'Hsp Kitchen'
-        if zone.floorArea > walkin_zone_area_m2
-          walkin_zone = zone
-          walkin_zone_area_m2 = zone.floorArea
-        end
-      end
-    end
-
-    unless walkin_zone.nil?
-      OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.Model', "Walkin zone is #{walkin_zone.name}, the largest zone with a space type typical for walkins.")
-      return walkin_zone
-    end
-
-    # If no typical space type was found,
-    # choose the largest zone in the model.
-    walkin_zone = nil
-    walkin_zone_area_m2 = 0
-    model.getThermalZones.each do |zone|
-      if zone.floorArea > walkin_zone_area_m2
-        walkin_zone = zone
-        walkin_zone_area_m2 = zone.floorArea
-      end
-    end
-
-    unless walkin_zone.nil?
-      OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.Model', "No space types typical for walkins were found, so the walkins will be placed in #{walkin_zone.name}, the largest zone.")
-      return walkin_zone
-    end
-
-    return walkin_zone
-  end
-
-  # Add a typical refrigeration system to the model, including cases, walkins,
-  # compressors, and condensors.  For small stores, each case and walkin is served
-  # by one compressor and one condenser.  For larger stores, all medium temp cases and walkins
-  # are served by one multi-compressor rack, and all low temp cases and walkins another.
-  #
-  # @param model [OpenStudio::Model::Model] OpenStudio model object
-  # @param building_type [String] building type
-  # @return [Boolean] returns true if successful, false if not
-  def model_add_typical_refrigeration(model, building_type)
-    # Define system category and scaling factor
-    floor_area_ft2 = OpenStudio.convert(model.getBuilding.floorArea, 'm^2', 'ft^2').get
-    case building_type
-    when 'SuperMarket', 'Gro'
-      if floor_area_ft2 < 35_000 # this is in m2
-        size_category = '<35k ft2'
-        floor_area_scaling_factor = floor_area_ft2 / 35_000
-      elsif floor_area_ft2 < 50_000
-        size_category = '35k - 50k ft2'
-        floor_area_scaling_factor = floor_area_ft2 / 50_000
-      else
-        size_category = '>50k ft2'
-        floor_area_scaling_factor = floor_area_ft2 / 50_000
-      end
-      OpenStudio.logFree(OpenStudio::Info, 'openstudio.Model.Model', "Refrigeration size category is #{size_category}, with a scaling factor of #{floor_area_scaling_factor} because the floor area is #{floor_area_ft2.round} ft2.  All cases and walkins added later will subsequently be scaled by this factor.")
-    else
-      size_category = 'Kitchen'
-      floor_area_scaling_factor = 1 # Do not scale kitchen systems
-    end
-
-    # Add a low and medium temperature system
-    ['Medium Temperature', 'Low Temperature'].each do |system_type|
-      # Find refrigeration system lineup
-      search_criteria = {
-        'template' => template,
-        'building_type' => building_type,
-        'size_category' => size_category,
-        'system_type' => system_type
-      }
-      props_lineup = model_find_object(standards_data['refrigeration_system_lineup'], search_criteria)
-      if props_lineup.nil?
-        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.Model.Model', "No refrigeration system lineup found for #{search_criteria}, no system will be added.")
-        next
-      end
-      number_of_display_cases = props_lineup['number_of_display_cases']
-      number_of_walkins = props_lineup['number_of_walkins']
-      compressor_name = props_lineup['compressor_name']
-      OpenStudio.logFree(OpenStudio::Info, 'openstudio.Model.Model', "Refrigeration system lineup found for #{search_criteria}: #{number_of_display_cases} display cases and #{number_of_walkins} walkins, with compressor '#{compressor_name}'.")
-
-      # Find the thermal zones most suited for holding the display cases
-      thermal_zone_case = nil
-      if number_of_display_cases > 0
-        thermal_zone_case = model_typical_display_case_zone(model)
-        if thermal_zone_case.nil?
-          OpenStudio.logFree(OpenStudio::Error, 'openstudio.model.Model', "Attempted to add #{number_of_display_cases} display cases to the model, but could find no thermal zone to put them into.")
-          return false
-        end
-      end
-
-      # Add display cases
-      display_cases = []
-      (1..number_of_display_cases).each_with_index do |display_case_number, def_start_hr_iterator|
-        case_type = props_lineup["case_type_#{display_case_number}"]
-
-        # Add the basic case
-        ref_case = model_add_refrigeration_case(model, thermal_zone_case, case_type, size_category)
-        return false if ref_case.nil?
-
-        # Scale based on floor area
-        ref_case.setCaseLength(ref_case.caseLength * floor_area_scaling_factor)
-
-        # Find defrost and dripdown properties
-        search_criteria = {
-          'template' => template,
-          'case_type' => case_type,
-          'size_category' => size_category
-        }
-        props_case = model_find_object(standards_data['refrigerated_cases'], search_criteria)
-        if props_case.nil?
-          OpenStudio.logFree(OpenStudio::Error, 'openstudio.Model.Model', "Could not find refrigerated case properties for: #{search_criteria}.")
-          next
-        end
-        numb_defrosts_per_day = props_case['defrost_per_day']
-        minutes_defrost = props_case['minutes_defrost']
-        minutes_dripdown = props_case['minutes_dripdown']
-        minutes_defrost = 59 if minutes_defrost > 59 # Just to make sure to remain in the same hour
-        minutes_dripdown = 59 if minutes_dripdown > 59 # Just to make sure to remain in the same hour
-
-        # Add defrost and dripdown schedules
-        defrost_sch = OpenStudio::Model::ScheduleRuleset.new(model)
-        defrost_sch.setName("#{ref_case.name} Defrost")
-        defrost_sch.defaultDaySchedule.setName("#{ref_case.name} Defrost Default")
-        dripdown_sch = OpenStudio::Model::ScheduleRuleset.new(model)
-        dripdown_sch.setName("#{ref_case.name} Dripdown")
-        dripdown_sch.defaultDaySchedule.setName("#{ref_case.name} Dripdown Default")
-
-        # Stagger the defrosts for cases by 1 hr
-        interval_defrost = (24 / numb_defrosts_per_day).floor # Hour interval between each defrost period
-        if (def_start_hr_iterator + (interval_defrost * numb_defrosts_per_day)) > 23
-          first_def_start_hr = 0 # Start over again at midnight when time reaches 23hrs
-        else
-          first_def_start_hr = def_start_hr_iterator
-        end
-
-        # Add the specified number of defrost periods to the daily schedule
-        (1..numb_defrosts_per_day).each do |defrost_of_day|
-          def_start_hr = first_def_start_hr + ((1 - defrost_of_day) * interval_defrost)
-          defrost_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, def_start_hr, 0, 0), 0)
-          defrost_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, def_start_hr, minutes_defrost.to_int, 0), 1)
-          dripdown_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, def_start_hr, 0, 0), 0) # Dripdown is synced with defrost
-          dripdown_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, def_start_hr, minutes_dripdown.to_int, 0), 1)
-        end
-        defrost_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, 24, 0, 0), 0)
-        dripdown_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, 24, 0, 0), 0)
-
-        # Assign the defrost and dripdown schedules
-        ref_case.setCaseDefrostSchedule(defrost_sch)
-        ref_case.setCaseDefrostDripDownSchedule(dripdown_sch)
-
-        display_cases << ref_case
-      end
-
-      # Find the thermal zones most suited for holding the walkins
-      thermal_zone_walkin = nil
-      if number_of_walkins > 0
-        thermal_zone_walkin = model_typical_walkin_zone(model)
-        if thermal_zone_walkin.nil?
-          OpenStudio.logFree(OpenStudio::Error, 'openstudio.model.Model', "Attempted to add #{number_of_walkins} walkins to the model, but could find no thermal zone to put them into.")
-          return false
-        end
-      end
-
-      # Add walkin cases
-      walkins = []
-      (1..number_of_walkins).each_with_index do |walkin_number, def_start_hr_iterator|
-        walkin_type = props_lineup["walkin_type_#{walkin_number}"]
-
-        # Add the basic walkin
-        ref_walkin = model_add_refrigeration_walkin(model, thermal_zone_walkin, size_category, walkin_type)
-        return false if ref_walkin.nil?
-
-        # Scale based on floor area
-        ref_walkin.setRatedTotalLightingPower(ref_walkin.ratedTotalLightingPower * floor_area_scaling_factor)
-        ref_walkin.setRatedCoolingCoilFanPower(ref_walkin.ratedCoolingCoilFanPower * floor_area_scaling_factor)
-        ref_walkin.setDefrostPower(ref_walkin.defrostPower.get * floor_area_scaling_factor)
-        ref_walkin.setRatedCoilCoolingCapacity(ref_walkin.ratedCoilCoolingCapacity * floor_area_scaling_factor)
-        ref_walkin.setZoneBoundaryTotalInsulatedSurfaceAreaFacingZone(ref_walkin.zoneBoundaryTotalInsulatedSurfaceAreaFacingZone.get * floor_area_scaling_factor)
-        ref_walkin.setInsulatedFloorSurfaceArea(ref_walkin.insulatedFloorSurfaceArea * floor_area_scaling_factor)
-
-        # Check that walkin physically fits inside the thermal zone.
-        # If not, remove the walkin and warn.
-        walkin_floor_area_ft2 = OpenStudio.convert(ref_walkin.insulatedFloorSurfaceArea, 'm^2', 'ft^2').get.round
-        walkin_zone_floor_area_ft2 = OpenStudio.convert(thermal_zone_walkin.floorArea, 'm^2', 'ft^2').get.round
-        if walkin_floor_area_ft2 > walkin_zone_floor_area_ft2
-          OpenStudio.logFree(OpenStudio::Warn, 'openstudio.Model.Model', "Walkin #{ref_walkin.name} has an area of #{walkin_floor_area_ft2} ft^2, which is larger than the #{walkin_zone_floor_area_ft2} ft^2 zone.  Walkin will be kept in the model, but considered re-sizing the zone '#{thermal_zone_walkin.name}'.")
-        end
-
-        # Find defrost and dripdown properties
-        search_criteria = {
-          'template' => template,
-          'walkin_type' => walkin_type,
-          'size_category' => size_category
-        }
-        props_walkin = model_find_object(standards_data['refrigeration_walkins'], search_criteria)
-        if props_walkin.nil?
-          OpenStudio.logFree(OpenStudio::Error, 'openstudio.Model.Model', "Could not find walkin properties for: #{search_criteria}.")
-          next
-        end
-        numb_defrosts_per_day = props_walkin['defrost_per_day']
-        minutes_defrost = props_walkin['minutes_defrost']
-        minutes_dripdown = props_walkin['minutes_dripdown']
-        minutes_defrost = 59 if minutes_defrost > 59 # Just to make sure to remain in the same hour
-        minutes_dripdown = 59 if minutes_dripdown > 59 # Just to make sure to remain in the same hour
-
-        # Add defrost and dripdown schedules
-        defrost_sch_walkin = OpenStudio::Model::ScheduleRuleset.new(model)
-        defrost_sch_walkin.setName("#{ref_walkin.name} Defrost")
-        defrost_sch_walkin.defaultDaySchedule.setName("#{ref_walkin.name} Defrost Default")
-        dripdown_sch_walkin = OpenStudio::Model::ScheduleRuleset.new(model)
-        dripdown_sch_walkin.setName("#{ref_walkin.name} Dripdown")
-        dripdown_sch_walkin.defaultDaySchedule.setName("#{ref_walkin.name} Dripdown Default")
-
-        # Stagger the defrosts for cases by 1 hr
-        interval_defrost = (24 / numb_defrosts_per_day).floor # Hour interval between each defrost period
-        if (def_start_hr_iterator + (interval_defrost * numb_defrosts_per_day)) > 23
-          first_def_start_hr = 0 # Start over again at midnight when time reaches 23hrs
-        else
-          first_def_start_hr = def_start_hr_iterator
-        end
-
-        # Add the specified number of defrost periods to the daily schedule
-        (1..numb_defrosts_per_day).each do |defrost_of_day|
-          def_start_hr = first_def_start_hr + ((1 - defrost_of_day) * interval_defrost)
-          defrost_sch_walkin.defaultDaySchedule.addValue(OpenStudio::Time.new(0, def_start_hr, 0, 0), 0)
-          defrost_sch_walkin.defaultDaySchedule.addValue(OpenStudio::Time.new(0, def_start_hr, minutes_defrost.to_int, 0), 1)
-          dripdown_sch_walkin.defaultDaySchedule.addValue(OpenStudio::Time.new(0, def_start_hr, 0, 0), 0) # Dripdown is synced with defrost
-          dripdown_sch_walkin.defaultDaySchedule.addValue(OpenStudio::Time.new(0, def_start_hr, minutes_dripdown.to_int, 0), 1)
-        end
-        defrost_sch_walkin.defaultDaySchedule.addValue(OpenStudio::Time.new(0, 24, 0, 0), 0)
-        dripdown_sch_walkin.defaultDaySchedule.addValue(OpenStudio::Time.new(0, 24, 0, 0), 0)
-
-        # Assign the defrost and dripdown schedules
-        ref_walkin.setDefrostSchedule(defrost_sch_walkin)
-        ref_walkin.setDefrostDripDownSchedule(dripdown_sch_walkin)
-
-        walkins << ref_walkin
-      end
-
-      # Divide cases and walkins into one or more refrigeration systems depending on store type
-      # For small stores and kitchens one system with one compressor and one condenser per case is employed.
-      # For larger stores, multiple cases and walkins are served by a rack with multiple compressors.
-      ref_system_lineups = []
-      case system_type
-      when '<35k ft2', 'Kitchen'
-        # Put each case on its own system
-        display_cases.each do |ref_case|
-          ref_system_lineups << { 'ref_cases' => [ref_case], 'walkins' => [] }
-        end
-        # Put each walkin on its own system
-        walkins.each do |walkin|
-          ref_system_lineups << { 'ref_cases' => [], 'walkins' => [walkin] }
-        end
-      else
-        # Put all cases and walkins on one system
-        ref_system_lineups << { 'ref_cases' => display_cases, 'walkins' => walkins }
-      end
-
-      # Find refrigeration system properties
-      search_criteria = {
-        'template' => template,
-        'building_type' => building_type,
-        'size_category' => size_category,
-        'system_type' => system_type
-      }
-      props_ref_system = model_find_object(standards_data['refrigeration_system'], search_criteria)
-      if props_ref_system.nil?
-        OpenStudio.logFree(OpenStudio::Error, 'openstudio.Model.Model', "Could not find refrigeration system properties for: #{search_criteria}.")
-        next
-      end
-
-      # Add refrigeration systems
-      ref_system_lineups.each do |ref_system_lineup|
-        # Skip if no cases or walkins are attached to the system
-        next if ref_system_lineup['ref_cases'].empty? && ref_system_lineup['walkins'].empty?
-
-        # Add refrigeration system
-        ref_system = OpenStudio::Model::RefrigerationSystem.new(model)
-        ref_system.setName(system_type)
-        ref_system.setRefrigerationSystemWorkingFluidType(props_ref_system['refrigerant'])
-        ref_system.setSuctionTemperatureControlType(props_ref_system['refrigerant'])
-
-        # Sum the capacity required by all cases and walkins
-        # and attach the cases and walkins to the system.
-        rated_case_capacity_w = 0
-        ref_system_lineup['ref_cases'].each do |ref_case|
-          rated_case_capacity_w += ref_case.ratedTotalCoolingCapacityperUnitLength * ref_case.caseLength
-          ref_system.addCase(ref_case)
-        end
-        ref_system_lineup['walkins'].each do |walkin|
-          rated_case_capacity_w += walkin.ratedCoilCoolingCapacity
-          ref_system.addWalkin(walkin)
-        end
-
-        # Find the compressor properties
-        search_criteria = {
-          'template' => template,
-          'compressor_name' => compressor_name
-        }
-        props_compressor = model_find_object(standards_data['refrigeration_compressors'], search_criteria)
-        if props_compressor.nil?
-          OpenStudio.logFree(OpenStudio::Error, 'openstudio.Model.Model', "Could not find refrigeration compressor properties for: #{search_criteria}.")
-          next
-        end
-
-        # Calculate the number of compressors required to meet the
-        # combined rated capacity of all the cases
-        # and add them to the system
-        rated_compressor_capacity_btu_per_hr = props_compressor['rated_capacity']
-        number_of_compressors = (rated_case_capacity_w / OpenStudio.convert(rated_compressor_capacity_btu_per_hr, 'Btu/h', 'W').get).ceil
-        (1..number_of_compressors).each do |compressor_number|
-          compressor = model_add_refrigeration_compressor(model, compressor_name)
-          ref_system.addCompressor(compressor)
-        end
-        OpenStudio.logFree(OpenStudio::Info, 'openstudio.Model.Model', "Added #{number_of_compressors} compressors, each with a capacity of #{rated_compressor_capacity_btu_per_hr.round} Btu/hr to serve #{OpenStudio.convert(rated_case_capacity_w, 'W', 'Btu/hr').get.round} Btu/hr of case and walkin load.")
-
-        # Find the condenser properties
-        search_criteria = {
-          'template' => template,
-          'building_type' => building_type,
-          'system_type' => system_type,
-          'size_category' => size_category
-        }
-        props_condenser = model_find_object(standards_data['refrigeration_condenser'], search_criteria)
-        if props_condenser.nil?
-          OpenStudio.logFree(OpenStudio::Error, 'openstudio.Model.Model', "Could not find refrigeration condenser properties for: #{search_criteria}.")
-          next
-        end
-
-        # Heat rejection as a function of temperature
-        heat_rejection_curve = OpenStudio::Model::CurveLinear.new(model)
-        heat_rejection_curve.setName('Condenser Heat Rejection Function of Temperature')
-        heat_rejection_curve.setCoefficient1Constant(0)
-        heat_rejection_curve.setCoefficient2x(props_condenser['heatrejectioncurve_c1'])
-        heat_rejection_curve.setMinimumValueofx(-50)
-        heat_rejection_curve.setMaximumValueofx(50)
-
-        # Add condenser
-        condenser = OpenStudio::Model::RefrigerationCondenserAirCooled.new(model)
-        condenser.setRatedEffectiveTotalHeatRejectionRateCurve(heat_rejection_curve)
-        condenser.setRatedSubcoolingTemperatureDifference(OpenStudio.convert(props_condenser['subcool_t'], 'F', 'C').get)
-        condenser.setMinimumFanAirFlowRatio(props_condenser['min_airflow'])
-        condenser.setRatedFanPower(props_condenser['fan_power_per_q_rejected'].to_f * rated_case_capacity_w)
-        condenser.setCondenserFanSpeedControlType(props_condenser['fan_speed_control'])
-        ref_system.setRefrigerationCondenser(condenser)
-
-        OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.Model', "Added #{system_type} refrigeration system")
-      end
-    end
-
-    return true
-  end
-
-  # Determine the latent case credit curve to use for walkins. Defaults to values after 90.1-2007.
-  # @todo Should probably use the model_add_refrigeration_walkin and lookups from the spreadsheet instead of hard-coded values
-  #
-  # @param model [OpenStudio::Model::Model] OpenStudio model object
-  # @return [Boolean] returns true if successful, false if not
-  def model_walkin_freezer_latent_case_credit_curve(model)
-    latent_case_credit_curve_name = 'Single Shelf Horizontal Latent Energy Multiplier_After2004'
-    return latent_case_credit_curve_name
-  end
-
   # Adds a full commercial refrigeration rack to the model, as would be found in a supermarket
   # @todo Move refrigeration compressors to spreadsheet
   #

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

@@ -321,7 +321,7 @@ class Standard
     return cop
   end
 
-  # Convert from EER to COP
+  # Convert from EER to COP (no fan)
   # @ref [References::USDOEPrototypeBuildings] If capacity is not supplied, use DOE Prototype Building method.
   # @ref [References::ASHRAE9012013] If capacity is supplied, use the 90.1-2013 method
   #
@@ -345,7 +345,7 @@ class Standard
     return cop
   end
 
-  # Convert from COP to EER
+  # Convert from COP (no fan) to EER
   # @ref [References::USDOEPrototypeBuildings]
   #
   # @param cop [Double] COP
@@ -367,6 +367,22 @@ class Standard
     return eer
   end
 
+  # Convert from IEER to COP (no fan)
+  #
+  # @note IEER is a weighted-average efficiency metrics at different load percentages, operataional and environemental conditions
+  # @note IEER should be modeled by using performance curves that match a targeted efficiency values
+  # @note This method estimates what a reasonable full load rated EER would be for a targeted IEER value
+  # @note The regression used in this method is based on a survey of over 1,000 rated AHRI units with IEER ranging from 11.8 to 25.6
+  # @todo Implement methods to handle IEER modeling
+  #
+  # @param ieer [Double] Energy Efficiency Ratio (EER)
+  # @return [Double] Coefficient of Performance (COP)
+  def ieer_to_cop_no_fan(ieer)
+    eer = 0.0183 * ieer * ieer - 0.4552 * ieer + 13.21
+
+    return eer_to_cop_no_fan(eer)
+  end
+
   # Convert from EER to COP
   #
   # @param eer [Double] Energy Efficiency Ratio (EER)

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

@@ -0,0 +1,125 @@
+module OpenstudioStandards
+  # The Refrigeration module provides methods to create, modify, and get information about refrigeration
+  module Refrigeration
+    # @!group Create Case
+    # Methods to add refrigerated cases
+
+    # Adds a refrigerated case to the model.
+    #
+    # @param model [OpenStudio::Model::Model] OpenStudio model object
+    # @param template [String] Technology or standards level, either 'old', 'new', or 'advanced'
+    # @param case_type [String] The case type. See refrigeration_cases data for valid options under case_name.
+    # @param case_length [String] The case length in meters.
+    # @param thermal_zone [OpenStudio::Model::ThermalZone] Thermal zone with the case. If nil, will look up from the model.
+    # @return [OpenStudio::Model::RefrigerationCase] the refrigeration case
+    def self.create_case(model,
+                         template: 'new',
+                         case_type: 'Vertical Open - All',
+                         case_length: nil,
+                         thermal_zone: nil)
+      # get thermal zone if not provided
+      if thermal_zone.nil?
+        # Find the thermal zones most suited for holding the display cases
+        thermal_zone = OpenstudioStandards::Refrigeration.refrigeration_case_zone(model)
+        if thermal_zone.nil?
+          OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Refrigeration', 'Attempted to add display cases to the model, but could find no thermal zone to put them into.')
+          return nil
+        end
+      end
+
+      # load refrigeration cases data
+      cases_csv = "#{__dir__}/data/refrigerated_cases.csv"
+      unless File.exist?(cases_csv)
+        OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Refrigeration', "Unable to find file: #{cases_csv}")
+        return nil
+      end
+      cases_tbl = CSV.table(cases_csv, encoding: 'ISO8859-1:utf-8')
+      cases_hsh = cases_tbl.map(&:to_hash)
+
+      # get case properties
+      case_properties = cases_hsh.select { |r| (r[:template] == template) && (r[:case_name] == case_type) }[0]
+
+      if case_properties.nil?
+        OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Refrigeration', "Unable to find case data for template #{template} case type #{case_type}.")
+        return nil
+      end
+
+      # add case
+      ref_case = OpenStudio::Model::RefrigerationCase.new(model, model.alwaysOnDiscreteSchedule)
+      ref_case.setName(case_type)
+      case_length_m = case_length.nil? ? case_properties[:unit_length] : case_length
+      ref_case.setCaseLength(case_length_m)
+      ref_case.setRatedTotalCoolingCapacityperUnitLength(case_properties[:rated_capacity])
+      ref_case.setCaseOperatingTemperature(case_properties[:case_operating_temperature])
+      ref_case.setDesignEvaporatorTemperatureorBrineInletTemperature(case_properties[:evaporator_temperature])
+      ref_case.setRatedLatentHeatRatio(case_properties[:rated_latent_heat_ratio])
+      ref_case.setRatedRuntimeFraction(case_properties[:rated_runtime_fraction])
+      ref_case.setLatentCaseCreditCurveType(case_properties[:latent_case_credit_curve_type])
+      # TODO: replace once curves are standardized
+      std = Standard.build('90.1-2013')
+      latent_case_credit_curve = std.model_add_curve(model, case_properties[:latent_case_credit_curve_name])
+      ref_case.setLatentCaseCreditCurve(latent_case_credit_curve)
+      ref_case.setStandardCaseFanPowerperUnitLength(case_properties[:fan_power])
+      ref_case.setOperatingCaseFanPowerperUnitLength(case_properties[:fan_power])
+      ref_case.setStandardCaseLightingPowerperUnitLength(case_properties[:lighting_power])
+      ref_case.setInstalledCaseLightingPowerperUnitLength(case_properties[:lighting_power])
+      ref_case.setCaseLightingSchedule(model.alwaysOnDiscreteSchedule)
+      ref_case.setFractionofLightingEnergytoCase(case_properties[:fraction_of_lighting_energy_to_case]) unless case_properties[:fraction_of_lighting_energy_to_case].nil?
+      ref_case.setCaseAntiSweatHeaterPowerperUnitLength(case_properties[:anti_sweat_power]) unless case_properties[:anti_sweat_power].nil?
+      ref_case.setMinimumAntiSweatHeaterPowerperUnitLength(0.0)
+      ref_case.setHumidityatZeroAntiSweatHeaterEnergy(0.0)
+      ref_case.setAntiSweatHeaterControlType(case_properties[:anti_sweat_heater_control_type])
+      ref_case.setFractionofAntiSweatHeaterEnergytoCase(case_properties[:fraction_of_anti_sweat_heater_energy_to_cases]) unless case_properties[:fraction_of_anti_sweat_heater_energy_to_cases].nil?
+      ref_case.setCaseDefrostPowerperUnitLength(case_properties[:defrost_power]) unless case_properties[:defrost_power].nil?
+      ref_case.setCaseDefrostType(case_properties[:defrost_type])
+      ref_case.setDefrostEnergyCorrectionCurveType(case_properties[:defrost_energy_correction_curve_type]) unless case_properties[:defrost_energy_correction_curve_type].nil?
+      unless case_properties[:defrost_energy_correction_curve_name].nil?
+        # TODO: replace once curves are standardized
+        defrost_correction_curve_name = std.model_add_curve(model, case_properties[:defrost_energy_correction_curve_name])
+        ref_case.setDefrostEnergyCorrectionCurve(defrost_correction_curve_name)
+      end
+      ref_case.setUnderCaseHVACReturnAirFraction(0.0)
+      ref_case.resetRefrigeratedCaseRestockingSchedule
+      ref_case.setAvailabilitySchedule(model.alwaysOnDiscreteSchedule)
+      ref_case.setThermalZone(thermal_zone)
+      ref_case.setRatedAmbientTemperature(OpenStudio.convert(75.0, 'F', 'C').get)
+
+      # place holders for schedules until data provided from ORNL
+      i = 0
+      # Defrost schedule
+      defrost_sch = OpenStudio::Model::ScheduleRuleset.new(model)
+      defrost_sch.setName("#{ref_case.name} Defrost")
+      defrost_sch.defaultDaySchedule.setName("#{ref_case.name} Defrost Default")
+      defrost_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, i, 0, 0), 0)
+      defrost_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, i, 59, 0), 1)
+      defrost_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, 24, 0, 0), 0)
+
+      # 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.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)
+
+      # Case Credit Schedule
+      case_credit_sch = OpenStudio::Model::ScheduleRuleset.new(model)
+      case_credit_sch.setName("#{ref_case.name} Case Credit")
+      case_credit_sch.defaultDaySchedule.setName("#{ref_case.name} Case Credit Default")
+      case_credit_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, 7, 0, 0), 0.2)
+      case_credit_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, 21, 0, 0), 0.4)
+      case_credit_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, 24, 0, 0), 0.2)
+      ref_case.setCaseDefrostSchedule(defrost_sch)
+      ref_case.setCaseDefrostDripDownSchedule(dripdown_sch)
+      ref_case.setCaseCreditFractionSchedule(case_credit_sch)
+
+      # reporting
+      length_ft = OpenStudio.convert(ref_case.caseLength, 'm', 'ft').get
+      cooling_capacity_w = ref_case.caseLength * ref_case.ratedTotalCoolingCapacityperUnitLength
+      cooling_capacity_btu_per_hr = OpenStudio.convert(cooling_capacity_w, 'W', 'Btu/hr').get
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Refrigeration', "Added #{length_ft.round} ft display case called #{case_type} with a cooling capacity of #{cooling_capacity_btu_per_hr.round} Btu/hr to #{thermal_zone&.name}.")
+
+      return ref_case
+    end
+  end
+end