Module: Pump

Included in:
Standard
Defined in:
lib/openstudio-standards/standards/Standards.Pump.rb

Overview

A variety of pump calculation methods that are the same regardless of pump type. These methods are available to PumpConstantSpeed, PumpVariableSpeed

Pump collapse

Instance Method Details

#pump_apply_prm_pressure_rise_and_motor_efficiency(pump, target_w_per_gpm) ⇒ Boolean

Set the pressure rise that corresponds to the target power per flow number, given the standard pump efficiency and the default EnergyPlus pump impeller efficiency of 0.78.

Parameters:

  • pump (OpenStudio::Model::StraightComponent) —

    pump object, allowable types: PumpConstantSpeed, PumpVariableSpeed

  • target_w_per_gpm (Double) —

    the target power per flow, in W/gpm

Returns:

  • (Boolean) —

    returns true if successful, false if not

Author:

  • jmarrec



14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
# File 'lib/openstudio-standards/standards/Standards.Pump.rb', line 14

def pump_apply_prm_pressure_rise_and_motor_efficiency(pump, target_w_per_gpm)
  # Eplus assumes an impeller efficiency of 0.78 to determine the total efficiency
  # http://bigladdersoftware.com/epx/docs/8-4/engineering-reference/component-sizing.html#pump-sizing
  # Rated_Power_Use = Rated_Volume_Flow_Rate * Rated_Pump_Head / Total_Efficiency
  # Rated_Power_Use / Rated_Volume_Flow_Rate =  Rated_Pump_Head / Total_Efficiency
  # Total_Efficiency = Motor_Efficiency * Impeler_Efficiency
  impeller_efficiency = 0.78

  # Get flow rate (whether autosized or hard-sized)
  flow_m3_per_s = 0
  flow_m3_per_s = if pump.to_PumpVariableSpeed.is_initialized || pump.to_PumpConstantSpeed.is_initialized
                    if pump.ratedFlowRate.is_initialized
                      pump.ratedFlowRate.get
                    elsif pump.autosizedRatedFlowRate.is_initialized
                      pump.autosizedRatedFlowRate.get
                    end
                  elsif pump.to_HeaderedPumpsVariableSpeed.is_initialized || pump.to_HeaderedPumpsConstantSpeed.is_initialized
                    if pump.totalRatedFlowRate.is_initialized
                      pump.totalRatedFlowRate.get / pump.numberofPumpsinBank
                    elsif pump.autosizedTotalRatedFlowRate.is_initialized
                      pump.autosizedTotalRatedFlowRate.get / pump.numberofPumpsinBank
                    end
                  end

  flow_gpm = OpenStudio.convert(flow_m3_per_s, 'm^3/s', 'gal/min').get

  # Calculate the target total pump motor power consumption
  target_motor_power_cons_w = target_w_per_gpm * flow_gpm
  target_motor_power_cons_hp = target_motor_power_cons_w / 745.7 # 745.7 W/HP

  # Find the motor efficiency using total power consumption
  # Note that this hp is ~5-10% high because it is being looked
  # up based on the motor consumption, which is always actually higher
  # than the brake horsepower.  This will bound the possible motor efficiency
  # values.  If a motor is just above a nominal size, and the next size
  # down has a lower efficiency value, later motor efficiency setting
  # methods can mess up the W/gpm.  All this nonsense avoids that.
  mot_eff_hi_end, nom_hp_hi_end = pump_standard_minimum_motor_efficiency_and_size(pump, target_motor_power_cons_hp)

  # Calculate the actual brake horsepower using this efficiency
  target_motor_bhp = target_motor_power_cons_hp * mot_eff_hi_end

  # Find the motor efficiency using actual bhp
  mot_eff_lo_end, nom_hp_lo_end = pump_standard_minimum_motor_efficiency_and_size(pump, target_motor_bhp)

  # If the efficiency drops you down into a lower band with
  # a lower efficiency value, use that for the motor efficiency.
  motor_efficiency = [mot_eff_lo_end, mot_eff_hi_end].min
  nominal_hp = [nom_hp_lo_end, nom_hp_hi_end].min

  # Calculate the brake horsepower that was assumed
  target_brake_power_hp = target_motor_power_cons_hp * motor_efficiency

  # Change the motor efficiency
  pump.setMotorEfficiency(motor_efficiency)

  total_efficiency = impeller_efficiency * motor_efficiency

  desired_power_per_m3_s = OpenStudio.convert(target_w_per_gpm, 'W*min/gal', 'W*s/m^3').get

  pressure_rise_pa = desired_power_per_m3_s * total_efficiency
  pressure_rise_ft_h2o = OpenStudio.convert(pressure_rise_pa, 'Pa', 'ftH_{2}O').get

  # Change pressure rise
  pump.setRatedPumpHead(pressure_rise_pa)

  # Report
  OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Pump', "For #{pump.name}: motor nameplate = #{nominal_hp}HP, motor eff = #{(motor_efficiency * 100).round(2)}%; #{target_w_per_gpm.round} W/gpm translates to a pressure rise of #{pressure_rise_ft_h2o.round(2)} ftH2O.")

  # Calculate the W/gpm for verification
  calculated_w = pump_pumppower(pump)

  calculated_w_per_gpm = calculated_w / flow_gpm

  OpenStudio.logFree(OpenStudio::Debug, 'openstudio.standards.Pump', "For #{pump.name}: calculated W/gpm = #{calculated_w_per_gpm.round(1)}.")

  return true
