GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 18.8% 45 / 0 / 239
Functions: 19.1% 13 / 0 / 68
Branches: 11.9% 21 / 0 / 177

src/model/ZoneHVACEnergyRecoveryVentilatorController.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 "ZoneHVACEnergyRecoveryVentilatorController.hpp"
7 #include "ZoneHVACEnergyRecoveryVentilatorController_Impl.hpp"
8
9 #include "Curve.hpp"
10 #include "Curve_Impl.hpp"
11 #include "Schedule.hpp"
12 #include "Schedule_Impl.hpp"
13 #include "ScheduleTypeLimits.hpp"
14 #include "ScheduleTypeRegistry.hpp"
15
16 #include <utilities/idd/IddFactory.hxx>
17 #include <utilities/idd/OS_ZoneHVAC_EnergyRecoveryVentilator_Controller_FieldEnums.hxx>
18
19 #include "../utilities/core/Assert.hpp"
20
21 namespace openstudio {
22 namespace model {
23
24 namespace detail {
25
26 1 ZoneHVACEnergyRecoveryVentilatorController_Impl::ZoneHVACEnergyRecoveryVentilatorController_Impl(const IdfObject& idfObject, Model_Impl* model,
27 1 bool keepHandle)
28 1 : ParentObject_Impl(idfObject, model, keepHandle) {
29
4/6
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✗ Branch 10 not taken.
✓ Branch 11 taken 1 time.
✗ Branch 13 not taken.
1 OS_ASSERT(idfObject.iddObject().type() == ZoneHVACEnergyRecoveryVentilatorController::iddObjectType());
30 1 }
31
32 ✗ ZoneHVACEnergyRecoveryVentilatorController_Impl::ZoneHVACEnergyRecoveryVentilatorController_Impl(
33 ✗ const openstudio::detail::WorkspaceObject_Impl& other, Model_Impl* model, bool keepHandle)
34 ✗ : ParentObject_Impl(other, model, keepHandle) {
35 ✗ OS_ASSERT(other.iddObject().type() == ZoneHVACEnergyRecoveryVentilatorController::iddObjectType());
36 ✗ }
37
38 ✗ ZoneHVACEnergyRecoveryVentilatorController_Impl::ZoneHVACEnergyRecoveryVentilatorController_Impl(
39 ✗ const ZoneHVACEnergyRecoveryVentilatorController_Impl& other, Model_Impl* model, bool keepHandle)
40 ✗ : ParentObject_Impl(other, model, keepHandle) {}
41
42 ✗ const std::vector<std::string>& ZoneHVACEnergyRecoveryVentilatorController_Impl::outputVariableNames() const {
43 ✗ static const std::vector<std::string> result;
44 // Not appropriate
45 ✗ return result;
46 }
47
48 ✗ IddObjectType ZoneHVACEnergyRecoveryVentilatorController_Impl::iddObjectType() const {
49 ✗ return ZoneHVACEnergyRecoveryVentilatorController::iddObjectType();
50 }
51
52 ✗ std::vector<ScheduleTypeKey> ZoneHVACEnergyRecoveryVentilatorController_Impl::getScheduleTypeKeys(const Schedule& schedule) const {
53 ✗ std::vector<ScheduleTypeKey> result;
54 ✗ UnsignedVector fieldIndices = getSourceIndices(schedule.handle());
55 ✗ UnsignedVector::const_iterator b(fieldIndices.begin());
56 ✗ UnsignedVector::const_iterator e(fieldIndices.end());
57 ✗ if (std::find(b, e, OS_ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::TimeofDayEconomizerFlowControlScheduleName) != e) {
58 ✗ result.push_back(ScheduleTypeKey("ZoneHVACEnergyRecoveryVentilatorController", "Time of Day Economizer Flow Control"));
59 }
60 ✗ return result;
61 ✗ }
62
63 ✗ std::vector<ModelObject> ZoneHVACEnergyRecoveryVentilatorController_Impl::children() const {
64 ✗ std::vector<ModelObject> result;
65 ✗ if (auto const intermediate = electronicEnthalpyLimitCurve()) {
66 ✗ result.push_back(intermediate.get());
67 ✗ }
68 ✗ return result;
69 ✗ }
70
71 ✗ boost::optional<double> ZoneHVACEnergyRecoveryVentilatorController_Impl::temperatureHighLimit() const {
72 ✗ return getDouble(OS_ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::TemperatureHighLimit, true);
73 }
74
75 ✗ boost::optional<double> ZoneHVACEnergyRecoveryVentilatorController_Impl::temperatureLowLimit() const {
76 ✗ return getDouble(OS_ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::TemperatureLowLimit, true);
77 }
78
79 ✗ boost::optional<double> ZoneHVACEnergyRecoveryVentilatorController_Impl::enthalpyHighLimit() const {
80 ✗ return getDouble(OS_ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::EnthalpyHighLimit, true);
81 }
82
83 ✗ boost::optional<double> ZoneHVACEnergyRecoveryVentilatorController_Impl::dewpointTemperatureLimit() const {
84 ✗ return getDouble(OS_ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::DewpointTemperatureLimit, true);
85 }
86
87 ✗ boost::optional<Curve> ZoneHVACEnergyRecoveryVentilatorController_Impl::electronicEnthalpyLimitCurve() const {
88 ✗ return getObject<ModelObject>().getModelObjectTarget<Curve>(
89 ✗ OS_ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::ElectronicEnthalpyLimitCurveName);
90 }
91
92 ✗ std::string ZoneHVACEnergyRecoveryVentilatorController_Impl::exhaustAirTemperatureLimit() const {
93 ✗ boost::optional<std::string> value = getString(OS_ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::ExhaustAirTemperatureLimit, true);
94 ✗ OS_ASSERT(value);
95 ✗ return value.get();
96 ✗ }
97
98 ✗ std::string ZoneHVACEnergyRecoveryVentilatorController_Impl::exhaustAirEnthalpyLimit() const {
99 ✗ boost::optional<std::string> value = getString(OS_ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::ExhaustAirEnthalpyLimit, true);
100 ✗ OS_ASSERT(value);
101 ✗ return value.get();
102 ✗ }
103
104 ✗ boost::optional<Schedule> ZoneHVACEnergyRecoveryVentilatorController_Impl::timeofDayEconomizerFlowControlSchedule() const {
105 ✗ return getObject<ModelObject>().getModelObjectTarget<Schedule>(
106 ✗ OS_ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::TimeofDayEconomizerFlowControlScheduleName);
107 }
108
109 ✗ bool ZoneHVACEnergyRecoveryVentilatorController_Impl::highHumidityControlFlag() const {
110 ✗ boost::optional<std::string> value = getString(OS_ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::HighHumidityControlFlag, true);
111 ✗ OS_ASSERT(value);
112 ✗ return openstudio::istringEqual(value.get(), "Yes");
113 ✗ }
114
115 ✗ double ZoneHVACEnergyRecoveryVentilatorController_Impl::highHumidityOutdoorAirFlowRatio() const {
116 ✗ boost::optional<double> value = getDouble(OS_ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::HighHumidityOutdoorAirFlowRatio, true);
117 ✗ OS_ASSERT(value);
118 ✗ return value.get();
119 }
120
121 ✗ bool ZoneHVACEnergyRecoveryVentilatorController_Impl::controlHighIndoorHumidityBasedonOutdoorHumidityRatio() const {
122 boost::optional<std::string> value =
123 ✗ getString(OS_ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::ControlHighIndoorHumidityBasedonOutdoorHumidityRatio, true);
124 ✗ OS_ASSERT(value);
125 ✗ return openstudio::istringEqual(value.get(), "Yes");
126 ✗ }
127
128 ✗ bool ZoneHVACEnergyRecoveryVentilatorController_Impl::setTemperatureHighLimit(boost::optional<double> temperatureHighLimit) {
129 ✗ bool result(false);
130 ✗ if (temperatureHighLimit) {
131 ✗ result = setDouble(OS_ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::TemperatureHighLimit, temperatureHighLimit.get());
132 } else {
133 ✗ resetTemperatureHighLimit();
134 ✗ result = true;
135 }
136 ✗ OS_ASSERT(result);
137 ✗ return result;
138 }
139
140 ✗ void ZoneHVACEnergyRecoveryVentilatorController_Impl::resetTemperatureHighLimit() {
141 ✗ bool result = setString(OS_ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::TemperatureHighLimit, "");
142 ✗ OS_ASSERT(result);
143 ✗ }
144
145 ✗ bool ZoneHVACEnergyRecoveryVentilatorController_Impl::setTemperatureLowLimit(boost::optional<double> temperatureLowLimit) {
146 ✗ bool result(false);
147 ✗ if (temperatureLowLimit) {
148 ✗ result = setDouble(OS_ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::TemperatureLowLimit, temperatureLowLimit.get());
149 } else {
150 ✗ resetTemperatureLowLimit();
151 ✗ result = true;
152 }
153 ✗ OS_ASSERT(result);
154 ✗ return result;
155 }
156
157 ✗ void ZoneHVACEnergyRecoveryVentilatorController_Impl::resetTemperatureLowLimit() {
158 ✗ bool result = setString(OS_ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::TemperatureLowLimit, "");
159 ✗ OS_ASSERT(result);
160 ✗ }
161
162 ✗ bool ZoneHVACEnergyRecoveryVentilatorController_Impl::setEnthalpyHighLimit(boost::optional<double> enthalpyHighLimit) {
163 ✗ bool result(false);
164 ✗ if (enthalpyHighLimit) {
165 ✗ result = setDouble(OS_ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::EnthalpyHighLimit, enthalpyHighLimit.get());
166 } else {
167 ✗ resetEnthalpyHighLimit();
168 ✗ result = true;
169 }
170 ✗ OS_ASSERT(result);
171 ✗ return result;
172 }
173
174 ✗ void ZoneHVACEnergyRecoveryVentilatorController_Impl::resetEnthalpyHighLimit() {
175 ✗ bool result = setString(OS_ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::EnthalpyHighLimit, "");
176 ✗ OS_ASSERT(result);
177 ✗ }
178
179 ✗ bool ZoneHVACEnergyRecoveryVentilatorController_Impl::setDewpointTemperatureLimit(boost::optional<double> dewpointTemperatureLimit) {
180 ✗ bool result(false);
181 ✗ if (dewpointTemperatureLimit) {
182 ✗ result = setDouble(OS_ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::DewpointTemperatureLimit, dewpointTemperatureLimit.get());
183 } else {
184 ✗ resetDewpointTemperatureLimit();
185 ✗ result = true;
186 }
187 ✗ OS_ASSERT(result);
188 ✗ return result;
189 }
190
191 ✗ void ZoneHVACEnergyRecoveryVentilatorController_Impl::resetDewpointTemperatureLimit() {
192 ✗ bool result = setString(OS_ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::DewpointTemperatureLimit, "");
193 ✗ OS_ASSERT(result);
194 ✗ }
195
196 ✗ bool ZoneHVACEnergyRecoveryVentilatorController_Impl::setElectronicEnthalpyLimitCurve(const boost::optional<Curve>& curve) {
197 ✗ bool result(false);
198 ✗ if (curve) {
199 ✗ result = setPointer(OS_ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::ElectronicEnthalpyLimitCurveName, curve.get().handle());
200 } else {
201 ✗ resetElectronicEnthalpyLimitCurve();
202 ✗ result = true;
203 }
204 ✗ return result;
205 }
206
207 ✗ void ZoneHVACEnergyRecoveryVentilatorController_Impl::resetElectronicEnthalpyLimitCurve() {
208 ✗ bool result = setString(OS_ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::ElectronicEnthalpyLimitCurveName, "");
209 ✗ OS_ASSERT(result);
210 ✗ }
211
212 1 bool ZoneHVACEnergyRecoveryVentilatorController_Impl::setExhaustAirTemperatureLimit(const std::string& exhaustAirTemperatureLimit) {
213 1 bool result = setString(OS_ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::ExhaustAirTemperatureLimit, exhaustAirTemperatureLimit);
214 1 return result;
215 }
216
217 1 bool ZoneHVACEnergyRecoveryVentilatorController_Impl::setExhaustAirEnthalpyLimit(const std::string& exhaustAirEnthalpyLimit) {
218 1 bool result = setString(OS_ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::ExhaustAirEnthalpyLimit, exhaustAirEnthalpyLimit);
219 1 return result;
220 }
221
222 ✗ bool ZoneHVACEnergyRecoveryVentilatorController_Impl::setTimeofDayEconomizerFlowControlSchedule(Schedule& schedule) {
223 ✗ bool result = setSchedule(OS_ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::TimeofDayEconomizerFlowControlScheduleName,
224 "ZoneHVACEnergyRecoveryVentilatorController", "Time of Day Economizer Flow Control", schedule);
225 ✗ return result;
226 }
227
228 ✗ void ZoneHVACEnergyRecoveryVentilatorController_Impl::resetTimeofDayEconomizerFlowControlSchedule() {
229 ✗ bool result = setString(OS_ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::TimeofDayEconomizerFlowControlScheduleName, "");
230 ✗ OS_ASSERT(result);
231 ✗ }
232
233 1 bool ZoneHVACEnergyRecoveryVentilatorController_Impl::setHighHumidityControlFlag(bool highHumidityControlFlag) {
234 1 return setBooleanFieldValue(OS_ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::HighHumidityControlFlag, highHumidityControlFlag);
235 ;
236 }
237
238 1 bool ZoneHVACEnergyRecoveryVentilatorController_Impl::setHighHumidityOutdoorAirFlowRatio(double highHumidityOutdoorAirFlowRatio) {
239 bool result =
240 1 setDouble(OS_ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::HighHumidityOutdoorAirFlowRatio, highHumidityOutdoorAirFlowRatio);
241 1 return result;
242 }
243
244 1 bool ZoneHVACEnergyRecoveryVentilatorController_Impl::setControlHighIndoorHumidityBasedonOutdoorHumidityRatio(
245 bool controlHighIndoorHumidityBasedonOutdoorHumidityRatio) {
246 1 return setBooleanFieldValue(OS_ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::ControlHighIndoorHumidityBasedonOutdoorHumidityRatio,
247 1 controlHighIndoorHumidityBasedonOutdoorHumidityRatio);
248 ;
249 }
250
251 } // namespace detail
252
253 1 ZoneHVACEnergyRecoveryVentilatorController::ZoneHVACEnergyRecoveryVentilatorController(const Model& model)
254 1 : ParentObject(ZoneHVACEnergyRecoveryVentilatorController::iddObjectType(), model) {
255
1/3
✗ Branch 2 not taken.
✓ Branch 3 taken 1 time.
✗ Branch 5 not taken.
1 OS_ASSERT(getImpl<detail::ZoneHVACEnergyRecoveryVentilatorController_Impl>());
256
257 1 bool ok = true;
258
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
1 ok = setExhaustAirTemperatureLimit("NoExhaustAirTemperatureLimit");
259
1/3
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
✗ Branch 3 not taken.
1 OS_ASSERT(ok);
260
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
1 ok = setExhaustAirEnthalpyLimit("NoExhaustAirEnthalpyLimit");
261
1/3
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
✗ Branch 3 not taken.
1 OS_ASSERT(ok);
262
1/1
✓ Branch 1 taken 1 time.
1 setHighHumidityControlFlag(false);
263
1/1
✓ Branch 1 taken 1 time.
1 ok = setHighHumidityOutdoorAirFlowRatio(1.0);
264
1/3
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
✗ Branch 3 not taken.
1 OS_ASSERT(ok);
265
1/1
✓ Branch 1 taken 1 time.
1 setControlHighIndoorHumidityBasedonOutdoorHumidityRatio(true);
266 1 }
267
268 7600 IddObjectType ZoneHVACEnergyRecoveryVentilatorController::iddObjectType() {
269
1/1
✓ Branch 1 taken 7600 times.
7600 return {IddObjectType::OS_ZoneHVAC_EnergyRecoveryVentilator_Controller};
270 }
271
272 ✗ std::vector<std::string> ZoneHVACEnergyRecoveryVentilatorController::exhaustAirTemperatureLimitValues() {
273 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(),
274 ✗ OS_ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::ExhaustAirTemperatureLimit);
275 }
276
277 ✗ std::vector<std::string> ZoneHVACEnergyRecoveryVentilatorController::exhaustAirEnthalpyLimitValues() {
278 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(),
279 ✗ OS_ZoneHVAC_EnergyRecoveryVentilator_ControllerFields::ExhaustAirEnthalpyLimit);
280 }
281
282 ✗ boost::optional<double> ZoneHVACEnergyRecoveryVentilatorController::temperatureHighLimit() const {
283 ✗ return getImpl<detail::ZoneHVACEnergyRecoveryVentilatorController_Impl>()->temperatureHighLimit();
284 }
285
286 ✗ boost::optional<double> ZoneHVACEnergyRecoveryVentilatorController::temperatureLowLimit() const {
287 ✗ return getImpl<detail::ZoneHVACEnergyRecoveryVentilatorController_Impl>()->temperatureLowLimit();
288 }
289
290 ✗ boost::optional<double> ZoneHVACEnergyRecoveryVentilatorController::enthalpyHighLimit() const {
291 ✗ return getImpl<detail::ZoneHVACEnergyRecoveryVentilatorController_Impl>()->enthalpyHighLimit();
292 }
293
294 ✗ boost::optional<double> ZoneHVACEnergyRecoveryVentilatorController::dewpointTemperatureLimit() const {
295 ✗ return getImpl<detail::ZoneHVACEnergyRecoveryVentilatorController_Impl>()->dewpointTemperatureLimit();
296 }
297
298 ✗ boost::optional<Curve> ZoneHVACEnergyRecoveryVentilatorController::electronicEnthalpyLimitCurve() const {
299 ✗ return getImpl<detail::ZoneHVACEnergyRecoveryVentilatorController_Impl>()->electronicEnthalpyLimitCurve();
300 }
301
302 ✗ std::string ZoneHVACEnergyRecoveryVentilatorController::exhaustAirTemperatureLimit() const {
303 ✗ return getImpl<detail::ZoneHVACEnergyRecoveryVentilatorController_Impl>()->exhaustAirTemperatureLimit();
304 }
305
306 ✗ std::string ZoneHVACEnergyRecoveryVentilatorController::exhaustAirEnthalpyLimit() const {
307 ✗ return getImpl<detail::ZoneHVACEnergyRecoveryVentilatorController_Impl>()->exhaustAirEnthalpyLimit();
308 }
309
310 ✗ boost::optional<Schedule> ZoneHVACEnergyRecoveryVentilatorController::timeofDayEconomizerFlowControlSchedule() const {
311 ✗ return getImpl<detail::ZoneHVACEnergyRecoveryVentilatorController_Impl>()->timeofDayEconomizerFlowControlSchedule();
312 }
313
314 ✗ bool ZoneHVACEnergyRecoveryVentilatorController::highHumidityControlFlag() const {
315 ✗ return getImpl<detail::ZoneHVACEnergyRecoveryVentilatorController_Impl>()->highHumidityControlFlag();
316 }
317
318 ✗ double ZoneHVACEnergyRecoveryVentilatorController::highHumidityOutdoorAirFlowRatio() const {
319 ✗ return getImpl<detail::ZoneHVACEnergyRecoveryVentilatorController_Impl>()->highHumidityOutdoorAirFlowRatio();
320 }
321
322 ✗ bool ZoneHVACEnergyRecoveryVentilatorController::controlHighIndoorHumidityBasedonOutdoorHumidityRatio() const {
323 ✗ return getImpl<detail::ZoneHVACEnergyRecoveryVentilatorController_Impl>()->controlHighIndoorHumidityBasedonOutdoorHumidityRatio();
324 }
325
326 ✗ bool ZoneHVACEnergyRecoveryVentilatorController::setTemperatureHighLimit(double temperatureHighLimit) {
327 ✗ return getImpl<detail::ZoneHVACEnergyRecoveryVentilatorController_Impl>()->setTemperatureHighLimit(temperatureHighLimit);
328 }
329
330 ✗ void ZoneHVACEnergyRecoveryVentilatorController::resetTemperatureHighLimit() {
331 ✗ getImpl<detail::ZoneHVACEnergyRecoveryVentilatorController_Impl>()->resetTemperatureHighLimit();
332 ✗ }
333
334 ✗ bool ZoneHVACEnergyRecoveryVentilatorController::setTemperatureLowLimit(double temperatureLowLimit) {
335 ✗ return getImpl<detail::ZoneHVACEnergyRecoveryVentilatorController_Impl>()->setTemperatureLowLimit(temperatureLowLimit);
336 }
337
338 ✗ void ZoneHVACEnergyRecoveryVentilatorController::resetTemperatureLowLimit() {
339 ✗ getImpl<detail::ZoneHVACEnergyRecoveryVentilatorController_Impl>()->resetTemperatureLowLimit();
340 ✗ }
341
342 ✗ bool ZoneHVACEnergyRecoveryVentilatorController::setEnthalpyHighLimit(double enthalpyHighLimit) {
343 ✗ return getImpl<detail::ZoneHVACEnergyRecoveryVentilatorController_Impl>()->setEnthalpyHighLimit(enthalpyHighLimit);
344 }
345
346 ✗ void ZoneHVACEnergyRecoveryVentilatorController::resetEnthalpyHighLimit() {
347 ✗ getImpl<detail::ZoneHVACEnergyRecoveryVentilatorController_Impl>()->resetEnthalpyHighLimit();
348 ✗ }
349
350 ✗ bool ZoneHVACEnergyRecoveryVentilatorController::setDewpointTemperatureLimit(double dewpointTemperatureLimit) {
351 ✗ return getImpl<detail::ZoneHVACEnergyRecoveryVentilatorController_Impl>()->setDewpointTemperatureLimit(dewpointTemperatureLimit);
352 }
353
354 ✗ void ZoneHVACEnergyRecoveryVentilatorController::resetDewpointTemperatureLimit() {
355 ✗ getImpl<detail::ZoneHVACEnergyRecoveryVentilatorController_Impl>()->resetDewpointTemperatureLimit();
356 ✗ }
357
358 ✗ bool ZoneHVACEnergyRecoveryVentilatorController::setElectronicEnthalpyLimitCurve(const Curve& curve) {
359 ✗ return getImpl<detail::ZoneHVACEnergyRecoveryVentilatorController_Impl>()->setElectronicEnthalpyLimitCurve(curve);
360 }
361
362 ✗ void ZoneHVACEnergyRecoveryVentilatorController::resetElectronicEnthalpyLimitCurve() {
363 ✗ getImpl<detail::ZoneHVACEnergyRecoveryVentilatorController_Impl>()->resetElectronicEnthalpyLimitCurve();
364 ✗ }
365
366 1 bool ZoneHVACEnergyRecoveryVentilatorController::setExhaustAirTemperatureLimit(const std::string& exhaustAirTemperatureLimit) {
367
1/1
✓ Branch 3 taken 1 time.
1 return getImpl<detail::ZoneHVACEnergyRecoveryVentilatorController_Impl>()->setExhaustAirTemperatureLimit(exhaustAirTemperatureLimit);
368 }
369
370 1 bool ZoneHVACEnergyRecoveryVentilatorController::setExhaustAirEnthalpyLimit(const std::string& exhaustAirEnthalpyLimit) {
371
1/1
✓ Branch 3 taken 1 time.
1 return getImpl<detail::ZoneHVACEnergyRecoveryVentilatorController_Impl>()->setExhaustAirEnthalpyLimit(exhaustAirEnthalpyLimit);
372 }
373
374 ✗ bool ZoneHVACEnergyRecoveryVentilatorController::setTimeofDayEconomizerFlowControlSchedule(Schedule& schedule) {
375 ✗ return getImpl<detail::ZoneHVACEnergyRecoveryVentilatorController_Impl>()->setTimeofDayEconomizerFlowControlSchedule(schedule);
376 }
377
378 ✗ void ZoneHVACEnergyRecoveryVentilatorController::resetTimeofDayEconomizerFlowControlSchedule() {
379 ✗ getImpl<detail::ZoneHVACEnergyRecoveryVentilatorController_Impl>()->resetTimeofDayEconomizerFlowControlSchedule();
380 ✗ }
381
382 1 bool ZoneHVACEnergyRecoveryVentilatorController::setHighHumidityControlFlag(bool highHumidityControlFlag) {
383
1/1
✓ Branch 3 taken 1 time.
1 return getImpl<detail::ZoneHVACEnergyRecoveryVentilatorController_Impl>()->setHighHumidityControlFlag(highHumidityControlFlag);
384 }
385
386 1 bool ZoneHVACEnergyRecoveryVentilatorController::setHighHumidityOutdoorAirFlowRatio(double highHumidityOutdoorAirFlowRatio) {
387
1/1
✓ Branch 3 taken 1 time.
1 return getImpl<detail::ZoneHVACEnergyRecoveryVentilatorController_Impl>()->setHighHumidityOutdoorAirFlowRatio(highHumidityOutdoorAirFlowRatio);
388 }
389
390 1 bool ZoneHVACEnergyRecoveryVentilatorController::setControlHighIndoorHumidityBasedonOutdoorHumidityRatio(
391 bool controlHighIndoorHumidityBasedonOutdoorHumidityRatio) {
392
1/1
✓ Branch 3 taken 1 time.
2 return getImpl<detail::ZoneHVACEnergyRecoveryVentilatorController_Impl>()->setControlHighIndoorHumidityBasedonOutdoorHumidityRatio(
393 2 controlHighIndoorHumidityBasedonOutdoorHumidityRatio);
394 }
395
396 /// @cond
397 ✗ ZoneHVACEnergyRecoveryVentilatorController::ZoneHVACEnergyRecoveryVentilatorController(
398 ✗ std::shared_ptr<detail::ZoneHVACEnergyRecoveryVentilatorController_Impl> impl)
399 ✗ : ParentObject(std::move(impl)) {}
400 /// @endcond
401
402 } // namespace model
403 } // namespace openstudio
404