GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 56.5% 135 / 0 / 239
Functions: 67.7% 42 / 0 / 62
Branches: 34.6% 90 / 0 / 260

src/model/AirTerminalDualDuctVAV.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 "AirTerminalDualDuctVAV.hpp"
7 #include "AirTerminalDualDuctVAV_Impl.hpp"
8 #include "AirLoopHVAC.hpp"
9 #include "AirLoopHVAC_Impl.hpp"
10 #include "Schedule.hpp"
11 #include "Schedule_Impl.hpp"
12 #include "Model.hpp"
13 #include "Model_Impl.hpp"
14 #include "Node.hpp"
15 #include "Node_Impl.hpp"
16 #include "DesignSpecificationOutdoorAir.hpp"
17 #include "DesignSpecificationOutdoorAir_Impl.hpp"
18 #include "ScheduleTypeLimits.hpp"
19 #include "ScheduleTypeRegistry.hpp"
20 #include <utilities/idd/OS_AirTerminal_DualDuct_VAV_FieldEnums.hxx>
21 #include <utilities/idd/IddEnums.hxx>
22 #include "../utilities/core/Assert.hpp"
23 #include "../utilities/data/DataEnums.hpp"
24
25 namespace openstudio {
26 namespace model {
27
28 namespace detail {
29
30 9 AirTerminalDualDuctVAV_Impl::AirTerminalDualDuctVAV_Impl(const IdfObject& idfObject, Model_Impl* model, bool keepHandle)
31 9 : Mixer_Impl(idfObject, model, keepHandle) {
32
4/6
✓ Branch 1 taken 9 times.
✓ Branch 4 taken 9 times.
✓ Branch 7 taken 9 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 9 times.
✗ Branch 13 not taken.
9 OS_ASSERT(idfObject.iddObject().type() == AirTerminalDualDuctVAV::iddObjectType());
33 9 }
34
35 ✗ AirTerminalDualDuctVAV_Impl::AirTerminalDualDuctVAV_Impl(const openstudio::detail::WorkspaceObject_Impl& other, Model_Impl* model,
36 ✗ bool keepHandle)
37 ✗ : Mixer_Impl(other, model, keepHandle) {
38 ✗ OS_ASSERT(other.iddObject().type() == AirTerminalDualDuctVAV::iddObjectType());
39 ✗ }
40
41 3 AirTerminalDualDuctVAV_Impl::AirTerminalDualDuctVAV_Impl(const AirTerminalDualDuctVAV_Impl& other, Model_Impl* model, bool keepHandle)
42 3 : Mixer_Impl(other, model, keepHandle) {}
43
44 ✗ const std::vector<std::string>& AirTerminalDualDuctVAV_Impl::outputVariableNames() const {
45 static const std::vector<std::string> result{// These apply to all AirTerminals
46 "Zone Air Terminal Sensible Heating Energy", "Zone Air Terminal Sensible Heating Rate",
47 ✗ "Zone Air Terminal Sensible Cooling Energy", "Zone Air Terminal Sensible Cooling Rate"};
48 ✗ return result;
49 ✗ }
50
51 13 IddObjectType AirTerminalDualDuctVAV_Impl::iddObjectType() const {
52 13 return AirTerminalDualDuctVAV::iddObjectType();
53 }
54
55 ✗ std::vector<ScheduleTypeKey> AirTerminalDualDuctVAV_Impl::getScheduleTypeKeys(const Schedule& schedule) const {
56 ✗ std::vector<ScheduleTypeKey> result;
57 ✗ UnsignedVector fieldIndices = getSourceIndices(schedule.handle());
58 ✗ UnsignedVector::const_iterator b(fieldIndices.begin());
59 ✗ UnsignedVector::const_iterator e(fieldIndices.end());
60 ✗ if (std::find(b, e, OS_AirTerminal_DualDuct_VAVFields::AvailabilitySchedule) != e) {
61 ✗ result.push_back(ScheduleTypeKey("AirTerminalDualDuctVAV", "Availability Schedule"));
62 }
63 ✗ if (std::find(b, e, OS_AirTerminal_DualDuct_VAVFields::MinimumAirFlowTurndownScheduleName) != e) {
64 ✗ result.push_back(ScheduleTypeKey("AirTerminalDualDuctVAV", "Minimum Air Flow Turndown"));
65 }
66 ✗ return result;
67 ✗ }
68
69 1 boost::optional<Schedule> AirTerminalDualDuctVAV_Impl::availabilitySchedule() const {
70
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
1 return getObject<ModelObject>().getModelObjectTarget<Schedule>(OS_AirTerminal_DualDuct_VAVFields::AvailabilitySchedule);
71 }
72
73 1 boost::optional<double> AirTerminalDualDuctVAV_Impl::maximumDamperAirFlowRate() const {
74 1 return getDouble(OS_AirTerminal_DualDuct_VAVFields::MaximumDamperAirFlowRate, true);
75 }
76
77 1 bool AirTerminalDualDuctVAV_Impl::isMaximumDamperAirFlowRateAutosized() const {
78 1 bool result = false;
79
1/1
✓ Branch 1 taken 1 time.
1 boost::optional<std::string> value = getString(OS_AirTerminal_DualDuct_VAVFields::MaximumDamperAirFlowRate, true);
80
1/2
✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.
1 if (value) {
81
3/3
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
2 result = openstudio::istringEqual(value.get(), "autosize");
82 }
83 1 return result;
84 1 }
85
86 1 double AirTerminalDualDuctVAV_Impl::zoneMinimumAirFlowFraction() const {
87
1/1
✓ Branch 1 taken 1 time.
1 boost::optional<double> value = getDouble(OS_AirTerminal_DualDuct_VAVFields::ZoneMinimumAirFlowFraction, true);
88
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 1 time.
✗ Branch 4 not taken.
1 OS_ASSERT(value);
89
1/1
✓ Branch 1 taken 1 time.
2 return value.get();
90 }
91
92 1 boost::optional<DesignSpecificationOutdoorAir> AirTerminalDualDuctVAV_Impl::designSpecificationOutdoorAirObject() const {
93
1/1
✓ Branch 1 taken 1 time.
2 return getObject<ModelObject>().getModelObjectTarget<DesignSpecificationOutdoorAir>(
94
1/1
✓ Branch 1 taken 1 time.
2 OS_AirTerminal_DualDuct_VAVFields::DesignSpecificationOutdoorAirObject);
95 }
96
97 5 boost::optional<Schedule> AirTerminalDualDuctVAV_Impl::minimumAirFlowTurndownSchedule() const {
98
1/1
✓ Branch 1 taken 5 times.
10 return this->getObject<AirTerminalDualDuctVAV>().getModelObjectTarget<Schedule>(
99
1/1
✓ Branch 1 taken 5 times.
10 OS_AirTerminal_DualDuct_VAVFields::MinimumAirFlowTurndownScheduleName);
100 }
101
102 ✗ boost::optional<ModelObject> AirTerminalDualDuctVAV_Impl::minimumAirFlowTurndownScheduleAsModelObject() const {
103 ✗ OptionalModelObject result;
104 ✗ OptionalSchedule intermediate = minimumAirFlowTurndownSchedule();
105 ✗ if (intermediate) {
106 ✗ result = *intermediate;
107 }
108 ✗ return result;
109 ✗ }
110
111 1 bool AirTerminalDualDuctVAV_Impl::setAvailabilitySchedule(Schedule& schedule) {
112
3/3
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
4 bool result = setSchedule(OS_AirTerminal_DualDuct_VAVFields::AvailabilitySchedule, "AirTerminalDualDuctVAV", "Availability Schedule", schedule);
113 1 return result;
114 }
115
116 ✗ void AirTerminalDualDuctVAV_Impl::resetAvailabilitySchedule() {
117 ✗ bool result = setString(OS_AirTerminal_DualDuct_VAVFields::AvailabilitySchedule, "");
118 ✗ OS_ASSERT(result);
119 ✗ }
120
121 1 bool AirTerminalDualDuctVAV_Impl::setMaximumDamperAirFlowRate(boost::optional<double> maximumDamperAirFlowRate) {
122 1 bool result(false);
123
1/2
✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.
1 if (maximumDamperAirFlowRate) {
124 1 result = setDouble(OS_AirTerminal_DualDuct_VAVFields::MaximumDamperAirFlowRate, maximumDamperAirFlowRate.get());
125 }
126 1 return result;
127 }
128
129 9 void AirTerminalDualDuctVAV_Impl::autosizeMaximumDamperAirFlowRate() {
130
2/2
✓ Branch 1 taken 9 times.
✓ Branch 4 taken 9 times.
18 bool result = setString(OS_AirTerminal_DualDuct_VAVFields::MaximumDamperAirFlowRate, "autosize");
131
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
9 OS_ASSERT(result);
132 9 }
133
134 10 bool AirTerminalDualDuctVAV_Impl::setZoneMinimumAirFlowFraction(double zoneMinimumAirFlowFraction) {
135 10 bool result = setDouble(OS_AirTerminal_DualDuct_VAVFields::ZoneMinimumAirFlowFraction, zoneMinimumAirFlowFraction);
136 10 return result;
137 }
138
139 1 bool AirTerminalDualDuctVAV_Impl::setDesignSpecificationOutdoorAirObject(
140 const boost::optional<DesignSpecificationOutdoorAir>& designSpecificationOutdoorAir) {
141 1 bool result(false);
142
1/2
✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.
1 if (designSpecificationOutdoorAir) {
143
3/3
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
1 result = setPointer(OS_AirTerminal_DualDuct_VAVFields::DesignSpecificationOutdoorAirObject, designSpecificationOutdoorAir.get().handle());
144 } else {
145 ✗ resetDesignSpecificationOutdoorAirObject();
146 ✗ result = true;
147 }
148 1 return result;
149 }
150
151 ✗ void AirTerminalDualDuctVAV_Impl::resetDesignSpecificationOutdoorAirObject() {
152 ✗ bool result = setString(OS_AirTerminal_DualDuct_VAVFields::DesignSpecificationOutdoorAirObject, "");
153 ✗ OS_ASSERT(result);
154 ✗ }
155
156 2 bool AirTerminalDualDuctVAV_Impl::setMinimumAirFlowTurndownSchedule(Schedule& schedule) {
157
3/3
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
✓ Branch 7 taken 2 times.
8 bool result = setSchedule(OS_AirTerminal_DualDuct_VAVFields::MinimumAirFlowTurndownScheduleName, "AirTerminalDualDuctVAV",
158 "Minimum Air Flow Turndown", schedule);
159 2 return result;
160 }
161
162 1 void AirTerminalDualDuctVAV_Impl::resetMinimumAirFlowTurndownSchedule() {
163
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
2 bool result = setString(OS_AirTerminal_DualDuct_VAVFields::MinimumAirFlowTurndownScheduleName, "");
164
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
1 OS_ASSERT(result);
165 1 }
166
167 ✗ bool AirTerminalDualDuctVAV_Impl::setMinimumAirFlowTurndownScheduleAsModelObject(const boost::optional<ModelObject>& modelObject) {
168 ✗ if (modelObject) {
169 ✗ OptionalSchedule intermediate = modelObject->optionalCast<Schedule>();
170 ✗ if (intermediate) {
171 ✗ Schedule schedule(*intermediate);
172 ✗ return setMinimumAirFlowTurndownSchedule(schedule);
173 ✗ } else {
174 ✗ return false;
175 }
176 ✗ } else {
177 ✗ resetMinimumAirFlowTurndownSchedule();
178 }
179 ✗ return true;
180 }
181
182 102 unsigned AirTerminalDualDuctVAV_Impl::outletPort() const {
183 102 return OS_AirTerminal_DualDuct_VAVFields::AirOutletNode;
184 }
185
186 24 unsigned AirTerminalDualDuctVAV_Impl::inletPort(unsigned branchIndex) const {
187
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 12 times.
24 if (branchIndex == 0) {
188 12 return OS_AirTerminal_DualDuct_VAVFields::HotAirInletNode;
189
1/2
✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
12 } else if (branchIndex == 1) {
190 12 return OS_AirTerminal_DualDuct_VAVFields::ColdAirInletNode;
191 } else {
192 ✗ LOG(Warn, "Calling inletPort with branchIndex greater than 1 for " << briefDescription() << " is not valid.");
193 ✗ LOG(Warn, briefDescription() << " has only two branches.");
194 ✗ return std::numeric_limits<unsigned>::max();
195 }
196 }
197
198 ✗ unsigned AirTerminalDualDuctVAV_Impl::nextInletPort() const {
199 ✗ LOG(Warn, "nextInletPort is not supported for " << briefDescription() << " .");
200 ✗ LOG(Warn, "Ports cannot be added or removed for " << briefDescription() << " .");
201 ✗ return std::numeric_limits<unsigned>::max();
202 }
203
204 ✗ unsigned AirTerminalDualDuctVAV_Impl::newInletPortAfterBranch(unsigned /*branchIndex*/) {
205 ✗ LOG(Warn, "newInletPortAfterBranch is not supported for " << briefDescription() << " .");
206 ✗ LOG(Warn, "Ports cannot be added or removed for " << briefDescription() << " .");
207 ✗ return std::numeric_limits<unsigned>::max();
208 }
209
210 ✗ void AirTerminalDualDuctVAV_Impl::removePortForBranch(unsigned /*branchIndex*/) {
211 ✗ LOG(Warn, "removePortForBranch is not supported for " << briefDescription() << " .");
212 ✗ LOG(Warn, "Ports cannot be added or removed for " << briefDescription() << " .");
213 ✗ }
214
215 1 boost::optional<Node> AirTerminalDualDuctVAV_Impl::hotAirInletNode() const {
216 1 boost::optional<Node> node;
217
2/3
✓ Branch 1 taken 1 time.
✓ Branch 3 taken 1 time.
✗ Branch 4 not taken.
2 if (auto mo = inletModelObject(0)) {
218
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
1 node = mo->optionalCast<Node>();
219
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 1 time.
✗ Branch 4 not taken.
1 OS_ASSERT(node);
220 1 }
221 1 return node;
222 ✗ }
223
224 1 boost::optional<Node> AirTerminalDualDuctVAV_Impl::coldAirInletNode() const {
225 1 boost::optional<Node> node;
226
2/3
✓ Branch 1 taken 1 time.
✓ Branch 3 taken 1 time.
✗ Branch 4 not taken.
2 if (auto mo = inletModelObject(1)) {
227
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
1 node = mo->optionalCast<Node>();
228
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 1 time.
✗ Branch 4 not taken.
1 OS_ASSERT(node);
229 1 }
230 1 return node;
231 ✗ }
232
233 2 std::vector<IdfObject> AirTerminalDualDuctVAV_Impl::remove() {
234
1/1
✓ Branch 1 taken 2 times.
2 auto modelObject = getObject<AirTerminalDualDuctVAV>();
235
4/4
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
✓ Branch 7 taken 2 times.
✓ Branch 10 taken 2 times.
2 AirLoopHVAC_Impl::removeDualDuctTerminalFromAirLoopHVAC(modelObject, inletPort(0), inletPort(1), outletPort());
236
1/1
✓ Branch 1 taken 2 times.
4 return Mixer_Impl::remove();
237 2 }
238
239 8 bool AirTerminalDualDuctVAV_Impl::addToNode(Node& node) {
240
1/1
✓ Branch 1 taken 8 times.
8 auto mo = getObject<AirTerminalDualDuctVAV>();
241
4/4
✓ Branch 1 taken 8 times.
✓ Branch 4 taken 8 times.
✓ Branch 7 taken 8 times.
✓ Branch 10 taken 8 times.
16 return AirLoopHVAC_Impl::addDualDuctTerminalToNode(mo, inletPort(0), inletPort(1), outletPort(), node);
242 8 }
243
244 1 ModelObject AirTerminalDualDuctVAV_Impl::clone(Model model) const {
245
3/3
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
1 auto t_clone = Mixer_Impl::clone(model).cast<AirTerminalDualDuctVAV>();
246
247
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
2 t_clone.setString(OS_AirTerminal_DualDuct_VAVFields::HotAirInletNode, "");
248
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
2 t_clone.setString(OS_AirTerminal_DualDuct_VAVFields::ColdAirInletNode, "");
249
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
1 t_clone.setString(OS_AirTerminal_DualDuct_VAVFields::AirOutletNode, "");
250
251 2 return std::move(t_clone);
252 1 }
253
254 2 bool AirTerminalDualDuctVAV_Impl::isRemovable() const {
255 2 return HVACComponent_Impl::isRemovable();
256 }
257
258 ✗ boost::optional<double> AirTerminalDualDuctVAV_Impl::autosizedMaximumDamperAirFlowRate() const {
259 ✗ return getAutosizedValue("Maximum Air Flow Rate", "m3/s");
260 }
261
262 ✗ void AirTerminalDualDuctVAV_Impl::autosize() {
263 ✗ autosizeMaximumDamperAirFlowRate();
264 ✗ }
265
266 ✗ void AirTerminalDualDuctVAV_Impl::applySizingValues() {
267 ✗ boost::optional<double> val;
268 ✗ val = autosizedMaximumDamperAirFlowRate();
269 ✗ if (val) {
270 ✗ setMaximumDamperAirFlowRate(val.get());
271 }
272 ✗ }
273
274 ✗ ComponentType AirTerminalDualDuctVAV_Impl::componentType() const {
275 ✗ if (auto a_ = airLoopHVAC()) {
276 ✗ return a_->componentType();
277 ✗ }
278
279 ✗ return ComponentType::None;
280 }
281
282 ✗ std::vector<FuelType> AirTerminalDualDuctVAV_Impl::coolingFuelTypes() const {
283 ✗ if (auto a_ = airLoopHVAC()) {
284 ✗ return a_->coolingFuelTypes();
285 ✗ }
286 ✗ return {};
287 }
288
289 ✗ std::vector<FuelType> AirTerminalDualDuctVAV_Impl::heatingFuelTypes() const {
290 ✗ if (auto a_ = airLoopHVAC()) {
291 ✗ return a_->heatingFuelTypes();
292 ✗ }
293 ✗ return {};
294 }
295
296 ✗ std::vector<AppGFuelType> AirTerminalDualDuctVAV_Impl::appGHeatingFuelTypes() const {
297 ✗ if (auto a_ = airLoopHVAC()) {
298 ✗ return a_->appGHeatingFuelTypes();
299 ✗ }
300 ✗ return {};
301 }
302
303 } // namespace detail
304
305 9 AirTerminalDualDuctVAV::AirTerminalDualDuctVAV(const Model& model) : Mixer(AirTerminalDualDuctVAV::iddObjectType(), model) {
306
1/3
✗ Branch 2 not taken.
✓ Branch 3 taken 9 times.
✗ Branch 5 not taken.
9 OS_ASSERT(getImpl<detail::AirTerminalDualDuctVAV_Impl>());
307
308
1/1
✓ Branch 1 taken 9 times.
9 autosizeMaximumDamperAirFlowRate();
309
1/1
✓ Branch 1 taken 9 times.
9 setZoneMinimumAirFlowFraction(0.3);
310 9 }
311
312 7629 IddObjectType AirTerminalDualDuctVAV::iddObjectType() {
313
1/1
✓ Branch 1 taken 7629 times.
7629 return {IddObjectType::OS_AirTerminal_DualDuct_VAV};
314 }
315
316 1 boost::optional<Schedule> AirTerminalDualDuctVAV::availabilitySchedule() const {
317
1/1
✓ Branch 3 taken 1 time.
1 return getImpl<detail::AirTerminalDualDuctVAV_Impl>()->availabilitySchedule();
318 }
319
320 1 boost::optional<double> AirTerminalDualDuctVAV::maximumDamperAirFlowRate() const {
321
1/1
✓ Branch 3 taken 1 time.
1 return getImpl<detail::AirTerminalDualDuctVAV_Impl>()->maximumDamperAirFlowRate();
322 }
323
324 1 bool AirTerminalDualDuctVAV::isMaximumDamperAirFlowRateAutosized() const {
325
1/1
✓ Branch 3 taken 1 time.
1 return getImpl<detail::AirTerminalDualDuctVAV_Impl>()->isMaximumDamperAirFlowRateAutosized();
326 }
327
328 1 double AirTerminalDualDuctVAV::zoneMinimumAirFlowFraction() const {
329
1/1
✓ Branch 3 taken 1 time.
1 return getImpl<detail::AirTerminalDualDuctVAV_Impl>()->zoneMinimumAirFlowFraction();
330 }
331
332 1 boost::optional<DesignSpecificationOutdoorAir> AirTerminalDualDuctVAV::designSpecificationOutdoorAirObject() const {
333
1/1
✓ Branch 3 taken 1 time.
1 return getImpl<detail::AirTerminalDualDuctVAV_Impl>()->designSpecificationOutdoorAirObject();
334 }
335
336 5 boost::optional<Schedule> AirTerminalDualDuctVAV::minimumAirFlowTurndownSchedule() const {
337
1/1
✓ Branch 3 taken 5 times.
5 return getImpl<detail::AirTerminalDualDuctVAV_Impl>()->minimumAirFlowTurndownSchedule();
338 }
339
340 1 bool AirTerminalDualDuctVAV::setAvailabilitySchedule(Schedule& schedule) {
341
1/1
✓ Branch 3 taken 1 time.
1 return getImpl<detail::AirTerminalDualDuctVAV_Impl>()->setAvailabilitySchedule(schedule);
342 }
343
344 ✗ void AirTerminalDualDuctVAV::resetAvailabilitySchedule() {
345 ✗ getImpl<detail::AirTerminalDualDuctVAV_Impl>()->resetAvailabilitySchedule();
346 ✗ }
347
348 1 bool AirTerminalDualDuctVAV::setMaximumDamperAirFlowRate(double maximumDamperAirFlowRate) {
349
2/2
✓ Branch 3 taken 1 time.
✓ Branch 6 taken 1 time.
1 return getImpl<detail::AirTerminalDualDuctVAV_Impl>()->setMaximumDamperAirFlowRate(maximumDamperAirFlowRate);
350 }
351
352 9 void AirTerminalDualDuctVAV::autosizeMaximumDamperAirFlowRate() {
353
1/1
✓ Branch 3 taken 9 times.
9 getImpl<detail::AirTerminalDualDuctVAV_Impl>()->autosizeMaximumDamperAirFlowRate();
354 9 }
355
356 10 bool AirTerminalDualDuctVAV::setZoneMinimumAirFlowFraction(double zoneMinimumAirFlowFraction) {
357
1/1
✓ Branch 3 taken 10 times.
10 return getImpl<detail::AirTerminalDualDuctVAV_Impl>()->setZoneMinimumAirFlowFraction(zoneMinimumAirFlowFraction);
358 }
359
360 1 bool AirTerminalDualDuctVAV::setDesignSpecificationOutdoorAirObject(const DesignSpecificationOutdoorAir& designSpecificationOutdoorAir) {
361
2/2
✓ Branch 3 taken 1 time.
✓ Branch 6 taken 1 time.
1 return getImpl<detail::AirTerminalDualDuctVAV_Impl>()->setDesignSpecificationOutdoorAirObject(designSpecificationOutdoorAir);
362 }
363
364 1 boost::optional<Node> AirTerminalDualDuctVAV::hotAirInletNode() const {
365
1/1
✓ Branch 3 taken 1 time.
1 return getImpl<detail::AirTerminalDualDuctVAV_Impl>()->hotAirInletNode();
366 }
367
368 1 boost::optional<Node> AirTerminalDualDuctVAV::coldAirInletNode() const {
369
1/1
✓ Branch 3 taken 1 time.
1 return getImpl<detail::AirTerminalDualDuctVAV_Impl>()->coldAirInletNode();
370 }
371
372 ✗ void AirTerminalDualDuctVAV::resetDesignSpecificationOutdoorAirObject() {
373 ✗ getImpl<detail::AirTerminalDualDuctVAV_Impl>()->resetDesignSpecificationOutdoorAirObject();
374 ✗ }
375
376 2 bool AirTerminalDualDuctVAV::setMinimumAirFlowTurndownSchedule(Schedule& schedule) {
377
1/1
✓ Branch 3 taken 2 times.
2 return getImpl<detail::AirTerminalDualDuctVAV_Impl>()->setMinimumAirFlowTurndownSchedule(schedule);
378 }
379
380 1 void AirTerminalDualDuctVAV::resetMinimumAirFlowTurndownSchedule() {
381
1/1
✓ Branch 3 taken 1 time.
1 getImpl<detail::AirTerminalDualDuctVAV_Impl>()->resetMinimumAirFlowTurndownSchedule();
382 1 }
383
384 /*
385 *void AirTerminalDualDuctVAV::autosize() {
386 * getImpl<detail::AirTerminalDualDuctVAV_Impl>()->autosize();
387 *}
388 *
389 *void AirTerminalDualDuctVAV::applySizingValues() {
390 * getImpl<detail::AirTerminalDualDuctVAV_Impl>()->applySizingValues();
391 *}
392 */
393
394 /// @cond
395
1/1
✓ Branch 3 taken 19 times.
19 AirTerminalDualDuctVAV::AirTerminalDualDuctVAV(std::shared_ptr<detail::AirTerminalDualDuctVAV_Impl> impl) : Mixer(std::move(impl)) {}
396 /// @endcond
397
398 ✗ boost::optional<double> AirTerminalDualDuctVAV::autosizedMaximumDamperAirFlowRate() const {
399 ✗ return getImpl<detail::AirTerminalDualDuctVAV_Impl>()->autosizedMaximumDamperAirFlowRate();
400 }
401
402 } // namespace model
403 } // namespace openstudio
404