Class: OpenStudio::Model::CoilCoolingDXTwoSpeed

Inherits:
Object
  • Object
show all
Defined in:
lib/openstudio-standards/hvac_sizing/HVACSizing.CoilCoolingDXTwoSpeed.rb,
lib/openstudio-standards/standards/Standards.CoilCoolingDXTwoSpeed.rb

Overview

Reopen the OpenStudio class to add methods to apply standards to this object

Instance Method Summary collapse

Instance Method Details

#applySizingValues ⇒ Object

Takes the values calculated by the EnergyPlus sizing routines and puts them into this object model in place of the autosized fields. Must have previously completed a run with sql output for this to work.



13
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
 
# File 'lib/openstudio-standards/hvac_sizing/HVACSizing.CoilCoolingDXTwoSpeed.rb', line 13

def applySizingValues

  rated_high_speed_air_flow_rate = self.autosizedRatedHighSpeedAirFlowRate
  if rated_high_speed_air_flow_rate.is_initialized
    self.setRatedHighSpeedAirFlowRate(rated_high_speed_air_flow_rate) 
  end

  rated_high_speed_total_cooling_capacity = self.autosizedRatedHighSpeedTotalCoolingCapacity
  if rated_high_speed_total_cooling_capacity.is_initialized
    self.setRatedHighSpeedTotalCoolingCapacity(rated_high_speed_total_cooling_capacity) 
  end    

  rated_high_speed_sensible_heat_ratio = self.autosizedRatedHighSpeedSensibleHeatRatio
  if rated_high_speed_sensible_heat_ratio.is_initialized
    self.setRatedHighSpeedSensibleHeatRatio(rated_high_speed_sensible_heat_ratio) 
  end     
  
  rated_low_speed_air_flow_rate = self.autosizedRatedLowSpeedAirFlowRate
  if rated_low_speed_air_flow_rate.is_initialized
    self.setRatedLowSpeedAirFlowRate(rated_low_speed_air_flow_rate) 
  end  

  rated_low_speed_total_cooling_capacity = self.autosizedRatedLowSpeedTotalCoolingCapacity
  if rated_low_speed_total_cooling_capacity.is_initialized
    self.setRatedLowSpeedTotalCoolingCapacity(rated_low_speed_total_cooling_capacity) 
  end  

  rated_low_speed_sensible_heat_ratio = self.autosizedRatedLowSpeedSensibleHeatRatio
  if rated_low_speed_sensible_heat_ratio.is_initialized
    self.setRatedLowSpeedSensibleHeatRatio(rated_low_speed_sensible_heat_ratio)
  end
  
end

#autosize ⇒ Object

Sets all auto-sizeable fields to autosize



6
7
8
 
# File 'lib/openstudio-standards/hvac_sizing/HVACSizing.CoilCoolingDXTwoSpeed.rb', line 6

def autosize
  OpenStudio::logFree(OpenStudio::Warn, "openstudio.sizing.CoilCoolingDXTwoSpeed", ".autosize not yet implemented for #{self.iddObject.type.valueDescription}.")
end

#autosizedRatedHighSpeedAirFlowRate ⇒ Object

returns the autosized rated high speed air flow rate as an optional double



48
49
50
51
52
 
# File 'lib/openstudio-standards/hvac_sizing/HVACSizing.CoilCoolingDXTwoSpeed.rb', line 48

def autosizedRatedHighSpeedAirFlowRate

  return self.model.getAutosizedValue(self, 'Design Size High Speed Rated Air Flow Rate', 'm3/s')   
  
end

#autosizedRatedHighSpeedSensibleHeatRatio ⇒ Object

returns the autosized rated high speed sensible heat ratio as an optional double



62
63
64
65
66
 
# File 'lib/openstudio-standards/hvac_sizing/HVACSizing.CoilCoolingDXTwoSpeed.rb', line 62

def autosizedRatedHighSpeedSensibleHeatRatio

  return self.model.getAutosizedValue(self, 'Design Size High Speed Rated Sensible Heat Ratio', '')
  
end