end

#pump_apply_standard_minimum_motor_efficiency(pump) ⇒ Boolean

Applies the minimum motor efficiency for this pump based on the motor’s brake horsepower.

Parameters:

  • pump (OpenStudio::Model::StraightComponent) —

    pump object, allowable types: PumpConstantSpeed, PumpVariableSpeed

Returns:

  • (Boolean) —

    returns true if successful, false if not



98
99
100
101
102
103
104
105
106
107
108
109
110
111
 
# File 'lib/openstudio-standards/standards/Standards.Pump.rb', line 98

def pump_apply_standard_minimum_motor_efficiency(pump)
  # Get the horsepower
  bhp = pump_brake_horsepower(pump)

  # Find the motor efficiency
  motor_eff, nominal_hp = pump_standard_minimum_motor_efficiency_and_size(pump, bhp)

  # Change the motor efficiency
  pump.setMotorEfficiency(motor_eff)

  OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Pump', "For #{pump.name}: brake hp = #{bhp.round(2)}HP, motor nameplate = #{nominal_hp.round(2)}HP, motor eff = #{(motor_eff * 100).round(2)}%.")

  return true
end

#pump_brake_horsepower(pump) ⇒ Double

Determines the brake horsepower of the pump based on flow rate, pressure rise, and impeller efficiency.

Parameters:

  • pump (OpenStudio::Model::StraightComponent) —

    pump object, allowable types: PumpConstantSpeed, PumpVariableSpeed

Returns:

  • (Double) —

    brake horsepower



235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
 
# File 'lib/openstudio-standards/standards/Standards.Pump.rb', line 235

def pump_brake_horsepower(pump)
  # Get flow rate (whether autosized or hard-sized)
  # Get flow rate (whether autosized or hard-sized)
  flow_m3_per_s = 0
  flow_m3_per_s = if pump.to_PumpVariableSpeed.is_initialized || pump.to_PumpConstantSpeed.is_initialized
                    if pump.ratedFlowRate.is_initialized
                      pump.ratedFlowRate.get
                    elsif pump.autosizedRatedFlowRate.is_initialized
                      pump.autosizedRatedFlowRate.get
                    end
                  elsif pump.to_HeaderedPumpsVariableSpeed.is_initialized || pump.to_HeaderedPumpsConstantSpeed.is_initialized
                    if pump.totalRatedFlowRate.is_initialized
                      pump.totalRatedFlowRate.get
                    elsif pump.autosizedTotalRatedFlowRate.is_initialized
                      pump.autosizedTotalRatedFlowRate.get
                    end
                  end

  # E+ default impeller efficiency
  # http://bigladdersoftware.com/epx/docs/8-4/engineering-reference/component-sizing.html#pump-sizing
  impeller_eff = 0.78

  # Get the pressure rise (Pa)
  pressure_rise_pa = pump.ratedPumpHead

  # Calculate the pump power (W)
  pump_power_w = pressure_rise_pa * flow_m3_per_s / impeller_eff

  # Convert to HP
  pump_power_hp = pump_power_w / 745.7 # 745.7 W/HP

  return pump_power_hp
