GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 37.5% 192 / 0 / 512
Functions: 30.8% 36 / 0 / 117
Branches: 39.0% 219 / 0 / 561

src/model/AirTerminalSingleDuctConstantVolumeFourPipeInduction.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 "AirTerminalSingleDuctConstantVolumeFourPipeInduction.hpp"
7 #include "AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl.hpp"
8
9 #include "Schedule.hpp"
10 #include "Schedule_Impl.hpp"
11 #include "ScheduleTypeLimits.hpp"
12 #include "ScheduleTypeRegistry.hpp"
13 #include "Model.hpp"
14 #include "Model_Impl.hpp"
15 #include "AirLoopHVAC.hpp"
16 #include "AirLoopHVAC_Impl.hpp"
17 #include "Node.hpp"
18 #include "Node_Impl.hpp"
19 #include "PortList.hpp"
20 #include "PortList_Impl.hpp"
21 #include "HVACComponent.hpp"
22 #include "HVACComponent_Impl.hpp"
23 #include "ThermalZone.hpp"
24 #include "ThermalZone_Impl.hpp"
25 #include "AirLoopHVACZoneSplitter.hpp"
26 #include "AirLoopHVACZoneSplitter_Impl.hpp"
27 #include "AirLoopHVACZoneMixer.hpp"
28 #include "AirLoopHVACZoneMixer_Impl.hpp"
29
30 #include <utilities/idd/OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInduction_FieldEnums.hxx>
31 #include <utilities/idd/IddEnums.hxx>
32
33 #include "../utilities/core/Assert.hpp"
34 #include "../utilities/data/DataEnums.hpp"
35
36 namespace openstudio {
37 namespace model {
38
39 namespace detail {
40
41 8 AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl(const IdfObject& idfObject,
42 Model_Impl* model,
43 8 bool keepHandle)
44 8 : StraightComponent_Impl(idfObject, model, keepHandle) {
45
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() == AirTerminalSingleDuctConstantVolumeFourPipeInduction::iddObjectType());
46 8 }
47
48 ✗ AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl(
49 ✗ const openstudio::detail::WorkspaceObject_Impl& other, Model_Impl* model, bool keepHandle)
50 ✗ : StraightComponent_Impl(other, model, keepHandle) {
51 ✗ OS_ASSERT(other.iddObject().type() == AirTerminalSingleDuctConstantVolumeFourPipeInduction::iddObjectType());
52 ✗ }
53
54 12 AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl(
55 12 const AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl& other, Model_Impl* model, bool keepHandle)
56 12 : StraightComponent_Impl(other, model, keepHandle) {}
57
58 ✗ const std::vector<std::string>& AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::outputVariableNames() const {
59 ✗ static const std::vector<std::string> result;
60 // Not Appropriate: No Specific output for this object
61 ✗ return result;
62 }
63
64 5 IddObjectType AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::iddObjectType() const {
65 5 return AirTerminalSingleDuctConstantVolumeFourPipeInduction::iddObjectType();
66 }
67
68 ✗ std::vector<ScheduleTypeKey> AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::getScheduleTypeKeys(const Schedule& schedule) const {
69 ✗ std::vector<ScheduleTypeKey> result;
70 ✗ UnsignedVector fieldIndices = getSourceIndices(schedule.handle());
71 ✗ UnsignedVector::const_iterator b(fieldIndices.begin());
72 ✗ UnsignedVector::const_iterator e(fieldIndices.end());
73 ✗ if (std::find(b, e, OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::AvailabilityScheduleName) != e) {
74 ✗ result.push_back(ScheduleTypeKey("AirTerminalSingleDuctConstantVolumeFourPipeInduction", "Availability"));
75 }
76 ✗ return result;
77 ✗ }
78
79 19 unsigned AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::inletPort() const {
80 19 return OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::SupplyAirInletNodeName;
81 }
82
83 72 unsigned AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::outletPort() const {
84 72 return OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::AirOutletNodeName;
85 }
86
87 15 bool AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::addToNode(Node& node) {
88
1/1
✓ Branch 1 taken 15 times.
15 Model _model = node.model();
89
90
2/3
✓ Branch 1 taken 15 times.
✓ Branch 3 taken 15 times.
✗ Branch 4 not taken.
30 if (boost::optional<ModelObject> outlet = node.outletModelObject()) {
91 15 boost::optional<ThermalZone> thermalZone;
92
93
4/4
✓ Branch 1 taken 15 times.
✓ Branch 4 taken 15 times.
✓ Branch 6 taken 8 times.
✓ Branch 7 taken 7 times.
30 if (boost::optional<PortList> portList = outlet->optionalCast<PortList>()) {
94
3/3
✓ Branch 1 taken 8 times.
✓ Branch 4 taken 8 times.
✓ Branch 7 taken 8 times.
8 thermalZone = portList->thermalZone();
95 15 }
96
97
14/19
✓ Branch 1 taken 7 times.
✓ Branch 2 taken 8 times.
✓ Branch 4 taken 7 times.
✓ Branch 7 taken 7 times.
✓ Branch 10 taken 3 times.
✓ Branch 11 taken 4 times.
✓ Branch 13 taken 3 times.
✓ Branch 16 taken 3 times.
✗ Branch 17 not taken.
✓ Branch 18 taken 3 times.
✓ Branch 19 taken 12 times.
✓ Branch 21 taken 7 times.
✓ Branch 22 taken 8 times.
✓ Branch 24 taken 11 times.
✓ Branch 25 taken 4 times.
✗ Branch 26 not taken.
✗ Branch 27 not taken.
✗ Branch 29 not taken.
✗ Branch 30 not taken.
40 if (thermalZone || (outlet->optionalCast<Mixer>() && node.airLoopHVAC())) {
98
2/3
✓ Branch 1 taken 11 times.
✓ Branch 3 taken 11 times.
✗ Branch 4 not taken.
22 if (boost::optional<ModelObject> inlet = node.inletModelObject()) {
99
3/4
✓ Branch 1 taken 11 times.
✓ Branch 4 taken 11 times.
✓ Branch 6 taken 11 times.
✗ Branch 7 not taken.
22 if (boost::optional<Splitter> splitter = inlet->optionalCast<Splitter>()) {
100
1/1
✓ Branch 1 taken 11 times.
11 boost::optional<ModelObject> sourceModelObject = inlet;
101
2/2
✓ Branch 1 taken 11 times.
✓ Branch 4 taken 11 times.
11 boost::optional<unsigned> sourcePort = node.connectedObjectPort(node.inletPort());
102
103
3/6
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 11 times.
✗ Branch 5 not taken.
22 if (sourcePort && sourceModelObject) {
104
1/1
✓ Branch 1 taken 11 times.
11 Node inletNode(_model);
105
106
1/1
✓ Branch 1 taken 11 times.
11 auto thisObject = getObject<ModelObject>();
107
108
6/6
✓ Branch 1 taken 11 times.
✓ Branch 4 taken 11 times.
✓ Branch 7 taken 11 times.
✓ Branch 10 taken 11 times.
✓ Branch 13 taken 11 times.
✓ Branch 16 taken 11 times.
11 _model.connect(sourceModelObject.get(), sourcePort.get(), inletNode, inletNode.inletPort());
109
110
5/5
✓ Branch 1 taken 11 times.
✓ Branch 4 taken 11 times.
✓ Branch 7 taken 11 times.
✓ Branch 10 taken 11 times.
✓ Branch 13 taken 11 times.
11 _model.connect(inletNode, inletNode.outletPort(), thisObject, inletPort());
111
112
5/5
✓ Branch 1 taken 11 times.
✓ Branch 4 taken 11 times.
✓ Branch 7 taken 11 times.
✓ Branch 10 taken 11 times.
✓ Branch 13 taken 11 times.
11 _model.connect(thisObject, outletPort(), node, node.inletPort());
113
114
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 3 times.
11 if (thermalZone) {
115
1/1
✓ Branch 1 taken 8 times.
8 Node inducedAirInletNode(_model);
116
117
2/2
✓ Branch 1 taken 8 times.
✓ Branch 4 taken 8 times.
8 PortList exhaustPortList = thermalZone->exhaustPortList();
118
119
5/5
✓ Branch 1 taken 8 times.
✓ Branch 4 taken 8 times.
✓ Branch 7 taken 8 times.
✓ Branch 10 taken 8 times.
✓ Branch 13 taken 8 times.
8 _model.connect(exhaustPortList, exhaustPortList.nextPort(), inducedAirInletNode, inducedAirInletNode.inletPort());
120
121
5/5
✓ Branch 1 taken 8 times.
✓ Branch 4 taken 8 times.
✓ Branch 7 taken 8 times.
✓ Branch 10 taken 8 times.
✓ Branch 13 taken 8 times.
8 _model.connect(inducedAirInletNode, inducedAirInletNode.outletPort(), thisObject, inducedAirInletPort());
122
123
1/1
✓ Branch 1 taken 8 times.
8 auto mo = this->getObject<ModelObject>();
124
125
2/2
✓ Branch 1 taken 8 times.
✓ Branch 4 taken 8 times.
8 thermalZone->addEquipment(mo);
126 8 }
127
128 11 return true;
129 11 }
130 22 }
131 11 }
132 }
133 30 }
134
135 4 return false;
136 15 }
137
138 1 std::vector<IdfObject> AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::remove() {
139
1/1
✓ Branch 1 taken 1 time.
1 Model _model = this->model();
140
1/1
✓ Branch 1 taken 1 time.
1 auto thisObject = this->getObject<ModelObject>();
141 1 boost::optional<PlantLoop> loop;
142
143
1/1
✓ Branch 1 taken 1 time.
1 HVACComponent _heatingCoil = heatingCoil();
144
1/1
✓ Branch 1 taken 1 time.
1 boost::optional<HVACComponent> _coolingCoil = coolingCoil();
145
146
1/1
✓ Branch 1 taken 1 time.
1 boost::optional<ModelObject> sourceModelObject = this->inletModelObject();
147
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
1 boost::optional<unsigned> sourcePort = this->connectedObjectPort(this->inletPort());
148
149
1/1
✓ Branch 1 taken 1 time.
1 boost::optional<ModelObject> targetModelObject = this->outletModelObject();
150
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
1 boost::optional<unsigned> targetPort = this->connectedObjectPort(this->outletPort());
151
152
1/1
✓ Branch 1 taken 1 time.
1 std::vector<ThermalZone> thermalZones = _model.getConcreteModelObjects<ThermalZone>();
153
1/2
✓ Branch 5 taken 1 time.
✗ Branch 6 not taken.
1 for (auto& thermalZone : thermalZones) {
154
1/1
✓ Branch 1 taken 1 time.
1 std::vector<ModelObject> equipment = thermalZone.equipment();
155
156
2/3
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✗ Branch 8 not taken.
1 if (std::find(equipment.begin(), equipment.end(), thisObject) != equipment.end()) {
157
1/1
✓ Branch 1 taken 1 time.
1 thermalZone.removeEquipment(thisObject);
158 1 break;
159 }
160 1 }
161
162
2/3
✓ Branch 1 taken 1 time.
✓ Branch 3 taken 1 time.
✗ Branch 4 not taken.
2 if (boost::optional<Node> t_inducedAirInletNode = inducedAirInletNode()) {
163
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
1 t_inducedAirInletNode->disconnect();
164
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
1 t_inducedAirInletNode->remove();
165 1 }
166
167
5/10
✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 time.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 time.
✗ Branch 5 not taken.
✓ Branch 6 taken 1 time.
✗ Branch 7 not taken.
✓ Branch 8 taken 1 time.
✗ Branch 9 not taken.
4 if (sourcePort && sourceModelObject && targetPort && targetModelObject) {
168
3/4
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 6 taken 1 time.
✗ Branch 7 not taken.
2 if (boost::optional<Node> inletNode = sourceModelObject->optionalCast<Node>()) {
169
3/4
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 6 taken 1 time.
✗ Branch 7 not taken.
2 if (boost::optional<ModelObject> source2ModelObject = inletNode->inletModelObject()) {
170
5/6
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✓ Branch 10 taken 1 time.
✓ Branch 12 taken 1 time.
✗ Branch 13 not taken.
2 if (boost::optional<unsigned> source2Port = inletNode->connectedObjectPort(inletNode->inletPort())) {
171
7/7
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✓ Branch 10 taken 1 time.
✓ Branch 13 taken 1 time.
✓ Branch 16 taken 1 time.
✓ Branch 19 taken 1 time.
1 _model.connect(source2ModelObject.get(), source2Port.get(), targetModelObject.get(), targetPort.get());
172
173
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
1 inletNode->disconnect();
174
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
1 inletNode->remove();
175
176
6/12
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✓ Branch 10 taken 1 time.
✗ Branch 11 not taken.
✓ Branch 12 taken 1 time.
✗ Branch 13 not taken.
✓ Branch 15 taken 1 time.
✗ Branch 16 not taken.
✗ Branch 17 not taken.
✗ Branch 18 not taken.
3 if (_coolingCoil && (loop = _coolingCoil->plantLoop())) {
177
4/4
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
✓ Branch 10 taken 1 time.
1 loop->removeDemandBranchWithComponent(*_coolingCoil);
178 }
179
180
2/3
✓ Branch 1 taken 1 time.
✓ Branch 5 taken 1 time.
✗ Branch 6 not taken.
2 if ((loop = _heatingCoil.plantLoop())) {
181
3/3
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 7 taken 1 time.
1 loop->removeDemandBranchWithComponent(_heatingCoil);
182 }
183
184
1/1
✓ Branch 1 taken 1 time.
1 return StraightComponent_Impl::remove();
185 }
186 1 }
187 1 }
188 }
189
190 ✗ model().disconnect(thisObject, inletPort());
191 ✗ model().disconnect(thisObject, outletPort());
192
193 ✗ if (_coolingCoil && (loop = _coolingCoil->plantLoop())) {
194 ✗ loop->removeDemandBranchWithComponent(*_coolingCoil);
195 }
196
197 ✗ if ((loop = _heatingCoil.plantLoop())) {
198 ✗ loop->removeDemandBranchWithComponent(_heatingCoil);
199 }
200
201 ✗ return StraightComponent_Impl::remove();
202 1 }
203
204 1 bool AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::isRemovable() const {
205 1 return true;
206 }
207
208 6 ModelObject AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::clone(Model model) const {
209
3/3
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
✓ Branch 7 taken 6 times.
6 auto airTerminalCVFourPipeInductionClone = StraightComponent_Impl::clone(model).cast<AirTerminalSingleDuctConstantVolumeFourPipeInduction>();
210
211
3/3
✓ Branch 1 taken 6 times.
✓ Branch 3 taken 3 times.
✓ Branch 4 taken 3 times.
12 if (boost::optional<HVACComponent> coolingCoil = this->coolingCoil()) {
212
4/4
✓ Branch 1 taken 3 times.
✓ Branch 4 taken 3 times.
✓ Branch 7 taken 3 times.
✓ Branch 10 taken 3 times.
3 auto coilCoolingClone = coolingCoil->clone(model).cast<HVACComponent>();
213
1/1
✓ Branch 1 taken 3 times.
3 airTerminalCVFourPipeInductionClone.setCoolingCoil(coilCoolingClone);
214 9 }
215
216
4/4
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
✓ Branch 7 taken 6 times.
✓ Branch 10 taken 6 times.
6 auto coilHeatingClone = this->heatingCoil().clone(model).cast<HVACComponent>();
217
1/1
✓ Branch 1 taken 6 times.
6 airTerminalCVFourPipeInductionClone.setHeatingCoil(coilHeatingClone);
218
219 // Reset the inducedAirInletPort (inletPort and outletPort are already handled by the StraightComponent_Impl::clone() method)
220
3/3
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
✓ Branch 7 taken 6 times.
6 airTerminalCVFourPipeInductionClone.setString(airTerminalCVFourPipeInductionClone.inducedAirInletPort(), "");
221
222 12 return std::move(airTerminalCVFourPipeInductionClone);
223 6 }
224
225 1 std::vector<ModelObject> AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::children() const {
226 1 std::vector<ModelObject> result;
227
2/3
✓ Branch 1 taken 1 time.
✓ Branch 3 taken 1 time.
✗ Branch 4 not taken.
2 if (OptionalHVACComponent intermediate = coolingCoil()) {
228
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
1 result.push_back(*intermediate);
229 1 }
230
2/3
✓ Branch 1 taken 1 time.
✓ Branch 3 taken 1 time.
✗ Branch 4 not taken.
2 if (OptionalHVACComponent intermediate = optionalHeatingCoil()) {
231
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
1 result.push_back(*intermediate);
232 1 }
233 1 return result;
234 ✗ }
235
236 ✗ boost::optional<Schedule> AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::availabilitySchedule() const {
237 ✗ return getObject<ModelObject>().getModelObjectTarget<Schedule>(
238 ✗ OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::AvailabilityScheduleName);
239 }
240
241 ✗ boost::optional<double> AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::maximumTotalAirFlowRate() const {
242 ✗ return getDouble(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MaximumTotalAirFlowRate, true);
243 }
244
245 ✗ bool AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::isMaximumTotalAirFlowRateAutosized() const {
246 ✗ bool result = false;
247 ✗ boost::optional<std::string> value = getString(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MaximumTotalAirFlowRate, true);
248 ✗ if (value) {
249 ✗ result = openstudio::istringEqual(value.get(), "autosize");
250 }
251 ✗ return result;
252 ✗ }
253
254 ✗ double AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::inductionRatio() const {
255 ✗ boost::optional<double> value = getDouble(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::InductionRatio, true);
256 ✗ OS_ASSERT(value);
257 ✗ return value.get();
258 }
259
260 ✗ bool AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::isInductionRatioDefaulted() const {
261 ✗ return isEmpty(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::InductionRatio);
262 }
263
264 24 HVACComponent AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::heatingCoil() const {
265
1/1
✓ Branch 1 taken 24 times.
24 boost::optional<HVACComponent> value = optionalHeatingCoil();
266
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 24 times.
24 if (!value) {
267 ✗ LOG_AND_THROW(briefDescription() << " does not have an Heating Coil attached.");
268 }
269
2/2
✓ Branch 1 taken 24 times.
✓ Branch 4 taken 24 times.
48 return value.get();
270 24 }
271
272 ✗ boost::optional<double> AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::maximumHotWaterFlowRate() const {
273 ✗ return getDouble(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MaximumHotWaterFlowRate, true);
274 }
275
276 ✗ bool AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::isMaximumHotWaterFlowRateAutosized() const {
277 ✗ bool result = false;
278 ✗ boost::optional<std::string> value = getString(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MaximumHotWaterFlowRate, true);
279 ✗ if (value) {
280 ✗ result = openstudio::istringEqual(value.get(), "autosize");
281 }
282 ✗ return result;
283 ✗ }
284
285 ✗ double AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::minimumHotWaterFlowRate() const {
286 ✗ boost::optional<double> value = getDouble(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MinimumHotWaterFlowRate, true);
287 ✗ OS_ASSERT(value);
288 ✗ return value.get();
289 }
290
291 ✗ bool AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::isMinimumHotWaterFlowRateDefaulted() const {
292 ✗ return isEmpty(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MinimumHotWaterFlowRate);
293 }
294
295 ✗ double AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::heatingConvergenceTolerance() const {
296 ✗ boost::optional<double> value = getDouble(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::HeatingConvergenceTolerance, true);
297 ✗ OS_ASSERT(value);
298 ✗ return value.get();
299 }
300
301 ✗ bool AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::isHeatingConvergenceToleranceDefaulted() const {
302 ✗ return isEmpty(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::HeatingConvergenceTolerance);
303 }
304
305 25 boost::optional<HVACComponent> AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::coolingCoil() const {
306
1/1
✓ Branch 1 taken 25 times.
50 return getObject<ModelObject>().getModelObjectTarget<HVACComponent>(
307
1/1
✓ Branch 1 taken 25 times.
50 OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::CoolingCoilName);
308 }
309
310 ✗ boost::optional<double> AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::maximumColdWaterFlowRate() const {
311 ✗ return getDouble(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MaximumColdWaterFlowRate, true);
312 }
313
314 ✗ bool AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::isMaximumColdWaterFlowRateAutosized() const {
315 ✗ bool result = false;
316 boost::optional<std::string> value =
317 ✗ getString(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MaximumColdWaterFlowRate, true);
318 ✗ if (value) {
319 ✗ result = openstudio::istringEqual(value.get(), "autosize");
320 }
321 ✗ return result;
322 ✗ }
323
324 ✗ double AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::minimumColdWaterFlowRate() const {
325 ✗ boost::optional<double> value = getDouble(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MinimumColdWaterFlowRate, true);
326 ✗ OS_ASSERT(value);
327 ✗ return value.get();
328 }
329
330 ✗ bool AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::isMinimumColdWaterFlowRateDefaulted() const {
331 ✗ return isEmpty(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MinimumColdWaterFlowRate);
332 }
333
334 ✗ double AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::coolingConvergenceTolerance() const {
335 ✗ boost::optional<double> value = getDouble(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::CoolingConvergenceTolerance, true);
336 ✗ OS_ASSERT(value);
337 ✗ return value.get();
338 }
339
340 ✗ bool AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::isCoolingConvergenceToleranceDefaulted() const {
341 ✗ return isEmpty(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::CoolingConvergenceTolerance);
342 }
343
344 ✗ bool AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::setAvailabilitySchedule(Schedule& schedule) {
345 ✗ bool result = setSchedule(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::AvailabilityScheduleName,
346 "AirTerminalSingleDuctConstantVolumeFourPipeInduction", "Availability", schedule);
347 ✗ return result;
348 }
349
350 ✗ void AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::resetAvailabilitySchedule() {
351 ✗ bool result = setString(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::AvailabilityScheduleName, "");
352 ✗ OS_ASSERT(result);
353 ✗ }
354
355 ✗ bool AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::setMaximumTotalAirFlowRate(boost::optional<double> maximumTotalAirFlowRate) {
356 ✗ bool result(false);
357 ✗ if (maximumTotalAirFlowRate) {
358 ✗ result = setDouble(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MaximumTotalAirFlowRate, maximumTotalAirFlowRate.get());
359 }
360 ✗ return result;
361 }
362
363 8 void AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::autosizeMaximumTotalAirFlowRate() {
364
2/2
✓ Branch 1 taken 8 times.
✓ Branch 4 taken 8 times.
16 bool result = setString(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MaximumTotalAirFlowRate, "autosize");
365
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
8 OS_ASSERT(result);
366 8 }
367
368 ✗ bool AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::setInductionRatio(double inductionRatio) {
369 ✗ bool result = setDouble(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::InductionRatio, inductionRatio);
370 ✗ return result;
371 }
372
373 ✗ void AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::resetInductionRatio() {
374 ✗ bool result = setString(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::InductionRatio, "");
375 ✗ OS_ASSERT(result);
376 ✗ }
377
378 14 bool AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::setHeatingCoil(const HVACComponent& heatingCoil) {
379
2/2
✓ Branch 1 taken 14 times.
✓ Branch 4 taken 14 times.
14 bool result = setPointer(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::HeatingCoilName, heatingCoil.handle());
380 14 return result;
381 }
382
383 ✗ bool AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::setMaximumHotWaterFlowRate(boost::optional<double> maximumHotWaterFlowRate) {
384 ✗ bool result(false);
385 ✗ if (maximumHotWaterFlowRate) {
386 ✗ result = setDouble(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MaximumHotWaterFlowRate, maximumHotWaterFlowRate.get());
387 } else {
388 ✗ resetMaximumHotWaterFlowRate();
389 ✗ result = true;
390 }
391 ✗ OS_ASSERT(result);
392 ✗ return result;
393 }
394
395 ✗ void AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::resetMaximumHotWaterFlowRate() {
396 ✗ bool result = setString(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MaximumHotWaterFlowRate, "");
397 ✗ OS_ASSERT(result);
398 ✗ }
399
400 8 void AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::autosizeMaximumHotWaterFlowRate() {
401
2/2
✓ Branch 1 taken 8 times.
✓ Branch 4 taken 8 times.
16 bool result = setString(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MaximumHotWaterFlowRate, "autosize");
402
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
8 OS_ASSERT(result);
403 8 }
404
405 ✗ bool AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::setMinimumHotWaterFlowRate(double minimumHotWaterFlowRate) {
406 ✗ bool result = setDouble(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MinimumHotWaterFlowRate, minimumHotWaterFlowRate);
407 ✗ return result;
408 }
409
410 ✗ void AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::resetMinimumHotWaterFlowRate() {
411 ✗ bool result = setString(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MinimumHotWaterFlowRate, "");
412 ✗ OS_ASSERT(result);
413 ✗ }
414
415 ✗ bool AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::setHeatingConvergenceTolerance(double heatingConvergenceTolerance) {
416 bool result =
417 ✗ setDouble(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::HeatingConvergenceTolerance, heatingConvergenceTolerance);
418 ✗ return result;
419 }
420
421 ✗ void AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::resetHeatingConvergenceTolerance() {
422 ✗ bool result = setString(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::HeatingConvergenceTolerance, "");
423 ✗ OS_ASSERT(result);
424 ✗ }
425
426 6 bool AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::setCoolingCoil(const boost::optional<HVACComponent>& coolingCoil) {
427 6 bool result(false);
428
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
6 if (coolingCoil) {
429
3/3
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
✓ Branch 7 taken 6 times.
6 result = setPointer(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::CoolingCoilName, coolingCoil.get().handle());
430 } else {
431 ✗ resetCoolingCoil();
432 ✗ result = true;
433 }
434 6 return result;
435 }
436
437 ✗ void AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::resetCoolingCoil() {
438 ✗ bool result = setString(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::CoolingCoilName, "");
439 ✗ OS_ASSERT(result);
440 ✗ }
441
442 ✗ bool AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::setMaximumColdWaterFlowRate(boost::optional<double> maximumColdWaterFlowRate) {
443 ✗ bool result(false);
444 ✗ if (maximumColdWaterFlowRate) {
445 result =
446 ✗ setDouble(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MaximumColdWaterFlowRate, maximumColdWaterFlowRate.get());
447 } else {
448 ✗ resetMaximumColdWaterFlowRate();
449 ✗ result = true;
450 }
451 ✗ OS_ASSERT(result);
452 ✗ return result;
453 }
454
455 ✗ void AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::resetMaximumColdWaterFlowRate() {
456 ✗ bool result = setString(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MaximumColdWaterFlowRate, "");
457 ✗ OS_ASSERT(result);
458 ✗ }
459
460 8 void AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::autosizeMaximumColdWaterFlowRate() {
461
2/2
✓ Branch 1 taken 8 times.
✓ Branch 4 taken 8 times.
16 bool result = setString(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MaximumColdWaterFlowRate, "autosize");
462
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
8 OS_ASSERT(result);
463 8 }
464
465 8 bool AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::setMinimumColdWaterFlowRate(double minimumColdWaterFlowRate) {
466 8 bool result = setDouble(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MinimumColdWaterFlowRate, minimumColdWaterFlowRate);
467 8 return result;
468 }
469
470 ✗ void AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::resetMinimumColdWaterFlowRate() {
471 ✗ bool result = setString(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::MinimumColdWaterFlowRate, "");
472 ✗ OS_ASSERT(result);
473 ✗ }
474
475 8 bool AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::setCoolingConvergenceTolerance(double coolingConvergenceTolerance) {
476 bool result =
477 8 setDouble(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::CoolingConvergenceTolerance, coolingConvergenceTolerance);
478 8 return result;
479 }
480
481 ✗ void AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::resetCoolingConvergenceTolerance() {
482 ✗ bool result = setString(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::CoolingConvergenceTolerance, "");
483 ✗ OS_ASSERT(result);
484 ✗ }
485
486 25 boost::optional<HVACComponent> AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::optionalHeatingCoil() const {
487
1/1
✓ Branch 1 taken 25 times.
50 return getObject<ModelObject>().getModelObjectTarget<HVACComponent>(
488
1/1
✓ Branch 1 taken 25 times.
50 OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::HeatingCoilName);
489 }
490
491 12 boost::optional<Node> AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::inducedAirInletNode() const {
492 12 boost::optional<Node> result;
493
4/4
✓ Branch 1 taken 12 times.
✓ Branch 4 taken 12 times.
✓ Branch 6 taken 10 times.
✓ Branch 7 taken 2 times.
24 if (auto modelObject = connectedObject(inducedAirInletPort())) {
494
2/2
✓ Branch 1 taken 10 times.
✓ Branch 4 taken 10 times.
10 result = modelObject->optionalCast<Node>();
495 12 }
496 12 return result;
497 ✗ }
498
499 27 unsigned AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::inducedAirInletPort() const {
500 27 return OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::InducedAirInletNodeName;
501 }
502
503 ✗ boost::optional<double> AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::autosizedMaximumTotalAirFlowRate() const {
504 ✗ return getAutosizedValue("Design Size Maximum Total Air Flow Rate", "m3/s");
505 }
506
507 ✗ boost::optional<double> AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::autosizedMaximumHotWaterFlowRate() const {
508 ✗ return getAutosizedValue("Design Size Maximum Hot Water Flow Rate", "m3/s");
509 }
510
511 ✗ boost::optional<double> AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::autosizedMaximumColdWaterFlowRate() const {
512 ✗ return getAutosizedValue("Design Size Maximum Cold Water Flow Rate", "m3/s");
513 }
514
515 ✗ void AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::autosize() {
516 ✗ autosizeMaximumTotalAirFlowRate();
517 ✗ autosizeMaximumHotWaterFlowRate();
518 ✗ autosizeMaximumColdWaterFlowRate();
519 ✗ }
520
521 ✗ void AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::applySizingValues() {
522 ✗ boost::optional<double> val;
523 ✗ val = autosizedMaximumTotalAirFlowRate();
524 ✗ if (val) {
525 ✗ setMaximumTotalAirFlowRate(val.get());
526 }
527
528 ✗ val = autosizedMaximumHotWaterFlowRate();
529 ✗ if (val) {
530 ✗ setMaximumHotWaterFlowRate(val.get());
531 }
532
533 ✗ val = autosizedMaximumColdWaterFlowRate();
534 ✗ if (val) {
535 ✗ setMaximumColdWaterFlowRate(val.get());
536 }
537 ✗ }
538
539 ✗ ComponentType AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::componentType() const {
540 ✗ bool has_cooling = coolingCoil().is_initialized();
541 ✗ bool has_heating = true; // HC is not optonal
542 ✗ if (auto a_ = airLoopHVAC()) {
543 ✗ auto compType = a_->componentType();
544 ✗ if (compType == ComponentType::Cooling) {
545 ✗ has_cooling = true;
546 ✗ } else if (compType == ComponentType::Heating) {
547 ✗ has_heating = true;
548 ✗ } else if (compType == ComponentType::Both) {
549 ✗ has_heating = true;
550 ✗ has_cooling = true;
551 }
552 ✗ }
553
554 ✗ if (has_cooling && has_heating) {
555 ✗ return ComponentType::Both;
556 ✗ } else if (has_cooling) {
557 ✗ return ComponentType::Cooling;
558 ✗ } else if (has_heating) {
559 ✗ return ComponentType::Heating;
560 }
561 ✗ return ComponentType::None;
562 }
563
564 ✗ std::vector<FuelType> AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::coolingFuelTypes() const {
565 ✗ std::set<FuelType> result;
566 ✗ if (auto cc_ = coolingCoil()) {
567 ✗ for (auto ft : cc_->coolingFuelTypes()) {
568 ✗ result.insert(ft);
569 ✗ }
570 ✗ }
571 ✗ if (auto a_ = airLoopHVAC()) {
572 ✗ for (auto ft : a_->coolingFuelTypes()) {
573 ✗ result.insert(ft);
574 ✗ }
575 ✗ }
576 ✗ return {result.begin(), result.end()};
577 ✗ }
578
579 ✗ std::vector<FuelType> AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::heatingFuelTypes() const {
580 ✗ std::set<FuelType> result;
581 ✗ for (auto ft : heatingCoil().heatingFuelTypes()) {
582 ✗ result.insert(ft);
583 ✗ }
584 ✗ if (auto a_ = airLoopHVAC()) {
585 ✗ for (auto ft : a_->heatingFuelTypes()) {
586 ✗ result.insert(ft);
587 ✗ }
588 ✗ }
589 ✗ return {result.begin(), result.end()};
590 ✗ }
591
592 ✗ std::vector<AppGFuelType> AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl::appGHeatingFuelTypes() const {
593 ✗ std::set<AppGFuelType> result;
594 ✗ for (auto ft : heatingCoil().appGHeatingFuelTypes()) {
595 ✗ result.insert(ft);
596 ✗ }
597 ✗ if (auto a_ = airLoopHVAC()) {
598 ✗ for (auto ft : a_->appGHeatingFuelTypes()) {
599 ✗ result.insert(ft);
600 ✗ }
601 ✗ }
602 ✗ return {result.begin(), result.end()};
603 ✗ }
604
605 } // namespace detail
606
607 8 AirTerminalSingleDuctConstantVolumeFourPipeInduction::AirTerminalSingleDuctConstantVolumeFourPipeInduction(const Model& model,
608 8 HVACComponent& heatingCoil)
609 8 : StraightComponent(AirTerminalSingleDuctConstantVolumeFourPipeInduction::iddObjectType(), model) {
610
1/3
✗ Branch 2 not taken.
✓ Branch 3 taken 8 times.
✗ Branch 5 not taken.
8 OS_ASSERT(getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>());
611
612
1/1
✓ Branch 1 taken 8 times.
8 autosizeMaximumTotalAirFlowRate();
613
1/1
✓ Branch 1 taken 8 times.
8 autosizeMaximumColdWaterFlowRate();
614
1/1
✓ Branch 1 taken 8 times.
8 autosizeMaximumHotWaterFlowRate();
615
1/1
✓ Branch 1 taken 8 times.
8 setHeatingCoil(heatingCoil);
616
1/1
✓ Branch 1 taken 8 times.
8 setMinimumColdWaterFlowRate(0.0);
617
1/1
✓ Branch 1 taken 8 times.
8 setCoolingConvergenceTolerance(0.001);
618
2/2
✓ Branch 1 taken 8 times.
✓ Branch 4 taken 8 times.
16 setString(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInductionFields::ZoneMixerName, "");
619 8 }
620
621 7824 IddObjectType AirTerminalSingleDuctConstantVolumeFourPipeInduction::iddObjectType() {
622
1/1
✓ Branch 1 taken 7824 times.
7824 return {IddObjectType::OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeInduction};
623 }
624
625 ✗ boost::optional<Schedule> AirTerminalSingleDuctConstantVolumeFourPipeInduction::availabilitySchedule() const {
626 ✗ return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->availabilitySchedule();
627 }
628
629 ✗ boost::optional<double> AirTerminalSingleDuctConstantVolumeFourPipeInduction::maximumTotalAirFlowRate() const {
630 ✗ return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->maximumTotalAirFlowRate();
631 }
632
633 ✗ bool AirTerminalSingleDuctConstantVolumeFourPipeInduction::isMaximumTotalAirFlowRateAutosized() const {
634 ✗ return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->isMaximumTotalAirFlowRateAutosized();
635 }
636
637 ✗ double AirTerminalSingleDuctConstantVolumeFourPipeInduction::inductionRatio() const {
638 ✗ return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->inductionRatio();
639 }
640
641 ✗ bool AirTerminalSingleDuctConstantVolumeFourPipeInduction::isInductionRatioDefaulted() const {
642 ✗ return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->isInductionRatioDefaulted();
643 }
644
645 17 HVACComponent AirTerminalSingleDuctConstantVolumeFourPipeInduction::heatingCoil() const {
646
1/1
✓ Branch 3 taken 17 times.
17 return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->heatingCoil();
647 }
648
649 ✗ boost::optional<double> AirTerminalSingleDuctConstantVolumeFourPipeInduction::maximumHotWaterFlowRate() const {
650 ✗ return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->maximumHotWaterFlowRate();
651 }
652
653 ✗ bool AirTerminalSingleDuctConstantVolumeFourPipeInduction::isMaximumHotWaterFlowRateAutosized() const {
654 ✗ return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->isMaximumHotWaterFlowRateAutosized();
655 }
656
657 ✗ double AirTerminalSingleDuctConstantVolumeFourPipeInduction::minimumHotWaterFlowRate() const {
658 ✗ return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->minimumHotWaterFlowRate();
659 }
660
661 ✗ bool AirTerminalSingleDuctConstantVolumeFourPipeInduction::isMinimumHotWaterFlowRateDefaulted() const {
662 ✗ return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->isMinimumHotWaterFlowRateDefaulted();
663 }
664
665 ✗ double AirTerminalSingleDuctConstantVolumeFourPipeInduction::heatingConvergenceTolerance() const {
666 ✗ return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->heatingConvergenceTolerance();
667 }
668
669 ✗ bool AirTerminalSingleDuctConstantVolumeFourPipeInduction::isHeatingConvergenceToleranceDefaulted() const {
670 ✗ return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->isHeatingConvergenceToleranceDefaulted();
671 }
672
673 17 boost::optional<HVACComponent> AirTerminalSingleDuctConstantVolumeFourPipeInduction::coolingCoil() const {
674
1/1
✓ Branch 3 taken 17 times.
17 return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->coolingCoil();
675 }
676
677 ✗ boost::optional<double> AirTerminalSingleDuctConstantVolumeFourPipeInduction::maximumColdWaterFlowRate() const {
678 ✗ return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->maximumColdWaterFlowRate();
679 }
680
681 ✗ bool AirTerminalSingleDuctConstantVolumeFourPipeInduction::isMaximumColdWaterFlowRateAutosized() const {
682 ✗ return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->isMaximumColdWaterFlowRateAutosized();
683 }
684
685 ✗ double AirTerminalSingleDuctConstantVolumeFourPipeInduction::minimumColdWaterFlowRate() const {
686 ✗ return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->minimumColdWaterFlowRate();
687 }
688
689 ✗ bool AirTerminalSingleDuctConstantVolumeFourPipeInduction::isMinimumColdWaterFlowRateDefaulted() const {
690 ✗ return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->isMinimumColdWaterFlowRateDefaulted();
691 }
692
693 ✗ double AirTerminalSingleDuctConstantVolumeFourPipeInduction::coolingConvergenceTolerance() const {
694 ✗ return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->coolingConvergenceTolerance();
695 }
696
697 ✗ bool AirTerminalSingleDuctConstantVolumeFourPipeInduction::isCoolingConvergenceToleranceDefaulted() const {
698 ✗ return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->isCoolingConvergenceToleranceDefaulted();
699 }
700
701 ✗ bool AirTerminalSingleDuctConstantVolumeFourPipeInduction::setAvailabilitySchedule(Schedule& schedule) {
702 ✗ return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->setAvailabilitySchedule(schedule);
703 }
704
705 ✗ void AirTerminalSingleDuctConstantVolumeFourPipeInduction::resetAvailabilitySchedule() {
706 ✗ getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->resetAvailabilitySchedule();
707 ✗ }
708
709 ✗ bool AirTerminalSingleDuctConstantVolumeFourPipeInduction::setMaximumTotalAirFlowRate(double maximumTotalAirFlowRate) {
710 ✗ return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->setMaximumTotalAirFlowRate(maximumTotalAirFlowRate);
711 }
712
713 8 void AirTerminalSingleDuctConstantVolumeFourPipeInduction::autosizeMaximumTotalAirFlowRate() {
714
1/1
✓ Branch 3 taken 8 times.
8 getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->autosizeMaximumTotalAirFlowRate();
715 8 }
716
717 ✗ bool AirTerminalSingleDuctConstantVolumeFourPipeInduction::setInductionRatio(double inductionRatio) {
718 ✗ return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->setInductionRatio(inductionRatio);
719 }
720
721 ✗ void AirTerminalSingleDuctConstantVolumeFourPipeInduction::resetInductionRatio() {
722 ✗ getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->resetInductionRatio();
723 ✗ }
724
725 14 bool AirTerminalSingleDuctConstantVolumeFourPipeInduction::setHeatingCoil(const HVACComponent& heatingCoil) {
726
1/1
✓ Branch 3 taken 14 times.
14 return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->setHeatingCoil(heatingCoil);
727 }
728
729 ✗ bool AirTerminalSingleDuctConstantVolumeFourPipeInduction::setMaximumHotWaterFlowRate(double maximumHotWaterFlowRate) {
730 ✗ return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->setMaximumHotWaterFlowRate(maximumHotWaterFlowRate);
731 }
732
733 ✗ void AirTerminalSingleDuctConstantVolumeFourPipeInduction::resetMaximumHotWaterFlowRate() {
734 ✗ getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->resetMaximumHotWaterFlowRate();
735 ✗ }
736
737 8 void AirTerminalSingleDuctConstantVolumeFourPipeInduction::autosizeMaximumHotWaterFlowRate() {
738
1/1
✓ Branch 3 taken 8 times.
8 getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->autosizeMaximumHotWaterFlowRate();
739 8 }
740
741 ✗ bool AirTerminalSingleDuctConstantVolumeFourPipeInduction::setMinimumHotWaterFlowRate(double minimumHotWaterFlowRate) {
742 ✗ return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->setMinimumHotWaterFlowRate(minimumHotWaterFlowRate);
743 }
744
745 ✗ void AirTerminalSingleDuctConstantVolumeFourPipeInduction::resetMinimumHotWaterFlowRate() {
746 ✗ getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->resetMinimumHotWaterFlowRate();
747 ✗ }
748
749 ✗ bool AirTerminalSingleDuctConstantVolumeFourPipeInduction::setHeatingConvergenceTolerance(double heatingConvergenceTolerance) {
750 ✗ return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->setHeatingConvergenceTolerance(heatingConvergenceTolerance);
751 }
752
753 ✗ void AirTerminalSingleDuctConstantVolumeFourPipeInduction::resetHeatingConvergenceTolerance() {
754 ✗ getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->resetHeatingConvergenceTolerance();
755 ✗ }
756
757 6 bool AirTerminalSingleDuctConstantVolumeFourPipeInduction::setCoolingCoil(const HVACComponent& coolingCoil) {
758
2/2
✓ Branch 3 taken 6 times.
✓ Branch 6 taken 6 times.
6 return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->setCoolingCoil(coolingCoil);
759 }
760
761 ✗ void AirTerminalSingleDuctConstantVolumeFourPipeInduction::resetCoolingCoil() {
762 ✗ getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->resetCoolingCoil();
763 ✗ }
764
765 ✗ bool AirTerminalSingleDuctConstantVolumeFourPipeInduction::setMaximumColdWaterFlowRate(double maximumColdWaterFlowRate) {
766 ✗ return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->setMaximumColdWaterFlowRate(maximumColdWaterFlowRate);
767 }
768
769 ✗ void AirTerminalSingleDuctConstantVolumeFourPipeInduction::resetMaximumColdWaterFlowRate() {
770 ✗ getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->resetMaximumColdWaterFlowRate();
771 ✗ }
772
773 8 void AirTerminalSingleDuctConstantVolumeFourPipeInduction::autosizeMaximumColdWaterFlowRate() {
774
1/1
✓ Branch 3 taken 8 times.
8 getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->autosizeMaximumColdWaterFlowRate();
775 8 }
776
777 8 bool AirTerminalSingleDuctConstantVolumeFourPipeInduction::setMinimumColdWaterFlowRate(double minimumColdWaterFlowRate) {
778
1/1
✓ Branch 3 taken 8 times.
8 return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->setMinimumColdWaterFlowRate(minimumColdWaterFlowRate);
779 }
780
781 ✗ void AirTerminalSingleDuctConstantVolumeFourPipeInduction::resetMinimumColdWaterFlowRate() {
782 ✗ getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->resetMinimumColdWaterFlowRate();
783 ✗ }
784
785 8 bool AirTerminalSingleDuctConstantVolumeFourPipeInduction::setCoolingConvergenceTolerance(double coolingConvergenceTolerance) {
786
1/1
✓ Branch 3 taken 8 times.
8 return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->setCoolingConvergenceTolerance(coolingConvergenceTolerance);
787 }
788
789 ✗ void AirTerminalSingleDuctConstantVolumeFourPipeInduction::resetCoolingConvergenceTolerance() {
790 ✗ getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->resetCoolingConvergenceTolerance();
791 ✗ }
792
793 11 boost::optional<Node> AirTerminalSingleDuctConstantVolumeFourPipeInduction::inducedAirInletNode() const {
794
1/1
✓ Branch 3 taken 11 times.
11 return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->inducedAirInletNode();
795 }
796
797 7 unsigned AirTerminalSingleDuctConstantVolumeFourPipeInduction::inducedAirInletPort() const {
798
1/1
✓ Branch 3 taken 7 times.
7 return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->inducedAirInletPort();
799 }
800
801 /// @cond
802 31 AirTerminalSingleDuctConstantVolumeFourPipeInduction::AirTerminalSingleDuctConstantVolumeFourPipeInduction(
803 31 std::shared_ptr<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl> impl)
804
1/1
✓ Branch 3 taken 31 times.
31 : StraightComponent(std::move(impl)) {}
805 /// @endcond
806
807 ✗ boost::optional<double> AirTerminalSingleDuctConstantVolumeFourPipeInduction::autosizedMaximumTotalAirFlowRate() const {
808 ✗ return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->autosizedMaximumTotalAirFlowRate();
809 }
810
811 ✗ boost::optional<double> AirTerminalSingleDuctConstantVolumeFourPipeInduction::autosizedMaximumHotWaterFlowRate() const {
812 ✗ return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->autosizedMaximumHotWaterFlowRate();
813 }
814
815 ✗ boost::optional<double> AirTerminalSingleDuctConstantVolumeFourPipeInduction::autosizedMaximumColdWaterFlowRate() const {
816 ✗ return getImpl<detail::AirTerminalSingleDuctConstantVolumeFourPipeInduction_Impl>()->autosizedMaximumColdWaterFlowRate();
817 }
818
819 } // namespace model
820 } // namespace openstudio
821