#autosizedRatedHighSpeedTotalCoolingCapacity ⇒ Object

returns the autosized rated high speed total cooling capacity as an optional double



55
56
57
58
59
 
# File 'lib/openstudio-standards/hvac_sizing/HVACSizing.CoilCoolingDXTwoSpeed.rb', line 55

def autosizedRatedHighSpeedTotalCoolingCapacity

  return self.model.getAutosizedValue(self, 'Design Size High Speed Gross Rated Total Cooling Capacity', 'W')
  
end

#autosizedRatedLowSpeedAirFlowRate ⇒ Object

returns the autosized rated low speed air flow rate as an optional double



69
70
71
72
73
 
# File 'lib/openstudio-standards/hvac_sizing/HVACSizing.CoilCoolingDXTwoSpeed.rb', line 69

def autosizedRatedLowSpeedAirFlowRate

  return self.model.getAutosizedValue(self, 'Design Size Low Speed Rated Air Flow Rate', 'm3/s')
  
end

#autosizedRatedLowSpeedSensibleHeatRatio ⇒ Object

returns the autosized rated low speed sensible heat ratio as an optional double



83
84
85
86
87
 
# File 'lib/openstudio-standards/hvac_sizing/HVACSizing.CoilCoolingDXTwoSpeed.rb', line 83

def autosizedRatedLowSpeedSensibleHeatRatio

  return self.model.getAutosizedValue(self, 'Design Size Low Speed Gross Rated Sensible Heat Ratio', '')

end

#autosizedRatedLowSpeedTotalCoolingCapacity ⇒ Object

returns the autosized rated low speed total cooling capacity as an optional double



76
77
78
79
80
 
# File 'lib/openstudio-standards/hvac_sizing/HVACSizing.CoilCoolingDXTwoSpeed.rb', line 76

def autosizedRatedLowSpeedTotalCoolingCapacity

  return self.model.getAutosizedValue(self, 'Design Size Low Speed Gross Rated Total Cooling Capacity', 'W')
  
end

#find_capacity ⇒ Double

Finds capacity in tons

Returns:

  • (Double) —

    capacity in tons to be used for find object



81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/openstudio-standards/standards/Standards.CoilCoolingDXTwoSpeed.rb', line 81

def find_capacity()

  # Get the coil capacity
  capacity_w = nil
  if self.ratedHighSpeedTotalCoolingCapacity.is_initialized
    capacity_w = self.ratedHighSpeedTotalCoolingCapacity.get
  elsif self.autosizedRatedHighSpeedTotalCoolingCapacity.is_initialized
    capacity_w = self.autosizedRatedHighSpeedTotalCoolingCapacity.get
  else
    #OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXSingleSpeed', "For #{self.name} capacity is not available, cannot apply efficiency standard.")
    successfully_set_all_properties = false
    return successfully_set_all_properties
  end

  # Convert capacity to Btu/hr
  capacity_btu_per_hr = OpenStudio.convert(capacity_w, "W", "Btu/hr").get

  return capacity_btu_per_hr

end

#find_search_criteria(template) ⇒ hash

Finds the search criteria

Parameters:

  • template (String) —

    valid choices: ‘DOE Ref Pre-1980’, ‘DOE Ref 1980-2004’, ‘90.1-2004’, ‘90.1-2007’, ‘90.1-2010’, ‘90.1-2013’

Returns:

  • (hash) —

    has for search criteria to be used for find object



9
10
11
12
13
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
 
