openstudio-standards 0.1.4 → 0.1.5

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

@@ -0,0 +1,138 @@
+
+# A variety of cooling tower methods that are the same regardless of type.
+# These methods are available to CoolingTowerSingleSpeed, CoolingTowerTwoSpeed, and CoolingTowerVariableSpeed
+module CoolingTower
+  # Set the cooling tower fan power such that the tower
+  # hits the minimum performance (gpm/hp) specified by the standard.
+  # Note that in this case hp is motor nameplate hp, per 90.1.
+  # This method assumes that the fan brake horsepower is 90%
+  # of the motor nameplate hp.
+  # This method determines the minimum motor efficiency
+  # for the nameplate motor hp and sets the actual
+  # fan power by multiplying the brake horsepower
+  # by the efficiency.  Thus the fan power used as
+  # an input to the simulation divided by the design flow
+  # rate will not (and should not)
+  # exactly equal the minimum tower performance.
+  #
+  # @param template [String] the template base requirements on
+  # @return [Bool] true if successful, false if not
+  def apply_minimum_power_per_flow(template)
+    # Get the design water flow rate
+    design_water_flow_m3_per_s = nil
+    if designWaterFlowRate.is_initialized
+      design_water_flow_m3_per_s = designWaterFlowRate.get
+    elsif autosizedDesignWaterFlowRate.is_initialized
+      design_water_flow_m3_per_s = autosizedDesignWaterFlowRate.get
+    else
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoolingTower', "For #{name} design water flow rate is not available, cannot apply efficiency standard.")
+      return false
+    end
+    design_water_flow_gpm = OpenStudio.convert(design_water_flow_m3_per_s, 'm^3/s', 'gal/min').get
+
+    # Get the table of cooling tower efficiencies
+    heat_rejection = $os_standards['heat_rejection']
+
+    # Define the criteria to find the cooling tower properties
+    # in the hvac standards data set.
+    search_criteria = {}
+    search_criteria['template'] = template
+
+    # By definition cooling towers in E+ are open.
+    # Closed cooling towers are the fluidcooler objects.
+    search_criteria['equipment_type'] = 'Open Cooling Tower'
+
+    # TODO: Standards replace this with a mechanism to store this
+    # data in the cooling tower object itself.
+    # For now, retrieve the fan type from the name
+    name = self.name.get
+    fan_type = nil
+    if name.include?('Centrifugal')
+      fan_type = 'Centrifugal'
+    elsif name.include?('Propeller or Axial')
+      fan_type = 'Propeller or Axial'
+    end
+    unless fan_type.nil?
+      search_criteria['fan_type'] = fan_type
+    end
+
+    # 90.1 6.5.5.3 Limit on Centrifugal Fan
+    # Open Circuit Cooling Towers.
+    case template
+    when '90.1-2010', '90.1-2013'
+      if fan_type == 'Centrifugal'
+        gpm_limit = 1100
+        if design_water_flow_gpm >= gpm_limit
+          fan_type = 'Propeller or Axial'
+          search_criteria['fan_type'] = fan_type
+          OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoolingTower', "For #{self.name}, the design flow rate of #{design_water_flow_gpm.round} gpm is higher than the limit of #{gpm_limit.round} gpm for open centrifugal towers per 6.5.5.3.  This tower must meet the minimum performance of #{fan_type} instead.")
+        end
+      end
+    end
+
+    # Get the cooling tower properties
+    ct_props = model.find_object(heat_rejection, search_criteria)
+    unless ct_props
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CoolingTower', "For #{self.name}, cannot find heat rejection properties, cannot apply standard efficiencies or curves.")
+      return false
+    end
+
+    # Get cooling tower efficiency
+    min_gpm_per_hp = ct_props['minimum_performance']
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoolingTower', "For #{self.name}, design water flow = #{design_water_flow_gpm.round} gpm, minimum performance = #{min_gpm_per_hp} gpm/hp (nameplate).")
+
+    # Calculate the allowed fan brake horsepower
+    # per method used in PNNL prototype buildings.
+    # Assumes that the fan brake horsepower is 90%
+    # of the fan nameplate rated motor power.
+    fan_motor_nameplate_hp = design_water_flow_gpm / min_gpm_per_hp
+    fan_bhp = 0.9 * fan_motor_nameplate_hp
+
+    # Lookup the minimum motor efficiency
+    fan_motor_eff = 0.85
+    motors = $os_standards['motors']
+
+    # Assuming all fan motors are 4-pole Enclosed
+    search_criteria = {
+      'template' => template,
+      'number_of_poles' => 4.0,
+      'type' => 'Enclosed'
+    }
+
+    motor_properties = model.find_object(motors, search_criteria, fan_motor_nameplate_hp)
+    if motor_properties.nil?
+      OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.CoolingTower', "For #{self.name}, could not find motor properties using search criteria: #{search_criteria}, motor_hp = #{motor_hp} hp.")
+      return false
+    end
+
+    fan_motor_eff = motor_properties['nominal_full_load_efficiency']
+    nominal_hp = motor_properties['maximum_capacity'].to_f.round(1)
+    # Round to nearest whole HP for niceness
+    if nominal_hp >= 2
+      nominal_hp = nominal_hp.round
+    end
+
+    # Calculate the fan motor power
+    fan_motor_actual_power_hp = fan_bhp / fan_motor_eff
+    # Convert to W
+    fan_motor_actual_power_w = fan_motor_actual_power_hp * 745.7 # 745.7 W/HP
+
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CoolingTower', "For #{self.name}, allowed fan motor nameplate hp = #{fan_motor_nameplate_hp.round(1)} hp, fan brake horsepower = #{fan_bhp.round(1)}, and fan motor actual power = #{fan_motor_actual_power_hp.round(1)} hp (#{fan_motor_actual_power_w.round} W) at #{fan_motor_eff} motor efficiency.")
+
+    # Append the efficiency to the name
+    setName("#{self.name} #{min_gpm_per_hp.round(1)} gpm/hp")
+
+    # Hard size the design fan power.
+    # Leave the water flow and air flow autosized.
+    if to_CoolingTowerSingleSpeed.is_initialized
+      setFanPoweratDesignAirFlowRate(fan_motor_actual_power_w)
+    elsif to_CoolingTowerTwoSpeed.is_initialized
+      setHighFanSpeedFanPower(fan_motor_actual_power_w)
+      setLowFanSpeedFanPower(0.3 * fan_motor_actual_power_w)
+    elsif to_CoolingTowerVariableSpeed.is_initialized
+      setDesignFanPower(fan_motor_actual_power_w)
+    end
+
+    return true
+  end
+end

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

