GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 75.3% 177 / 0 / 235
Functions: 76.2% 64 / 0 / 84
Branches: 54.8% 92 / 0 / 168

src/model/ControllerWaterCoil.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 "ControllerWaterCoil.hpp"
7 #include "ControllerWaterCoil_Impl.hpp"
8 #include "Node.hpp"
9 #include "Node_Impl.hpp"
10
11 #include "../utilities/core/Assert.hpp"
12 #include "../utilities/data/DataEnums.hpp"
13
14 #include <utilities/idd/IddFactory.hxx>
15 #include <utilities/idd/OS_Controller_WaterCoil_FieldEnums.hxx>
16 #include <utilities/idd/IddEnums.hxx>
17
18 namespace openstudio {
19
20 namespace model {
21
22 namespace detail {
23
24 89 ControllerWaterCoil_Impl::ControllerWaterCoil_Impl(const IdfObject& idfObject, Model_Impl* model, bool keepHandle)
25 89 : HVACComponent_Impl(idfObject, model, keepHandle) {
26
4/6
✓ Branch 1 taken 89 times.
✓ Branch 4 taken 89 times.
✓ Branch 7 taken 89 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 89 times.
✗ Branch 13 not taken.
89 OS_ASSERT(idfObject.iddObject().type() == ControllerWaterCoil::iddObjectType());
27 89 }
28
29 ✗ ControllerWaterCoil_Impl::ControllerWaterCoil_Impl(const openstudio::detail::WorkspaceObject_Impl& other, Model_Impl* model, bool keepHandle)
30 ✗ : HVACComponent_Impl(other, model, keepHandle) {
31 ✗ OS_ASSERT(other.iddObject().type() == ControllerWaterCoil::iddObjectType());
32 ✗ }
33
34 8 ControllerWaterCoil_Impl::ControllerWaterCoil_Impl(const ControllerWaterCoil_Impl& other, Model_Impl* model, bool keepHandle)
35 8 : HVACComponent_Impl(other, model, keepHandle) {}
36
37 ✗ const std::vector<std::string>& ControllerWaterCoil_Impl::outputVariableNames() const {
38 ✗ static const std::vector<std::string> result;
39 // Not appropriate: no specific output
40 ✗ return result;
41 }
42
43 ✗ IddObjectType ControllerWaterCoil_Impl::iddObjectType() const {
44 ✗ return ControllerWaterCoil::iddObjectType();
45 }
46
47 17 std::string ControllerWaterCoil_Impl::controlVariable() const {
48
1/1
✓ Branch 1 taken 17 times.
17 boost::optional<std::string> result = getString(OS_Controller_WaterCoilFields::ControlVariable, true);
49
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 17 times.
✗ Branch 4 not taken.
17 OS_ASSERT(result);
50
2/2
✓ Branch 1 taken 17 times.
✓ Branch 4 taken 17 times.
34 return result.get();
51 17 }
52
53 3 bool ControllerWaterCoil_Impl::isControlVariableDefaulted() const {
54 3 return isEmpty(OS_Controller_WaterCoilFields::ControlVariable);
55 }
56
57 27 boost::optional<std::string> ControllerWaterCoil_Impl::action() const {
58 27 return getString(OS_Controller_WaterCoilFields::Action, true);
59 }
60
61 11 std::string ControllerWaterCoil_Impl::actuatorVariable() const {
62
1/1
✓ Branch 1 taken 11 times.
11 boost::optional<std::string> result = getString(OS_Controller_WaterCoilFields::ActuatorVariable, true);
63
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
✗ Branch 4 not taken.
11 OS_ASSERT(result);
64
2/2
✓ Branch 1 taken 11 times.
✓ Branch 4 taken 11 times.
22 return result.get();
65 11 }
66
67 3 bool ControllerWaterCoil_Impl::isActuatorVariableDefaulted() const {
68 3 return isEmpty(OS_Controller_WaterCoilFields::ActuatorVariable);
69 }
70
71 2 boost::optional<double> ControllerWaterCoil_Impl::controllerConvergenceTolerance() const {
72 2 return getDouble(OS_Controller_WaterCoilFields::ControllerConvergenceTolerance, true);
73 }
74
75 4 bool ControllerWaterCoil_Impl::isControllerConvergenceToleranceDefaulted() const {
76 4 return isEmpty(OS_Controller_WaterCoilFields::ControllerConvergenceTolerance);
77 }
78
79 10 bool ControllerWaterCoil_Impl::isControllerConvergenceToleranceAutosized() const {
80 10 bool result = false;
81
1/1
✓ Branch 1 taken 10 times.
10 boost::optional<std::string> value = getString(OS_Controller_WaterCoilFields::ControllerConvergenceTolerance, true);
82
1/2
✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
10 if (value) {
83
3/3
✓ Branch 1 taken 10 times.
✓ Branch 4 taken 10 times.
✓ Branch 7 taken 10 times.
20 result = openstudio::istringEqual(value.get(), "Autosize");
84 }
85 10 return result;
86 10 }
87
88 4 boost::optional<double> ControllerWaterCoil_Impl::maximumActuatedFlow() const {
89 4 return getDouble(OS_Controller_WaterCoilFields::MaximumActuatedFlow, true);
90 }
91
92 9 bool ControllerWaterCoil_Impl::isMaximumActuatedFlowAutosized() const {
93 9 bool result = false;
94
1/1
✓ Branch 1 taken 9 times.
9 boost::optional<std::string> value = getString(OS_Controller_WaterCoilFields::MaximumActuatedFlow, true);
95
1/2
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
9 if (value) {
96
3/3
✓ Branch 1 taken 9 times.
✓ Branch 4 taken 9 times.
✓ Branch 7 taken 9 times.
18 result = openstudio::istringEqual(value.get(), "Autosize");
97 }
98 9 return result;
99 9 }
100
101 9 double ControllerWaterCoil_Impl::minimumActuatedFlow() const {
102
1/1
✓ Branch 1 taken 9 times.
9 boost::optional<double> value = getDouble(OS_Controller_WaterCoilFields::MinimumActuatedFlow, true);
103
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
✗ Branch 4 not taken.
9 OS_ASSERT(value);
104
1/1
✓ Branch 1 taken 9 times.
18 return value.get();
105 }
106
107 1 bool ControllerWaterCoil_Impl::isMinimumActuatedFlowDefaulted() const {
108 1 return isEmpty(OS_Controller_WaterCoilFields::MinimumActuatedFlow);
109 }
110
111 4 bool ControllerWaterCoil_Impl::setControlVariable(const std::string& controlVariable) {
112 4 bool result = setString(OS_Controller_WaterCoilFields::ControlVariable, controlVariable);
113 4 return result;
114 }
115
116 1 void ControllerWaterCoil_Impl::resetControlVariable() {
117
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
2 bool result = setString(OS_Controller_WaterCoilFields::ControlVariable, "");
118
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
1 OS_ASSERT(result);
119 1 }
120
121 91 bool ControllerWaterCoil_Impl::setAction(const std::string& action) {
122 91 bool result = setString(OS_Controller_WaterCoilFields::Action, action);
123 91 return result;
124 }
125
126 ✗ void ControllerWaterCoil_Impl::resetAction() {
127 ✗ bool result = setString(OS_Controller_WaterCoilFields::Action, "");
128 ✗ OS_ASSERT(result);
129 ✗ }
130
131 2 bool ControllerWaterCoil_Impl::setActuatorVariable(const std::string& actuatorVariable) {
132 2 bool result = setString(OS_Controller_WaterCoilFields::ActuatorVariable, actuatorVariable);
133 2 return result;
134 }
135
136 1 void ControllerWaterCoil_Impl::resetActuatorVariable() {
137
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
2 bool result = setString(OS_Controller_WaterCoilFields::ActuatorVariable, "");
138
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
1 OS_ASSERT(result);
139 1 }
140
141 11 bool ControllerWaterCoil_Impl::setControllerConvergenceTolerance(double controllerConvergenceTolerance) {
142 11 bool result = setDouble(OS_Controller_WaterCoilFields::ControllerConvergenceTolerance, controllerConvergenceTolerance);
143
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
11 OS_ASSERT(result);
144 11 return result;
145 }
146
147 1 void ControllerWaterCoil_Impl::resetControllerConvergenceTolerance() {
148
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
2 bool result = setString(OS_Controller_WaterCoilFields::ControllerConvergenceTolerance, "");
149
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
1 OS_ASSERT(result);
150 1 }
151
152 1 void ControllerWaterCoil_Impl::autosizeControllerConvergenceTolerance() {
153
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
2 bool result = setString(OS_Controller_WaterCoilFields::ControllerConvergenceTolerance, "Autosize");
154
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
1 OS_ASSERT(result);
155 1 }
156
157 12 bool ControllerWaterCoil_Impl::setMaximumActuatedFlow(double maximumActuatedFlow) {
158 12 bool result = setDouble(OS_Controller_WaterCoilFields::MaximumActuatedFlow, maximumActuatedFlow);
159 12 return result;
160 }
161
162 1 void ControllerWaterCoil_Impl::resetMaximumActuatedFlow() {
163
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
2 bool result = setString(OS_Controller_WaterCoilFields::MaximumActuatedFlow, "");
164
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
1 OS_ASSERT(result);
165 1 }
166
167 ✗ void ControllerWaterCoil_Impl::autosizeMaximumActuatedFlow() {
168 ✗ bool result = setString(OS_Controller_WaterCoilFields::MaximumActuatedFlow, "Autosize");
169 ✗ OS_ASSERT(result);
170 ✗ }
171
172 12 bool ControllerWaterCoil_Impl::setMinimumActuatedFlow(double minimumActuatedFlow) {
173 12 bool result = setDouble(OS_Controller_WaterCoilFields::MinimumActuatedFlow, minimumActuatedFlow);
174 12 return result;
175 }
176
177 89 void ControllerWaterCoil_Impl::resetMinimumActuatedFlow() {
178
2/2
✓ Branch 1 taken 89 times.
✓ Branch 4 taken 89 times.
178 bool result = setString(OS_Controller_WaterCoilFields::MinimumActuatedFlow, "");
179
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 89 times.
89 OS_ASSERT(result);
180 89 }
181
182 9 boost::optional<Node> ControllerWaterCoil_Impl::sensorNode() const {
183
2/2
✓ Branch 1 taken 9 times.
✓ Branch 4 taken 9 times.
9 return this->getObject<ModelObject>().getModelObjectTarget<Node>(OS_Controller_WaterCoilFields::SensorNodeName);
184 }
185
186 9 boost::optional<Node> ControllerWaterCoil_Impl::actuatorNode() const {
187
2/2
✓ Branch 1 taken 9 times.
✓ Branch 4 taken 9 times.
9 return this->getObject<ModelObject>().getModelObjectTarget<Node>(OS_Controller_WaterCoilFields::ActuatorNodeName);
188 }
189
190 1 bool ControllerWaterCoil_Impl::setSensorNode(const Node& node) {
191
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
1 return this->setPointer(OS_Controller_WaterCoilFields::SensorNodeName, node.handle());
192 }
193
194 1 bool ControllerWaterCoil_Impl::setActuatorNode(const Node& node) {
195
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
1 return this->setPointer(OS_Controller_WaterCoilFields::ActuatorNodeName, node.handle());
196 }
197
198 89 bool ControllerWaterCoil_Impl::setWaterCoil(const HVACComponent& comp) {
199
2/2
✓ Branch 1 taken 89 times.
✓ Branch 4 taken 89 times.
89 auto result = setPointer(OS_Controller_WaterCoilFields::WaterCoilName, comp.handle());
200
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 89 times.
89 OS_ASSERT(result);
201 89 return result;
202 }
203
204 1102 boost::optional<HVACComponent> ControllerWaterCoil_Impl::waterCoil() const {
205
2/2
✓ Branch 1 taken 1102 times.
✓ Branch 4 taken 1102 times.
1102 return getObject<ModelObject>().getModelObjectTarget<HVACComponent>(OS_Controller_WaterCoilFields::WaterCoilName);
206 }
207
208 ✗ boost::optional<double> ControllerWaterCoil_Impl::autosizedControllerConvergenceTolerance() const {
209 ✗ return getAutosizedValue("Controller Convergence Tolerance", "");
210 }
211
212 ✗ boost::optional<double> ControllerWaterCoil_Impl::autosizedMaximumActuatedFlow() const {
213 ✗ return getAutosizedValue("Maximum Actuated Flow", "m3/s");
214 }
215
216 ✗ void ControllerWaterCoil_Impl::autosize() {
217 ✗ autosizeControllerConvergenceTolerance();
218 ✗ autosizeMaximumActuatedFlow();
219 ✗ }
220
221 ✗ void ControllerWaterCoil_Impl::applySizingValues() {
222 ✗ boost::optional<double> val;
223 ✗ val = autosizedControllerConvergenceTolerance();
224 ✗ if (val) {
225 ✗ setControllerConvergenceTolerance(val.get());
226 }
227
228 ✗ val = autosizedMaximumActuatedFlow();
229 ✗ if (val) {
230 ✗ setMaximumActuatedFlow(val.get());
231 }
232 ✗ }
233
234 ✗ ComponentType ControllerWaterCoil_Impl::componentType() const {
235 ✗ return ComponentType::None;
236 }
237
238 ✗ std::vector<FuelType> ControllerWaterCoil_Impl::coolingFuelTypes() const {
239 ✗ return {};
240 }
241
242 ✗ std::vector<FuelType> ControllerWaterCoil_Impl::heatingFuelTypes() const {
243 ✗ return {};
244 }
245
246 ✗ std::vector<AppGFuelType> ControllerWaterCoil_Impl::appGHeatingFuelTypes() const {
247 ✗ return {};
248 }
249
250 } // namespace detail
251
252 89 ControllerWaterCoil::ControllerWaterCoil(const Model& model) : HVACComponent(ControllerWaterCoil::iddObjectType(), model) {
253
1/3
✗ Branch 2 not taken.
✓ Branch 3 taken 89 times.
✗ Branch 5 not taken.
89 OS_ASSERT(getImpl<detail::ControllerWaterCoil_Impl>());
254
1/1
✓ Branch 1 taken 89 times.
89 resetMinimumActuatedFlow();
255 89 }
256
257 8107 IddObjectType ControllerWaterCoil::iddObjectType() {
258
1/1
✓ Branch 1 taken 8107 times.
8107 IddObjectType result(IddObjectType::OS_Controller_WaterCoil);
259 8107 return result;
260 }
261
262 ✗ std::vector<std::string> ControllerWaterCoil::validControlVariableValues() {
263 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_Controller_WaterCoilFields::ControlVariable);
264 }
265
266 ✗ std::vector<std::string> ControllerWaterCoil::validActionValues() {
267 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_Controller_WaterCoilFields::Action);
268 }
269
270 ✗ std::vector<std::string> ControllerWaterCoil::validActuatorVariableValues() {
271 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_Controller_WaterCoilFields::ActuatorVariable);
272 }
273
274 17 boost::optional<std::string> ControllerWaterCoil::controlVariable() const {
275
2/2
✓ Branch 3 taken 17 times.
✓ Branch 6 taken 17 times.
17 return getImpl<detail::ControllerWaterCoil_Impl>()->controlVariable();
276 }
277
278 2 boost::optional<HVACComponent> ControllerWaterCoil::waterCoil() const {
279
1/1
✓ Branch 3 taken 2 times.
2 return getImpl<detail::ControllerWaterCoil_Impl>()->waterCoil();
280 }
281
282 3 bool ControllerWaterCoil::isControlVariableDefaulted() const {
283
1/1
✓ Branch 3 taken 3 times.
3 return getImpl<detail::ControllerWaterCoil_Impl>()->isControlVariableDefaulted();
284 }
285
286 27 boost::optional<std::string> ControllerWaterCoil::action() const {
287
1/1
✓ Branch 3 taken 27 times.
27 return getImpl<detail::ControllerWaterCoil_Impl>()->action();
288 }
289
290 11 boost::optional<std::string> ControllerWaterCoil::actuatorVariable() const {
291
2/2
✓ Branch 3 taken 11 times.
✓ Branch 6 taken 11 times.
11 return getImpl<detail::ControllerWaterCoil_Impl>()->actuatorVariable();
292 }
293
294 3 bool ControllerWaterCoil::isActuatorVariableDefaulted() const {
295
1/1
✓ Branch 3 taken 3 times.
3 return getImpl<detail::ControllerWaterCoil_Impl>()->isActuatorVariableDefaulted();
296 }
297
298 2 boost::optional<double> ControllerWaterCoil::controllerConvergenceTolerance() const {
299
1/1
✓ Branch 3 taken 2 times.
2 return getImpl<detail::ControllerWaterCoil_Impl>()->controllerConvergenceTolerance();
300 }
301
302 4 bool ControllerWaterCoil::isControllerConvergenceToleranceDefaulted() const {
303
1/1
✓ Branch 3 taken 4 times.
4 return getImpl<detail::ControllerWaterCoil_Impl>()->isControllerConvergenceToleranceDefaulted();
304 }
305
306 10 bool ControllerWaterCoil::isControllerConvergenceToleranceAutosized() const {
307
1/1
✓ Branch 3 taken 10 times.
10 return getImpl<detail::ControllerWaterCoil_Impl>()->isControllerConvergenceToleranceAutosized();
308 }
309
310 4 boost::optional<double> ControllerWaterCoil::maximumActuatedFlow() const {
311
1/1
✓ Branch 3 taken 4 times.
4 return getImpl<detail::ControllerWaterCoil_Impl>()->maximumActuatedFlow();
312 }
313
314 9 bool ControllerWaterCoil::isMaximumActuatedFlowAutosized() const {
315
1/1
✓ Branch 3 taken 9 times.
9 return getImpl<detail::ControllerWaterCoil_Impl>()->isMaximumActuatedFlowAutosized();
316 }
317
318 9 double ControllerWaterCoil::minimumActuatedFlow() const {
319
1/1
✓ Branch 3 taken 9 times.
9 return getImpl<detail::ControllerWaterCoil_Impl>()->minimumActuatedFlow();
320 }
321
322 1 bool ControllerWaterCoil::isMinimumActuatedFlowDefaulted() const {
323
1/1
✓ Branch 3 taken 1 time.
1 return getImpl<detail::ControllerWaterCoil_Impl>()->isMinimumActuatedFlowDefaulted();
324 }
325
326 4 bool ControllerWaterCoil::setControlVariable(const std::string& controlVariable) {
327
1/1
✓ Branch 3 taken 4 times.
4 return getImpl<detail::ControllerWaterCoil_Impl>()->setControlVariable(controlVariable);
328 }
329
330 1 void ControllerWaterCoil::resetControlVariable() {
331
1/1
✓ Branch 3 taken 1 time.
1 getImpl<detail::ControllerWaterCoil_Impl>()->resetControlVariable();
332 1 }
333
334 91 bool ControllerWaterCoil::setAction(const std::string& action) {
335
1/1
✓ Branch 3 taken 91 times.
91 return getImpl<detail::ControllerWaterCoil_Impl>()->setAction(action);
336 }
337
338 ✗ void ControllerWaterCoil::resetAction() {
339 ✗ getImpl<detail::ControllerWaterCoil_Impl>()->resetAction();
340 ✗ }
341
342 2 bool ControllerWaterCoil::setActuatorVariable(const std::string& actuatorVariable) {
343
1/1
✓ Branch 3 taken 2 times.
2 return getImpl<detail::ControllerWaterCoil_Impl>()->setActuatorVariable(actuatorVariable);
344 }
345
346 1 void ControllerWaterCoil::resetActuatorVariable() {
347
1/1
✓ Branch 3 taken 1 time.
1 getImpl<detail::ControllerWaterCoil_Impl>()->resetActuatorVariable();
348 1 }
349
350 11 bool ControllerWaterCoil::setControllerConvergenceTolerance(double controllerConvergenceTolerance) {
351
1/1
✓ Branch 3 taken 11 times.
11 return getImpl<detail::ControllerWaterCoil_Impl>()->setControllerConvergenceTolerance(controllerConvergenceTolerance);
352 }
353
354 1 void ControllerWaterCoil::resetControllerConvergenceTolerance() {
355
1/1
✓ Branch 3 taken 1 time.
1 getImpl<detail::ControllerWaterCoil_Impl>()->resetControllerConvergenceTolerance();
356 1 }
357
358 1 void ControllerWaterCoil::autosizeControllerConvergenceTolerance() {
359
1/1
✓ Branch 3 taken 1 time.
1 getImpl<detail::ControllerWaterCoil_Impl>()->autosizeControllerConvergenceTolerance();
360 1 }
361
362 12 bool ControllerWaterCoil::setMaximumActuatedFlow(double maximumActuatedFlow) {
363
1/1
✓ Branch 3 taken 12 times.
12 return getImpl<detail::ControllerWaterCoil_Impl>()->setMaximumActuatedFlow(maximumActuatedFlow);
364 }
365
366 1 void ControllerWaterCoil::resetMaximumActuatedFlow() {
367
1/1
✓ Branch 3 taken 1 time.
1 getImpl<detail::ControllerWaterCoil_Impl>()->resetMaximumActuatedFlow();
368 1 }
369
370 ✗ void ControllerWaterCoil::autosizeMaximumActuatedFlow() {
371 ✗ getImpl<detail::ControllerWaterCoil_Impl>()->autosizeMaximumActuatedFlow();
372 ✗ }
373
374 12 bool ControllerWaterCoil::setMinimumActuatedFlow(double minimumActuatedFlow) {
375
1/1
✓ Branch 3 taken 12 times.
12 return getImpl<detail::ControllerWaterCoil_Impl>()->setMinimumActuatedFlow(minimumActuatedFlow);
376 }
377
378 89 void ControllerWaterCoil::resetMinimumActuatedFlow() {
379
1/1
✓ Branch 3 taken 89 times.
89 getImpl<detail::ControllerWaterCoil_Impl>()->resetMinimumActuatedFlow();
380 89 }
381
382 9 boost::optional<Node> ControllerWaterCoil::sensorNode() const {
383
1/1
✓ Branch 3 taken 9 times.
9 return getImpl<detail::ControllerWaterCoil_Impl>()->sensorNode();
384 }
385
386 9 boost::optional<Node> ControllerWaterCoil::actuatorNode() const {
387
1/1
✓ Branch 3 taken 9 times.
9 return getImpl<detail::ControllerWaterCoil_Impl>()->actuatorNode();
388 }
389
390 1 bool ControllerWaterCoil::setSensorNode(const Node& node) {
391
1/1
✓ Branch 3 taken 1 time.
1 return getImpl<detail::ControllerWaterCoil_Impl>()->setSensorNode(node);
392 }
393
394 1 bool ControllerWaterCoil::setActuatorNode(const Node& node) {
395
1/1
✓ Branch 3 taken 1 time.
1 return getImpl<detail::ControllerWaterCoil_Impl>()->setActuatorNode(node);
396 }
397
398 /// @cond
399
1/1
✓ Branch 3 taken 1229 times.
1229 ControllerWaterCoil::ControllerWaterCoil(std::shared_ptr<detail::ControllerWaterCoil_Impl> impl) : HVACComponent(std::move(impl)) {}
400 /// @endcond
401
402 ✗ boost::optional<double> ControllerWaterCoil::autosizedControllerConvergenceTolerance() const {
403 ✗ return getImpl<detail::ControllerWaterCoil_Impl>()->autosizedControllerConvergenceTolerance();
404 }
405
406 ✗ boost::optional<double> ControllerWaterCoil::autosizedMaximumActuatedFlow() const {
407 ✗ return getImpl<detail::ControllerWaterCoil_Impl>()->autosizedMaximumActuatedFlow();
408 }
409
410 } // namespace model
411
412 } // namespace openstudio
413