# File 'lib/openstudio-standards/standards/Standards.CoilCoolingDXTwoSpeed.rb', line 9

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
  search_criteria['cooling_type'] = cooling_type


  # Determine the heating type if unitary or zone hvac
  heat_pump = false
  heating_type = nil
  if self.airLoopHVAC.empty?
    if self.containingHVACComponent.is_initialized
      containing_comp = containingHVACComponent.get
      if containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAir.is_initialized
        heat_pump = true
        heating_type = 'Electric Resistance or None'
      end # TODO Add other unitary systems
    elsif self.containingZoneHVACComponent.is_initialized
      containing_comp = containingZoneHVACComponent.get
      if containing_comp.to_ZoneHVACPackagedTerminalAirConditioner.is_initialized
        htg_coil = containing_comp.to_ZoneHVACPackagedTerminalAirConditioner.get.heatingCoil
        if htg_coil.to_CoilHeatingElectric.is_initialized
          heating_type = 'Electric Resistance or None'
        elsif htg_coil.to_CoilHeatingWater.is_initialized || htg_coil.to_CoilHeatingGas.is_initialized
          heating_type = 'All Other'
        end
      end # TODO Add other zone hvac systems
    end
  end

  # Determine the heating type if on an airloop
  if self.airLoopHVAC.is_initialized
    air_loop = self.airLoopHVAC.get
    if air_loop.supplyComponents('Coil:Heating:Electric'.to_IddObjectType).size > 0
      heating_type = 'Electric Resistance or None'
    elsif air_loop.supplyComponents('Coil:Heating:Gas'.to_IddObjectType).size > 0
      heating_type = 'All Other'
    elsif air_loop.supplyComponents('Coil:Heating:Water'.to_IddObjectType).size > 0
      heating_type = 'All Other'
    elsif air_loop.supplyComponents('Coil:Heating:DX:SingleSpeed'.to_IddObjectType).size > 0
      heating_type = 'All Other'
    elsif air_loop.supplyComponents('Coil:Heating:Gas:MultiStage'.to_IddObjectType).size > 0
      heating_type = 'All Other'
    elsif air_loop.supplyComponents('Coil:Heating:Desuperheater'.to_IddObjectType).size > 0
      heating_type = 'All Other'
    elsif air_loop.supplyComponents('Coil:Heating:WaterToAirHeatPump:EquationFit'.to_IddObjectType).size > 0
      heating_type = 'All Other'
    else
      heating_type = 'Electric Resistance or None'
    end
  end

  # Add the heating type to the search criteria
  unless heating_type.nil?
    search_criteria['heating_type'] = heating_type
  end

  # TODO Standards - add split system vs single package to model
  # For now, assume single package
  subcategory = 'Single Package'
  search_criteria['subcategory'] = subcategory

  return search_criteria

end

#setStandardEfficiencyAndCurves(template) ⇒ Bool

Applies the standard efficiency ratings and typical performance curves to this object.

Parameters:

  • template (String) —

    valid choices: ‘DOE Ref Pre-1980’, ‘DOE Ref 1980-2004’, ‘90.1-2004’, ‘90.1-2007’, ‘90.1-2010’, ‘90.1-2013’

  • standards (Hash) —

    the OpenStudio_Standards spreadsheet in hash format

Returns:

  • (Bool) —

    true if successful, false if not



165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
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
228
229
230
231
232
233
234
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
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
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
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
 
# File 'lib/openstudio-standards/standards/Standards.CoilCoolingDXTwoSpeed.rb', line 165

