GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 62.7% 250 / 0 / 399
Functions: 63.8% 60 / 0 / 94
Branches: 54.2% 270 / 0 / 498

src/model/CoilHeatingWater.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 "CoilHeatingWater.hpp"
7 #include "CoilHeatingWater_Impl.hpp"
8 #include "ControllerWaterCoil.hpp"
9 #include "ControllerWaterCoil_Impl.hpp"
10 #include "Schedule.hpp"
11 #include "Schedule_Impl.hpp"
12 #include "ZoneHVACComponent.hpp"
13 #include "ZoneHVACComponent_Impl.hpp"
14 #include "ZoneHVACFourPipeFanCoil.hpp"
15 #include "ZoneHVACFourPipeFanCoil_Impl.hpp"
16 #include "ZoneHVACPackagedTerminalAirConditioner.hpp"
17 #include "ZoneHVACPackagedTerminalAirConditioner_Impl.hpp"
18 #include "ZoneHVACPackagedTerminalHeatPump.hpp"
19 #include "ZoneHVACPackagedTerminalHeatPump_Impl.hpp"
20 #include "ZoneHVACWaterToAirHeatPump.hpp"
21 #include "ZoneHVACWaterToAirHeatPump_Impl.hpp"
22 #include "ZoneHVACUnitHeater.hpp"
23 #include "ZoneHVACUnitHeater_Impl.hpp"
24 #include "ZoneHVACUnitVentilator.hpp"
25 #include "ZoneHVACUnitVentilator_Impl.hpp"
26 #include "AirLoopHVACUnitarySystem.hpp"
27 #include "AirLoopHVACUnitarySystem_Impl.hpp"
28 #include "AirLoopHVACUnitaryHeatCoolVAVChangeoverBypass.hpp"
29 #include "AirLoopHVACUnitaryHeatCoolVAVChangeoverBypass_Impl.hpp"
30 #include "AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed.hpp"
31 #include "AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed_Impl.hpp"
32 #include "Node.hpp"
33 #include "Node_Impl.hpp"
34 #include "ScheduleCompact.hpp"
35 #include "ScheduleCompact_Impl.hpp"
36 #include "AirTerminalSingleDuctConstantVolumeReheat.hpp"
37 #include "AirTerminalSingleDuctConstantVolumeReheat_Impl.hpp"
38 #include "AirTerminalSingleDuctVAVReheat.hpp"
39 #include "AirTerminalSingleDuctVAVReheat_Impl.hpp"
40 #include "AirTerminalSingleDuctVAVHeatAndCoolReheat.hpp"
41 #include "AirTerminalSingleDuctVAVHeatAndCoolReheat_Impl.hpp"
42 #include "AirTerminalSingleDuctParallelPIUReheat.hpp"
43 #include "AirTerminalSingleDuctParallelPIUReheat_Impl.hpp"
44 #include "AirTerminalSingleDuctSeriesPIUReheat.hpp"
45 #include "AirTerminalSingleDuctSeriesPIUReheat_Impl.hpp"
46 #include "AirTerminalSingleDuctConstantVolumeFourPipeInduction.hpp"
47 #include "AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl.hpp"
48 #include "AirflowNetworkEquivalentDuct.hpp"
49 #include "AirflowNetworkEquivalentDuct_Impl.hpp"
50 #include "Model.hpp"
51 #include <utilities/idd/OS_Coil_Heating_Water_FieldEnums.hxx>
52 #include <utilities/idd/IddEnums.hxx>
53 #include "../utilities/core/Compare.hpp"
54 #include "../utilities/core/Assert.hpp"
55 #include "../utilities/data/DataEnums.hpp"
56
57 namespace openstudio {
58 namespace model {
59
60 namespace detail {
61
62 127 CoilHeatingWater_Impl::CoilHeatingWater_Impl(const IdfObject& idfObject, Model_Impl* model, bool keepHandle)
63 127 : WaterToAirComponent_Impl(idfObject, model, keepHandle) {
64
4/6
✓ Branch 1 taken 127 times.
✓ Branch 4 taken 127 times.
✓ Branch 7 taken 127 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 127 times.
✗ Branch 13 not taken.
127 OS_ASSERT(idfObject.iddObject().type() == CoilHeatingWater::iddObjectType());
65 127 }
66
67 1 CoilHeatingWater_Impl::CoilHeatingWater_Impl(const openstudio::detail::WorkspaceObject_Impl& other, Model_Impl* model, bool keepHandle)
68 1 : WaterToAirComponent_Impl(other, model, keepHandle) {
69
4/6
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✗ Branch 10 not taken.
✓ Branch 11 taken 1 time.
✗ Branch 13 not taken.
1 OS_ASSERT(other.iddObject().type() == CoilHeatingWater::iddObjectType());
70 1 }
71
72 57 CoilHeatingWater_Impl::CoilHeatingWater_Impl(const CoilHeatingWater_Impl& other, Model_Impl* model, bool keepHandle)
73 57 : WaterToAirComponent_Impl(other, model, keepHandle) {}
74
75 ✗ const std::vector<std::string>& CoilHeatingWater_Impl::outputVariableNames() const {
76 static const std::vector<std::string> result{"Heating Coil Heating Energy", "Heating Coil Source Side Heat Transfer Energy",
77 ✗ "Heating Coil Heating Rate", "Heating Coil U Factor Times Area Value"};
78 ✗ return result;
79 ✗ }
80
81 114 bool CoilHeatingWater_Impl::addToNode(Node& node) {
82 114 bool success = WaterToAirComponent_Impl::addToNode(node);
83
84
12/18
✓ Branch 0 taken 114 times.
✗ Branch 1 not taken.
✓ Branch 3 taken 114 times.
✓ Branch 6 taken 94 times.
✓ Branch 7 taken 20 times.
✓ Branch 9 taken 94 times.
✓ Branch 12 taken 84 times.
✓ Branch 13 taken 10 times.
✓ Branch 14 taken 94 times.
✓ Branch 15 taken 20 times.
✓ Branch 17 taken 114 times.
✗ Branch 18 not taken.
✓ Branch 20 taken 84 times.
✓ Branch 21 taken 30 times.
✗ Branch 22 not taken.
✗ Branch 23 not taken.
✗ Branch 25 not taken.
✗ Branch 26 not taken.
114 if (success && (!containingHVACComponent()) && (!containingZoneHVACComponent())) {
85
3/3
✓ Branch 1 taken 84 times.
✓ Branch 3 taken 63 times.
✓ Branch 4 taken 21 times.
168 if (boost::optional<ModelObject> _waterInletModelObject = waterInletModelObject()) {
86
3/3
✓ Branch 1 taken 63 times.
✓ Branch 3 taken 6 times.
✓ Branch 4 taken 57 times.
126 if (auto oldController = controllerWaterCoil()) {
87
6/7
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
✓ Branch 7 taken 6 times.
✓ Branch 10 taken 6 times.
✓ Branch 13 taken 6 times.
✗ Branch 17 not taken.
✓ Branch 18 taken 6 times.
12 if (!openstudio::istringEqual(oldController->action().get(), "Normal")) {
88 ✗ LOG(Warn, briefDescription()
89 << " has an existing ControllerWaterCoil with action set to something else than 'Normal'. Make sure this is what you want");
90 }
91 } else {
92
1/1
✓ Branch 1 taken 57 times.
57 Model t_model = model();
93
1/1
✓ Branch 1 taken 57 times.
57 ControllerWaterCoil controller(t_model);
94
2/2
✓ Branch 3 taken 57 times.
✓ Branch 6 taken 57 times.
57 controller.getImpl<ControllerWaterCoil_Impl>()->setWaterCoil(getObject<HVACComponent>());
95
2/2
✓ Branch 1 taken 57 times.
✓ Branch 4 taken 57 times.
57 controller.setAction("Normal");
96 120 }
97 84 }
98 }
99
100 114 return success;
101 }
102
103 111 bool CoilHeatingWater_Impl::removeFromPlantLoop() {
104
3/3
✓ Branch 1 taken 111 times.
✓ Branch 3 taken 9 times.
✓ Branch 4 taken 102 times.
222 if (boost::optional<ControllerWaterCoil> controller = this->controllerWaterCoil()) {
105
2/2
✓ Branch 1 taken 9 times.
✓ Branch 4 taken 9 times.
9 controller->remove();
106 111 }
107
108 111 return WaterToAirComponent_Impl::removeFromPlantLoop();
109 }
110
111 22 std::vector<openstudio::IdfObject> CoilHeatingWater_Impl::remove() {
112
2/2
✓ Branch 1 taken 10 times.
✓ Branch 2 taken 12 times.
22 if (isRemovable()) {
113 10 return WaterToAirComponent_Impl::remove();
114 }
115
116 12 return {};
117 }
118
119 23 ModelObject CoilHeatingWater_Impl::clone(Model model) const {
120
2/2
✓ Branch 1 taken 23 times.
✓ Branch 4 taken 23 times.
23 return WaterToAirComponent_Impl::clone(model);
121 }
122
123 834 IddObjectType CoilHeatingWater_Impl::iddObjectType() const {
124 834 return CoilHeatingWater::iddObjectType();
125 }
126
127 28 std::vector<ModelObject> CoilHeatingWater_Impl::children() const {
128 28 std::vector<ModelObject> result;
129 std::vector<AirflowNetworkEquivalentDuct> myAFNItems =
130
3/3
✓ Branch 1 taken 28 times.
✓ Branch 4 taken 28 times.
✓ Branch 7 taken 28 times.
28 getObject<ModelObject>().getModelObjectSources<AirflowNetworkEquivalentDuct>(AirflowNetworkEquivalentDuct::iddObjectType());
131
1/1
✓ Branch 5 taken 28 times.
28 result.insert(result.end(), myAFNItems.begin(), myAFNItems.end());
132 56 return result;
133 28 }
134
135 ✗ std::vector<ScheduleTypeKey> CoilHeatingWater_Impl::getScheduleTypeKeys(const Schedule& schedule) const {
136 ✗ std::vector<ScheduleTypeKey> result;
137 ✗ UnsignedVector fieldIndices = getSourceIndices(schedule.handle());
138 ✗ UnsignedVector::const_iterator b(fieldIndices.begin());
139 ✗ UnsignedVector::const_iterator e(fieldIndices.end());
140 ✗ if (std::find(b, e, OS_Coil_Heating_WaterFields::AvailabilityScheduleName) != e) {
141 ✗ result.emplace_back("CoilHeatingWater", "Availability");
142 }
143 ✗ return result;
144 ✗ }
145
146 11 Schedule CoilHeatingWater_Impl::availabilitySchedule() const {
147
2/2
✓ Branch 1 taken 11 times.
✓ Branch 4 taken 11 times.
11 OptionalSchedule value = getObject<ModelObject>().getModelObjectTarget<Schedule>(OS_Coil_Heating_WaterFields::AvailabilityScheduleName);
148
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
11 if (!value) {
149 // it is an error if we get here, however we don't want to crash
150 // so we hook up to global always on schedule
151 ✗ LOG(Error, "Required availability schedule not set, using 'Always On' schedule");
152 ✗ value = this->model().alwaysOnDiscreteSchedule();
153 ✗ OS_ASSERT(value);
154 ✗ const_cast<CoilHeatingWater_Impl*>(this)->setAvailabilitySchedule(*value);
155 ✗ value = getObject<ModelObject>().getModelObjectTarget<Schedule>(OS_Coil_Heating_WaterFields::AvailabilityScheduleName);
156 }
157
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
✗ Branch 4 not taken.
11 OS_ASSERT(value);
158
2/2
✓ Branch 1 taken 11 times.
✓ Branch 4 taken 11 times.
22 return value.get();
159 11 }
160
161 126 bool CoilHeatingWater_Impl::setAvailabilitySchedule(Schedule& schedule) {
162
3/3
✓ Branch 1 taken 126 times.
✓ Branch 4 taken 126 times.
✓ Branch 7 taken 126 times.
504 bool result = setSchedule(OS_Coil_Heating_WaterFields::AvailabilityScheduleName, "CoilHeatingWater", "Availability", schedule);
163 126 return result;
164 }
165
166 ✗ boost::optional<double> CoilHeatingWater_Impl::uFactorTimesAreaValue() {
167 ✗ return getDouble(openstudio::OS_Coil_Heating_WaterFields::UFactorTimesAreaValue);
168 }
169
170 ✗ bool CoilHeatingWater_Impl::setUFactorTimesAreaValue(double value) {
171 ✗ return setDouble(openstudio::OS_Coil_Heating_WaterFields::UFactorTimesAreaValue, value);
172 }
173
174 11 bool CoilHeatingWater_Impl::isUFactorTimesAreaValueAutosized() {
175 11 bool result = false;
176
1/1
✓ Branch 1 taken 11 times.
11 boost::optional<std::string> value = getString(OS_Coil_Heating_WaterFields::UFactorTimesAreaValue, true);
177
1/2
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
11 if (value) {
178
3/3
✓ Branch 1 taken 11 times.
✓ Branch 4 taken 11 times.
✓ Branch 7 taken 11 times.
22 result = openstudio::istringEqual(value.get(), "Autosize");
179 }
180 11 return result;
181 11 }
182
183 ✗ void CoilHeatingWater_Impl::autosizeUFactorTimesAreaValue() {
184 ✗ setString(OS_Coil_Heating_WaterFields::UFactorTimesAreaValue, "Autosize");
185 ✗ }
186
187 ✗ boost::optional<double> CoilHeatingWater_Impl::maximumWaterFlowRate() {
188 ✗ return getDouble(openstudio::OS_Coil_Heating_WaterFields::MaximumWaterFlowRate);
189 }
190
191 ✗ bool CoilHeatingWater_Impl::setMaximumWaterFlowRate(double value) {
192 ✗ return setDouble(openstudio::OS_Coil_Heating_WaterFields::MaximumWaterFlowRate, value);
193 }
194
195 11 bool CoilHeatingWater_Impl::isMaximumWaterFlowRateAutosized() {
196 11 bool result = false;
197
1/1
✓ Branch 1 taken 11 times.
11 boost::optional<std::string> value = getString(OS_Coil_Heating_WaterFields::MaximumWaterFlowRate, true);
198
1/2
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
11 if (value) {
199
3/3
✓ Branch 1 taken 11 times.
✓ Branch 4 taken 11 times.
✓ Branch 7 taken 11 times.
22 result = openstudio::istringEqual(value.get(), "Autosize");
200 }
201 11 return result;
202 11 }
203
204 ✗ void CoilHeatingWater_Impl::autosizeMaximumWaterFlowRate() {
205 ✗ setString(OS_Coil_Heating_WaterFields::MaximumWaterFlowRate, "Autosize");
206 ✗ }
207
208 11 std::string CoilHeatingWater_Impl::performanceInputMethod() {
209
3/3
✓ Branch 1 taken 11 times.
✓ Branch 4 taken 11 times.
✓ Branch 7 taken 11 times.
11 return getString(openstudio::OS_Coil_Heating_WaterFields::PerformanceInputMethod, true).get();
210 }
211
212 26 bool CoilHeatingWater_Impl::setPerformanceInputMethod(const std::string& value) {
213 26 return setString(openstudio::OS_Coil_Heating_WaterFields::PerformanceInputMethod, value);
214 ;
215 }
216
217 5 boost::optional<double> CoilHeatingWater_Impl::ratedCapacity() {
218 5 return getDouble(openstudio::OS_Coil_Heating_WaterFields::RatedCapacity);
219 }
220
221 26 bool CoilHeatingWater_Impl::setRatedCapacity(double value) {
222 26 return setDouble(openstudio::OS_Coil_Heating_WaterFields::RatedCapacity, value);
223 }
224
225 11 bool CoilHeatingWater_Impl::isRatedCapacityAutosized() {
226 11 bool result = false;
227
1/1
✓ Branch 1 taken 11 times.
11 boost::optional<std::string> value = getString(OS_Coil_Heating_WaterFields::RatedCapacity, true);
228
1/2
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
11 if (value) {
229
3/3
✓ Branch 1 taken 11 times.
✓ Branch 4 taken 11 times.
✓ Branch 7 taken 11 times.
22 result = openstudio::istringEqual(value.get(), "Autosize");
230 }
231 11 return result;
232 11 }
233
234 ✗ void CoilHeatingWater_Impl::autosizeRatedCapacity() {
235 ✗ setString(OS_Coil_Heating_WaterFields::RatedCapacity, "Autosize");
236 ✗ }
237
238 16 double CoilHeatingWater_Impl::ratedInletWaterTemperature() {
239
2/2
✓ Branch 1 taken 16 times.
✓ Branch 4 taken 16 times.
16 return getDouble(openstudio::OS_Coil_Heating_WaterFields::RatedInletWaterTemperature, true).get();
240 }
241
242 26 bool CoilHeatingWater_Impl::setRatedInletWaterTemperature(double value) {
243 26 return setDouble(openstudio::OS_Coil_Heating_WaterFields::RatedInletWaterTemperature, value);
244 ;
245 }
246
247 11 double CoilHeatingWater_Impl::ratedInletAirTemperature() {
248
2/2
✓ Branch 1 taken 11 times.
✓ Branch 4 taken 11 times.
11 return getDouble(openstudio::OS_Coil_Heating_WaterFields::RatedInletAirTemperature, true).get();
249 }
250
251 26 bool CoilHeatingWater_Impl::setRatedInletAirTemperature(double value) {
252 26 return setDouble(openstudio::OS_Coil_Heating_WaterFields::RatedInletAirTemperature, value);
253 }
254
255 16 double CoilHeatingWater_Impl::ratedOutletWaterTemperature() {
256
2/2
✓ Branch 1 taken 16 times.
✓ Branch 4 taken 16 times.
16 return getDouble(openstudio::OS_Coil_Heating_WaterFields::RatedOutletWaterTemperature, true).get();
257 }
258
259 26 bool CoilHeatingWater_Impl::setRatedOutletWaterTemperature(double value) {
260 26 return setDouble(openstudio::OS_Coil_Heating_WaterFields::RatedOutletWaterTemperature, value);
261 ;
262 }
263
264 11 double CoilHeatingWater_Impl::ratedOutletAirTemperature() {
265
2/2
✓ Branch 1 taken 11 times.
✓ Branch 4 taken 11 times.
11 return getDouble(openstudio::OS_Coil_Heating_WaterFields::RatedOutletAirTemperature, true).get();
266 }
267
268 26 bool CoilHeatingWater_Impl::setRatedOutletAirTemperature(double value) {
269 26 return setDouble(openstudio::OS_Coil_Heating_WaterFields::RatedOutletAirTemperature, value);
270 }
271
272 11 double CoilHeatingWater_Impl::ratedRatioForAirAndWaterConvection() {
273
2/2
✓ Branch 1 taken 11 times.
✓ Branch 4 taken 11 times.
11 return getDouble(openstudio::OS_Coil_Heating_WaterFields::RatedRatioforAirandWaterConvection, true).get();
274 }
275
276 ✗ bool CoilHeatingWater_Impl::setRatedRatioForAirAndWaterConvection(double value) {
277 ✗ return setDouble(openstudio::OS_Coil_Heating_WaterFields::RatedRatioforAirandWaterConvection, value);
278 }
279
280 1955 unsigned CoilHeatingWater_Impl::airInletPort() const {
281 1955 return OS_Coil_Heating_WaterFields::AirInletNodeName;
282 }
283
284 1926 unsigned CoilHeatingWater_Impl::airOutletPort() const {
285 1926 return OS_Coil_Heating_WaterFields::AirOutletNodeName;
286 }
287
288 3646 unsigned CoilHeatingWater_Impl::waterInletPort() const {
289 3646 return OS_Coil_Heating_WaterFields::WaterInletNodeName;
290 }
291
292 1771 unsigned CoilHeatingWater_Impl::waterOutletPort() const {
293 1771 return OS_Coil_Heating_WaterFields::WaterOutletNodeName;
294 }
295
296 179 boost::optional<HVACComponent> CoilHeatingWater_Impl::containingHVACComponent() const {
297 // Process all types that might contain a CoilHeatingWater object.
298
299 // Here is the list of AirTerminals and AirLoopHVACUnitary that are in OpenStudio as of 2.3.0
300
301 // Can have a heating coil (and are implemented below)
302 // * AirTerminalSingleDuctConstantVolumeFourPipeInduction
303 // * AirTerminalSingleDuctConstantVolumeReheat
304 // * AirTerminalSingleDuctParallelPIUReheat
305 // * AirTerminalSingleDuctSeriesPIUReheat
306 // * AirTerminalSingleDuctVAVHeatAndCoolReheat
307 // * AirTerminalSingleDuctVAVReheat
308 // * AirLoopHVACUnitarySystem
309 // * AirLoopHVACUnitaryHeatCoolVAVChangeoverBypass
310 // * AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed
311
312 // Cannot have a heating coil:
313 // * AirTerminalDualDuctVAV
314 // * AirTerminalSingleDuctConstantVolumeCooledBeam
315 // * AirTerminalSingleDuctInletSideMixer
316 // * AirTerminalSingleDuctConstantVolumeNoReheat (previously named AirTerminalSingleDuctUncontrolled)
317 // * AirTerminalSingleDuctVAVHeatAndCoolNoReheat
318 // * AirTerminalSingleDuctVAVNoReheat
319
320 // AirLoopHVACUnitarySystem
321
2/2
✓ Branch 1 taken 179 times.
✓ Branch 4 taken 179 times.
179 std::vector<AirLoopHVACUnitarySystem> airLoopHVACUnitarySystems = this->model().getConcreteModelObjects<AirLoopHVACUnitarySystem>();
322
323
2/2
✓ Branch 5 taken 12 times.
✓ Branch 6 taken 167 times.
179 for (const auto& airLoopHVACUnitarySystem : airLoopHVACUnitarySystems) {
324
2/3
✓ Branch 1 taken 12 times.
✓ Branch 3 taken 12 times.
✗ Branch 4 not taken.
24 if (boost::optional<HVACComponent> heatingCoil = airLoopHVACUnitarySystem.heatingCoil()) {
325
6/6
✓ Branch 1 taken 12 times.
✓ Branch 4 taken 12 times.
✓ Branch 7 taken 12 times.
✓ Branch 10 taken 12 times.
✓ Branch 12 taken 6 times.
✓ Branch 13 taken 6 times.
12 if (heatingCoil->handle() == this->handle()) {
326
1/1
✓ Branch 1 taken 6 times.
6 return airLoopHVACUnitarySystem;
327 }
328 12 }
329
2/3
✓ Branch 1 taken 6 times.
✓ Branch 3 taken 6 times.
✗ Branch 4 not taken.
12 if (boost::optional<HVACComponent> suppHeatingCoil = airLoopHVACUnitarySystem.supplementalHeatingCoil()) {
330
5/6
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
✓ Branch 7 taken 6 times.
✓ Branch 10 taken 6 times.
✓ Branch 12 taken 6 times.
✗ Branch 13 not taken.
6 if (suppHeatingCoil->handle() == this->handle()) {
331
1/1
✓ Branch 1 taken 6 times.
6 return airLoopHVACUnitarySystem;
332 }
333 6 }
334 }
335
336 // AirLoopHVACUnitaryHeatCoolVAVChangeoverBypass
337 std::vector<AirLoopHVACUnitaryHeatCoolVAVChangeoverBypass> bypassSystems =
338
2/2
✓ Branch 1 taken 167 times.
✓ Branch 4 taken 167 times.
167 this->model().getConcreteModelObjects<AirLoopHVACUnitaryHeatCoolVAVChangeoverBypass>();
339
340
1/2
✗ Branch 5 not taken.
✓ Branch 6 taken 167 times.
167 for (const auto& bypassSystem : bypassSystems) {
341 ✗ if (boost::optional<HVACComponent> heatingCoil = bypassSystem.heatingCoil()) {
342 ✗ if (heatingCoil->handle() == this->handle()) {
343 ✗ return bypassSystem;
344 }
345 ✗ }
346 }
347
348 // AirTerminalSingleDuctVAVReheat
349
350 std::vector<AirTerminalSingleDuctVAVReheat> airTerminalSingleDuctVAVReheatObjects =
351
2/2
✓ Branch 1 taken 167 times.
✓ Branch 4 taken 167 times.
167 this->model().getConcreteModelObjects<AirTerminalSingleDuctVAVReheat>();
352
353
2/2
✓ Branch 5 taken 235 times.
✓ Branch 6 taken 148 times.
383 for (const auto& airTerminalSingleDuctVAVReheatObject : airTerminalSingleDuctVAVReheatObjects) {
354
3/4
✓ Branch 1 taken 235 times.
✓ Branch 4 taken 235 times.
✓ Branch 8 taken 235 times.
✗ Branch 9 not taken.
470 if (boost::optional<HVACComponent> coil = airTerminalSingleDuctVAVReheatObject.reheatCoil()) {
355
6/6
✓ Branch 1 taken 235 times.
✓ Branch 4 taken 235 times.
✓ Branch 7 taken 235 times.
✓ Branch 10 taken 235 times.
✓ Branch 12 taken 19 times.
✓ Branch 13 taken 216 times.
235 if (coil->handle() == this->handle()) {
356
1/1
✓ Branch 1 taken 19 times.
19 return airTerminalSingleDuctVAVReheatObject;
357 }
358 235 }
359 }
360
361 // AirTerminalSingleDuctVAVHeatAndCoolReheat
362 std::vector<AirTerminalSingleDuctVAVHeatAndCoolReheat> airTerminalSingleDuctVAVHeatAndCoolReheatObjects =
363
2/2
✓ Branch 1 taken 148 times.
✓ Branch 4 taken 148 times.
148 this->model().getConcreteModelObjects<AirTerminalSingleDuctVAVHeatAndCoolReheat>();
364
365
2/2
✓ Branch 5 taken 5 times.
✓ Branch 6 taken 144 times.
149 for (const auto& airTerminalSingleDuctVAVHeatAndCoolReheatObject : airTerminalSingleDuctVAVHeatAndCoolReheatObjects) {
366 // Not an optional
367
6/6
✓ Branch 1 taken 5 times.
✓ Branch 4 taken 5 times.
✓ Branch 7 taken 5 times.
✓ Branch 10 taken 5 times.
✓ Branch 13 taken 4 times.
✓ Branch 14 taken 1 time.
5 if (airTerminalSingleDuctVAVHeatAndCoolReheatObject.reheatCoil().handle() == this->handle()) {
368
1/1
✓ Branch 1 taken 4 times.
4 return airTerminalSingleDuctVAVHeatAndCoolReheatObject;
369 }
370 }
371
372 // AirTerminalSingleDuctConstantVolumeReheat
373
374 std::vector<AirTerminalSingleDuctConstantVolumeReheat> airTerminalSingleDuctConstantVolumeReheatObjects =
375
2/2
✓ Branch 1 taken 144 times.
✓ Branch 4 taken 144 times.
144 this->model().getConcreteModelObjects<AirTerminalSingleDuctConstantVolumeReheat>();
376
377
2/2
✓ Branch 5 taken 8 times.
✓ Branch 6 taken 137 times.
145 for (const auto& airTerminalSingleDuctConstantVolumeReheatObject : airTerminalSingleDuctConstantVolumeReheatObjects) {
378
3/4
✓ Branch 1 taken 8 times.
✓ Branch 4 taken 8 times.
✓ Branch 8 taken 8 times.
✗ Branch 9 not taken.
16 if (boost::optional<HVACComponent> coil = airTerminalSingleDuctConstantVolumeReheatObject.reheatCoil()) {
379 // Not an optional actually...
380
6/6
✓ Branch 1 taken 8 times.
✓ Branch 4 taken 8 times.
✓ Branch 7 taken 8 times.
✓ Branch 10 taken 8 times.
✓ Branch 12 taken 7 times.
✓ Branch 13 taken 1 time.
8 if (coil->handle() == this->handle()) {
381
1/1
✓ Branch 1 taken 7 times.
7 return airTerminalSingleDuctConstantVolumeReheatObject;
382 }
383 8 }
384 }
385
386 // AirTerminalSingleDuctSeriesPIUReheat
387
388 std::vector<AirTerminalSingleDuctSeriesPIUReheat> airTerminalSingleDuctSeriesPIUReheatObjects =
389
2/2
✓ Branch 1 taken 137 times.
✓ Branch 4 taken 137 times.
137 this->model().getConcreteModelObjects<AirTerminalSingleDuctSeriesPIUReheat>();
390
391
2/2
✓ Branch 5 taken 5 times.
✓ Branch 6 taken 133 times.
138 for (const auto& airTerminalSingleDuctSeriesPIUReheatObject : airTerminalSingleDuctSeriesPIUReheatObjects) {
392 // Not an optional
393
6/6
✓ Branch 1 taken 5 times.
✓ Branch 4 taken 5 times.
✓ Branch 7 taken 5 times.
✓ Branch 10 taken 5 times.
✓ Branch 13 taken 4 times.
✓ Branch 14 taken 1 time.
5 if (airTerminalSingleDuctSeriesPIUReheatObject.reheatCoil().handle() == this->handle()) {
394
1/1
✓ Branch 1 taken 4 times.
4 return airTerminalSingleDuctSeriesPIUReheatObject;
395 }
396 }
397
398 // AirTerminalSingleDuctParallelPIUReheat
399
400 std::vector<AirTerminalSingleDuctParallelPIUReheat> airTerminalSingleDuctParallelPIUReheatObjects =
401
2/2
✓ Branch 1 taken 133 times.
✓ Branch 4 taken 133 times.
133 this->model().getConcreteModelObjects<AirTerminalSingleDuctParallelPIUReheat>();
402
403
2/2
✓ Branch 5 taken 5 times.
✓ Branch 6 taken 129 times.
134 for (const auto& airTerminalSingleDuctParallelPIUReheatObject : airTerminalSingleDuctParallelPIUReheatObjects) {
404 // Not an optional
405
6/6
✓ Branch 1 taken 5 times.
✓ Branch 4 taken 5 times.
✓ Branch 7 taken 5 times.
✓ Branch 10 taken 5 times.
✓ Branch 13 taken 4 times.
✓ Branch 14 taken 1 time.
5 if (airTerminalSingleDuctParallelPIUReheatObject.reheatCoil().handle() == this->handle()) {
406
1/1
✓ Branch 1 taken 4 times.
4 return airTerminalSingleDuctParallelPIUReheatObject;
407 }
408 }
409
410 // AirTerminalSingleDuctConstantVolumeFourPipeInduction
411 std::vector<AirTerminalSingleDuctConstantVolumeFourPipeInduction> fourPipeSystems =
412
2/2
✓ Branch 1 taken 129 times.
✓ Branch 4 taken 129 times.
129 this->model().getConcreteModelObjects<AirTerminalSingleDuctConstantVolumeFourPipeInduction>();
413
414
2/2
✓ Branch 5 taken 5 times.
✓ Branch 6 taken 124 times.
129 for (const auto& fourPipeSystem : fourPipeSystems) {
415 // Not an optional
416
5/6
✓ Branch 1 taken 5 times.
✓ Branch 4 taken 5 times.
✓ Branch 7 taken 5 times.
✓ Branch 10 taken 5 times.
✓ Branch 13 taken 5 times.
✗ Branch 14 not taken.
5 if (fourPipeSystem.heatingCoil().handle() == this->handle()) {
417
1/1
✓ Branch 1 taken 5 times.
5 return fourPipeSystem;
418 }
419 }
420
421 // AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed
422 {
423
2/2
✓ Branch 1 taken 124 times.
✓ Branch 4 taken 124 times.
124 auto systems = this->model().getConcreteModelObjects<AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed>();
424
425
1/2
✗ Branch 5 not taken.
✓ Branch 6 taken 124 times.
124 for (const auto& system : systems) {
426 ✗ auto heatingCoil = system.heatingCoil();
427 ✗ if (heatingCoil.handle() == this->handle()) {
428 ✗ return system;
429 }
430 ✗ auto supHeatingCoil = system.supplementalHeatingCoil();
431 ✗ if (supHeatingCoil.handle() == this->handle()) {
432 ✗ return system;
433 }
434 ✗ }
435 124 }
436
437 124 return boost::none;
438 179 }
439
440 125 boost::optional<ZoneHVACComponent> CoilHeatingWater_Impl::containingZoneHVACComponent() const {
441 // ZoneHVACFourPipeFanCoil
442
443 125 std::vector<ZoneHVACFourPipeFanCoil> zoneHVACFourPipeFanCoils;
444
445
2/2
✓ Branch 1 taken 125 times.
✓ Branch 4 taken 125 times.
125 zoneHVACFourPipeFanCoils = this->model().getConcreteModelObjects<ZoneHVACFourPipeFanCoil>();
446
447
2/2
✓ Branch 5 taken 2 times.
✓ Branch 6 taken 123 times.
125 for (const auto& zoneHVACFourPipeFanCoil : zoneHVACFourPipeFanCoils) {
448
3/4
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
✓ Branch 8 taken 2 times.
✗ Branch 9 not taken.
4 if (boost::optional<HVACComponent> coil = zoneHVACFourPipeFanCoil.heatingCoil()) {
449
5/6
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
✓ Branch 7 taken 2 times.
✓ Branch 10 taken 2 times.
✓ Branch 12 taken 2 times.
✗ Branch 13 not taken.
2 if (coil->handle() == this->handle()) {
450
1/1
✓ Branch 1 taken 2 times.
2 return zoneHVACFourPipeFanCoil;
451 }
452 2 }
453 }
454
455 // ZoneHVACPackagedTerminalAirConditioner
456
457 123 std::vector<ZoneHVACPackagedTerminalAirConditioner> zoneHVACPackagedTerminalAirConditioners;
458
459
2/2
✓ Branch 1 taken 123 times.
✓ Branch 4 taken 123 times.
123 zoneHVACPackagedTerminalAirConditioners = this->model().getConcreteModelObjects<ZoneHVACPackagedTerminalAirConditioner>();
460
461
2/2
✓ Branch 5 taken 7 times.
✓ Branch 6 taken 116 times.
123 for (const auto& zoneHVACPackagedTerminalAirConditioner : zoneHVACPackagedTerminalAirConditioners) {
462
3/4
✓ Branch 1 taken 7 times.
✓ Branch 4 taken 7 times.
✓ Branch 8 taken 7 times.
✗ Branch 9 not taken.
14 if (boost::optional<HVACComponent> coil = zoneHVACPackagedTerminalAirConditioner.heatingCoil()) {
463
5/6
✓ Branch 1 taken 7 times.
✓ Branch 4 taken 7 times.
✓ Branch 7 taken 7 times.
✓ Branch 10 taken 7 times.
✓ Branch 12 taken 7 times.
✗ Branch 13 not taken.
7 if (coil->handle() == this->handle()) {
464
1/1
✓ Branch 1 taken 7 times.
7 return zoneHVACPackagedTerminalAirConditioner;
465 }
466 7 }
467 }
468
469 // ZoneHVACPackagedTerminalHeatPump
470
471 116 std::vector<ZoneHVACPackagedTerminalHeatPump> zoneHVACPackagedTerminalHeatPumps;
472
473
2/2
✓ Branch 1 taken 116 times.
✓ Branch 4 taken 116 times.
116 zoneHVACPackagedTerminalHeatPumps = this->model().getConcreteModelObjects<ZoneHVACPackagedTerminalHeatPump>();
474
475
2/2
✓ Branch 5 taken 2 times.
✓ Branch 6 taken 114 times.
116 for (const auto& zoneHVACPackagedTerminalHeatPump : zoneHVACPackagedTerminalHeatPumps) {
476
3/4
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
✓ Branch 8 taken 2 times.
✗ Branch 9 not taken.
4 if (boost::optional<HVACComponent> coil = zoneHVACPackagedTerminalHeatPump.supplementalHeatingCoil()) {
477
5/6
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
✓ Branch 7 taken 2 times.
✓ Branch 10 taken 2 times.
✓ Branch 12 taken 2 times.
✗ Branch 13 not taken.
2 if (coil->handle() == this->handle()) {
478
1/1
✓ Branch 1 taken 2 times.
2 return zoneHVACPackagedTerminalHeatPump;
479 }
480 2 }
481 }
482
483 // ZoneHVACWaterToAirHeatPump
484
485 114 std::vector<ZoneHVACWaterToAirHeatPump> zoneHVACWaterToAirHeatPumps;
486
487
2/2
✓ Branch 1 taken 114 times.
✓ Branch 4 taken 114 times.
114 zoneHVACWaterToAirHeatPumps = this->model().getConcreteModelObjects<ZoneHVACWaterToAirHeatPump>();
488
489
1/2
✗ Branch 5 not taken.
✓ Branch 6 taken 114 times.
114 for (const auto& zoneHVACWaterToAirHeatPump : zoneHVACWaterToAirHeatPumps) {
490 ✗ if (boost::optional<HVACComponent> coil = zoneHVACWaterToAirHeatPump.supplementalHeatingCoil()) {
491 ✗ if (coil->handle() == this->handle()) {
492 ✗ return zoneHVACWaterToAirHeatPump;
493 }
494 ✗ }
495 }
496
497 // ZoneHVACUnitHeater
498
499 114 std::vector<ZoneHVACUnitHeater> zoneHVACUnitHeater;
500
501
2/2
✓ Branch 1 taken 114 times.
✓ Branch 4 taken 114 times.
114 zoneHVACUnitHeater = this->model().getConcreteModelObjects<ZoneHVACUnitHeater>();
502
503
1/2
✗ Branch 5 not taken.
✓ Branch 6 taken 114 times.
114 for (const auto& elem : zoneHVACUnitHeater) {
504 ✗ if (boost::optional<HVACComponent> coil = elem.heatingCoil()) {
505 ✗ if (coil->handle() == this->handle()) {
506 ✗ return elem;
507 }
508 ✗ }
509 }
510
511 // ZoneHVACUnitVentilator
512
513 114 std::vector<ZoneHVACUnitVentilator> zoneHVACUnitVentilator;
514
515
2/2
✓ Branch 1 taken 114 times.
✓ Branch 4 taken 114 times.
114 zoneHVACUnitVentilator = this->model().getConcreteModelObjects<ZoneHVACUnitVentilator>();
516
517
1/2
✗ Branch 5 not taken.
✓ Branch 6 taken 114 times.
114 for (const auto& elem : zoneHVACUnitVentilator) {
518 ✗ if (boost::optional<HVACComponent> coil = elem.heatingCoil()) {
519 ✗ if (coil->handle() == this->handle()) {
520 ✗ return elem;
521 }
522 ✗ }
523 }
524
525 114 return boost::none;
526 125 }
527
528 ✗ boost::optional<ModelObject> CoilHeatingWater_Impl::availabilityScheduleAsModelObject() const {
529 ✗ OptionalModelObject result = availabilitySchedule();
530 ✗ return result;
531 }
532
533 ✗ bool CoilHeatingWater_Impl::setAvailabilityScheduleAsModelObject(const boost::optional<ModelObject>& modelObject) {
534 ✗ if (modelObject) {
535 ✗ OptionalSchedule intermediate = modelObject->optionalCast<Schedule>();
536 ✗ if (intermediate) {
537 ✗ Schedule schedule(*intermediate);
538 ✗ return setAvailabilitySchedule(schedule);
539 ✗ }
540 ✗ }
541 ✗ return false;
542 }
543
544 ✗ AirflowNetworkEquivalentDuct CoilHeatingWater_Impl::getAirflowNetworkEquivalentDuct(double length, double diameter) {
545 ✗ boost::optional<AirflowNetworkEquivalentDuct> opt = airflowNetworkEquivalentDuct();
546 ✗ if (opt) {
547 ✗ if (opt->airPathLength() != length) {
548 ✗ opt->setAirPathLength(length);
549 }
550 ✗ if (opt->airPathHydraulicDiameter() != diameter) {
551 ✗ opt->setAirPathHydraulicDiameter(diameter);
552 }
553 }
554 ✗ return AirflowNetworkEquivalentDuct(model(), length, diameter, handle());
555 ✗ }
556
557 ✗ boost::optional<AirflowNetworkEquivalentDuct> CoilHeatingWater_Impl::airflowNetworkEquivalentDuct() const {
558 std::vector<AirflowNetworkEquivalentDuct> myAFN =
559 ✗ getObject<ModelObject>().getModelObjectSources<AirflowNetworkEquivalentDuct>(AirflowNetworkEquivalentDuct::iddObjectType());
560 ✗ auto count = myAFN.size();
561 ✗ if (count == 1) {
562 ✗ return myAFN[0];
563 ✗ } else if (count > 1) {
564 ✗ LOG(Warn, briefDescription() << " has more than one AirflowNetwork EquivalentDuct attached, returning first.");
565 ✗ return myAFN[0];
566 }
567 ✗ return boost::none;
568 ✗ }
569 ✗ boost::optional<double> CoilHeatingWater_Impl::autosizedUFactorTimesAreaValue() const {
570 ✗ return getAutosizedValue("Design Size U-Factor Times Area Value", "W/K");
571 }
572
573 ✗ boost::optional<double> CoilHeatingWater_Impl::autosizedMaximumWaterFlowRate() const {
574 ✗ return getAutosizedValue("Design Size Maximum Water Flow Rate", "m3/s");
575 }
576
577 ✗ boost::optional<double> CoilHeatingWater_Impl::autosizedRatedCapacity() const {
578 ✗ return getAutosizedValue("Design Size Rated Capacity", "W");
579 }
580
581 ✗ void CoilHeatingWater_Impl::autosize() {
582 ✗ autosizeUFactorTimesAreaValue();
583 ✗ autosizeMaximumWaterFlowRate();
584 ✗ autosizeRatedCapacity();
585 ✗ }
586
587 ✗ void CoilHeatingWater_Impl::applySizingValues() {
588 ✗ boost::optional<double> val;
589 ✗ val = autosizedUFactorTimesAreaValue();
590 ✗ if (val) {
591 ✗ setUFactorTimesAreaValue(val.get());
592 }
593
594 ✗ val = autosizedMaximumWaterFlowRate();
595 ✗ if (val) {
596 ✗ setMaximumWaterFlowRate(val.get());
597 }
598
599 ✗ val = autosizedRatedCapacity();
600 ✗ if (val) {
601 ✗ setRatedCapacity(val.get());
602 }
603 ✗ }
604
605 2 ComponentType CoilHeatingWater_Impl::componentType() const {
606
1/1
✓ Branch 1 taken 2 times.
2 return ComponentType::Heating;
607 }
608
609 2 std::vector<FuelType> CoilHeatingWater_Impl::coolingFuelTypes() const {
610 2 return {};
611 }
612
613 8 std::vector<FuelType> CoilHeatingWater_Impl::heatingFuelTypes() const {
614
3/3
✓ Branch 1 taken 8 times.
✓ Branch 3 taken 7 times.
✓ Branch 4 taken 1 time.
16 if (auto p_ = plantLoop()) {
615
2/2
✓ Branch 1 taken 7 times.
✓ Branch 4 taken 7 times.
7 return p_->heatingFuelTypes();
616 8 }
617 1 return {};
618 }
619
620 7 std::vector<AppGFuelType> CoilHeatingWater_Impl::appGHeatingFuelTypes() const {
621
2/3
✓ Branch 1 taken 7 times.
✓ Branch 3 taken 7 times.
✗ Branch 4 not taken.
14 if (auto p_ = plantLoop()) {
622
2/2
✓ Branch 1 taken 7 times.
✓ Branch 4 taken 7 times.
7 return p_->appGHeatingFuelTypes();
623 7 }
624 ✗ return {};
625 }
626
627 } // namespace detail
628
629 92 CoilHeatingWater::CoilHeatingWater(const Model& model, Schedule& availableSchedule)
630 92 : WaterToAirComponent(CoilHeatingWater::iddObjectType(), model) {
631
1/3
✗ Branch 2 not taken.
✓ Branch 3 taken 92 times.
✗ Branch 5 not taken.
92 OS_ASSERT(getImpl<detail::CoilHeatingWater_Impl>());
632
633
1/1
✓ Branch 1 taken 92 times.
92 setAvailableSchedule(availableSchedule);
634 92 }
635
636 34 CoilHeatingWater::CoilHeatingWater(const Model& model) : WaterToAirComponent(CoilHeatingWater::iddObjectType(), model) {
637
1/3
✗ Branch 2 not taken.
✓ Branch 3 taken 34 times.
✗ Branch 5 not taken.
34 OS_ASSERT(getImpl<detail::CoilHeatingWater_Impl>());
638
639
1/1
✓ Branch 1 taken 34 times.
34 auto availableSchedule = model.alwaysOnDiscreteSchedule();
640
1/1
✓ Branch 1 taken 34 times.
34 setAvailableSchedule(availableSchedule);
641 34 }
642
643
1/1
✓ Branch 3 taken 59 times.
59 CoilHeatingWater::CoilHeatingWater(std::shared_ptr<detail::CoilHeatingWater_Impl> p) : WaterToAirComponent(std::move(p)) {}
644
645 ✗ Schedule CoilHeatingWater::availabilitySchedule() const {
646 ✗ return getImpl<detail::CoilHeatingWater_Impl>()->availabilitySchedule();
647 }
648
649 11 Schedule CoilHeatingWater::availableSchedule() const {
650
1/1
✓ Branch 3 taken 11 times.
11 return getImpl<detail::CoilHeatingWater_Impl>()->availabilitySchedule();
651 }
652
653 ✗ bool CoilHeatingWater::setAvailabilitySchedule(Schedule& schedule) {
654 ✗ return getImpl<detail::CoilHeatingWater_Impl>()->setAvailabilitySchedule(schedule);
655 }
656
657 126 bool CoilHeatingWater::setAvailableSchedule(Schedule& schedule) {
658
1/1
✓ Branch 3 taken 126 times.
126 return getImpl<detail::CoilHeatingWater_Impl>()->setAvailabilitySchedule(schedule);
659 }
660
661 ✗ boost::optional<double> CoilHeatingWater::uFactorTimesAreaValue() {
662 ✗ return getImpl<detail::CoilHeatingWater_Impl>()->uFactorTimesAreaValue();
663 }
664
665 ✗ bool CoilHeatingWater::setUFactorTimesAreaValue(double value) {
666 ✗ return getImpl<detail::CoilHeatingWater_Impl>()->setUFactorTimesAreaValue(value);
667 }
668
669 11 bool CoilHeatingWater::isUFactorTimesAreaValueAutosized() {
670
1/1
✓ Branch 3 taken 11 times.
11 return getImpl<detail::CoilHeatingWater_Impl>()->isUFactorTimesAreaValueAutosized();
671 }
672
673 ✗ void CoilHeatingWater::autosizeUFactorTimesAreaValue() {
674 ✗ getImpl<detail::CoilHeatingWater_Impl>()->autosizeUFactorTimesAreaValue();
675 ✗ }
676
677 ✗ boost::optional<double> CoilHeatingWater::maximumWaterFlowRate() {
678 ✗ return getImpl<detail::CoilHeatingWater_Impl>()->maximumWaterFlowRate();
679 }
680
681 ✗ bool CoilHeatingWater::setMaximumWaterFlowRate(double value) {
682 ✗ return getImpl<detail::CoilHeatingWater_Impl>()->setMaximumWaterFlowRate(value);
683 }
684
685 11 bool CoilHeatingWater::isMaximumWaterFlowRateAutosized() {
686
1/1
✓ Branch 3 taken 11 times.
11 return getImpl<detail::CoilHeatingWater_Impl>()->isMaximumWaterFlowRateAutosized();
687 }
688
689 ✗ void CoilHeatingWater::autosizeMaximumWaterFlowRate() {
690 ✗ getImpl<detail::CoilHeatingWater_Impl>()->autosizeMaximumWaterFlowRate();
691 ✗ }
692
693 11 std::string CoilHeatingWater::performanceInputMethod() {
694
1/1
✓ Branch 3 taken 11 times.
11 return getImpl<detail::CoilHeatingWater_Impl>()->performanceInputMethod();
695 }
696
697 26 bool CoilHeatingWater::setPerformanceInputMethod(const std::string& value) {
698
1/1
✓ Branch 3 taken 26 times.
26 return getImpl<detail::CoilHeatingWater_Impl>()->setPerformanceInputMethod(value);
699 }
700
701 5 boost::optional<double> CoilHeatingWater::ratedCapacity() {
702
1/1
✓ Branch 3 taken 5 times.
5 return getImpl<detail::CoilHeatingWater_Impl>()->ratedCapacity();
703 }
704
705 26 bool CoilHeatingWater::setRatedCapacity(double value) {
706
1/1
✓ Branch 3 taken 26 times.
26 return getImpl<detail::CoilHeatingWater_Impl>()->setRatedCapacity(value);
707 }
708
709 11 bool CoilHeatingWater::isRatedCapacityAutosized() {
710
1/1
✓ Branch 3 taken 11 times.
11 return getImpl<detail::CoilHeatingWater_Impl>()->isRatedCapacityAutosized();
711 }
712
713 ✗ void CoilHeatingWater::autosizeRatedCapacity() {
714 ✗ getImpl<detail::CoilHeatingWater_Impl>()->autosizeRatedCapacity();
715 ✗ }
716
717 16 double CoilHeatingWater::ratedInletWaterTemperature() {
718
1/1
✓ Branch 3 taken 16 times.
16 return getImpl<detail::CoilHeatingWater_Impl>()->ratedInletWaterTemperature();
719 }
720
721 26 bool CoilHeatingWater::setRatedInletWaterTemperature(double value) {
722
1/1
✓ Branch 3 taken 26 times.
26 return getImpl<detail::CoilHeatingWater_Impl>()->setRatedInletWaterTemperature(value);
723 }
724
725 11 double CoilHeatingWater::ratedInletAirTemperature() {
726
1/1
✓ Branch 3 taken 11 times.
11 return getImpl<detail::CoilHeatingWater_Impl>()->ratedInletAirTemperature();
727 }
728
729 26 bool CoilHeatingWater::setRatedInletAirTemperature(double value) {
730
1/1
✓ Branch 3 taken 26 times.
26 return getImpl<detail::CoilHeatingWater_Impl>()->setRatedInletAirTemperature(value);
731 }
732
733 16 double CoilHeatingWater::ratedOutletWaterTemperature() {
734
1/1
✓ Branch 3 taken 16 times.
16 return getImpl<detail::CoilHeatingWater_Impl>()->ratedOutletWaterTemperature();
735 }
736
737 26 bool CoilHeatingWater::setRatedOutletWaterTemperature(double value) {
738
1/1
✓ Branch 3 taken 26 times.
26 return getImpl<detail::CoilHeatingWater_Impl>()->setRatedOutletWaterTemperature(value);
739 }
740
741 11 double CoilHeatingWater::ratedOutletAirTemperature() {
742
1/1
✓ Branch 3 taken 11 times.
11 return getImpl<detail::CoilHeatingWater_Impl>()->ratedOutletAirTemperature();
743 }
744
745 26 bool CoilHeatingWater::setRatedOutletAirTemperature(double value) {
746
1/1
✓ Branch 3 taken 26 times.
26 return getImpl<detail::CoilHeatingWater_Impl>()->setRatedOutletAirTemperature(value);
747 }
748
749 11 double CoilHeatingWater::ratedRatioForAirAndWaterConvection() {
750
1/1
✓ Branch 3 taken 11 times.
11 return getImpl<detail::CoilHeatingWater_Impl>()->ratedRatioForAirAndWaterConvection();
751 }
752
753 ✗ bool CoilHeatingWater::setRatedRatioForAirAndWaterConvection(double value) {
754 ✗ return getImpl<detail::CoilHeatingWater_Impl>()->setRatedRatioForAirAndWaterConvection(value);
755 }
756
757 8840 IddObjectType CoilHeatingWater::iddObjectType() {
758
1/1
✓ Branch 1 taken 8840 times.
8840 IddObjectType result(IddObjectType::OS_Coil_Heating_Water);
759 8840 return result;
760 }
761
762 13 boost::optional<ControllerWaterCoil> CoilHeatingWater::controllerWaterCoil() {
763
1/1
✓ Branch 3 taken 13 times.
13 return getImpl<detail::CoilHeatingWater_Impl>()->controllerWaterCoil();
764 }
765
766 ✗ AirflowNetworkEquivalentDuct CoilHeatingWater::getAirflowNetworkEquivalentDuct(double length, double diameter) {
767 ✗ return getImpl<detail::CoilHeatingWater_Impl>()->getAirflowNetworkEquivalentDuct(length, diameter);
768 }
769
770 ✗ boost::optional<AirflowNetworkEquivalentDuct> CoilHeatingWater::airflowNetworkEquivalentDuct() const {
771 ✗ return getImpl<detail::CoilHeatingWater_Impl>()->airflowNetworkEquivalentDuct();
772 }
773
774 ✗ boost::optional<double> CoilHeatingWater::autosizedUFactorTimesAreaValue() const {
775 ✗ return getImpl<detail::CoilHeatingWater_Impl>()->autosizedUFactorTimesAreaValue();
776 }
777
778 ✗ boost::optional<double> CoilHeatingWater::autosizedMaximumWaterFlowRate() const {
779 ✗ return getImpl<detail::CoilHeatingWater_Impl>()->autosizedMaximumWaterFlowRate();
780 }
781
782 ✗ boost::optional<double> CoilHeatingWater::autosizedRatedCapacity() const {
783 ✗ return getImpl<detail::CoilHeatingWater_Impl>()->autosizedRatedCapacity();
784 }
785
786 } // namespace model
787 } // namespace openstudio
788