@@ -0,0 +1,11 @@
+
+# Reopen the OpenStudio class to add methods to apply standards to this object
+class OpenStudio::Model::CoolingTowerSingleSpeed
+  include CoolingTower
+
+  def apply_efficiency_and_curves(template)
+    apply_minimum_power_per_flow(template)
+
+    return true
+  end
+end

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

@@ -0,0 +1,11 @@
+
+# Reopen the OpenStudio class to add methods to apply standards to this object
+class OpenStudio::Model::CoolingTowerTwoSpeed
+  include CoolingTower
+
+  def apply_efficiency_and_curves(template)
+    apply_minimum_power_per_flow(template)
+
+    return true
+  end
+end

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

@@ -0,0 +1,16 @@
+
+# Reopen the OpenStudio class to add methods to apply standards to this object
+class OpenStudio::Model::CoolingTowerVariableSpeed
+  include CoolingTower
+
+  def apply_efficiency_and_curves(template)
+    apply_minimum_power_per_flow(template)
+
+    # 90.1-2013 6.5.2.2 Multicell heat rejection with VSD
+    if template == '90.1-2013'
+      setCellControl('MaximalCell')
+    end
+
+    return true
+  end
+end

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

@@ -2,260 +2,185 @@
 # A variety of fan calculation methods that are the same regardless of fan type.
 # These methods are available to FanConstantVolume, FanOnOff, FanVariableVolume, and FanZoneExhaust
 module Fan
+  def apply_standard_minimum_motor_efficiency(template, allowed_bhp)
+    # Find the motor efficiency
+    motor_eff, nominal_hp = standard_minimum_motor_efficiency_and_size(template, allowed_bhp)
 
