GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 50.6% 633 / 0 / 1250
Functions: 51.5% 177 / 0 / 344
Branches: 45.5% 537 / 0 / 1179

src/model/WaterHeaterMixed.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 "WaterHeaterMixed.hpp"
7 #include "WaterHeaterMixed_Impl.hpp"
8 #include "Model.hpp"
9 #include "Model_Impl.hpp"
10 #include "WaterHeaterHeatPump.hpp"
11 #include "WaterHeaterHeatPump_Impl.hpp"
12 #include "Schedule.hpp"
13 #include "Schedule_Impl.hpp"
14 #include "ScheduleDay.hpp"
15 #include "ScheduleDay_Impl.hpp"
16 #include "ScheduleRuleset.hpp"
17 #include "ScheduleRuleset_Impl.hpp"
18 #include "CurveCubic.hpp"
19 #include "CurveCubic_Impl.hpp"
20 #include "ThermalZone.hpp"
21 #include "ThermalZone_Impl.hpp"
22 #include "WaterHeaterSizing.hpp"
23 #include "WaterHeaterSizing_Impl.hpp"
24 #include "PlantLoop.hpp"
25 #include "PlantLoop_Impl.hpp"
26 #include "Node.hpp"
27 #include "Node_Impl.hpp"
28
29 #include "../utilities/units/Unit.hpp"
30 #include "../utilities/core/Assert.hpp"
31 #include "../utilities/data/DataEnums.hpp"
32
33 #include <utilities/idd/IddFactory.hxx>
34 #include <utilities/idd/OS_WaterHeater_Mixed_FieldEnums.hxx>
35 #include <utilities/idd/IddEnums.hxx>
36
37 #include <algorithm>
38
39 namespace openstudio {
40
41 namespace model {
42
43 namespace detail {
44
45 62 WaterHeaterMixed_Impl::WaterHeaterMixed_Impl(const IdfObject& idfObject, Model_Impl* model, bool keepHandle)
46 62 : WaterToWaterComponent_Impl(idfObject, model, keepHandle) {
47
4/6
✓ Branch 1 taken 62 times.
✓ Branch 4 taken 62 times.
✓ Branch 7 taken 62 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 62 times.
✗ Branch 13 not taken.
62 OS_ASSERT(idfObject.iddObject().type() == WaterHeaterMixed::iddObjectType());
48 62 }
49
50 16 WaterHeaterMixed_Impl::WaterHeaterMixed_Impl(const openstudio::detail::WorkspaceObject_Impl& other, Model_Impl* model, bool keepHandle)
51 16 : WaterToWaterComponent_Impl(other, model, keepHandle) {
52
4/6
✓ Branch 1 taken 16 times.
✓ Branch 4 taken 16 times.
✓ Branch 7 taken 16 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 16 times.
✗ Branch 13 not taken.
16 OS_ASSERT(other.iddObject().type() == WaterHeaterMixed::iddObjectType());
53 16 }
54
55 74 WaterHeaterMixed_Impl::WaterHeaterMixed_Impl(const WaterHeaterMixed_Impl& other, Model_Impl* model, bool keepHandle)
56 74 : WaterToWaterComponent_Impl(other, model, keepHandle) {}
57
58 ✗ const std::vector<std::string>& WaterHeaterMixed_Impl::outputVariableNames() const {
59 static const std::vector<std::string> result{
60 "Water Heater Tank Temperature", "Water Heater Final Tank Temperature", "Water Heater Heat Loss Rate", "Water Heater Heat Loss Energy",
61 "Water Heater Use Side Mass Flow Rate", "Water Heater Use Side Inlet Temperature", "Water Heater Use Side Outlet Temperature",
62 "Water Heater Use Side Heat Transfer Rate", "Water Heater Use Side Heat Transfer Energy", "Water Heater Source Side Mass Flow Rate",
63 "Water Heater Source Side Inlet Temperature", "Water Heater Source Side Outlet Temperature", "Water Heater Source Side Heat Transfer Rate",
64 "Water Heater Source Side Heat Transfer Energy", "Water Heater Off Cycle Parasitic Tank Heat Transfer Rate",
65 "Water Heater Off Cycle Parasitic Tank Heat Transfer Energy", "Water Heater On Cycle Parasitic Tank Heat Transfer Rate",
66 "Water Heater On Cycle Parasitic Tank Heat Transfer Energy", "Water Heater Total Demand Heat Transfer Rate",
67 "Water Heater Total Demand Energy", "Water Heater Heating Rate", "Water Heater Heating Energy",
68 "Water Heater Unmet Demand Heat Transfer Rate", "Water Heater Unmet Demand Heat Transfer Energy", "Water Heater Venting Heat Transfer Rate",
69 "Water Heater Venting Heat Transfer Energy", "Water Heater Net Heat Transfer Rate", "Water Heater Net Heat Transfer Energy",
70 "Water Heater Cycle On Count", "Water Heater Runtime Fraction", "Water Heater Part Load Ratio", "Water Heater Electricity Rate",
71
72 // This should be based on fuel type
73
74 //"Water Heater <Fuel Type> Rate",
75 //"Water Heater <Fuel Type> Energy",
76 // Fuel type specific
77 // TODO: DLM: the return type of this method needs to change to std::vector<std::string> in ModelObject
78 // until then, make this include all possible outputVariableNames for class regardless of fuelType
79 // std::string fuelType = this->fuelType();
80 // if (fuelType == "Electricity") {
81 "Water Heater Electricity Rate", "Water Heater Electricity Energy",
82 // } else if (fuelType == "NaturalGas") {
83 "Water Heater NaturalGas Rate", "Water Heater NaturalGas Energy",
84 // } else if (fuelType == "Propane") {
85 "Water Heater Propane Rate", "Water Heater Propane Energy",
86 // } else if (fuelType == "FuelOilNo1") {
87 "Water Heater FuelOilNo1 Rate", "Water Heater FuelOilNo1 Energy",
88 // } else if (fuelType == "FuelOilNo2") {
89 "Water Heater FuelOilNo2 Rate", "Water Heater FuelOilNo2 Energy",
90 // } else if (fuelType == "Coal") {
91 "Water Heater Coal Rate", "Water Heater Coal Energy",
92 // } else if (fuelType == "Diesel") {
93 "Water Heater Diesel Rate", "Water Heater Diesel Energy",
94 // } else if (fuelType == "Gasoline") {
95 "Water Heater Gasoline Rate", "Water Heater Gasoline Energy",
96 // } else if (fuelType == "OtherFuel1") {
97 "Water Heater OtherFuel1 Rate", "Water Heater OtherFuel1 Energy",
98 // } else if (fuelType == "OtherFuel2") {
99 "Water Heater OtherFuel2 Rate", "Water Heater OtherFuel2 Energy",
100 // }
101
102 // TODO: implement these too...
103 //"Water Heater Off Cycle Parasitic <Fuel Type> Rate",
104 //"Water Heater Off Cycle Parasitic <Fuel Type> Energy",
105 //"Water Heater On Cycle Parasitic <Fuel Type> Rate",
106 // "Water Heater On Cycle Parasitic <Fuel Type> Energy",
107 //
108 "Water Heater Water Volume Flow Rate", "Water Heater Water Volume"
109
110 ✗ };
111 ✗ return result;
112 ✗ }
113
114 60 IddObjectType WaterHeaterMixed_Impl::iddObjectType() const {
115 60 return WaterHeaterMixed::iddObjectType();
116 }
117
118 47 std::vector<ModelObject> WaterHeaterMixed_Impl::children() const {
119
3/5
✓ Branch 1 taken 47 times.
✓ Branch 3 taken 47 times.
✓ Branch 4 taken 47 times.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
141 return std::vector<ModelObject>{waterHeaterSizing()};
120 47 }
121
122 1 ModelObject WaterHeaterMixed_Impl::clone(Model model) const {
123
3/3
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
1 auto whClone = WaterToWaterComponent_Impl::clone(model).cast<WaterHeaterMixed>();
124
125
4/4
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✓ Branch 10 taken 1 time.
1 auto sizingClone = waterHeaterSizing().clone(model).cast<WaterHeaterSizing>();
126
1/1
✓ Branch 3 taken 1 time.
1 sizingClone.getImpl<WaterHeaterSizing_Impl>()->setWaterHeater(whClone);
127 2 return std::move(whClone);
128 1 }
129
130 ✗ std::vector<ScheduleTypeKey> WaterHeaterMixed_Impl::getScheduleTypeKeys(const Schedule& schedule) const {
131 ✗ std::vector<ScheduleTypeKey> result;
132 ✗ UnsignedVector fieldIndices = getSourceIndices(schedule.handle());
133 ✗ UnsignedVector::const_iterator b(fieldIndices.begin());
134 ✗ UnsignedVector::const_iterator e(fieldIndices.end());
135 ✗ if (std::find(b, e, OS_WaterHeater_MixedFields::SetpointTemperatureScheduleName) != e) {
136 ✗ result.push_back(ScheduleTypeKey("WaterHeaterMixed", "Setpoint Temperature"));
137 }
138 ✗ if (std::find(b, e, OS_WaterHeater_MixedFields::AmbientTemperatureScheduleName) != e) {
139 ✗ result.push_back(ScheduleTypeKey("WaterHeaterMixed", "Ambient Temperature"));
140 }
141 ✗ if (std::find(b, e, OS_WaterHeater_MixedFields::UseFlowRateFractionScheduleName) != e) {
142 ✗ result.push_back(ScheduleTypeKey("WaterHeaterMixed", "Use Flow Rate Fraction"));
143 }
144 ✗ if (std::find(b, e, OS_WaterHeater_MixedFields::ColdWaterSupplyTemperatureScheduleName) != e) {
145 ✗ result.push_back(ScheduleTypeKey("WaterHeaterMixed", "Cold Water Supply Temperature"));
146 }
147 ✗ if (std::find(b, e, OS_WaterHeater_MixedFields::IndirectAlternateSetpointTemperatureScheduleName) != e) {
148 ✗ result.push_back(ScheduleTypeKey("WaterHeaterMixed", "Indirect Alternate Setpoint Temperature"));
149 }
150 ✗ return result;
151 ✗ }
152
153 30 boost::optional<double> WaterHeaterMixed_Impl::tankVolume() const {
154 30 return getDouble(OS_WaterHeater_MixedFields::TankVolume, true);
155 }
156
157 ✗ bool WaterHeaterMixed_Impl::isTankVolumeDefaulted() const {
158 ✗ return isEmpty(OS_WaterHeater_MixedFields::TankVolume);
159 }
160
161 30 bool WaterHeaterMixed_Impl::isTankVolumeAutosized() const {
162 30 bool result = false;
163
1/1
✓ Branch 1 taken 30 times.
30 boost::optional<std::string> value = getString(OS_WaterHeater_MixedFields::TankVolume, true);
164
1/2
✓ Branch 0 taken 30 times.
✗ Branch 1 not taken.
30 if (value) {
165
3/3
✓ Branch 1 taken 30 times.
✓ Branch 4 taken 30 times.
✓ Branch 7 taken 30 times.
60 result = openstudio::istringEqual(value.get(), "autosize");
166 }
167 30 return result;
168 30 }
169
170 40 boost::optional<Schedule> WaterHeaterMixed_Impl::setpointTemperatureSchedule() const {
171
2/2
✓ Branch 1 taken 40 times.
✓ Branch 4 taken 40 times.
40 return getObject<ModelObject>().getModelObjectTarget<Schedule>(OS_WaterHeater_MixedFields::SetpointTemperatureScheduleName);
172 }
173
174 30 double WaterHeaterMixed_Impl::deadbandTemperatureDifference() const {
175
1/1
✓ Branch 1 taken 30 times.
30 boost::optional<double> value = getDouble(OS_WaterHeater_MixedFields::DeadbandTemperatureDifference, true);
176
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
✗ Branch 4 not taken.
30 OS_ASSERT(value);
177
1/1
✓ Branch 1 taken 30 times.
60 return value.get();
178 }
179
180 ✗ bool WaterHeaterMixed_Impl::isDeadbandTemperatureDifferenceDefaulted() const {
181 ✗ return isEmpty(OS_WaterHeater_MixedFields::DeadbandTemperatureDifference);
182 }
183
184 30 boost::optional<double> WaterHeaterMixed_Impl::maximumTemperatureLimit() const {
185 30 return getDouble(OS_WaterHeater_MixedFields::MaximumTemperatureLimit, true);
186 }
187
188 30 std::string WaterHeaterMixed_Impl::heaterControlType() const {
189
1/1
✓ Branch 1 taken 30 times.
30 boost::optional<std::string> value = getString(OS_WaterHeater_MixedFields::HeaterControlType, true);
190
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
✗ Branch 4 not taken.
30 OS_ASSERT(value);
191
2/2
✓ Branch 1 taken 30 times.
✓ Branch 4 taken 30 times.
60 return value.get();
192 30 }
193
194 ✗ bool WaterHeaterMixed_Impl::isHeaterControlTypeDefaulted() const {
195 ✗ return isEmpty(OS_WaterHeater_MixedFields::HeaterControlType);
196 }
197
198 126 boost::optional<double> WaterHeaterMixed_Impl::heaterMaximumCapacity() const {
199 126 return getDouble(OS_WaterHeater_MixedFields::HeaterMaximumCapacity, true);
200 }
201
202 30 bool WaterHeaterMixed_Impl::isHeaterMaximumCapacityAutosized() const {
203 30 bool result = false;
204
1/1
✓ Branch 1 taken 30 times.
30 boost::optional<std::string> value = getString(OS_WaterHeater_MixedFields::HeaterMaximumCapacity, true);
205
1/2
✓ Branch 0 taken 30 times.
✗ Branch 1 not taken.
30 if (value) {
206
3/3
✓ Branch 1 taken 30 times.
✓ Branch 4 taken 30 times.
✓ Branch 7 taken 30 times.
60 result = openstudio::istringEqual(value.get(), "autosize");
207 }
208 30 return result;
209 30 }
210
211 30 boost::optional<double> WaterHeaterMixed_Impl::heaterMinimumCapacity() const {
212 30 return getDouble(OS_WaterHeater_MixedFields::HeaterMinimumCapacity, true);
213 }
214
215 30 double WaterHeaterMixed_Impl::heaterIgnitionMinimumFlowRate() const {
216
1/1
✓ Branch 1 taken 30 times.
30 boost::optional<double> value = getDouble(OS_WaterHeater_MixedFields::HeaterIgnitionMinimumFlowRate, true);
217
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
✗ Branch 4 not taken.
30 OS_ASSERT(value);
218
1/1
✓ Branch 1 taken 30 times.
60 return value.get();
219 }
220
221 ✗ bool WaterHeaterMixed_Impl::isHeaterIgnitionMinimumFlowRateDefaulted() const {
222 ✗ return isEmpty(OS_WaterHeater_MixedFields::HeaterIgnitionMinimumFlowRate);
223 }
224
225 30 double WaterHeaterMixed_Impl::heaterIgnitionDelay() const {
226
1/1
✓ Branch 1 taken 30 times.
30 boost::optional<double> value = getDouble(OS_WaterHeater_MixedFields::HeaterIgnitionDelay, true);
227
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
✗ Branch 4 not taken.
30 OS_ASSERT(value);
228
1/1
✓ Branch 1 taken 30 times.
60 return value.get();
229 }
230
231 ✗ bool WaterHeaterMixed_Impl::isHeaterIgnitionDelayDefaulted() const {
232 ✗ return isEmpty(OS_WaterHeater_MixedFields::HeaterIgnitionDelay);
233 }
234
235 30 std::string WaterHeaterMixed_Impl::heaterFuelType() const {
236
1/1
✓ Branch 1 taken 30 times.
30 boost::optional<std::string> value = getString(OS_WaterHeater_MixedFields::HeaterFuelType, true);
237
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
✗ Branch 4 not taken.
30 OS_ASSERT(value);
238
2/2
✓ Branch 1 taken 30 times.
✓ Branch 4 taken 30 times.
60 return value.get();
239 30 }
240
241 42 boost::optional<double> WaterHeaterMixed_Impl::heaterThermalEfficiency() const {
242 42 return getDouble(OS_WaterHeater_MixedFields::HeaterThermalEfficiency, true);
243 }
244
245 30 boost::optional<CurveCubic> WaterHeaterMixed_Impl::partLoadFactorCurve() const {
246
2/2
✓ Branch 1 taken 30 times.
✓ Branch 4 taken 30 times.
30 return getObject<ModelObject>().getModelObjectTarget<CurveCubic>(OS_WaterHeater_MixedFields::PartLoadFactorCurveName);
247 }
248
249 30 double WaterHeaterMixed_Impl::offCycleParasiticFuelConsumptionRate() const {
250
1/1
✓ Branch 1 taken 30 times.
30 boost::optional<double> value = getDouble(OS_WaterHeater_MixedFields::OffCycleParasiticFuelConsumptionRate, true);
251
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
✗ Branch 4 not taken.
30 OS_ASSERT(value);
252
1/1
✓ Branch 1 taken 30 times.
60 return value.get();
253 }
254
255 ✗ bool WaterHeaterMixed_Impl::isOffCycleParasiticFuelConsumptionRateDefaulted() const {
256 ✗ return isEmpty(OS_WaterHeater_MixedFields::OffCycleParasiticFuelConsumptionRate);
257 }
258
259 30 boost::optional<std::string> WaterHeaterMixed_Impl::offCycleParasiticFuelType() const {
260 30 return getString(OS_WaterHeater_MixedFields::OffCycleParasiticFuelType, true);
261 }
262
263 30 double WaterHeaterMixed_Impl::offCycleParasiticHeatFractiontoTank() const {
264
1/1
✓ Branch 1 taken 30 times.
30 boost::optional<double> value = getDouble(OS_WaterHeater_MixedFields::OffCycleParasiticHeatFractiontoTank, true);
265
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
✗ Branch 4 not taken.
30 OS_ASSERT(value);
266
1/1
✓ Branch 1 taken 30 times.
60 return value.get();
267 }
268
269 ✗ bool WaterHeaterMixed_Impl::isOffCycleParasiticHeatFractiontoTankDefaulted() const {
270 ✗ return isEmpty(OS_WaterHeater_MixedFields::OffCycleParasiticHeatFractiontoTank);
271 }
272
273 30 double WaterHeaterMixed_Impl::onCycleParasiticFuelConsumptionRate() const {
274
1/1
✓ Branch 1 taken 30 times.
30 boost::optional<double> value = getDouble(OS_WaterHeater_MixedFields::OnCycleParasiticFuelConsumptionRate, true);
275
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
✗ Branch 4 not taken.
30 OS_ASSERT(value);
276
1/1
✓ Branch 1 taken 30 times.
60 return value.get();
277 }
278
279 ✗ bool WaterHeaterMixed_Impl::isOnCycleParasiticFuelConsumptionRateDefaulted() const {
280 ✗ return isEmpty(OS_WaterHeater_MixedFields::OnCycleParasiticFuelConsumptionRate);
281 }
282
283 30 boost::optional<std::string> WaterHeaterMixed_Impl::onCycleParasiticFuelType() const {
284 30 return getString(OS_WaterHeater_MixedFields::OnCycleParasiticFuelType, true);
285 }
286
287 30 double WaterHeaterMixed_Impl::onCycleParasiticHeatFractiontoTank() const {
288
1/1
✓ Branch 1 taken 30 times.
30 boost::optional<double> value = getDouble(OS_WaterHeater_MixedFields::OnCycleParasiticHeatFractiontoTank, true);
289
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
✗ Branch 4 not taken.
30 OS_ASSERT(value);
290
1/1
✓ Branch 1 taken 30 times.
60 return value.get();
291 }
292
293 ✗ bool WaterHeaterMixed_Impl::isOnCycleParasiticHeatFractiontoTankDefaulted() const {
294 ✗ return isEmpty(OS_WaterHeater_MixedFields::OnCycleParasiticHeatFractiontoTank);
295 }
296
297 60 std::string WaterHeaterMixed_Impl::ambientTemperatureIndicator() const {
298
1/1
✓ Branch 1 taken 60 times.
60 boost::optional<std::string> value = getString(OS_WaterHeater_MixedFields::AmbientTemperatureIndicator, true);
299
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 60 times.
✗ Branch 4 not taken.
60 OS_ASSERT(value);
300
2/2
✓ Branch 1 taken 60 times.
✓ Branch 4 taken 60 times.
120 return value.get();
301 60 }
302
303 30 boost::optional<Schedule> WaterHeaterMixed_Impl::ambientTemperatureSchedule() const {
304
2/2
✓ Branch 1 taken 30 times.
✓ Branch 4 taken 30 times.
30 return getObject<ModelObject>().getModelObjectTarget<Schedule>(OS_WaterHeater_MixedFields::AmbientTemperatureScheduleName);
305 }
306
307 30 boost::optional<ThermalZone> WaterHeaterMixed_Impl::ambientTemperatureThermalZone() const {
308
2/2
✓ Branch 1 taken 30 times.
✓ Branch 4 taken 30 times.
30 return getObject<ModelObject>().getModelObjectTarget<ThermalZone>(OS_WaterHeater_MixedFields::AmbientTemperatureThermalZoneName);
309 }
310
311 30 boost::optional<std::string> WaterHeaterMixed_Impl::ambientTemperatureOutdoorAirNodeName() const {
312 30 return getString(OS_WaterHeater_MixedFields::AmbientTemperatureOutdoorAirNodeName, true);
313 }
314
315 30 boost::optional<double> WaterHeaterMixed_Impl::offCycleLossCoefficienttoAmbientTemperature() const {
316 30 return getDouble(OS_WaterHeater_MixedFields::OffCycleLossCoefficienttoAmbientTemperature, true);
317 }
318
319 30 double WaterHeaterMixed_Impl::offCycleLossFractiontoThermalZone() const {
320
1/1
✓ Branch 1 taken 30 times.
30 boost::optional<double> value = getDouble(OS_WaterHeater_MixedFields::OffCycleLossFractiontoThermalZone, true);
321
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
✗ Branch 4 not taken.
30 OS_ASSERT(value);
322
1/1
✓ Branch 1 taken 30 times.
60 return value.get();
323 }
324
325 ✗ bool WaterHeaterMixed_Impl::isOffCycleLossFractiontoThermalZoneDefaulted() const {
326 ✗ return isEmpty(OS_WaterHeater_MixedFields::OffCycleLossFractiontoThermalZone);
327 }
328
329 30 boost::optional<double> WaterHeaterMixed_Impl::onCycleLossCoefficienttoAmbientTemperature() const {
330 30 return getDouble(OS_WaterHeater_MixedFields::OnCycleLossCoefficienttoAmbientTemperature, true);
331 }
332
333 30 double WaterHeaterMixed_Impl::onCycleLossFractiontoThermalZone() const {
334
1/1
✓ Branch 1 taken 30 times.
30 boost::optional<double> value = getDouble(OS_WaterHeater_MixedFields::OnCycleLossFractiontoThermalZone, true);
335
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
✗ Branch 4 not taken.
30 OS_ASSERT(value);
336
1/1
✓ Branch 1 taken 30 times.
60 return value.get();
337 }
338
339 ✗ bool WaterHeaterMixed_Impl::isOnCycleLossFractiontoThermalZoneDefaulted() const {
340 ✗ return isEmpty(OS_WaterHeater_MixedFields::OnCycleLossFractiontoThermalZone);
341 }
342
343 47 boost::optional<double> WaterHeaterMixed_Impl::peakUseFlowRate() const {
344 47 return getDouble(OS_WaterHeater_MixedFields::PeakUseFlowRate, true);
345 }
346
347 35 boost::optional<Schedule> WaterHeaterMixed_Impl::useFlowRateFractionSchedule() const {
348
2/2
✓ Branch 1 taken 35 times.
✓ Branch 4 taken 35 times.
35 return getObject<ModelObject>().getModelObjectTarget<Schedule>(OS_WaterHeater_MixedFields::UseFlowRateFractionScheduleName);
349 }
350
351 30 boost::optional<Schedule> WaterHeaterMixed_Impl::coldWaterSupplyTemperatureSchedule() const {
352
2/2
✓ Branch 1 taken 30 times.
✓ Branch 4 taken 30 times.
30 return getObject<ModelObject>().getModelObjectTarget<Schedule>(OS_WaterHeater_MixedFields::ColdWaterSupplyTemperatureScheduleName);
353 }
354
355 30 double WaterHeaterMixed_Impl::useSideEffectiveness() const {
356
1/1
✓ Branch 1 taken 30 times.
30 boost::optional<double> value = getDouble(OS_WaterHeater_MixedFields::UseSideEffectiveness, true);
357
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
✗ Branch 4 not taken.
30 OS_ASSERT(value);
358
1/1
✓ Branch 1 taken 30 times.
60 return value.get();
359 }
360
361 ✗ bool WaterHeaterMixed_Impl::isUseSideEffectivenessDefaulted() const {
362 ✗ return isEmpty(OS_WaterHeater_MixedFields::UseSideEffectiveness);
363 }
364
365 30 double WaterHeaterMixed_Impl::sourceSideEffectiveness() const {
366
1/1
✓ Branch 1 taken 30 times.
30 boost::optional<double> value = getDouble(OS_WaterHeater_MixedFields::SourceSideEffectiveness, true);
367
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
✗ Branch 4 not taken.
30 OS_ASSERT(value);
368
1/1
✓ Branch 1 taken 30 times.
60 return value.get();
369 }
370
371 ✗ bool WaterHeaterMixed_Impl::isSourceSideEffectivenessDefaulted() const {
372 ✗ return isEmpty(OS_WaterHeater_MixedFields::SourceSideEffectiveness);
373 }
374
375 ✗ boost::optional<double> WaterHeaterMixed_Impl::useSideDesignFlowRate() const {
376 ✗ return getDouble(OS_WaterHeater_MixedFields::UseSideDesignFlowRate, true);
377 }
378
379 ✗ bool WaterHeaterMixed_Impl::isUseSideDesignFlowRateDefaulted() const {
380 ✗ return isEmpty(OS_WaterHeater_MixedFields::UseSideDesignFlowRate);
381 }
382
383 30 bool WaterHeaterMixed_Impl::isUseSideDesignFlowRateAutosized() const {
384 30 bool result = false;
385
1/1
✓ Branch 1 taken 30 times.
30 boost::optional<std::string> value = getString(OS_WaterHeater_MixedFields::UseSideDesignFlowRate, true);
386
1/2
✓ Branch 0 taken 30 times.
✗ Branch 1 not taken.
30 if (value) {
387
3/3
✓ Branch 1 taken 30 times.
✓ Branch 4 taken 30 times.
✓ Branch 7 taken 30 times.
60 result = openstudio::istringEqual(value.get(), "autosize");
388 }
389 30 return result;
390 30 }
391
392 ✗ boost::optional<double> WaterHeaterMixed_Impl::sourceSideDesignFlowRate() const {
393 ✗ return getDouble(OS_WaterHeater_MixedFields::SourceSideDesignFlowRate, true);
394 }
395
396 ✗ bool WaterHeaterMixed_Impl::isSourceSideDesignFlowRateDefaulted() const {
397 ✗ return isEmpty(OS_WaterHeater_MixedFields::SourceSideDesignFlowRate);
398 }
399
400 30 bool WaterHeaterMixed_Impl::isSourceSideDesignFlowRateAutosized() const {
401 30 bool result = false;
402
1/1
✓ Branch 1 taken 30 times.
30 boost::optional<std::string> value = getString(OS_WaterHeater_MixedFields::SourceSideDesignFlowRate, true);
403
1/2
✓ Branch 0 taken 30 times.
✗ Branch 1 not taken.
30 if (value) {
404
3/3
✓ Branch 1 taken 30 times.
✓ Branch 4 taken 30 times.
✓ Branch 7 taken 30 times.
60 result = openstudio::istringEqual(value.get(), "autosize");
405 }
406 30 return result;
407 30 }
408
409 30 double WaterHeaterMixed_Impl::indirectWaterHeatingRecoveryTime() const {
410
1/1
✓ Branch 1 taken 30 times.
30 boost::optional<double> value = getDouble(OS_WaterHeater_MixedFields::IndirectWaterHeatingRecoveryTime, true);
411
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 30 times.
✗ Branch 4 not taken.
30 OS_ASSERT(value);
412
1/1
✓ Branch 1 taken 30 times.
60 return value.get();
413 }
414
415 ✗ bool WaterHeaterMixed_Impl::isIndirectWaterHeatingRecoveryTimeDefaulted() const {
416 ✗ return isEmpty(OS_WaterHeater_MixedFields::IndirectWaterHeatingRecoveryTime);
417 }
418
419 47 bool WaterHeaterMixed_Impl::setTankVolume(boost::optional<double> tankVolume) {
420 47 bool result = false;
421
1/2
✓ Branch 0 taken 47 times.
✗ Branch 1 not taken.
47 if (tankVolume) {
422 47 result = setDouble(OS_WaterHeater_MixedFields::TankVolume, tankVolume.get());
423 } else {
424 ✗ result = setString(OS_WaterHeater_MixedFields::TankVolume, "");
425 }
426 47 return result;
427 }
428
429 ✗ void WaterHeaterMixed_Impl::resetTankVolume() {
430 ✗ bool result = setString(OS_WaterHeater_MixedFields::TankVolume, "");
431 ✗ OS_ASSERT(result);
432 ✗ }
433
434 ✗ void WaterHeaterMixed_Impl::autosizeTankVolume() {
435 ✗ bool result = setString(OS_WaterHeater_MixedFields::TankVolume, "autosize");
436 ✗ OS_ASSERT(result);
437 ✗ }
438
439 53 bool WaterHeaterMixed_Impl::setSetpointTemperatureSchedule(Schedule& schedule) {
440
3/3
✓ Branch 1 taken 53 times.
✓ Branch 4 taken 53 times.
✓ Branch 7 taken 53 times.
212 bool result = setSchedule(OS_WaterHeater_MixedFields::SetpointTemperatureScheduleName, "WaterHeaterMixed", "Setpoint Temperature", schedule);
441 53 return result;
442 }
443
444 ✗ void WaterHeaterMixed_Impl::resetSetpointTemperatureSchedule() {
445 ✗ bool result = setString(OS_WaterHeater_MixedFields::SetpointTemperatureScheduleName, "");
446 ✗ OS_ASSERT(result);
447 ✗ }
448
449 46 bool WaterHeaterMixed_Impl::setDeadbandTemperatureDifference(double deadbandTemperatureDifference) {
450 46 bool result = setDouble(OS_WaterHeater_MixedFields::DeadbandTemperatureDifference, deadbandTemperatureDifference);
451 46 return result;
452 }
453
454 ✗ void WaterHeaterMixed_Impl::resetDeadbandTemperatureDifference() {
455 ✗ bool result = setString(OS_WaterHeater_MixedFields::DeadbandTemperatureDifference, "");
456 ✗ OS_ASSERT(result);
457 ✗ }
458
459 46 bool WaterHeaterMixed_Impl::setMaximumTemperatureLimit(boost::optional<double> maximumTemperatureLimit) {
460 46 bool result = false;
461
1/2
✓ Branch 0 taken 46 times.
✗ Branch 1 not taken.
46 if (maximumTemperatureLimit) {
462 46 result = setDouble(OS_WaterHeater_MixedFields::MaximumTemperatureLimit, maximumTemperatureLimit.get());
463 } else {
464 ✗ result = setString(OS_WaterHeater_MixedFields::MaximumTemperatureLimit, "");
465 }
466
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 46 times.
46 OS_ASSERT(result);
467 46 return result;
468 }
469
470 ✗ void WaterHeaterMixed_Impl::resetMaximumTemperatureLimit() {
471 ✗ bool result = setString(OS_WaterHeater_MixedFields::MaximumTemperatureLimit, "");
472 ✗ OS_ASSERT(result);
473 ✗ }
474
475 46 bool WaterHeaterMixed_Impl::setHeaterControlType(const std::string& heaterControlType) {
476 46 bool result = setString(OS_WaterHeater_MixedFields::HeaterControlType, heaterControlType);
477 46 return result;
478 }
479
480 ✗ void WaterHeaterMixed_Impl::resetHeaterControlType() {
481 ✗ bool result = setString(OS_WaterHeater_MixedFields::HeaterControlType, "");
482 ✗ OS_ASSERT(result);
483 ✗ }
484
485 52 bool WaterHeaterMixed_Impl::setHeaterMaximumCapacity(boost::optional<double> heaterMaximumCapacity) {
486 52 bool result = false;
487
1/2
✓ Branch 0 taken 52 times.
✗ Branch 1 not taken.
52 if (heaterMaximumCapacity) {
488 52 result = setDouble(OS_WaterHeater_MixedFields::HeaterMaximumCapacity, heaterMaximumCapacity.get());
489 } else {
490 ✗ result = setString(OS_WaterHeater_MixedFields::HeaterMaximumCapacity, "");
491 }
492 52 return result;
493 }
494
495 ✗ void WaterHeaterMixed_Impl::resetHeaterMaximumCapacity() {
496 ✗ bool result = setString(OS_WaterHeater_MixedFields::HeaterMaximumCapacity, "");
497 ✗ OS_ASSERT(result);
498 ✗ }
499
500 ✗ void WaterHeaterMixed_Impl::autosizeHeaterMaximumCapacity() {
501 ✗ bool result = setString(OS_WaterHeater_MixedFields::HeaterMaximumCapacity, "autosize");
502 ✗ OS_ASSERT(result);
503 ✗ }
504
505 ✗ bool WaterHeaterMixed_Impl::setHeaterMinimumCapacity(boost::optional<double> heaterMinimumCapacity) {
506 ✗ bool result = false;
507 ✗ if (heaterMinimumCapacity) {
508 ✗ result = setDouble(OS_WaterHeater_MixedFields::HeaterMinimumCapacity, heaterMinimumCapacity.get());
509 } else {
510 ✗ result = setString(OS_WaterHeater_MixedFields::HeaterMinimumCapacity, "");
511 }
512 ✗ return result;
513 }
514
515 ✗ void WaterHeaterMixed_Impl::resetHeaterMinimumCapacity() {
516 ✗ bool result = setString(OS_WaterHeater_MixedFields::HeaterMinimumCapacity, "");
517 ✗ OS_ASSERT(result);
518 ✗ }
519
520 ✗ bool WaterHeaterMixed_Impl::setHeaterIgnitionMinimumFlowRate(double heaterIgnitionMinimumFlowRate) {
521 ✗ bool result = setDouble(OS_WaterHeater_MixedFields::HeaterIgnitionMinimumFlowRate, heaterIgnitionMinimumFlowRate);
522 ✗ return result;
523 }
524
525 ✗ void WaterHeaterMixed_Impl::resetHeaterIgnitionMinimumFlowRate() {
526 ✗ bool result = setString(OS_WaterHeater_MixedFields::HeaterIgnitionMinimumFlowRate, "");
527 ✗ OS_ASSERT(result);
528 ✗ }
529
530 ✗ bool WaterHeaterMixed_Impl::setHeaterIgnitionDelay(double heaterIgnitionDelay) {
531 ✗ bool result = setDouble(OS_WaterHeater_MixedFields::HeaterIgnitionDelay, heaterIgnitionDelay);
532 ✗ return result;
533 }
534
535 ✗ void WaterHeaterMixed_Impl::resetHeaterIgnitionDelay() {
536 ✗ bool result = setString(OS_WaterHeater_MixedFields::HeaterIgnitionDelay, "");
537 ✗ OS_ASSERT(result);
538 ✗ }
539
540 48 bool WaterHeaterMixed_Impl::setHeaterFuelType(const FuelType& heaterFuelType) {
541
2/2
✓ Branch 1 taken 48 times.
✓ Branch 4 taken 48 times.
48 const bool result = setString(OS_WaterHeater_MixedFields::HeaterFuelType, heaterFuelType.valueDescription());
542 48 return result;
543 }
544
545 57 bool WaterHeaterMixed_Impl::setHeaterThermalEfficiency(boost::optional<double> heaterThermalEfficiency) {
546 57 bool result = false;
547
1/2
✓ Branch 0 taken 57 times.
✗ Branch 1 not taken.
57 if (heaterThermalEfficiency) {
548 57 result = setDouble(OS_WaterHeater_MixedFields::HeaterThermalEfficiency, heaterThermalEfficiency.get());
549 } else {
550 ✗ result = setString(OS_WaterHeater_MixedFields::HeaterThermalEfficiency, "");
551 }
552 57 return result;
553 }
554
555 ✗ void WaterHeaterMixed_Impl::resetHeaterThermalEfficiency() {
556 ✗ bool result = setString(OS_WaterHeater_MixedFields::HeaterThermalEfficiency, "");
557 ✗ OS_ASSERT(result);
558 ✗ }
559
560 ✗ bool WaterHeaterMixed_Impl::setPartLoadFactorCurve(const boost::optional<CurveCubic>& partLoadFactorCurve) {
561 ✗ bool result = false;
562 ✗ if (partLoadFactorCurve) {
563 ✗ result = setPointer(OS_WaterHeater_MixedFields::PartLoadFactorCurveName, partLoadFactorCurve.get().handle());
564 } else {
565 ✗ result = setString(OS_WaterHeater_MixedFields::PartLoadFactorCurveName, "");
566 }
567 ✗ return result;
568 }
569
570 ✗ void WaterHeaterMixed_Impl::resetPartLoadFactorCurve() {
571 ✗ bool result = setString(OS_WaterHeater_MixedFields::PartLoadFactorCurveName, "");
572 ✗ OS_ASSERT(result);
573 ✗ }
574
575 47 bool WaterHeaterMixed_Impl::setOffCycleParasiticFuelConsumptionRate(double offCycleParasiticFuelConsumptionRate) {
576 47 bool result = setDouble(OS_WaterHeater_MixedFields::OffCycleParasiticFuelConsumptionRate, offCycleParasiticFuelConsumptionRate);
577 47 return result;
578 }
579
580 ✗ void WaterHeaterMixed_Impl::resetOffCycleParasiticFuelConsumptionRate() {
581 ✗ bool result = setString(OS_WaterHeater_MixedFields::OffCycleParasiticFuelConsumptionRate, "");
582 ✗ OS_ASSERT(result);
583 ✗ }
584
585 46 bool WaterHeaterMixed_Impl::setOffCycleParasiticFuelType(const FuelType& offCycleParasiticFuelType) {
586
2/2
✓ Branch 1 taken 46 times.
✓ Branch 4 taken 46 times.
46 const bool result = setString(OS_WaterHeater_MixedFields::OffCycleParasiticFuelType, offCycleParasiticFuelType.valueDescription());
587 46 return result;
588 }
589
590 ✗ void WaterHeaterMixed_Impl::resetOffCycleParasiticFuelType() {
591 ✗ bool result = setString(OS_WaterHeater_MixedFields::OffCycleParasiticFuelType, "");
592 ✗ OS_ASSERT(result);
593 ✗ }
594
595 46 bool WaterHeaterMixed_Impl::setOffCycleParasiticHeatFractiontoTank(double offCycleParasiticHeatFractiontoTank) {
596 46 bool result = setDouble(OS_WaterHeater_MixedFields::OffCycleParasiticHeatFractiontoTank, offCycleParasiticHeatFractiontoTank);
597 46 return result;
598 }
599
600 ✗ void WaterHeaterMixed_Impl::resetOffCycleParasiticHeatFractiontoTank() {
601 ✗ bool result = setString(OS_WaterHeater_MixedFields::OffCycleParasiticHeatFractiontoTank, "");
602 ✗ OS_ASSERT(result);
603 ✗ }
604
605 1 bool WaterHeaterMixed_Impl::setOnCycleParasiticFuelConsumptionRate(double onCycleParasiticFuelConsumptionRate) {
606 1 bool result = setDouble(OS_WaterHeater_MixedFields::OnCycleParasiticFuelConsumptionRate, onCycleParasiticFuelConsumptionRate);
607 1 return result;
608 }
609
610 ✗ void WaterHeaterMixed_Impl::resetOnCycleParasiticFuelConsumptionRate() {
611 ✗ bool result = setString(OS_WaterHeater_MixedFields::OnCycleParasiticFuelConsumptionRate, "");
612 ✗ OS_ASSERT(result);
613 ✗ }
614
615 46 bool WaterHeaterMixed_Impl::setOnCycleParasiticFuelType(const FuelType& onCycleParasiticFuelType) {
616
2/2
✓ Branch 1 taken 46 times.
✓ Branch 4 taken 46 times.
46 const bool result = setString(OS_WaterHeater_MixedFields::OnCycleParasiticFuelType, onCycleParasiticFuelType.valueDescription());
617 46 return result;
618 }
619
620 ✗ void WaterHeaterMixed_Impl::resetOnCycleParasiticFuelType() {
621 ✗ bool result = setString(OS_WaterHeater_MixedFields::OnCycleParasiticFuelType, "");
622 ✗ OS_ASSERT(result);
623 ✗ }
624
625 ✗ bool WaterHeaterMixed_Impl::setOnCycleParasiticHeatFractiontoTank(double onCycleParasiticHeatFractiontoTank) {
626 ✗ bool result = setDouble(OS_WaterHeater_MixedFields::OnCycleParasiticHeatFractiontoTank, onCycleParasiticHeatFractiontoTank);
627 ✗ return result;
628 }
629
630 ✗ void WaterHeaterMixed_Impl::resetOnCycleParasiticHeatFractiontoTank() {
631 ✗ bool result = setString(OS_WaterHeater_MixedFields::OnCycleParasiticHeatFractiontoTank, "");
632 ✗ OS_ASSERT(result);
633 ✗ }
634
635 52 bool WaterHeaterMixed_Impl::setAmbientTemperatureIndicator(const std::string& ambientTemperatureIndicator) {
636 52 bool result = setString(OS_WaterHeater_MixedFields::AmbientTemperatureIndicator, ambientTemperatureIndicator);
637 52 return result;
638 }
639
640 47 bool WaterHeaterMixed_Impl::setAmbientTemperatureSchedule(Schedule& schedule) {
641
3/3
✓ Branch 1 taken 47 times.
✓ Branch 4 taken 47 times.
✓ Branch 7 taken 47 times.
188 bool result = setSchedule(OS_WaterHeater_MixedFields::AmbientTemperatureScheduleName, "WaterHeaterMixed", "Ambient Temperature", schedule);
642 47 return result;
643 }
644
645 ✗ void WaterHeaterMixed_Impl::resetAmbientTemperatureSchedule() {
646 ✗ bool result = setString(OS_WaterHeater_MixedFields::AmbientTemperatureScheduleName, "");
647 ✗ OS_ASSERT(result);
648 ✗ }
649
650 5 bool WaterHeaterMixed_Impl::setAmbientTemperatureThermalZone(const boost::optional<ThermalZone>& ambientTemperatureThermalZone) {
651 5 bool result = false;
652
1/2
✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
5 if (ambientTemperatureThermalZone) {
653
3/3
✓ Branch 1 taken 5 times.
✓ Branch 4 taken 5 times.
✓ Branch 7 taken 5 times.
5 result = setPointer(OS_WaterHeater_MixedFields::AmbientTemperatureThermalZoneName, ambientTemperatureThermalZone.get().handle());
654 } else {
655 ✗ result = setString(OS_WaterHeater_MixedFields::AmbientTemperatureThermalZoneName, "");
656 }
657 5 return result;
658 }
659
660 ✗ void WaterHeaterMixed_Impl::resetAmbientTemperatureThermalZone() {
661 ✗ bool result = setString(OS_WaterHeater_MixedFields::AmbientTemperatureThermalZoneName, "");
662 ✗ OS_ASSERT(result);
663 ✗ }
664
665 ✗ bool WaterHeaterMixed_Impl::setAmbientTemperatureOutdoorAirNodeName(boost::optional<std::string> ambientTemperatureOutdoorAirNodeName) {
666 ✗ bool result = false;
667 ✗ if (ambientTemperatureOutdoorAirNodeName) {
668 ✗ result = setString(OS_WaterHeater_MixedFields::AmbientTemperatureOutdoorAirNodeName, ambientTemperatureOutdoorAirNodeName.get());
669 } else {
670 ✗ result = setString(OS_WaterHeater_MixedFields::AmbientTemperatureOutdoorAirNodeName, "");
671 }
672 ✗ OS_ASSERT(result);
673 ✗ return result;
674 }
675
676 ✗ void WaterHeaterMixed_Impl::resetAmbientTemperatureOutdoorAirNodeName() {
677 ✗ bool result = setString(OS_WaterHeater_MixedFields::AmbientTemperatureOutdoorAirNodeName, "");
678 ✗ OS_ASSERT(result);
679 ✗ }
680
681 47 bool WaterHeaterMixed_Impl::setOffCycleLossCoefficienttoAmbientTemperature(boost::optional<double> offCycleLossCoefficienttoAmbientTemperature) {
682 47 bool result = false;
683
1/2
✓ Branch 0 taken 47 times.
✗ Branch 1 not taken.
47 if (offCycleLossCoefficienttoAmbientTemperature) {
684 result =
685 47 setDouble(OS_WaterHeater_MixedFields::OffCycleLossCoefficienttoAmbientTemperature, offCycleLossCoefficienttoAmbientTemperature.get());
686 } else {
687 ✗ result = setString(OS_WaterHeater_MixedFields::OffCycleLossCoefficienttoAmbientTemperature, "");
688 }
689 47 return result;
690 }
691
692 ✗ void WaterHeaterMixed_Impl::resetOffCycleLossCoefficienttoAmbientTemperature() {
693 ✗ bool result = setString(OS_WaterHeater_MixedFields::OffCycleLossCoefficienttoAmbientTemperature, "");
694 ✗ OS_ASSERT(result);
695 ✗ }
696
697 ✗ bool WaterHeaterMixed_Impl::setOffCycleLossFractiontoThermalZone(double offCycleLossFractiontoThermalZone) {
698 ✗ bool result = setDouble(OS_WaterHeater_MixedFields::OffCycleLossFractiontoThermalZone, offCycleLossFractiontoThermalZone);
699 ✗ return result;
700 }
701
702 ✗ void WaterHeaterMixed_Impl::resetOffCycleLossFractiontoThermalZone() {
703 ✗ bool result = setString(OS_WaterHeater_MixedFields::OffCycleLossFractiontoThermalZone, "");
704 ✗ OS_ASSERT(result);
705 ✗ }
706
707 47 bool WaterHeaterMixed_Impl::setOnCycleLossCoefficienttoAmbientTemperature(boost::optional<double> onCycleLossCoefficienttoAmbientTemperature) {
708 47 bool result = false;
709
1/2
✓ Branch 0 taken 47 times.
✗ Branch 1 not taken.
47 if (onCycleLossCoefficienttoAmbientTemperature) {
710 47 result = setDouble(OS_WaterHeater_MixedFields::OnCycleLossCoefficienttoAmbientTemperature, onCycleLossCoefficienttoAmbientTemperature.get());
711 } else {
712 ✗ result = setString(OS_WaterHeater_MixedFields::OnCycleLossCoefficienttoAmbientTemperature, "");
713 }
714 47 return result;
715 }
716
717 ✗ void WaterHeaterMixed_Impl::resetOnCycleLossCoefficienttoAmbientTemperature() {
718 ✗ bool result = setString(OS_WaterHeater_MixedFields::OnCycleLossCoefficienttoAmbientTemperature, "");
719 ✗ OS_ASSERT(result);
720 ✗ }
721
722 ✗ bool WaterHeaterMixed_Impl::setOnCycleLossFractiontoThermalZone(double onCycleLossFractiontoThermalZone) {
723 ✗ bool result = setDouble(OS_WaterHeater_MixedFields::OnCycleLossFractiontoThermalZone, onCycleLossFractiontoThermalZone);
724 ✗ return result;
725 }
726
727 ✗ void WaterHeaterMixed_Impl::resetOnCycleLossFractiontoThermalZone() {
728 ✗ bool result = setString(OS_WaterHeater_MixedFields::OnCycleLossFractiontoThermalZone, "");
729 ✗ OS_ASSERT(result);
730 ✗ }
731
732 1 bool WaterHeaterMixed_Impl::setPeakUseFlowRate(boost::optional<double> peakUseFlowRate) {
733 1 bool result = false;
734
1/2
✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.
1 if (peakUseFlowRate) {
735 1 result = setDouble(OS_WaterHeater_MixedFields::PeakUseFlowRate, peakUseFlowRate.get());
736 } else {
737 ✗ result = setString(OS_WaterHeater_MixedFields::PeakUseFlowRate, "");
738 }
739 1 return result;
740 }
741
742 1 void WaterHeaterMixed_Impl::resetPeakUseFlowRate() {
743
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
2 bool result = setString(OS_WaterHeater_MixedFields::PeakUseFlowRate, "");
744
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
1 OS_ASSERT(result);
745 1 }
746
747 1 bool WaterHeaterMixed_Impl::setUseFlowRateFractionSchedule(Schedule& schedule) {
748
3/3
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
4 bool result = setSchedule(OS_WaterHeater_MixedFields::UseFlowRateFractionScheduleName, "WaterHeaterMixed", "Use Flow Rate Fraction", schedule);
749 1 return result;
750 }
751
752 1 void WaterHeaterMixed_Impl::resetUseFlowRateFractionSchedule() {
753
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
2 bool result = setString(OS_WaterHeater_MixedFields::UseFlowRateFractionScheduleName, "");
754
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
1 OS_ASSERT(result);
755 1 }
756
757 ✗ bool WaterHeaterMixed_Impl::setColdWaterSupplyTemperatureSchedule(Schedule& schedule) {
758 ✗ bool result = setSchedule(OS_WaterHeater_MixedFields::ColdWaterSupplyTemperatureScheduleName, "WaterHeaterMixed",
759 "Cold Water Supply Temperature", schedule);
760 ✗ return result;
761 }
762
763 ✗ void WaterHeaterMixed_Impl::resetColdWaterSupplyTemperatureSchedule() {
764 ✗ bool result = setString(OS_WaterHeater_MixedFields::ColdWaterSupplyTemperatureScheduleName, "");
765 ✗ OS_ASSERT(result);
766 ✗ }
767
768 46 bool WaterHeaterMixed_Impl::setUseSideEffectiveness(double useSideEffectiveness) {
769 46 bool result = setDouble(OS_WaterHeater_MixedFields::UseSideEffectiveness, useSideEffectiveness);
770 46 return result;
771 }
772
773 ✗ void WaterHeaterMixed_Impl::resetUseSideEffectiveness() {
774 ✗ bool result = setString(OS_WaterHeater_MixedFields::UseSideEffectiveness, "");
775 ✗ OS_ASSERT(result);
776 ✗ }
777
778 46 bool WaterHeaterMixed_Impl::setSourceSideEffectiveness(double sourceSideEffectiveness) {
779 46 bool result = setDouble(OS_WaterHeater_MixedFields::SourceSideEffectiveness, sourceSideEffectiveness);
780 46 return result;
781 }
782
783 ✗ void WaterHeaterMixed_Impl::resetSourceSideEffectiveness() {
784 ✗ bool result = setString(OS_WaterHeater_MixedFields::SourceSideEffectiveness, "");
785 ✗ OS_ASSERT(result);
786 ✗ }
787
788 ✗ bool WaterHeaterMixed_Impl::setUseSideDesignFlowRate(boost::optional<double> useSideDesignFlowRate) {
789 ✗ bool result = false;
790 ✗ if (useSideDesignFlowRate) {
791 ✗ result = setDouble(OS_WaterHeater_MixedFields::UseSideDesignFlowRate, useSideDesignFlowRate.get());
792 } else {
793 ✗ result = setString(OS_WaterHeater_MixedFields::UseSideDesignFlowRate, "");
794 }
795 ✗ return result;
796 }
797
798 ✗ void WaterHeaterMixed_Impl::resetUseSideDesignFlowRate() {
799 ✗ bool result = setString(OS_WaterHeater_MixedFields::UseSideDesignFlowRate, "");
800 ✗ OS_ASSERT(result);
801 ✗ }
802
803 46 void WaterHeaterMixed_Impl::autosizeUseSideDesignFlowRate() {
804
2/2
✓ Branch 1 taken 46 times.
✓ Branch 4 taken 46 times.
92 bool result = setString(OS_WaterHeater_MixedFields::UseSideDesignFlowRate, "autosize");
805
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 46 times.
46 OS_ASSERT(result);
806 46 }
807
808 ✗ bool WaterHeaterMixed_Impl::setSourceSideDesignFlowRate(boost::optional<double> sourceSideDesignFlowRate) {
809 ✗ bool result = false;
810 ✗ if (sourceSideDesignFlowRate) {
811 ✗ result = setDouble(OS_WaterHeater_MixedFields::SourceSideDesignFlowRate, sourceSideDesignFlowRate.get());
812 } else {
813 ✗ result = setString(OS_WaterHeater_MixedFields::SourceSideDesignFlowRate, "");
814 }
815 ✗ return result;
816 }
817
818 ✗ void WaterHeaterMixed_Impl::resetSourceSideDesignFlowRate() {
819 ✗ bool result = setString(OS_WaterHeater_MixedFields::SourceSideDesignFlowRate, "");
820 ✗ OS_ASSERT(result);
821 ✗ }
822
823 46 void WaterHeaterMixed_Impl::autosizeSourceSideDesignFlowRate() {
824
2/2
✓ Branch 1 taken 46 times.
✓ Branch 4 taken 46 times.
92 bool result = setString(OS_WaterHeater_MixedFields::SourceSideDesignFlowRate, "autosize");
825
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 46 times.
46 OS_ASSERT(result);
826 46 }
827
828 46 bool WaterHeaterMixed_Impl::setIndirectWaterHeatingRecoveryTime(double indirectWaterHeatingRecoveryTime) {
829 46 bool result = setDouble(OS_WaterHeater_MixedFields::IndirectWaterHeatingRecoveryTime, indirectWaterHeatingRecoveryTime);
830 46 return result;
831 }
832
833 ✗ void WaterHeaterMixed_Impl::resetIndirectWaterHeatingRecoveryTime() {
834 ✗ bool result = setString(OS_WaterHeater_MixedFields::IndirectWaterHeatingRecoveryTime, "");
835 ✗ OS_ASSERT(result);
836 ✗ }
837
838 ✗ std::vector<std::string> WaterHeaterMixed_Impl::heaterControlTypeValues() const {
839 ✗ return WaterHeaterMixed::heaterControlTypeValues();
840 }
841
842 ✗ std::vector<std::string> WaterHeaterMixed_Impl::heaterFuelTypeValues() const {
843 ✗ return WaterHeaterMixed::heaterFuelTypeValues();
844 }
845
846 ✗ std::vector<std::string> WaterHeaterMixed_Impl::offCycleParasiticFuelTypeValues() const {
847 ✗ return WaterHeaterMixed::offCycleParasiticFuelTypeValues();
848 }
849
850 ✗ std::vector<std::string> WaterHeaterMixed_Impl::onCycleParasiticFuelTypeValues() const {
851 ✗ return WaterHeaterMixed::onCycleParasiticFuelTypeValues();
852 }
853
854 ✗ std::vector<std::string> WaterHeaterMixed_Impl::ambientTemperatureIndicatorValues() const {
855 ✗ return WaterHeaterMixed::ambientTemperatureIndicatorValues();
856 }
857
858 ✗ boost::optional<ModelObject> WaterHeaterMixed_Impl::setpointTemperatureScheduleAsModelObject() const {
859 ✗ OptionalModelObject result;
860 ✗ OptionalSchedule intermediate = setpointTemperatureSchedule();
861 ✗ if (intermediate) {
862 ✗ result = *intermediate;
863 }
864 ✗ return result;
865 ✗ }
866
867 ✗ boost::optional<ModelObject> WaterHeaterMixed_Impl::partLoadFactorCurveAsModelObject() const {
868 ✗ OptionalModelObject result;
869 ✗ OptionalCurveCubic intermediate = partLoadFactorCurve();
870 ✗ if (intermediate) {
871 ✗ result = *intermediate;
872 }
873 ✗ return result;
874 ✗ }
875
876 ✗ boost::optional<ModelObject> WaterHeaterMixed_Impl::ambientTemperatureScheduleAsModelObject() const {
877 ✗ OptionalModelObject result;
878 ✗ OptionalSchedule intermediate = ambientTemperatureSchedule();
879 ✗ if (intermediate) {
880 ✗ result = *intermediate;
881 }
882 ✗ return result;
883 ✗ }
884
885 ✗ boost::optional<ModelObject> WaterHeaterMixed_Impl::ambientTemperatureThermalZoneAsModelObject() const {
886 ✗ OptionalModelObject result;
887 ✗ OptionalThermalZone intermediate = ambientTemperatureThermalZone();
888 ✗ if (intermediate) {
889 ✗ result = *intermediate;
890 }
891 ✗ return result;
892 ✗ }
893
894 ✗ boost::optional<ModelObject> WaterHeaterMixed_Impl::useFlowRateFractionScheduleAsModelObject() const {
895 ✗ OptionalModelObject result;
896 ✗ OptionalSchedule intermediate = useFlowRateFractionSchedule();
897 ✗ if (intermediate) {
898 ✗ result = *intermediate;
899 }
900 ✗ return result;
901 ✗ }
902
903 ✗ boost::optional<ModelObject> WaterHeaterMixed_Impl::coldWaterSupplyTemperatureScheduleAsModelObject() const {
904 ✗ OptionalModelObject result;
905 ✗ OptionalSchedule intermediate = coldWaterSupplyTemperatureSchedule();
906 ✗ if (intermediate) {
907 ✗ result = *intermediate;
908 }
909 ✗ return result;
910 ✗ }
911
912 ✗ bool WaterHeaterMixed_Impl::setSetpointTemperatureScheduleAsModelObject(const boost::optional<ModelObject>& modelObject) {
913 ✗ if (modelObject) {
914 ✗ OptionalSchedule intermediate = modelObject->optionalCast<Schedule>();
915 ✗ if (intermediate) {
916 ✗ Schedule schedule(*intermediate);
917 ✗ return setSetpointTemperatureSchedule(schedule);
918 ✗ } else {
919 ✗ return false;
920 }
921 ✗ } else {
922 ✗ resetSetpointTemperatureSchedule();
923 }
924 ✗ return true;
925 }
926
927 ✗ bool WaterHeaterMixed_Impl::setPartLoadFactorCurveAsModelObject(const boost::optional<ModelObject>& modelObject) {
928 ✗ if (modelObject) {
929 ✗ OptionalCurveCubic intermediate = modelObject->optionalCast<CurveCubic>();
930 ✗ if (intermediate) {
931 ✗ return setPartLoadFactorCurve(*intermediate);
932 } else {
933 ✗ return false;
934 }
935 ✗ } else {
936 ✗ resetPartLoadFactorCurve();
937 }
938 ✗ return true;
939 }
940
941 ✗ bool WaterHeaterMixed_Impl::setAmbientTemperatureScheduleAsModelObject(const boost::optional<ModelObject>& modelObject) {
942 ✗ if (modelObject) {
943 ✗ OptionalSchedule intermediate = modelObject->optionalCast<Schedule>();
944 ✗ if (intermediate) {
945 ✗ Schedule schedule(*intermediate);
946 ✗ return setAmbientTemperatureSchedule(schedule);
947 ✗ } else {
948 ✗ return false;
949 }
950 ✗ } else {
951 ✗ resetAmbientTemperatureSchedule();
952 }
953 ✗ return true;
954 }
955
956 ✗ bool WaterHeaterMixed_Impl::setAmbientTemperatureThermalZoneAsModelObject(const boost::optional<ModelObject>& modelObject) {
957 ✗ if (modelObject) {
958 ✗ OptionalThermalZone intermediate = modelObject->optionalCast<ThermalZone>();
959 ✗ if (intermediate) {
960 ✗ return setAmbientTemperatureThermalZone(*intermediate);
961 } else {
962 ✗ return false;
963 }
964 ✗ } else {
965 ✗ resetAmbientTemperatureThermalZone();
966 }
967 ✗ return true;
968 }
969
970 ✗ bool WaterHeaterMixed_Impl::setUseFlowRateFractionScheduleAsModelObject(const boost::optional<ModelObject>& modelObject) {
971 ✗ if (modelObject) {
972 ✗ OptionalSchedule intermediate = modelObject->optionalCast<Schedule>();
973 ✗ if (intermediate) {
974 ✗ Schedule schedule(*intermediate);
975 ✗ return setUseFlowRateFractionSchedule(schedule);
976 ✗ } else {
977 ✗ return false;
978 }
979 ✗ } else {
980 ✗ resetUseFlowRateFractionSchedule();
981 }
982 ✗ return true;
983 }
984
985 ✗ bool WaterHeaterMixed_Impl::setColdWaterSupplyTemperatureScheduleAsModelObject(const boost::optional<ModelObject>& modelObject) {
986 ✗ if (modelObject) {
987 ✗ OptionalSchedule intermediate = modelObject->optionalCast<Schedule>();
988 ✗ if (intermediate) {
989 ✗ return setColdWaterSupplyTemperatureSchedule(*intermediate);
990 } else {
991 ✗ return false;
992 }
993 ✗ } else {
994 ✗ resetColdWaterSupplyTemperatureSchedule();
995 }
996 ✗ return true;
997 }
998
999 72 boost::optional<ZoneHVACComponent> WaterHeaterMixed_Impl::containingZoneHVACComponent() const {
1000
2/2
✓ Branch 1 taken 72 times.
✓ Branch 4 taken 72 times.
72 auto hpwhs = model().getConcreteModelObjects<model::WaterHeaterHeatPump>();
1001
1/1
✓ Branch 1 taken 72 times.
72 auto t_Handle = handle();
1002
1003
2/2
✓ Branch 5 taken 11 times.
✓ Branch 6 taken 61 times.
72 for (const auto& hpwh : hpwhs) {
1004
4/5
✓ Branch 1 taken 11 times.
✓ Branch 4 taken 11 times.
✓ Branch 7 taken 11 times.
✓ Branch 10 taken 11 times.
✗ Branch 11 not taken.
11 if (hpwh.tank().handle() == t_Handle) {
1005
1/1
✓ Branch 1 taken 11 times.
11 return hpwh;
1006 }
1007 }
1008
1009 61 return boost::none;
1010 72 }
1011
1012 ✗ boost::optional<double> WaterHeaterMixed_Impl::autosizedTankVolume() const {
1013 ✗ return getAutosizedValue("Design Size Tank Volume", "m3");
1014 }
1015
1016 ✗ boost::optional<double> WaterHeaterMixed_Impl::autosizedHeaterMaximumCapacity() const {
1017 ✗ return getAutosizedValue("Design Size Heater Maximum Capacity", "W");
1018 }
1019
1020 ✗ boost::optional<double> WaterHeaterMixed_Impl::autosizedUseSideDesignFlowRate() const {
1021 ✗ return getAutosizedValue("Design Size Use Side Design Flow Rate", "m3/s");
1022 }
1023
1024 ✗ boost::optional<double> WaterHeaterMixed_Impl::autosizedSourceSideDesignFlowRate() const {
1025 ✗ return getAutosizedValue("Design Size Source Side Design Flow Rate", "m3/s");
1026 }
1027
1028 ✗ void WaterHeaterMixed_Impl::autosize() {
1029 ✗ autosizeTankVolume();
1030 ✗ autosizeHeaterMaximumCapacity();
1031 ✗ autosizeUseSideDesignFlowRate();
1032 ✗ autosizeSourceSideDesignFlowRate();
1033 ✗ }
1034
1035 ✗ void WaterHeaterMixed_Impl::applySizingValues() {
1036 ✗ boost::optional<double> val;
1037 ✗ val = autosizedTankVolume();
1038 ✗ if (val) {
1039 ✗ setTankVolume(val.get());
1040 }
1041
1042 ✗ val = autosizedHeaterMaximumCapacity();
1043 ✗ if (val) {
1044 ✗ setHeaterMaximumCapacity(val.get());
1045 }
1046
1047 ✗ val = autosizedUseSideDesignFlowRate();
1048 ✗ if (val) {
1049 ✗ setUseSideDesignFlowRate(val.get());
1050 }
1051
1052 ✗ val = autosizedSourceSideDesignFlowRate();
1053 ✗ if (val) {
1054 ✗ setSourceSideDesignFlowRate(val.get());
1055 }
1056 ✗ }
1057
1058 32 std::string WaterHeaterMixed_Impl::endUseSubcategory() const {
1059
1/1
✓ Branch 1 taken 32 times.
32 auto value = getString(OS_WaterHeater_MixedFields::EndUseSubcategory, true);
1060
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 32 times.
✗ Branch 4 not taken.
32 OS_ASSERT(value);
1061
2/2
✓ Branch 1 taken 32 times.
✓ Branch 4 taken 32 times.
64 return value.get();
1062 32 }
1063
1064 47 bool WaterHeaterMixed_Impl::setEndUseSubcategory(const std::string& endUseSubcategory) {
1065 47 return setString(OS_WaterHeater_MixedFields::EndUseSubcategory, endUseSubcategory);
1066 }
1067
1068 ✗ std::vector<std::string> WaterHeaterMixed_Impl::sourceSideFlowControlModeValues() const {
1069 ✗ return WaterHeaterMixed::sourceSideFlowControlModeValues();
1070 }
1071
1072 36 std::string WaterHeaterMixed_Impl::sourceSideFlowControlMode() const {
1073
1/1
✓ Branch 1 taken 36 times.
36 boost::optional<std::string> value = getString(OS_WaterHeater_MixedFields::SourceSideFlowControlMode, true);
1074
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 36 times.
✗ Branch 4 not taken.
36 OS_ASSERT(value);
1075
2/2
✓ Branch 1 taken 36 times.
✓ Branch 4 taken 36 times.
72 return value.get();
1076 36 }
1077
1078 50 bool WaterHeaterMixed_Impl::setSourceSideFlowControlMode(const std::string& sourceSideFlowControlMode) {
1079
1080 50 bool result = false;
1081
1082 // Do not accept IndirectHeatAlternateSetpoint unless there is already a schedule that is set
1083
4/4
✓ Branch 1 taken 50 times.
✓ Branch 4 taken 50 times.
✓ Branch 7 taken 1 time.
✓ Branch 8 taken 49 times.
100 if (openstudio::istringEqual("IndirectHeatAlternateSetpoint", sourceSideFlowControlMode)) {
1084
2/3
✓ Branch 1 taken 1 time.
✓ Branch 5 taken 1 time.
✗ Branch 6 not taken.
1 if (!indirectAlternateSetpointTemperatureSchedule()) {
1085
7/7
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✓ Branch 10 taken 1 time.
✓ Branch 14 taken 1 time.
✓ Branch 17 taken 1 time.
✓ Branch 20 taken 1 time.
1 LOG(Warn, "If you want to use a Source Side Flow Control Mode of 'IndirectHeatAlternateSetpoint', "
1086 "use setIndirectAlternateSetpointTemperatureSchedule(schedule) instead for "
1087 << briefDescription());
1088 1 return false;
1089 }
1090 }
1091 // If other than IndirectHeatAlternateSetpoint, Reset the indirect alternate setpoint temp schedule
1092 else {
1093 // Have to do this before resetting the schedule, in case a bad (per IDD) value other than 'IndirectHeatAlternateSetpoint' is provided
1094 49 result = setString(OS_WaterHeater_MixedFields::SourceSideFlowControlMode, sourceSideFlowControlMode);
1095
1096
9/11
✓ Branch 0 taken 48 times.
✓ Branch 1 taken 1 time.
✓ Branch 3 taken 48 times.
✓ Branch 6 taken 1 time.
✓ Branch 7 taken 47 times.
✓ Branch 8 taken 48 times.
✓ Branch 9 taken 1 time.
✓ Branch 11 taken 1 time.
✓ Branch 12 taken 48 times.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
97 if (result && indirectAlternateSetpointTemperatureSchedule()) {
1097
7/7
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✓ Branch 10 taken 1 time.
✓ Branch 14 taken 1 time.
✓ Branch 17 taken 1 time.
✓ Branch 20 taken 1 time.
1 LOG(Info, "Resetting the 'Indirect Alternate Setpoint Temperature Schedule Name' for " << briefDescription());
1098
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
3 setString(OS_WaterHeater_MixedFields::IndirectAlternateSetpointTemperatureScheduleName, "");
1099 }
1100 }
1101
1102 49 return result;
1103 }
1104
1105 54 boost::optional<Schedule> WaterHeaterMixed_Impl::indirectAlternateSetpointTemperatureSchedule() const {
1106
2/2
✓ Branch 1 taken 54 times.
✓ Branch 4 taken 54 times.
54 return getObject<ModelObject>().getModelObjectTarget<Schedule>(OS_WaterHeater_MixedFields::IndirectAlternateSetpointTemperatureScheduleName);
1107 }
1108
1109 2 bool WaterHeaterMixed_Impl::setIndirectAlternateSetpointTemperatureSchedule(Schedule& indirectAlternateSetpointTemperatureSchedule) {
1110
3/3
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
✓ Branch 7 taken 2 times.
8 bool result = setSchedule(OS_WaterHeater_MixedFields::IndirectAlternateSetpointTemperatureScheduleName, "WaterHeaterMixed",
1111 "Indirect Alternate Setpoint Temperature", indirectAlternateSetpointTemperatureSchedule);
1112 // Also set the source Side Flow Control Mode accordingly
1113
9/21
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✓ Branch 3 taken 2 times.
✓ Branch 6 taken 2 times.
✓ Branch 9 taken 2 times.
✓ Branch 11 taken 2 times.
✗ Branch 12 not taken.
✓ Branch 13 taken 2 times.
✗ Branch 14 not taken.
✓ Branch 16 taken 2 times.
✗ Branch 17 not taken.
✓ Branch 18 taken 2 times.
✗ Branch 19 not taken.
✓ Branch 21 taken 2 times.
✗ Branch 22 not taken.
✗ Branch 23 not taken.
✗ Branch 24 not taken.
✗ Branch 26 not taken.
✗ Branch 27 not taken.
✗ Branch 28 not taken.
✗ Branch 29 not taken.
6 if (result && !openstudio::istringEqual("IndirectHeatAlternateSetpoint", sourceSideFlowControlMode())) {
1114
7/7
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
✓ Branch 7 taken 2 times.
✓ Branch 10 taken 2 times.
✓ Branch 14 taken 2 times.
✓ Branch 17 taken 2 times.
✓ Branch 20 taken 2 times.
2 LOG(Info, "Setting the Source Side Flow Control Mode to 'IndirectHeatAlternateSetpoint' for " << briefDescription());
1115
2/2
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
6 result = setString(OS_WaterHeater_MixedFields::SourceSideFlowControlMode, "IndirectHeatAlternateSetpoint");
1116 }
1117 2 return result;
1118 }
1119
1120 1 void WaterHeaterMixed_Impl::resetIndirectAlternateSetpointTemperatureSchedule() {
1121
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
2 bool result = setString(OS_WaterHeater_MixedFields::IndirectAlternateSetpointTemperatureScheduleName, "");
1122
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
1 OS_ASSERT(result);
1123 // Reset the Source Side Flow Control Mode to the default "IndirectHeatPrimarySetpoint"
1124
4/5
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✓ Branch 11 taken 1 time.
✗ Branch 12 not taken.
3 if (openstudio::istringEqual("IndirectHeatAlternateSetpoint", sourceSideFlowControlMode())) {
1125
7/7
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✓ Branch 10 taken 1 time.
✓ Branch 14 taken 1 time.
✓ Branch 17 taken 1 time.
✓ Branch 20 taken 1 time.
1 LOG(Info, "Resetting the Source Side Flow Control Mode to the default 'IndirectHeatPrimarySetpoint' for " << briefDescription());
1126
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
3 result = setString(OS_WaterHeater_MixedFields::SourceSideFlowControlMode, "IndirectHeatPrimarySetpoint");
1127 }
1128
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
1 OS_ASSERT(result);
1129 1 }
1130
1131 ✗ boost::optional<ModelObject> WaterHeaterMixed_Impl::indirectAlternateSetpointTemperatureScheduleAsModelObject() const {
1132 ✗ OptionalModelObject result;
1133 ✗ OptionalSchedule intermediate = indirectAlternateSetpointTemperatureSchedule();
1134 ✗ if (intermediate) {
1135 ✗ result = *intermediate;
1136 }
1137 ✗ return result;
1138 ✗ }
1139
1140 ✗ bool WaterHeaterMixed_Impl::setIndirectAlternateSetpointTemperatureScheduleAsModelObject(const boost::optional<ModelObject>& modelObject) {
1141 ✗ if (modelObject) {
1142 ✗ OptionalSchedule intermediate = modelObject->optionalCast<Schedule>();
1143 ✗ if (intermediate) {
1144 ✗ Schedule schedule(*intermediate);
1145 ✗ return setIndirectAlternateSetpointTemperatureSchedule(schedule);
1146 ✗ } else {
1147 ✗ return false;
1148 }
1149 ✗ } else {
1150 ✗ resetIndirectAlternateSetpointTemperatureSchedule();
1151 }
1152 ✗ return true;
1153 }
1154
1155 83 WaterHeaterSizing WaterHeaterMixed_Impl::waterHeaterSizing() const {
1156 83 boost::optional<WaterHeaterSizing> waterHeaterSizing_;
1157
1158
2/2
✓ Branch 1 taken 83 times.
✓ Branch 4 taken 83 times.
83 auto sizingObjects = getObject<WaterHeaterMixed>().getModelObjectSources<WaterHeaterSizing>();
1159
1/1
✓ Branch 1 taken 83 times.
83 auto predicate = [thisHandle = this->handle()](const auto& siz) {
1160 try {
1161
3/3
✓ Branch 1 taken 83 times.
✓ Branch 4 taken 83 times.
✓ Branch 7 taken 83 times.
83 return siz.waterHeater().handle() == thisHandle;
1162 ✗ } catch (...) {
1163 ✗ LOG(Debug, siz.briefDescription() << " is not attached to a WaterHeater object.");
1164 ✗ return false;
1165 }
1166 };
1167
1168
1/1
✓ Branch 3 taken 83 times.
83 auto it = std::find_if(sizingObjects.cbegin(), sizingObjects.cend(), predicate);
1169
1/2
✓ Branch 2 taken 83 times.
✗ Branch 3 not taken.
83 if (it != sizingObjects.cend()) {
1170
1/1
✓ Branch 2 taken 83 times.
166 return *it;
1171 } else {
1172 ✗ LOG_AND_THROW(briefDescription() << " missing WaterHeater:Sizing object.");
1173 }
1174 83 }
1175
1176 // Loop connections
1177
1178 619 unsigned WaterHeaterMixed_Impl::supplyInletPort() const {
1179 619 return OS_WaterHeater_MixedFields::UseSideInletNodeName;
1180 }
1181
1182 628 unsigned WaterHeaterMixed_Impl::supplyOutletPort() const {
1183 628 return OS_WaterHeater_MixedFields::UseSideOutletNodeName;
1184 }
1185
1186 86 unsigned WaterHeaterMixed_Impl::demandInletPort() const {
1187 86 return OS_WaterHeater_MixedFields::SourceSideInletNodeName;
1188 }
1189
1190 270 unsigned WaterHeaterMixed_Impl::demandOutletPort() const {
1191 270 return OS_WaterHeater_MixedFields::SourceSideOutletNodeName;
1192 }
1193
1194 121 boost::optional<PlantLoop> WaterHeaterMixed_Impl::plantLoop() const {
1195
2/2
✓ Branch 1 taken 24 times.
✓ Branch 2 taken 97 times.
242 if (m_plantLoop) {
1196 24 return m_plantLoop;
1197 } else {
1198 // Note: checking for supply side only isn't sufficient for this object, as it can be on the supply of two plant loops
1199 // Here we only want to return the Use Side one, so we need to filter out the source Side one
1200
1/1
✓ Branch 1 taken 97 times.
97 boost::optional<PlantLoop> sourceSidePlantLoop = this->sourceSidePlantLoop();
1201
1202
2/2
✓ Branch 1 taken 97 times.
✓ Branch 4 taken 97 times.
97 std::vector<PlantLoop> plantLoops = this->model().getConcreteModelObjects<PlantLoop>();
1203
1204
2/2
✓ Branch 5 taken 93 times.
✓ Branch 6 taken 59 times.
152 for (const auto& elem : plantLoops) {
1205
1/1
✓ Branch 1 taken 93 times.
93 OptionalPlantLoop plantLoop = elem.optionalCast<PlantLoop>();
1206
1/2
✓ Branch 0 taken 93 times.
✗ Branch 1 not taken.
93 if (plantLoop) {
1207 // Check that the component is on the supply side of the PlantLoop
1208
5/5
✓ Branch 1 taken 93 times.
✓ Branch 4 taken 93 times.
✓ Branch 7 taken 93 times.
✓ Branch 10 taken 41 times.
✓ Branch 11 taken 52 times.
186 if (plantLoop->supplyComponent(this->handle())) {
1209 // Skip the sourceSide one
1210
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 33 times.
41 if (sourceSidePlantLoop) {
1211
7/7
✓ Branch 1 taken 8 times.
✓ Branch 4 taken 8 times.
✓ Branch 7 taken 8 times.
✓ Branch 10 taken 8 times.
✓ Branch 13 taken 8 times.
✓ Branch 15 taken 3 times.
✓ Branch 16 taken 5 times.
8 if (plantLoop->handle() == sourceSidePlantLoop->handle()) {
1212 3 continue;
1213 }
1214 }
1215
1/1
✓ Branch 1 taken 38 times.
38 m_plantLoop = plantLoop;
1216
1217 38 return plantLoop;
1218 }
1219 }
1220 93 }
1221 135 }
1222
1223 59 return boost::none;
1224 }
1225
1226 173 boost::optional<PlantLoop> WaterHeaterMixed_Impl::secondaryPlantLoop() const {
1227
2/2
✓ Branch 1 taken 21 times.
✓ Branch 2 taken 152 times.
346 if (m_secondaryPlantLoop) {
1228 21 return m_secondaryPlantLoop;
1229 } else {
1230
1231 // Regular case, it's on the demand side: use the base class implementation
1232
1/1
✓ Branch 1 taken 152 times.
152 m_secondaryPlantLoop = WaterToWaterComponent_Impl::secondaryPlantLoop();
1233
2/2
✓ Branch 1 taken 1 time.
✓ Branch 2 taken 151 times.
304 if (m_secondaryPlantLoop) {
1234 1 return m_secondaryPlantLoop;
1235 }
1236
1237 // Less common case: it's also on the supply side (like for the PlantLoop one)
1238 // so we explicitly ensure this is connected to the **Source** Side Nodes
1239
3/3
✓ Branch 1 taken 151 times.
✓ Branch 3 taken 4 times.
✓ Branch 4 taken 147 times.
302 if (auto sourceSideOutletModelObject_ = sourceSideOutletModelObject()) {
1240
3/4
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
✓ Branch 6 taken 4 times.
✗ Branch 7 not taken.
8 if (auto sourceSideOutletHVACComponent_ = sourceSideOutletModelObject_->optionalCast<HVACComponent>()) {
1241
2/2
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
4 auto plantLoops = this->model().getConcreteModelObjects<PlantLoop>();
1242
1243
1/2
✓ Branch 5 taken 5 times.
✗ Branch 6 not taken.
5 for (const auto& plantLoop : plantLoops) {
1244
7/7
✓ 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 19 taken 4 times.
✓ Branch 20 taken 1 time.
15 if (!plantLoop.supplyComponents(plantLoop.supplyInletNode(), sourceSideOutletHVACComponent_.get()).empty()) {
1245
1/1
✓ Branch 1 taken 4 times.
4 m_secondaryPlantLoop = plantLoop;
1246
1/1
✓ Branch 1 taken 4 times.
4 return plantLoop;
1247 }
1248 }
1249 8 }
1250 151 }
1251 }
1252
1253 147 return boost::none;
1254 }
1255
1256 12 bool WaterHeaterMixed_Impl::removeFromSecondaryPlantLoop() {
1257
1258
3/3
✓ Branch 1 taken 12 times.
✓ Branch 3 taken 3 times.
✓ Branch 4 taken 9 times.
24 if (auto plant_ = secondaryPlantLoop()) {
1259 3 m_secondaryPlantLoop = boost::none;
1260
1261
3/3
✓ Branch 1 taken 3 times.
✓ Branch 4 taken 3 times.
✓ Branch 7 taken 3 times.
3 auto outletNode = sourceSideOutletModelObject()->cast<HVACComponent>();
1262
1263
2/2
✓ Branch 1 taken 3 times.
✓ Branch 4 taken 3 times.
3 auto supplyNode = plant_->supplyInletNode();
1264
5/6
✓ Branch 1 taken 3 times.
✓ Branch 4 taken 3 times.
✓ Branch 7 taken 3 times.
✓ Branch 10 taken 3 times.
✓ Branch 15 taken 3 times.
✗ Branch 16 not taken.
9 if (!plant_->supplyComponents(supplyNode, outletNode).empty()) {
1265
5/5
✓ Branch 1 taken 3 times.
✓ Branch 4 taken 3 times.
✓ Branch 7 taken 3 times.
✓ Branch 10 taken 3 times.
✓ Branch 13 taken 3 times.
3 return HVACComponent_Impl::removeFromLoop(supplyNode, plant_->supplyOutletNode(), demandInletPort(), demandOutletPort());
1266 } else {
1267 ✗ return HVACComponent_Impl::removeFromLoop(plant_->demandInletNode(), plant_->demandOutletNode(), demandInletPort(), demandOutletPort());
1268 }
1269 15 }
1270
1271 9 return false;
1272 }
1273
1274 25 bool WaterHeaterMixed_Impl::addToNode(Node& node) {
1275
1/1
✓ Branch 1 taken 25 times.
25 boost::optional<PlantLoop> t_plantLoop = node.plantLoop();
1276
1277
1/2
✓ Branch 0 taken 25 times.
✗ Branch 1 not taken.
25 if (t_plantLoop) {
1278
5/5
✓ Branch 1 taken 25 times.
✓ Branch 4 taken 25 times.
✓ Branch 7 taken 25 times.
✓ Branch 10 taken 24 times.
✓ Branch 11 taken 1 time.
50 if (t_plantLoop->supplyComponent(node.handle())) {
1279 // If these is already a use side Plant Loop
1280
1/1
✓ Branch 1 taken 24 times.
24 boost::optional<PlantLoop> useSidePlant = this->useSidePlantLoop();
1281
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 21 times.
24 if (useSidePlant) {
1282 // And it's not the same as the node's loop
1283
4/5
✓ Branch 1 taken 3 times.
✓ Branch 4 taken 3 times.
✓ Branch 7 taken 3 times.
✓ Branch 9 taken 3 times.
✗ Branch 10 not taken.
3 if (t_plantLoop.get() != useSidePlant.get()) {
1284 // Then try to add it to the source side one
1285
7/7
✓ Branch 1 taken 3 times.
✓ Branch 4 taken 3 times.
✓ Branch 7 taken 3 times.
✓ Branch 10 taken 3 times.
✓ Branch 14 taken 3 times.
✓ Branch 17 taken 3 times.
✓ Branch 20 taken 3 times.
3 LOG(Warn, "Calling addToSecondaryNode to connect it to the source side loop for " << briefDescription());
1286
1/1
✓ Branch 1 taken 3 times.
3 return this->addToSourceSideNode(node);
1287 }
1288 }
1289 24 }
1290 }
1291
1292 // All other cases, call the base class implementation
1293
1/1
✓ Branch 1 taken 22 times.
22 return WaterToWaterComponent_Impl::addToNode(node);
1294 25 }
1295
1296 4 bool WaterHeaterMixed_Impl::addToSourceSideNode(Node& node) {
1297
1/1
✓ Branch 1 taken 4 times.
4 auto thisModelObject = getObject<ModelObject>();
1298
1/1
✓ Branch 1 taken 4 times.
4 auto t_plantLoop = node.plantLoop();
1299
1300
2/2
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
4 boost::optional<unsigned> componentInletPort = demandInletPort();
1301
2/2
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
4 boost::optional<unsigned> componentOutletPort = demandOutletPort();
1302
1303 4 boost::optional<HVACComponent> systemStartComponent;
1304 4 boost::optional<HVACComponent> systemEndComponent;
1305
1306
2/3
✓ Branch 3 taken 4 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 4 times.
4 if (node.getImpl<Node_Impl>()->isConnected(thisModelObject)) {
1307 ✗ return false;
1308 }
1309
1310
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
4 if (t_plantLoop) {
1311
4/5
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
✓ Branch 7 taken 4 times.
✓ Branch 10 taken 4 times.
✗ Branch 11 not taken.
8 if (t_plantLoop->supplyComponent(node.handle())) {
1312
1313
3/3
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
✓ Branch 7 taken 4 times.
4 systemStartComponent = t_plantLoop->supplyInletNode();
1314
3/3
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
✓ Branch 7 taken 4 times.
4 systemEndComponent = t_plantLoop->supplyOutletNode();
1315
1316
1/1
✓ Branch 1 taken 4 times.
4 removeFromSourceSidePlantLoop();
1317 ✗ } else if (t_plantLoop->demandComponent(node.handle())) {
1318 ✗ systemStartComponent = t_plantLoop->demandInletNode();
1319 ✗ systemEndComponent = t_plantLoop->demandOutletNode();
1320
1321 ✗ removeFromSourceSidePlantLoop();
1322 }
1323 }
1324
1325
5/10
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 4 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 4 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 4 times.
✗ Branch 9 not taken.
16 if (systemStartComponent && systemEndComponent && componentOutletPort && componentInletPort) {
1326
3/3
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
✓ Branch 7 taken 4 times.
4 return HVACComponent_Impl::addToNode(node, systemStartComponent.get(), systemEndComponent.get(), componentInletPort.get(),
1327
2/2
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
8 componentOutletPort.get());
1328 }
1329
1330 ✗ return false;
1331 4 }
1332
1333 // Name aliases
1334
1335 142 boost::optional<PlantLoop> WaterHeaterMixed_Impl::sourceSidePlantLoop() const {
1336 142 return secondaryPlantLoop();
1337 }
1338
1339 36 boost::optional<PlantLoop> WaterHeaterMixed_Impl::useSidePlantLoop() const {
1340 36 return plantLoop();
1341 }
1342
1343 7 bool WaterHeaterMixed_Impl::removeFromSourceSidePlantLoop() {
1344 7 return removeFromSecondaryPlantLoop();
1345 }
1346
1347 ✗ boost::optional<ModelObject> WaterHeaterMixed_Impl::useSideInletModelObject() const {
1348 ✗ return supplyInletModelObject();
1349 }
1350
1351 ✗ boost::optional<ModelObject> WaterHeaterMixed_Impl::useSideOutletModelObject() const {
1352 ✗ return supplyOutletModelObject();
1353 }
1354
1355 ✗ boost::optional<ModelObject> WaterHeaterMixed_Impl::sourceSideInletModelObject() const {
1356 ✗ return demandInletModelObject();
1357 }
1358
1359 154 boost::optional<ModelObject> WaterHeaterMixed_Impl::sourceSideOutletModelObject() const {
1360 154 return demandOutletModelObject();
1361 }
1362
1363 88 ComponentType WaterHeaterMixed_Impl::componentType() const {
1364
2/3
✓ Branch 1 taken 88 times.
✓ Branch 3 taken 88 times.
✗ Branch 4 not taken.
176 if (boost::optional<double> _cap = heaterMaximumCapacity()) {
1365
3/3
✓ Branch 1 taken 88 times.
✓ Branch 3 taken 6 times.
✓ Branch 4 taken 82 times.
88 if (_cap.get() == 0.0) {
1366 // Capacity is zero: it's a storage tank!
1367 // get the Source loop
1368
3/3
✓ Branch 1 taken 6 times.
✓ Branch 3 taken 3 times.
✓ Branch 4 taken 3 times.
12 if (boost::optional<PlantLoop> p_ = secondaryPlantLoop()) {
1369 // I guess we could rely on Heating/Cooling/Condenser set in the sizingPlant
1370 // if ( openstudio::istringEqual(p->sizingPlant().loopType(), "Heating") { }
1371 // Might be better to do a recursive call to see what type of equipment you have on the supply side of the plant loop though
1372
2/2
✓ Branch 1 taken 3 times.
✓ Branch 4 taken 3 times.
3 return p_->componentType();
1373
1374 // We also need to check if the tank isn't attached to a HPWH, in which case we return Heating
1375 // There's some magic later that'll put the HPWH itself and not the tank on the PlantEquipmentOperation,
1376 // see function operationSchemeComponent()
1377
3/3
✓ Branch 1 taken 3 times.
✓ Branch 3 taken 2 times.
✓ Branch 4 taken 1 time.
6 } else if (boost::optional<ZoneHVACComponent> zoneComp_ = containingZoneHVACComponent()) {
1378 // We don't have to explicitly check if it's a WaterHeaterHeatPump or WaterHeaterHeatPumpWrappedCondenser since
1379 // these are the only two types of zoneHVACComponent that could have a WaterHeater object, but this might change in the future
1380
2/2
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
2 IddObjectType zoneCompIdd = zoneComp_->iddObjectType();
1381
1/1
✓ Branch 1 taken 2 times.
2 if ((zoneCompIdd == openstudio::IddObjectType::OS_WaterHeater_HeatPump)
1382
2/7
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
✗ Branch 3 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✓ Branch 8 taken 2 times.
✗ Branch 9 not taken.
2 || (zoneCompIdd == openstudio::IddObjectType::OS_WaterHeater_HeatPump_WrappedCondenser)) {
1383
1/1
✓ Branch 1 taken 2 times.
2 return ComponentType::Heating;
1384 } else {
1385 ✗ OS_ASSERT(false);
1386 ✗ return ComponentType::None;
1387 }
1388 } else {
1389 // It isn't connected to a source side, and has zero capacity, and not part of HPWH => it's a buffer tank => NONE
1390
1/1
✓ Branch 1 taken 1 time.
1 return ComponentType::None;
1391 9 } // End if has source loop
1392
1393 } else {
1394 // If there is a capacity, and it's not zero, it's heating
1395
1/1
✓ Branch 1 taken 82 times.
82 return ComponentType::Heating;
1396 } // End cap == 0
1397
1398 } else {
1399 // If autosize, then it's Heating
1400 ✗ return ComponentType::Heating;
1401 } // end has a heater capacity
1402 }
1403
1404 2 std::vector<FuelType> WaterHeaterMixed_Impl::coolingFuelTypes() const {
1405 2 std::set<FuelType> result;
1406
1407
2/3
✓ Branch 1 taken 2 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2 times.
4 if (boost::optional<PlantLoop> p_ = secondaryPlantLoop()) {
1408 ✗ auto plantFuelTypes = p_->coolingFuelTypes();
1409 ✗ result.insert(plantFuelTypes.begin(), plantFuelTypes.end());
1410 2 }
1411
1412
1/1
✓ Branch 3 taken 2 times.
6 return {result.begin(), result.end()};
1413 2 }
1414
1415 4 std::vector<FuelType> WaterHeaterMixed_Impl::heatingFuelTypes() const {
1416
1417 4 std::set<FuelType> result;
1418
3/4
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 4 times.
4 if (boost::optional<double> _cap = heaterMaximumCapacity(); _cap.get() > 0.0) {
1419 ✗ result.insert(FuelType(heaterFuelType()));
1420 }
1421
2/3
✓ Branch 1 taken 4 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 4 times.
8 if (boost::optional<PlantLoop> p_ = secondaryPlantLoop()) {
1422 ✗ auto plantFuelTypes = p_->heatingFuelTypes();
1423 ✗ result.insert(plantFuelTypes.begin(), plantFuelTypes.end());
1424 4 }
1425
2/3
✓ Branch 1 taken 4 times.
✓ Branch 3 taken 4 times.
✗ Branch 4 not taken.
8 if (auto zoneComp_ = containingZoneHVACComponent()) {
1426 // The only accepted types are the WaterHeaterHeatPump or WaterHeaterHeatPumpWrappedCondenser so skip the checks
1427
2/2
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
4 result.insert(FuelType::Electricity);
1428 4 }
1429
1430
1/1
✓ Branch 3 taken 4 times.
12 return {result.begin(), result.end()};
1431 4 }
1432
1433 4 std::vector<AppGFuelType> WaterHeaterMixed_Impl::appGHeatingFuelTypes() const {
1434 4 std::set<AppGFuelType> result;
1435
3/4
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 4 times.
4 if (boost::optional<double> _cap = heaterMaximumCapacity(); _cap.get() > 0.0) {
1436 ✗ result.insert(convertFuelTypeToAppG(FuelType(heaterFuelType())));
1437 }
1438
2/3
✓ Branch 1 taken 4 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 4 times.
8 if (boost::optional<PlantLoop> p_ = secondaryPlantLoop()) {
1439 ✗ auto plantFuelTypes = p_->appGHeatingFuelTypes();
1440 ✗ result.insert(plantFuelTypes.begin(), plantFuelTypes.end());
1441 4 }
1442
2/3
✓ Branch 1 taken 4 times.
✓ Branch 3 taken 4 times.
✗ Branch 4 not taken.
8 if (auto zoneComp_ = containingZoneHVACComponent()) {
1443 // The only accepted types are the WaterHeaterHeatPump or WaterHeaterHeatPumpWrappedCondenser so skip the checks
1444
2/2
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
4 result.insert(AppGFuelType::HeatPump);
1445 4 }
1446
1447
1/1
✓ Branch 3 taken 4 times.
12 return {result.begin(), result.end()};
1448 4 }
1449
1450 } // namespace detail
1451
1452 46 WaterHeaterMixed::WaterHeaterMixed(const Model& model) : WaterToWaterComponent(WaterHeaterMixed::iddObjectType(), model) {
1453
1/3
✗ Branch 2 not taken.
✓ Branch 3 taken 46 times.
✗ Branch 5 not taken.
46 OS_ASSERT(getImpl<detail::WaterHeaterMixed_Impl>());
1454
1455
1/1
✓ Branch 1 taken 46 times.
46 setTankVolume(0.3785);
1456
1/1
✓ Branch 1 taken 46 times.
46 setDeadbandTemperatureDifference(2.0);
1457
1/1
✓ Branch 1 taken 46 times.
46 setMaximumTemperatureLimit(82.22);
1458
2/2
✓ Branch 1 taken 46 times.
✓ Branch 4 taken 46 times.
46 setHeaterControlType("Cycle");
1459
1/1
✓ Branch 1 taken 46 times.
46 setHeaterMaximumCapacity(845000);
1460
2/2
✓ Branch 1 taken 46 times.
✓ Branch 4 taken 46 times.
46 setHeaterFuelType(FuelType::Gas);
1461
1/1
✓ Branch 1 taken 46 times.
46 setHeaterThermalEfficiency(0.8);
1462
1/1
✓ Branch 1 taken 46 times.
46 setOffCycleParasiticFuelConsumptionRate(20.0);
1463
2/2
✓ Branch 1 taken 46 times.
✓ Branch 4 taken 46 times.
46 setOffCycleParasiticFuelType(FuelType::Gas);
1464
1/1
✓ Branch 1 taken 46 times.
46 setOffCycleParasiticHeatFractiontoTank(0.8);
1465
2/2
✓ Branch 1 taken 46 times.
✓ Branch 4 taken 46 times.
46 setOnCycleParasiticFuelType(FuelType::Gas);
1466
1/1
✓ Branch 1 taken 46 times.
46 setOffCycleLossCoefficienttoAmbientTemperature(6.0);
1467
1/1
✓ Branch 1 taken 46 times.
46 setOnCycleLossCoefficienttoAmbientTemperature(6.0);
1468
1/1
✓ Branch 1 taken 46 times.
46 setUseSideEffectiveness(1.0);
1469
1/1
✓ Branch 1 taken 46 times.
46 setSourceSideEffectiveness(1.0);
1470
1/1
✓ Branch 1 taken 46 times.
46 autosizeUseSideDesignFlowRate();
1471
1/1
✓ Branch 1 taken 46 times.
46 autosizeSourceSideDesignFlowRate();
1472
1/1
✓ Branch 1 taken 46 times.
46 setIndirectWaterHeatingRecoveryTime(1.5);
1473
1474
2/2
✓ Branch 1 taken 46 times.
✓ Branch 4 taken 46 times.
46 setAmbientTemperatureIndicator("Schedule");
1475
1/1
✓ Branch 1 taken 46 times.
46 ScheduleRuleset amb_schedule(model);
1476
3/3
✓ Branch 1 taken 46 times.
✓ Branch 4 taken 46 times.
✓ Branch 7 taken 46 times.
46 amb_schedule.defaultDaySchedule().addValue(Time(0, 24, 0, 0), 22.0);
1477
1/1
✓ Branch 1 taken 46 times.
46 setAmbientTemperatureSchedule(amb_schedule);
1478
1479
1/1
✓ Branch 1 taken 46 times.
46 ScheduleRuleset setpoint_schedule(model);
1480
3/3
✓ Branch 1 taken 46 times.
✓ Branch 4 taken 46 times.
✓ Branch 7 taken 46 times.
46 setpoint_schedule.defaultDaySchedule().addValue(Time(0, 24, 0, 0), 60.0);
1481
1/1
✓ Branch 1 taken 46 times.
46 setSetpointTemperatureSchedule(setpoint_schedule);
1482
1483
2/2
✓ Branch 1 taken 46 times.
✓ Branch 4 taken 46 times.
92 setSourceSideFlowControlMode("IndirectHeatPrimarySetpoint");
1484
2/2
✓ Branch 1 taken 46 times.
✓ Branch 4 taken 46 times.
46 setEndUseSubcategory("General");
1485
1486
1/1
✓ Branch 1 taken 46 times.
46 WaterHeaterSizing waterHeaterSizing(*this);
1487 46 }
1488
1489 7808 IddObjectType WaterHeaterMixed::iddObjectType() {
1490
1/1
✓ Branch 1 taken 7808 times.
7808 return {IddObjectType::OS_WaterHeater_Mixed};
1491 }
1492
1493 ✗ std::vector<std::string> WaterHeaterMixed::heaterControlTypeValues() {
1494 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_WaterHeater_MixedFields::HeaterControlType);
1495 }
1496
1497 ✗ std::vector<std::string> WaterHeaterMixed::heaterFuelTypeValues() {
1498 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_WaterHeater_MixedFields::HeaterFuelType);
1499 }
1500
1501 ✗ std::vector<std::string> WaterHeaterMixed::offCycleParasiticFuelTypeValues() {
1502 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_WaterHeater_MixedFields::OffCycleParasiticFuelType);
1503 }
1504
1505 ✗ std::vector<std::string> WaterHeaterMixed::onCycleParasiticFuelTypeValues() {
1506 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_WaterHeater_MixedFields::OnCycleParasiticFuelType);
1507 }
1508
1509 ✗ std::vector<std::string> WaterHeaterMixed::ambientTemperatureIndicatorValues() {
1510 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_WaterHeater_MixedFields::AmbientTemperatureIndicator);
1511 }
1512
1513 30 boost::optional<double> WaterHeaterMixed::tankVolume() const {
1514
1/1
✓ Branch 3 taken 30 times.
30 return getImpl<detail::WaterHeaterMixed_Impl>()->tankVolume();
1515 }
1516
1517 ✗ bool WaterHeaterMixed::isTankVolumeDefaulted() const {
1518 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->isTankVolumeDefaulted();
1519 }
1520
1521 30 bool WaterHeaterMixed::isTankVolumeAutosized() const {
1522
1/1
✓ Branch 3 taken 30 times.
30 return getImpl<detail::WaterHeaterMixed_Impl>()->isTankVolumeAutosized();
1523 }
1524
1525 40 boost::optional<Schedule> WaterHeaterMixed::setpointTemperatureSchedule() const {
1526
1/1
✓ Branch 3 taken 40 times.
40 return getImpl<detail::WaterHeaterMixed_Impl>()->setpointTemperatureSchedule();
1527 }
1528
1529 30 double WaterHeaterMixed::deadbandTemperatureDifference() const {
1530
1/1
✓ Branch 3 taken 30 times.
30 return getImpl<detail::WaterHeaterMixed_Impl>()->deadbandTemperatureDifference();
1531 }
1532
1533 ✗ bool WaterHeaterMixed::isDeadbandTemperatureDifferenceDefaulted() const {
1534 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->isDeadbandTemperatureDifferenceDefaulted();
1535 }
1536
1537 30 boost::optional<double> WaterHeaterMixed::maximumTemperatureLimit() const {
1538
1/1
✓ Branch 3 taken 30 times.
30 return getImpl<detail::WaterHeaterMixed_Impl>()->maximumTemperatureLimit();
1539 }
1540
1541 30 std::string WaterHeaterMixed::heaterControlType() const {
1542
1/1
✓ Branch 3 taken 30 times.
30 return getImpl<detail::WaterHeaterMixed_Impl>()->heaterControlType();
1543 }
1544
1545 ✗ bool WaterHeaterMixed::isHeaterControlTypeDefaulted() const {
1546 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->isHeaterControlTypeDefaulted();
1547 }
1548
1549 30 boost::optional<double> WaterHeaterMixed::heaterMaximumCapacity() const {
1550
1/1
✓ Branch 3 taken 30 times.
30 return getImpl<detail::WaterHeaterMixed_Impl>()->heaterMaximumCapacity();
1551 }
1552
1553 30 bool WaterHeaterMixed::isHeaterMaximumCapacityAutosized() const {
1554
1/1
✓ Branch 3 taken 30 times.
30 return getImpl<detail::WaterHeaterMixed_Impl>()->isHeaterMaximumCapacityAutosized();
1555 }
1556
1557 30 boost::optional<double> WaterHeaterMixed::heaterMinimumCapacity() const {
1558
1/1
✓ Branch 3 taken 30 times.
30 return getImpl<detail::WaterHeaterMixed_Impl>()->heaterMinimumCapacity();
1559 }
1560
1561 30 double WaterHeaterMixed::heaterIgnitionMinimumFlowRate() const {
1562
1/1
✓ Branch 3 taken 30 times.
30 return getImpl<detail::WaterHeaterMixed_Impl>()->heaterIgnitionMinimumFlowRate();
1563 }
1564
1565 ✗ bool WaterHeaterMixed::isHeaterIgnitionMinimumFlowRateDefaulted() const {
1566 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->isHeaterIgnitionMinimumFlowRateDefaulted();
1567 }
1568
1569 30 double WaterHeaterMixed::heaterIgnitionDelay() const {
1570
1/1
✓ Branch 3 taken 30 times.
30 return getImpl<detail::WaterHeaterMixed_Impl>()->heaterIgnitionDelay();
1571 }
1572
1573 ✗ bool WaterHeaterMixed::isHeaterIgnitionDelayDefaulted() const {
1574 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->isHeaterIgnitionDelayDefaulted();
1575 }
1576
1577 30 std::string WaterHeaterMixed::heaterFuelType() const {
1578
1/1
✓ Branch 3 taken 30 times.
30 return getImpl<detail::WaterHeaterMixed_Impl>()->heaterFuelType();
1579 }
1580
1581 42 boost::optional<double> WaterHeaterMixed::heaterThermalEfficiency() const {
1582
1/1
✓ Branch 3 taken 42 times.
42 return getImpl<detail::WaterHeaterMixed_Impl>()->heaterThermalEfficiency();
1583 }
1584
1585 30 boost::optional<CurveCubic> WaterHeaterMixed::partLoadFactorCurve() const {
1586
1/1
✓ Branch 3 taken 30 times.
30 return getImpl<detail::WaterHeaterMixed_Impl>()->partLoadFactorCurve();
1587 }
1588
1589 30 double WaterHeaterMixed::offCycleParasiticFuelConsumptionRate() const {
1590
1/1
✓ Branch 3 taken 30 times.
30 return getImpl<detail::WaterHeaterMixed_Impl>()->offCycleParasiticFuelConsumptionRate();
1591 }
1592
1593 ✗ bool WaterHeaterMixed::isOffCycleParasiticFuelConsumptionRateDefaulted() const {
1594 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->isOffCycleParasiticFuelConsumptionRateDefaulted();
1595 }
1596
1597 30 boost::optional<std::string> WaterHeaterMixed::offCycleParasiticFuelType() const {
1598
1/1
✓ Branch 3 taken 30 times.
30 return getImpl<detail::WaterHeaterMixed_Impl>()->offCycleParasiticFuelType();
1599 }
1600
1601 30 double WaterHeaterMixed::offCycleParasiticHeatFractiontoTank() const {
1602
1/1
✓ Branch 3 taken 30 times.
30 return getImpl<detail::WaterHeaterMixed_Impl>()->offCycleParasiticHeatFractiontoTank();
1603 }
1604
1605 ✗ bool WaterHeaterMixed::isOffCycleParasiticHeatFractiontoTankDefaulted() const {
1606 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->isOffCycleParasiticHeatFractiontoTankDefaulted();
1607 }
1608
1609 30 double WaterHeaterMixed::onCycleParasiticFuelConsumptionRate() const {
1610
1/1
✓ Branch 3 taken 30 times.
30 return getImpl<detail::WaterHeaterMixed_Impl>()->onCycleParasiticFuelConsumptionRate();
1611 }
1612
1613 ✗ bool WaterHeaterMixed::isOnCycleParasiticFuelConsumptionRateDefaulted() const {
1614 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->isOnCycleParasiticFuelConsumptionRateDefaulted();
1615 }
1616
1617 30 boost::optional<std::string> WaterHeaterMixed::onCycleParasiticFuelType() const {
1618
1/1
✓ Branch 3 taken 30 times.
30 return getImpl<detail::WaterHeaterMixed_Impl>()->onCycleParasiticFuelType();
1619 }
1620
1621 30 double WaterHeaterMixed::onCycleParasiticHeatFractiontoTank() const {
1622
1/1
✓ Branch 3 taken 30 times.
30 return getImpl<detail::WaterHeaterMixed_Impl>()->onCycleParasiticHeatFractiontoTank();
1623 }
1624
1625 ✗ bool WaterHeaterMixed::isOnCycleParasiticHeatFractiontoTankDefaulted() const {
1626 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->isOnCycleParasiticHeatFractiontoTankDefaulted();
1627 }
1628
1629 60 std::string WaterHeaterMixed::ambientTemperatureIndicator() const {
1630
1/1
✓ Branch 3 taken 60 times.
60 return getImpl<detail::WaterHeaterMixed_Impl>()->ambientTemperatureIndicator();
1631 }
1632
1633 30 boost::optional<Schedule> WaterHeaterMixed::ambientTemperatureSchedule() const {
1634
1/1
✓ Branch 3 taken 30 times.
30 return getImpl<detail::WaterHeaterMixed_Impl>()->ambientTemperatureSchedule();
1635 }
1636
1637 30 boost::optional<ThermalZone> WaterHeaterMixed::ambientTemperatureThermalZone() const {
1638
1/1
✓ Branch 3 taken 30 times.
30 return getImpl<detail::WaterHeaterMixed_Impl>()->ambientTemperatureThermalZone();
1639 }
1640
1641 30 boost::optional<std::string> WaterHeaterMixed::ambientTemperatureOutdoorAirNodeName() const {
1642
1/1
✓ Branch 3 taken 30 times.
30 return getImpl<detail::WaterHeaterMixed_Impl>()->ambientTemperatureOutdoorAirNodeName();
1643 }
1644
1645 30 boost::optional<double> WaterHeaterMixed::offCycleLossCoefficienttoAmbientTemperature() const {
1646
1/1
✓ Branch 3 taken 30 times.
30 return getImpl<detail::WaterHeaterMixed_Impl>()->offCycleLossCoefficienttoAmbientTemperature();
1647 }
1648
1649 30 double WaterHeaterMixed::offCycleLossFractiontoThermalZone() const {
1650
1/1
✓ Branch 3 taken 30 times.
30 return getImpl<detail::WaterHeaterMixed_Impl>()->offCycleLossFractiontoThermalZone();
1651 }
1652
1653 ✗ bool WaterHeaterMixed::isOffCycleLossFractiontoThermalZoneDefaulted() const {
1654 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->isOffCycleLossFractiontoThermalZoneDefaulted();
1655 }
1656
1657 30 boost::optional<double> WaterHeaterMixed::onCycleLossCoefficienttoAmbientTemperature() const {
1658
1/1
✓ Branch 3 taken 30 times.
30 return getImpl<detail::WaterHeaterMixed_Impl>()->onCycleLossCoefficienttoAmbientTemperature();
1659 }
1660
1661 30 double WaterHeaterMixed::onCycleLossFractiontoThermalZone() const {
1662
1/1
✓ Branch 3 taken 30 times.
30 return getImpl<detail::WaterHeaterMixed_Impl>()->onCycleLossFractiontoThermalZone();
1663 }
1664
1665 ✗ bool WaterHeaterMixed::isOnCycleLossFractiontoThermalZoneDefaulted() const {
1666 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->isOnCycleLossFractiontoThermalZoneDefaulted();
1667 }
1668
1669 47 boost::optional<double> WaterHeaterMixed::peakUseFlowRate() const {
1670
1/1
✓ Branch 3 taken 47 times.
47 return getImpl<detail::WaterHeaterMixed_Impl>()->peakUseFlowRate();
1671 }
1672
1673 35 boost::optional<Schedule> WaterHeaterMixed::useFlowRateFractionSchedule() const {
1674
1/1
✓ Branch 3 taken 35 times.
35 return getImpl<detail::WaterHeaterMixed_Impl>()->useFlowRateFractionSchedule();
1675 }
1676
1677 30 boost::optional<Schedule> WaterHeaterMixed::coldWaterSupplyTemperatureSchedule() const {
1678
1/1
✓ Branch 3 taken 30 times.
30 return getImpl<detail::WaterHeaterMixed_Impl>()->coldWaterSupplyTemperatureSchedule();
1679 }
1680
1681 30 double WaterHeaterMixed::useSideEffectiveness() const {
1682
1/1
✓ Branch 3 taken 30 times.
30 return getImpl<detail::WaterHeaterMixed_Impl>()->useSideEffectiveness();
1683 }
1684
1685 ✗ bool WaterHeaterMixed::isUseSideEffectivenessDefaulted() const {
1686 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->isUseSideEffectivenessDefaulted();
1687 }
1688
1689 30 double WaterHeaterMixed::sourceSideEffectiveness() const {
1690
1/1
✓ Branch 3 taken 30 times.
30 return getImpl<detail::WaterHeaterMixed_Impl>()->sourceSideEffectiveness();
1691 }
1692
1693 ✗ bool WaterHeaterMixed::isSourceSideEffectivenessDefaulted() const {
1694 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->isSourceSideEffectivenessDefaulted();
1695 }
1696
1697 ✗ boost::optional<double> WaterHeaterMixed::useSideDesignFlowRate() const {
1698 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->useSideDesignFlowRate();
1699 }
1700
1701 ✗ bool WaterHeaterMixed::isUseSideDesignFlowRateDefaulted() const {
1702 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->isUseSideDesignFlowRateDefaulted();
1703 }
1704
1705 30 bool WaterHeaterMixed::isUseSideDesignFlowRateAutosized() const {
1706
1/1
✓ Branch 3 taken 30 times.
30 return getImpl<detail::WaterHeaterMixed_Impl>()->isUseSideDesignFlowRateAutosized();
1707 }
1708
1709 ✗ boost::optional<double> WaterHeaterMixed::sourceSideDesignFlowRate() const {
1710 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->sourceSideDesignFlowRate();
1711 }
1712
1713 ✗ bool WaterHeaterMixed::isSourceSideDesignFlowRateDefaulted() const {
1714 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->isSourceSideDesignFlowRateDefaulted();
1715 }
1716
1717 30 bool WaterHeaterMixed::isSourceSideDesignFlowRateAutosized() const {
1718
1/1
✓ Branch 3 taken 30 times.
30 return getImpl<detail::WaterHeaterMixed_Impl>()->isSourceSideDesignFlowRateAutosized();
1719 }
1720
1721 30 double WaterHeaterMixed::indirectWaterHeatingRecoveryTime() const {
1722
1/1
✓ Branch 3 taken 30 times.
30 return getImpl<detail::WaterHeaterMixed_Impl>()->indirectWaterHeatingRecoveryTime();
1723 }
1724
1725 ✗ bool WaterHeaterMixed::isIndirectWaterHeatingRecoveryTimeDefaulted() const {
1726 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->isIndirectWaterHeatingRecoveryTimeDefaulted();
1727 }
1728
1729 47 bool WaterHeaterMixed::setTankVolume(double tankVolume) {
1730
2/2
✓ Branch 3 taken 47 times.
✓ Branch 6 taken 47 times.
47 return getImpl<detail::WaterHeaterMixed_Impl>()->setTankVolume(tankVolume);
1731 }
1732
1733 ✗ void WaterHeaterMixed::resetTankVolume() {
1734 ✗ getImpl<detail::WaterHeaterMixed_Impl>()->resetTankVolume();
1735 ✗ }
1736
1737 ✗ void WaterHeaterMixed::autosizeTankVolume() {
1738 ✗ getImpl<detail::WaterHeaterMixed_Impl>()->autosizeTankVolume();
1739 ✗ }
1740
1741 53 bool WaterHeaterMixed::setSetpointTemperatureSchedule(Schedule& setpointTemperatureSchedule) {
1742
1/1
✓ Branch 3 taken 53 times.
53 return getImpl<detail::WaterHeaterMixed_Impl>()->setSetpointTemperatureSchedule(setpointTemperatureSchedule);
1743 }
1744
1745 ✗ void WaterHeaterMixed::resetSetpointTemperatureSchedule() {
1746 ✗ getImpl<detail::WaterHeaterMixed_Impl>()->resetSetpointTemperatureSchedule();
1747 ✗ }
1748
1749 46 bool WaterHeaterMixed::setDeadbandTemperatureDifference(double deadbandTemperatureDifference) {
1750
1/1
✓ Branch 3 taken 46 times.
46 return getImpl<detail::WaterHeaterMixed_Impl>()->setDeadbandTemperatureDifference(deadbandTemperatureDifference);
1751 }
1752
1753 ✗ void WaterHeaterMixed::resetDeadbandTemperatureDifference() {
1754 ✗ getImpl<detail::WaterHeaterMixed_Impl>()->resetDeadbandTemperatureDifference();
1755 ✗ }
1756
1757 46 bool WaterHeaterMixed::setMaximumTemperatureLimit(double maximumTemperatureLimit) {
1758
2/2
✓ Branch 3 taken 46 times.
✓ Branch 6 taken 46 times.
46 return getImpl<detail::WaterHeaterMixed_Impl>()->setMaximumTemperatureLimit(maximumTemperatureLimit);
1759 }
1760
1761 ✗ void WaterHeaterMixed::resetMaximumTemperatureLimit() {
1762 ✗ getImpl<detail::WaterHeaterMixed_Impl>()->resetMaximumTemperatureLimit();
1763 ✗ }
1764
1765 46 bool WaterHeaterMixed::setHeaterControlType(const std::string& heaterControlType) {
1766
1/1
✓ Branch 3 taken 46 times.
46 return getImpl<detail::WaterHeaterMixed_Impl>()->setHeaterControlType(heaterControlType);
1767 }
1768
1769 ✗ void WaterHeaterMixed::resetHeaterControlType() {
1770 ✗ getImpl<detail::WaterHeaterMixed_Impl>()->resetHeaterControlType();
1771 ✗ }
1772
1773 52 bool WaterHeaterMixed::setHeaterMaximumCapacity(double heaterMaximumCapacity) {
1774
2/2
✓ Branch 3 taken 52 times.
✓ Branch 6 taken 52 times.
52 return getImpl<detail::WaterHeaterMixed_Impl>()->setHeaterMaximumCapacity(heaterMaximumCapacity);
1775 }
1776
1777 ✗ void WaterHeaterMixed::resetHeaterMaximumCapacity() {
1778 ✗ getImpl<detail::WaterHeaterMixed_Impl>()->resetHeaterMaximumCapacity();
1779 ✗ }
1780
1781 ✗ void WaterHeaterMixed::autosizeHeaterMaximumCapacity() {
1782 ✗ getImpl<detail::WaterHeaterMixed_Impl>()->autosizeHeaterMaximumCapacity();
1783 ✗ }
1784
1785 ✗ bool WaterHeaterMixed::setHeaterMinimumCapacity(double heaterMinimumCapacity) {
1786 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->setHeaterMinimumCapacity(heaterMinimumCapacity);
1787 }
1788
1789 ✗ void WaterHeaterMixed::resetHeaterMinimumCapacity() {
1790 ✗ getImpl<detail::WaterHeaterMixed_Impl>()->resetHeaterMinimumCapacity();
1791 ✗ }
1792
1793 ✗ bool WaterHeaterMixed::setHeaterIgnitionMinimumFlowRate(double heaterIgnitionMinimumFlowRate) {
1794 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->setHeaterIgnitionMinimumFlowRate(heaterIgnitionMinimumFlowRate);
1795 }
1796
1797 ✗ void WaterHeaterMixed::resetHeaterIgnitionMinimumFlowRate() {
1798 ✗ getImpl<detail::WaterHeaterMixed_Impl>()->resetHeaterIgnitionMinimumFlowRate();
1799 ✗ }
1800
1801 ✗ bool WaterHeaterMixed::setHeaterIgnitionDelay(double heaterIgnitionDelay) {
1802 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->setHeaterIgnitionDelay(heaterIgnitionDelay);
1803 }
1804
1805 ✗ void WaterHeaterMixed::resetHeaterIgnitionDelay() {
1806 ✗ getImpl<detail::WaterHeaterMixed_Impl>()->resetHeaterIgnitionDelay();
1807 ✗ }
1808
1809 48 bool WaterHeaterMixed::setHeaterFuelType(const FuelType& heaterFuelType) {
1810
1/1
✓ Branch 3 taken 48 times.
48 return getImpl<detail::WaterHeaterMixed_Impl>()->setHeaterFuelType(heaterFuelType);
1811 }
1812
1813 2 bool WaterHeaterMixed::setHeaterFuelType(const std::string& heaterFuelType) {
1814 try {
1815
2/2
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
2 return setHeaterFuelType(FuelType{heaterFuelType});
1816 ✗ } catch (std::runtime_error& e) {
1817 ✗ LOG(Debug, e.what());
1818 ✗ return false;
1819 ✗ }
1820 }
1821
1822 57 bool WaterHeaterMixed::setHeaterThermalEfficiency(double heaterThermalEfficiency) {
1823
2/2
✓ Branch 3 taken 57 times.
✓ Branch 6 taken 57 times.
57 return getImpl<detail::WaterHeaterMixed_Impl>()->setHeaterThermalEfficiency(heaterThermalEfficiency);
1824 }
1825
1826 ✗ void WaterHeaterMixed::resetHeaterThermalEfficiency() {
1827 ✗ getImpl<detail::WaterHeaterMixed_Impl>()->resetHeaterThermalEfficiency();
1828 ✗ }
1829
1830 ✗ bool WaterHeaterMixed::setPartLoadFactorCurve(const CurveCubic& partLoadFactorCurve) {
1831 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->setPartLoadFactorCurve(partLoadFactorCurve);
1832 }
1833
1834 ✗ void WaterHeaterMixed::resetPartLoadFactorCurve() {
1835 ✗ getImpl<detail::WaterHeaterMixed_Impl>()->resetPartLoadFactorCurve();
1836 ✗ }
1837
1838 47 bool WaterHeaterMixed::setOffCycleParasiticFuelConsumptionRate(double offCycleParasiticFuelConsumptionRate) {
1839
1/1
✓ Branch 3 taken 47 times.
47 return getImpl<detail::WaterHeaterMixed_Impl>()->setOffCycleParasiticFuelConsumptionRate(offCycleParasiticFuelConsumptionRate);
1840 }
1841
1842 ✗ void WaterHeaterMixed::resetOffCycleParasiticFuelConsumptionRate() {
1843 ✗ getImpl<detail::WaterHeaterMixed_Impl>()->resetOffCycleParasiticFuelConsumptionRate();
1844 ✗ }
1845
1846 46 bool WaterHeaterMixed::setOffCycleParasiticFuelType(const FuelType& offCycleParasiticFuelType) {
1847
1/1
✓ Branch 3 taken 46 times.
46 return getImpl<detail::WaterHeaterMixed_Impl>()->setOffCycleParasiticFuelType(offCycleParasiticFuelType);
1848 }
1849
1850 1 bool WaterHeaterMixed::setOffCycleParasiticFuelType(const std::string& offCycleParasiticFuelType) {
1851 try {
1852
0/2
✗ Branch 1 not taken.
✗ Branch 4 not taken.
1 return setOffCycleParasiticFuelType(FuelType{offCycleParasiticFuelType});
1853
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
1 } catch (std::runtime_error& e) {
1854
5/5
✓ Branch 1 taken 1 time.
✓ Branch 5 taken 1 time.
✓ Branch 8 taken 1 time.
✓ Branch 11 taken 1 time.
✓ Branch 14 taken 1 time.
1 LOG(Debug, e.what());
1855 1 return false;
1856 1 }
1857 }
1858
1859 ✗ void WaterHeaterMixed::resetOffCycleParasiticFuelType() {
1860 ✗ getImpl<detail::WaterHeaterMixed_Impl>()->resetOffCycleParasiticFuelType();
1861 ✗ }
1862
1863 46 bool WaterHeaterMixed::setOffCycleParasiticHeatFractiontoTank(double offCycleParasiticHeatFractiontoTank) {
1864
1/1
✓ Branch 3 taken 46 times.
46 return getImpl<detail::WaterHeaterMixed_Impl>()->setOffCycleParasiticHeatFractiontoTank(offCycleParasiticHeatFractiontoTank);
1865 }
1866
1867 ✗ void WaterHeaterMixed::resetOffCycleParasiticHeatFractiontoTank() {
1868 ✗ getImpl<detail::WaterHeaterMixed_Impl>()->resetOffCycleParasiticHeatFractiontoTank();
1869 ✗ }
1870
1871 1 bool WaterHeaterMixed::setOnCycleParasiticFuelConsumptionRate(double onCycleParasiticFuelConsumptionRate) {
1872
1/1
✓ Branch 3 taken 1 time.
1 return getImpl<detail::WaterHeaterMixed_Impl>()->setOnCycleParasiticFuelConsumptionRate(onCycleParasiticFuelConsumptionRate);
1873 }
1874
1875 ✗ void WaterHeaterMixed::resetOnCycleParasiticFuelConsumptionRate() {
1876 ✗ getImpl<detail::WaterHeaterMixed_Impl>()->resetOnCycleParasiticFuelConsumptionRate();
1877 ✗ }
1878
1879 46 bool WaterHeaterMixed::setOnCycleParasiticFuelType(const FuelType& onCycleParasiticFuelType) {
1880
1/1
✓ Branch 3 taken 46 times.
46 return getImpl<detail::WaterHeaterMixed_Impl>()->setOnCycleParasiticFuelType(onCycleParasiticFuelType);
1881 }
1882
1883 1 bool WaterHeaterMixed::setOnCycleParasiticFuelType(const std::string& onCycleParasiticFuelType) {
1884 try {
1885
0/2
✗ Branch 1 not taken.
✗ Branch 4 not taken.
1 return setOnCycleParasiticFuelType(FuelType{onCycleParasiticFuelType});
1886
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
1 } catch (std::runtime_error& e) {
1887
5/5
✓ Branch 1 taken 1 time.
✓ Branch 5 taken 1 time.
✓ Branch 8 taken 1 time.
✓ Branch 11 taken 1 time.
✓ Branch 14 taken 1 time.
1 LOG(Debug, e.what());
1888 1 return false;
1889 1 }
1890 }
1891
1892 ✗ void WaterHeaterMixed::resetOnCycleParasiticFuelType() {
1893 ✗ getImpl<detail::WaterHeaterMixed_Impl>()->resetOnCycleParasiticFuelType();
1894 ✗ }
1895
1896 ✗ bool WaterHeaterMixed::setOnCycleParasiticHeatFractiontoTank(double onCycleParasiticHeatFractiontoTank) {
1897 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->setOnCycleParasiticHeatFractiontoTank(onCycleParasiticHeatFractiontoTank);
1898 }
1899
1900 ✗ void WaterHeaterMixed::resetOnCycleParasiticHeatFractiontoTank() {
1901 ✗ getImpl<detail::WaterHeaterMixed_Impl>()->resetOnCycleParasiticHeatFractiontoTank();
1902 ✗ }
1903
1904 52 bool WaterHeaterMixed::setAmbientTemperatureIndicator(const std::string& ambientTemperatureIndicator) {
1905
1/1
✓ Branch 3 taken 52 times.
52 return getImpl<detail::WaterHeaterMixed_Impl>()->setAmbientTemperatureIndicator(ambientTemperatureIndicator);
1906 }
1907
1908 47 bool WaterHeaterMixed::setAmbientTemperatureSchedule(Schedule& ambientTemperatureSchedule) {
1909
1/1
✓ Branch 3 taken 47 times.
47 return getImpl<detail::WaterHeaterMixed_Impl>()->setAmbientTemperatureSchedule(ambientTemperatureSchedule);
1910 }
1911
1912 ✗ void WaterHeaterMixed::resetAmbientTemperatureSchedule() {
1913 ✗ getImpl<detail::WaterHeaterMixed_Impl>()->resetAmbientTemperatureSchedule();
1914 ✗ }
1915
1916 5 bool WaterHeaterMixed::setAmbientTemperatureThermalZone(const ThermalZone& ambientTemperatureThermalZone) {
1917
2/2
✓ Branch 3 taken 5 times.
✓ Branch 6 taken 5 times.
5 return getImpl<detail::WaterHeaterMixed_Impl>()->setAmbientTemperatureThermalZone(ambientTemperatureThermalZone);
1918 }
1919
1920 ✗ void WaterHeaterMixed::resetAmbientTemperatureThermalZone() {
1921 ✗ getImpl<detail::WaterHeaterMixed_Impl>()->resetAmbientTemperatureThermalZone();
1922 ✗ }
1923
1924 ✗ bool WaterHeaterMixed::setAmbientTemperatureOutdoorAirNodeName(const std::string& ambientTemperatureOutdoorAirNodeName) {
1925 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->setAmbientTemperatureOutdoorAirNodeName(ambientTemperatureOutdoorAirNodeName);
1926 }
1927
1928 ✗ void WaterHeaterMixed::resetAmbientTemperatureOutdoorAirNodeName() {
1929 ✗ getImpl<detail::WaterHeaterMixed_Impl>()->resetAmbientTemperatureOutdoorAirNodeName();
1930 ✗ }
1931
1932 47 bool WaterHeaterMixed::setOffCycleLossCoefficienttoAmbientTemperature(double offCycleLossCoefficienttoAmbientTemperature) {
1933
2/2
✓ Branch 3 taken 47 times.
✓ Branch 6 taken 47 times.
47 return getImpl<detail::WaterHeaterMixed_Impl>()->setOffCycleLossCoefficienttoAmbientTemperature(offCycleLossCoefficienttoAmbientTemperature);
1934 }
1935
1936 ✗ void WaterHeaterMixed::resetOffCycleLossCoefficienttoAmbientTemperature() {
1937 ✗ getImpl<detail::WaterHeaterMixed_Impl>()->resetOffCycleLossCoefficienttoAmbientTemperature();
1938 ✗ }
1939
1940 ✗ bool WaterHeaterMixed::setOffCycleLossFractiontoThermalZone(double offCycleLossFractiontoThermalZone) {
1941 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->setOffCycleLossFractiontoThermalZone(offCycleLossFractiontoThermalZone);
1942 }
1943
1944 ✗ void WaterHeaterMixed::resetOffCycleLossFractiontoThermalZone() {
1945 ✗ getImpl<detail::WaterHeaterMixed_Impl>()->resetOffCycleLossFractiontoThermalZone();
1946 ✗ }
1947
1948 47 bool WaterHeaterMixed::setOnCycleLossCoefficienttoAmbientTemperature(double onCycleLossCoefficienttoAmbientTemperature) {
1949
2/2
✓ Branch 3 taken 47 times.
✓ Branch 6 taken 47 times.
47 return getImpl<detail::WaterHeaterMixed_Impl>()->setOnCycleLossCoefficienttoAmbientTemperature(onCycleLossCoefficienttoAmbientTemperature);
1950 }
1951
1952 ✗ void WaterHeaterMixed::resetOnCycleLossCoefficienttoAmbientTemperature() {
1953 ✗ getImpl<detail::WaterHeaterMixed_Impl>()->resetOnCycleLossCoefficienttoAmbientTemperature();
1954 ✗ }
1955
1956 ✗ bool WaterHeaterMixed::setOnCycleLossFractiontoThermalZone(double onCycleLossFractiontoThermalZone) {
1957 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->setOnCycleLossFractiontoThermalZone(onCycleLossFractiontoThermalZone);
1958 }
1959
1960 ✗ void WaterHeaterMixed::resetOnCycleLossFractiontoThermalZone() {
1961 ✗ getImpl<detail::WaterHeaterMixed_Impl>()->resetOnCycleLossFractiontoThermalZone();
1962 ✗ }
1963
1964 1 bool WaterHeaterMixed::setPeakUseFlowRate(double peakUseFlowRate) {
1965
2/2
✓ Branch 3 taken 1 time.
✓ Branch 6 taken 1 time.
1 return getImpl<detail::WaterHeaterMixed_Impl>()->setPeakUseFlowRate(peakUseFlowRate);
1966 }
1967
1968 1 void WaterHeaterMixed::resetPeakUseFlowRate() {
1969
1/1
✓ Branch 3 taken 1 time.
1 getImpl<detail::WaterHeaterMixed_Impl>()->resetPeakUseFlowRate();
1970 1 }
1971
1972 1 bool WaterHeaterMixed::setUseFlowRateFractionSchedule(Schedule& useFlowRateFractionSchedule) {
1973
1/1
✓ Branch 3 taken 1 time.
1 return getImpl<detail::WaterHeaterMixed_Impl>()->setUseFlowRateFractionSchedule(useFlowRateFractionSchedule);
1974 }
1975
1976 1 void WaterHeaterMixed::resetUseFlowRateFractionSchedule() {
1977
1/1
✓ Branch 3 taken 1 time.
1 getImpl<detail::WaterHeaterMixed_Impl>()->resetUseFlowRateFractionSchedule();
1978 1 }
1979
1980 ✗ bool WaterHeaterMixed::setColdWaterSupplyTemperatureSchedule(Schedule& coldWaterSupplyTemperatureSchedule) {
1981 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->setColdWaterSupplyTemperatureSchedule(coldWaterSupplyTemperatureSchedule);
1982 }
1983
1984 ✗ void WaterHeaterMixed::resetColdWaterSupplyTemperatureSchedule() {
1985 ✗ getImpl<detail::WaterHeaterMixed_Impl>()->resetColdWaterSupplyTemperatureSchedule();
1986 ✗ }
1987
1988 46 bool WaterHeaterMixed::setUseSideEffectiveness(double useSideEffectiveness) {
1989
1/1
✓ Branch 3 taken 46 times.
46 return getImpl<detail::WaterHeaterMixed_Impl>()->setUseSideEffectiveness(useSideEffectiveness);
1990 }
1991
1992 ✗ void WaterHeaterMixed::resetUseSideEffectiveness() {
1993 ✗ getImpl<detail::WaterHeaterMixed_Impl>()->resetUseSideEffectiveness();
1994 ✗ }
1995
1996 46 bool WaterHeaterMixed::setSourceSideEffectiveness(double sourceSideEffectiveness) {
1997
1/1
✓ Branch 3 taken 46 times.
46 return getImpl<detail::WaterHeaterMixed_Impl>()->setSourceSideEffectiveness(sourceSideEffectiveness);
1998 }
1999
2000 ✗ void WaterHeaterMixed::resetSourceSideEffectiveness() {
2001 ✗ getImpl<detail::WaterHeaterMixed_Impl>()->resetSourceSideEffectiveness();
2002 ✗ }
2003
2004 ✗ bool WaterHeaterMixed::setUseSideDesignFlowRate(double useSideDesignFlowRate) {
2005 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->setUseSideDesignFlowRate(useSideDesignFlowRate);
2006 }
2007
2008 ✗ void WaterHeaterMixed::resetUseSideDesignFlowRate() {
2009 ✗ getImpl<detail::WaterHeaterMixed_Impl>()->resetUseSideDesignFlowRate();
2010 ✗ }
2011
2012 46 void WaterHeaterMixed::autosizeUseSideDesignFlowRate() {
2013
1/1
✓ Branch 3 taken 46 times.
46 getImpl<detail::WaterHeaterMixed_Impl>()->autosizeUseSideDesignFlowRate();
2014 46 }
2015
2016 ✗ bool WaterHeaterMixed::setSourceSideDesignFlowRate(double sourceSideDesignFlowRate) {
2017 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->setSourceSideDesignFlowRate(sourceSideDesignFlowRate);
2018 }
2019
2020 ✗ void WaterHeaterMixed::resetSourceSideDesignFlowRate() {
2021 ✗ getImpl<detail::WaterHeaterMixed_Impl>()->resetSourceSideDesignFlowRate();
2022 ✗ }
2023
2024 46 void WaterHeaterMixed::autosizeSourceSideDesignFlowRate() {
2025
1/1
✓ Branch 3 taken 46 times.
46 getImpl<detail::WaterHeaterMixed_Impl>()->autosizeSourceSideDesignFlowRate();
2026 46 }
2027
2028 46 bool WaterHeaterMixed::setIndirectWaterHeatingRecoveryTime(double indirectWaterHeatingRecoveryTime) {
2029
1/1
✓ Branch 3 taken 46 times.
46 return getImpl<detail::WaterHeaterMixed_Impl>()->setIndirectWaterHeatingRecoveryTime(indirectWaterHeatingRecoveryTime);
2030 }
2031
2032 ✗ void WaterHeaterMixed::resetIndirectWaterHeatingRecoveryTime() {
2033 ✗ getImpl<detail::WaterHeaterMixed_Impl>()->resetIndirectWaterHeatingRecoveryTime();
2034 ✗ }
2035
2036 ✗ std::vector<std::string> WaterHeaterMixed::sourceSideFlowControlModeValues() {
2037 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_WaterHeater_MixedFields::SourceSideFlowControlMode);
2038 }
2039
2040 33 std::string WaterHeaterMixed::sourceSideFlowControlMode() const {
2041
1/1
✓ Branch 3 taken 33 times.
33 return getImpl<detail::WaterHeaterMixed_Impl>()->sourceSideFlowControlMode();
2042 }
2043
2044 50 bool WaterHeaterMixed::setSourceSideFlowControlMode(const std::string& sourceSideFlowControlMode) {
2045
1/1
✓ Branch 3 taken 50 times.
50 return getImpl<detail::WaterHeaterMixed_Impl>()->setSourceSideFlowControlMode(sourceSideFlowControlMode);
2046 }
2047
2048 5 boost::optional<Schedule> WaterHeaterMixed::indirectAlternateSetpointTemperatureSchedule() const {
2049
1/1
✓ Branch 3 taken 5 times.
5 return getImpl<detail::WaterHeaterMixed_Impl>()->indirectAlternateSetpointTemperatureSchedule();
2050 }
2051
2052 2 bool WaterHeaterMixed::setIndirectAlternateSetpointTemperatureSchedule(Schedule& indirectAlternateSetpointTemperatureSchedule) {
2053
1/1
✓ Branch 3 taken 2 times.
2 return getImpl<detail::WaterHeaterMixed_Impl>()->setIndirectAlternateSetpointTemperatureSchedule(indirectAlternateSetpointTemperatureSchedule);
2054 }
2055 1 void WaterHeaterMixed::resetIndirectAlternateSetpointTemperatureSchedule() {
2056
1/1
✓ Branch 3 taken 1 time.
1 getImpl<detail::WaterHeaterMixed_Impl>()->resetIndirectAlternateSetpointTemperatureSchedule();
2057 1 }
2058
2059 32 std::string WaterHeaterMixed::endUseSubcategory() const {
2060
1/1
✓ Branch 3 taken 32 times.
32 return getImpl<detail::WaterHeaterMixed_Impl>()->endUseSubcategory();
2061 }
2062
2063 47 bool WaterHeaterMixed::setEndUseSubcategory(const std::string& endUseSubcategory) {
2064
1/1
✓ Branch 3 taken 47 times.
47 return getImpl<detail::WaterHeaterMixed_Impl>()->setEndUseSubcategory(endUseSubcategory);
2065 }
2066
2067 /// @cond
2068
1/1
✓ Branch 3 taken 226 times.
226 WaterHeaterMixed::WaterHeaterMixed(std::shared_ptr<detail::WaterHeaterMixed_Impl> impl) : WaterToWaterComponent(std::move(impl)) {}
2069 /// @endcond
2070
2071 ✗ boost::optional<double> WaterHeaterMixed::autosizedTankVolume() const {
2072 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->autosizedTankVolume();
2073 }
2074
2075 ✗ boost::optional<double> WaterHeaterMixed::autosizedHeaterMaximumCapacity() const {
2076 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->autosizedHeaterMaximumCapacity();
2077 }
2078
2079 ✗ boost::optional<double> WaterHeaterMixed::autosizedUseSideDesignFlowRate() const {
2080 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->autosizedUseSideDesignFlowRate();
2081 }
2082
2083 ✗ boost::optional<double> WaterHeaterMixed::autosizedSourceSideDesignFlowRate() const {
2084 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->autosizedSourceSideDesignFlowRate();
2085 }
2086
2087 35 WaterHeaterSizing WaterHeaterMixed::waterHeaterSizing() const {
2088
1/1
✓ Branch 3 taken 35 times.
35 return getImpl<detail::WaterHeaterMixed_Impl>()->waterHeaterSizing();
2089 }
2090
2091 // Helper
2092 1 bool WaterHeaterMixed::addToSourceSideNode(Node& node) {
2093
1/1
✓ Branch 3 taken 1 time.
1 return getImpl<detail::WaterHeaterMixed_Impl>()->addToSourceSideNode(node);
2094 }
2095
2096 // Name aliases
2097 45 boost::optional<PlantLoop> WaterHeaterMixed::sourceSidePlantLoop() const {
2098
1/1
✓ Branch 3 taken 45 times.
45 return getImpl<detail::WaterHeaterMixed_Impl>()->sourceSidePlantLoop();
2099 }
2100
2101 12 boost::optional<PlantLoop> WaterHeaterMixed::useSidePlantLoop() const {
2102
1/1
✓ Branch 3 taken 12 times.
12 return getImpl<detail::WaterHeaterMixed_Impl>()->useSidePlantLoop();
2103 }
2104
2105 3 bool WaterHeaterMixed::removeFromSourceSidePlantLoop() {
2106
1/1
✓ Branch 3 taken 3 times.
3 return getImpl<detail::WaterHeaterMixed_Impl>()->removeFromSourceSidePlantLoop();
2107 }
2108
2109 ✗ boost::optional<ModelObject> WaterHeaterMixed::useSideInletModelObject() const {
2110 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->useSideInletModelObject();
2111 }
2112
2113 ✗ boost::optional<ModelObject> WaterHeaterMixed::useSideOutletModelObject() const {
2114 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->useSideOutletModelObject();
2115 }
2116
2117 ✗ boost::optional<ModelObject> WaterHeaterMixed::sourceSideInletModelObject() const {
2118 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->sourceSideInletModelObject();
2119 }
2120
2121 ✗ boost::optional<ModelObject> WaterHeaterMixed::sourceSideOutletModelObject() const {
2122 ✗ return getImpl<detail::WaterHeaterMixed_Impl>()->sourceSideOutletModelObject();
2123 }
2124
2125 } // namespace model
2126 } // namespace openstudio
2127