def setStandardEfficiencyAndCurves(template)

  successfully_set_all_properties = true  

  unitary_acs = $os_standards['unitary_acs']

  # Define the criteria to find the chiller properties
  # in the hvac standards data set.
  search_criteria = {}
  search_criteria['template'] = template
  cooling_type = self.condenserType
  search_criteria['cooling_type'] = cooling_type
  

  # Determine the heating type if unitary or zone hvac
  heat_pump = false
  heating_type = nil
  if self.airLoopHVAC.empty?
    if self.containingHVACComponent.is_initialized
      containing_comp = containingHVACComponent.get
      if containing_comp.to_AirLoopHVACUnitaryHeatPumpAirToAir.is_initialized
        heat_pump = true
        heating_type = 'Electric Resistance or None'
      end # TODO Add other unitary systems
    elsif self.containingZoneHVACComponent.is_initialized
      containing_comp = containingZoneHVACComponent.get
      if containing_comp.to_ZoneHVACPackagedTerminalAirConditioner.is_initialized
        htg_coil = containing_comp.to_ZoneHVACPackagedTerminalAirConditioner.get.heatingCoil
        if htg_coil.to_CoilHeatingElectric.is_initialized
          heating_type = 'Electric Resistance or None'          
        elsif htg_coil.to_CoilHeatingWater.is_initialized || htg_coil.to_CoilHeatingGas.is_initialized
          heating_type = 'All Other'
        end 
      end # TODO Add other zone hvac systems
    end
  end    
  
  # Determine the heating type if on an airloop
  if self.airLoopHVAC.is_initialized
    air_loop = self.airLoopHVAC.get
    if air_loop.supplyComponents('Coil:Heating:Electric'.to_IddObjectType).size > 0
      heating_type = 'Electric Resistance or None'
    elsif air_loop.supplyComponents('Coil:Heating:Gas'.to_IddObjectType).size > 0
      heating_type = 'All Other'
    elsif air_loop.supplyComponents('Coil:Heating:Water'.to_IddObjectType).size > 0
      heating_type = 'All Other'
    elsif air_loop.supplyComponents('Coil:Heating:DX:SingleSpeed'.to_IddObjectType).size > 0
      heating_type = 'All Other'
    elsif air_loop.supplyComponents('Coil:Heating:Gas:MultiStage'.to_IddObjectType).size > 0
      heating_type = 'All Other'
    elsif air_loop.supplyComponents('Coil:Heating:Desuperheater'.to_IddObjectType).size > 0
      heating_type = 'All Other'
    elsif air_loop.supplyComponents('Coil:Heating:WaterToAirHeatPump:EquationFit'.to_IddObjectType).size > 0
      heating_type = 'All Other'  
    else
      heating_type = 'Electric Resistance or None'
    end
  end
  
  # Add the heating type to the search criteria
  unless heating_type.nil?
    search_criteria['heating_type'] = heating_type
  end
  
  # TODO Standards - add split system vs single package to model
  # For now, assume single package
  subcategory = 'Single Package'
  search_criteria['subcategory'] = subcategory

  # Get the coil capacity
  capacity_w = nil
  if self.ratedHighSpeedTotalCoolingCapacity.is_initialized
    capacity_w = self.ratedHighSpeedTotalCoolingCapacity.get
  elsif self.autosizedRatedHighSpeedTotalCoolingCapacity.is_initialized
    capacity_w = self.autosizedRatedHighSpeedTotalCoolingCapacity.get
  else
    #OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXSingleSpeed', "For #{self.name} capacity is not available, cannot apply efficiency standard.")
    successfully_set_all_properties = false
    return successfully_set_all_properties
  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
  
  ac_props = self.model.find_object(unitary_acs, search_criteria, capacity_btu_per_hr)

  # Check to make sure properties were found
  if ac_props.nil?
    OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXTwoSpeed', "For #{self.name}, cannot find efficiency info, cannot apply efficiency standard.")
    successfully_set_all_properties = false
    return successfully_set_all_properties
  end
 
  # Make the total COOL-CAP-FT curve
  tot_cool_cap_ft = self.model.add_curve(ac_props["cool_cap_ft"])
  if tot_cool_cap_ft
    self.setTotalCoolingCapacityFunctionOfTemperatureCurve(tot_cool_cap_ft)
  else
    OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXTwoSpeed', "For #{self.name}, cannot find cool_cap_ft curve, will not be set.")
    successfully_set_all_properties = false
  end

  # Make the total COOL-CAP-FFLOW curve
  tot_cool_cap_fflow = self.model.add_curve(ac_props["cool_cap_fflow"])
  if tot_cool_cap_fflow
    self.setTotalCoolingCapacityFunctionOfFlowFractionCurve(tot_cool_cap_fflow)
  else
    OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXTwoSpeed', "For #{self.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"])
  if cool_eir_ft
    self.setEnergyInputRatioFunctionOfTemperatureCurve(cool_eir_ft)  
  else
    OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXTwoSpeed', "For #{self.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"])
  if cool_eir_fflow
    self.setEnergyInputRatioFunctionOfFlowFractionCurve(cool_eir_fflow)
  else
    OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXTwoSpeed', "For #{self.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"])
  if cool_plf_fplr
    self.setPartLoadFractionCorrelationCurve(cool_plf_fplr)
  else
    OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXTwoSpeed', "For #{self.name}, cannot find cool_plf_fplr curve, will not be set.")
    successfully_set_all_properties = false
  end
  
  # Make the low speed COOL-CAP-FT curve
  low_speed_cool_cap_ft = self.model.add_curve(ac_props["cool_cap_ft"])
  if low_speed_cool_cap_ft
    self.setLowSpeedTotalCoolingCapacityFunctionOfTemperatureCurve(low_speed_cool_cap_ft)
  else
    OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXTwoSpeed', "For #{self.name}, cannot find cool_cap_ft curve, will not be set.")
    successfully_set_all_properties = false
  end

  # Make the low speed COOL-EIR-FT curve
  low_speed_cool_eir_ft = self.model.add_curve(ac_props["cool_eir_ft"])
  if low_speed_cool_eir_ft
    self.setLowSpeedEnergyInputRatioFunctionOfTemperatureCurve(low_speed_cool_eir_ft)  
  else
    OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXTwoSpeed', "For #{self.name}, cannot find cool_eir_ft curve, will not be set.")
    successfully_set_all_properties = false
  end

  # Get the minimum efficiency standards
  cop = nil
  
  # 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)
    self.setName("#{self.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_seer}SEER")
    OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.CoilCoolingDXTwoSpeed', "For #{template}: #{self.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)
    self.setName("#{self.name} #{capacity_kbtu_per_hr.round}kBtu/hr #{min_eer}EER")
    OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.CoilCoolingDXTwoSpeed', "For #{template}: #{self.name}: #{cooling_type} #{heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; EER = #{min_eer}")
  end

  # Set the efficiency values
  self.setRatedHighSpeedCOP(cop)
  self.setRatedLowSpeedCOP(cop)
  
  return true