-  # Sets the fan motor efficiency based on the standard.
-  # Assumes 65% fan efficiency and 4-pole, enclosed motor.
-  #
-  # @return [Bool] true if successful, false if not
-  def setStandardEfficiency(template)
-    
-    # Get the max flow rate from the fan.
-    maximum_flow_rate_m3_per_s = nil
-    if self.maximumFlowRate.is_initialized
-      maximum_flow_rate_m3_per_s = self.maximumFlowRate.get
-    elsif self.autosizedMaximumFlowRate.is_initialized
-      maximum_flow_rate_m3_per_s = self.autosizedMaximumFlowRate.get
-    else
-      OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.Fan', "For #{self.name} max flow rate is not hard sized, cannot apply efficiency standard.")
-      return false
-    end
+    # Change the motor efficiency
+    # but preserve the existing fan impeller
+    # efficiency.
+    change_motor_efficiency(motor_eff)
 
-    # Convert max flow rate to cfm
-    maximum_flow_rate_cfm = OpenStudio.convert(maximum_flow_rate_m3_per_s, 'm^3/s', 'cfm').get
-    
-    # Get the pressure rise from the fan
-    pressure_rise_pa = self.pressureRise
-    pressure_rise_in_h2o = OpenStudio.convert(pressure_rise_pa, 'Pa','inH_{2}O').get
-
-    # Get the default impeller efficiency
-    fan_impeller_eff = self.baselineImpellerEfficiency(template)
-
-    # Calculate the Brake Horsepower
-    brake_hp = (pressure_rise_in_h2o * maximum_flow_rate_cfm)/(fan_impeller_eff * 6356) 
-    allowed_hp = brake_hp * 1.1 # Per PNNL document #TODO add reference
-    if allowed_hp > 0.1
-      allowed_hp = allowed_hp.round(2)+0.0001
-    elsif allowed_hp < 0.01
-      allowed_hp = 0.01
-    end
+    # Calculate the total motor HP
+    motor_hp = motor_horsepower
 
-    # Minimum motor size for efficiency lookup
-    # is 1 HP unless the motor serves an exhaust fan,
-    # a powered VAV terminal, or a fan coil unit.
-    unless self.is_small_fan
-      if allowed_hp < 1.0
-        allowed_hp = 1.01
-      end
-    end
-    
-    # Find the motor efficiency
-    motor_eff, nominal_hp = standard_minimum_motor_efficiency_and_size(template, allowed_hp)
-
-    # Calculate the total fan efficiency
-    total_fan_eff = fan_impeller_eff * motor_eff
-    
-    # Set the total fan efficiency and the motor efficiency
-    if self.to_FanZoneExhaust.is_initialized
-      self.setFanEfficiency(total_fan_eff)
+    # Exception for small fans, including
+    # zone exhaust, fan coil, and fan powered terminals.
+    # In this case, 0.5 HP is used for the lookup.
+    if small_fan?
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Fan', "For #{name}: motor eff = #{(motor_eff * 100).round(2)}%; assumed to represent several < 1 HP motors.")
     else
-      self.setFanEfficiency(total_fan_eff)
-      self.setMotorEfficiency(motor_eff)
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Fan', "For #{name}: motor nameplate = #{nominal_hp}HP, motor eff = #{(motor_eff * 100).round(2)}%.")
     end
-    
 
-    if(template == 'NECB 2011')
-      fan_power_kw = maximum_flow_rate_m3_per_s*pressure_rise_pa/(fan_impeller_eff*1000.0)
-    end
-
-    OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.Fan', "For #{self.name}: allowed_hp = #{allowed_hp.round(2)}HP; motor eff = #{(motor_eff*100).round(2)}%; total fan eff = #{(total_fan_eff*100).round}% based on #{maximum_flow_rate_cfm.round} cfm.")
-    
     return true
-    
   end
 