end

#pump_motor_horsepower(pump) ⇒ Double

Determines the horsepower of the pump motor, including motor efficiency and pump impeller efficiency.

Parameters:

  • pump (OpenStudio::Model::StraightComponent) —

    pump object, allowable types: PumpConstantSpeed, PumpVariableSpeed

Returns:

  • (Double) —

    motor horsepower



274
275
276
277
278
279
280
281
282
 
# File 'lib/openstudio-standards/standards/Standards.Pump.rb', line 274

def pump_motor_horsepower(pump)
  # Get the pump power
  pump_power_w = pump_pumppower(pump)

  # Convert to HP
  pump_hp = pump_power_w / 745.7 # 745.7 W/HP

  return pump_hp
end

#pump_pumppower(pump) ⇒ Double

Determines the pump power (W) based on flow rate, pressure rise, and total pump efficiency(impeller eff * motor eff). Uses the E+ default assumption of 0.78 impeller efficiency.

Parameters:

  • pump (OpenStudio::Model::StraightComponent) —

    pump object, allowable types: PumpConstantSpeed, PumpVariableSpeed

Returns:

  • (Double) —

    pump power in watts



191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
 
# File 'lib/openstudio-standards/standards/Standards.Pump.rb', line 191

def pump_pumppower(pump)
  # Get flow rate (whether autosized or hard-sized)
  flow_m3_per_s = 0
  flow_m3_per_s = if pump.to_PumpVariableSpeed.is_initialized || pump.to_PumpConstantSpeed.is_initialized
                    if pump.ratedFlowRate.is_initialized
                      pump.ratedFlowRate.get
                    elsif pump.autosizedRatedFlowRate.is_initialized
                      pump.autosizedRatedFlowRate.get
                    end
                  elsif pump.to_HeaderedPumpsVariableSpeed.is_initialized || pump.to_HeaderedPumpsConstantSpeed.is_initialized
                    if pump.totalRatedFlowRate.is_initialized
                      pump.totalRatedFlowRate.get
                    elsif pump.autosizedTotalRatedFlowRate.is_initialized
                      pump.autosizedTotalRatedFlowRate.get
                    end
                  end

  # E+ default impeller efficiency
  # http://bigladdersoftware.com/epx/docs/8-4/engineering-reference/component-sizing.html#pump-sizing
  impeller_eff = 0.78

  # Get the motor efficiency
  motor_eff = pump.motorEfficiency

  # Calculate the total efficiency
  # which includes both motor and
  # impeller efficiency.
  pump_total_eff = impeller_eff * motor_eff

  # Get the pressure rise (Pa)
  pressure_rise_pa = pump.ratedPumpHead

  # Calculate the pump power (W)
  pump_power_w = pressure_rise_pa * flow_m3_per_s / pump_total_eff

  return pump_power_w
end

#pump_rated_w_per_gpm(pump) ⇒ Double

Determines the rated watts per GPM of the pump

Parameters:

  • pump (OpenStudio::Model::StraightComponent) —

    pump object, allowable types: PumpConstantSpeed, PumpVariableSpeed

Returns:

  • (Double) —

    rated power consumption per flow in watts per gpm, W*min/gal



289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
 
# File 'lib/openstudio-standards/standards/Standards.Pump.rb', line 289

