GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 29.9% 207 / 0 / 693
Functions: 26.6% 53 / 0 / 199
Branches: 24.7% 121 / 0 / 489

src/model/CoolingTowerVariableSpeed.cpp
Line Branch Exec Source
1 /***********************************************************************************************************************
2 * OpenStudio(R), Copyright (c) Alliance for Energy Innovation, LLC.
3 * See also https://openstudio.net/license
4 ***********************************************************************************************************************/
5
6 #include "Model.hpp"
7 #include "CoolingTowerVariableSpeed.hpp"
8 #include "CoolingTowerVariableSpeed_Impl.hpp"
9 #include "Schedule.hpp"
10 #include "Schedule_Impl.hpp"
11 #include "Node.hpp"
12 #include "Node_Impl.hpp"
13 #include "PlantLoop.hpp"
14 #include "PlantLoop_Impl.hpp"
15 #include "CurveCubic.hpp"
16 #include "CurveCubic_Impl.hpp"
17 #include "ScheduleTypeLimits.hpp"
18 #include "ScheduleTypeRegistry.hpp"
19
20 #include "../utilities/core/Assert.hpp"
21 #include "../utilities/data/DataEnums.hpp"
22
23 #include <utilities/idd/IddFactory.hxx>
24 #include <utilities/idd/OS_CoolingTower_VariableSpeed_FieldEnums.hxx>
25 #include <utilities/idd/IddEnums.hxx>
26
27 namespace openstudio {
28 namespace model {
29
30 namespace detail {
31
32 4 CoolingTowerVariableSpeed_Impl::CoolingTowerVariableSpeed_Impl(const IdfObject& idfObject, Model_Impl* model, bool keepHandle)
33 4 : StraightComponent_Impl(idfObject, model, keepHandle) {
34
4/6
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
✓ Branch 7 taken 4 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 4 times.
✗ Branch 13 not taken.
4 OS_ASSERT(idfObject.iddObject().type() == CoolingTowerVariableSpeed::iddObjectType());
35 4 }
36
37 ✗ CoolingTowerVariableSpeed_Impl::CoolingTowerVariableSpeed_Impl(const openstudio::detail::WorkspaceObject_Impl& other, Model_Impl* model,
38 ✗ bool keepHandle)
39 ✗ : StraightComponent_Impl(other, model, keepHandle) {
40 ✗ OS_ASSERT(other.iddObject().type() == CoolingTowerVariableSpeed::iddObjectType());
41 ✗ }
42
43 ✗ CoolingTowerVariableSpeed_Impl::CoolingTowerVariableSpeed_Impl(const CoolingTowerVariableSpeed_Impl& other, Model_Impl* model, bool keepHandle)
44 ✗ : StraightComponent_Impl(other, model, keepHandle) {}
45
46 ✗ const std::vector<std::string>& CoolingTowerVariableSpeed_Impl::outputVariableNames() const {
47 // static until it changes
48 static const std::vector<std::string> result{
49
50 // Common Variables
51 "Cooling Tower Fan Electricity Rate", "Cooling Tower Fan Electricity Energy", "Cooling Tower Heat Transfer Rate",
52 "Cooling Tower Inlet Temperature", "Cooling Tower Outlet Temperature", "Cooling Tower Mass Flow Rate", "Cooling Tower Fan Part Load Ratio",
53 "Cooling Tower Air Flow Rate Ratio", "Cooling Tower Operating Cells Count",
54
55 // When Mains Water is used
56 "Cooling Tower Make Up Water Volume Flow Rate", "Cooling Tower Make Up Water Volume", "Cooling Tower Make Up Mains Water Volume",
57
58 // When storage tank water is used:
59 // Supply Water Storage Tank Name isn't implemented in OpenStudio
60 // TODO: Revisit if need be
61 //"Cooling Tower Make Up Water Volume Flow Rate",
62 //"Cooling Tower Make Up Water Volume",
63 //"Cooling Tower Storage Tank Water Volume Flow Rate",
64 //"Cooling Tower Storage Tank Water Volume",
65 //"Cooling Tower Starved Storage Tank Water Volume Flow Rate",
66 //"Cooling Tower Starved Storage Tank Water Volume",
67 //"Cooling Tower Make Up Mains Water Volume",
68 //"Cooling Tower Water Evaporation Volume Flow Rate",
69 //"Cooling Tower Water Evaporation Volume",
70 //"Cooling Tower Water Drift Volume Flow Rate",
71 //"Cooling Tower Water Drift Volume",
72 //"Cooling Tower Water Blowdown Volume Flow Rate",
73 //"Cooling Tower Water Blowdown Volume",
74
75 // DLM: the return type of this method needs to change to std::vector<std::string> in ModelObject
76 // if specified
77 // if (this->basinHeaterCapacity() > 0) {
78 ✗ "Cooling Tower Basin Heater Electricity Rate", "Cooling Tower Basin Heater Electric Energy"};
79
80 ✗ return result;
81 ✗ }
82
83 ✗ IddObjectType CoolingTowerVariableSpeed_Impl::iddObjectType() const {
84 ✗ return CoolingTowerVariableSpeed::iddObjectType();
85 }
86
87 ✗ ModelObject CoolingTowerVariableSpeed_Impl::clone(Model model) const {
88 // StraightComponent_Impl will clone the CT and reset the inlet/outlet ports for us
89 ✗ auto newTower = StraightComponent_Impl::clone(model).cast<CoolingTowerVariableSpeed>();
90
91 ✗ if (boost::optional<ModelObject> mo = modelCoefficient()) {
92 ✗ newTower.setModelCoefficient(mo->clone(model));
93 ✗ }
94
95 ✗ return std::move(newTower);
96 ✗ }
97
98 ✗ std::vector<IddObjectType> CoolingTowerVariableSpeed_Impl::allowableChildTypes() const {
99 ✗ std::vector<IddObjectType> result;
100 ✗ result.push_back(IddObjectType::OS_CoolingTowerPerformance_YorkCalc);
101 ✗ result.push_back(IddObjectType::OS_CoolingTowerPerformance_CoolTools);
102 ✗ result.push_back(IddObjectType::OS_Curve_Cubic);
103 ✗ return result;
104 ✗ }
105
106 ✗ std::vector<ModelObject> CoolingTowerVariableSpeed_Impl::children() const {
107 ✗ std::vector<ModelObject> result;
108 ✗ if (boost::optional<ModelObject> mo = modelCoefficient()) {
109 ✗ result.push_back(mo.get());
110 ✗ }
111
112 ✗ if (boost::optional<CurveCubic> mo = fanPowerRatioFunctionofAirFlowRateRatioCurve()) {
113 ✗ result.push_back(mo.get());
114 ✗ }
115
116 ✗ return result;
117 ✗ }
118
119 ✗ std::vector<ScheduleTypeKey> CoolingTowerVariableSpeed_Impl::getScheduleTypeKeys(const Schedule& schedule) const {
120 ✗ std::vector<ScheduleTypeKey> result;
121 ✗ UnsignedVector fieldIndices = getSourceIndices(schedule.handle());
122 ✗ UnsignedVector::const_iterator b(fieldIndices.begin());
123 ✗ UnsignedVector::const_iterator e(fieldIndices.end());
124 ✗ if (std::find(b, e, OS_CoolingTower_VariableSpeedFields::BasinHeaterOperatingSchedule) != e) {
125 ✗ result.push_back(ScheduleTypeKey("CoolingTowerVariableSpeed", "Basin Heater Operating Schedule"));
126 }
127 ✗ if (std::find(b, e, OS_CoolingTower_VariableSpeedFields::BlowdownMakeupWaterUsageSchedule) != e) {
128 ✗ result.push_back(ScheduleTypeKey("CoolingTowerVariableSpeed", "Blowdown Makeup Water Usage Schedule"));
129 }
130 ✗ return result;
131 ✗ }
132
133 ✗ boost::optional<std::string> CoolingTowerVariableSpeed_Impl::modelType() const {
134 ✗ return getString(OS_CoolingTower_VariableSpeedFields::ModelType, true);
135 }
136
137 ✗ boost::optional<ModelObject> CoolingTowerVariableSpeed_Impl::modelCoefficient() const {
138 ✗ return getObject<ModelObject>().getModelObjectTarget<ModelObject>(OS_CoolingTower_VariableSpeedFields::ModelCoefficient);
139 }
140
141 ✗ boost::optional<double> CoolingTowerVariableSpeed_Impl::designInletAirWetBulbTemperature() const {
142 ✗ return getDouble(OS_CoolingTower_VariableSpeedFields::DesignInletAirWetBulbTemperature, true);
143 }
144
145 ✗ boost::optional<double> CoolingTowerVariableSpeed_Impl::designApproachTemperature() const {
146 ✗ return getDouble(OS_CoolingTower_VariableSpeedFields::DesignApproachTemperature, true);
147 }
148
149 ✗ boost::optional<double> CoolingTowerVariableSpeed_Impl::designRangeTemperature() const {
150 ✗ return getDouble(OS_CoolingTower_VariableSpeedFields::DesignRangeTemperature, true);
151 }
152
153 ✗ boost::optional<double> CoolingTowerVariableSpeed_Impl::designWaterFlowRate() const {
154 ✗ return getDouble(OS_CoolingTower_VariableSpeedFields::DesignWaterFlowRate, true);
155 }
156
157 ✗ bool CoolingTowerVariableSpeed_Impl::isDesignWaterFlowRateAutosized() const {
158 ✗ bool result = false;
159 ✗ boost::optional<std::string> value = getString(OS_CoolingTower_VariableSpeedFields::DesignWaterFlowRate, true);
160 ✗ if (value) {
161 ✗ result = openstudio::istringEqual(value.get(), "autosize");
162 }
163 ✗ return result;
164 ✗ }
165
166 ✗ boost::optional<double> CoolingTowerVariableSpeed_Impl::designAirFlowRate() const {
167 ✗ return getDouble(OS_CoolingTower_VariableSpeedFields::DesignAirFlowRate, true);
168 }
169
170 ✗ bool CoolingTowerVariableSpeed_Impl::isDesignAirFlowRateAutosized() const {
171 ✗ bool result = false;
172 ✗ boost::optional<std::string> value = getString(OS_CoolingTower_VariableSpeedFields::DesignAirFlowRate, true);
173 ✗ if (value) {
174 ✗ result = openstudio::istringEqual(value.get(), "autosize");
175 }
176 ✗ return result;
177 ✗ }
178
179 ✗ boost::optional<double> CoolingTowerVariableSpeed_Impl::designFanPower() const {
180 ✗ return getDouble(OS_CoolingTower_VariableSpeedFields::DesignFanPower, true);
181 }
182
183 ✗ bool CoolingTowerVariableSpeed_Impl::isDesignFanPowerAutosized() const {
184 ✗ bool result = false;
185 ✗ boost::optional<std::string> value = getString(OS_CoolingTower_VariableSpeedFields::DesignFanPower, true);
186 ✗ if (value) {
187 ✗ result = openstudio::istringEqual(value.get(), "autosize");
188 }
189 ✗ return result;
190 ✗ }
191
192 ✗ boost::optional<CurveCubic> CoolingTowerVariableSpeed_Impl::fanPowerRatioFunctionofAirFlowRateRatioCurve() const {
193 ✗ return getObject<ModelObject>().getModelObjectTarget<CurveCubic>(
194 ✗ OS_CoolingTower_VariableSpeedFields::FanPowerRatioFunctionofAirFlowRateRatioCurve);
195 }
196
197 ✗ boost::optional<double> CoolingTowerVariableSpeed_Impl::minimumAirFlowRateRatio() const {
198 ✗ return getDouble(OS_CoolingTower_VariableSpeedFields::MinimumAirFlowRateRatio, true);
199 }
200
201 ✗ boost::optional<double> CoolingTowerVariableSpeed_Impl::fractionofTowerCapacityinFreeConvectionRegime() const {
202 ✗ return getDouble(OS_CoolingTower_VariableSpeedFields::FractionofTowerCapacityinFreeConvectionRegime, true);
203 }
204
205 ✗ boost::optional<double> CoolingTowerVariableSpeed_Impl::basinHeaterCapacity() const {
206 ✗ return getDouble(OS_CoolingTower_VariableSpeedFields::BasinHeaterCapacity, true);
207 }
208
209 ✗ boost::optional<double> CoolingTowerVariableSpeed_Impl::basinHeaterSetpointTemperature() const {
210 ✗ return getDouble(OS_CoolingTower_VariableSpeedFields::BasinHeaterSetpointTemperature, true);
211 }
212
213 ✗ boost::optional<Schedule> CoolingTowerVariableSpeed_Impl::basinHeaterOperatingSchedule() const {
214 ✗ return getObject<ModelObject>().getModelObjectTarget<Schedule>(OS_CoolingTower_VariableSpeedFields::BasinHeaterOperatingSchedule);
215 }
216
217 ✗ std::string CoolingTowerVariableSpeed_Impl::evaporationLossMode() const {
218 ✗ boost::optional<std::string> value = getString(OS_CoolingTower_VariableSpeedFields::EvaporationLossMode, true);
219 ✗ OS_ASSERT(value);
220 ✗ return value.get();
221 ✗ }
222
223 ✗ bool CoolingTowerVariableSpeed_Impl::isEvaporationLossModeDefaulted() const {
224 ✗ return isEmpty(OS_CoolingTower_VariableSpeedFields::EvaporationLossMode);
225 }
226
227 ✗ double CoolingTowerVariableSpeed_Impl::evaporationLossFactor() const {
228 ✗ boost::optional<double> value = getDouble(OS_CoolingTower_VariableSpeedFields::EvaporationLossFactor, true);
229 ✗ OS_ASSERT(value);
230 ✗ return value.get();
231 }
232
233 ✗ bool CoolingTowerVariableSpeed_Impl::isEvaporationLossFactorDefaulted() const {
234 ✗ return isEmpty(OS_CoolingTower_VariableSpeedFields::EvaporationLossFactor);
235 }
236
237 ✗ boost::optional<double> CoolingTowerVariableSpeed_Impl::driftLossPercent() const {
238 ✗ return getDouble(OS_CoolingTower_VariableSpeedFields::DriftLossPercent, true);
239 }
240
241 ✗ std::string CoolingTowerVariableSpeed_Impl::blowdownCalculationMode() const {
242 ✗ boost::optional<std::string> value = getString(OS_CoolingTower_VariableSpeedFields::BlowdownCalculationMode, true);
243 ✗ OS_ASSERT(value);
244 ✗ return value.get();
245 ✗ }
246
247 ✗ bool CoolingTowerVariableSpeed_Impl::isBlowdownCalculationModeDefaulted() const {
248 ✗ return isEmpty(OS_CoolingTower_VariableSpeedFields::BlowdownCalculationMode);
249 }
250
251 ✗ boost::optional<double> CoolingTowerVariableSpeed_Impl::blowdownConcentrationRatio() const {
252 ✗ return getDouble(OS_CoolingTower_VariableSpeedFields::BlowdownConcentrationRatio, true);
253 }
254
255 ✗ boost::optional<Schedule> CoolingTowerVariableSpeed_Impl::blowdownMakeupWaterUsageSchedule() const {
256 ✗ return getObject<ModelObject>().getModelObjectTarget<Schedule>(OS_CoolingTower_VariableSpeedFields::BlowdownMakeupWaterUsageSchedule);
257 }
258
259 ✗ boost::optional<int> CoolingTowerVariableSpeed_Impl::numberofCells() const {
260 ✗ return getInt(OS_CoolingTower_VariableSpeedFields::NumberofCells, true);
261 }
262
263 ✗ std::string CoolingTowerVariableSpeed_Impl::cellControl() const {
264 ✗ boost::optional<std::string> value = getString(OS_CoolingTower_VariableSpeedFields::CellControl, true);
265 ✗ OS_ASSERT(value);
266 ✗ return value.get();
267 ✗ }
268
269 ✗ bool CoolingTowerVariableSpeed_Impl::isCellControlDefaulted() const {
270 ✗ return isEmpty(OS_CoolingTower_VariableSpeedFields::CellControl);
271 }
272
273 ✗ boost::optional<double> CoolingTowerVariableSpeed_Impl::cellMinimumWaterFlowRateFraction() const {
274 ✗ return getDouble(OS_CoolingTower_VariableSpeedFields::CellMinimumWaterFlowRateFraction, true);
275 }
276
277 ✗ boost::optional<double> CoolingTowerVariableSpeed_Impl::cellMaximumWaterFlowRateFraction() const {
278 ✗ return getDouble(OS_CoolingTower_VariableSpeedFields::CellMaximumWaterFlowRateFraction, true);
279 }
280
281 ✗ boost::optional<double> CoolingTowerVariableSpeed_Impl::sizingFactor() const {
282 ✗ return getDouble(OS_CoolingTower_VariableSpeedFields::SizingFactor, true);
283 }
284
285 4 bool CoolingTowerVariableSpeed_Impl::setModelType(boost::optional<std::string> modelType) {
286 4 bool result(false);
287
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
4 if (modelType) {
288 4 result = setString(OS_CoolingTower_VariableSpeedFields::ModelType, modelType.get());
289 } else {
290 ✗ resetModelType();
291 ✗ result = true;
292 }
293 4 return result;
294 }
295
296 ✗ void CoolingTowerVariableSpeed_Impl::resetModelType() {
297 ✗ bool result = setString(OS_CoolingTower_VariableSpeedFields::ModelType, "");
298 ✗ OS_ASSERT(result);
299 ✗ }
300
301 ✗ bool CoolingTowerVariableSpeed_Impl::setModelCoefficient(const boost::optional<ModelObject>& variableSpeedTowerCoefficient) {
302 ✗ bool result(false);
303 ✗ if (variableSpeedTowerCoefficient) {
304 ✗ result = setPointer(OS_CoolingTower_VariableSpeedFields::ModelCoefficient, variableSpeedTowerCoefficient.get().handle());
305 } else {
306 ✗ resetModelCoefficient();
307 ✗ result = true;
308 }
309 ✗ return result;
310 }
311
312 ✗ void CoolingTowerVariableSpeed_Impl::resetModelCoefficient() {
313 ✗ bool result = setString(OS_CoolingTower_VariableSpeedFields::ModelCoefficient, "");
314 ✗ OS_ASSERT(result);
315 ✗ }
316
317 10 bool CoolingTowerVariableSpeed_Impl::setDesignInletAirWetBulbTemperature(boost::optional<double> designInletAirWetBulbTemperature) {
318 10 bool result(false);
319
1/2
✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
10 if (designInletAirWetBulbTemperature) {
320 10 result = setDouble(OS_CoolingTower_VariableSpeedFields::DesignInletAirWetBulbTemperature, designInletAirWetBulbTemperature.get());
321 } else {
322 ✗ resetDesignInletAirWetBulbTemperature();
323 ✗ result = true;
324 }
325 10 return result;
326 }
327
328 ✗ void CoolingTowerVariableSpeed_Impl::resetDesignInletAirWetBulbTemperature() {
329 ✗ bool result = setString(OS_CoolingTower_VariableSpeedFields::DesignInletAirWetBulbTemperature, "");
330 ✗ OS_ASSERT(result);
331 ✗ }
332
333 7 bool CoolingTowerVariableSpeed_Impl::setDesignApproachTemperature(boost::optional<double> designApproachTemperature) {
334 7 bool result(false);
335
1/2
✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
7 if (designApproachTemperature) {
336 7 result = setDouble(OS_CoolingTower_VariableSpeedFields::DesignApproachTemperature, designApproachTemperature.get());
337 } else {
338 ✗ resetDesignApproachTemperature();
339 ✗ result = true;
340 }
341 7 return result;
342 }
343
344 ✗ void CoolingTowerVariableSpeed_Impl::resetDesignApproachTemperature() {
345 ✗ bool result = setString(OS_CoolingTower_VariableSpeedFields::DesignApproachTemperature, "");
346 ✗ OS_ASSERT(result);
347 ✗ }
348
349 7 bool CoolingTowerVariableSpeed_Impl::setDesignRangeTemperature(boost::optional<double> designRangeTemperature) {
350 7 bool result(false);
351
1/2
✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
7 if (designRangeTemperature) {
352 7 result = setDouble(OS_CoolingTower_VariableSpeedFields::DesignRangeTemperature, designRangeTemperature.get());
353 } else {
354 ✗ resetDesignRangeTemperature();
355 ✗ result = true;
356 }
357 7 return result;
358 }
359
360 ✗ void CoolingTowerVariableSpeed_Impl::resetDesignRangeTemperature() {
361 ✗ bool result = setString(OS_CoolingTower_VariableSpeedFields::DesignRangeTemperature, "");
362 ✗ OS_ASSERT(result);
363 ✗ }
364
365 3 bool CoolingTowerVariableSpeed_Impl::setDesignWaterFlowRate(boost::optional<double> designWaterFlowRate) {
366 3 bool result(false);
367
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
3 if (designWaterFlowRate) {
368 3 result = setDouble(OS_CoolingTower_VariableSpeedFields::DesignWaterFlowRate, designWaterFlowRate.get());
369 }
370 3 return result;
371 }
372
373 4 void CoolingTowerVariableSpeed_Impl::autosizeDesignWaterFlowRate() {
374
2/2
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
8 bool result = setString(OS_CoolingTower_VariableSpeedFields::DesignWaterFlowRate, "autosize");
375
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
4 OS_ASSERT(result);
376 4 }
377
378 3 bool CoolingTowerVariableSpeed_Impl::setDesignAirFlowRate(boost::optional<double> designAirFlowRate) {
379 3 bool result(false);
380
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
3 if (designAirFlowRate) {
381 3 result = setDouble(OS_CoolingTower_VariableSpeedFields::DesignAirFlowRate, designAirFlowRate.get());
382 }
383 3 return result;
384 }
385
386 4 void CoolingTowerVariableSpeed_Impl::autosizeDesignAirFlowRate() {
387
2/2
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
8 bool result = setString(OS_CoolingTower_VariableSpeedFields::DesignAirFlowRate, "autosize");
388
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
4 OS_ASSERT(result);
389 4 }
390
391 3 bool CoolingTowerVariableSpeed_Impl::setDesignFanPower(boost::optional<double> designFanPower) {
392 3 bool result(false);
393
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
3 if (designFanPower) {
394 3 result = setDouble(OS_CoolingTower_VariableSpeedFields::DesignFanPower, designFanPower.get());
395 }
396 3 return result;
397 }
398
399 4 void CoolingTowerVariableSpeed_Impl::autosizeDesignFanPower() {
400
2/2
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
8 bool result = setString(OS_CoolingTower_VariableSpeedFields::DesignFanPower, "autosize");
401
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
4 OS_ASSERT(result);
402 4 }
403
404 4 bool CoolingTowerVariableSpeed_Impl::setFanPowerRatioFunctionofAirFlowRateRatioCurve(const boost::optional<CurveCubic>& cubicCurves) {
405 4 bool result(false);
406
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
4 if (cubicCurves) {
407
3/3
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
✓ Branch 7 taken 4 times.
4 result = setPointer(OS_CoolingTower_VariableSpeedFields::FanPowerRatioFunctionofAirFlowRateRatioCurve, cubicCurves.get().handle());
408 } else {
409 ✗ resetFanPowerRatioFunctionofAirFlowRateRatioCurve();
410 ✗ result = true;
411 }
412 4 return result;
413 }
414
415 ✗ void CoolingTowerVariableSpeed_Impl::resetFanPowerRatioFunctionofAirFlowRateRatioCurve() {
416 ✗ bool result = setString(OS_CoolingTower_VariableSpeedFields::FanPowerRatioFunctionofAirFlowRateRatioCurve, "");
417 ✗ OS_ASSERT(result);
418 ✗ }
419
420 4 bool CoolingTowerVariableSpeed_Impl::setMinimumAirFlowRateRatio(boost::optional<double> minimumAirFlowRateRatio) {
421 4 bool result(false);
422
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
4 if (minimumAirFlowRateRatio) {
423 4 result = setDouble(OS_CoolingTower_VariableSpeedFields::MinimumAirFlowRateRatio, minimumAirFlowRateRatio.get());
424 } else {
425 ✗ resetMinimumAirFlowRateRatio();
426 ✗ result = true;
427 }
428 4 return result;
429 }
430
431 ✗ void CoolingTowerVariableSpeed_Impl::resetMinimumAirFlowRateRatio() {
432 ✗ bool result = setString(OS_CoolingTower_VariableSpeedFields::MinimumAirFlowRateRatio, "");
433 ✗ OS_ASSERT(result);
434 ✗ }
435
436 4 bool CoolingTowerVariableSpeed_Impl::setFractionofTowerCapacityinFreeConvectionRegime(
437 boost::optional<double> fractionofTowerCapacityinFreeConvectionRegime) {
438 4 bool result(false);
439
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
4 if (fractionofTowerCapacityinFreeConvectionRegime) {
440 4 result = setDouble(OS_CoolingTower_VariableSpeedFields::FractionofTowerCapacityinFreeConvectionRegime,
441 4 fractionofTowerCapacityinFreeConvectionRegime.get());
442 } else {
443 ✗ resetFractionofTowerCapacityinFreeConvectionRegime();
444 ✗ result = true;
445 }
446 4 return result;
447 }
448
449 ✗ void CoolingTowerVariableSpeed_Impl::resetFractionofTowerCapacityinFreeConvectionRegime() {
450 ✗ bool result = setString(OS_CoolingTower_VariableSpeedFields::FractionofTowerCapacityinFreeConvectionRegime, "");
451 ✗ OS_ASSERT(result);
452 ✗ }
453
454 4 bool CoolingTowerVariableSpeed_Impl::setBasinHeaterCapacity(boost::optional<double> basinHeaterCapacity) {
455 4 bool result(false);
456
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
4 if (basinHeaterCapacity) {
457 4 result = setDouble(OS_CoolingTower_VariableSpeedFields::BasinHeaterCapacity, basinHeaterCapacity.get());
458 } else {
459 ✗ resetBasinHeaterCapacity();
460 ✗ result = true;
461 }
462 4 return result;
463 }
464
465 ✗ void CoolingTowerVariableSpeed_Impl::resetBasinHeaterCapacity() {
466 ✗ bool result = setString(OS_CoolingTower_VariableSpeedFields::BasinHeaterCapacity, "");
467 ✗ OS_ASSERT(result);
468 ✗ }
469
470 4 bool CoolingTowerVariableSpeed_Impl::setBasinHeaterSetpointTemperature(boost::optional<double> basinHeaterSetpointTemperature) {
471 4 bool result(false);
472
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
4 if (basinHeaterSetpointTemperature) {
473 4 result = setDouble(OS_CoolingTower_VariableSpeedFields::BasinHeaterSetpointTemperature, basinHeaterSetpointTemperature.get());
474 } else {
475 ✗ resetBasinHeaterSetpointTemperature();
476 ✗ result = true;
477 }
478 4 return result;
479 }
480
481 ✗ void CoolingTowerVariableSpeed_Impl::resetBasinHeaterSetpointTemperature() {
482 ✗ bool result = setString(OS_CoolingTower_VariableSpeedFields::BasinHeaterSetpointTemperature, "");
483 ✗ OS_ASSERT(result);
484 ✗ }
485
486 ✗ bool CoolingTowerVariableSpeed_Impl::setBasinHeaterOperatingSchedule(Schedule& schedule) {
487 ✗ bool result = setSchedule(OS_CoolingTower_VariableSpeedFields::BasinHeaterOperatingSchedule, "CoolingTowerVariableSpeed",
488 "Basin Heater Operating Schedule", schedule);
489 ✗ return result;
490 }
491
492 ✗ void CoolingTowerVariableSpeed_Impl::resetBasinHeaterOperatingSchedule() {
493 ✗ bool result = setString(OS_CoolingTower_VariableSpeedFields::BasinHeaterOperatingSchedule, "");
494 ✗ OS_ASSERT(result);
495 ✗ }
496
497 4 bool CoolingTowerVariableSpeed_Impl::setEvaporationLossMode(boost::optional<std::string> evaporationLossMode) {
498 4 bool result(false);
499
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
4 if (evaporationLossMode) {
500 4 result = setString(OS_CoolingTower_VariableSpeedFields::EvaporationLossMode, evaporationLossMode.get());
501 } else {
502 ✗ resetEvaporationLossMode();
503 ✗ result = true;
504 }
505 4 return result;
506 }
507
508 ✗ void CoolingTowerVariableSpeed_Impl::resetEvaporationLossMode() {
509 ✗ bool result = setString(OS_CoolingTower_VariableSpeedFields::EvaporationLossMode, "");
510 ✗ OS_ASSERT(result);
511 ✗ }
512
513 4 bool CoolingTowerVariableSpeed_Impl::setEvaporationLossFactor(double evaporationLossFactor) {
514 4 bool result = setDouble(OS_CoolingTower_VariableSpeedFields::EvaporationLossFactor, evaporationLossFactor);
515
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
4 OS_ASSERT(result);
516 4 return result;
517 }
518
519 ✗ void CoolingTowerVariableSpeed_Impl::resetEvaporationLossFactor() {
520 ✗ bool result = setString(OS_CoolingTower_VariableSpeedFields::EvaporationLossFactor, "");
521 ✗ OS_ASSERT(result);
522 ✗ }
523
524 4 bool CoolingTowerVariableSpeed_Impl::setDriftLossPercent(boost::optional<double> driftLossPercent) {
525 4 bool result(false);
526
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
4 if (driftLossPercent) {
527 4 result = setDouble(OS_CoolingTower_VariableSpeedFields::DriftLossPercent, driftLossPercent.get());
528 } else {
529 ✗ resetDriftLossPercent();
530 ✗ result = true;
531 }
532
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
4 OS_ASSERT(result);
533 4 return result;
534 }
535
536 ✗ void CoolingTowerVariableSpeed_Impl::resetDriftLossPercent() {
537 ✗ bool result = setString(OS_CoolingTower_VariableSpeedFields::DriftLossPercent, "");
538 ✗ OS_ASSERT(result);
539 ✗ }
540
541 4 bool CoolingTowerVariableSpeed_Impl::setBlowdownCalculationMode(boost::optional<std::string> blowdownCalculationMode) {
542 4 bool result(false);
543
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
4 if (blowdownCalculationMode) {
544 4 result = setString(OS_CoolingTower_VariableSpeedFields::BlowdownCalculationMode, blowdownCalculationMode.get());
545 } else {
546 ✗ resetBlowdownCalculationMode();
547 ✗ result = true;
548 }
549 4 return result;
550 }
551
552 ✗ void CoolingTowerVariableSpeed_Impl::resetBlowdownCalculationMode() {
553 ✗ bool result = setString(OS_CoolingTower_VariableSpeedFields::BlowdownCalculationMode, "");
554 ✗ OS_ASSERT(result);
555 ✗ }
556
557 4 bool CoolingTowerVariableSpeed_Impl::setBlowdownConcentrationRatio(boost::optional<double> blowdownConcentrationRatio) {
558 4 bool result(false);
559
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
4 if (blowdownConcentrationRatio) {
560 4 result = setDouble(OS_CoolingTower_VariableSpeedFields::BlowdownConcentrationRatio, blowdownConcentrationRatio.get());
561 } else {
562 ✗ resetBlowdownConcentrationRatio();
563 ✗ result = true;
564 }
565 4 return result;
566 }
567
568 ✗ void CoolingTowerVariableSpeed_Impl::resetBlowdownConcentrationRatio() {
569 ✗ bool result = setString(OS_CoolingTower_VariableSpeedFields::BlowdownConcentrationRatio, "");
570 ✗ OS_ASSERT(result);
571 ✗ }
572
573 ✗ bool CoolingTowerVariableSpeed_Impl::setBlowdownMakeupWaterUsageSchedule(Schedule& schedule) {
574 ✗ bool result = setSchedule(OS_CoolingTower_VariableSpeedFields::BlowdownMakeupWaterUsageSchedule, "CoolingTowerVariableSpeed",
575 "Blowdown Makeup Water Usage Schedule", schedule);
576 ✗ return result;
577 }
578
579 ✗ void CoolingTowerVariableSpeed_Impl::resetBlowdownMakeupWaterUsageSchedule() {
580 ✗ bool result = setString(OS_CoolingTower_VariableSpeedFields::BlowdownMakeupWaterUsageSchedule, "");
581 ✗ OS_ASSERT(result);
582 ✗ }
583
584 3 bool CoolingTowerVariableSpeed_Impl::setNumberofCells(boost::optional<int> numberofCells) {
585 3 bool result(false);
586
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
3 if (numberofCells) {
587 3 result = setInt(OS_CoolingTower_VariableSpeedFields::NumberofCells, numberofCells.get());
588 } else {
589 ✗ resetNumberofCells();
590 ✗ result = true;
591 }
592 3 return result;
593 }
594
595 ✗ void CoolingTowerVariableSpeed_Impl::resetNumberofCells() {
596 ✗ bool result = setString(OS_CoolingTower_VariableSpeedFields::NumberofCells, "");
597 ✗ OS_ASSERT(result);
598 ✗ }
599
600 ✗ bool CoolingTowerVariableSpeed_Impl::setCellControl(boost::optional<std::string> cellControl) {
601 ✗ bool result(false);
602 ✗ if (cellControl) {
603 ✗ result = setString(OS_CoolingTower_VariableSpeedFields::CellControl, cellControl.get());
604 } else {
605 ✗ resetCellControl();
606 ✗ result = true;
607 }
608 ✗ return result;
609 }
610
611 ✗ void CoolingTowerVariableSpeed_Impl::resetCellControl() {
612 ✗ bool result = setString(OS_CoolingTower_VariableSpeedFields::CellControl, "");
613 ✗ OS_ASSERT(result);
614 ✗ }
615
616 ✗ bool CoolingTowerVariableSpeed_Impl::setCellMinimumWaterFlowRateFraction(boost::optional<double> cellMinimumWaterFlowRateFraction) {
617 ✗ bool result(false);
618 ✗ if (cellMinimumWaterFlowRateFraction) {
619 ✗ result = setDouble(OS_CoolingTower_VariableSpeedFields::CellMinimumWaterFlowRateFraction, cellMinimumWaterFlowRateFraction.get());
620 } else {
621 ✗ resetCellMinimumWaterFlowRateFraction();
622 ✗ result = true;
623 }
624 ✗ return result;
625 }
626
627 ✗ void CoolingTowerVariableSpeed_Impl::resetCellMinimumWaterFlowRateFraction() {
628 ✗ bool result = setString(OS_CoolingTower_VariableSpeedFields::CellMinimumWaterFlowRateFraction, "");
629 ✗ OS_ASSERT(result);
630 ✗ }
631
632 ✗ bool CoolingTowerVariableSpeed_Impl::setCellMaximumWaterFlowRateFraction(boost::optional<double> cellMaximumWaterFlowRateFraction) {
633 ✗ bool result(false);
634 ✗ if (cellMaximumWaterFlowRateFraction) {
635 ✗ result = setDouble(OS_CoolingTower_VariableSpeedFields::CellMaximumWaterFlowRateFraction, cellMaximumWaterFlowRateFraction.get());
636 } else {
637 ✗ resetCellMaximumWaterFlowRateFraction();
638 ✗ result = true;
639 }
640 ✗ return result;
641 }
642
643 ✗ void CoolingTowerVariableSpeed_Impl::resetCellMaximumWaterFlowRateFraction() {
644 ✗ bool result = setString(OS_CoolingTower_VariableSpeedFields::CellMaximumWaterFlowRateFraction, "");
645 ✗ OS_ASSERT(result);
646 ✗ }
647
648 4 bool CoolingTowerVariableSpeed_Impl::setSizingFactor(boost::optional<double> sizingFactor) {
649 4 bool result(false);
650
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
4 if (sizingFactor) {
651 4 result = setDouble(OS_CoolingTower_VariableSpeedFields::SizingFactor, sizingFactor.get());
652 } else {
653 ✗ resetSizingFactor();
654 ✗ result = true;
655 }
656 4 return result;
657 }
658
659 ✗ void CoolingTowerVariableSpeed_Impl::resetSizingFactor() {
660 ✗ bool result = setString(OS_CoolingTower_VariableSpeedFields::SizingFactor, "");
661 ✗ OS_ASSERT(result);
662 ✗ }
663
664 6 unsigned CoolingTowerVariableSpeed_Impl::inletPort() const {
665 6 return OS_CoolingTower_VariableSpeedFields::WaterInletNode;
666 }
667
668 234 unsigned CoolingTowerVariableSpeed_Impl::outletPort() const {
669 234 return OS_CoolingTower_VariableSpeedFields::WaterOutletNode;
670 }
671
672 3 bool CoolingTowerVariableSpeed_Impl::addToNode(Node& node) {
673
2/3
✓ Branch 1 taken 3 times.
✓ Branch 3 taken 3 times.
✗ Branch 4 not taken.
6 if (boost::optional<PlantLoop> plant = node.plantLoop()) {
674
4/5
✓ Branch 1 taken 3 times.
✓ Branch 4 taken 3 times.
✓ Branch 7 taken 3 times.
✓ Branch 10 taken 3 times.
✗ Branch 11 not taken.
6 if (plant->supplyComponent(node.handle())) {
675
1/1
✓ Branch 1 taken 3 times.
3 return StraightComponent_Impl::addToNode(node);
676 }
677 3 }
678
679 ✗ return false;
680 }
681
682 ✗ std::string CoolingTowerVariableSpeed_Impl::endUseSubcategory() const {
683 ✗ auto value = getString(OS_CoolingTower_VariableSpeedFields::EndUseSubcategory, true);
684 ✗ OS_ASSERT(value);
685 ✗ return value.get();
686 ✗ }
687
688 4 bool CoolingTowerVariableSpeed_Impl::setEndUseSubcategory(const std::string& endUseSubcategory) {
689 4 return setString(OS_CoolingTower_VariableSpeedFields::EndUseSubcategory, endUseSubcategory);
690 }
691
692 ✗ boost::optional<double> CoolingTowerVariableSpeed_Impl::autosizedDesignWaterFlowRate() const {
693 ✗ return getAutosizedValue("Design Water Flow Rate", "m3/s");
694 }
695
696 ✗ boost::optional<double> CoolingTowerVariableSpeed_Impl::autosizedDesignAirFlowRate() const {
697 ✗ return getAutosizedValue("Design Air Flow Rate", "m3/s");
698 }
699
700 ✗ boost::optional<double> CoolingTowerVariableSpeed_Impl::autosizedDesignFanPower() const {
701 ✗ return getAutosizedValue("Fan Power at Design Air Flow Rate", "W");
702 }
703
704 ✗ void CoolingTowerVariableSpeed_Impl::autosize() {
705 ✗ autosizeDesignWaterFlowRate();
706 ✗ autosizeDesignAirFlowRate();
707 ✗ autosizeDesignFanPower();
708 ✗ }
709
710 ✗ void CoolingTowerVariableSpeed_Impl::applySizingValues() {
711 ✗ boost::optional<double> val;
712 ✗ val = autosizedDesignWaterFlowRate();
713 ✗ if (val) {
714 ✗ setDesignWaterFlowRate(val.get());
715 }
716
717 ✗ val = autosizedDesignAirFlowRate();
718 ✗ if (val) {
719 ✗ setDesignAirFlowRate(val.get());
720 }
721
722 ✗ val = autosizedDesignFanPower();
723 ✗ if (val) {
724 ✗ setDesignFanPower(val.get());
725 }
726 ✗ }
727
728 1 ComponentType CoolingTowerVariableSpeed_Impl::componentType() const {
729
1/1
✓ Branch 1 taken 1 time.
1 return ComponentType::Cooling;
730 }
731
732 ✗ std::vector<FuelType> CoolingTowerVariableSpeed_Impl::coolingFuelTypes() const {
733 ✗ return {FuelType::Electricity};
734 }
735
736 ✗ std::vector<FuelType> CoolingTowerVariableSpeed_Impl::heatingFuelTypes() const {
737 ✗ return {};
738 }
739
740 ✗ std::vector<AppGFuelType> CoolingTowerVariableSpeed_Impl::appGHeatingFuelTypes() const {
741 ✗ return {};
742 }
743
744 } // namespace detail
745
746 4 CoolingTowerVariableSpeed::CoolingTowerVariableSpeed(const Model& model) : StraightComponent(CoolingTowerVariableSpeed::iddObjectType(), model) {
747
1/3
✗ Branch 2 not taken.
✓ Branch 3 taken 4 times.
✗ Branch 5 not taken.
4 OS_ASSERT(getImpl<detail::CoolingTowerVariableSpeed_Impl>());
748
749
2/2
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
4 setModelType("CoolToolsCrossFlow");
750
1/1
✓ Branch 1 taken 4 times.
4 setDesignInletAirWetBulbTemperature(25.5556);
751
1/1
✓ Branch 1 taken 4 times.
4 setDesignApproachTemperature(3.8889);
752
1/1
✓ Branch 1 taken 4 times.
4 setDesignRangeTemperature(5.5556);
753
1/1
✓ Branch 1 taken 4 times.
4 autosizeDesignWaterFlowRate();
754
1/1
✓ Branch 1 taken 4 times.
4 autosizeDesignAirFlowRate();
755
1/1
✓ Branch 1 taken 4 times.
4 autosizeDesignFanPower();
756
1/1
✓ Branch 1 taken 4 times.
4 setMinimumAirFlowRateRatio(0.2000);
757
1/1
✓ Branch 1 taken 4 times.
4 setFractionofTowerCapacityinFreeConvectionRegime(0.1250);
758
1/1
✓ Branch 1 taken 4 times.
4 setBasinHeaterCapacity(0.0000);
759
1/1
✓ Branch 1 taken 4 times.
4 setBasinHeaterSetpointTemperature(2.0000);
760
2/2
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
4 setEvaporationLossMode("SaturatedExit");
761
1/1
✓ Branch 1 taken 4 times.
4 setEvaporationLossFactor(0.2000);
762
1/1
✓ Branch 1 taken 4 times.
4 setDriftLossPercent(0.0080);
763
2/2
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
4 setBlowdownCalculationMode("ConcentrationRatio");
764
1/1
✓ Branch 1 taken 4 times.
4 setBlowdownConcentrationRatio(3.0000);
765
1/1
✓ Branch 1 taken 4 times.
4 setSizingFactor(1.0000);
766
2/2
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
4 setEndUseSubcategory("General");
767
768
1/1
✓ Branch 1 taken 4 times.
4 CurveCubic curve(model);
769
4/4
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
✓ Branch 7 taken 4 times.
✓ Branch 10 taken 4 times.
4 curve.setName(name().get() + " Fan Power Ratio Curve");
770
1/1
✓ Branch 1 taken 4 times.
4 curve.setCoefficient1Constant(-0.0093);
771
1/1
✓ Branch 1 taken 4 times.
4 curve.setCoefficient2x(0.0512);
772
1/1
✓ Branch 1 taken 4 times.
4 curve.setCoefficient3xPOW2(-0.0838);
773
1/1
✓ Branch 1 taken 4 times.
4 curve.setCoefficient4xPOW3(1.0419);
774
1/1
✓ Branch 1 taken 4 times.
4 curve.setMinimumValueofx(0.1500);
775
1/1
✓ Branch 1 taken 4 times.
4 curve.setMaximumValueofx(1.0000);
776
777
1/1
✓ Branch 1 taken 4 times.
4 setFanPowerRatioFunctionofAirFlowRateRatioCurve(curve);
778 4 }
779
780 7606 IddObjectType CoolingTowerVariableSpeed::iddObjectType() {
781
1/1
✓ Branch 1 taken 7606 times.
7606 return {IddObjectType::OS_CoolingTower_VariableSpeed};
782 }
783
784 ✗ std::vector<std::string> CoolingTowerVariableSpeed::modelTypeValues() {
785 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_CoolingTower_VariableSpeedFields::ModelType);
786 }
787
788 ✗ std::vector<std::string> CoolingTowerVariableSpeed::evaporationLossModeValues() {
789 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_CoolingTower_VariableSpeedFields::EvaporationLossMode);
790 }
791
792 ✗ std::vector<std::string> CoolingTowerVariableSpeed::blowdownCalculationModeValues() {
793 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_CoolingTower_VariableSpeedFields::BlowdownCalculationMode);
794 }
795
796 ✗ std::vector<std::string> CoolingTowerVariableSpeed::cellControlValues() {
797 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_CoolingTower_VariableSpeedFields::CellControl);
798 }
799
800 ✗ boost::optional<std::string> CoolingTowerVariableSpeed::modelType() const {
801 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->modelType();
802 }
803
804 ✗ boost::optional<ModelObject> CoolingTowerVariableSpeed::modelCoefficient() const {
805 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->modelCoefficient();
806 }
807
808 ✗ boost::optional<double> CoolingTowerVariableSpeed::designInletAirWetBulbTemperature() const {
809 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->designInletAirWetBulbTemperature();
810 }
811
812 ✗ boost::optional<double> CoolingTowerVariableSpeed::designApproachTemperature() const {
813 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->designApproachTemperature();
814 }
815
816 ✗ boost::optional<double> CoolingTowerVariableSpeed::designRangeTemperature() const {
817 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->designRangeTemperature();
818 }
819
820 ✗ boost::optional<double> CoolingTowerVariableSpeed::designWaterFlowRate() const {
821 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->designWaterFlowRate();
822 }
823
824 ✗ bool CoolingTowerVariableSpeed::isDesignWaterFlowRateAutosized() const {
825 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->isDesignWaterFlowRateAutosized();
826 }
827
828 ✗ boost::optional<double> CoolingTowerVariableSpeed::designAirFlowRate() const {
829 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->designAirFlowRate();
830 }
831
832 ✗ bool CoolingTowerVariableSpeed::isDesignAirFlowRateAutosized() const {
833 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->isDesignAirFlowRateAutosized();
834 }
835
836 ✗ boost::optional<double> CoolingTowerVariableSpeed::designFanPower() const {
837 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->designFanPower();
838 }
839
840 ✗ bool CoolingTowerVariableSpeed::isDesignFanPowerAutosized() const {
841 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->isDesignFanPowerAutosized();
842 }
843
844 ✗ boost::optional<CurveCubic> CoolingTowerVariableSpeed::fanPowerRatioFunctionofAirFlowRateRatioCurve() const {
845 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->fanPowerRatioFunctionofAirFlowRateRatioCurve();
846 }
847
848 ✗ boost::optional<double> CoolingTowerVariableSpeed::minimumAirFlowRateRatio() const {
849 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->minimumAirFlowRateRatio();
850 }
851
852 ✗ boost::optional<double> CoolingTowerVariableSpeed::fractionofTowerCapacityinFreeConvectionRegime() const {
853 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->fractionofTowerCapacityinFreeConvectionRegime();
854 }
855
856 ✗ boost::optional<double> CoolingTowerVariableSpeed::basinHeaterCapacity() const {
857 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->basinHeaterCapacity();
858 }
859
860 ✗ boost::optional<double> CoolingTowerVariableSpeed::basinHeaterSetpointTemperature() const {
861 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->basinHeaterSetpointTemperature();
862 }
863
864 ✗ boost::optional<Schedule> CoolingTowerVariableSpeed::basinHeaterOperatingSchedule() const {
865 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->basinHeaterOperatingSchedule();
866 }
867
868 ✗ std::string CoolingTowerVariableSpeed::evaporationLossMode() const {
869 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->evaporationLossMode();
870 }
871
872 ✗ bool CoolingTowerVariableSpeed::isEvaporationLossModeDefaulted() const {
873 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->isEvaporationLossModeDefaulted();
874 }
875
876 ✗ double CoolingTowerVariableSpeed::evaporationLossFactor() const {
877 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->evaporationLossFactor();
878 }
879
880 ✗ bool CoolingTowerVariableSpeed::isEvaporationLossFactorDefaulted() const {
881 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->isEvaporationLossFactorDefaulted();
882 }
883
884 ✗ boost::optional<double> CoolingTowerVariableSpeed::driftLossPercent() const {
885 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->driftLossPercent();
886 }
887
888 ✗ std::string CoolingTowerVariableSpeed::blowdownCalculationMode() const {
889 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->blowdownCalculationMode();
890 }
891
892 ✗ bool CoolingTowerVariableSpeed::isBlowdownCalculationModeDefaulted() const {
893 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->isBlowdownCalculationModeDefaulted();
894 }
895
896 ✗ boost::optional<double> CoolingTowerVariableSpeed::blowdownConcentrationRatio() const {
897 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->blowdownConcentrationRatio();
898 }
899
900 ✗ boost::optional<Schedule> CoolingTowerVariableSpeed::blowdownMakeupWaterUsageSchedule() const {
901 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->blowdownMakeupWaterUsageSchedule();
902 }
903
904 ✗ boost::optional<int> CoolingTowerVariableSpeed::numberofCells() const {
905 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->numberofCells();
906 }
907
908 ✗ std::string CoolingTowerVariableSpeed::cellControl() const {
909 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->cellControl();
910 }
911
912 ✗ bool CoolingTowerVariableSpeed::isCellControlDefaulted() const {
913 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->isCellControlDefaulted();
914 }
915
916 ✗ boost::optional<double> CoolingTowerVariableSpeed::cellMinimumWaterFlowRateFraction() const {
917 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->cellMinimumWaterFlowRateFraction();
918 }
919
920 ✗ boost::optional<double> CoolingTowerVariableSpeed::cellMaximumWaterFlowRateFraction() const {
921 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->cellMaximumWaterFlowRateFraction();
922 }
923
924 ✗ boost::optional<double> CoolingTowerVariableSpeed::sizingFactor() const {
925 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->sizingFactor();
926 }
927
928 4 bool CoolingTowerVariableSpeed::setModelType(const std::string& modelType) {
929
2/2
✓ Branch 3 taken 4 times.
✓ Branch 6 taken 4 times.
4 return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->setModelType(modelType);
930 }
931
932 ✗ void CoolingTowerVariableSpeed::resetModelType() {
933 ✗ getImpl<detail::CoolingTowerVariableSpeed_Impl>()->resetModelType();
934 ✗ }
935
936 ✗ bool CoolingTowerVariableSpeed::setModelCoefficient(const ModelObject& variableSpeedTowerCoefficient) {
937 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->setModelCoefficient(variableSpeedTowerCoefficient);
938 }
939
940 ✗ void CoolingTowerVariableSpeed::resetModelCoefficient() {
941 ✗ getImpl<detail::CoolingTowerVariableSpeed_Impl>()->resetModelCoefficient();
942 ✗ }
943
944 10 bool CoolingTowerVariableSpeed::setDesignInletAirWetBulbTemperature(double designInletAirWetBulbTemperature) {
945
2/2
✓ Branch 3 taken 10 times.
✓ Branch 6 taken 10 times.
10 return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->setDesignInletAirWetBulbTemperature(designInletAirWetBulbTemperature);
946 }
947
948 ✗ void CoolingTowerVariableSpeed::resetDesignInletAirWetBulbTemperature() {
949 ✗ getImpl<detail::CoolingTowerVariableSpeed_Impl>()->resetDesignInletAirWetBulbTemperature();
950 ✗ }
951
952 7 bool CoolingTowerVariableSpeed::setDesignApproachTemperature(double designApproachTemperature) {
953
2/2
✓ Branch 3 taken 7 times.
✓ Branch 6 taken 7 times.
7 return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->setDesignApproachTemperature(designApproachTemperature);
954 }
955
956 ✗ void CoolingTowerVariableSpeed::resetDesignApproachTemperature() {
957 ✗ getImpl<detail::CoolingTowerVariableSpeed_Impl>()->resetDesignApproachTemperature();
958 ✗ }
959
960 7 bool CoolingTowerVariableSpeed::setDesignRangeTemperature(double designRangeTemperature) {
961
2/2
✓ Branch 3 taken 7 times.
✓ Branch 6 taken 7 times.
7 return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->setDesignRangeTemperature(designRangeTemperature);
962 }
963
964 ✗ void CoolingTowerVariableSpeed::resetDesignRangeTemperature() {
965 ✗ getImpl<detail::CoolingTowerVariableSpeed_Impl>()->resetDesignRangeTemperature();
966 ✗ }
967
968 3 bool CoolingTowerVariableSpeed::setDesignWaterFlowRate(double designWaterFlowRate) {
969
2/2
✓ Branch 3 taken 3 times.
✓ Branch 6 taken 3 times.
3 return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->setDesignWaterFlowRate(designWaterFlowRate);
970 }
971
972 4 void CoolingTowerVariableSpeed::autosizeDesignWaterFlowRate() {
973
1/1
✓ Branch 3 taken 4 times.
4 getImpl<detail::CoolingTowerVariableSpeed_Impl>()->autosizeDesignWaterFlowRate();
974 4 }
975
976 3 bool CoolingTowerVariableSpeed::setDesignAirFlowRate(double designAirFlowRate) {
977
2/2
✓ Branch 3 taken 3 times.
✓ Branch 6 taken 3 times.
3 return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->setDesignAirFlowRate(designAirFlowRate);
978 }
979
980 4 void CoolingTowerVariableSpeed::autosizeDesignAirFlowRate() {
981
1/1
✓ Branch 3 taken 4 times.
4 getImpl<detail::CoolingTowerVariableSpeed_Impl>()->autosizeDesignAirFlowRate();
982 4 }
983
984 3 bool CoolingTowerVariableSpeed::setDesignFanPower(double designFanPower) {
985
2/2
✓ Branch 3 taken 3 times.
✓ Branch 6 taken 3 times.
3 return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->setDesignFanPower(designFanPower);
986 }
987
988 4 void CoolingTowerVariableSpeed::autosizeDesignFanPower() {
989
1/1
✓ Branch 3 taken 4 times.
4 getImpl<detail::CoolingTowerVariableSpeed_Impl>()->autosizeDesignFanPower();
990 4 }
991
992 4 bool CoolingTowerVariableSpeed::setFanPowerRatioFunctionofAirFlowRateRatioCurve(const CurveCubic& curve) {
993
2/2
✓ Branch 3 taken 4 times.
✓ Branch 6 taken 4 times.
4 return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->setFanPowerRatioFunctionofAirFlowRateRatioCurve(curve);
994 }
995
996 ✗ void CoolingTowerVariableSpeed::resetFanPowerRatioFunctionofAirFlowRateRatioCurve() {
997 ✗ getImpl<detail::CoolingTowerVariableSpeed_Impl>()->resetFanPowerRatioFunctionofAirFlowRateRatioCurve();
998 ✗ }
999
1000 4 bool CoolingTowerVariableSpeed::setMinimumAirFlowRateRatio(double minimumAirFlowRateRatio) {
1001
2/2
✓ Branch 3 taken 4 times.
✓ Branch 6 taken 4 times.
4 return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->setMinimumAirFlowRateRatio(minimumAirFlowRateRatio);
1002 }
1003
1004 ✗ void CoolingTowerVariableSpeed::resetMinimumAirFlowRateRatio() {
1005 ✗ getImpl<detail::CoolingTowerVariableSpeed_Impl>()->resetMinimumAirFlowRateRatio();
1006 ✗ }
1007
1008 4 bool CoolingTowerVariableSpeed::setFractionofTowerCapacityinFreeConvectionRegime(double fractionofTowerCapacityinFreeConvectionRegime) {
1009
2/2
✓ Branch 3 taken 4 times.
✓ Branch 6 taken 4 times.
8 return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->setFractionofTowerCapacityinFreeConvectionRegime(
1010 8 fractionofTowerCapacityinFreeConvectionRegime);
1011 }
1012
1013 ✗ void CoolingTowerVariableSpeed::resetFractionofTowerCapacityinFreeConvectionRegime() {
1014 ✗ getImpl<detail::CoolingTowerVariableSpeed_Impl>()->resetFractionofTowerCapacityinFreeConvectionRegime();
1015 ✗ }
1016
1017 4 bool CoolingTowerVariableSpeed::setBasinHeaterCapacity(double basinHeaterCapacity) {
1018
2/2
✓ Branch 3 taken 4 times.
✓ Branch 6 taken 4 times.
4 return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->setBasinHeaterCapacity(basinHeaterCapacity);
1019 }
1020
1021 ✗ void CoolingTowerVariableSpeed::resetBasinHeaterCapacity() {
1022 ✗ getImpl<detail::CoolingTowerVariableSpeed_Impl>()->resetBasinHeaterCapacity();
1023 ✗ }
1024
1025 4 bool CoolingTowerVariableSpeed::setBasinHeaterSetpointTemperature(double basinHeaterSetpointTemperature) {
1026
2/2
✓ Branch 3 taken 4 times.
✓ Branch 6 taken 4 times.
4 return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->setBasinHeaterSetpointTemperature(basinHeaterSetpointTemperature);
1027 }
1028
1029 ✗ void CoolingTowerVariableSpeed::resetBasinHeaterSetpointTemperature() {
1030 ✗ getImpl<detail::CoolingTowerVariableSpeed_Impl>()->resetBasinHeaterSetpointTemperature();
1031 ✗ }
1032
1033 ✗ bool CoolingTowerVariableSpeed::setBasinHeaterOperatingSchedule(Schedule& schedule) {
1034 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->setBasinHeaterOperatingSchedule(schedule);
1035 }
1036
1037 ✗ void CoolingTowerVariableSpeed::resetBasinHeaterOperatingSchedule() {
1038 ✗ getImpl<detail::CoolingTowerVariableSpeed_Impl>()->resetBasinHeaterOperatingSchedule();
1039 ✗ }
1040
1041 4 bool CoolingTowerVariableSpeed::setEvaporationLossMode(const std::string& evaporationLossMode) {
1042
2/2
✓ Branch 3 taken 4 times.
✓ Branch 6 taken 4 times.
4 return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->setEvaporationLossMode(evaporationLossMode);
1043 }
1044
1045 ✗ void CoolingTowerVariableSpeed::resetEvaporationLossMode() {
1046 ✗ getImpl<detail::CoolingTowerVariableSpeed_Impl>()->resetEvaporationLossMode();
1047 ✗ }
1048
1049 4 bool CoolingTowerVariableSpeed::setEvaporationLossFactor(double evaporationLossFactor) {
1050
1/1
✓ Branch 3 taken 4 times.
4 return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->setEvaporationLossFactor(evaporationLossFactor);
1051 }
1052
1053 ✗ void CoolingTowerVariableSpeed::resetEvaporationLossFactor() {
1054 ✗ getImpl<detail::CoolingTowerVariableSpeed_Impl>()->resetEvaporationLossFactor();
1055 ✗ }
1056
1057 4 bool CoolingTowerVariableSpeed::setDriftLossPercent(double driftLossPercent) {
1058
2/2
✓ Branch 3 taken 4 times.
✓ Branch 6 taken 4 times.
4 return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->setDriftLossPercent(driftLossPercent);
1059 }
1060
1061 ✗ void CoolingTowerVariableSpeed::resetDriftLossPercent() {
1062 ✗ getImpl<detail::CoolingTowerVariableSpeed_Impl>()->resetDriftLossPercent();
1063 ✗ }
1064
1065 4 bool CoolingTowerVariableSpeed::setBlowdownCalculationMode(const std::string& blowdownCalculationMode) {
1066
2/2
✓ Branch 3 taken 4 times.
✓ Branch 6 taken 4 times.
4 return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->setBlowdownCalculationMode(blowdownCalculationMode);
1067 }
1068
1069 ✗ void CoolingTowerVariableSpeed::resetBlowdownCalculationMode() {
1070 ✗ getImpl<detail::CoolingTowerVariableSpeed_Impl>()->resetBlowdownCalculationMode();
1071 ✗ }
1072
1073 4 bool CoolingTowerVariableSpeed::setBlowdownConcentrationRatio(double blowdownConcentrationRatio) {
1074
2/2
✓ Branch 3 taken 4 times.
✓ Branch 6 taken 4 times.
4 return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->setBlowdownConcentrationRatio(blowdownConcentrationRatio);
1075 }
1076
1077 ✗ void CoolingTowerVariableSpeed::resetBlowdownConcentrationRatio() {
1078 ✗ getImpl<detail::CoolingTowerVariableSpeed_Impl>()->resetBlowdownConcentrationRatio();
1079 ✗ }
1080
1081 ✗ bool CoolingTowerVariableSpeed::setBlowdownMakeupWaterUsageSchedule(Schedule& schedule) {
1082 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->setBlowdownMakeupWaterUsageSchedule(schedule);
1083 }
1084
1085 ✗ void CoolingTowerVariableSpeed::resetBlowdownMakeupWaterUsageSchedule() {
1086 ✗ getImpl<detail::CoolingTowerVariableSpeed_Impl>()->resetBlowdownMakeupWaterUsageSchedule();
1087 ✗ }
1088
1089 3 bool CoolingTowerVariableSpeed::setNumberofCells(int numberofCells) {
1090
2/2
✓ Branch 3 taken 3 times.
✓ Branch 6 taken 3 times.
3 return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->setNumberofCells(numberofCells);
1091 }
1092
1093 ✗ void CoolingTowerVariableSpeed::resetNumberofCells() {
1094 ✗ getImpl<detail::CoolingTowerVariableSpeed_Impl>()->resetNumberofCells();
1095 ✗ }
1096
1097 ✗ bool CoolingTowerVariableSpeed::setCellControl(const std::string& cellControl) {
1098 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->setCellControl(cellControl);
1099 }
1100
1101 ✗ void CoolingTowerVariableSpeed::resetCellControl() {
1102 ✗ getImpl<detail::CoolingTowerVariableSpeed_Impl>()->resetCellControl();
1103 ✗ }
1104
1105 ✗ bool CoolingTowerVariableSpeed::setCellMinimumWaterFlowRateFraction(double cellMinimumWaterFlowRateFraction) {
1106 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->setCellMinimumWaterFlowRateFraction(cellMinimumWaterFlowRateFraction);
1107 }
1108
1109 ✗ void CoolingTowerVariableSpeed::resetCellMinimumWaterFlowRateFraction() {
1110 ✗ getImpl<detail::CoolingTowerVariableSpeed_Impl>()->resetCellMinimumWaterFlowRateFraction();
1111 ✗ }
1112
1113 ✗ bool CoolingTowerVariableSpeed::setCellMaximumWaterFlowRateFraction(double cellMaximumWaterFlowRateFraction) {
1114 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->setCellMaximumWaterFlowRateFraction(cellMaximumWaterFlowRateFraction);
1115 }
1116
1117 ✗ void CoolingTowerVariableSpeed::resetCellMaximumWaterFlowRateFraction() {
1118 ✗ getImpl<detail::CoolingTowerVariableSpeed_Impl>()->resetCellMaximumWaterFlowRateFraction();
1119 ✗ }
1120
1121 4 bool CoolingTowerVariableSpeed::setSizingFactor(double sizingFactor) {
1122
2/2
✓ Branch 3 taken 4 times.
✓ Branch 6 taken 4 times.
4 return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->setSizingFactor(sizingFactor);
1123 }
1124
1125 ✗ void CoolingTowerVariableSpeed::resetSizingFactor() {
1126 ✗ getImpl<detail::CoolingTowerVariableSpeed_Impl>()->resetSizingFactor();
1127 ✗ }
1128
1129 ✗ std::string CoolingTowerVariableSpeed::endUseSubcategory() const {
1130 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->endUseSubcategory();
1131 }
1132
1133 4 bool CoolingTowerVariableSpeed::setEndUseSubcategory(const std::string& endUseSubcategory) {
1134
1/1
✓ Branch 3 taken 4 times.
4 return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->setEndUseSubcategory(endUseSubcategory);
1135 }
1136
1137 /// @cond
1138 ✗ CoolingTowerVariableSpeed::CoolingTowerVariableSpeed(std::shared_ptr<detail::CoolingTowerVariableSpeed_Impl> impl)
1139 ✗ : StraightComponent(std::move(impl)) {}
1140 /// @endcond
1141
1142 ✗ boost::optional<double> CoolingTowerVariableSpeed::autosizedDesignWaterFlowRate() const {
1143 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->autosizedDesignWaterFlowRate();
1144 }
1145
1146 ✗ boost::optional<double> CoolingTowerVariableSpeed::autosizedDesignAirFlowRate() const {
1147 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->autosizedDesignAirFlowRate();
1148 }
1149
1150 ✗ boost::optional<double> CoolingTowerVariableSpeed::autosizedDesignFanPower() const {
1151 ✗ return getImpl<detail::CoolingTowerVariableSpeed_Impl>()->autosizedDesignFanPower();
1152 }
1153
1154 } // namespace model
1155 } // namespace openstudio
1156