-  def set_standard_minimum_motor_efficiency(template, allowed_bhp)
-    
-    # Find the motor efficiency
-    motor_eff, nominal_hp = standard_minimum_motor_efficiency_and_size(template, allowed_bhp)
-
-    # Change the motor efficiency
-    # but preserve the existing fan impeller
-    # efficiency.
-    self.changeMotorEfficiency(motor_eff)
-    
-    # Calculate the total motor HP
-    motor_hp = self.motorHorsepower
-    
-    OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.Fan', "For #{self.name}: motor nameplate = #{nominal_hp}HP, motor eff = #{(motor_eff*100).round(2)}%.")
-    
-    return true    
-  
-  end
-  
   # Adjust the fan pressure rise to hit the target fan power (W).
   # Keep the fan impeller and motor efficiencies static.
   #
   # @param target_fan_power [Double] the target fan power in W
   # @return [Bool] true if successful, false if not
   def adjust_pressure_rise_to_meet_fan_power(target_fan_power)
-  
     # Get design supply air flow rate (whether autosized or hard-sized)
     dsn_air_flow_m3_per_s = 0
-    if self.autosizedMaximumFlowRate.is_initialized
-      dsn_air_flow_m3_per_s = self.autosizedMaximumFlowRate.get
-    else
-      dsn_air_flow_m3_per_s = self.maximumFlowRate.get
-    end  
-  
+    dsn_air_flow_m3_per_s = if autosizedMaximumFlowRate.is_initialized
+                              autosizedMaximumFlowRate.get
+                            else
+                              maximumFlowRate.get
+                            end
+
     # Get the current fan power
-    current_fan_power_w = self.fanPower
+    current_fan_power_w = fan_power
 
     # Get the current pressure rise (Pa)
-    pressure_rise_pa = self.pressureRise
-    
+    pressure_rise_pa = pressureRise
+
     # Get the total fan efficiency
-    fan_total_eff = self.fanEfficiency
+    fan_total_eff = fanEfficiency
 
     # Calculate the new fan pressure rise (Pa)
     new_pressure_rise_pa = target_fan_power * fan_total_eff / dsn_air_flow_m3_per_s
-    new_pressure_rise_in_h2o = OpenStudio.convert(new_pressure_rise_pa, 'Pa','inH_{2}O').get
-    
+    new_pressure_rise_in_h2o = OpenStudio.convert(new_pressure_rise_pa, 'Pa', 'inH_{2}O').get
+
     # Set the new pressure rise
-    self.setPressureRise(new_pressure_rise_pa)
-    
+    setPressureRise(new_pressure_rise_pa)
+
     # Calculate the new power
-    new_power_w = self.fanPower
-    
-    OpenStudio::logFree(OpenStudio::Info, "openstudio.standards.Fan", "For #{self.name}: pressure rise = #{new_pressure_rise_in_h2o.round(1)} in w.c., power = #{new_power_w.round} W // #{self.motorHorsepower.round(2)}HP.")
-    
+    new_power_w = fan_power
+
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Fan', "For #{name}: pressure rise = #{new_pressure_rise_in_h2o.round(1)} in w.c., power = #{motor_horsepower.round(2)}HP.")
+
     return true
-  
   end
-  
-  # Determines the fan power (W) based on 
-  # flow rate, pressure rise, and total fan efficiency(impeller eff * motor eff) 
-  # 
+
+  # Determines the fan power (W) based on
+  # flow rate, pressure rise, and total fan efficiency(impeller eff * motor eff)
+  #
   # @return [Double] fan power
   #   @units Watts (W)
-  def fanPower()
-    
+  def fan_power
     # Get design supply air flow rate (whether autosized or hard-sized)
     dsn_air_flow_m3_per_s = 0
-    if self.autosizedMaximumFlowRate.is_initialized
-      dsn_air_flow_m3_per_s = self.autosizedMaximumFlowRate.get
-    else
-      dsn_air_flow_m3_per_s = self.maximumFlowRate.get
-    end
-  
+    dsn_air_flow_m3_per_s = if to_FanZoneExhaust.empty?
+                              if autosizedMaximumFlowRate.is_initialized
+                                autosizedMaximumFlowRate.get
+                              else
+                                maximumFlowRate.get
+                              end
+                            else
+                              maximumFlowRate.get
+                            end
+
     # Get the total fan efficiency,
     # which in E+ includes both motor and
     # impeller efficiency.
