GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 45.1% 125 / 0 / 277
Functions: 50.6% 40 / 0 / 79
Branches: 31.1% 66 / 0 / 212

src/model/CoilHeatingWaterBaseboard.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 "CoilHeatingWaterBaseboard.hpp"
7 #include "CoilHeatingWaterBaseboard_Impl.hpp"
8 #include "Node.hpp"
9 #include "Node_Impl.hpp"
10 #include "PlantLoop.hpp"
11 #include "PlantLoop_Impl.hpp"
12 #include "ZoneHVACBaseboardConvectiveWater.hpp"
13 #include "ZoneHVACBaseboardConvectiveWater_Impl.hpp"
14
15 #include <utilities/idd/OS_Coil_Heating_Water_Baseboard_FieldEnums.hxx>
16 #include <utilities/idd/IddEnums.hxx>
17 #include <utilities/idd/IddFactory.hxx>
18
19 #include "../utilities/core/Assert.hpp"
20 #include "../utilities/data/DataEnums.hpp"
21
22 namespace openstudio {
23 namespace model {
24
25 namespace detail {
26
27 5 CoilHeatingWaterBaseboard_Impl::CoilHeatingWaterBaseboard_Impl(const IdfObject& idfObject, Model_Impl* model, bool keepHandle)
28 5 : StraightComponent_Impl(idfObject, model, keepHandle) {
29
4/6
✓ Branch 1 taken 5 times.
✓ Branch 4 taken 5 times.
✓ Branch 7 taken 5 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 5 times.
✗ Branch 13 not taken.
5 OS_ASSERT(idfObject.iddObject().type() == CoilHeatingWaterBaseboard::iddObjectType());
30 5 }
31
32 ✗ CoilHeatingWaterBaseboard_Impl::CoilHeatingWaterBaseboard_Impl(const openstudio::detail::WorkspaceObject_Impl& other, Model_Impl* model,
33 ✗ bool keepHandle)
34 ✗ : StraightComponent_Impl(other, model, keepHandle) {
35 ✗ OS_ASSERT(other.iddObject().type() == CoilHeatingWaterBaseboard::iddObjectType());
36 ✗ }
37
38 ✗ CoilHeatingWaterBaseboard_Impl::CoilHeatingWaterBaseboard_Impl(const CoilHeatingWaterBaseboard_Impl& other, Model_Impl* model, bool keepHandle)
39 ✗ : StraightComponent_Impl(other, model, keepHandle) {}
40
41 ✗ const std::vector<std::string>& CoilHeatingWaterBaseboard_Impl::outputVariableNames() const {
42 ✗ static const std::vector<std::string> result;
43 ✗ return result;
44 }
45
46 ✗ IddObjectType CoilHeatingWaterBaseboard_Impl::iddObjectType() const {
47 ✗ return CoilHeatingWaterBaseboard::iddObjectType();
48 }
49 3 unsigned CoilHeatingWaterBaseboard_Impl::inletPort() const {
50 3 return OS_Coil_Heating_Water_BaseboardFields::WaterInletNodeName;
51 }
52
53 4 unsigned CoilHeatingWaterBaseboard_Impl::outletPort() const {
54 4 return OS_Coil_Heating_Water_BaseboardFields::WaterOutletNodeName;
55 }
56
57 ✗ boost::optional<ZoneHVACComponent> CoilHeatingWaterBaseboard_Impl::containingZoneHVACComponent() const {
58 // this coil can only be found in a ZoneHVACBaseboardConvectiveWater
59 // check all ZoneHVACBaseboardConvectiveWaters in the model, seeing if this coil
60 // is inside of one of them. Return the one it is inside of
61
62 // declare a vector to hold all of the zoneHVACBaseboardConvectiveWater
63 ✗ std::vector<ZoneHVACBaseboardConvectiveWater> zoneHVACBaseboardConvectiveWaters;
64 // populate the vector with all of them
65 ✗ zoneHVACBaseboardConvectiveWaters = this->model().getConcreteModelObjects<ZoneHVACBaseboardConvectiveWater>();
66 // loop through each one, seeing if the coil is contained by the zonehvacbaseboard
67 ✗ for (const auto& zoneHVACBaseboardConvectiveWater : zoneHVACBaseboardConvectiveWaters) {
68 ✗ if (boost::optional<HVACComponent> coil = zoneHVACBaseboardConvectiveWater.heatingCoil()) {
69 ✗ if (coil->handle() == this->handle()) //if the handles match, this coil is inside of a zonehvacbaseboard
70 {
71 ✗ return zoneHVACBaseboardConvectiveWater;
72 }
73 ✗ }
74 }
75
76 // if the coil isn't inside any zonehvacbaseboards (which currently should never happen), return nothing
77 ✗ return boost::none;
78 ✗ }
79
80 ✗ std::string CoilHeatingWaterBaseboard_Impl::heatingDesignCapacityMethod() const {
81 ✗ boost::optional<std::string> value = getString(OS_Coil_Heating_Water_BaseboardFields::HeatingDesignCapacityMethod, true);
82 ✗ OS_ASSERT(value);
83 ✗ return value.get();
84 ✗ }
85
86 ✗ boost::optional<double> CoilHeatingWaterBaseboard_Impl::heatingDesignCapacity() const {
87 ✗ return getDouble(OS_Coil_Heating_Water_BaseboardFields::HeatingDesignCapacity, true);
88 }
89
90 ✗ bool CoilHeatingWaterBaseboard_Impl::isHeatingDesignCapacityAutosized() const {
91 ✗ bool result = false;
92 ✗ boost::optional<std::string> value = getString(OS_Coil_Heating_Water_BaseboardFields::HeatingDesignCapacity, true);
93 ✗ if (value) {
94 ✗ result = openstudio::istringEqual(value.get(), "autosize");
95 }
96 ✗ return result;
97 ✗ }
98
99 ✗ double CoilHeatingWaterBaseboard_Impl::heatingDesignCapacityPerFloorArea() const {
100 ✗ boost::optional<double> value = getDouble(OS_Coil_Heating_Water_BaseboardFields::HeatingDesignCapacityPerFloorArea, true);
101 ✗ OS_ASSERT(value);
102 ✗ return value.get();
103 }
104
105 ✗ double CoilHeatingWaterBaseboard_Impl::fractionofAutosizedHeatingDesignCapacity() const {
106 ✗ boost::optional<double> value = getDouble(OS_Coil_Heating_Water_BaseboardFields::FractionofAutosizedHeatingDesignCapacity, true);
107 ✗ OS_ASSERT(value);
108 ✗ return value.get();
109 }
110
111 2 boost::optional<double> CoilHeatingWaterBaseboard_Impl::uFactorTimesAreaValue() const {
112 2 return getDouble(OS_Coil_Heating_Water_BaseboardFields::UFactorTimesAreaValue, true);
113 }
114
115 2 bool CoilHeatingWaterBaseboard_Impl::isUFactorTimesAreaValueDefaulted() const {
116 2 return isEmpty(OS_Coil_Heating_Water_BaseboardFields::UFactorTimesAreaValue);
117 }
118
119 ✗ bool CoilHeatingWaterBaseboard_Impl::isUFactorTimesAreaValueAutosized() const {
120 ✗ bool result = false;
121 ✗ boost::optional<std::string> value = getString(OS_Coil_Heating_Water_BaseboardFields::UFactorTimesAreaValue, true);
122 ✗ if (value) {
123 ✗ result = openstudio::istringEqual(value.get(), "autosize");
124 }
125 ✗ return result;
126 ✗ }
127
128 2 boost::optional<double> CoilHeatingWaterBaseboard_Impl::maximumWaterFlowRate() const {
129 2 return getDouble(OS_Coil_Heating_Water_BaseboardFields::MaximumWaterFlowRate, true);
130 }
131
132 ✗ bool CoilHeatingWaterBaseboard_Impl::isMaximumWaterFlowRateDefaulted() const {
133 ✗ return isEmpty(OS_Coil_Heating_Water_BaseboardFields::MaximumWaterFlowRate);
134 }
135
136 2 bool CoilHeatingWaterBaseboard_Impl::isMaximumWaterFlowRateAutosized() const {
137 2 bool result = false;
138
1/1
✓ Branch 1 taken 2 times.
2 boost::optional<std::string> value = getString(OS_Coil_Heating_Water_BaseboardFields::MaximumWaterFlowRate, true);
139
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
2 if (value) {
140
3/3
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
✓ Branch 7 taken 2 times.
4 result = openstudio::istringEqual(value.get(), "autosize");
141 }
142 2 return result;
143 2 }
144
145 2 double CoilHeatingWaterBaseboard_Impl::convergenceTolerance() const {
146
1/1
✓ Branch 1 taken 2 times.
2 boost::optional<double> value = getDouble(OS_Coil_Heating_Water_BaseboardFields::ConvergenceTolerance, true);
147
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✗ Branch 4 not taken.
2 OS_ASSERT(value);
148
1/1
✓ Branch 1 taken 2 times.
4 return value.get();
149 }
150
151 2 bool CoilHeatingWaterBaseboard_Impl::isConvergenceToleranceDefaulted() const {
152 2 return isEmpty(OS_Coil_Heating_Water_BaseboardFields::ConvergenceTolerance);
153 }
154
155 5 bool CoilHeatingWaterBaseboard_Impl::setHeatingDesignCapacityMethod(const std::string& heatingDesignCapacityMethod) {
156 5 bool result = setString(OS_Coil_Heating_Water_BaseboardFields::HeatingDesignCapacityMethod, heatingDesignCapacityMethod);
157 5 return result;
158 }
159
160 ✗ bool CoilHeatingWaterBaseboard_Impl::setHeatingDesignCapacity(boost::optional<double> heatingDesignCapacity) {
161 ✗ bool result(false);
162 ✗ if (heatingDesignCapacity) {
163 ✗ result = setDouble(OS_Coil_Heating_Water_BaseboardFields::HeatingDesignCapacity, heatingDesignCapacity.get());
164 }
165 ✗ return result;
166 }
167
168 5 void CoilHeatingWaterBaseboard_Impl::autosizeHeatingDesignCapacity() {
169
2/2
✓ Branch 1 taken 5 times.
✓ Branch 4 taken 5 times.
10 bool result = setString(OS_Coil_Heating_Water_BaseboardFields::HeatingDesignCapacity, "autosize");
170
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
5 OS_ASSERT(result);
171 5 }
172
173 5 bool CoilHeatingWaterBaseboard_Impl::setHeatingDesignCapacityPerFloorArea(double heatingDesignCapacityPerFloorArea) {
174 5 bool result = setDouble(OS_Coil_Heating_Water_BaseboardFields::HeatingDesignCapacityPerFloorArea, heatingDesignCapacityPerFloorArea);
175 5 return result;
176 }
177
178 5 bool CoilHeatingWaterBaseboard_Impl::setFractionofAutosizedHeatingDesignCapacity(double fractionofAutosizedHeatingDesignCapacity) {
179 bool result =
180 5 setDouble(OS_Coil_Heating_Water_BaseboardFields::FractionofAutosizedHeatingDesignCapacity, fractionofAutosizedHeatingDesignCapacity);
181 5 return result;
182 }
183
184 1 bool CoilHeatingWaterBaseboard_Impl::setUFactorTimesAreaValue(boost::optional<double> uFactorTimesAreaValue) {
185 1 bool result(false);
186
1/2
✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.
1 if (uFactorTimesAreaValue) {
187 1 result = setDouble(OS_Coil_Heating_Water_BaseboardFields::UFactorTimesAreaValue, uFactorTimesAreaValue.get());
188 } else {
189 ✗ resetUFactorTimesAreaValue();
190 ✗ result = true;
191 }
192
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
1 OS_ASSERT(result);
193 1 return result;
194 }
195
196 1 void CoilHeatingWaterBaseboard_Impl::resetUFactorTimesAreaValue() {
197
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
2 bool result = setString(OS_Coil_Heating_Water_BaseboardFields::UFactorTimesAreaValue, "");
198
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
1 OS_ASSERT(result);
199 1 }
200
201 ✗ void CoilHeatingWaterBaseboard_Impl::autosizeUFactorTimesAreaValue() {
202 ✗ bool result = setString(OS_Coil_Heating_Water_BaseboardFields::UFactorTimesAreaValue, "autosize");
203 ✗ OS_ASSERT(result);
204 ✗ }
205
206 1 bool CoilHeatingWaterBaseboard_Impl::setMaximumWaterFlowRate(boost::optional<double> maximumWaterFlowRate) {
207 1 bool result(false);
208
1/2
✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.
1 if (maximumWaterFlowRate) {
209 1 result = setDouble(OS_Coil_Heating_Water_BaseboardFields::MaximumWaterFlowRate, maximumWaterFlowRate.get());
210 } else {
211 ✗ resetMaximumWaterFlowRate();
212 ✗ result = true;
213 }
214
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
1 OS_ASSERT(result);
215 1 return result;
216 }
217
218 1 void CoilHeatingWaterBaseboard_Impl::resetMaximumWaterFlowRate() {
219
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
2 bool result = setString(OS_Coil_Heating_Water_BaseboardFields::MaximumWaterFlowRate, "");
220
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
1 OS_ASSERT(result);
221 1 }
222
223 1 void CoilHeatingWaterBaseboard_Impl::autosizeMaximumWaterFlowRate() {
224
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
2 bool result = setString(OS_Coil_Heating_Water_BaseboardFields::MaximumWaterFlowRate, "autosize");
225
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
1 OS_ASSERT(result);
226 1 }
227
228 1 bool CoilHeatingWaterBaseboard_Impl::setConvergenceTolerance(double convergenceTolerance) {
229 1 bool result = setDouble(OS_Coil_Heating_Water_BaseboardFields::ConvergenceTolerance, convergenceTolerance);
230 1 return result;
231 }
232
233 1 void CoilHeatingWaterBaseboard_Impl::resetConvergenceTolerance() {
234
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
2 bool result = setString(OS_Coil_Heating_Water_BaseboardFields::ConvergenceTolerance, "");
235
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
1 OS_ASSERT(result);
236 1 }
237
238 5 bool CoilHeatingWaterBaseboard_Impl::addToNode(Node& node) {
239
3/3
✓ Branch 1 taken 5 times.
✓ Branch 3 taken 3 times.
✓ Branch 4 taken 2 times.
10 if (boost::optional<PlantLoop> plant = node.plantLoop()) {
240
5/5
✓ Branch 1 taken 3 times.
✓ Branch 4 taken 3 times.
✓ Branch 7 taken 3 times.
✓ Branch 10 taken 2 times.
✓ Branch 11 taken 1 time.
6 if (plant->demandComponent(node.handle())) {
241
1/1
✓ Branch 1 taken 2 times.
2 return StraightComponent_Impl::addToNode(node);
242 }
243 5 }
244
245 3 return false;
246 }
247
248 ✗ boost::optional<double> CoilHeatingWaterBaseboard_Impl::autosizedHeatingDesignCapacity() const {
249 ✗ boost::optional<double> result;
250 // Get the containing ZoneHVAC equipment and get its autosized value
251 ✗ auto parentHVAC = containingZoneHVACComponent();
252 ✗ if (!parentHVAC) {
253 ✗ return result;
254 }
255 ✗ return parentHVAC->getAutosizedValue("Design Size Heating Design Capacity", "W");
256 ✗ }
257
258 ✗ boost::optional<double> CoilHeatingWaterBaseboard_Impl::autosizedUFactorTimesAreaValue() const {
259 ✗ boost::optional<double> result;
260 // Get the containing ZoneHVAC equipment and get its autosized value
261 ✗ auto parentHVAC = containingZoneHVACComponent();
262 ✗ if (!parentHVAC) {
263 ✗ return result;
264 }
265 ✗ return parentHVAC->getAutosizedValue("Design Size U-Factor Times Area Value", "W/K");
266 ✗ }
267
268 ✗ boost::optional<double> CoilHeatingWaterBaseboard_Impl::autosizedMaximumWaterFlowRate() const {
269 ✗ boost::optional<double> result;
270 // Get the containing ZoneHVAC equipment and get its autosized value
271 ✗ auto parentHVAC = containingZoneHVACComponent();
272 ✗ if (!parentHVAC) {
273 ✗ return result;
274 }
275 ✗ return parentHVAC->getAutosizedValue("Design Size Maximum Water Flow Rate", "m3/s");
276 ✗ }
277
278 ✗ void CoilHeatingWaterBaseboard_Impl::autosize() {
279 ✗ autosizeHeatingDesignCapacity();
280 ✗ autosizeUFactorTimesAreaValue();
281 ✗ autosizeMaximumWaterFlowRate();
282 ✗ }
283
284 ✗ void CoilHeatingWaterBaseboard_Impl::applySizingValues() {
285 ✗ boost::optional<double> val;
286 ✗ val = autosizedHeatingDesignCapacity();
287 ✗ if (val) {
288 ✗ setHeatingDesignCapacity(val.get());
289 }
290
291 ✗ val = autosizedUFactorTimesAreaValue();
292 ✗ if (val) {
293 ✗ setUFactorTimesAreaValue(val.get());
294 }
295
296 ✗ val = autosizedMaximumWaterFlowRate();
297 ✗ if (val) {
298 ✗ setMaximumWaterFlowRate(val.get());
299 }
300 ✗ }
301
302 ✗ ComponentType CoilHeatingWaterBaseboard_Impl::componentType() const {
303 ✗ return ComponentType::Heating;
304 }
305
306 ✗ std::vector<FuelType> CoilHeatingWaterBaseboard_Impl::coolingFuelTypes() const {
307 ✗ return {};
308 }
309
310 ✗ std::vector<FuelType> CoilHeatingWaterBaseboard_Impl::heatingFuelTypes() const {
311 ✗ if (auto p_ = plantLoop()) {
312 ✗ return p_->heatingFuelTypes();
313 ✗ }
314 ✗ return {};
315 }
316
317 ✗ std::vector<AppGFuelType> CoilHeatingWaterBaseboard_Impl::appGHeatingFuelTypes() const {
318 ✗ if (auto p_ = plantLoop()) {
319 ✗ return p_->appGHeatingFuelTypes();
320 ✗ }
321 ✗ return {};
322 }
323
324 } // namespace detail
325
326 5 CoilHeatingWaterBaseboard::CoilHeatingWaterBaseboard(const Model& model) : StraightComponent(CoilHeatingWaterBaseboard::iddObjectType(), model) {
327
1/3
✗ Branch 2 not taken.
✓ Branch 3 taken 5 times.
✗ Branch 5 not taken.
5 OS_ASSERT(getImpl<detail::CoilHeatingWaterBaseboard_Impl>());
328
329
2/2
✓ Branch 1 taken 5 times.
✓ Branch 4 taken 5 times.
5 setHeatingDesignCapacityMethod("HeatingDesignCapacity");
330
1/1
✓ Branch 1 taken 5 times.
5 autosizeHeatingDesignCapacity();
331
1/1
✓ Branch 1 taken 5 times.
5 setHeatingDesignCapacityPerFloorArea(0.0);
332
1/1
✓ Branch 1 taken 5 times.
5 setFractionofAutosizedHeatingDesignCapacity(0.8);
333 5 }
334 ✗ unsigned CoilHeatingWaterBaseboard::inletPort() const {
335 ✗ return getImpl<detail::CoilHeatingWaterBaseboard_Impl>()->inletPort();
336 }
337
338 ✗ unsigned CoilHeatingWaterBaseboard::outletPort() const {
339 ✗ return getImpl<detail::CoilHeatingWaterBaseboard_Impl>()->outletPort();
340 }
341
342 7608 IddObjectType CoilHeatingWaterBaseboard::iddObjectType() {
343
1/1
✓ Branch 1 taken 7608 times.
7608 return {IddObjectType::OS_Coil_Heating_Water_Baseboard};
344 }
345
346 ✗ std::vector<std::string> CoilHeatingWaterBaseboard::heatingDesignCapacityMethodValues() {
347 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(),
348 ✗ OS_Coil_Heating_Water_BaseboardFields::HeatingDesignCapacityMethod);
349 }
350
351 ✗ std::string CoilHeatingWaterBaseboard::heatingDesignCapacityMethod() const {
352 ✗ return getImpl<detail::CoilHeatingWaterBaseboard_Impl>()->heatingDesignCapacityMethod();
353 }
354
355 ✗ boost::optional<double> CoilHeatingWaterBaseboard::heatingDesignCapacity() const {
356 ✗ return getImpl<detail::CoilHeatingWaterBaseboard_Impl>()->heatingDesignCapacity();
357 }
358
359 ✗ bool CoilHeatingWaterBaseboard::isHeatingDesignCapacityAutosized() const {
360 ✗ return getImpl<detail::CoilHeatingWaterBaseboard_Impl>()->isHeatingDesignCapacityAutosized();
361 }
362
363 ✗ double CoilHeatingWaterBaseboard::heatingDesignCapacityPerFloorArea() const {
364 ✗ return getImpl<detail::CoilHeatingWaterBaseboard_Impl>()->heatingDesignCapacityPerFloorArea();
365 }
366
367 ✗ double CoilHeatingWaterBaseboard::fractionofAutosizedHeatingDesignCapacity() const {
368 ✗ return getImpl<detail::CoilHeatingWaterBaseboard_Impl>()->fractionofAutosizedHeatingDesignCapacity();
369 }
370
371 2 boost::optional<double> CoilHeatingWaterBaseboard::uFactorTimesAreaValue() const {
372
1/1
✓ Branch 3 taken 2 times.
2 return getImpl<detail::CoilHeatingWaterBaseboard_Impl>()->uFactorTimesAreaValue();
373 }
374
375 2 bool CoilHeatingWaterBaseboard::isUFactorTimesAreaValueDefaulted() const {
376
1/1
✓ Branch 3 taken 2 times.
2 return getImpl<detail::CoilHeatingWaterBaseboard_Impl>()->isUFactorTimesAreaValueDefaulted();
377 }
378
379 ✗ bool CoilHeatingWaterBaseboard::isUFactorTimesAreaValueAutosized() const {
380 ✗ return getImpl<detail::CoilHeatingWaterBaseboard_Impl>()->isUFactorTimesAreaValueAutosized();
381 }
382
383 2 boost::optional<double> CoilHeatingWaterBaseboard::maximumWaterFlowRate() const {
384
1/1
✓ Branch 3 taken 2 times.
2 return getImpl<detail::CoilHeatingWaterBaseboard_Impl>()->maximumWaterFlowRate();
385 }
386
387 ✗ bool CoilHeatingWaterBaseboard::isMaximumWaterFlowRateDefaulted() const {
388 ✗ return getImpl<detail::CoilHeatingWaterBaseboard_Impl>()->isMaximumWaterFlowRateDefaulted();
389 }
390
391 2 bool CoilHeatingWaterBaseboard::isMaximumWaterFlowRateAutosized() const {
392
1/1
✓ Branch 3 taken 2 times.
2 return getImpl<detail::CoilHeatingWaterBaseboard_Impl>()->isMaximumWaterFlowRateAutosized();
393 }
394
395 2 double CoilHeatingWaterBaseboard::convergenceTolerance() const {
396
1/1
✓ Branch 3 taken 2 times.
2 return getImpl<detail::CoilHeatingWaterBaseboard_Impl>()->convergenceTolerance();
397 }
398
399 2 bool CoilHeatingWaterBaseboard::isConvergenceToleranceDefaulted() const {
400
1/1
✓ Branch 3 taken 2 times.
2 return getImpl<detail::CoilHeatingWaterBaseboard_Impl>()->isConvergenceToleranceDefaulted();
401 }
402
403 5 bool CoilHeatingWaterBaseboard::setHeatingDesignCapacityMethod(const std::string& heatingDesignCapacityMethod) {
404
1/1
✓ Branch 3 taken 5 times.
5 return getImpl<detail::CoilHeatingWaterBaseboard_Impl>()->setHeatingDesignCapacityMethod(heatingDesignCapacityMethod);
405 }
406
407 ✗ bool CoilHeatingWaterBaseboard::setHeatingDesignCapacity(double heatingDesignCapacity) {
408 ✗ return getImpl<detail::CoilHeatingWaterBaseboard_Impl>()->setHeatingDesignCapacity(heatingDesignCapacity);
409 }
410
411 5 void CoilHeatingWaterBaseboard::autosizeHeatingDesignCapacity() {
412
1/1
✓ Branch 3 taken 5 times.
5 getImpl<detail::CoilHeatingWaterBaseboard_Impl>()->autosizeHeatingDesignCapacity();
413 5 }
414
415 5 bool CoilHeatingWaterBaseboard::setHeatingDesignCapacityPerFloorArea(double heatingDesignCapacityPerFloorArea) {
416
1/1
✓ Branch 3 taken 5 times.
5 return getImpl<detail::CoilHeatingWaterBaseboard_Impl>()->setHeatingDesignCapacityPerFloorArea(heatingDesignCapacityPerFloorArea);
417 }
418
419 5 bool CoilHeatingWaterBaseboard::setFractionofAutosizedHeatingDesignCapacity(double fractionofAutosizedHeatingDesignCapacity) {
420
1/1
✓ Branch 3 taken 5 times.
5 return getImpl<detail::CoilHeatingWaterBaseboard_Impl>()->setFractionofAutosizedHeatingDesignCapacity(fractionofAutosizedHeatingDesignCapacity);
421 }
422
423 1 bool CoilHeatingWaterBaseboard::setUFactorTimesAreaValue(double uFactorTimesAreaValue) {
424
2/2
✓ Branch 3 taken 1 time.
✓ Branch 6 taken 1 time.
1 return getImpl<detail::CoilHeatingWaterBaseboard_Impl>()->setUFactorTimesAreaValue(uFactorTimesAreaValue);
425 }
426
427 1 void CoilHeatingWaterBaseboard::resetUFactorTimesAreaValue() {
428
1/1
✓ Branch 3 taken 1 time.
1 getImpl<detail::CoilHeatingWaterBaseboard_Impl>()->resetUFactorTimesAreaValue();
429 1 }
430
431 ✗ void CoilHeatingWaterBaseboard::autosizeUFactorTimesAreaValue() {
432 ✗ getImpl<detail::CoilHeatingWaterBaseboard_Impl>()->autosizeUFactorTimesAreaValue();
433 ✗ }
434
435 1 bool CoilHeatingWaterBaseboard::setMaximumWaterFlowRate(double maximumWaterFlowRate) {
436
2/2
✓ Branch 3 taken 1 time.
✓ Branch 6 taken 1 time.
1 return getImpl<detail::CoilHeatingWaterBaseboard_Impl>()->setMaximumWaterFlowRate(maximumWaterFlowRate);
437 }
438
439 1 void CoilHeatingWaterBaseboard::resetMaximumWaterFlowRate() {
440
1/1
✓ Branch 3 taken 1 time.
1 getImpl<detail::CoilHeatingWaterBaseboard_Impl>()->resetMaximumWaterFlowRate();
441 1 }
442
443 1 void CoilHeatingWaterBaseboard::autosizeMaximumWaterFlowRate() {
444
1/1
✓ Branch 3 taken 1 time.
1 getImpl<detail::CoilHeatingWaterBaseboard_Impl>()->autosizeMaximumWaterFlowRate();
445 1 }
446
447 1 bool CoilHeatingWaterBaseboard::setConvergenceTolerance(double convergenceTolerance) {
448
1/1
✓ Branch 3 taken 1 time.
1 return getImpl<detail::CoilHeatingWaterBaseboard_Impl>()->setConvergenceTolerance(convergenceTolerance);
449 }
450
451 1 void CoilHeatingWaterBaseboard::resetConvergenceTolerance() {
452
1/1
✓ Branch 3 taken 1 time.
1 getImpl<detail::CoilHeatingWaterBaseboard_Impl>()->resetConvergenceTolerance();
453 1 }
454
455 ✗ CoilHeatingWaterBaseboard::CoilHeatingWaterBaseboard(std::shared_ptr<detail::CoilHeatingWaterBaseboard_Impl> impl)
456 ✗ : StraightComponent(std::move(impl)) {}
457 /// @endcond
458
459 ✗ boost::optional<double> CoilHeatingWaterBaseboard::autosizedHeatingDesignCapacity() const {
460 ✗ return getImpl<detail::CoilHeatingWaterBaseboard_Impl>()->autosizedHeatingDesignCapacity();
461 }
462
463 ✗ boost::optional<double> CoilHeatingWaterBaseboard::autosizedUFactorTimesAreaValue() const {
464 ✗ return getImpl<detail::CoilHeatingWaterBaseboard_Impl>()->autosizedUFactorTimesAreaValue();
465 }
466
467 ✗ boost::optional<double> CoilHeatingWaterBaseboard::autosizedMaximumWaterFlowRate() const {
468 ✗ return getImpl<detail::CoilHeatingWaterBaseboard_Impl>()->autosizedMaximumWaterFlowRate();
469 }
470
471 } // namespace model
472 } // namespace openstudio
473