openstudio-standards 0.1.4 → 0.1.5

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

@@ -1,6 +1,75 @@
 
 # open the class to add methods to apply HVAC efficiency standards
 class OpenStudio::Model::BuildingStory
+  # Checks all spaces on this story that are part of the total
+  # floor area to see if they have the same multiplier.
+  # If they do, assume that the multipliers are being used
+  # as a floor multiplier.
+  #
+  # @return [Integer] return the floor multiplier for this story,
+  # returning 1 if no floor multiplier.
+  def floor_multiplier
+    floor_multiplier = 1
 
+    # Determine the multipliers for all spaces
+    multipliers = []
+    spaces.each do |space|
+      # Ignore spaces that aren't part of the total floor area
+      next unless space.partofTotalFloorArea
+      multipliers << space.multiplier
+    end
 
+    # If there are no spaces on this story, assume
+    # a multiplier of 1
+    if multipliers.size.zero?
+      return floor_multiplier
+    end
+
+    # Calculate the average multiplier and
+    # then convert to integer.
+    avg_multiplier = (multipliers.inject { |a, e| a + e }.to_f / multipliers.size).to_i
+
+    # If the multiplier is greater than 1, report this
+    if avg_multiplier > 1
+      floor_multiplier = avg_multiplier
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.BuildingStory', "Story #{name} has a multiplier of #{floor_multiplier}.")
+    end
+
+    return floor_multiplier
+  end
+
+  # Gets the minimum z-value of the story.
+  # This is considered to be the minimum z value
+  # of any vertex of any surface of any space on the
+  # story, with the exception of plenum spaces.
+  #
+  # @return [Double] the minimum z-value, in m
+  def minimum_z_value
+    z_heights = []
+    spaces.each do |space|
+      # Skip plenum spaces
+      next if space.plenum?
+
+      # Get the z value of the space, which
+      # vertices in space surfaces are relative to.
+      z_origin = space.zOrigin
+
+      # loop through space surfaces to find min z value
+      space.surfaces.each do |surface|
+        surface.vertices.each do |vertex|
+          z_heights << vertex.z + z_origin
+        end
+      end
+    end
+
+    # Error if no z heights were found
+    z = 999.9 
+    if z_heights.size > 0
+      z = z_heights.min
+    else
+      OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Model', "For #{name} could not find the minimum_z_value, which means the story has no spaces assigned or the spaces have no surfaces.")
+    end
+
+    return z
+  end
 end

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

@@ -1,21 +1,19 @@
 
 # Reopen the OpenStudio class to add methods to apply standards to this object
 class OpenStudio::Model::ChillerElectricEIR
-
   # Finds the search criteria
   #
   # @param template [String] valid choices: 'DOE Ref Pre-1980', 'DOE Ref 1980-2004', '90.1-2004', '90.1-2007', '90.1-2010', '90.1-2013'
   # @return [hash] has for search criteria to be used for find object
   def find_search_criteria(template)
-
     # Define the criteria to find the chiller properties
     # in the hvac standards data set.
     search_criteria = {}
     search_criteria['template'] = template
-    cooling_type = self.condenserType
+    cooling_type = condenserType
     search_criteria['cooling_type'] = cooling_type
 
-    # TODO Standards replace this with a mechanism to store this
+    # TODO: Standards replace this with a mechanism to store this
     # data in the chiller object itself.
     # For now, retrieve the condenser type from the name
     name = self.name.get
@@ -32,7 +30,7 @@ class OpenStudio::Model::ChillerElectricEIR
         compressor_type = 'Reciprocating'
       elsif name.include?('Rotary Screw')
         compressor_type = 'Rotary Screw'
-      elsif  name.include?('Scroll')
+      elsif name.include?('Scroll')
         compressor_type = 'Scroll'
       elsif name.include?('Centrifugal')
         compressor_type = 'Centrifugal'
@@ -46,31 +44,27 @@ class OpenStudio::Model::ChillerElectricEIR
     end
 
     return search_criteria
-
   end
 
   # Finds capacity in tons
   #
   # @return [Double] capacity in tons to be used for find object
-  def find_capacity()
-
+  def find_capacity
     # Get the chiller capacity
     capacity_w = nil