-    fan_total_eff = self.fanEfficiency
-    
+    fan_total_eff = fanEfficiency
+
     # Get the pressure rise (Pa)
-    pressure_rise_pa = self.pressureRise
-    
+    pressure_rise_pa = pressureRise
+
     # Calculate the fan power (W)
     fan_power_w = pressure_rise_pa * dsn_air_flow_m3_per_s / fan_total_eff
-    
+
     return fan_power_w
-  
   end
 
   # Determines the brake horsepower of the fan
   # based on fan power and fan motor efficiency.
-  # 
+  #
   # @return [Double] brake horsepower
-  #   @units horsepower (hp)  
-  def brakeHorsepower()
-  
+  #   @units horsepower (hp)
+  def brake_horsepower
     # Get the fan motor efficiency
     existing_motor_eff = 0.7
-    if self.to_FanZoneExhaust.empty?
-      existing_motor_eff = self.motorEfficiency
+    if to_FanZoneExhaust.empty?
+      existing_motor_eff = motorEfficiency
     end
-  
+
     # Get the fan power (W)
-    fan_power_w = self.fanPower
-    
+    fan_power_w = fan_power
+
     # Calculate the brake horsepower (bhp)
     fan_bhp = fan_power_w * existing_motor_eff / 746
-    
-    return fan_bhp
 
+    return fan_bhp
   end
 
   # Determines the horsepower of the fan
   # motor, including motor efficiency and
   # fan impeller efficiency.
-  # 
+  #
   # @return [Double] horsepower
-  def motorHorsepower()
-  
+  def motor_horsepower
     # Get the fan power
-    fan_power_w = self.fanPower
-    
+    fan_power_w = fan_power
+
     # Convert to HP
     fan_hp = fan_power_w / 745.7 # 745.7 W/HP
-    
-    return fan_hp
 
-  end  
+    return fan_hp
+  end
 
   # Changes the fan motor efficiency and also the fan total efficiency
   # at the same time, preserving the impeller efficiency.
   #
   # @param motor_eff [Double] motor efficiency (0.0 to 1.0)
-  def changeMotorEfficiency(motor_eff)
-    
+  def change_motor_efficiency(motor_eff)
     # Calculate the existing impeller efficiency
     existing_motor_eff = 0.7
-    if self.to_FanZoneExhaust.empty?
-      existing_motor_eff = self.motorEfficiency
+    if to_FanZoneExhaust.empty?
+      existing_motor_eff = motorEfficiency
     end
-    existing_total_eff = self.fanEfficiency
+    existing_total_eff = fanEfficiency
     existing_impeller_eff = existing_total_eff / existing_motor_eff
-    
+
     # Calculate the new total efficiency
     new_total_eff = motor_eff * existing_impeller_eff
-    
+
     # Set the revised motor and total fan efficiencies
-    if self.to_FanZoneExhaust.is_initialized
-      self.setFanEfficiency(new_total_eff)
+    if to_FanZoneExhaust.is_initialized
+      setFanEfficiency(new_total_eff)
     else
-      self.setFanEfficiency(new_total_eff)
-      self.setMotorEfficiency(motor_eff)
+      setFanEfficiency(new_total_eff)
+      setMotorEfficiency(motor_eff)
     end
-  
   end
 
   # Changes the fan impeller efficiency and also the fan total efficiency
   # at the same time, preserving the motor efficiency.
   #
-  # @param impeller_eff [Double] impeller efficiency (0.0 to 1.0)  
-  def changeImpellerEfficiency(impeller_eff)
-    
+  # @param impeller_eff [Double] impeller efficiency (0.0 to 1.0)
+  def change_impeller_efficiency(impeller_eff)
     # Get the existing motor efficiency
     existing_motor_eff = 0.7
-    if self.to_FanZoneExhaust.empty?
-      existing_motor_eff = self.motorEfficiency
+    if to_FanZoneExhaust.empty?
+      existing_motor_eff = motorEfficiency
     end
 
     # Calculate the new total efficiency
     new_total_eff = existing_motor_eff * impeller_eff
-    
+
     # Set the revised motor and total fan efficiencies
-    self.setFanEfficiency(new_total_eff)
-  
+    setFanEfficiency(new_total_eff)
   end
