GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 15.2% 34 / 0 / 223
Functions: 14.1% 10 / 0 / 71
Branches: 12.2% 21 / 0 / 172

src/model/AirflowNetworkOccupantVentilationControl.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 "AirflowNetworkOccupantVentilationControl.hpp"
7 #include "AirflowNetworkOccupantVentilationControl_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/IddEnums.hxx>
17 #include <utilities/idd/OS_AirflowNetworkOccupantVentilationControl_FieldEnums.hxx>
18
19 #include "../utilities/units/Unit.hpp"
20
21 #include "../utilities/core/Assert.hpp"
22
23 namespace openstudio {
24 namespace model {
25
26 namespace detail {
27
28 2 AirflowNetworkOccupantVentilationControl_Impl::AirflowNetworkOccupantVentilationControl_Impl(const IdfObject& idfObject, Model_Impl* model,
29 2 bool keepHandle)
30 2 : ModelObject_Impl(idfObject, model, keepHandle) {
31
4/6
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
✓ Branch 7 taken 2 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 2 times.
✗ Branch 13 not taken.
2 OS_ASSERT(idfObject.iddObject().type() == AirflowNetworkOccupantVentilationControl::iddObjectType());
32 2 }
33
34 ✗ AirflowNetworkOccupantVentilationControl_Impl::AirflowNetworkOccupantVentilationControl_Impl(
35 ✗ const openstudio::detail::WorkspaceObject_Impl& other, Model_Impl* model, bool keepHandle)
36 ✗ : ModelObject_Impl(other, model, keepHandle) {
37 ✗ OS_ASSERT(other.iddObject().type() == AirflowNetworkOccupantVentilationControl::iddObjectType());
38 ✗ }
39
40 ✗ AirflowNetworkOccupantVentilationControl_Impl::AirflowNetworkOccupantVentilationControl_Impl(
41 ✗ const AirflowNetworkOccupantVentilationControl_Impl& other, Model_Impl* model, bool keepHandle)
42 ✗ : ModelObject_Impl(other, model, keepHandle) {}
43
44 ✗ const std::vector<std::string>& AirflowNetworkOccupantVentilationControl_Impl::outputVariableNames() const {
45 ✗ static const std::vector<std::string> result;
46 ✗ return result;
47 }
48
49 ✗ IddObjectType AirflowNetworkOccupantVentilationControl_Impl::iddObjectType() const {
50 ✗ return AirflowNetworkOccupantVentilationControl::iddObjectType();
51 }
52
53 ✗ std::vector<ScheduleTypeKey> AirflowNetworkOccupantVentilationControl_Impl::getScheduleTypeKeys(const Schedule& schedule) const {
54 ✗ std::vector<ScheduleTypeKey> result;
55 ✗ UnsignedVector fieldIndices = getSourceIndices(schedule.handle());
56 ✗ UnsignedVector::const_iterator b(fieldIndices.begin());
57 ✗ UnsignedVector::const_iterator e(fieldIndices.end());
58 ✗ if (std::find(b, e, OS_AirflowNetworkOccupantVentilationControlFields::OpeningProbabilityScheduleName) != e) {
59 ✗ result.emplace_back("AirflowNetworkOccupantVentilationControl", "Opening Probability");
60 }
61 ✗ if (std::find(b, e, OS_AirflowNetworkOccupantVentilationControlFields::ClosingProbabilityScheduleName) != e) {
62 ✗ result.emplace_back("AirflowNetworkOccupantVentilationControl", "Closing Probability");
63 }
64 ✗ return result;
65 ✗ }
66
67 ✗ double AirflowNetworkOccupantVentilationControl_Impl::minimumOpeningTime() const {
68 ✗ boost::optional<double> value = getDouble(OS_AirflowNetworkOccupantVentilationControlFields::MinimumOpeningTime, true);
69 ✗ OS_ASSERT(value);
70 ✗ return value.get();
71 }
72
73 ✗ bool AirflowNetworkOccupantVentilationControl_Impl::isMinimumOpeningTimeDefaulted() const {
74 ✗ return isEmpty(OS_AirflowNetworkOccupantVentilationControlFields::MinimumOpeningTime);
75 }
76
77 ✗ double AirflowNetworkOccupantVentilationControl_Impl::minimumClosingTime() const {
78 ✗ boost::optional<double> value = getDouble(OS_AirflowNetworkOccupantVentilationControlFields::MinimumClosingTime, true);
79 ✗ OS_ASSERT(value);
80 ✗ return value.get();
81 }
82
83 ✗ bool AirflowNetworkOccupantVentilationControl_Impl::isMinimumClosingTimeDefaulted() const {
84 ✗ return isEmpty(OS_AirflowNetworkOccupantVentilationControlFields::MinimumClosingTime);
85 }
86
87 1 Curve AirflowNetworkOccupantVentilationControl_Impl::thermalComfortLowTemperatureCurve() const {
88
1/1
✓ Branch 1 taken 1 time.
2 boost::optional<Curve> value = getObject<ModelObject>().getModelObjectTarget<Curve>(
89
1/1
✓ Branch 1 taken 1 time.
1 OS_AirflowNetworkOccupantVentilationControlFields::ThermalComfortLowTemperatureCurveName);
90
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1 time.
1 if (!value) {
91 ✗ LOG_AND_THROW(briefDescription() << " does not have an Thermal Comfort Low Temperature Curve attached.");
92 }
93
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
2 return value.get();
94 1 }
95
96 ✗ double AirflowNetworkOccupantVentilationControl_Impl::thermalComfortTemperatureBoundaryPoint() const {
97 ✗ boost::optional<double> value = getDouble(OS_AirflowNetworkOccupantVentilationControlFields::ThermalComfortTemperatureBoundaryPoint, true);
98 ✗ OS_ASSERT(value);
99 ✗ return value.get();
100 }
101
102 ✗ bool AirflowNetworkOccupantVentilationControl_Impl::isThermalComfortTemperatureBoundaryPointDefaulted() const {
103 ✗ return isEmpty(OS_AirflowNetworkOccupantVentilationControlFields::ThermalComfortTemperatureBoundaryPoint);
104 }
105
106 1 boost::optional<Curve> AirflowNetworkOccupantVentilationControl_Impl::thermalComfortHighTemperatureCurve() const {
107
1/1
✓ Branch 1 taken 1 time.
2 return getObject<ModelObject>().getModelObjectTarget<Curve>(
108
1/1
✓ Branch 1 taken 1 time.
2 OS_AirflowNetworkOccupantVentilationControlFields::ThermalComfortHighTemperatureCurveName);
109 }
110
111 ✗ double AirflowNetworkOccupantVentilationControl_Impl::maximumPredictedPercentageofDissatisfiedThreshold() const {
112 boost::optional<double> value =
113 ✗ getDouble(OS_AirflowNetworkOccupantVentilationControlFields::MaximumPredictedPercentageofDissatisfiedThreshold, true);
114 ✗ OS_ASSERT(value);
115 ✗ return value.get();
116 }
117
118 ✗ bool AirflowNetworkOccupantVentilationControl_Impl::isMaximumPredictedPercentageofDissatisfiedThresholdDefaulted() const {
119 ✗ return isEmpty(OS_AirflowNetworkOccupantVentilationControlFields::MaximumPredictedPercentageofDissatisfiedThreshold);
120 }
121
122 ✗ bool AirflowNetworkOccupantVentilationControl_Impl::occupancyCheck() const {
123 ✗ boost::optional<std::string> value = getString(OS_AirflowNetworkOccupantVentilationControlFields::OccupancyCheck, true);
124 ✗ OS_ASSERT(value);
125 ✗ return openstudio::istringEqual(value.get(), "Yes");
126 ✗ }
127
128 ✗ bool AirflowNetworkOccupantVentilationControl_Impl::isOccupancyCheckDefaulted() const {
129 ✗ return isEmpty(OS_AirflowNetworkOccupantVentilationControlFields::OccupancyCheck);
130 }
131
132 ✗ boost::optional<Schedule> AirflowNetworkOccupantVentilationControl_Impl::openingProbabilitySchedule() const {
133 ✗ return getObject<ModelObject>().getModelObjectTarget<Schedule>(
134 ✗ OS_AirflowNetworkOccupantVentilationControlFields::OpeningProbabilityScheduleName);
135 }
136
137 ✗ boost::optional<Schedule> AirflowNetworkOccupantVentilationControl_Impl::closingProbabilitySchedule() const {
138 ✗ return getObject<ModelObject>().getModelObjectTarget<Schedule>(
139 ✗ OS_AirflowNetworkOccupantVentilationControlFields::ClosingProbabilityScheduleName);
140 }
141
142 ✗ bool AirflowNetworkOccupantVentilationControl_Impl::setMinimumOpeningTime(double minimumOpeningTime) {
143 ✗ bool result = setDouble(OS_AirflowNetworkOccupantVentilationControlFields::MinimumOpeningTime, minimumOpeningTime);
144 ✗ return result;
145 }
146
147 ✗ void AirflowNetworkOccupantVentilationControl_Impl::resetMinimumOpeningTime() {
148 ✗ bool result = setString(OS_AirflowNetworkOccupantVentilationControlFields::MinimumOpeningTime, "");
149 ✗ OS_ASSERT(result);
150 ✗ }
151
152 ✗ bool AirflowNetworkOccupantVentilationControl_Impl::setMinimumClosingTime(double minimumClosingTime) {
153 ✗ bool result = setDouble(OS_AirflowNetworkOccupantVentilationControlFields::MinimumClosingTime, minimumClosingTime);
154 ✗ return result;
155 }
156
157 ✗ void AirflowNetworkOccupantVentilationControl_Impl::resetMinimumClosingTime() {
158 ✗ bool result = setString(OS_AirflowNetworkOccupantVentilationControlFields::MinimumClosingTime, "");
159 ✗ OS_ASSERT(result);
160 ✗ }
161
162 2 bool AirflowNetworkOccupantVentilationControl_Impl::setThermalComfortLowTemperatureCurve(const Curve& curve) {
163
2/2
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
2 bool result = setPointer(OS_AirflowNetworkOccupantVentilationControlFields::ThermalComfortLowTemperatureCurveName, curve.handle());
164 2 return result;
165 }
166
167 //void AirflowNetworkOccupantVentilationControl_Impl::resetThermalComfortLowTemperatureCurve()
168 //{
169 // bool result = setString(OS_AirflowNetworkOccupantVentilationControlFields::ThermalComfortLowTemperatureCurveName, "");
170 // OS_ASSERT(result);
171 //}
172
173 ✗ bool AirflowNetworkOccupantVentilationControl_Impl::setThermalComfortTemperatureBoundaryPoint(double thermalComfortTemperatureBoundaryPoint) {
174 bool result =
175 ✗ setDouble(OS_AirflowNetworkOccupantVentilationControlFields::ThermalComfortTemperatureBoundaryPoint, thermalComfortTemperatureBoundaryPoint);
176 ✗ return result;
177 }
178
179 ✗ void AirflowNetworkOccupantVentilationControl_Impl::resetThermalComfortTemperatureBoundaryPoint() {
180 ✗ bool result = setString(OS_AirflowNetworkOccupantVentilationControlFields::ThermalComfortTemperatureBoundaryPoint, "");
181 ✗ OS_ASSERT(result);
182 ✗ }
183
184 ✗ bool AirflowNetworkOccupantVentilationControl_Impl::setThermalComfortHighTemperatureCurve(const Curve& curve) {
185 ✗ bool result = setPointer(OS_AirflowNetworkOccupantVentilationControlFields::ThermalComfortHighTemperatureCurveName, curve.handle());
186 ✗ return result;
187 }
188
189 ✗ void AirflowNetworkOccupantVentilationControl_Impl::resetThermalComfortHighTemperatureCurve() {
190 ✗ bool result = setString(OS_AirflowNetworkOccupantVentilationControlFields::ThermalComfortHighTemperatureCurveName, "");
191 ✗ OS_ASSERT(result);
192 ✗ }
193
194 ✗ bool AirflowNetworkOccupantVentilationControl_Impl::setMaximumPredictedPercentageofDissatisfiedThreshold(
195 double maximumPredictedPercentageofDissatisfiedThreshold) {
196 ✗ bool result = setDouble(OS_AirflowNetworkOccupantVentilationControlFields::MaximumPredictedPercentageofDissatisfiedThreshold,
197 maximumPredictedPercentageofDissatisfiedThreshold);
198 ✗ return result;
199 }
200
201 ✗ void AirflowNetworkOccupantVentilationControl_Impl::resetMaximumPredictedPercentageofDissatisfiedThreshold() {
202 ✗ bool result = setString(OS_AirflowNetworkOccupantVentilationControlFields::MaximumPredictedPercentageofDissatisfiedThreshold, "");
203 ✗ OS_ASSERT(result);
204 ✗ }
205
206 ✗ void AirflowNetworkOccupantVentilationControl_Impl::setOccupancyCheck(bool occupancyCheck) {
207 ✗ bool result = false;
208 ✗ if (occupancyCheck) {
209 ✗ result = setString(OS_AirflowNetworkOccupantVentilationControlFields::OccupancyCheck, "Yes");
210 } else {
211 ✗ result = setString(OS_AirflowNetworkOccupantVentilationControlFields::OccupancyCheck, "No");
212 }
213 ✗ OS_ASSERT(result);
214 ✗ }
215
216 ✗ void AirflowNetworkOccupantVentilationControl_Impl::resetOccupancyCheck() {
217 ✗ bool result = setString(OS_AirflowNetworkOccupantVentilationControlFields::OccupancyCheck, "");
218 ✗ OS_ASSERT(result);
219 ✗ }
220
221 ✗ bool AirflowNetworkOccupantVentilationControl_Impl::setOpeningProbabilitySchedule(Schedule& schedule) {
222 ✗ bool result = setSchedule(OS_AirflowNetworkOccupantVentilationControlFields::OpeningProbabilityScheduleName,
223 "AirflowNetworkOccupantVentilationControl", "Opening Probability", schedule);
224 ✗ return result;
225 }
226
227 ✗ void AirflowNetworkOccupantVentilationControl_Impl::resetOpeningProbabilitySchedule() {
228 ✗ bool result = setString(OS_AirflowNetworkOccupantVentilationControlFields::OpeningProbabilityScheduleName, "");
229 ✗ OS_ASSERT(result);
230 ✗ }
231
232 ✗ bool AirflowNetworkOccupantVentilationControl_Impl::setClosingProbabilitySchedule(Schedule& schedule) {
233 ✗ bool result = setSchedule(OS_AirflowNetworkOccupantVentilationControlFields::ClosingProbabilityScheduleName,
234 "AirflowNetworkOccupantVentilationControl", "Closing Probability", schedule);
235 ✗ return result;
236 }
237
238 ✗ void AirflowNetworkOccupantVentilationControl_Impl::resetClosingProbabilitySchedule() {
239 ✗ bool result = setString(OS_AirflowNetworkOccupantVentilationControlFields::ClosingProbabilityScheduleName, "");
240 ✗ OS_ASSERT(result);
241 ✗ }
242
243 } // namespace detail
244
245 2 AirflowNetworkOccupantVentilationControl::AirflowNetworkOccupantVentilationControl(const Model& model, const Curve& curve)
246 2 : ModelObject(AirflowNetworkOccupantVentilationControl::iddObjectType(), model) {
247
1/3
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
✗ Branch 5 not taken.
2 OS_ASSERT(getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>());
248
1/1
✓ Branch 1 taken 2 times.
2 bool ok = setThermalComfortLowTemperatureCurve(curve);
249
1/3
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
✗ Branch 3 not taken.
2 OS_ASSERT(ok);
250 2 }
251
252 8635 IddObjectType AirflowNetworkOccupantVentilationControl::iddObjectType() {
253
1/1
✓ Branch 1 taken 8635 times.
8635 return {IddObjectType::OS_AirflowNetworkOccupantVentilationControl};
254 }
255
256 ✗ double AirflowNetworkOccupantVentilationControl::minimumOpeningTime() const {
257 ✗ return getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>()->minimumOpeningTime();
258 }
259
260 ✗ bool AirflowNetworkOccupantVentilationControl::isMinimumOpeningTimeDefaulted() const {
261 ✗ return getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>()->isMinimumOpeningTimeDefaulted();
262 }
263
264 ✗ double AirflowNetworkOccupantVentilationControl::minimumClosingTime() const {
265 ✗ return getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>()->minimumClosingTime();
266 }
267
268 ✗ bool AirflowNetworkOccupantVentilationControl::isMinimumClosingTimeDefaulted() const {
269 ✗ return getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>()->isMinimumClosingTimeDefaulted();
270 }
271
272 1 Curve AirflowNetworkOccupantVentilationControl::thermalComfortLowTemperatureCurve() const {
273
1/1
✓ Branch 3 taken 1 time.
1 return getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>()->thermalComfortLowTemperatureCurve();
274 }
275
276 ✗ double AirflowNetworkOccupantVentilationControl::thermalComfortTemperatureBoundaryPoint() const {
277 ✗ return getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>()->thermalComfortTemperatureBoundaryPoint();
278 }
279
280 ✗ bool AirflowNetworkOccupantVentilationControl::isThermalComfortTemperatureBoundaryPointDefaulted() const {
281 ✗ return getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>()->isThermalComfortTemperatureBoundaryPointDefaulted();
282 }
283
284 1 boost::optional<Curve> AirflowNetworkOccupantVentilationControl::thermalComfortHighTemperatureCurve() const {
285
1/1
✓ Branch 3 taken 1 time.
1 return getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>()->thermalComfortHighTemperatureCurve();
286 }
287
288 ✗ double AirflowNetworkOccupantVentilationControl::maximumPredictedPercentageofDissatisfiedThreshold() const {
289 ✗ return getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>()->maximumPredictedPercentageofDissatisfiedThreshold();
290 }
291
292 ✗ bool AirflowNetworkOccupantVentilationControl::isMaximumPredictedPercentageofDissatisfiedThresholdDefaulted() const {
293 ✗ return getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>()->isMaximumPredictedPercentageofDissatisfiedThresholdDefaulted();
294 }
295
296 ✗ bool AirflowNetworkOccupantVentilationControl::occupancyCheck() const {
297 ✗ return getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>()->occupancyCheck();
298 }
299
300 ✗ bool AirflowNetworkOccupantVentilationControl::isOccupancyCheckDefaulted() const {
301 ✗ return getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>()->isOccupancyCheckDefaulted();
302 }
303
304 ✗ boost::optional<Schedule> AirflowNetworkOccupantVentilationControl::openingProbabilitySchedule() const {
305 ✗ return getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>()->openingProbabilitySchedule();
306 }
307
308 ✗ boost::optional<Schedule> AirflowNetworkOccupantVentilationControl::closingProbabilitySchedule() const {
309 ✗ return getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>()->closingProbabilitySchedule();
310 }
311
312 ✗ bool AirflowNetworkOccupantVentilationControl::setMinimumOpeningTime(double minimumOpeningTime) {
313 ✗ return getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>()->setMinimumOpeningTime(minimumOpeningTime);
314 }
315
316 ✗ void AirflowNetworkOccupantVentilationControl::resetMinimumOpeningTime() {
317 ✗ getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>()->resetMinimumOpeningTime();
318 ✗ }
319
320 ✗ bool AirflowNetworkOccupantVentilationControl::setMinimumClosingTime(double minimumClosingTime) {
321 ✗ return getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>()->setMinimumClosingTime(minimumClosingTime);
322 }
323
324 ✗ void AirflowNetworkOccupantVentilationControl::resetMinimumClosingTime() {
325 ✗ getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>()->resetMinimumClosingTime();
326 ✗ }
327
328 2 bool AirflowNetworkOccupantVentilationControl::setThermalComfortLowTemperatureCurve(const Curve& curve) {
329
1/1
✓ Branch 3 taken 2 times.
2 return getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>()->setThermalComfortLowTemperatureCurve(curve);
330 }
331
332 //void AirflowNetworkOccupantVentilationControl::resetThermalComfortLowTemperatureCurve() {
333 // getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>()->resetThermalComfortLowTemperatureCurve();
334 //}
335
336 ✗ bool AirflowNetworkOccupantVentilationControl::setThermalComfortTemperatureBoundaryPoint(double thermalComfortTemperatureBoundaryPoint) {
337 ✗ return getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>()->setThermalComfortTemperatureBoundaryPoint(
338 ✗ thermalComfortTemperatureBoundaryPoint);
339 }
340
341 ✗ void AirflowNetworkOccupantVentilationControl::resetThermalComfortTemperatureBoundaryPoint() {
342 ✗ getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>()->resetThermalComfortTemperatureBoundaryPoint();
343 ✗ }
344
345 ✗ bool AirflowNetworkOccupantVentilationControl::setThermalComfortHighTemperatureCurve(const Curve& curve) {
346 ✗ return getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>()->setThermalComfortHighTemperatureCurve(curve);
347 }
348
349 ✗ void AirflowNetworkOccupantVentilationControl::resetThermalComfortHighTemperatureCurve() {
350 ✗ getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>()->resetThermalComfortHighTemperatureCurve();
351 ✗ }
352
353 ✗ bool AirflowNetworkOccupantVentilationControl::setMaximumPredictedPercentageofDissatisfiedThreshold(
354 double maximumPredictedPercentageofDissatisfiedThreshold) {
355 ✗ return getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>()->setMaximumPredictedPercentageofDissatisfiedThreshold(
356 ✗ maximumPredictedPercentageofDissatisfiedThreshold);
357 }
358
359 ✗ void AirflowNetworkOccupantVentilationControl::resetMaximumPredictedPercentageofDissatisfiedThreshold() {
360 ✗ getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>()->resetMaximumPredictedPercentageofDissatisfiedThreshold();
361 ✗ }
362
363 ✗ void AirflowNetworkOccupantVentilationControl::setOccupancyCheck(bool occupancyCheck) {
364 ✗ getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>()->setOccupancyCheck(occupancyCheck);
365 ✗ }
366
367 ✗ void AirflowNetworkOccupantVentilationControl::resetOccupancyCheck() {
368 ✗ getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>()->resetOccupancyCheck();
369 ✗ }
370
371 ✗ bool AirflowNetworkOccupantVentilationControl::setOpeningProbabilitySchedule(Schedule& schedule) {
372 ✗ return getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>()->setOpeningProbabilitySchedule(schedule);
373 }
374
375 ✗ void AirflowNetworkOccupantVentilationControl::resetOpeningProbabilitySchedule() {
376 ✗ getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>()->resetOpeningProbabilitySchedule();
377 ✗ }
378
379 ✗ bool AirflowNetworkOccupantVentilationControl::setClosingProbabilitySchedule(Schedule& schedule) {
380 ✗ return getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>()->setClosingProbabilitySchedule(schedule);
381 }
382
383 ✗ void AirflowNetworkOccupantVentilationControl::resetClosingProbabilitySchedule() {
384 ✗ getImpl<detail::AirflowNetworkOccupantVentilationControl_Impl>()->resetClosingProbabilitySchedule();
385 ✗ }
386
387 /// @cond
388 4 AirflowNetworkOccupantVentilationControl::AirflowNetworkOccupantVentilationControl(
389 4 std::shared_ptr<detail::AirflowNetworkOccupantVentilationControl_Impl> impl)
390
1/1
✓ Branch 2 taken 4 times.
4 : ModelObject(impl) {}
391 /// @endcond
392
393 } // namespace model
394 } // namespace openstudio
395