-    if self.referenceCapacity.is_initialized
-      capacity_w = self.referenceCapacity.get
-    elsif self.autosizedReferenceCapacity.is_initialized
-      capacity_w = self.autosizedReferenceCapacity.get
+    if referenceCapacity.is_initialized
+      capacity_w = referenceCapacity.get
+    elsif autosizedReferenceCapacity.is_initialized
+      capacity_w = autosizedReferenceCapacity.get
     else
-      OpenStudio::logFree(OpenStudio::Warn, "openstudio.standards.ChillerElectricEIR", "For #{self.name} capacity is not available, cannot apply efficiency standard.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.ChillerElectricEIR', "For #{name} capacity is not available, cannot apply efficiency standard.")
       successfully_set_all_properties = false
       return successfully_set_all_properties
     end
 
-    capacity_tons = OpenStudio.convert(capacity_w, "W", "ton").get
-
+    capacity_tons = OpenStudio.convert(capacity_w, 'W', 'ton').get
 
     return capacity_tons
-
   end
 
   # Finds lookup object in standards and return full load efficiency
@@ -78,12 +72,11 @@ class OpenStudio::Model::ChillerElectricEIR
   # @param template [String] valid choices: 'DOE Ref Pre-1980', 'DOE Ref 1980-2004', '90.1-2004', '90.1-2007', '90.1-2010', '90.1-2013'
   # @param standards [Hash] the OpenStudio_Standards spreadsheet in hash format
   # @return [Double] full load efficiency (COP)
-  def standard_minimum_full_load_efficiency(template,standards)
-
+  def standard_minimum_full_load_efficiency(template, standards)
     # Get the chiller properties
-    search_criteria = self.find_search_criteria(template)
-    capacity_tons = self.find_capacity
-    chlr_props = self.model.find_object(standards['chillers'], search_criteria, capacity_tons)
+    search_criteria = find_search_criteria(template)
+    capacity_tons = find_capacity
+    chlr_props = model.find_object(standards['chillers'], search_criteria, capacity_tons, Date.today)
 
     # lookup the efficiency value
     kw_per_ton = nil
@@ -92,11 +85,10 @@ class OpenStudio::Model::ChillerElectricEIR
       kw_per_ton = chlr_props['minimum_full_load_efficiency']
       cop = kw_per_ton_to_cop(kw_per_ton)
     else
-      OpenStudio::logFree(OpenStudio::Warn, "openstudio.standards.ChillerElectricEIR", "For #{self.name}, cannot find minimum full load efficiency.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.ChillerElectricEIR', "For #{name}, cannot find minimum full load efficiency.")
     end
 
     return cop
-
   end
 
   # Applies the standard efficiency ratings and typical performance curves to this object.
@@ -104,22 +96,20 @@ class OpenStudio::Model::ChillerElectricEIR
   # @param template [String] valid choices: 'DOE Ref Pre-1980', 'DOE Ref 1980-2004', '90.1-2004', '90.1-2007', '90.1-2010', '90.1-2013'
   # @param standards [Hash] the OpenStudio_Standards spreadsheet in hash format
   # @return [Bool] true if successful, false if not
-  def setStandardEfficiencyAndCurves(template, clg_tower_objs)
-
+  def apply_efficiency_and_curves(template, clg_tower_objs)
     chillers = $os_standards['chillers']
     curve_biquadratics = $os_standards['curve_biquadratics']
     curve_quadratics = $os_standards['curve_quadratics']
     curve_bicubics = $os_standards['curve_bicubics']
 
-
     # Define the criteria to find the chiller properties
     # in the hvac standards data set.
     search_criteria = {}
     search_criteria['template'] = template
-    cooling_type = self.condenserType
+    cooling_type = condenserType
     search_criteria['cooling_type'] = cooling_type
 
-    # TODO Standards replace this with a mechanism to store this
+    # TODO: Standards replace this with a mechanism to store this
     # data in the chiller object itself.
     # For now, retrieve the condenser type from the name
     name = self.name.get
@@ -136,7 +126,7 @@ class OpenStudio::Model::ChillerElectricEIR
         compressor_type = 'Reciprocating'
       elsif name.include?('Rotary Screw')
         compressor_type = 'Rotary Screw'
-      elsif  name.include?('Scroll')
+      elsif name.include?('Scroll')
         compressor_type = 'Scroll'
       elsif name.include?('Centrifugal')
         compressor_type = 'Centrifugal'
@@ -151,73 +141,73 @@ class OpenStudio::Model::ChillerElectricEIR
 
     # Get the chiller capacity
     capacity_w = nil
-    if self.referenceCapacity.is_initialized
-      capacity_w = self.referenceCapacity.get
-    elsif self.autosizedReferenceCapacity.is_initialized
-      capacity_w = self.autosizedReferenceCapacity.get
+    if referenceCapacity.is_initialized
+      capacity_w = referenceCapacity.get
+    elsif autosizedReferenceCapacity.is_initialized
+      capacity_w = autosizedReferenceCapacity.get
     else
-      OpenStudio::logFree(OpenStudio::Warn, "openstudio.standards.ChillerElectricEIR", "For #{self.name} capacity is not available, cannot apply efficiency standard.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.ChillerElectricEIR', "For #{self.name} capacity is not available, cannot apply efficiency standard.")
       successfully_set_all_properties = false
       return successfully_set_all_properties
     end
 
-    #NECB 2011 requires that all chillers be modulating down to 25% of their capacity
+    # NECB 2011 requires that all chillers be modulating down to 25% of their capacity
     if template == 'NECB 2011'
-      self.setChillerFlowMode('LeavingSetpointModulated')
-      self.setMinimumPartLoadRatio(0.25)
-      self.setMinimumUnloadingRatio(0.25)
-      if((capacity_w/1000.0) < 2100.0)
-        if(self.name.to_s.include? 'Primary Chiller')
+      setChillerFlowMode('LeavingSetpointModulated')
+      setMinimumPartLoadRatio(0.25)
+      setMinimumUnloadingRatio(0.25)
+      if (capacity_w / 1000.0) < 2100.0
+        if self.name.to_s.include? 'Primary Chiller'
           chiller_capacity = capacity_w
-        elsif(self.name.to_s.include? 'Secondary Chiller')
+        elsif self.name.to_s.include? 'Secondary Chiller'
           chiller_capacity = 0.001
         end
       else
-        chiller_capacity = capacity_w/2.0
+        chiller_capacity = capacity_w / 2.0
       end
-      self.setReferenceCapacity(chiller_capacity)
-    end  # NECB 2011
+      setReferenceCapacity(chiller_capacity)
+    end # NECB 2011
 
     # Convert capacity to tons
-    if template == 'NECB 2011'
-      capacity_tons = OpenStudio.convert(chiller_capacity, "W", "ton").get
-    else
-      capacity_tons = OpenStudio.convert(capacity_w, "W", "ton").get
-    end
+    capacity_tons = if template == 'NECB 2011'
+                      OpenStudio.convert(chiller_capacity, 'W', 'ton').get
+                    else
+                      OpenStudio.convert(capacity_w, 'W', 'ton').get
+                    end
 
     # Get the chiller properties
-    chlr_props = self.model.find_object(chillers, search_criteria, capacity_tons)
-    if !chlr_props
-      OpenStudio::logFree(OpenStudio::Warn, "openstudio.standards.ChillerElectricEIR", "For #{self.name}, cannot find chiller properties, cannot apply standard efficiencies or curves.")
+    chlr_props = model.find_object(chillers, search_criteria, capacity_tons, Date.today)
+    unless chlr_props
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.ChillerElectricEIR', "For #{self.name}, cannot find chiller properties, cannot apply standard efficiencies or curves.")
       successfully_set_all_properties = false
       return successfully_set_all_properties
     end
 
     # Make the CAPFT curve
-    cool_cap_ft = self.model.add_curve(chlr_props['capft'])
+    cool_cap_ft = model.add_curve(chlr_props['capft'])
     if cool_cap_ft
-      self.setCoolingCapacityFunctionOfTemperature(cool_cap_ft)
+      setCoolingCapacityFunctionOfTemperature(cool_cap_ft)
     else
-      OpenStudio::logFree(OpenStudio::Warn, "openstudio.standards.ChillerElectricEIR", "For #{self.name}, cannot find cool_cap_ft curve, will not be set.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.ChillerElectricEIR', "For #{self.name}, cannot find cool_cap_ft curve, will not be set.")
       successfully_set_all_properties = false
     end
 
     # Make the EIRFT curve
-    cool_eir_ft = self.model.add_curve(chlr_props['eirft'])
+    cool_eir_ft = model.add_curve(chlr_props['eirft'])
     if cool_eir_ft
-      self.setElectricInputToCoolingOutputRatioFunctionOfTemperature(cool_eir_ft)
+      setElectricInputToCoolingOutputRatioFunctionOfTemperature(cool_eir_ft)
     else
-      OpenStudio::logFree(OpenStudio::Warn, "openstudio.standards.ChillerElectricEIR", "For #{self.name}, cannot find cool_eir_ft curve, will not be set.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.ChillerElectricEIR', "For #{self.name}, cannot find cool_eir_ft curve, will not be set.")
       successfully_set_all_properties = false
     end
 
     # Make the EIRFPLR curve
     # which may be either a CurveBicubic or a CurveQuadratic based on chiller type
-    cool_plf_fplr = self.model.add_curve(chlr_props['eirfplr'])
+    cool_plf_fplr = model.add_curve(chlr_props['eirfplr'])
     if cool_plf_fplr
-      self.setElectricInputToCoolingOutputRatioFunctionOfPLR(cool_plf_fplr)
+      setElectricInputToCoolingOutputRatioFunctionOfPLR(cool_plf_fplr)
     else
-      OpenStudio::logFree(OpenStudio::Warn, "openstudio.standards.ChillerElectricEIR", "For #{self.name}, cannot find cool_plf_fplr curve, will not be set.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.ChillerElectricEIR', "For #{self.name}, cannot find cool_plf_fplr curve, will not be set.")
       successfully_set_all_properties = false
     end
 
@@ -227,32 +217,30 @@ class OpenStudio::Model::ChillerElectricEIR
     if chlr_props['minimum_full_load_efficiency']
       kw_per_ton = chlr_props['minimum_full_load_efficiency']
       cop = kw_per_ton_to_cop(kw_per_ton)
-      self.setReferenceCOP(cop)
+      setReferenceCOP(cop)
     else
-      OpenStudio::logFree(OpenStudio::Warn, "openstudio.standards.ChillerElectricEIR", "For #{self.name}, cannot find minimum full load efficiency, will not be set.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.ChillerElectricEIR', "For #{self.name}, cannot find minimum full load efficiency, will not be set.")
       successfully_set_all_properties = false
     end
 
     # Set cooling tower properties for NECB 2011 now that the new COP of the chiller is set
     if template == 'NECB 2011'
-      if(self.name.to_s.include? 'Primary Chiller')
+      if self.name.to_s.include? 'Primary Chiller'
         # Single speed tower model assumes 25% extra for compressor power
-        tower_cap = capacity_w*(1.0+1.0/self.referenceCOP)
-        if((tower_cap/1000.0) < 1750)
+        tower_cap = capacity_w * (1.0 + 1.0 / referenceCOP)
+        if (tower_cap / 1000.0) < 1750
           clg_tower_objs[0].setNumberofCells(1)
         else
-          clg_tower_objs[0].setNumberofCells((tower_cap/(1000*1750)+0.5).round)
+          clg_tower_objs[0].setNumberofCells((tower_cap / (1000 * 1750) + 0.5).round)
         end
-        clg_tower_objs[0].setFanPoweratDesignAirFlowRate(0.015*tower_cap)
+        clg_tower_objs[0].setFanPoweratDesignAirFlowRate(0.015 * tower_cap)
       end
     end
 
     # Append the name with size and kw/ton
-    self.setName("#{name} #{capacity_tons.round}tons #{kw_per_ton.round(1)}kW/ton")
-    OpenStudio::logFree(OpenStudio::Info, 'openstudio.model.ChillerElectricEIR', "For #{template}: #{self.name}: #{cooling_type} #{condenser_type} #{compressor_type} Capacity = #{capacity_tons.round}tons; COP = #{cop.round(1)} (#{kw_per_ton.round(1)}kW/ton)")
+    setName("#{name} #{capacity_tons.round}tons #{kw_per_ton.round(1)}kW/ton")
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.ChillerElectricEIR', "For #{template}: #{self.name}: #{cooling_type} #{condenser_type} #{compressor_type} Capacity = #{capacity_tons.round}tons; COP = #{cop.round(1)} (#{kw_per_ton.round(1)}kW/ton)")
 
     return successfully_set_all_properties
-
   end
-
 end

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

@@ -1,16 +1,14 @@
 
 # Reopen the OpenStudio class to add methods to apply standards to this object
 class OpenStudio::Model::CoilCoolingDXMultiSpeed
-
   # Applies the standard efficiency ratings and typical performance curves to this object.
-  # 
+  #
   # @param template [String] valid choices: 'DOE Ref Pre-1980', 'DOE Ref 1980-2004', '90.1-2004', '90.1-2007', '90.1-2010', '90.1-2013'
   # @param standards [Hash] the OpenStudio_Standards spreadsheet in hash format
-  # @return [Bool] true if successful, false if not 
-  def setStandardEfficiencyAndCurves(template, standards, sql_db_vars_map)
-
+  # @return [Bool] true if successful, false if not
+  def apply_efficiency_and_curves(template, standards, sql_db_vars_map)
     successfully_set_all_properties = true
-  
+
     unitary_acs = standards['unitary_acs']
     heat_pumps = standards['heat_pumps']
 
@@ -18,40 +16,40 @@ class OpenStudio::Model::CoilCoolingDXMultiSpeed
     # in the hvac standards data set.
     search_criteria = {}
     search_criteria['template'] = template
-    cooling_type = self.condenserType
+    cooling_type = condenserType
     search_criteria['cooling_type'] = cooling_type
 
-    # TODO Standards - add split system vs single package to model
+    # TODO: Standards - add split system vs single package to model
     # For now, assume single package as default
     subcategory = 'Single Package'
-    
+
     # Determine the heating type if unitary or zone hvac
     heat_pump = false
     heating_type = nil
     containing_comp = nil
-    if self.airLoopHVAC.empty?
-      if self.containingHVACComponent.is_initialized
+    if airLoopHVAC.empty?
+      if containingHVACComponent.is_initialized
         containing_comp = containingHVACComponent.get
         if containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed.is_initialized
           htg_coil = containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed.get.heatingCoil
-          if(htg_coil.to_CoilHeatingDXMultiSpeed.is_initialized) 
+          if htg_coil.to_CoilHeatingDXMultiSpeed.is_initialized
             heat_pump = true
             heating_type = 'Electric Resistance or None'
-          elsif(htg_coil.to_CoilHeatingGasMultiStage.is_initialized)
+          elsif htg_coil.to_CoilHeatingGasMultiStage.is_initialized
             heating_type = 'All Other'
-          end            
-        end # TODO Add other unitary systems
-      elsif self.containingZoneHVACComponent.is_initialized
+          end
+        end # TODO: Add other unitary systems
+      elsif containingZoneHVACComponent.is_initialized
         containing_comp = containingZoneHVACComponent.get
         if containing_comp.to_ZoneHVACPackagedTerminalAirConditioner.is_initialized
           subcategory = 'PTAC'
           htg_coil = containing_comp.to_ZoneHVACPackagedTerminalAirConditioner.get.heatingCoil
           if htg_coil.to_CoilHeatingElectric.is_initialized
-            heating_type = 'Electric Resistance or None'          
+            heating_type = 'Electric Resistance or None'
           elsif htg_coil.to_CoilHeatingWater.is_initialized || htg_coil.to_CoilHeatingGas.is_initialized || htg_col.to_CoilHeatingGasMultiStage
             heating_type = 'All Other'
-          end 
-        end # TODO Add other zone hvac systems
+          end
+        end # TODO: Add other zone hvac systems
       end
     end
 
@@ -61,184 +59,184 @@ class OpenStudio::Model::CoilCoolingDXMultiSpeed
     end
 
     search_criteria['subcategory'] = subcategory
-    
+
     # Get the coil capacity
     capacity_w = nil
-    clg_stages = self.stages
+    clg_stages = stages
     if clg_stages.last.grossRatedTotalCoolingCapacity.is_initialized
       capacity_w = clg_stages.last.grossRatedTotalCoolingCapacity.get
-    elsif self.autosizedSpeed4GrossRatedTotalCoolingCapacity.is_initialized
-      capacity_w = self.autosizedSpeed4GrossRatedTotalCoolingCapacity.get
+    elsif autosizedSpeed4GrossRatedTotalCoolingCapacity.is_initialized
+      capacity_w = autosizedSpeed4GrossRatedTotalCoolingCapacity.get
     else
-      OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{self.name} capacity is not available, cannot apply efficiency standard.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{name} capacity is not available, cannot apply efficiency standard.")
       successfully_set_all_properties = false
       return successfully_set_all_properties
-    end   
+    end
 
     # Volume flow rate
     flow_rate4 = nil
     if clg_stages.last.ratedAirFlowRate.is_initialized
       flow_rate4 = clg_stages.last.ratedAirFlowRate.get
-    elsif self.autosizedSpeed4RatedAirFlowRate.is_initialized
-      flow_rate4 = self.autosizedSpeed4RatedAirFlowRate.get
+    elsif autosizedSpeed4RatedAirFlowRate.is_initialized
+      flow_rate4 = autosizedSpeed4RatedAirFlowRate.get
     end
 
     # Set number of stages for NECB 2011
-    if(template == 'NECB 2011')
+    if template == 'NECB 2011'
       stage_cap = []
-      num_stages = (capacity_w/(66.0*1000.0)+0.5).round
-      num_stages = [num_stages,4].min
-      if(num_stages == 1)
-        stage_cap[0] = capacity_w/2.0
-        stage_cap[1] = 2.0*stage_cap[0]
-        stage_cap[2] = stage_cap[1]+0.1
-        stage_cap[3] = stage_cap[2]+0.1
+      num_stages = (capacity_w / (66.0 * 1000.0) + 0.5).round
+      num_stages = [num_stages, 4].min
+      if num_stages == 1
+        stage_cap[0] = capacity_w / 2.0
+        stage_cap[1] = 2.0 * stage_cap[0]
+        stage_cap[2] = stage_cap[1] + 0.1
+        stage_cap[3] = stage_cap[2] + 0.1
       else
-        stage_cap[0] = 66.0*1000.0
-        stage_cap[1] = 2.0*stage_cap[0]
-        if(num_stages == 2)
-          stage_cap[2] = stage_cap[1]+0.1
-          stage_cap[3] = stage_cap[2]+0.1         
-        elsif(num_stages == 3)
-          stage_cap[2] = 3.0*stage_cap[0]
-          stage_cap[3] = stage_cap[2]+0.1
-        elsif(num_stages == 4)
-          stage_cap[2] = 3.0*stage_cap[0]
-          stage_cap[3] = 4.0*stage_cap[0]
+        stage_cap[0] = 66.0 * 1000.0
+        stage_cap[1] = 2.0 * stage_cap[0]
+        if num_stages == 2
+          stage_cap[2] = stage_cap[1] + 0.1
+          stage_cap[3] = stage_cap[2] + 0.1
+        elsif num_stages == 3
+          stage_cap[2] = 3.0 * stage_cap[0]
+          stage_cap[3] = stage_cap[2] + 0.1
+        elsif num_stages == 4
+          stage_cap[2] = 3.0 * stage_cap[0]
+          stage_cap[3] = 4.0 * stage_cap[0]
         end
       end
       # set capacities, flow rates, and sensible heat ratio for stages
-      for istage in 0..3
+      (0..3).each do |istage|
         clg_stages[istage].setGrossRatedTotalCoolingCapacity(stage_cap[istage])
-        clg_stages[istage].setRatedAirFlowRate(flow_rate4*stage_cap[istage]/capacity_w)
-      end        
+        clg_stages[istage].setRatedAirFlowRate(flow_rate4 * stage_cap[istage] / capacity_w)
+      end
     end
- 
+
     # Convert capacity to Btu/hr
-    capacity_btu_per_hr = OpenStudio.convert(capacity_w, "W", "Btu/hr").get
-    capacity_kbtu_per_hr = OpenStudio.convert(capacity_w, "W", "kBtu/hr").get
-    
+    capacity_btu_per_hr = OpenStudio.convert(capacity_w, 'W', 'Btu/hr').get
+    capacity_kbtu_per_hr = OpenStudio.convert(capacity_w, 'W', 'kBtu/hr').get
+
     # Lookup efficiencies depending on whether it is a unitary AC or a heat pump
     ac_props = nil
-    if heat_pump == true
-      ac_props = self.model.find_object(heat_pumps, search_criteria, capacity_btu_per_hr)
-    else
-      ac_props = self.model.find_object(unitary_acs, search_criteria, capacity_btu_per_hr)
-    end
+    ac_props = if heat_pump == true
+                 model.find_object(heat_pumps, search_criteria, capacity_btu_per_hr, Date.today)
+               else
+                 model.find_object(unitary_acs, search_criteria, capacity_btu_per_hr, Date.today)
+               end
 
     # Check to make sure properties were found
     if ac_props.nil?
-      OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{self.name}, cannot find efficiency info, cannot apply efficiency standard.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{name}, cannot find efficiency info, cannot apply efficiency standard.")
       successfully_set_all_properties = false
       return successfully_set_all_properties
     end
 
     # Make the COOL-CAP-FT curve
-    cool_cap_ft = self.model.add_curve(ac_props["cool_cap_ft"], standards)
+    cool_cap_ft = model.add_curve(ac_props['cool_cap_ft'], standards)
     if cool_cap_ft
-      clg_stages.each do |istage|
-        istage.setTotalCoolingCapacityFunctionofTemperatureCurve(cool_cap_ft)
+      clg_stages.each do |stage|
+        stage.setTotalCoolingCapacityFunctionofTemperatureCurve(cool_cap_ft)
       end
     else
-      OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{self.name}, cannot find cool_cap_ft curve, will not be set.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{name}, cannot find cool_cap_ft curve, will not be set.")
       successfully_set_all_properties = false
     end
 
     # Make the COOL-CAP-FFLOW curve
-    cool_cap_fflow = self.model.add_curve(ac_props["cool_cap_fflow"], standards)
+    cool_cap_fflow = model.add_curve(ac_props['cool_cap_fflow'], standards)
     if cool_cap_fflow
-      clg_stages.each do |istage|
-        istage.setTotalCoolingCapacityFunctionofFlowFractionCurve(cool_cap_fflow)
+      clg_stages.each do |stage|
+        stage.setTotalCoolingCapacityFunctionofFlowFractionCurve(cool_cap_fflow)
       end
     else
-      OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{self.name}, cannot find cool_cap_fflow curve, will not be set.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{name}, cannot find cool_cap_fflow curve, will not be set.")
       successfully_set_all_properties = false
     end
-    
+
     # Make the COOL-EIR-FT curve
-    cool_eir_ft = self.model.add_curve(ac_props["cool_eir_ft"], standards)
+    cool_eir_ft = model.add_curve(ac_props['cool_eir_ft'], standards)
     if cool_eir_ft
-      clg_stages.each do |istage|
-        istage.setEnergyInputRatioFunctionofTemperatureCurve(cool_eir_ft) 
+      clg_stages.each do |stage|
+        stage.setEnergyInputRatioFunctionofTemperatureCurve(cool_eir_ft)
       end
     else
-      OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{self.name}, cannot find cool_eir_ft curve, will not be set.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{name}, cannot find cool_eir_ft curve, will not be set.")
       successfully_set_all_properties = false
     end
 
     # Make the COOL-EIR-FFLOW curve
-    cool_eir_fflow = self.model.add_curve(ac_props["cool_eir_fflow"], standards)
+    cool_eir_fflow = model.add_curve(ac_props['cool_eir_fflow'], standards)
     if cool_eir_fflow
-      clg_stages.each do |istage|
-        istage.setEnergyInputRatioFunctionofFlowFractionCurve(cool_eir_fflow)
+      clg_stages.each do |stage|
+        stage.setEnergyInputRatioFunctionofFlowFractionCurve(cool_eir_fflow)
       end
     else
-      OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{self.name}, cannot find cool_eir_fflow curve, will not be set.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{name}, cannot find cool_eir_fflow curve, will not be set.")
       successfully_set_all_properties = false
     end
-    
+
     # Make the COOL-PLF-FPLR curve
-    cool_plf_fplr = self.model.add_curve(ac_props["cool_plf_fplr"], standards)
+    cool_plf_fplr = model.add_curve(ac_props['cool_plf_fplr'], standards)
     if cool_plf_fplr
-      clg_stages.each do |istage|
-        istage.setPartLoadFractionCorrelationCurve(cool_plf_fplr)
+      clg_stages.each do |stage|
+        stage.setPartLoadFractionCorrelationCurve(cool_plf_fplr)
       end
     else
-      OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{self.name}, cannot find cool_plf_fplr curve, will not be set.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{name}, cannot find cool_plf_fplr curve, will not be set.")
       successfully_set_all_properties = false
-    end 
- 
+    end
+
     # Get the minimum efficiency standards
     cop = nil
-    
+
     if subcategory == 'PTAC'
       ptac_eer_coeff_1 = ac_props['ptac_eer_coefficient_1']
       ptac_eer_coeff_2 = ac_props['ptac_eer_coefficient_2']
       capacity_btu_per_hr = 7000 if capacity_btu_per_hr < 7000
-      capacity_btu_per_hr = 15000 if capacity_btu_per_hr > 15000
+      capacity_btu_per_hr = 15_000 if capacity_btu_per_hr > 15_000
       ptac_eer = ptac_eer_coeff_1 + (ptac_eer_coeff_2 * capacity_btu_per_hr)
       cop = eer_to_cop(ptac_eer)
-      #self.setName("#{self.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{ptac_eer}EER")
-      new_comp_name = "#{self.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{ptac_eer}EER"
-      OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.CoilCoolingDXMultiSpeed',  "For #{template}: #{self.name}: #{cooling_type} #{heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; EER = #{ptac_eer}")      
+      # self.setName("#{self.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{ptac_eer}EER")
+      new_comp_name = "#{name} #{capacity_kbtu_per_hr.round}kBtu/hr #{ptac_eer}EER"
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{template}: #{name}: #{cooling_type} #{heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; EER = #{ptac_eer}")
     end
-    
+
     # If specified as SEER
     unless ac_props['minimum_seasonal_energy_efficiency_ratio'].nil?
       min_seer = ac_props['minimum_seasonal_energy_efficiency_ratio']
       cop = seer_to_cop(min_seer)
-      new_comp_name = "#{self.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_seer}SEER"
-#      self.setName("#{self.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_seer}SEER")
-      OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.CoilCoolingDXMultiSpeed',  "For #{template}: #{self.name}: #{cooling_type} #{heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; SEER = #{min_seer}")
+      new_comp_name = "#{name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_seer}SEER"
+      #      self.setName("#{self.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_seer}SEER")
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{template}: #{name}: #{cooling_type} #{heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; SEER = #{min_seer}")
     end
-    
+
     # If specified as EER
     unless ac_props['minimum_energy_efficiency_ratio'].nil?
       min_eer = ac_props['minimum_energy_efficiency_ratio']
       cop = eer_to_cop(min_eer)
-      new_comp_name = "#{self.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_eer}EER"
-      OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{template}: #{self.name}: #{cooling_type} #{heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; EER = #{min_eer}")
+      new_comp_name = "#{name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_eer}EER"
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{template}: #{name}: #{cooling_type} #{heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; EER = #{min_eer}")
     end
 
     # if specified as SEER (heat pump)
     unless ac_props['minimum_seasonal_efficiency'].nil?
       min_seer = ac_props['minimum_seasonal_efficiency']
       cop = seer_to_cop(min_seer)
-      new_comp_name = "#{self.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_seer}SEER"
-#      self.setName("#{self.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_seer}SEER")
-      OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.CoilCoolingDXMultiSpeed',  "For #{template}: #{self.name}: #{cooling_type} #{heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; SEER = #{min_seer}")
+      new_comp_name = "#{name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_seer}SEER"
+      #      self.setName("#{self.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_seer}SEER")
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{template}: #{name}: #{cooling_type} #{heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; SEER = #{min_seer}")
     end
- 
-      # If specified as EER (heat pump)
+
+    # If specified as EER (heat pump)
     unless ac_props['minimum_full_load_efficiency'].nil?
       min_eer = ac_props['minimum_full_load_efficiency']
       cop = eer_to_cop(min_eer)
-      new_comp_name = "#{self.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_eer}EER"
-      OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{template}: #{self.name}: #{cooling_type} #{heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; EER = #{min_eer}")
-    end  
-      
-    sql_db_vars_map[new_comp_name] = self.name.to_s
-    self.setName(new_comp_name)
+      new_comp_name = "#{name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_eer}EER"
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoilCoolingDXMultiSpeed', "For #{template}: #{name}: #{cooling_type} #{heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; EER = #{min_eer}")
+    end
+
+    sql_db_vars_map[new_comp_name] = name.to_s
+    setName(new_comp_name)
 
     # Set the efficiency values
 
@@ -249,7 +247,5 @@ class OpenStudio::Model::CoilCoolingDXMultiSpeed
     end
 
     return sql_db_vars_map
-
   end
-
 end