-  
+
   # Determines the baseline fan impeller efficiency
   # based on the specified fan type.
   #
   # @return [Double] impeller efficiency (0.0 to 1.0)
   # @todo Add fan type to data model and modify this method
-  def baselineImpellerEfficiency(template)
-  
+  def baseline_impeller_efficiency(template)
     # Assume that the fan efficiency is 65% for normal fans
     # and 55% for small fans (like exhaust fans).
     # TODO add fan type to fan data model
@@ -264,79 +189,108 @@ module Fan
     # fan impeller for the baseline system?
     # TODO check COMNET and T24 ACM and PNNL 90.1 doc
     fan_impeller_eff = 0.65
-  
-    if self.is_small_fan
+
+    if small_fan?
       fan_impeller_eff = 0.55
     end
 
     return fan_impeller_eff
-  
   end
-  
-  # Determines the minimum fan motor efficiency 
+
+  # Determines the minimum fan motor efficiency and nominal size
   # for a given motor bhp.  This should be the total brake horsepower with
-  # any desired safety factor already included.  This method
+  # any desired safety factor already included.  This method picks
+  # the next nominal motor catgory larger than the required brake
+  # horsepower, and the efficiency is based on that size.  For example,
+  # if the bhp = 6.3, the nominal size will be 7.5HP and the efficiency
+  # for 90.1-2010 will be 91.7% from Table 10.8B.  This method assumes
+  # 4-pole, 1800rpm totally-enclosed fan-cooled motors.
   #
   # @param motor_bhp [Double] motor brake horsepower (hp)
-
-  # @return [Double] minimum motor efficiency (0.0 to 1.0), nominal HP
+  # @return [Array<Double>] minimum motor efficiency (0.0 to 1.0), nominal horsepower
   def standard_minimum_motor_efficiency_and_size(template, motor_bhp)
-  
     fan_motor_eff = 0.85
     nominal_hp = motor_bhp
-  
+
+    # Don't attempt to look up motor efficiency
+    # for zero-hp fans, which may occur when there is no
+    # airflow required for a particular system, typically
+    # heated-only spaces with high internal gains
+    # and no OA requirements such as elevator shafts.
+    return [fan_motor_eff, 0] if motor_bhp == 0.0
+
     # Lookup the minimum motor efficiency
-    motors = $os_standards["motors"]
-    
+    motors = $os_standards['motors']
+
     # Assuming all fan motors are 4-pole ODP
     template_mod = template.dup
-    if(template == 'NECB 2011') 
-      if(self.class.name == 'OpenStudio::Model::FanConstantVolume')
-        template_mod = template_mod+'-CONSTANT'
-      elsif(self.class.name == 'OpenStudio::Model::FanVariableVolume')
-        template_mod = template_mod+'-VARIABLE'
-        fan_power_kw = 0.909*0.7457*motor_bhp
-        if(fan_power_kw >= 25.0)
-          power_vs_flow_curve_name = 'VarVolFan-FCInletVanes-NECB2011-FPLR'
-        elsif(fan_power_kw >= 7.5 && fan_power_kw < 25)
-          power_vs_flow_curve_name = 'VarVolFan-AFBIInletVanes-NECB2011-FPLR'
-        else
-          power_vs_flow_curve_name = 'VarVolFan-AFBIFanCurve-NECB2011-FPLR'
-        end
-        power_vs_flow_curve = self.model.add_curve(power_vs_flow_curve_name, standards)
-        self.setFanPowerMinimumFlowRateInputMethod("Fraction")
-        self.setFanPowerCoefficient5(0.0)
-        self.setFanPowerMinimumFlowFraction(power_vs_flow_curve.minimumValueofx)
-        self.setFanPowerCoefficient1(power_vs_flow_curve.coefficient1Constant)
-        self.setFanPowerCoefficient2(power_vs_flow_curve.coefficient2x)
-        self.setFanPowerCoefficient3(power_vs_flow_curve.coefficient3xPOW2)
-        self.setFanPowerCoefficient4(power_vs_flow_curve.coefficient4xPOW3)
+    if template == 'NECB 2011'
+      if self.class.name == 'OpenStudio::Model::FanConstantVolume'
+        template_mod += '-CONSTANT'
+      elsif self.class.name == 'OpenStudio::Model::FanVariableVolume'
+        template_mod += '-VARIABLE'
+        # 0.909 corrects for 10% over sizing implemented upstream
+        # 0.7457 is to convert from bhp to kW
+        fan_power_kw = 0.909 * 0.7457 * motor_bhp
+        power_vs_flow_curve_name = if fan_power_kw >= 25.0
+                                     'VarVolFan-FCInletVanes-NECB2011-FPLR'
+                                   elsif fan_power_kw >= 7.5 && fan_power_kw < 25
+                                     'VarVolFan-AFBIInletVanes-NECB2011-FPLR'
+                                   else
+                                     'VarVolFan-AFBIFanCurve-NECB2011-FPLR'
+                                   end
+        power_vs_flow_curve = model.add_curve(power_vs_flow_curve_name)
+        setFanPowerMinimumFlowRateInputMethod('Fraction')
+        setFanPowerCoefficient5(0.0)
+        setFanPowerMinimumFlowFraction(power_vs_flow_curve.minimumValueofx)
+        setFanPowerCoefficient1(power_vs_flow_curve.coefficient1Constant)
+        setFanPowerCoefficient2(power_vs_flow_curve.coefficient2x)
+        setFanPowerCoefficient3(power_vs_flow_curve.coefficient3xPOW2)
+        setFanPowerCoefficient4(power_vs_flow_curve.coefficient4xPOW3)
       end
     end