end

#standard_minimum_cop(template, standards) ⇒ Double

Finds lookup object in standards and return efficiency

Parameters:

  • template (String) —

    valid choices: ‘DOE Ref Pre-1980’, ‘DOE Ref 1980-2004’, ‘90.1-2004’, ‘90.1-2007’, ‘90.1-2010’, ‘90.1-2013’

  • standards (Hash) —

    the OpenStudio_Standards spreadsheet in hash format

Returns:

  • (Double) —

    full load efficiency (COP)



107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
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
 
# File 'lib/openstudio-standards/standards/Standards.CoilCoolingDXTwoSpeed.rb', line 107

def standard_minimum_cop(template,standards)

  # find ac properties
  search_criteria = self.find_search_criteria(template)
  cooling_type = search_criteria["cooling_type"]
  heating_type = search_criteria["heating_type"]
  subcategory = search_criteria["subcategory"]
  capacity_btu_per_hr = self.find_capacity
  capacity_kbtu_per_hr = OpenStudio.convert(capacity_btu_per_hr, "Btu/hr", "kBtu/hr").get

  ac_props = self.model.find_object(standards["unitary_acs"], search_criteria, capacity_btu_per_hr)

  # Get the minimum efficiency standards
  cop = nil

  # Check to make sure properties were found
  if ac_props.nil?
    OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.CoilCoolingDXTwoSpeed', "For #{self.name}, cannot find efficiency info, cannot apply efficiency standard.")
    return cop # value of nil
  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)
    OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.CoilCoolingDXTwoSpeed', "For #{template}: #{self.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)
    OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.CoilCoolingDXTwoSpeed', "For #{template}: #{self.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)
    OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.CoilCoolingDXSingleSpeed',  "For #{template}: #{self.name}: #{cooling_type} #{heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; SEER = #{min_seer}")
  end

  # 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)
    OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.CoilCoolingDXSingleSpeed', "For #{template}: #{self.name}: #{cooling_type} #{heating_type} #{subcategory} Capacity = #{capacity_kbtu_per_hr.round}kBtu/hr; EER = #{min_eer}")
  end

  return cop

end