def pump_rated_w_per_gpm(pump)
  # Get design power (whether autosized or hard-sized)
  rated_power_w = 0
  if pump.ratedPowerConsumption.is_initialized
    rated_power_w = pump.ratedPowerConsumption.get
  elsif pump.autosizedRatedPowerConsumption.is_initialized
    rated_power_w = pump.autosizedRatedPowerConsumption.get
  else
    OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Pump', "For #{pump.name}, could not find rated pump power consumption, cannot determine w per gpm correctly.")
    return 0.0
  end

  rated_m3_per_s = 0
  if pump.to_PumpVariableSpeed.is_initialized || pump.to_PumpConstantSpeed.is_initialized
    if pump.ratedFlowRate.is_initialized
      rated_m3_per_s = pump.ratedFlowRate.get
    elsif pump.autosizedRatedFlowRate.is_initialized
      rated_m3_per_s = pump.autosizedRatedFlowRate.get
    else
      OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Pump', "For #{pump.name}, could not find rated pump Flow Rate, cannot determine w per gpm correctly.")
      return 0.0
    end
  elsif pump.to_HeaderedPumpsVariableSpeed.is_initialized || pump.to_HeaderedPumpsConstantSpeed.is_initialized
    if pump.totalRatedFlowRate.is_initialized
      rated_m3_per_s = pump.totalRatedFlowRate.get
    elsif pump.autosizedTotalRatedFlowRate.is_initialized
      rated_m3_per_s = pump.autosizedTotalRatedFlowRate.get
    else
      OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Pump', "For #{pump.name}, could not find rated pump Flow Rate, cannot determine w per gpm correctly.")
      return 0.0
    end
  end

  rated_w_per_m3s = rated_power_w / rated_m3_per_s

  rated_w_per_gpm = OpenStudio.convert(rated_w_per_m3s, 'W*s/m^3', 'W*min/gal').get

  return rated_w_per_gpm
end

#pump_standard_minimum_motor_efficiency_and_size(pump, motor_bhp) ⇒ Array<Double>

Determines the minimum pump 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 picks the next nominal motor category 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.

Parameters:

  • pump (OpenStudio::Model::StraightComponent) —

    pump object, allowable types: PumpConstantSpeed, PumpVariableSpeed

  • motor_bhp (Double) —

    motor brake horsepower (hp)

Returns:

  • (Array<Double>) —

    minimum motor efficiency (0.0 to 1.0), nominal horsepower



126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
 
# File 'lib/openstudio-standards/standards/Standards.Pump.rb', line 126

def pump_standard_minimum_motor_efficiency_and_size(pump, motor_bhp)
  motor_eff = 0.85
  # 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.
  # Source: Thornton et al. (2011), Achieving the 30% Goal: Energy and Cost Savings Analysis of ASHRAE Standard 90.1-2010, Section 4.5.4
  nominal_hp = motor_bhp * 1.1

  # Don't attempt to look up motor efficiency
  # for zero-hp pumps (required for circulation-pump-free
  # service water heating systems).
  return [1.0, 0] if motor_bhp < 0.0001 # under 1 watt

  if nominal_hp <= 0.75
    motor_type = motor_type(nominal_hp)
    motor_properties = motor_fractional_hp_efficiencies(nominal_hp, motor_type = motor_type)
  else
    # Lookup the minimum motor efficiency
    motors = standards_data['motors']

    # Assuming all pump motors are 4-pole ODP
    search_criteria = {
      'template' => template,
      'number_of_poles' => 4.0,
      'type' => 'Enclosed'
    }

    # Use the efficiency largest motor efficiency when BHP is greater than the largest size for which a requirement is provided
    data = model_find_objects(motors, search_criteria)
    maximum_capacity = model_find_maximum_value(data, 'maximum_capacity')
    if motor_bhp > maximum_capacity
      motor_bhp = maximum_capacity
    end

    motor_properties = model_find_object(motors, search_criteria, capacity = nil, date = Date.today, area = nil, num_floors = nil, fan_motor_bhp = motor_bhp)

    if motor_properties.nil?
      # Retry without the date
      motor_properties = model_find_object(motors, search_criteria, capacity = nil, date = nil, area = nil, num_floors = nil, fan_motor_bhp = motor_bhp)
    end
  end

  if motor_properties.nil?
    OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.Pump', "For #{pump.name}, could not find motor properties using search criteria: #{search_criteria}, motor_bhp = #{motor_bhp} hp.")
    return [motor_eff, nominal_hp]
  end

  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

  return [motor_eff, nominal_hp]
end