- 
+
     search_criteria = {
-      "template" => template_mod,
-      "number_of_poles" => 4.0,
-      "type" => "Enclosed",
+      'template' => template_mod,
+      'number_of_poles' => 4.0,
+      'type' => 'Enclosed'
     }
- 
-    motor_properties = self.model.find_object(motors, search_criteria, motor_bhp)
+
+    # Exception for small fans, including
+    # zone exhaust, fan coil, and fan powered terminals.
+    # In this case, use the 0.5 HP for the lookup.
+    if small_fan?
+      nominal_hp = 0.5
+    else
+      motor_properties = model.find_object(motors, search_criteria, motor_bhp)
+      if motor_properties.nil?
+        OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Fan', "For #{name}, could not find motor properties using search criteria: #{search_criteria}, motor_bhp = #{motor_bhp} hp.")
+        return [fan_motor_eff, nominal_hp]
+      end
+
+      nominal_hp = motor_properties['maximum_capacity'].to_f.round(1)
+      # If the biggest fan motor size is hit, use the highest category efficiency
+      if nominal_hp == 9999.0
+        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.Fan', "For #{name}, there is no greater nominal HP.  Use the efficiency of the largest motor category.")
+        nominal_hp = motor_bhp
+      end
+
+      # Round to nearest whole HP for niceness
+      if nominal_hp >= 2
+        nominal_hp = nominal_hp.round
+      end
+    end
+
+    # Get the efficiency based on the nominal horsepower
+    # Add 0.01 hp to avoid search errors.
+    motor_properties = model.find_object(motors, search_criteria, nominal_hp + 0.01)
     if motor_properties.nil?
-      OpenStudio::logFree(OpenStudio::Error, "openstudio.standards.Fan", "For #{self.name}, could not find motor properties using search criteria: #{search_criteria}, motor_bhp = #{motor_bhp} hp.")
+      OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Fan', "For #{name}, could not find nominal motor properties using search criteria: #{search_criteria}, motor_hp = #{nominal_hp} hp.")
       return [fan_motor_eff, nominal_hp]
     end
- 
-    fan_motor_eff = motor_properties["nominal_full_load_efficiency"]  
-    nominal_hp = motor_properties["maximum_capacity"].to_f.round(1)
-    # Round to nearest whole HP for niceness
-    if nominal_hp >= 2
-      nominal_hp = nominal_hp.round
-    end
-
-    # TODO Add exception for small 
+    fan_motor_eff = motor_properties['nominal_full_load_efficiency']
 
     return [fan_motor_eff, nominal_hp]
-  
   end
 
   # Zone exhaust fans, fan coil unit fans,
