GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 45.3% 208 / 0 / 459
Functions: 45.8% 60 / 0 / 131
Branches: 33.6% 193 / 0 / 574

src/model/HeatExchangerFluidToFluid.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 "HeatExchangerFluidToFluid.hpp"
7 #include "HeatExchangerFluidToFluid_Impl.hpp"
8
9 #include "Schedule.hpp"
10 #include "Schedule_Impl.hpp"
11 #include "Connection.hpp"
12 #include "Connection_Impl.hpp"
13 #include "Node.hpp"
14 #include "Node_Impl.hpp"
15 #include "ScheduleTypeLimits.hpp"
16 #include "ScheduleTypeRegistry.hpp"
17 #include "Model.hpp"
18 #include "Model_Impl.hpp"
19
20 #include "../utilities/core/Assert.hpp"
21 #include "../utilities/data/DataEnums.hpp"
22
23 #include <utilities/idd/IddFactory.hxx>
24 #include <utilities/idd/OS_HeatExchanger_FluidToFluid_FieldEnums.hxx>
25 #include <utilities/idd/IddEnums.hxx>
26
27 namespace openstudio {
28 namespace model {
29
30 namespace detail {
31
32 8 HeatExchangerFluidToFluid_Impl::HeatExchangerFluidToFluid_Impl(const IdfObject& idfObject, Model_Impl* model, bool keepHandle)
33 8 : WaterToWaterComponent_Impl(idfObject, model, keepHandle) {
34
4/6
✓ Branch 1 taken 8 times.
✓ Branch 4 taken 8 times.
✓ Branch 7 taken 8 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 8 times.
✗ Branch 13 not taken.
8 OS_ASSERT(idfObject.iddObject().type() == HeatExchangerFluidToFluid::iddObjectType());
35 8 }
36
37 ✗ HeatExchangerFluidToFluid_Impl::HeatExchangerFluidToFluid_Impl(const openstudio::detail::WorkspaceObject_Impl& other, Model_Impl* model,
38 ✗ bool keepHandle)
39 ✗ : WaterToWaterComponent_Impl(other, model, keepHandle) {
40 ✗ OS_ASSERT(other.iddObject().type() == HeatExchangerFluidToFluid::iddObjectType());
41 ✗ }
42
43 3 HeatExchangerFluidToFluid_Impl::HeatExchangerFluidToFluid_Impl(const HeatExchangerFluidToFluid_Impl& other, Model_Impl* model, bool keepHandle)
44 3 : WaterToWaterComponent_Impl(other, model, keepHandle) {}
45
46 ✗ const std::vector<std::string>& HeatExchangerFluidToFluid_Impl::outputVariableNames() const {
47 static const std::vector<std::string> result{"Fluid Heat Exchanger Heat Transfer Rate",
48 "Fluid Heat Exchanger Heat Transfer Energy",
49 "Fluid Heat Exchanger Loop Supply Side Mass Flow Rate",
50 "Fluid Heat Exchanger Loop Supply Side Inlet Temperature",
51 "Fluid Heat Exchanger Loop Supply Side Outlet Temperature",
52 "Fluid Heat Exchanger Loop Demand Side Mass Flow Rate",
53 "Fluid Heat Exchanger Loop Demand Side Inlet Temperature",
54 "Fluid Heat Exchanger Loop Demand Side Outlet Temperature",
55 "Fluid Heat Exchanger Operation Status",
56 ✗ "Fluid Heat Exchanger Effectiveness"};
57 ✗ return result;
58 ✗ }
59
60 ✗ IddObjectType HeatExchangerFluidToFluid_Impl::iddObjectType() const {
61 ✗ return HeatExchangerFluidToFluid::iddObjectType();
62 }
63
64 ✗ std::vector<ScheduleTypeKey> HeatExchangerFluidToFluid_Impl::getScheduleTypeKeys(const Schedule& schedule) const {
65 // TODO: Check schedule display names.
66 ✗ std::vector<ScheduleTypeKey> result;
67 ✗ UnsignedVector fieldIndices = getSourceIndices(schedule.handle());
68 ✗ UnsignedVector::const_iterator b(fieldIndices.begin());
69 ✗ UnsignedVector::const_iterator e(fieldIndices.end());
70 ✗ if (std::find(b, e, OS_HeatExchanger_FluidToFluidFields::AvailabilityScheduleName) != e) {
71 ✗ result.push_back(ScheduleTypeKey("HeatExchangerFluidToFluid", "Availability"));
72 }
73 ✗ return result;
74 ✗ }
75
76 3 boost::optional<Schedule> HeatExchangerFluidToFluid_Impl::availabilitySchedule() const {
77
2/2
✓ Branch 1 taken 3 times.
✓ Branch 4 taken 3 times.
3 return getObject<ModelObject>().getModelObjectTarget<Schedule>(OS_HeatExchanger_FluidToFluidFields::AvailabilityScheduleName);
78 }
79
80 ✗ boost::optional<double> HeatExchangerFluidToFluid_Impl::loopDemandSideDesignFlowRate() const {
81 ✗ return getDouble(OS_HeatExchanger_FluidToFluidFields::LoopDemandSideDesignFlowRate, true);
82 }
83
84 3 bool HeatExchangerFluidToFluid_Impl::isLoopDemandSideDesignFlowRateAutosized() const {
85 3 bool result = false;
86
1/1
✓ Branch 1 taken 3 times.
3 boost::optional<std::string> value = getString(OS_HeatExchanger_FluidToFluidFields::LoopDemandSideDesignFlowRate, true);
87
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
3 if (value) {
88
3/3
✓ Branch 1 taken 3 times.
✓ Branch 4 taken 3 times.
✓ Branch 7 taken 3 times.
6 result = openstudio::istringEqual(value.get(), "autosize");
89 }
90 3 return result;
91 3 }
92
93 ✗ boost::optional<double> HeatExchangerFluidToFluid_Impl::loopSupplySideDesignFlowRate() const {
94 ✗ return getDouble(OS_HeatExchanger_FluidToFluidFields::LoopSupplySideDesignFlowRate, true);
95 }
96
97 3 bool HeatExchangerFluidToFluid_Impl::isLoopSupplySideDesignFlowRateAutosized() const {
98 3 bool result = false;
99
1/1
✓ Branch 1 taken 3 times.
3 boost::optional<std::string> value = getString(OS_HeatExchanger_FluidToFluidFields::LoopSupplySideDesignFlowRate, true);
100
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
3 if (value) {
101
3/3
✓ Branch 1 taken 3 times.
✓ Branch 4 taken 3 times.
✓ Branch 7 taken 3 times.
6 result = openstudio::istringEqual(value.get(), "autosize");
102 }
103 3 return result;
104 3 }
105
106 3 std::string HeatExchangerFluidToFluid_Impl::heatExchangeModelType() const {
107
1/1
✓ Branch 1 taken 3 times.
3 boost::optional<std::string> value = getString(OS_HeatExchanger_FluidToFluidFields::HeatExchangeModelType, true);
108
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 4 not taken.
3 OS_ASSERT(value);
109
2/2
✓ Branch 1 taken 3 times.
✓ Branch 4 taken 3 times.
6 return value.get();
110 3 }
111
112 ✗ bool HeatExchangerFluidToFluid_Impl::isHeatExchangeModelTypeDefaulted() const {
113 ✗ return isEmpty(OS_HeatExchanger_FluidToFluidFields::HeatExchangeModelType);
114 }
115
116 ✗ boost::optional<double> HeatExchangerFluidToFluid_Impl::heatExchangerUFactorTimesAreaValue() const {
117 ✗ return getDouble(OS_HeatExchanger_FluidToFluidFields::HeatExchangerUFactorTimesAreaValue, true);
118 }
119
120 3 bool HeatExchangerFluidToFluid_Impl::isHeatExchangerUFactorTimesAreaValueAutosized() const {
121 3 bool result = false;
122
1/1
✓ Branch 1 taken 3 times.
3 boost::optional<std::string> value = getString(OS_HeatExchanger_FluidToFluidFields::HeatExchangerUFactorTimesAreaValue, true);
123
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
3 if (value) {
124
3/3
✓ Branch 1 taken 3 times.
✓ Branch 4 taken 3 times.
✓ Branch 7 taken 3 times.
6 result = openstudio::istringEqual(value.get(), "autosize");
125 }
126 3 return result;
127 3 }
128
129 23 std::string HeatExchangerFluidToFluid_Impl::controlType() const {
130
1/1
✓ Branch 1 taken 23 times.
23 boost::optional<std::string> value = getString(OS_HeatExchanger_FluidToFluidFields::ControlType, true);
131
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 23 times.
✗ Branch 4 not taken.
23 OS_ASSERT(value);
132
2/2
✓ Branch 1 taken 23 times.
✓ Branch 4 taken 23 times.
46 return value.get();
133 23 }
134
135 ✗ bool HeatExchangerFluidToFluid_Impl::isControlTypeDefaulted() const {
136 ✗ return isEmpty(OS_HeatExchanger_FluidToFluidFields::ControlType);
137 }
138
139 3 double HeatExchangerFluidToFluid_Impl::minimumTemperatureDifferencetoActivateHeatExchanger() const {
140
1/1
✓ Branch 1 taken 3 times.
3 boost::optional<double> value = getDouble(OS_HeatExchanger_FluidToFluidFields::MinimumTemperatureDifferencetoActivateHeatExchanger, true);
141
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 4 not taken.
3 OS_ASSERT(value);
142
1/1
✓ Branch 1 taken 3 times.
6 return value.get();
143 }
144
145 ✗ bool HeatExchangerFluidToFluid_Impl::isMinimumTemperatureDifferencetoActivateHeatExchangerDefaulted() const {
146 ✗ return isEmpty(OS_HeatExchanger_FluidToFluidFields::MinimumTemperatureDifferencetoActivateHeatExchanger);
147 }
148
149 3 std::string HeatExchangerFluidToFluid_Impl::heatTransferMeteringEndUseType() const {
150
1/1
✓ Branch 1 taken 3 times.
3 boost::optional<std::string> value = getString(OS_HeatExchanger_FluidToFluidFields::HeatTransferMeteringEndUseType, true);
151
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 4 not taken.
3 OS_ASSERT(value);
152
2/2
✓ Branch 1 taken 3 times.
✓ Branch 4 taken 3 times.
6 return value.get();
153 3 }
154
155 ✗ bool HeatExchangerFluidToFluid_Impl::isHeatTransferMeteringEndUseTypeDefaulted() const {
156 ✗ return isEmpty(OS_HeatExchanger_FluidToFluidFields::HeatTransferMeteringEndUseType);
157 }
158
159 3 boost::optional<Node> HeatExchangerFluidToFluid_Impl::componentOverrideLoopSupplySideInletNode() const {
160
2/2
✓ Branch 1 taken 3 times.
✓ Branch 4 taken 3 times.
3 return getObject<ModelObject>().getModelObjectTarget<Node>(OS_HeatExchanger_FluidToFluidFields::ComponentOverrideLoopSupplySideInletNode);
161 }
162
163 3 boost::optional<Node> HeatExchangerFluidToFluid_Impl::componentOverrideLoopDemandSideInletNode() const {
164
2/2
✓ Branch 1 taken 3 times.
✓ Branch 4 taken 3 times.
3 return getObject<ModelObject>().getModelObjectTarget<Node>(OS_HeatExchanger_FluidToFluidFields::ComponentOverrideLoopDemandSideInletNode);
165 }
166
167 3 std::string HeatExchangerFluidToFluid_Impl::componentOverrideCoolingControlTemperatureMode() const {
168
1/1
✓ Branch 1 taken 3 times.
3 boost::optional<std::string> value = getString(OS_HeatExchanger_FluidToFluidFields::ComponentOverrideCoolingControlTemperatureMode, true);
169
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 4 not taken.
3 OS_ASSERT(value);
170
2/2
✓ Branch 1 taken 3 times.
✓ Branch 4 taken 3 times.
6 return value.get();
171 3 }
172
173 ✗ bool HeatExchangerFluidToFluid_Impl::isComponentOverrideCoolingControlTemperatureModeDefaulted() const {
174 ✗ return isEmpty(OS_HeatExchanger_FluidToFluidFields::ComponentOverrideCoolingControlTemperatureMode);
175 }
176
177 3 double HeatExchangerFluidToFluid_Impl::sizingFactor() const {
178
1/1
✓ Branch 1 taken 3 times.
3 boost::optional<double> value = getDouble(OS_HeatExchanger_FluidToFluidFields::SizingFactor, true);
179
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 4 not taken.
3 OS_ASSERT(value);
180
1/1
✓ Branch 1 taken 3 times.
6 return value.get();
181 }
182
183 ✗ bool HeatExchangerFluidToFluid_Impl::isSizingFactorDefaulted() const {
184 ✗ return isEmpty(OS_HeatExchanger_FluidToFluidFields::SizingFactor);
185 }
186
187 3 boost::optional<double> HeatExchangerFluidToFluid_Impl::operationMinimumTemperatureLimit() const {
188 3 return getDouble(OS_HeatExchanger_FluidToFluidFields::OperationMinimumTemperatureLimit, true);
189 }
190
191 3 boost::optional<double> HeatExchangerFluidToFluid_Impl::operationMaximumTemperatureLimit() const {
192 3 return getDouble(OS_HeatExchanger_FluidToFluidFields::OperationMaximumTemperatureLimit, true);
193 }
194
195 ✗ bool HeatExchangerFluidToFluid_Impl::setAvailabilitySchedule(Schedule& schedule) {
196 ✗ bool result = setSchedule(OS_HeatExchanger_FluidToFluidFields::AvailabilityScheduleName, "HeatExchangerFluidToFluid", "Availability", schedule);
197 ✗ return result;
198 }
199
200 ✗ void HeatExchangerFluidToFluid_Impl::resetAvailabilitySchedule() {
201 ✗ bool result = setString(OS_HeatExchanger_FluidToFluidFields::AvailabilityScheduleName, "");
202 ✗ OS_ASSERT(result);
203 ✗ }
204
205 ✗ bool HeatExchangerFluidToFluid_Impl::setLoopDemandSideDesignFlowRate(boost::optional<double> loopDemandSideDesignFlowRate) {
206 ✗ bool result(false);
207 ✗ if (loopDemandSideDesignFlowRate) {
208 ✗ result = setDouble(OS_HeatExchanger_FluidToFluidFields::LoopDemandSideDesignFlowRate, loopDemandSideDesignFlowRate.get());
209 }
210 ✗ return result;
211 }
212
213 8 void HeatExchangerFluidToFluid_Impl::autosizeLoopDemandSideDesignFlowRate() {
214
2/2
✓ Branch 1 taken 8 times.
✓ Branch 4 taken 8 times.
16 bool result = setString(OS_HeatExchanger_FluidToFluidFields::LoopDemandSideDesignFlowRate, "autosize");
215
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
8 OS_ASSERT(result);
216 8 }
217
218 ✗ bool HeatExchangerFluidToFluid_Impl::setLoopSupplySideDesignFlowRate(boost::optional<double> loopSupplySideDesignFlowRate) {
219 ✗ bool result(false);
220 ✗ if (loopSupplySideDesignFlowRate) {
221 ✗ result = setDouble(OS_HeatExchanger_FluidToFluidFields::LoopSupplySideDesignFlowRate, loopSupplySideDesignFlowRate.get());
222 }
223 ✗ return result;
224 }
225
226 8 void HeatExchangerFluidToFluid_Impl::autosizeLoopSupplySideDesignFlowRate() {
227
2/2
✓ Branch 1 taken 8 times.
✓ Branch 4 taken 8 times.
16 bool result = setString(OS_HeatExchanger_FluidToFluidFields::LoopSupplySideDesignFlowRate, "autosize");
228
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
8 OS_ASSERT(result);
229 8 }
230
231 8 bool HeatExchangerFluidToFluid_Impl::setHeatExchangeModelType(const std::string& heatExchangeModelType) {
232 8 bool result = setString(OS_HeatExchanger_FluidToFluidFields::HeatExchangeModelType, heatExchangeModelType);
233 8 return result;
234 }
235
236 ✗ void HeatExchangerFluidToFluid_Impl::resetHeatExchangeModelType() {
237 ✗ bool result = setString(OS_HeatExchanger_FluidToFluidFields::HeatExchangeModelType, "");
238 ✗ OS_ASSERT(result);
239 ✗ }
240
241 ✗ bool HeatExchangerFluidToFluid_Impl::setHeatExchangerUFactorTimesAreaValue(boost::optional<double> heatExchangerUFactorTimesAreaValue) {
242 ✗ bool result(false);
243 ✗ if (heatExchangerUFactorTimesAreaValue) {
244 ✗ result = setDouble(OS_HeatExchanger_FluidToFluidFields::HeatExchangerUFactorTimesAreaValue, heatExchangerUFactorTimesAreaValue.get());
245 }
246 ✗ return result;
247 }
248
249 8 void HeatExchangerFluidToFluid_Impl::autosizeHeatExchangerUFactorTimesAreaValue() {
250
2/2
✓ Branch 1 taken 8 times.
✓ Branch 4 taken 8 times.
16 bool result = setString(OS_HeatExchanger_FluidToFluidFields::HeatExchangerUFactorTimesAreaValue, "autosize");
251
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
8 OS_ASSERT(result);
252 8 }
253
254 22 bool HeatExchangerFluidToFluid_Impl::setControlType(const std::string& controlType) {
255 22 bool result = setString(OS_HeatExchanger_FluidToFluidFields::ControlType, controlType);
256 22 return result;
257 }
258
259 ✗ void HeatExchangerFluidToFluid_Impl::resetControlType() {
260 ✗ bool result = setString(OS_HeatExchanger_FluidToFluidFields::ControlType, "");
261 ✗ OS_ASSERT(result);
262 ✗ }
263
264 8 bool HeatExchangerFluidToFluid_Impl::setMinimumTemperatureDifferencetoActivateHeatExchanger(
265 double minimumTemperatureDifferencetoActivateHeatExchanger) {
266 8 bool result = setDouble(OS_HeatExchanger_FluidToFluidFields::MinimumTemperatureDifferencetoActivateHeatExchanger,
267 minimumTemperatureDifferencetoActivateHeatExchanger);
268 8 return result;
269 }
270
271 ✗ void HeatExchangerFluidToFluid_Impl::resetMinimumTemperatureDifferencetoActivateHeatExchanger() {
272 ✗ bool result = setString(OS_HeatExchanger_FluidToFluidFields::MinimumTemperatureDifferencetoActivateHeatExchanger, "");
273 ✗ OS_ASSERT(result);
274 ✗ }
275
276 8 bool HeatExchangerFluidToFluid_Impl::setHeatTransferMeteringEndUseType(const std::string& heatTransferMeteringEndUseType) {
277 8 bool result = setString(OS_HeatExchanger_FluidToFluidFields::HeatTransferMeteringEndUseType, heatTransferMeteringEndUseType);
278 8 return result;
279 }
280
281 ✗ void HeatExchangerFluidToFluid_Impl::resetHeatTransferMeteringEndUseType() {
282 ✗ bool result = setString(OS_HeatExchanger_FluidToFluidFields::HeatTransferMeteringEndUseType, "");
283 ✗ OS_ASSERT(result);
284 ✗ }
285
286 ✗ bool HeatExchangerFluidToFluid_Impl::setComponentOverrideLoopSupplySideInletNode(const boost::optional<Node>& node) {
287 ✗ bool result(false);
288 ✗ if (node) {
289 ✗ result = setPointer(OS_HeatExchanger_FluidToFluidFields::ComponentOverrideLoopSupplySideInletNode, node.get().handle());
290 } else {
291 ✗ resetComponentOverrideLoopSupplySideInletNode();
292 ✗ result = true;
293 }
294 ✗ return result;
295 }
296
297 ✗ void HeatExchangerFluidToFluid_Impl::resetComponentOverrideLoopSupplySideInletNode() {
298 ✗ bool result = setString(OS_HeatExchanger_FluidToFluidFields::ComponentOverrideLoopSupplySideInletNode, "");
299 ✗ OS_ASSERT(result);
300 ✗ }
301
302 ✗ bool HeatExchangerFluidToFluid_Impl::setComponentOverrideLoopDemandSideInletNode(const boost::optional<Node>& node) {
303 ✗ bool result(false);
304 ✗ if (node) {
305 ✗ result = setPointer(OS_HeatExchanger_FluidToFluidFields::ComponentOverrideLoopDemandSideInletNode, node.get().handle());
306 } else {
307 ✗ resetComponentOverrideLoopDemandSideInletNode();
308 ✗ result = true;
309 }
310 ✗ return result;
311 }
312
313 ✗ void HeatExchangerFluidToFluid_Impl::resetComponentOverrideLoopDemandSideInletNode() {
314 ✗ bool result = setString(OS_HeatExchanger_FluidToFluidFields::ComponentOverrideLoopDemandSideInletNode, "");
315 ✗ OS_ASSERT(result);
316 ✗ }
317
318 8 bool HeatExchangerFluidToFluid_Impl::setComponentOverrideCoolingControlTemperatureMode(
319 const std::string& componentOverrideCoolingControlTemperatureMode) {
320 8 bool result = setString(OS_HeatExchanger_FluidToFluidFields::ComponentOverrideCoolingControlTemperatureMode,
321 componentOverrideCoolingControlTemperatureMode);
322 8 return result;
323 }
324
325 ✗ void HeatExchangerFluidToFluid_Impl::resetComponentOverrideCoolingControlTemperatureMode() {
326 ✗ bool result = setString(OS_HeatExchanger_FluidToFluidFields::ComponentOverrideCoolingControlTemperatureMode, "");
327 ✗ OS_ASSERT(result);
328 ✗ }
329
330 8 bool HeatExchangerFluidToFluid_Impl::setSizingFactor(double sizingFactor) {
331 8 bool result = setDouble(OS_HeatExchanger_FluidToFluidFields::SizingFactor, sizingFactor);
332 8 return result;
333 }
334
335 ✗ void HeatExchangerFluidToFluid_Impl::resetSizingFactor() {
336 ✗ bool result = setString(OS_HeatExchanger_FluidToFluidFields::SizingFactor, "");
337 ✗ OS_ASSERT(result);
338 ✗ }
339
340 8 bool HeatExchangerFluidToFluid_Impl::setOperationMinimumTemperatureLimit(boost::optional<double> operationMinimumTemperatureLimit) {
341 8 bool result(false);
342
1/2
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
8 if (operationMinimumTemperatureLimit) {
343 8 result = setDouble(OS_HeatExchanger_FluidToFluidFields::OperationMinimumTemperatureLimit, operationMinimumTemperatureLimit.get());
344 } else {
345 ✗ resetOperationMinimumTemperatureLimit();
346 ✗ result = true;
347 }
348
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
8 OS_ASSERT(result);
349 8 return result;
350 }
351
352 ✗ void HeatExchangerFluidToFluid_Impl::resetOperationMinimumTemperatureLimit() {
353 ✗ bool result = setString(OS_HeatExchanger_FluidToFluidFields::OperationMinimumTemperatureLimit, "");
354 ✗ OS_ASSERT(result);
355 ✗ }
356
357 8 bool HeatExchangerFluidToFluid_Impl::setOperationMaximumTemperatureLimit(boost::optional<double> operationMaximumTemperatureLimit) {
358 8 bool result(false);
359
1/2
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
8 if (operationMaximumTemperatureLimit) {
360 8 result = setDouble(OS_HeatExchanger_FluidToFluidFields::OperationMaximumTemperatureLimit, operationMaximumTemperatureLimit.get());
361 } else {
362 ✗ resetOperationMaximumTemperatureLimit();
363 ✗ result = true;
364 }
365
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
8 OS_ASSERT(result);
366 8 return result;
367 }
368
369 ✗ void HeatExchangerFluidToFluid_Impl::resetOperationMaximumTemperatureLimit() {
370 ✗ bool result = setString(OS_HeatExchanger_FluidToFluidFields::OperationMaximumTemperatureLimit, "");
371 ✗ OS_ASSERT(result);
372 ✗ }
373
374 54 unsigned HeatExchangerFluidToFluid_Impl::supplyInletPort() const {
375 54 return OS_HeatExchanger_FluidToFluidFields::LoopSupplySideInletNode;
376 }
377
378 53 unsigned HeatExchangerFluidToFluid_Impl::supplyOutletPort() const {
379 53 return OS_HeatExchanger_FluidToFluidFields::LoopSupplySideOutletNode;
380 }
381
382 18 unsigned HeatExchangerFluidToFluid_Impl::demandInletPort() const {
383 18 return OS_HeatExchanger_FluidToFluidFields::LoopDemandSideInletNode;
384 }
385
386 22 unsigned HeatExchangerFluidToFluid_Impl::demandOutletPort() const {
387 22 return OS_HeatExchanger_FluidToFluidFields::LoopDemandSideOutletNode;
388 }
389
390 ✗ boost::optional<double> HeatExchangerFluidToFluid_Impl::autosizedLoopDemandSideDesignFlowRate() const {
391 ✗ return getAutosizedValue("Loop Demand Side Design Fluid Flow Rate", "m3/s");
392 }
393
394 ✗ boost::optional<double> HeatExchangerFluidToFluid_Impl::autosizedLoopSupplySideDesignFlowRate() const {
395 ✗ return getAutosizedValue("Loop Supply Side Design Fluid Flow Rate", "m3/s");
396 }
397
398 ✗ boost::optional<double> HeatExchangerFluidToFluid_Impl::autosizedHeatExchangerUFactorTimesAreaValue() const {
399 ✗ return getAutosizedValue("Heat Exchanger U-Factor Times Area Value", "W/C");
400 }
401
402 ✗ void HeatExchangerFluidToFluid_Impl::autosize() {
403 ✗ autosizeLoopDemandSideDesignFlowRate();
404 ✗ autosizeLoopSupplySideDesignFlowRate();
405 ✗ autosizeHeatExchangerUFactorTimesAreaValue();
406 ✗ }
407
408 ✗ void HeatExchangerFluidToFluid_Impl::applySizingValues() {
409 ✗ boost::optional<double> val;
410 ✗ val = autosizedLoopDemandSideDesignFlowRate();
411 ✗ if (val) {
412 ✗ setLoopDemandSideDesignFlowRate(val.get());
413 }
414
415 ✗ val = autosizedLoopSupplySideDesignFlowRate();
416 ✗ if (val) {
417 ✗ setLoopSupplySideDesignFlowRate(val.get());
418 }
419
420 ✗ val = autosizedHeatExchangerUFactorTimesAreaValue();
421 ✗ if (val) {
422 ✗ setHeatExchangerUFactorTimesAreaValue(val.get());
423 }
424 ✗ }
425
426 20 ComponentType HeatExchangerFluidToFluid_Impl::componentType() const {
427
1/1
✓ Branch 1 taken 20 times.
20 const std::string controlType = this->controlType();
428
429
16/26
✓ Branch 1 taken 20 times.
✓ Branch 4 taken 20 times.
✓ Branch 6 taken 16 times.
✓ Branch 7 taken 4 times.
✓ Branch 9 taken 16 times.
✓ Branch 12 taken 16 times.
✓ Branch 14 taken 1 time.
✓ Branch 15 taken 15 times.
✓ Branch 16 taken 16 times.
✓ Branch 17 taken 4 times.
✓ Branch 19 taken 16 times.
✓ Branch 20 taken 4 times.
✓ Branch 21 taken 20 times.
✗ Branch 22 not taken.
✓ Branch 24 taken 20 times.
✗ Branch 25 not taken.
✓ Branch 26 taken 5 times.
✓ Branch 27 taken 15 times.
✗ Branch 28 not taken.
✗ Branch 29 not taken.
✗ Branch 31 not taken.
✗ Branch 32 not taken.
✗ Branch 33 not taken.
✗ Branch 34 not taken.
✗ Branch 36 not taken.
✗ Branch 37 not taken.
92 if (openstudio::istringEqual(controlType, "HeatingSetpointModulated") || openstudio::istringEqual(controlType, "HeatingSetpointOnOff")) {
430
1/1
✓ Branch 1 taken 5 times.
5 return ComponentType::Heating;
431
432
11/21
✓ Branch 1 taken 15 times.
✓ Branch 4 taken 14 times.
✓ Branch 7 taken 14 times.
✓ Branch 9 taken 13 times.
✓ Branch 10 taken 1 time.
✓ Branch 12 taken 14 times.
✓ Branch 13 taken 1 time.
✓ Branch 14 taken 15 times.
✗ Branch 15 not taken.
✓ Branch 17 taken 15 times.
✗ Branch 18 not taken.
✓ Branch 19 taken 4 times.
✓ Branch 20 taken 11 times.
✗ Branch 21 not taken.
✗ Branch 22 not taken.
✗ Branch 24 not taken.
✗ Branch 25 not taken.
✗ Branch 26 not taken.
✗ Branch 27 not taken.
✗ Branch 29 not taken.
✗ Branch 30 not taken.
73 } else if (openstudio::istringEqual(controlType, "CoolingSetpointModulated") || openstudio::istringEqual(controlType, "CoolingSetpointOnOff")
433
8/12
✓ Branch 1 taken 13 times.
✓ Branch 4 taken 13 times.
✓ Branch 6 taken 12 times.
✓ Branch 7 taken 1 time.
✓ Branch 9 taken 13 times.
✓ Branch 10 taken 2 times.
✓ Branch 11 taken 14 times.
✓ Branch 12 taken 1 time.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
✗ Branch 16 not taken.
✗ Branch 17 not taken.
41 || openstudio::istringEqual(controlType, "CoolingDifferentialOnOff")
434
13/17
✓ Branch 1 taken 15 times.
✓ Branch 3 taken 14 times.
✓ Branch 4 taken 1 time.
✓ Branch 6 taken 12 times.
✓ Branch 9 taken 12 times.
✓ Branch 11 taken 1 time.
✓ Branch 12 taken 11 times.
✓ Branch 13 taken 12 times.
✓ Branch 14 taken 3 times.
✓ Branch 16 taken 12 times.
✓ Branch 17 taken 3 times.
✓ Branch 18 taken 13 times.
✓ Branch 19 taken 2 times.
✗ Branch 20 not taken.
✗ Branch 21 not taken.
✗ Branch 23 not taken.
✗ Branch 24 not taken.
56 || openstudio::istringEqual(controlType, "CoolingSetpointOnOffWithComponentOverride")) {
435
1/1
✓ Branch 1 taken 4 times.
4 return ComponentType::Cooling;
436
437
4/9
✓ Branch 1 taken 11 times.
✓ Branch 4 taken 11 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2 times.
✓ Branch 7 taken 9 times.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
33 } else if (openstudio::istringEqual(controlType, "DualDeadbandSetpointModulated")
438
12/17
✓ Branch 1 taken 11 times.
✓ Branch 3 taken 10 times.
✓ Branch 4 taken 1 time.
✓ Branch 6 taken 10 times.
✓ Branch 9 taken 10 times.
✓ Branch 11 taken 1 time.
✓ Branch 12 taken 9 times.
✓ Branch 13 taken 10 times.
✓ Branch 14 taken 1 time.
✓ Branch 16 taken 10 times.
✓ Branch 17 taken 1 time.
✓ Branch 18 taken 11 times.
✗ Branch 19 not taken.
✗ Branch 20 not taken.
✗ Branch 21 not taken.
✗ Branch 23 not taken.
✗ Branch 24 not taken.
42 || openstudio::istringEqual(controlType, "DualDeadbandSetpointOnOff")) {
439
1/1
✓ Branch 1 taken 2 times.
2 return ComponentType::Both;
440
4/4
✓ Branch 1 taken 9 times.
✓ Branch 4 taken 9 times.
✓ Branch 7 taken 7 times.
✓ Branch 8 taken 2 times.
18 } else if (openstudio::istringEqual(controlType, "UncontrolledOn")) {
441 // Here we go check what's on the supply side of the secondary plantLoop if there is one
442 // It's going to crash if there isn't a secondary plant Loop anyways
443 // get the Source loop
444
3/3
✓ Branch 1 taken 7 times.
✓ Branch 3 taken 6 times.
✓ Branch 4 taken 1 time.
14 if (boost::optional<PlantLoop> p_ = secondaryPlantLoop()) {
445
2/2
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
6 return p_->componentType();
446 } else {
447 // It isn't connected to a source side (beats the point of the HX)
448
1/1
✓ Branch 1 taken 1 time.
1 return ComponentType::None;
449 7 } // End if has source loop
450
451 } else {
452 // For OperationSchemeModulated and OperationSchemeOnOff
453
9/9
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
✓ Branch 7 taken 2 times.
✓ Branch 10 taken 2 times.
✓ Branch 13 taken 2 times.
✓ Branch 16 taken 2 times.
✓ Branch 20 taken 2 times.
✓ Branch 23 taken 2 times.
✓ Branch 26 taken 2 times.
2 LOG(Debug, briefDescription() << "' doesn't have a controlType ('" << controlType
454 << "') that allows us to specify whether "
455 "it's heating or cooling, setting to ComponentType::BOTH");
456
1/1
✓ Branch 1 taken 2 times.
2 return ComponentType::Both;
457 }
458 20 }
459
460 ✗ std::vector<FuelType> HeatExchangerFluidToFluid_Impl::coolingFuelTypes() const {
461 ✗ const std::string controlType = this->controlType();
462 ✗ if (openstudio::istringEqual(controlType, "HeatingSetpointModulated") || openstudio::istringEqual(controlType, "HeatingSetpointOnOff")) {
463 ✗ return {};
464 }
465 ✗ if (auto p_ = secondaryPlantLoop()) {
466 ✗ return p_->coolingFuelTypes();
467 ✗ }
468
469 ✗ return {};
470 ✗ }
471
472 ✗ std::vector<FuelType> HeatExchangerFluidToFluid_Impl::heatingFuelTypes() const {
473 ✗ const std::string controlType = this->controlType();
474 ✗ if (openstudio::istringEqual(controlType, "CoolingSetpointModulated") || openstudio::istringEqual(controlType, "CoolingSetpointOnOff")
475 ✗ || openstudio::istringEqual(controlType, "CoolingDifferentialOnOff")
476 ✗ || openstudio::istringEqual(controlType, "CoolingSetpointOnOffWithComponentOverride")) {
477 ✗ return {};
478 }
479 ✗ if (auto p_ = secondaryPlantLoop()) {
480 ✗ return p_->heatingFuelTypes();
481 ✗ }
482
483 ✗ return {};
484 ✗ }
485
486 ✗ std::vector<AppGFuelType> HeatExchangerFluidToFluid_Impl::appGHeatingFuelTypes() const {
487 ✗ const std::string controlType = this->controlType();
488 ✗ if (openstudio::istringEqual(controlType, "CoolingSetpointModulated") || openstudio::istringEqual(controlType, "CoolingSetpointOnOff")
489 ✗ || openstudio::istringEqual(controlType, "CoolingDifferentialOnOff")
490 ✗ || openstudio::istringEqual(controlType, "CoolingSetpointOnOffWithComponentOverride")) {
491 ✗ return {};
492 }
493 ✗ if (auto p_ = secondaryPlantLoop()) {
494 ✗ return p_->appGHeatingFuelTypes();
495 ✗ }
496
497 ✗ return {};
498 ✗ }
499
500 } // namespace detail
501
502 8 HeatExchangerFluidToFluid::HeatExchangerFluidToFluid(const Model& model)
503 8 : WaterToWaterComponent(HeatExchangerFluidToFluid::iddObjectType(), model) {
504
1/3
✗ Branch 2 not taken.
✓ Branch 3 taken 8 times.
✗ Branch 5 not taken.
8 OS_ASSERT(getImpl<detail::HeatExchangerFluidToFluid_Impl>());
505
506
1/1
✓ Branch 1 taken 8 times.
8 autosizeLoopDemandSideDesignFlowRate();
507
1/1
✓ Branch 1 taken 8 times.
8 autosizeLoopSupplySideDesignFlowRate();
508
2/2
✓ Branch 1 taken 8 times.
✓ Branch 4 taken 8 times.
8 setHeatExchangeModelType("Ideal");
509
1/1
✓ Branch 1 taken 8 times.
8 autosizeHeatExchangerUFactorTimesAreaValue();
510
2/2
✓ Branch 1 taken 8 times.
✓ Branch 4 taken 8 times.
8 setControlType("UncontrolledOn");
511
1/1
✓ Branch 1 taken 8 times.
8 setMinimumTemperatureDifferencetoActivateHeatExchanger(0.01);
512
2/2
✓ Branch 1 taken 8 times.
✓ Branch 4 taken 8 times.
16 setHeatTransferMeteringEndUseType("LoopToLoop");
513
2/2
✓ Branch 1 taken 8 times.
✓ Branch 4 taken 8 times.
8 setComponentOverrideCoolingControlTemperatureMode("Loop");
514
1/1
✓ Branch 1 taken 8 times.
8 setSizingFactor(1.0);
515
1/1
✓ Branch 1 taken 8 times.
8 setOperationMinimumTemperatureLimit(0.0);
516
1/1
✓ Branch 1 taken 8 times.
8 setOperationMaximumTemperatureLimit(100.0);
517 8 }
518
519 7614 IddObjectType HeatExchangerFluidToFluid::iddObjectType() {
520
1/1
✓ Branch 1 taken 7614 times.
7614 return {IddObjectType::OS_HeatExchanger_FluidToFluid};
521 }
522
523 ✗ std::vector<std::string> HeatExchangerFluidToFluid::heatExchangeModelTypeValues() {
524 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_HeatExchanger_FluidToFluidFields::HeatExchangeModelType);
525 }
526
527 ✗ std::vector<std::string> HeatExchangerFluidToFluid::controlTypeValues() {
528 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_HeatExchanger_FluidToFluidFields::ControlType);
529 }
530
531 ✗ std::vector<std::string> HeatExchangerFluidToFluid::heatTransferMeteringEndUseTypeValues() {
532 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(),
533 ✗ OS_HeatExchanger_FluidToFluidFields::HeatTransferMeteringEndUseType);
534 }
535
536 ✗ std::vector<std::string> HeatExchangerFluidToFluid::componentOverrideCoolingControlTemperatureModeValues() {
537 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(),
538 ✗ OS_HeatExchanger_FluidToFluidFields::ComponentOverrideCoolingControlTemperatureMode);
539 }
540
541 3 boost::optional<Schedule> HeatExchangerFluidToFluid::availabilitySchedule() const {
542
1/1
✓ Branch 3 taken 3 times.
3 return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->availabilitySchedule();
543 }
544
545 ✗ boost::optional<double> HeatExchangerFluidToFluid::loopDemandSideDesignFlowRate() const {
546 ✗ return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->loopDemandSideDesignFlowRate();
547 }
548
549 3 bool HeatExchangerFluidToFluid::isLoopDemandSideDesignFlowRateAutosized() const {
550
1/1
✓ Branch 3 taken 3 times.
3 return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->isLoopDemandSideDesignFlowRateAutosized();
551 }
552
553 ✗ boost::optional<double> HeatExchangerFluidToFluid::loopSupplySideDesignFlowRate() const {
554 ✗ return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->loopSupplySideDesignFlowRate();
555 }
556
557 3 bool HeatExchangerFluidToFluid::isLoopSupplySideDesignFlowRateAutosized() const {
558
1/1
✓ Branch 3 taken 3 times.
3 return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->isLoopSupplySideDesignFlowRateAutosized();
559 }
560
561 3 std::string HeatExchangerFluidToFluid::heatExchangeModelType() const {
562
1/1
✓ Branch 3 taken 3 times.
3 return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->heatExchangeModelType();
563 }
564
565 ✗ bool HeatExchangerFluidToFluid::isHeatExchangeModelTypeDefaulted() const {
566 ✗ return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->isHeatExchangeModelTypeDefaulted();
567 }
568
569 ✗ boost::optional<double> HeatExchangerFluidToFluid::heatExchangerUFactorTimesAreaValue() const {
570 ✗ return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->heatExchangerUFactorTimesAreaValue();
571 }
572
573 3 bool HeatExchangerFluidToFluid::isHeatExchangerUFactorTimesAreaValueAutosized() const {
574
1/1
✓ Branch 3 taken 3 times.
3 return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->isHeatExchangerUFactorTimesAreaValueAutosized();
575 }
576
577 3 std::string HeatExchangerFluidToFluid::controlType() const {
578
1/1
✓ Branch 3 taken 3 times.
3 return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->controlType();
579 }
580
581 ✗ bool HeatExchangerFluidToFluid::isControlTypeDefaulted() const {
582 ✗ return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->isControlTypeDefaulted();
583 }
584
585 3 double HeatExchangerFluidToFluid::minimumTemperatureDifferencetoActivateHeatExchanger() const {
586
1/1
✓ Branch 3 taken 3 times.
3 return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->minimumTemperatureDifferencetoActivateHeatExchanger();
587 }
588
589 ✗ bool HeatExchangerFluidToFluid::isMinimumTemperatureDifferencetoActivateHeatExchangerDefaulted() const {
590 ✗ return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->isMinimumTemperatureDifferencetoActivateHeatExchangerDefaulted();
591 }
592
593 3 std::string HeatExchangerFluidToFluid::heatTransferMeteringEndUseType() const {
594
1/1
✓ Branch 3 taken 3 times.
3 return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->heatTransferMeteringEndUseType();
595 }
596
597 ✗ bool HeatExchangerFluidToFluid::isHeatTransferMeteringEndUseTypeDefaulted() const {
598 ✗ return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->isHeatTransferMeteringEndUseTypeDefaulted();
599 }
600
601 3 boost::optional<Node> HeatExchangerFluidToFluid::componentOverrideLoopSupplySideInletNode() const {
602
1/1
✓ Branch 3 taken 3 times.
3 return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->componentOverrideLoopSupplySideInletNode();
603 }
604
605 3 boost::optional<Node> HeatExchangerFluidToFluid::componentOverrideLoopDemandSideInletNode() const {
606
1/1
✓ Branch 3 taken 3 times.
3 return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->componentOverrideLoopDemandSideInletNode();
607 }
608
609 3 std::string HeatExchangerFluidToFluid::componentOverrideCoolingControlTemperatureMode() const {
610
1/1
✓ Branch 3 taken 3 times.
3 return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->componentOverrideCoolingControlTemperatureMode();
611 }
612
613 ✗ bool HeatExchangerFluidToFluid::isComponentOverrideCoolingControlTemperatureModeDefaulted() const {
614 ✗ return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->isComponentOverrideCoolingControlTemperatureModeDefaulted();
615 }
616
617 3 double HeatExchangerFluidToFluid::sizingFactor() const {
618
1/1
✓ Branch 3 taken 3 times.
3 return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->sizingFactor();
619 }
620
621 ✗ bool HeatExchangerFluidToFluid::isSizingFactorDefaulted() const {
622 ✗ return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->isSizingFactorDefaulted();
623 }
624
625 3 boost::optional<double> HeatExchangerFluidToFluid::operationMinimumTemperatureLimit() const {
626
1/1
✓ Branch 3 taken 3 times.
3 return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->operationMinimumTemperatureLimit();
627 }
628
629 3 boost::optional<double> HeatExchangerFluidToFluid::operationMaximumTemperatureLimit() const {
630
1/1
✓ Branch 3 taken 3 times.
3 return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->operationMaximumTemperatureLimit();
631 }
632
633 ✗ bool HeatExchangerFluidToFluid::setAvailabilitySchedule(Schedule& schedule) {
634 ✗ return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->setAvailabilitySchedule(schedule);
635 }
636
637 ✗ void HeatExchangerFluidToFluid::resetAvailabilitySchedule() {
638 ✗ getImpl<detail::HeatExchangerFluidToFluid_Impl>()->resetAvailabilitySchedule();
639 ✗ }
640
641 ✗ bool HeatExchangerFluidToFluid::setLoopDemandSideDesignFlowRate(double loopDemandSideDesignFlowRate) {
642 ✗ return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->setLoopDemandSideDesignFlowRate(loopDemandSideDesignFlowRate);
643 }
644
645 8 void HeatExchangerFluidToFluid::autosizeLoopDemandSideDesignFlowRate() {
646
1/1
✓ Branch 3 taken 8 times.
8 getImpl<detail::HeatExchangerFluidToFluid_Impl>()->autosizeLoopDemandSideDesignFlowRate();
647 8 }
648
649 ✗ bool HeatExchangerFluidToFluid::setLoopSupplySideDesignFlowRate(double loopSupplySideDesignFlowRate) {
650 ✗ return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->setLoopSupplySideDesignFlowRate(loopSupplySideDesignFlowRate);
651 }
652
653 8 void HeatExchangerFluidToFluid::autosizeLoopSupplySideDesignFlowRate() {
654
1/1
✓ Branch 3 taken 8 times.
8 getImpl<detail::HeatExchangerFluidToFluid_Impl>()->autosizeLoopSupplySideDesignFlowRate();
655 8 }
656
657 8 bool HeatExchangerFluidToFluid::setHeatExchangeModelType(const std::string& heatExchangeModelType) {
658
1/1
✓ Branch 3 taken 8 times.
8 return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->setHeatExchangeModelType(heatExchangeModelType);
659 }
660
661 ✗ void HeatExchangerFluidToFluid::resetHeatExchangeModelType() {
662 ✗ getImpl<detail::HeatExchangerFluidToFluid_Impl>()->resetHeatExchangeModelType();
663 ✗ }
664
665 ✗ bool HeatExchangerFluidToFluid::setHeatExchangerUFactorTimesAreaValue(double heatExchangerUFactorTimesAreaValue) {
666 ✗ return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->setHeatExchangerUFactorTimesAreaValue(heatExchangerUFactorTimesAreaValue);
667 }
668
669 8 void HeatExchangerFluidToFluid::autosizeHeatExchangerUFactorTimesAreaValue() {
670
1/1
✓ Branch 3 taken 8 times.
8 getImpl<detail::HeatExchangerFluidToFluid_Impl>()->autosizeHeatExchangerUFactorTimesAreaValue();
671 8 }
672
673 22 bool HeatExchangerFluidToFluid::setControlType(const std::string& controlType) {
674
1/1
✓ Branch 3 taken 22 times.
22 return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->setControlType(controlType);
675 }
676
677 ✗ void HeatExchangerFluidToFluid::resetControlType() {
678 ✗ getImpl<detail::HeatExchangerFluidToFluid_Impl>()->resetControlType();
679 ✗ }
680
681 8 bool HeatExchangerFluidToFluid::setMinimumTemperatureDifferencetoActivateHeatExchanger(double minimumTemperatureDifferencetoActivateHeatExchanger) {
682
1/1
✓ Branch 3 taken 8 times.
16 return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->setMinimumTemperatureDifferencetoActivateHeatExchanger(
683 16 minimumTemperatureDifferencetoActivateHeatExchanger);
684 }
685
686 ✗ void HeatExchangerFluidToFluid::resetMinimumTemperatureDifferencetoActivateHeatExchanger() {
687 ✗ getImpl<detail::HeatExchangerFluidToFluid_Impl>()->resetMinimumTemperatureDifferencetoActivateHeatExchanger();
688 ✗ }
689
690 8 bool HeatExchangerFluidToFluid::setHeatTransferMeteringEndUseType(const std::string& heatTransferMeteringEndUseType) {
691
1/1
✓ Branch 3 taken 8 times.
8 return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->setHeatTransferMeteringEndUseType(heatTransferMeteringEndUseType);
692 }
693
694 ✗ void HeatExchangerFluidToFluid::resetHeatTransferMeteringEndUseType() {
695 ✗ getImpl<detail::HeatExchangerFluidToFluid_Impl>()->resetHeatTransferMeteringEndUseType();
696 ✗ }
697
698 ✗ bool HeatExchangerFluidToFluid::setComponentOverrideLoopSupplySideInletNode(const Node& node) {
699 ✗ return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->setComponentOverrideLoopSupplySideInletNode(node);
700 }
701
702 ✗ void HeatExchangerFluidToFluid::resetComponentOverrideLoopSupplySideInletNode() {
703 ✗ getImpl<detail::HeatExchangerFluidToFluid_Impl>()->resetComponentOverrideLoopSupplySideInletNode();
704 ✗ }
705
706 ✗ bool HeatExchangerFluidToFluid::setComponentOverrideLoopDemandSideInletNode(const Node& node) {
707 ✗ return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->setComponentOverrideLoopDemandSideInletNode(node);
708 }
709
710 ✗ void HeatExchangerFluidToFluid::resetComponentOverrideLoopDemandSideInletNode() {
711 ✗ getImpl<detail::HeatExchangerFluidToFluid_Impl>()->resetComponentOverrideLoopDemandSideInletNode();
712 ✗ }
713
714 bool
715 8 HeatExchangerFluidToFluid::setComponentOverrideCoolingControlTemperatureMode(const std::string& componentOverrideCoolingControlTemperatureMode) {
716
1/1
✓ Branch 3 taken 8 times.
16 return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->setComponentOverrideCoolingControlTemperatureMode(
717 16 componentOverrideCoolingControlTemperatureMode);
718 }
719
720 ✗ void HeatExchangerFluidToFluid::resetComponentOverrideCoolingControlTemperatureMode() {
721 ✗ getImpl<detail::HeatExchangerFluidToFluid_Impl>()->resetComponentOverrideCoolingControlTemperatureMode();
722 ✗ }
723
724 8 bool HeatExchangerFluidToFluid::setSizingFactor(double sizingFactor) {
725
1/1
✓ Branch 3 taken 8 times.
8 return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->setSizingFactor(sizingFactor);
726 }
727
728 ✗ void HeatExchangerFluidToFluid::resetSizingFactor() {
729 ✗ getImpl<detail::HeatExchangerFluidToFluid_Impl>()->resetSizingFactor();
730 ✗ }
731
732 8 bool HeatExchangerFluidToFluid::setOperationMinimumTemperatureLimit(double operationMinimumTemperatureLimit) {
733
2/2
✓ Branch 3 taken 8 times.
✓ Branch 6 taken 8 times.
8 return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->setOperationMinimumTemperatureLimit(operationMinimumTemperatureLimit);
734 }
735
736 ✗ void HeatExchangerFluidToFluid::resetOperationMinimumTemperatureLimit() {
737 ✗ getImpl<detail::HeatExchangerFluidToFluid_Impl>()->resetOperationMinimumTemperatureLimit();
738 ✗ }
739
740 8 bool HeatExchangerFluidToFluid::setOperationMaximumTemperatureLimit(double operationMaximumTemperatureLimit) {
741
2/2
✓ Branch 3 taken 8 times.
✓ Branch 6 taken 8 times.
8 return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->setOperationMaximumTemperatureLimit(operationMaximumTemperatureLimit);
742 }
743
744 ✗ void HeatExchangerFluidToFluid::resetOperationMaximumTemperatureLimit() {
745 ✗ getImpl<detail::HeatExchangerFluidToFluid_Impl>()->resetOperationMaximumTemperatureLimit();
746 ✗ }
747
748 /// @cond
749 3 HeatExchangerFluidToFluid::HeatExchangerFluidToFluid(std::shared_ptr<detail::HeatExchangerFluidToFluid_Impl> impl)
750
1/1
✓ Branch 3 taken 3 times.
3 : WaterToWaterComponent(std::move(impl)) {}
751 /// @endcond
752
753 ✗ boost::optional<double> HeatExchangerFluidToFluid::autosizedLoopDemandSideDesignFlowRate() const {
754 ✗ return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->autosizedLoopDemandSideDesignFlowRate();
755 }
756
757 ✗ boost::optional<double> HeatExchangerFluidToFluid::autosizedLoopSupplySideDesignFlowRate() const {
758 ✗ return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->autosizedLoopSupplySideDesignFlowRate();
759 }
760
761 ✗ boost::optional<double> HeatExchangerFluidToFluid::autosizedHeatExchangerUFactorTimesAreaValue() const {
762 ✗ return getImpl<detail::HeatExchangerFluidToFluid_Impl>()->autosizedHeatExchangerUFactorTimesAreaValue();
763 }
764
765 } // namespace model
766 } // namespace openstudio
767