Class: OpenStudio::Model::CoilCoolingDXMultiSpeed

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

Overview

open the class to add methods to return sizing values

Instance Method Summary collapse

Instance Method Details

#apply_efficiency_and_curves(template, sql_db_vars_map) ⇒ 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’

Returns:

  • (Bool) —

    true if successful, false if not



8
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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
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
159
160
161
162
163
164
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
 
# File 'lib/openstudio-standards/standards/Standards.CoilCoolingDXMultiSpeed.rb', line 8

def apply_efficiency_and_curves(template, sql_db_vars_map)
  successfully_set_all_properties = true

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

  # 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 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
          heat_pump = true
          heating_type = 'Electric Resistance or None'
        elsif htg_coil.to_CoilHeatingGasMultiStage.is_initialized
          heating_type = 'All Other'
        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'
        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

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

  search_criteria['subcategory'] = subcategory

  # Get the coil capacity
  capacity_w = nil
  clg_stages = stages
  if clg_stages.last.grossRatedTotalCoolingCapacity.is_initialized
    capacity_w = clg_stages.last.grossRatedTotalCoolingCapacity.get
  elsif autosizedSpeed4GrossRatedTotalCoolingCapacity.is_initialized
    capacity_w = autosizedSpeed4GrossRatedTotalCoolingCapacity.get
  else
    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

  # Volume flow rate
  flow_rate4 = nil
  if clg_stages.last.ratedAirFlowRate.is_initialized
    flow_rate4 = clg_stages.last.ratedAirFlowRate.get
  elsif autosizedSpeed4RatedAirFlowRate.is_initialized
    flow_rate4 = autosizedSpeed4RatedAirFlowRate.get
  end

  # Set number of stages for 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
    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]
      end
    end
    # set capacities, flow rates, and sensible heat ratio for stages
    (0..3).each do |istage|
      clg_stages[istage].setGrossRatedTotalCoolingCapacity(stage_cap[istage])
      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

  # Lookup efficiencies depending on whether it is a unitary AC or a heat pump
  ac_props = nil
  ac_props = if heat_pump == true
               model.find_object($os_standards['heat_pumps'], search_criteria, capacity_btu_per_hr, Date.today)
             else
               model.find_object($os_standards['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 #{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 = model.add_curve(ac_props['cool_cap_ft'], standards)
  if cool_cap_ft
    clg_stages.each do |stage|
      stage.setTotalCoolingCapacityFunctionofTemperatureCurve(cool_cap_ft)
    end
  else
    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 = model.add_curve(ac_props['cool_cap_fflow'], standards)
  if cool_cap_fflow
    clg_stages.each do |stage|
      stage.setTotalCoolingCapacityFunctionofFlowFractionCurve(cool_cap_fflow)
    end
  else
    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 = model.add_curve(ac_props['cool_eir_ft'], standards)
  if cool_eir_ft
    clg_stages.each do |stage|
      stage.setEnergyInputRatioFunctionofTemperatureCurve(cool_eir_ft)
    end
  else
    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 = model.add_curve(ac_props['cool_eir_fflow'], standards)
  if cool_eir_fflow
    clg_stages.each do |stage|
      stage.setEnergyInputRatioFunctionofFlowFractionCurve(cool_eir_fflow)
    end
  else
    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 = model.add_curve(ac_props['cool_plf_fplr'], standards)
  if cool_plf_fplr
    clg_stages.each do |stage|
      stage.setPartLoadFractionCorrelationCurve(cool_plf_fplr)
    end
  else
    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

  # 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 = 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 = "#{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 = "#{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 = "#{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 = "#{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)
  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 = "#{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

  unless cop.nil?
    clg_stages.each do |istage|
      istage.setGrossRatedCoolingCOP(cop)
    end
  end

  return sql_db_vars_map
end

#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.



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
 
# File 'lib/openstudio-standards/hvac_sizing/Siz.CoilCoolingDXMultiSpeed.rb', line 24

def applySizingValues

  rated_speed1_rated_total_cooling_capacity = self.autosizedSpeed1GrossRatedTotalCoolingCapacity
  if rated_speed1_rated_total_cooling_capacity.is_initialized
    self.setSpeed1GrossRatedTotalCoolingCapacity(rated_speed1_rated_total_cooling_capacity.get) 
  end

  rated_speed2_rated_total_cooling_capacity = self.autosizedSpeed2GrossRatedTotalCoolingCapacity
  if rated_speed2_rated_total_cooling_capacity.is_initialized
    self.setSpeed2GrossRatedTotalCoolingCapacity(rated_speed2_rated_total_cooling_capacity.get) 
  end

  rated_speed3_rated_total_cooling_capacity = self.autosizedSpeed3GrossRatedTotalCoolingCapacity
  if rated_speed3_rated_total_cooling_capacity.is_initialized
    self.setSpeed3GrossRatedTotalCoolingCapacity(rated_speed3_rated_total_cooling_capacity.get) 
  end
  
  rated_speed4_rated_total_cooling_capacity = self.autosizedSpeed4GrossRatedTotalCoolingCapacity
  if rated_speed4_rated_total_cooling_capacity.is_initialized
    self.setSpeed4GrossRatedTotalCoolingCapacity(rated_speed4_rated_total_cooling_capacity.get) 
  end
  
  rated_speed1_rated_sensible_heat_ratio = self.autosizedSpeed1RatedSensibleHeatRatio
  if rated_speed1_rated_sensible_heat_ratio.is_initialized
    self.setSpeed1RatedSensibleHeatRatio(rated_speed1_rated_sensible_heat_ratio.get) 
  end

  rated_speed2_rated_sensible_heat_ratio = self.autosizedSpeed2RatedSensibleHeatRatio
  if rated_speed2_rated_sensible_heat_ratio.is_initialized
    self.setSpeed2RatedSensibleHeatRatio(rated_speed2_rated_sensible_heat_ratio.get) 
  end

  rated_speed3_rated_sensible_heat_ratio = self.autosizedSpeed3RatedSensibleHeatRatio
  if rated_speed3_rated_sensible_heat_ratio.is_initialized
    self.setSpeed3RatedSensibleHeatRatio(rated_speed3_rated_sensible_heat_ratio.get) 
  end

  rated_speed4_rated_sensible_heat_ratio = self.autosizedSpeed4RatedSensibleHeatRatio
  if rated_speed4_rated_sensible_heat_ratio.is_initialized
    self.setSpeed4RatedSensibleHeatRatio(rated_speed4_rated_sensible_heat_ratio.get) 
  end

  rated_speed1_rated_air_flow_rate = self.autosizedSpeed1RatedAirFlowRate
  if rated_speed1_rated_air_flow_rate.is_initialized
    self.setSpeed1RatedAirFlowRate(rated_speed1_rated_air_flow_rate.get) 
  end
 
  rated_speed2_rated_air_flow_rate = self.autosizedSpeed2RatedAirFlowRate
  if rated_speed2_rated_air_flow_rate.is_initialized
    self.setSpeed2RatedAirFlowRate(rated_speed2_rated_air_flow_rate.get) 
  end

  rated_speed3_rated_air_flow_rate = self.autosizedSpeed3RatedAirFlowRate
  if rated_speed3_rated_air_flow_rate.is_initialized
    self.setSpeed3RatedAirFlowRate(rated_speed3_rated_air_flow_rate.get) 
  end
  
  rated_speed4_rated_air_flow_rate = self.autosizedSpeed4RatedAirFlowRate
  if rated_speed4_rated_air_flow_rate.is_initialized
    self.setSpeed4RatedAirFlowRate(rated_speed4_rated_air_flow_rate.get) 
  end
 
end

#autosize ⇒ Object

Sets all auto-sizeable fields to autosize



6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
# File 'lib/openstudio-standards/hvac_sizing/Siz.CoilCoolingDXMultiSpeed.rb', line 6

def autosize
  autosizeSpeed1GrossRatedTotalCoolingCapacity
  autosizeSpeed2GrossRatedTotalCoolingCapacity
  autosizeSpeed3GrossRatedTotalCoolingCapacity
  autosizeSpeed4GrossRatedTotalCoolingCapacity
  autosizeSpeed1GrossRatedSensibleHeatRatio
  autosizeSpeed2GrossRatedSensibleHeatRatio
  autosizeSpeed3GrossRatedSensibleHeatRatio
  autosizeSpeed4GrossRatedSensibleHeatRatio  
  autosizeSpeed1RatedAirFlowRate
  autosizeSpeed2RatedAirFlowRate
  autosizeSpeed3RatedAirFlowRate
  autosizeSpeed4RatedAirFlowRate 
end

#autosizedSpeed1GrossRatedTotalCoolingCapacity ⇒ Object

returns the autosized rated total cooling capacity for stage 1 as an optional double



89
90
91
92
93
 
# File 'lib/openstudio-standards/hvac_sizing/Siz.CoilCoolingDXMultiSpeed.rb', line 89

def autosizedSpeed1GrossRatedTotalCoolingCapacity

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

#autosizedSpeed1RatedAirFlowRate ⇒ Object

returns the autosized rated air flow rate for stage 1 as an optional double



145
146
147
148
149
 
# File 'lib/openstudio-standards/hvac_sizing/Siz.CoilCoolingDXMultiSpeed.rb', line 145

def autosizedSpeed1RatedAirFlowRate

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

#autosizedSpeed1RatedSensibleHeatRatio ⇒ Object

returns the autosized rated sensible heat ratio for stage 1 as an optional double



117
118
119
120
121
 
# File 'lib/openstudio-standards/hvac_sizing/Siz.CoilCoolingDXMultiSpeed.rb', line 117

def autosizedSpeed1RatedSensibleHeatRatio

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

#autosizedSpeed2GrossRatedTotalCoolingCapacity ⇒ Object

returns the autosized rated total cooling capacity for stage 2 as an optional double



96
97
98
99
100
 
# File 'lib/openstudio-standards/hvac_sizing/Siz.CoilCoolingDXMultiSpeed.rb', line 96

def autosizedSpeed2GrossRatedTotalCoolingCapacity

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

#autosizedSpeed2RatedAirFlowRate ⇒ Object

returns the autosized rated air flow rate for stage 2 as an optional double



152
153
154
155
156
 
# File 'lib/openstudio-standards/hvac_sizing/Siz.CoilCoolingDXMultiSpeed.rb', line 152

def autosizedSpeed2RatedAirFlowRate

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

#autosizedSpeed2RatedSensibleHeatRatio ⇒ Object

returns the autosized rated sensible heat ratio for stage 2 as an optional double



124
125
126
127
128
 
# File 'lib/openstudio-standards/hvac_sizing/Siz.CoilCoolingDXMultiSpeed.rb', line 124

def autosizedSpeed2RatedSensibleHeatRatio

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

#autosizedSpeed3GrossRatedTotalCoolingCapacity ⇒ Object

returns the autosized rated total cooling capacity for stage 3 as an optional double



103
104
105
106
107
 
# File 'lib/openstudio-standards/hvac_sizing/Siz.CoilCoolingDXMultiSpeed.rb', line 103

def autosizedSpeed3GrossRatedTotalCoolingCapacity

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

#autosizedSpeed3RatedAirFlowRate ⇒ Object

returns the autosized rated air flow rate for stage 3 as an optional double



159
160
161
162
163
 
# File 'lib/openstudio-standards/hvac_sizing/Siz.CoilCoolingDXMultiSpeed.rb', line 159

def autosizedSpeed3RatedAirFlowRate

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

#autosizedSpeed3RatedSensibleHeatRatio ⇒ Object

returns the autosized rated sensible heat ratio for stage 3 as an optional double



131
132
133
134
135
 
# File 'lib/openstudio-standards/hvac_sizing/Siz.CoilCoolingDXMultiSpeed.rb', line 131

def autosizedSpeed3RatedSensibleHeatRatio

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

#autosizedSpeed4GrossRatedTotalCoolingCapacity ⇒ Object

returns the autosized rated total cooling capacity for stage 4 as an optional double



110
111
112
113
114
 
# File 'lib/openstudio-standards/hvac_sizing/Siz.CoilCoolingDXMultiSpeed.rb', line 110

def autosizedSpeed4GrossRatedTotalCoolingCapacity

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

#autosizedSpeed4RatedAirFlowRate ⇒ Object

returns the autosized rated air flow rate for stage 4 as an optional double



166
167
168
169
170
 
# File 'lib/openstudio-standards/hvac_sizing/Siz.CoilCoolingDXMultiSpeed.rb', line 166

def autosizedSpeed4RatedAirFlowRate

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

#autosizedSpeed4RatedSensibleHeatRatio ⇒ Object

returns the autosized rated sensible heat ratio for stage 4 as an optional double



138
139
140
141
142
 
# File 'lib/openstudio-standards/hvac_sizing/Siz.CoilCoolingDXMultiSpeed.rb', line 138

def autosizedSpeed4RatedSensibleHeatRatio

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