@@ -344,29 +298,33 @@ module Fan
   # as small fans and get different impeller efficiencies
   # and motor efficiencies than other fans
   # @return [Bool] returns true if it is a small fan, false if not
-  def is_small_fan()
-  
+  def small_fan?
     is_small = false
 
     # Exhaust fan
-    if self.to_FanZoneExhaust.is_initialized
+    if to_FanZoneExhaust.is_initialized
       is_small = true
-    # Fan coil unit
-    elsif self.containingZoneHVACComponent.is_initialized
-      zone_hvac = self.containingZoneHVACComponent.get
+    # Fan coil unit, unit heater, PTAC, PTHP
+    elsif containingZoneHVACComponent.is_initialized
+      zone_hvac = containingZoneHVACComponent.get
       if zone_hvac.to_ZoneHVACFourPipeFanCoil.is_initialized
         is_small = true
+      elsif zone_hvac.to_ZoneHVACUnitHeater.is_initialized
+        is_small = true
+      elsif zone_hvac.to_ZoneHVACPackagedTerminalAirConditioner.is_initialized
+        is_small = true
+      elsif zone_hvac.to_ZoneHVACPackagedTerminalHeatPump.is_initialized
+        is_small = true
       end
     # Powered VAV terminal
-    elsif self.containingHVACComponent.is_initialized
-      zone_hvac = self.containingHVACComponent.get
+    elsif containingHVACComponent.is_initialized
+      zone_hvac = containingHVACComponent.get
       if zone_hvac.to_AirTerminalSingleDuctParallelPIUReheat.is_initialized || zone_hvac.to_AirTerminalSingleDuctSeriesPIUReheat.is_initialized
         is_small = true
       end
-    end  
-  
+    end
+
     return is_small
-  
   end
 
   # Find the actual rated fan power per flow (W/CFM)
@@ -374,33 +332,29 @@ module Fan
   #
   # @return [Double] rated power consumption per flow
   #   @units Watts per CFM (W*min/ft^3)
-  def rated_w_per_cfm()
-
+  def rated_w_per_cfm
     # Get design power (whether autosized or hard-sized)
-    rated_power_w = self.model.getAutosizedValueFromEquipmentSummary(self, 'Fans', 'Rated Electric Power', 'W')
+    rated_power_w = model.getAutosizedValueFromEquipmentSummary(self, 'Fans', 'Rated Electric Power', 'W')
     if rated_power_w.is_initialized
       rated_power_w = rated_power_w.get
     else
-      rated_power_w = self.fanPower
-      OpenStudio::logFree(OpenStudio::Warn, "openstudio.standards.Pump", "For #{self.name}, could not find rated fan power from Equipment Summary. Will calculate it based on current pressure rise and total fan efficiency")
+      rated_power_w = fan_power
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.Pump', "For #{name}, could not find rated fan power from Equipment Summary. Will calculate it based on current pressure rise and total fan efficiency")
     end
 
-    if self.autosizedMaximumFlowRate.is_initialized
-      max_m3_per_s = self.autosizedMaximumFlowRate.get
-    elsif self.maximumFlowRate.is_initialized
-      max_m3_per_s = self.ratedFlowRate.get
+    if autosizedMaximumFlowRate.is_initialized
+      max_m3_per_s = autosizedMaximumFlowRate.get
+    elsif maximumFlowRate.is_initialized
+      max_m3_per_s = ratedFlowRate.get
     else
-      OpenStudio::logFree(OpenStudio::Error, "openstudio.standards.Pump", "For #{self.name}, could not find fan Maximum Flow Rate, cannot determine w per cfm correctly.")
+      OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Pump', "For #{name}, could not find fan Maximum Flow Rate, cannot determine w per cfm correctly.")
       return false
     end
 
     rated_w_per_m3s = rated_power_w / max_m3_per_s
 
-    rated_w_per_gpm = OpenStudio::convert(rated_w_per_m3s, 'W*s/m^3', 'W*min/ft^3').get
+    rated_w_per_gpm = OpenStudio.convert(rated_w_per_m3s, 'W*s/m^3', 'W*min/ft^3').get
 
     return rated_w_per_gpm
-
-
   end
-  
 end