GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 66.2% 867 / 0 / 1309
Functions: 67.7% 218 / 0 / 322
Branches: 45.9% 605 / 0 / 1318

src/model/AirLoopHVACUnitarySystem.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 "AirLoopHVACUnitarySystem.hpp"
7 #include "AirLoopHVACUnitarySystem_Impl.hpp"
8
9 #include "ThermalZone.hpp"
10 #include "ThermalZone_Impl.hpp"
11 #include "Schedule.hpp"
12 #include "Schedule_Impl.hpp"
13 #include "Model.hpp"
14 #include "Model_Impl.hpp"
15 #include "HVACComponent.hpp"
16 #include "HVACComponent_Impl.hpp"
17 #include "Node.hpp"
18 #include "Node_Impl.hpp"
19 #include "PlantLoop.hpp"
20 #include "ScheduleTypeLimits.hpp"
21 #include "ScheduleTypeRegistry.hpp"
22 #include "UnitarySystemPerformanceMultispeed.hpp"
23 #include "UnitarySystemPerformanceMultispeed_Impl.hpp"
24
25 #include "../utilities/core/Assert.hpp"
26 #include "../utilities/data/DataEnums.hpp"
27 #include "../utilities/core/Compare.hpp"
28 #include "../utilities/core/Exception.hpp"
29
30 #include <utilities/idd/IddFactory.hxx>
31 #include <utilities/idd/OS_AirLoopHVAC_UnitarySystem_FieldEnums.hxx>
32 #include <utilities/idd/IddEnums.hxx>
33
34 // Remove when deprecated methods (maximumCyclingRate and co) are removed
35 #include "../utilities/core/DeprecatedHelpers.hpp"
36 #include "CoilCoolingDXVariableSpeed.hpp"
37 #include "CoilCoolingDXVariableSpeed_Impl.hpp"
38 #include "CoilCoolingWaterToAirHeatPumpEquationFit.hpp"
39 #include "CoilCoolingWaterToAirHeatPumpEquationFit_Impl.hpp"
40 #include "CoilCoolingWaterToAirHeatPumpVariableSpeedEquationFit.hpp"
41 #include "CoilCoolingWaterToAirHeatPumpVariableSpeedEquationFit_Impl.hpp"
42
43 namespace openstudio {
44 namespace model {
45
46 namespace detail {
47
48 114 AirLoopHVACUnitarySystem_Impl::AirLoopHVACUnitarySystem_Impl(const IdfObject& idfObject, Model_Impl* model, bool keepHandle)
49 114 : ZoneHVACComponent_Impl(idfObject, model, keepHandle) {
50
4/6
✓ Branch 1 taken 114 times.
✓ Branch 4 taken 114 times.
✓ Branch 7 taken 114 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 114 times.
✗ Branch 13 not taken.
114 OS_ASSERT(idfObject.iddObject().type() == AirLoopHVACUnitarySystem::iddObjectType());
51 114 }
52
53 17 AirLoopHVACUnitarySystem_Impl::AirLoopHVACUnitarySystem_Impl(const openstudio::detail::WorkspaceObject_Impl& other, Model_Impl* model,
54 17 bool keepHandle)
55 17 : ZoneHVACComponent_Impl(other, model, keepHandle) {
56
4/6
✓ Branch 1 taken 17 times.
✓ Branch 4 taken 17 times.
✓ Branch 7 taken 17 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 17 times.
✗ Branch 13 not taken.
17 OS_ASSERT(other.iddObject().type() == AirLoopHVACUnitarySystem::iddObjectType());
57 17 }
58
59 89 AirLoopHVACUnitarySystem_Impl::AirLoopHVACUnitarySystem_Impl(const AirLoopHVACUnitarySystem_Impl& other, Model_Impl* model, bool keepHandle)
60 89 : ZoneHVACComponent_Impl(other, model, keepHandle) {}
61
62 ✗ const std::vector<std::string>& AirLoopHVACUnitarySystem_Impl::outputVariableNames() const {
63 // TODO: make this non static, and do implement the test cases below
64 static const std::vector<std::string> result{
65 "Unitary System Fan Part Load Ratio", "Unitary System Compressor Part Load Ratio", "Unitary System Total Cooling Rate",
66 "Unitary System Total Heating Rate", "Unitary System Sensible Cooling Rate", "Unitary System Sensible Heating Rate",
67 "Unitary System Latent Cooling Rate", "Unitary System Latent Heating Rate", "Unitary System Ancillary Electricity Rate",
68
69 // Load based and SingleZoneVAV control outputs
70 "Unitary System Predicted Sensible Load to Setpoint Heat Transfer Rate",
71 "Unitary System Predicted Moisture Load to Setpoint Heat Transfer Rate",
72
73 // Two speed coil outputs
74 "Unitary System Cycling Ratio", "Unitary System Compressor Speed Ratio",
75
76 // Multi speed coil outputs
77 "Unitary System DX Coil Cycling Ratio", "Unitary System DX Coil Speed Ratio", "Unitary System DX Coil Speed Level",
78 "Unitary System Electricity Rate", "Unitary System Electricity Energy", "Unitary System Cooling Ancillary Electricity Energy",
79 "Unitary System Heating Ancillary Electricity Energy",
80
81 // Multi speed coil outputs(If heat recovery is specified)
82 "Unitary System Heat Recovery Rate", "Unitary System Heat Recovery Inlet Temperature", "Unitary System Heat Recovery Outlet Temperature",
83 "Unitary System Heat Recovery Fluid Mass Flow Rate", "Unitary System Heat Recovery Energy",
84
85 // Variable speed coils
86 "Unitary System Requested Sensible Cooling Rate", "Unitary System Requested Latent Cooling Rate",
87
88 // Water to air heat pump outputs
89 "Unitary System Requested Sensible Cooling Rate", "Unitary System Requested Latent Cooling Rate", "Unitary System Requested Heating Rate",
90 ✗ "Unitary System Water Coil Cycling Ratio", "Unitary System Water Coil Speed Ratio", "Unitary System Water Coil Speed Level"};
91 ✗ return result;
92 ✗ }
93
94 32 IddObjectType AirLoopHVACUnitarySystem_Impl::iddObjectType() const {
95 32 return AirLoopHVACUnitarySystem::iddObjectType();
96 }
97
98 ✗ std::vector<ScheduleTypeKey> AirLoopHVACUnitarySystem_Impl::getScheduleTypeKeys(const Schedule& schedule) const {
99 ✗ std::vector<ScheduleTypeKey> result;
100 ✗ const UnsignedVector fieldIndices = getSourceIndices(schedule.handle());
101 ✗ const auto b = fieldIndices.cbegin();
102 ✗ const auto e = fieldIndices.cend();
103 ✗ if (std::find(b, e, OS_AirLoopHVAC_UnitarySystemFields::AvailabilityScheduleName) != e) {
104 ✗ result.emplace_back("AirLoopHVACUnitarySystem", "Availability");
105 }
106 ✗ if (std::find(b, e, OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFanOperatingModeScheduleName) != e) {
107 ✗ result.emplace_back("AirLoopHVACUnitarySystem", "Supply Air Fan Operating Mode");
108 }
109 ✗ return result;
110 ✗ }
111
112 8 ModelObject AirLoopHVACUnitarySystem_Impl::clone(Model model) const {
113 // Mimic what StraightComponent_Impl::clone would do (we inherit ZoneHVACComponent here...)
114
3/3
✓ Branch 1 taken 8 times.
✓ Branch 4 taken 8 times.
✓ Branch 7 taken 8 times.
8 auto modelObjectClone = ModelObject_Impl::clone(model).cast<AirLoopHVACUnitarySystem>(); // NOLINT(bugprone-parent-virtual-call)
115
3/3
✓ Branch 1 taken 8 times.
✓ Branch 4 taken 8 times.
✓ Branch 7 taken 8 times.
16 modelObjectClone.setString(modelObjectClone.inletPort(), "");
116
3/3
✓ Branch 1 taken 8 times.
✓ Branch 4 taken 8 times.
✓ Branch 7 taken 8 times.
8 modelObjectClone.setString(modelObjectClone.outletPort(), "");
117
118
3/3
✓ Branch 1 taken 8 times.
✓ Branch 3 taken 4 times.
✓ Branch 4 taken 4 times.
16 if (boost::optional<HVACComponent> supplyFan = this->supplyFan()) {
119
5/5
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
✓ Branch 7 taken 4 times.
✓ Branch 10 taken 4 times.
✓ Branch 13 taken 4 times.
4 modelObjectClone.setSupplyFan(supplyFan->clone(model).cast<HVACComponent>());
120 8 }
121
3/3
✓ Branch 1 taken 8 times.
✓ Branch 3 taken 6 times.
✓ Branch 4 taken 2 times.
16 if (boost::optional<HVACComponent> coolingCoil = this->coolingCoil()) {
122
5/5
✓ Branch 1 taken 6 times.
✓ Branch 4 taken 6 times.
✓ Branch 7 taken 6 times.
✓ Branch 10 taken 6 times.
✓ Branch 13 taken 6 times.
6 modelObjectClone.setCoolingCoil(coolingCoil->clone(model).cast<HVACComponent>());
123 8 }
124
3/3
✓ Branch 1 taken 8 times.
✓ Branch 3 taken 4 times.
✓ Branch 4 taken 4 times.
16 if (boost::optional<HVACComponent> heatingCoil = this->heatingCoil()) {
125
5/5
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
✓ Branch 7 taken 4 times.
✓ Branch 10 taken 4 times.
✓ Branch 13 taken 4 times.
4 modelObjectClone.setHeatingCoil(heatingCoil->clone(model).cast<HVACComponent>());
126 8 }
127
3/3
✓ Branch 1 taken 8 times.
✓ Branch 3 taken 4 times.
✓ Branch 4 taken 4 times.
16 if (boost::optional<HVACComponent> supplementalHeatingCoil = this->supplementalHeatingCoil()) {
128
5/5
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
✓ Branch 7 taken 4 times.
✓ Branch 10 taken 4 times.
✓ Branch 13 taken 4 times.
4 modelObjectClone.setSupplementalHeatingCoil(supplementalHeatingCoil->clone(model).cast<HVACComponent>());
129 8 }
130
2/3
✓ Branch 1 taken 8 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 8 times.
16 if (auto designSpec = designSpecificationMultispeedObject()) {
131 ✗ modelObjectClone.setDesignSpecificationMultispeedObject(designSpec->clone(model).cast<UnitarySystemPerformanceMultispeed>());
132 8 }
133
134 16 return std::move(modelObjectClone);
135 8 }
136
137 76 std::vector<ModelObject> AirLoopHVACUnitarySystem_Impl::children() const {
138 76 std::vector<ModelObject> result;
139
140
3/3
✓ Branch 1 taken 76 times.
✓ Branch 3 taken 26 times.
✓ Branch 4 taken 50 times.
152 if (boost::optional<HVACComponent> supplyFan = this->supplyFan()) {
141
2/2
✓ Branch 1 taken 26 times.
✓ Branch 4 taken 26 times.
26 result.push_back(*supplyFan);
142 76 }
143
3/3
✓ Branch 1 taken 76 times.
✓ Branch 3 taken 53 times.
✓ Branch 4 taken 23 times.
152 if (boost::optional<HVACComponent> coolingCoil = this->coolingCoil()) {
144
2/2
✓ Branch 1 taken 53 times.
✓ Branch 4 taken 53 times.
53 result.push_back(*coolingCoil);
145 76 }
146
3/3
✓ Branch 1 taken 76 times.
✓ Branch 3 taken 38 times.
✓ Branch 4 taken 38 times.
152 if (boost::optional<HVACComponent> heatingCoil = this->heatingCoil()) {
147
2/2
✓ Branch 1 taken 38 times.
✓ Branch 4 taken 38 times.
38 result.push_back(*heatingCoil);
148 76 }
149
3/3
✓ Branch 1 taken 76 times.
✓ Branch 3 taken 22 times.
✓ Branch 4 taken 54 times.
152 if (boost::optional<HVACComponent> supplementalHeatingCoil = this->supplementalHeatingCoil()) {
150
2/2
✓ Branch 1 taken 22 times.
✓ Branch 4 taken 22 times.
22 result.push_back(*supplementalHeatingCoil);
151 76 }
152
3/3
✓ Branch 1 taken 76 times.
✓ Branch 3 taken 11 times.
✓ Branch 4 taken 65 times.
152 if (auto designSpec = designSpecificationMultispeedObject()) {
153
2/2
✓ Branch 1 taken 11 times.
✓ Branch 4 taken 11 times.
11 result.push_back(*designSpec);
154 76 }
155
156 76 return result;
157 ✗ }
158
159 3 std::vector<IdfObject> AirLoopHVACUnitarySystem_Impl::remove() {
160 3 std::vector<IdfObject> result;
161
162
3/3
✓ Branch 1 taken 3 times.
✓ Branch 3 taken 2 times.
✓ Branch 4 taken 1 time.
6 if (boost::optional<HVACComponent> _supplyFan = this->supplyFan()) {
163
2/2
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
2 std::vector<IdfObject> removedFans = _supplyFan->remove();
164
1/1
✓ Branch 5 taken 2 times.
2 result.insert(result.end(), removedFans.begin(), removedFans.end());
165 5 }
166
167
3/3
✓ Branch 1 taken 3 times.
✓ Branch 3 taken 2 times.
✓ Branch 4 taken 1 time.
6 if (boost::optional<HVACComponent> _coolingCoil = this->coolingCoil()) {
168
3/4
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 2 times.
4 if (boost::optional<PlantLoop> loop = _coolingCoil->plantLoop()) {
169 ✗ loop->removeDemandBranchWithComponent(*_coolingCoil);
170 2 }
171
2/2
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
2 std::vector<IdfObject> removedCoolingCoils = _coolingCoil->remove();
172
1/1
✓ Branch 5 taken 2 times.
2 result.insert(result.end(), removedCoolingCoils.begin(), removedCoolingCoils.end());
173 5 }
174
175
3/3
✓ Branch 1 taken 3 times.
✓ Branch 3 taken 2 times.
✓ Branch 4 taken 1 time.
6 if (boost::optional<HVACComponent> _heatingCoil = this->heatingCoil()) {
176
4/4
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
✓ Branch 6 taken 1 time.
✓ Branch 7 taken 1 time.
4 if (boost::optional<PlantLoop> loop = _heatingCoil->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(*_heatingCoil);
178 2 }
179
2/2
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
2 std::vector<IdfObject> removedHeatingCoils = _heatingCoil->remove();
180
1/1
✓ Branch 5 taken 2 times.
2 result.insert(result.end(), removedHeatingCoils.begin(), removedHeatingCoils.end());
181 5 }
182
183
3/3
✓ Branch 1 taken 3 times.
✓ Branch 3 taken 2 times.
✓ Branch 4 taken 1 time.
6 if (boost::optional<HVACComponent> _supplementalHeatingCoil = this->supplementalHeatingCoil()) {
184
4/4
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
✓ Branch 6 taken 1 time.
✓ Branch 7 taken 1 time.
4 if (boost::optional<PlantLoop> loop = _supplementalHeatingCoil->plantLoop()) {
185
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(*_supplementalHeatingCoil);
186 2 }
187
2/2
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
2 std::vector<IdfObject> removedSuppHeatingCoils = _supplementalHeatingCoil->remove();
188
1/1
✓ Branch 5 taken 2 times.
2 result.insert(result.end(), removedSuppHeatingCoils.begin(), removedSuppHeatingCoils.end());
189 5 }
190
191
2/3
✓ Branch 1 taken 3 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3 times.
6 if (auto designSpec = designSpecificationMultispeedObject()) {
192 ✗ auto removed = designSpec->remove();
193 ✗ result.insert(result.end(), removed.begin(), removed.end());
194 3 }
195
196
1/1
✓ Branch 1 taken 3 times.
3 std::vector<IdfObject> removedUnitarySystem = ZoneHVACComponent_Impl::remove();
197
1/1
✓ Branch 5 taken 3 times.
3 result.insert(result.end(), removedUnitarySystem.begin(), removedUnitarySystem.end());
198
199 6 return result;
200 3 }
201
202 76 bool AirLoopHVACUnitarySystem_Impl::addToNode(Node& node) {
203 76 bool result = ZoneHVACComponent_Impl::addToNode(node);
204
205
1/2
✓ Branch 0 taken 76 times.
✗ Branch 1 not taken.
76 if (!result) {
206
1/1
✓ Branch 1 taken 76 times.
76 auto _model = node.model();
207
1/1
✓ Branch 1 taken 76 times.
76 auto thisModelObject = getObject<ModelObject>();
208
1/1
✓ Branch 1 taken 76 times.
76 auto t_airLoop = node.airLoopHVAC();
209
1/1
✓ Branch 1 taken 76 times.
76 auto t_oaSystem = node.airLoopHVACOutdoorAirSystem();
210
211 76 boost::optional<unsigned> componentInletPort;
212 76 boost::optional<unsigned> componentOutletPort;
213
214 76 boost::optional<HVACComponent> systemStartComponent;
215 76 boost::optional<HVACComponent> systemEndComponent;
216
217
3/3
✓ Branch 3 taken 76 times.
✓ Branch 6 taken 1 time.
✓ Branch 7 taken 75 times.
76 if (node.getImpl<Node_Impl>()->isConnected(thisModelObject)) {
218 1 return false;
219 }
220
221
5/6
✓ Branch 0 taken 71 times.
✓ Branch 1 taken 4 times.
✓ Branch 3 taken 71 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 71 times.
✓ Branch 6 taken 4 times.
75 if (t_airLoop && !t_oaSystem) {
222
5/5
✓ Branch 1 taken 71 times.
✓ Branch 4 taken 71 times.
✓ Branch 7 taken 71 times.
✓ Branch 10 taken 1 time.
✓ Branch 11 taken 70 times.
142 if (t_airLoop->demandComponent(node.handle())) {
223 1 return false;
224 }
225
226
3/3
✓ Branch 1 taken 70 times.
✓ Branch 4 taken 70 times.
✓ Branch 7 taken 70 times.
70 systemStartComponent = t_airLoop->supplyInletNode();
227
2/2
✓ Branch 1 taken 70 times.
✓ Branch 4 taken 70 times.
70 auto nodes = t_airLoop->supplyOutletNodes();
228
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 70 times.
✗ Branch 4 not taken.
70 OS_ASSERT(!nodes.empty());
229
5/22
✗ Branch 1 not taken.
✓ Branch 2 taken 70 times.
✗ Branch 4 not taken.
✗ Branch 7 not taken.
✗ Branch 10 not taken.
✗ Branch 14 not taken.
✗ Branch 17 not taken.
✗ Branch 18 not taken.
✗ Branch 19 not taken.
✓ Branch 20 taken 70 times.
✗ Branch 22 not taken.
✓ Branch 23 taken 70 times.
✗ Branch 25 not taken.
✓ Branch 26 taken 70 times.
✗ Branch 27 not taken.
✓ Branch 28 taken 70 times.
✗ Branch 29 not taken.
✗ Branch 30 not taken.
✗ Branch 32 not taken.
✗ Branch 33 not taken.
✗ Branch 35 not taken.
✗ Branch 36 not taken.
70 if ((nodes.size() == 2u) && (!t_airLoop->supplyComponents(node, nodes[1]).empty())) {
230 ✗ systemEndComponent = nodes[1];
231 } else {
232
1/1
✓ Branch 2 taken 70 times.
70 systemEndComponent = nodes[0];
233 }
234
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 70 times.
✗ Branch 4 not taken.
70 OS_ASSERT(systemEndComponent);
235
2/2
✓ Branch 1 taken 70 times.
✓ Branch 4 taken 70 times.
70 componentInletPort = inletPort();
236
2/2
✓ Branch 1 taken 70 times.
✓ Branch 4 taken 70 times.
70 componentOutletPort = outletPort();
237
238
1/1
✓ Branch 1 taken 70 times.
70 removeFromAirLoopHVAC();
239
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
74 } else if (t_oaSystem) {
240 ✗ if (t_oaSystem->oaComponent(node.handle())) {
241 ✗ systemStartComponent = t_oaSystem->outboardOANode();
242 ✗ systemEndComponent = t_oaSystem.get();
243 ✗ componentInletPort = inletPort();
244 ✗ componentOutletPort = outletPort();
245 ✗ } else if (t_oaSystem->reliefComponent(node.handle())) {
246 ✗ systemStartComponent = t_oaSystem.get();
247 ✗ systemEndComponent = t_oaSystem->outboardReliefNode();
248 ✗ componentInletPort = inletPort();
249 ✗ componentOutletPort = outletPort();
250 }
251 ✗ removeFromAirLoopHVAC();
252 }
253
254
7/10
✓ Branch 0 taken 70 times.
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 70 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 70 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 70 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 70 times.
✓ Branch 9 taken 4 times.
284 if (systemStartComponent && systemEndComponent && componentOutletPort && componentInletPort) {
255
3/3
✓ Branch 1 taken 70 times.
✓ Branch 4 taken 70 times.
✓ Branch 7 taken 70 times.
70 result = HVACComponent_Impl::addToNode(node, systemStartComponent.get(), systemEndComponent.get(), componentInletPort.get(),
256
2/2
✓ Branch 1 taken 70 times.
✓ Branch 4 taken 70 times.
70 componentOutletPort.get());
257 }
258 86 }
259
260 74 return result;
261 }
262
263 358 unsigned AirLoopHVACUnitarySystem_Impl::inletPort() const {
264 358 return OS_AirLoopHVAC_UnitarySystemFields::AirInletNodeName;
265 }
266
267 636 unsigned AirLoopHVACUnitarySystem_Impl::outletPort() const {
268 636 return OS_AirLoopHVAC_UnitarySystemFields::AirOutletNodeName;
269 }
270
271 75 std::string AirLoopHVACUnitarySystem_Impl::controlType() const {
272
1/1
✓ Branch 1 taken 75 times.
75 boost::optional<std::string> value = getString(OS_AirLoopHVAC_UnitarySystemFields::ControlType, true);
273
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 75 times.
✗ Branch 4 not taken.
75 OS_ASSERT(value);
274
2/2
✓ Branch 1 taken 75 times.
✓ Branch 4 taken 75 times.
150 return value.get();
275 75 }
276
277 3 bool AirLoopHVACUnitarySystem_Impl::isControlTypeDefaulted() const {
278 3 return isEmpty(OS_AirLoopHVAC_UnitarySystemFields::ControlType);
279 }
280
281 73 boost::optional<ThermalZone> AirLoopHVACUnitarySystem_Impl::controllingZoneorThermostatLocation() const {
282
2/2
✓ Branch 1 taken 73 times.
✓ Branch 4 taken 73 times.
73 return getObject<ModelObject>().getModelObjectTarget<ThermalZone>(OS_AirLoopHVAC_UnitarySystemFields::ControllingZoneorThermostatLocation);
283 }
284
285 75 std::string AirLoopHVACUnitarySystem_Impl::dehumidificationControlType() const {
286
1/1
✓ Branch 1 taken 75 times.
75 boost::optional<std::string> value = getString(OS_AirLoopHVAC_UnitarySystemFields::DehumidificationControlType, true);
287
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 75 times.
✗ Branch 4 not taken.
75 OS_ASSERT(value);
288
2/2
✓ Branch 1 taken 75 times.
✓ Branch 4 taken 75 times.
150 return value.get();
289 75 }
290
291 ✗ bool AirLoopHVACUnitarySystem_Impl::isDehumidificationControlTypeDefaulted() const {
292 ✗ return isEmpty(OS_AirLoopHVAC_UnitarySystemFields::DehumidificationControlType);
293 }
294
295 73 boost::optional<Schedule> AirLoopHVACUnitarySystem_Impl::availabilitySchedule() const {
296
2/2
✓ Branch 1 taken 73 times.
✓ Branch 4 taken 73 times.
73 return getObject<ModelObject>().getModelObjectTarget<Schedule>(OS_AirLoopHVAC_UnitarySystemFields::AvailabilityScheduleName);
297 }
298
299 173 boost::optional<HVACComponent> AirLoopHVACUnitarySystem_Impl::supplyFan() const {
300
2/2
✓ Branch 1 taken 173 times.
✓ Branch 4 taken 173 times.
173 return getObject<ModelObject>().getModelObjectTarget<HVACComponent>(OS_AirLoopHVAC_UnitarySystemFields::SupplyFanName);
301 }
302
303 74 boost::optional<std::string> AirLoopHVACUnitarySystem_Impl::fanPlacement() const {
304 // No default, and return uninitialized if empty
305 74 return getString(OS_AirLoopHVAC_UnitarySystemFields::FanPlacement, false, true);
306 }
307
308 73 boost::optional<Schedule> AirLoopHVACUnitarySystem_Impl::supplyAirFanOperatingModeSchedule() const {
309
2/2
✓ Branch 1 taken 73 times.
✓ Branch 4 taken 73 times.
73 return getObject<ModelObject>().getModelObjectTarget<Schedule>(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFanOperatingModeScheduleName);
310 }
311
312 2 bool AirLoopHVACUnitarySystem_Impl::hasHeatingCoil() const {
313 2 return !isEmpty(OS_AirLoopHVAC_UnitarySystemFields::HeatingCoilName);
314 }
315
316 225 boost::optional<HVACComponent> AirLoopHVACUnitarySystem_Impl::heatingCoil() const {
317
2/2
✓ Branch 1 taken 225 times.
✓ Branch 4 taken 225 times.
225 return getObject<ModelObject>().getModelObjectTarget<HVACComponent>(OS_AirLoopHVAC_UnitarySystemFields::HeatingCoilName);
318 }
319
320 75 double AirLoopHVACUnitarySystem_Impl::dXHeatingCoilSizingRatio() const {
321
1/1
✓ Branch 1 taken 75 times.
75 boost::optional<double> value = getDouble(OS_AirLoopHVAC_UnitarySystemFields::DXHeatingCoilSizingRatio, true);
322
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 75 times.
✗ Branch 4 not taken.
75 OS_ASSERT(value);
323
1/1
✓ Branch 1 taken 75 times.
150 return value.get();
324 }
325
326 ✗ bool AirLoopHVACUnitarySystem_Impl::isDXHeatingCoilSizingRatioDefaulted() const {
327 ✗ return isEmpty(OS_AirLoopHVAC_UnitarySystemFields::DXHeatingCoilSizingRatio);
328 }
329
330 2 bool AirLoopHVACUnitarySystem_Impl::hasCoolingCoil() const {
331 2 return !isEmpty(OS_AirLoopHVAC_UnitarySystemFields::CoolingCoilName);
332 }
333
334 268 boost::optional<HVACComponent> AirLoopHVACUnitarySystem_Impl::coolingCoil() const {
335
2/2
✓ Branch 1 taken 268 times.
✓ Branch 4 taken 268 times.
268 return getObject<ModelObject>().getModelObjectTarget<HVACComponent>(OS_AirLoopHVAC_UnitarySystemFields::CoolingCoilName);
336 }
337
338 75 bool AirLoopHVACUnitarySystem_Impl::useDOASDXCoolingCoil() const {
339
1/1
✓ Branch 1 taken 75 times.
75 boost::optional<std::string> value = getString(OS_AirLoopHVAC_UnitarySystemFields::UseDOASDXCoolingCoil, true);
340
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 75 times.
✗ Branch 4 not taken.
75 OS_ASSERT(value);
341
3/3
✓ Branch 1 taken 75 times.
✓ Branch 4 taken 75 times.
✓ Branch 7 taken 75 times.
150 return openstudio::istringEqual(value.get(), "Yes");
342 75 }
343
344 ✗ bool AirLoopHVACUnitarySystem_Impl::isUseDOASDXCoolingCoilDefaulted() const {
345 ✗ return isEmpty(OS_AirLoopHVAC_UnitarySystemFields::UseDOASDXCoolingCoil);
346 }
347
348 75 double AirLoopHVACUnitarySystem_Impl::dOASDXCoolingCoilLeavingMinimumAirTemperature() const {
349
1/1
✓ Branch 1 taken 75 times.
75 boost::optional<double> value = getDouble(OS_AirLoopHVAC_UnitarySystemFields::DOASDXCoolingCoilLeavingMinimumAirTemperature, true);
350
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 75 times.
✗ Branch 4 not taken.
75 OS_ASSERT(value);
351
1/1
✓ Branch 1 taken 75 times.
150 return value.get();
352 }
353
354 3 bool AirLoopHVACUnitarySystem_Impl::isDOASDXCoolingCoilLeavingMinimumAirTemperatureDefaulted() const {
355 3 return isEmpty(OS_AirLoopHVAC_UnitarySystemFields::DOASDXCoolingCoilLeavingMinimumAirTemperature);
356 }
357
358 76 bool AirLoopHVACUnitarySystem_Impl::isDOASDXCoolingCoilLeavingMinimumAirTemperatureAutosized() const {
359 76 bool result = false;
360
1/1
✓ Branch 1 taken 76 times.
76 boost::optional<std::string> value = getString(OS_AirLoopHVAC_UnitarySystemFields::DOASDXCoolingCoilLeavingMinimumAirTemperature, true);
361
1/2
✓ Branch 0 taken 76 times.
✗ Branch 1 not taken.
76 if (value) {
362
3/3
✓ Branch 1 taken 76 times.
✓ Branch 4 taken 76 times.
✓ Branch 7 taken 76 times.
152 result = openstudio::istringEqual(value.get(), "Autosize");
363 }
364 76 return result;
365 76 }
366
367 75 std::string AirLoopHVACUnitarySystem_Impl::latentLoadControl() const {
368
1/1
✓ Branch 1 taken 75 times.
75 boost::optional<std::string> value = getString(OS_AirLoopHVAC_UnitarySystemFields::LatentLoadControl, true);
369
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 75 times.
✗ Branch 4 not taken.
75 OS_ASSERT(value);
370
2/2
✓ Branch 1 taken 75 times.
✓ Branch 4 taken 75 times.
150 return value.get();
371 75 }
372
373 ✗ bool AirLoopHVACUnitarySystem_Impl::isLatentLoadControlDefaulted() const {
374 ✗ return isEmpty(OS_AirLoopHVAC_UnitarySystemFields::LatentLoadControl);
375 }
376
377 178 boost::optional<HVACComponent> AirLoopHVACUnitarySystem_Impl::supplementalHeatingCoil() const {
378
2/2
✓ Branch 1 taken 178 times.
✓ Branch 4 taken 178 times.
178 return getObject<ModelObject>().getModelObjectTarget<HVACComponent>(OS_AirLoopHVAC_UnitarySystemFields::SupplementalHeatingCoilName);
379 }
380
381 131 std::string AirLoopHVACUnitarySystem_Impl::supplyAirFlowRateMethodDuringCoolingOperation() const {
382
1/1
✓ Branch 1 taken 131 times.
131 boost::optional<std::string> value = getString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringCoolingOperation, true);
383
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 131 times.
✗ Branch 4 not taken.
131 OS_ASSERT(value);
384
2/2
✓ Branch 1 taken 131 times.
✓ Branch 4 taken 131 times.
262 return value.get();
385 131 }
386
387 21 boost::optional<double> AirLoopHVACUnitarySystem_Impl::supplyAirFlowRateDuringCoolingOperation() const {
388 21 return getDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringCoolingOperation, true);
389 }
390
391 60 bool AirLoopHVACUnitarySystem_Impl::isSupplyAirFlowRateDuringCoolingOperationAutosized() const {
392 60 bool result = false;
393
1/1
✓ Branch 1 taken 60 times.
60 boost::optional<std::string> value = getString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringCoolingOperation, true);
394
1/2
✓ Branch 0 taken 60 times.
✗ Branch 1 not taken.
60 if (value) {
395
3/3
✓ Branch 1 taken 60 times.
✓ Branch 4 taken 60 times.
✓ Branch 7 taken 60 times.
120 result = openstudio::istringEqual(value.get(), "Autosize");
396 }
397 60 return result;
398 60 }
399
400 59 boost::optional<double> AirLoopHVACUnitarySystem_Impl::supplyAirFlowRatePerFloorAreaDuringCoolingOperation() const {
401 59 return getDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaDuringCoolingOperation, true);
402 }
403
404 59 boost::optional<double> AirLoopHVACUnitarySystem_Impl::fractionofAutosizedDesignCoolingSupplyAirFlowRate() const {
405 59 return getDouble(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignCoolingSupplyAirFlowRate, true);
406 }
407
408 59 boost::optional<double> AirLoopHVACUnitarySystem_Impl::designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation() const {
409 59 return getDouble(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation, true);
410 }
411
412 102 std::string AirLoopHVACUnitarySystem_Impl::supplyAirFlowRateMethodDuringHeatingOperation() const {
413
1/1
✓ Branch 1 taken 102 times.
102 boost::optional<std::string> value = getString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringHeatingOperation, true);
414
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 102 times.
✗ Branch 4 not taken.
102 OS_ASSERT(value);
415
2/2
✓ Branch 1 taken 102 times.
✓ Branch 4 taken 102 times.
204 return value.get();
416 102 }
417
418 21 boost::optional<double> AirLoopHVACUnitarySystem_Impl::supplyAirFlowRateDuringHeatingOperation() const {
419 21 return getDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringHeatingOperation, true);
420 }
421
422 45 bool AirLoopHVACUnitarySystem_Impl::isSupplyAirFlowRateDuringHeatingOperationAutosized() const {
423 45 bool result = false;
424
1/1
✓ Branch 1 taken 45 times.
45 boost::optional<std::string> value = getString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringHeatingOperation, true);
425
1/2
✓ Branch 0 taken 45 times.
✗ Branch 1 not taken.
45 if (value) {
426
3/3
✓ Branch 1 taken 45 times.
✓ Branch 4 taken 45 times.
✓ Branch 7 taken 45 times.
90 result = openstudio::istringEqual(value.get(), "Autosize");
427 }
428 45 return result;
429 45 }
430
431 44 boost::optional<double> AirLoopHVACUnitarySystem_Impl::supplyAirFlowRatePerFloorAreaduringHeatingOperation() const {
432 44 return getDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaduringHeatingOperation, true);
433 }
434
435 44 boost::optional<double> AirLoopHVACUnitarySystem_Impl::fractionofAutosizedDesignHeatingSupplyAirFlowRate() const {
436 44 return getDouble(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignHeatingSupplyAirFlowRate, true);
437 }
438
439 44 boost::optional<double> AirLoopHVACUnitarySystem_Impl::designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation() const {
440 44 return getDouble(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation, true);
441 }
442
443 85 std::string AirLoopHVACUnitarySystem_Impl::supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired() const {
444 boost::optional<std::string> value =
445
1/1
✓ Branch 1 taken 85 times.
85 getString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired, true);
446
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 85 times.
✗ Branch 4 not taken.
85 OS_ASSERT(value);
447
2/2
✓ Branch 1 taken 85 times.
✓ Branch 4 taken 85 times.
170 return value.get();
448 85 }
449
450 84 boost::optional<double> AirLoopHVACUnitarySystem_Impl::supplyAirFlowRateWhenNoCoolingorHeatingisRequired() const {
451 84 return getDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateWhenNoCoolingorHeatingisRequired, true);
452 }
453
454 85 bool AirLoopHVACUnitarySystem_Impl::isSupplyAirFlowRateWhenNoCoolingorHeatingisRequiredAutosized() const {
455 85 bool result = false;
456
1/1
✓ Branch 1 taken 85 times.
85 boost::optional<std::string> value = getString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateWhenNoCoolingorHeatingisRequired, true);
457
1/2
✓ Branch 0 taken 85 times.
✗ Branch 1 not taken.
85 if (value) {
458
3/3
✓ Branch 1 taken 85 times.
✓ Branch 4 taken 85 times.
✓ Branch 7 taken 85 times.
170 result = openstudio::istringEqual(value.get(), "Autosize");
459 }
460 85 return result;
461 85 }
462
463 84 boost::optional<double> AirLoopHVACUnitarySystem_Impl::supplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired() const {
464 84 return getDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired, true);
465 }
466
467 84 boost::optional<double> AirLoopHVACUnitarySystem_Impl::fractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired() const {
468 84 return getDouble(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired, true);
469 }
470
471 84 boost::optional<double> AirLoopHVACUnitarySystem_Impl::fractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired() const {
472 84 return getDouble(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired, true);
473 }
474
475 boost::optional<double>
476 84 AirLoopHVACUnitarySystem_Impl::designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired() const {
477 84 return getDouble(
478 84 OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired, true);
479 }
480
481 boost::optional<double>
482 84 AirLoopHVACUnitarySystem_Impl::designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired() const {
483 84 return getDouble(
484 84 OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired, true);
485 }
486
487 75 bool AirLoopHVACUnitarySystem_Impl::noLoadSupplyAirFlowRateControlSetToLowSpeed() const {
488 75 return getBooleanFieldValue(OS_AirLoopHVAC_UnitarySystemFields::NoLoadSupplyAirFlowRateControlSetToLowSpeed);
489 }
490
491 74 boost::optional<double> AirLoopHVACUnitarySystem_Impl::maximumSupplyAirTemperature() const {
492 74 return getDouble(OS_AirLoopHVAC_UnitarySystemFields::MaximumSupplyAirTemperature, true);
493 }
494
495 ✗ bool AirLoopHVACUnitarySystem_Impl::isMaximumSupplyAirTemperatureDefaulted() const {
496 ✗ return isEmpty(OS_AirLoopHVAC_UnitarySystemFields::MaximumSupplyAirTemperature);
497 }
498
499 74 bool AirLoopHVACUnitarySystem_Impl::isMaximumSupplyAirTemperatureAutosized() const {
500 74 bool result = false;
501
1/1
✓ Branch 1 taken 74 times.
74 boost::optional<std::string> value = getString(OS_AirLoopHVAC_UnitarySystemFields::MaximumSupplyAirTemperature, true);
502
1/2
✓ Branch 0 taken 74 times.
✗ Branch 1 not taken.
74 if (value) {
503
3/3
✓ Branch 1 taken 74 times.
✓ Branch 4 taken 74 times.
✓ Branch 7 taken 74 times.
148 result = openstudio::istringEqual(value.get(), "Autosize");
504 }
505 74 return result;
506 74 }
507
508 75 double AirLoopHVACUnitarySystem_Impl::maximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation() const {
509 boost::optional<double> value =
510
1/1
✓ Branch 1 taken 75 times.
75 getDouble(OS_AirLoopHVAC_UnitarySystemFields::MaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation, true);
511
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 75 times.
✗ Branch 4 not taken.
75 OS_ASSERT(value);
512
1/1
✓ Branch 1 taken 75 times.
150 return value.get();
513 }
514
515 ✗ bool AirLoopHVACUnitarySystem_Impl::isMaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperationDefaulted() const {
516 ✗ return isEmpty(OS_AirLoopHVAC_UnitarySystemFields::MaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation);
517 }
518
519 73 boost::optional<std::string> AirLoopHVACUnitarySystem_Impl::outdoorDryBulbTemperatureSensorNodeName() const {
520 73 return getString(OS_AirLoopHVAC_UnitarySystemFields::OutdoorDryBulbTemperatureSensorNodeName, true);
521 }
522
523 75 double AirLoopHVACUnitarySystem_Impl::ancilliaryOnCycleElectricPower() const {
524
1/1
✓ Branch 1 taken 75 times.
75 boost::optional<double> value = getDouble(OS_AirLoopHVAC_UnitarySystemFields::AncilliaryOnCycleElectricPower, true);
525
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 75 times.
✗ Branch 4 not taken.
75 OS_ASSERT(value);
526
1/1
✓ Branch 1 taken 75 times.
150 return value.get();
527 }
528
529 ✗ bool AirLoopHVACUnitarySystem_Impl::isAncilliaryOnCycleElectricPowerDefaulted() const {
530 ✗ return isEmpty(OS_AirLoopHVAC_UnitarySystemFields::AncilliaryOnCycleElectricPower);
531 }
532
533 75 double AirLoopHVACUnitarySystem_Impl::ancilliaryOffCycleElectricPower() const {
534
1/1
✓ Branch 1 taken 75 times.
75 boost::optional<double> value = getDouble(OS_AirLoopHVAC_UnitarySystemFields::AncilliaryOffCycleElectricPower, true);
535
1/3
✗ Branch 1 not taken.
✓ Branch 2 taken 75 times.
✗ Branch 4 not taken.
75 OS_ASSERT(value);
536
1/1
✓ Branch 1 taken 75 times.
150 return value.get();
537 }
538
539 ✗ bool AirLoopHVACUnitarySystem_Impl::isAncilliaryOffCycleElectricPowerDefaulted() const {
540 ✗ return isEmpty(OS_AirLoopHVAC_UnitarySystemFields::AncilliaryOffCycleElectricPower);
541 }
542
543 // double AirLoopHVACUnitarySystem_Impl::designHeatRecoveryWaterFlowRate() const {
544 // boost::optional<double> value = getDouble(OS_AirLoopHVAC_UnitarySystemFields::DesignHeatRecoveryWaterFlowRate,true);
545 // OS_ASSERT(value);
546 // return value.get();
547 // }
548
549 // bool AirLoopHVACUnitarySystem_Impl::isDesignHeatRecoveryWaterFlowRateDefaulted() const {
550 // return isEmpty(OS_AirLoopHVAC_UnitarySystemFields::DesignHeatRecoveryWaterFlowRate);
551 // }
552
553 // double AirLoopHVACUnitarySystem_Impl::maximumTemperatureforHeatRecovery() const {
554 // boost::optional<double> value = getDouble(OS_AirLoopHVAC_UnitarySystemFields::MaximumTemperatureforHeatRecovery,true);
555 // OS_ASSERT(value);
556 // return value.get();
557 // }
558
559 // bool AirLoopHVACUnitarySystem_Impl::isMaximumTemperatureforHeatRecoveryDefaulted() const {
560 // return isEmpty(OS_AirLoopHVAC_UnitarySystemFields::MaximumTemperatureforHeatRecovery);
561 // }
562
563 163 boost::optional<UnitarySystemPerformanceMultispeed> AirLoopHVACUnitarySystem_Impl::designSpecificationMultispeedObject() const {
564
1/1
✓ Branch 1 taken 163 times.
326 return getObject<ModelObject>().getModelObjectTarget<UnitarySystemPerformanceMultispeed>(
565
1/1
✓ Branch 1 taken 163 times.
326 OS_AirLoopHVAC_UnitarySystemFields::DesignSpecificationMultispeedObjectName);
566 }
567
568 100 bool AirLoopHVACUnitarySystem_Impl::setControlType(const std::string& controlType) {
569 100 const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::ControlType, controlType);
570 100 return result;
571 }
572
573 1 void AirLoopHVACUnitarySystem_Impl::resetControlType() {
574
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
2 const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::ControlType, "");
575
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
1 OS_ASSERT(result);
576 1 }
577
578 ✗ bool AirLoopHVACUnitarySystem_Impl::setControllingZoneorThermostatLocation(const ThermalZone& thermalZone) {
579 ✗ const bool result = setPointer(OS_AirLoopHVAC_UnitarySystemFields::ControllingZoneorThermostatLocation, thermalZone.handle());
580 ✗ return result;
581 }
582
583 ✗ void AirLoopHVACUnitarySystem_Impl::resetControllingZoneorThermostatLocation() {
584 ✗ const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::ControllingZoneorThermostatLocation, "");
585 ✗ OS_ASSERT(result);
586 ✗ }
587
588 98 bool AirLoopHVACUnitarySystem_Impl::setDehumidificationControlType(const std::string& dehumidificationControlType) {
589 98 const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::DehumidificationControlType, dehumidificationControlType);
590 98 return result;
591 }
592
593 ✗ void AirLoopHVACUnitarySystem_Impl::resetDehumidificationControlType() {
594 ✗ const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::DehumidificationControlType, "");
595 ✗ OS_ASSERT(result);
596 ✗ }
597
598 ✗ bool AirLoopHVACUnitarySystem_Impl::setAvailabilitySchedule(Schedule& schedule) {
599 const bool result =
600 ✗ setSchedule(OS_AirLoopHVAC_UnitarySystemFields::AvailabilityScheduleName, "AirLoopHVACUnitarySystem", "Availability", schedule);
601 ✗ return result;
602 }
603
604 ✗ void AirLoopHVACUnitarySystem_Impl::resetAvailabilitySchedule() {
605 ✗ const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::AvailabilityScheduleName, "");
606 ✗ OS_ASSERT(result);
607 ✗ }
608
609 44 bool AirLoopHVACUnitarySystem_Impl::setSupplyFan(const HVACComponent& supplyFan) {
610
2/2
✓ Branch 1 taken 44 times.
✓ Branch 4 taken 44 times.
44 const bool result = setPointer(OS_AirLoopHVAC_UnitarySystemFields::SupplyFanName, supplyFan.handle());
611 44 return result;
612 }
613
614 ✗ void AirLoopHVACUnitarySystem_Impl::resetSupplyFan() {
615 ✗ const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyFanName, "");
616 ✗ OS_ASSERT(result);
617 ✗ }
618
619 31 bool AirLoopHVACUnitarySystem_Impl::setFanPlacement(const std::string& fanPlacement) {
620 31 const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::FanPlacement, fanPlacement);
621 31 return result;
622 }
623
624 ✗ void AirLoopHVACUnitarySystem_Impl::resetFanPlacement() {
625 ✗ const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::FanPlacement, "");
626 ✗ OS_ASSERT(result);
627 ✗ }
628
629 ✗ bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFanOperatingModeSchedule(Schedule& schedule) {
630 ✗ const bool result = setSchedule(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFanOperatingModeScheduleName, "AirLoopHVACUnitarySystem",
631 "Supply Air Fan Operating Mode", schedule);
632 ✗ return result;
633 }
634
635 ✗ void AirLoopHVACUnitarySystem_Impl::resetSupplyAirFanOperatingModeSchedule() {
636 ✗ const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFanOperatingModeScheduleName, "");
637 ✗ OS_ASSERT(result);
638 ✗ }
639
640 59 bool AirLoopHVACUnitarySystem_Impl::setHeatingCoil(const HVACComponent& heatingCoil) {
641
2/2
✓ Branch 1 taken 59 times.
✓ Branch 4 taken 59 times.
59 const bool result = setPointer(OS_AirLoopHVAC_UnitarySystemFields::HeatingCoilName, heatingCoil.handle());
642
5/5
✓ Branch 1 taken 59 times.
✓ Branch 4 taken 59 times.
✓ Branch 7 taken 59 times.
✓ Branch 11 taken 47 times.
✓ Branch 12 taken 12 times.
177 if (openstudio::istringEqual("None", supplyAirFlowRateMethodDuringHeatingOperation())) {
643 47 autosizeSupplyAirFlowRateDuringHeatingOperation();
644
3/5
✓ Branch 1 taken 47 times.
✓ Branch 4 taken 47 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 47 times.
✗ Branch 9 not taken.
94 OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("SupplyAirFlowRate"));
645 }
646 59 return result;
647 }
648
649 2 void AirLoopHVACUnitarySystem_Impl::resetHeatingCoil() {
650
2/2
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
4 const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::HeatingCoilName, "");
651
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 OS_ASSERT(result);
652
3/5
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 2 times.
✗ Branch 9 not taken.
2 OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("None"));
653 2 resetSupplyAirFlowRateDuringHeatingOperation();
654 2 resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation();
655 2 resetFractionofAutosizedDesignHeatingSupplyAirFlowRate();
656 2 resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation();
657
2/2
✓ Branch 1 taken 1 time.
✓ Branch 2 taken 1 time.
2 if (!hasCoolingCoil()) {
658
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
1 setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired("None");
659 1 resetSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
660 1 resetSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired();
661 1 resetFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
662 1 resetFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
663 1 resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired();
664 1 resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired();
665 }
666 2 }
667
668 98 bool AirLoopHVACUnitarySystem_Impl::setDXHeatingCoilSizingRatio(double dXHeatingCoilSizingRatio) {
669 98 const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::DXHeatingCoilSizingRatio, dXHeatingCoilSizingRatio);
670 98 return result;
671 }
672
673 ✗ void AirLoopHVACUnitarySystem_Impl::resetDXHeatingCoilSizingRatio() {
674 ✗ const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::DXHeatingCoilSizingRatio, "");
675 ✗ OS_ASSERT(result);
676 ✗ }
677
678 73 bool AirLoopHVACUnitarySystem_Impl::setCoolingCoil(const HVACComponent& coolingCoil) {
679
2/2
✓ Branch 1 taken 73 times.
✓ Branch 4 taken 73 times.
73 const bool result = setPointer(OS_AirLoopHVAC_UnitarySystemFields::CoolingCoilName, coolingCoil.handle());
680
5/5
✓ Branch 1 taken 73 times.
✓ Branch 4 taken 73 times.
✓ Branch 7 taken 73 times.
✓ Branch 11 taken 59 times.
✓ Branch 12 taken 14 times.
219 if (openstudio::istringEqual("None", supplyAirFlowRateMethodDuringCoolingOperation())) {
681 59 autosizeSupplyAirFlowRateDuringCoolingOperation();
682
3/5
✓ Branch 1 taken 59 times.
✓ Branch 4 taken 59 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 59 times.
✗ Branch 9 not taken.
118 OS_ASSERT(setSupplyAirFlowRateMethodDuringCoolingOperation("SupplyAirFlowRate"));
683 }
684 73 return result;
685 }
686
687 2 void AirLoopHVACUnitarySystem_Impl::resetCoolingCoil() {
688
2/2
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
4 const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::CoolingCoilName, "");
689
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 OS_ASSERT(result);
690
3/5
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 2 times.
✗ Branch 9 not taken.
2 OS_ASSERT(setSupplyAirFlowRateMethodDuringCoolingOperation("None"));
691 2 resetSupplyAirFlowRateDuringCoolingOperation();
692 2 resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation();
693 2 resetFractionofAutosizedDesignCoolingSupplyAirFlowRate();
694 2 resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation();
695
1/2
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
2 if (!hasHeatingCoil()) {
696
2/2
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
2 setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired("None");
697 2 resetSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
698 2 resetSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired();
699 2 resetFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
700 2 resetFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
701 2 resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired();
702 2 resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired();
703 }
704 2 }
705
706 98 bool AirLoopHVACUnitarySystem_Impl::setUseDOASDXCoolingCoil(bool useDOASDXCoolingCoil) {
707 98 return setBooleanFieldValue(OS_AirLoopHVAC_UnitarySystemFields::UseDOASDXCoolingCoil, useDOASDXCoolingCoil);
708 }
709
710 ✗ void AirLoopHVACUnitarySystem_Impl::resetUseDOASDXCoolingCoil() {
711 ✗ const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::UseDOASDXCoolingCoil, "");
712 ✗ OS_ASSERT(result);
713 ✗ }
714
715 98 bool AirLoopHVACUnitarySystem_Impl::setDOASDXCoolingCoilLeavingMinimumAirTemperature(double dOASDXCoolingCoilLeavingMinimumAirTemperature) {
716 const bool result =
717 98 setDouble(OS_AirLoopHVAC_UnitarySystemFields::DOASDXCoolingCoilLeavingMinimumAirTemperature, dOASDXCoolingCoilLeavingMinimumAirTemperature);
718 98 return result;
719 }
720
721 1 void AirLoopHVACUnitarySystem_Impl::resetDOASDXCoolingCoilLeavingMinimumAirTemperature() {
722
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
2 const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::DOASDXCoolingCoilLeavingMinimumAirTemperature, "");
723
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
1 OS_ASSERT(result);
724 1 }
725
726 1 void AirLoopHVACUnitarySystem_Impl::autosizeDOASDXCoolingCoilLeavingMinimumAirTemperature() {
727
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
2 const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::DOASDXCoolingCoilLeavingMinimumAirTemperature, "Autosize");
728
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
1 OS_ASSERT(result);
729 1 }
730
731 98 bool AirLoopHVACUnitarySystem_Impl::setLatentLoadControl(const std::string& latentLoadControl) {
732 98 const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::LatentLoadControl, latentLoadControl);
733 98 return result;
734 }
735
736 ✗ void AirLoopHVACUnitarySystem_Impl::resetLatentLoadControl() {
737 ✗ const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::LatentLoadControl, "");
738 ✗ OS_ASSERT(result);
739 ✗ }
740
741 39 bool AirLoopHVACUnitarySystem_Impl::setSupplementalHeatingCoil(const HVACComponent& supplementalHeatingCoil) {
742
2/2
✓ Branch 1 taken 39 times.
✓ Branch 4 taken 39 times.
39 const bool result = setPointer(OS_AirLoopHVAC_UnitarySystemFields::SupplementalHeatingCoilName, supplementalHeatingCoil.handle());
743 39 return result;
744 }
745
746 ✗ void AirLoopHVACUnitarySystem_Impl::resetSupplementalHeatingCoil() {
747 ✗ const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplementalHeatingCoilName, "");
748 ✗ OS_ASSERT(result);
749 ✗ }
750
751 226 bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRateMethodDuringCoolingOperation(
752 const std::string& supplyAirFlowRateMethodDuringCoolingOperation) {
753 const bool result =
754 226 setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringCoolingOperation, supplyAirFlowRateMethodDuringCoolingOperation);
755 226 return result;
756 }
757
758 5 bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRateDuringCoolingOperation(double supplyAirFlowRateDuringCoolingOperation) {
759 const bool result =
760 5 setDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringCoolingOperation, supplyAirFlowRateDuringCoolingOperation);
761
3/5
✓ Branch 1 taken 5 times.
✓ Branch 4 taken 5 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 5 times.
✗ Branch 9 not taken.
5 OS_ASSERT(setSupplyAirFlowRateMethodDuringCoolingOperation("SupplyAirFlowRate"));
762 // resetSupplyAirFlowRateDuringCoolingOperation();
763 5 resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation();
764 5 resetFractionofAutosizedDesignCoolingSupplyAirFlowRate();
765 5 resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation();
766 5 return result;
767 }
768
769 5 void AirLoopHVACUnitarySystem_Impl::resetSupplyAirFlowRateDuringCoolingOperation() {
770
2/2
✓ Branch 1 taken 5 times.
✓ Branch 4 taken 5 times.
10 const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringCoolingOperation, "");
771
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
5 OS_ASSERT(result);
772 5 }
773
774 60 void AirLoopHVACUnitarySystem_Impl::autosizeSupplyAirFlowRateDuringCoolingOperation() {
775
2/2
✓ Branch 1 taken 60 times.
✓ Branch 4 taken 60 times.
120 const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringCoolingOperation, "Autosize");
776
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 60 times.
60 OS_ASSERT(result);
777
3/5
✓ Branch 1 taken 60 times.
✓ Branch 4 taken 60 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 60 times.
✗ Branch 9 not taken.
60 OS_ASSERT(setSupplyAirFlowRateMethodDuringCoolingOperation("SupplyAirFlowRate"));
778 // resetSupplyAirFlowRateDuringCoolingOperation();
779 60 resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation();
780 60 resetFractionofAutosizedDesignCoolingSupplyAirFlowRate();
781 60 resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation();
782 60 }
783
784 1 bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(
785 double supplyAirFlowRatePerFloorAreaDuringCoolingOperation) {
786 1 const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaDuringCoolingOperation,
787 supplyAirFlowRatePerFloorAreaDuringCoolingOperation);
788
3/5
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✗ Branch 6 not taken.
✓ Branch 7 taken 1 time.
✗ Branch 9 not taken.
1 OS_ASSERT(setSupplyAirFlowRateMethodDuringCoolingOperation("FlowPerFloorArea"));
789 1 resetSupplyAirFlowRateDuringCoolingOperation();
790 // resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation();
791 1 resetFractionofAutosizedDesignCoolingSupplyAirFlowRate();
792 1 resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation();
793 1 return result;
794 }
795
796 69 void AirLoopHVACUnitarySystem_Impl::resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation() {
797
2/2
✓ Branch 1 taken 69 times.
✓ Branch 4 taken 69 times.
138 const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaDuringCoolingOperation, "");
798
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 69 times.
69 OS_ASSERT(result);
799 69 }
800
801 bool
802 1 AirLoopHVACUnitarySystem_Impl::setFractionofAutosizedDesignCoolingSupplyAirFlowRate(double fractionofAutosizedDesignCoolingSupplyAirFlowRate) {
803 1 const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignCoolingSupplyAirFlowRate,
804 fractionofAutosizedDesignCoolingSupplyAirFlowRate);
805
3/5
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✗ Branch 6 not taken.
✓ Branch 7 taken 1 time.
✗ Branch 9 not taken.
1 OS_ASSERT(setSupplyAirFlowRateMethodDuringCoolingOperation("FractionOfAutosizedCoolingValue"));
806 1 resetSupplyAirFlowRateDuringCoolingOperation();
807 1 resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation();
808 // resetFractionofAutosizedDesignCoolingSupplyAirFlowRate();
809 1 resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation();
810 1 return result;
811 }
812
813 69 void AirLoopHVACUnitarySystem_Impl::resetFractionofAutosizedDesignCoolingSupplyAirFlowRate() {
814
2/2
✓ Branch 1 taken 69 times.
✓ Branch 4 taken 69 times.
138 const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignCoolingSupplyAirFlowRate, "");
815
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 69 times.
69 OS_ASSERT(result);
816 69 }
817
818 1 bool AirLoopHVACUnitarySystem_Impl::setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(
819 double designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation) {
820 1 const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation,
821 designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation);
822
3/5
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✗ Branch 6 not taken.
✓ Branch 7 taken 1 time.
✗ Branch 9 not taken.
1 OS_ASSERT(setSupplyAirFlowRateMethodDuringCoolingOperation("FlowPerCoolingCapacity"));
823 1 resetSupplyAirFlowRateDuringCoolingOperation();
824 1 resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation();
825 1 resetFractionofAutosizedDesignCoolingSupplyAirFlowRate();
826 // resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation();
827 1 return result;
828 }
829
830 69 void AirLoopHVACUnitarySystem_Impl::resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation() {
831
2/2
✓ Branch 1 taken 69 times.
✓ Branch 4 taken 69 times.
138 const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation, "");
832
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 69 times.
69 OS_ASSERT(result);
833 69 }
834
835 202 bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRateMethodDuringHeatingOperation(
836 const std::string& supplyAirFlowRateMethodDuringHeatingOperation) {
837 const bool result =
838 202 setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringHeatingOperation, supplyAirFlowRateMethodDuringHeatingOperation);
839 202 return result;
840 }
841
842 5 bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRateDuringHeatingOperation(double supplyAirFlowRateDuringHeatingOperation) {
843 const bool result =
844 5 setDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringHeatingOperation, supplyAirFlowRateDuringHeatingOperation);
845
3/5
✓ Branch 1 taken 5 times.
✓ Branch 4 taken 5 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 5 times.
✗ Branch 9 not taken.
5 OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("SupplyAirFlowRate"));
846 // resetSupplyAirFlowRateDuringHeatingOperation();
847 5 resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation();
848 5 resetFractionofAutosizedDesignHeatingSupplyAirFlowRate();
849 5 resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation();
850 5 return result;
851 }
852
853 5 void AirLoopHVACUnitarySystem_Impl::resetSupplyAirFlowRateDuringHeatingOperation() {
854
2/2
✓ Branch 1 taken 5 times.
✓ Branch 4 taken 5 times.
10 const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringHeatingOperation, "");
855
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
5 OS_ASSERT(result);
856 5 }
857
858 48 void AirLoopHVACUnitarySystem_Impl::autosizeSupplyAirFlowRateDuringHeatingOperation() {
859
2/2
✓ Branch 1 taken 48 times.
✓ Branch 4 taken 48 times.
96 const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateDuringHeatingOperation, "Autosize");
860
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 48 times.
48 OS_ASSERT(result);
861
3/5
✓ Branch 1 taken 48 times.
✓ Branch 4 taken 48 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 48 times.
✗ Branch 9 not taken.
48 OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("SupplyAirFlowRate"));
862 // resetSupplyAirFlowRateDuringHeatingOperation();
863 48 resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation();
864 48 resetFractionofAutosizedDesignHeatingSupplyAirFlowRate();
865 48 resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation();
866 48 }
867
868 1 bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRatePerFloorAreaduringHeatingOperation(
869 double supplyAirFlowRatePerFloorAreaDuringHeatingOperation) {
870 1 const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaduringHeatingOperation,
871 supplyAirFlowRatePerFloorAreaDuringHeatingOperation);
872
3/5
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✗ Branch 6 not taken.
✓ Branch 7 taken 1 time.
✗ Branch 9 not taken.
1 OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("FlowPerFloorArea"));
873 1 resetSupplyAirFlowRateDuringHeatingOperation();
874 // resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation();
875 1 resetFractionofAutosizedDesignHeatingSupplyAirFlowRate();
876 1 resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation();
877 1 return result;
878 }
879
880 57 void AirLoopHVACUnitarySystem_Impl::resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation() {
881
2/2
✓ Branch 1 taken 57 times.
✓ Branch 4 taken 57 times.
114 const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaduringHeatingOperation, "");
882
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 57 times.
57 OS_ASSERT(result);
883 57 }
884
885 bool
886 1 AirLoopHVACUnitarySystem_Impl::setFractionofAutosizedDesignHeatingSupplyAirFlowRate(double fractionofAutosizedDesignHeatingSupplyAirFlowRate) {
887 1 const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignHeatingSupplyAirFlowRate,
888 fractionofAutosizedDesignHeatingSupplyAirFlowRate);
889
3/5
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✗ Branch 6 not taken.
✓ Branch 7 taken 1 time.
✗ Branch 9 not taken.
1 OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("FractionOfAutosizedHeatingValue"));
890 1 resetSupplyAirFlowRateDuringHeatingOperation();
891 1 resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation();
892 // resetFractionofAutosizedDesignHeatingSupplyAirFlowRate();
893 1 resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation();
894 1 return result;
895 }
896
897 57 void AirLoopHVACUnitarySystem_Impl::resetFractionofAutosizedDesignHeatingSupplyAirFlowRate() {
898
2/2
✓ Branch 1 taken 57 times.
✓ Branch 4 taken 57 times.
114 const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignHeatingSupplyAirFlowRate, "");
899
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 57 times.
57 OS_ASSERT(result);
900 57 }
901
902 1 bool AirLoopHVACUnitarySystem_Impl::setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(
903 double designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation) {
904 1 const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation,
905 designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation);
906
3/5
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✗ Branch 6 not taken.
✓ Branch 7 taken 1 time.
✗ Branch 9 not taken.
1 OS_ASSERT(setSupplyAirFlowRateMethodDuringHeatingOperation("FlowPerHeatingCapacity"));
907 1 resetSupplyAirFlowRateDuringHeatingOperation();
908 1 resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation();
909 1 resetFractionofAutosizedDesignHeatingSupplyAirFlowRate();
910 // resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation();
911 1 return result;
912 }
913
914 57 void AirLoopHVACUnitarySystem_Impl::resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation() {
915
2/2
✓ Branch 1 taken 57 times.
✓ Branch 4 taken 57 times.
114 const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation, "");
916
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 57 times.
57 OS_ASSERT(result);
917 57 }
918
919 110 bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired(
920 const std::string& supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired) {
921 110 const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired,
922 supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired);
923 110 return result;
924 }
925
926 1 void AirLoopHVACUnitarySystem_Impl::resetSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired() {
927
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
2 const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired, "None");
928
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
1 OS_ASSERT(result);
929 1 resetSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
930 1 resetSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired();
931 1 resetFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
932 1 resetFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
933 1 resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired();
934 1 resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired();
935 1 }
936
937 bool
938 1 AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(double supplyAirFlowRateWhenNoCoolingorHeatingisRequired) {
939 1 const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateWhenNoCoolingorHeatingisRequired,
940 supplyAirFlowRateWhenNoCoolingorHeatingisRequired);
941
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
1 if (!result) {
942 ✗ return false;
943 }
944
945
3/5
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✗ Branch 6 not taken.
✓ Branch 7 taken 1 time.
✗ Branch 9 not taken.
1 OS_ASSERT(setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired("SupplyAirFlowRate"));
946 // resetSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
947 1 resetSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired();
948 1 resetFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
949 1 resetFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
950 1 resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired();
951 1 resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired();
952
953 1 return true;
954 }
955
956 10 void AirLoopHVACUnitarySystem_Impl::resetSupplyAirFlowRateWhenNoCoolingorHeatingisRequired() {
957
2/2
✓ Branch 1 taken 10 times.
✓ Branch 4 taken 10 times.
20 const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateWhenNoCoolingorHeatingisRequired, "");
958
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
10 OS_ASSERT(result);
959 10 }
960
961 3 void AirLoopHVACUnitarySystem_Impl::autosizeSupplyAirFlowRateWhenNoCoolingorHeatingisRequired() {
962
2/2
✓ Branch 1 taken 3 times.
✓ Branch 4 taken 3 times.
6 const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateWhenNoCoolingorHeatingisRequired, "Autosize");
963
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
3 OS_ASSERT(result);
964
3/5
✓ Branch 1 taken 3 times.
✓ Branch 4 taken 3 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 3 times.
✗ Branch 9 not taken.
3 OS_ASSERT(setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired("SupplyAirFlowRate"));
965 // resetSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
966 3 resetSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired();
967 3 resetFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
968 3 resetFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
969 3 resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired();
970 3 resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired();
971 3 }
972
973 1 bool AirLoopHVACUnitarySystem_Impl::setSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired(
974 double supplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired) {
975 1 const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired,
976 supplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired);
977
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
1 if (!result) {
978 ✗ return false;
979 }
980
981
3/5
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✗ Branch 6 not taken.
✓ Branch 7 taken 1 time.
✗ Branch 9 not taken.
1 OS_ASSERT(setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired("FlowPerFloorArea"));
982 1 resetSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
983 // resetSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired();
984 1 resetFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
985 1 resetFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
986 1 resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired();
987 1 resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired();
988
989 1 return true;
990 }
991
992 13 void AirLoopHVACUnitarySystem_Impl::resetSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired() {
993
2/2
✓ Branch 1 taken 13 times.
✓ Branch 4 taken 13 times.
26 const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired, "");
994
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
13 OS_ASSERT(result);
995 13 }
996
997 1 bool AirLoopHVACUnitarySystem_Impl::setFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(
998 double fractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired) {
999 const bool result =
1000 1 setDouble(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired,
1001 fractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired);
1002
1003
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
1 if (!result) {
1004 ✗ return false;
1005 }
1006
1007
3/5
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✗ Branch 6 not taken.
✓ Branch 7 taken 1 time.
✗ Branch 9 not taken.
1 OS_ASSERT(setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired("FractionOfAutosizedCoolingValue"));
1008 1 resetSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
1009 1 resetSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired();
1010 // resetFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
1011 1 resetFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
1012 1 resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired();
1013 1 resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired();
1014
1015 1 return true;
1016 }
1017
1018 13 void AirLoopHVACUnitarySystem_Impl::resetFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired() {
1019 const bool result =
1020
2/2
✓ Branch 1 taken 13 times.
✓ Branch 4 taken 13 times.
26 setString(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired, "");
1021
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
13 OS_ASSERT(result);
1022 13 }
1023
1024 1 bool AirLoopHVACUnitarySystem_Impl::setFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(
1025 double fractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired) {
1026 const bool result =
1027 1 setDouble(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired,
1028 fractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired);
1029
1030
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
1 if (!result) {
1031 ✗ return false;
1032 }
1033
1034
3/5
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✗ Branch 6 not taken.
✓ Branch 7 taken 1 time.
✗ Branch 9 not taken.
1 OS_ASSERT(setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired("FractionOfAutosizedHeatingValue"));
1035 1 resetSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
1036 1 resetSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired();
1037 1 resetFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
1038 // resetFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
1039 1 resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired();
1040 1 resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired();
1041
1042 1 return true;
1043 }
1044
1045 13 void AirLoopHVACUnitarySystem_Impl::resetFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired() {
1046 const bool result =
1047
2/2
✓ Branch 1 taken 13 times.
✓ Branch 4 taken 13 times.
26 setString(OS_AirLoopHVAC_UnitarySystemFields::FractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired, "");
1048
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
13 OS_ASSERT(result);
1049 13 }
1050
1051 1 bool AirLoopHVACUnitarySystem_Impl::setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired(
1052 double designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired) {
1053 const bool result =
1054 1 setDouble(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired,
1055 designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired);
1056
1057
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
1 if (!result) {
1058 ✗ return false;
1059 }
1060
1061
3/5
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
✗ Branch 6 not taken.
✓ Branch 7 taken 1 time.
✗ Branch 9 not taken.
1 OS_ASSERT(setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired("FlowPerCoolingCapacity"));
1062 1 resetSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
1063 1 resetSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired();
1064 1 resetFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
1065 1 resetFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
1066 // resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired();
1067 1 resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired();
1068
1069 1 return true;
1070 }
1071
1072 13 void AirLoopHVACUnitarySystem_Impl::resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired() {
1073
2/2
✓ Branch 1 taken 13 times.
✓ Branch 4 taken 13 times.
26 const bool result = setString(
1074
1075 OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired, "");
1076
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
13 OS_ASSERT(result);
1077 13 }
1078
1079 2 bool AirLoopHVACUnitarySystem_Impl::setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired(
1080 double designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired) {
1081 const bool result =
1082 2 setDouble(OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired,
1083 designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired);
1084
1085
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 if (!result) {
1086 ✗ return false;
1087 }
1088
1089
3/5
✓ Branch 1 taken 2 times.
✓ Branch 4 taken 2 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 2 times.
✗ Branch 9 not taken.
2 OS_ASSERT(setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired("FlowPerHeatingCapacity"));
1090 2 resetSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
1091 2 resetSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired();
1092 2 resetFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
1093 2 resetFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
1094 2 resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired();
1095 // resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired();
1096
1097 2 return true;
1098 }
1099
1100 12 void AirLoopHVACUnitarySystem_Impl::resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired() {
1101
2/2
✓ Branch 1 taken 12 times.
✓ Branch 4 taken 12 times.
24 const bool result = setString(
1102 OS_AirLoopHVAC_UnitarySystemFields::DesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired, "");
1103
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
12 OS_ASSERT(result);
1104 12 }
1105
1106 98 bool AirLoopHVACUnitarySystem_Impl::setNoLoadSupplyAirFlowRateControlSetToLowSpeed(bool noLoadSupplyAirFlowRateControlSetToLowSpeed) {
1107 98 return setBooleanFieldValue(OS_AirLoopHVAC_UnitarySystemFields::NoLoadSupplyAirFlowRateControlSetToLowSpeed,
1108 98 noLoadSupplyAirFlowRateControlSetToLowSpeed);
1109 }
1110
1111 97 bool AirLoopHVACUnitarySystem_Impl::setMaximumSupplyAirTemperature(double maximumSupplyAirTemperature) {
1112 97 const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::MaximumSupplyAirTemperature, maximumSupplyAirTemperature);
1113 97 return result;
1114 }
1115
1116 ✗ void AirLoopHVACUnitarySystem_Impl::resetMaximumSupplyAirTemperature() {
1117 ✗ const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::MaximumSupplyAirTemperature, "");
1118 ✗ OS_ASSERT(result);
1119 ✗ }
1120
1121 1 void AirLoopHVACUnitarySystem_Impl::autosizeMaximumSupplyAirTemperature() {
1122
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
2 const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::MaximumSupplyAirTemperature, "Autosize");
1123
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
1 OS_ASSERT(result);
1124 1 }
1125
1126 98 bool AirLoopHVACUnitarySystem_Impl::setMaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation(
1127 double maximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation) {
1128 98 const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::MaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation,
1129 maximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation);
1130 98 return result;
1131 }
1132
1133 ✗ void AirLoopHVACUnitarySystem_Impl::resetMaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation() {
1134 ✗ const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::MaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation, "");
1135 ✗ OS_ASSERT(result);
1136 ✗ }
1137
1138 ✗ bool AirLoopHVACUnitarySystem_Impl::setOutdoorDryBulbTemperatureSensorNodeName(const std::string& outdoorDryBulbTemperatureSensorNodeName) {
1139 const bool result =
1140 ✗ setString(OS_AirLoopHVAC_UnitarySystemFields::OutdoorDryBulbTemperatureSensorNodeName, outdoorDryBulbTemperatureSensorNodeName);
1141 ✗ OS_ASSERT(result);
1142 ✗ return result;
1143 }
1144
1145 ✗ void AirLoopHVACUnitarySystem_Impl::resetOutdoorDryBulbTemperatureSensorNodeName() {
1146 ✗ const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::OutdoorDryBulbTemperatureSensorNodeName, "");
1147 ✗ OS_ASSERT(result);
1148 ✗ }
1149
1150 98 bool AirLoopHVACUnitarySystem_Impl::setAncilliaryOnCycleElectricPower(double ancilliaryOnCycleElectricPower) {
1151 98 const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::AncilliaryOnCycleElectricPower, ancilliaryOnCycleElectricPower);
1152 98 return result;
1153 }
1154
1155 ✗ void AirLoopHVACUnitarySystem_Impl::resetAncilliaryOnCycleElectricPower() {
1156 ✗ const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::AncilliaryOnCycleElectricPower, "");
1157 ✗ OS_ASSERT(result);
1158 ✗ }
1159
1160 98 bool AirLoopHVACUnitarySystem_Impl::setAncilliaryOffCycleElectricPower(double ancilliaryOffCycleElectricPower) {
1161 98 const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::AncilliaryOffCycleElectricPower, ancilliaryOffCycleElectricPower);
1162 98 return result;
1163 }
1164
1165 ✗ void AirLoopHVACUnitarySystem_Impl::resetAncilliaryOffCycleElectricPower() {
1166 ✗ const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::AncilliaryOffCycleElectricPower, "");
1167 ✗ OS_ASSERT(result);
1168 ✗ }
1169
1170 // bool AirLoopHVACUnitarySystem_Impl::setDesignHeatRecoveryWaterFlowRate(double designHeatRecoveryWaterFlowRate) {
1171 // const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::DesignHeatRecoveryWaterFlowRate, designHeatRecoveryWaterFlowRate);
1172 // return result;
1173 // }
1174
1175 // void AirLoopHVACUnitarySystem_Impl::resetDesignHeatRecoveryWaterFlowRate() {
1176 // const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::DesignHeatRecoveryWaterFlowRate, "");
1177 // OS_ASSERT(result);
1178 // }
1179
1180 // bool AirLoopHVACUnitarySystem_Impl::setMaximumTemperatureforHeatRecovery(double maximumTemperatureforHeatRecovery) {
1181 // const bool result = setDouble(OS_AirLoopHVAC_UnitarySystemFields::MaximumTemperatureforHeatRecovery, maximumTemperatureforHeatRecovery);
1182 // return result;
1183 // }
1184
1185 // void AirLoopHVACUnitarySystem_Impl::resetMaximumTemperatureforHeatRecovery() {
1186 // const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::MaximumTemperatureforHeatRecovery, "");
1187 // OS_ASSERT(result);
1188 // }
1189
1190 12 bool AirLoopHVACUnitarySystem_Impl::setDesignSpecificationMultispeedObject(const UnitarySystemPerformanceMultispeed& unitarySystemPerformace) {
1191
2/2
✓ Branch 1 taken 12 times.
✓ Branch 4 taken 12 times.
12 const bool result = setPointer(OS_AirLoopHVAC_UnitarySystemFields::DesignSpecificationMultispeedObjectName, unitarySystemPerformace.handle());
1192 12 return result;
1193 }
1194
1195 1 void AirLoopHVACUnitarySystem_Impl::resetDesignSpecificationMultispeedObject() {
1196
2/2
✓ Branch 1 taken 1 time.
✓ Branch 4 taken 1 time.
2 const bool result = setString(OS_AirLoopHVAC_UnitarySystemFields::DesignSpecificationMultispeedObjectName, "");
1197
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
1 OS_ASSERT(result);
1198 1 }
1199
1200 ✗ boost::optional<double> AirLoopHVACUnitarySystem_Impl::autosizedSupplyAirFlowRateDuringCoolingOperation() const {
1201 ✗ return getAutosizedValue("Design Size Cooling Supply Air Flow Rate", "m3/s");
1202 }
1203
1204 ✗ boost::optional<double> AirLoopHVACUnitarySystem_Impl::autosizedSupplyAirFlowRateDuringHeatingOperation() const {
1205 ✗ return getAutosizedValue("Design Size Heating Supply Air Flow Rate", "m3/s");
1206 }
1207
1208 ✗ boost::optional<double> AirLoopHVACUnitarySystem_Impl::autosizedSupplyAirFlowRateWhenNoCoolingorHeatingisRequired() const {
1209 ✗ return getAutosizedValue("Design Size No Load Supply Air Flow Rate", "m3/s");
1210 }
1211
1212 ✗ boost::optional<double> AirLoopHVACUnitarySystem_Impl::autosizedMaximumSupplyAirTemperature() const {
1213 ✗ return getAutosizedValue("Design Size Maximum Supply Air Temperature", "C");
1214 }
1215
1216 ✗ boost::optional<double> AirLoopHVACUnitarySystem_Impl::autosizedDOASDXCoolingCoilLeavingMinimumAirTemperature() const {
1217 ✗ return getAutosizedValue("Design Size Minimum Supply Air Temperature", "C");
1218 }
1219
1220 ✗ void AirLoopHVACUnitarySystem_Impl::autosize() {
1221 ✗ autosizeSupplyAirFlowRateDuringCoolingOperation();
1222 ✗ autosizeSupplyAirFlowRateDuringHeatingOperation();
1223 ✗ autosizeSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
1224 ✗ autosizeMaximumSupplyAirTemperature();
1225 ✗ }
1226
1227 ✗ void AirLoopHVACUnitarySystem_Impl::applySizingValues() {
1228 ✗ boost::optional<double> val;
1229 ✗ val = autosizedSupplyAirFlowRateDuringCoolingOperation();
1230 ✗ if (val) {
1231 ✗ setSupplyAirFlowRateDuringCoolingOperation(val.get());
1232 }
1233
1234 ✗ val = autosizedSupplyAirFlowRateDuringHeatingOperation();
1235 ✗ if (val) {
1236 ✗ setSupplyAirFlowRateDuringHeatingOperation(val.get());
1237 }
1238
1239 ✗ val = autosizedSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
1240 ✗ if (val) {
1241 ✗ setSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(val.get());
1242 }
1243
1244 ✗ val = autosizedMaximumSupplyAirTemperature();
1245 ✗ if (val) {
1246 ✗ setMaximumSupplyAirTemperature(val.get());
1247 }
1248 ✗ }
1249
1250 ✗ std::vector<EMSActuatorNames> AirLoopHVACUnitarySystem_Impl::emsActuatorNames() const {
1251 std::vector<EMSActuatorNames> actuators{{"AirLoopHVAC:UnitarySystem", "Autosized Supply Air Flow Rate"},
1252 {"AirLoopHVAC:UnitarySystem", "Autosized Supply Air Flow Rate During Cooling Operation"},
1253 {"AirLoopHVAC:UnitarySystem", "Autosized Supply Air Flow Rate During Heating Operation"},
1254 {"AirLoopHVAC:UnitarySystem", "Autosized Supply Air Flow Rate During No Heating or Cooling Operation"},
1255 {"Unitary HVAC", "Sensible Load Request"},
1256 ✗ {"Unitary HVAC", "Moisture Load Request"}};
1257 ✗ return actuators;
1258 ✗ }
1259
1260 ✗ std::vector<std::string> AirLoopHVACUnitarySystem_Impl::emsInternalVariableNames() const {
1261 std::vector<std::string> types{"Unitary System Control Zone Mass Flow Fraction", "Unitary HVAC Design Heating Capacity",
1262 ✗ "Unitary HVAC Design Cooling Capacity"};
1263 ✗ return types;
1264 ✗ }
1265
1266 ✗ ComponentType AirLoopHVACUnitarySystem_Impl::componentType() const {
1267 ✗ const bool has_cooling = coolingCoil().is_initialized();
1268 ✗ const bool has_heating = heatingCoil().is_initialized();
1269
1270 ✗ if (has_cooling && has_heating) {
1271 ✗ return ComponentType::Both;
1272 ✗ } else if (has_cooling) {
1273 ✗ return ComponentType::Cooling;
1274 ✗ } else if (has_heating) {
1275 ✗ return ComponentType::Heating;
1276 }
1277 ✗ return ComponentType::None;
1278 }
1279
1280 ✗ std::vector<FuelType> AirLoopHVACUnitarySystem_Impl::coolingFuelTypes() const {
1281 ✗ std::set<FuelType> result;
1282 ✗ if (auto cc_ = coolingCoil()) {
1283 ✗ for (auto ft : cc_->coolingFuelTypes()) {
1284 ✗ result.insert(ft);
1285 ✗ }
1286 ✗ }
1287
1288 ✗ return {result.begin(), result.end()};
1289 ✗ }
1290
1291 ✗ std::vector<FuelType> AirLoopHVACUnitarySystem_Impl::heatingFuelTypes() const {
1292 ✗ std::set<FuelType> result;
1293 ✗ if (auto hc_ = heatingCoil()) {
1294 ✗ for (auto ft : hc_->heatingFuelTypes()) {
1295 ✗ result.insert(ft);
1296 ✗ }
1297 ✗ }
1298 ✗ if (auto supHC_ = supplementalHeatingCoil()) {
1299 ✗ for (auto ft : supHC_->heatingFuelTypes()) {
1300 ✗ result.insert(ft);
1301 ✗ }
1302 ✗ }
1303
1304 ✗ return {result.begin(), result.end()};
1305 ✗ }
1306
1307 ✗ std::vector<AppGFuelType> AirLoopHVACUnitarySystem_Impl::appGHeatingFuelTypes() const {
1308 ✗ std::set<AppGFuelType> result;
1309 ✗ if (auto hc_ = heatingCoil()) {
1310 ✗ for (auto ft : hc_->appGHeatingFuelTypes()) {
1311 ✗ result.insert(ft);
1312 ✗ }
1313 ✗ }
1314 ✗ if (auto supHC_ = supplementalHeatingCoil()) {
1315 ✗ for (auto ft : supHC_->appGHeatingFuelTypes()) {
1316 ✗ result.insert(ft);
1317 ✗ }
1318 ✗ }
1319 ✗ return {result.begin(), result.end()};
1320 ✗ }
1321
1322 } // namespace detail
1323
1324 97 AirLoopHVACUnitarySystem::AirLoopHVACUnitarySystem(const Model& model) : ZoneHVACComponent(AirLoopHVACUnitarySystem::iddObjectType(), model) {
1325
1/3
✗ Branch 2 not taken.
✓ Branch 3 taken 97 times.
✗ Branch 5 not taken.
97 OS_ASSERT(getImpl<detail::AirLoopHVACUnitarySystem_Impl>());
1326
1327 97 bool ok = true;
1328
2/2
✓ Branch 3 taken 97 times.
✓ Branch 6 taken 97 times.
291 ok = getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setControlType("Load");
1329
1/3
✗ Branch 0 not taken.
✓ Branch 1 taken 97 times.
✗ Branch 3 not taken.
97 OS_ASSERT(ok);
1330
2/2
✓ Branch 1 taken 97 times.
✓ Branch 4 taken 97 times.
97 ok = setDehumidificationControlType("None");
1331
1/3
✗ Branch 0 not taken.
✓ Branch 1 taken 97 times.
✗ Branch 3 not taken.
97 OS_ASSERT(ok);
1332
1/1
✓ Branch 1 taken 97 times.
97 ok = setDXHeatingCoilSizingRatio(1.0);
1333
1/3
✗ Branch 0 not taken.
✓ Branch 1 taken 97 times.
✗ Branch 3 not taken.
97 OS_ASSERT(ok);
1334
1/1
✓ Branch 1 taken 97 times.
97 setUseDOASDXCoolingCoil(false);
1335
1/1
✓ Branch 1 taken 97 times.
97 ok = setDOASDXCoolingCoilLeavingMinimumAirTemperature(2.0);
1336
1/3
✗ Branch 0 not taken.
✓ Branch 1 taken 97 times.
✗ Branch 3 not taken.
97 OS_ASSERT(ok);
1337
2/2
✓ Branch 1 taken 97 times.
✓ Branch 4 taken 97 times.
97 ok = setLatentLoadControl("SensibleOnlyLoadControl");
1338
1/3
✗ Branch 0 not taken.
✓ Branch 1 taken 97 times.
✗ Branch 3 not taken.
97 OS_ASSERT(ok);
1339
2/2
✓ Branch 3 taken 97 times.
✓ Branch 6 taken 97 times.
291 getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setSupplyAirFlowRateMethodDuringCoolingOperation("None");
1340
2/2
✓ Branch 3 taken 97 times.
✓ Branch 6 taken 97 times.
291 getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setSupplyAirFlowRateMethodDuringHeatingOperation("None");
1341
2/2
✓ Branch 3 taken 97 times.
✓ Branch 6 taken 97 times.
291 getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired("None");
1342
1/1
✓ Branch 1 taken 97 times.
97 setNoLoadSupplyAirFlowRateControlSetToLowSpeed(true);
1343
1/1
✓ Branch 1 taken 97 times.
97 setMaximumSupplyAirTemperature(80.0);
1344
1/1
✓ Branch 1 taken 97 times.
97 setMaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation(21.0);
1345
1/1
✓ Branch 1 taken 97 times.
97 ok = setAncilliaryOnCycleElectricPower(0.0);
1346
1/3
✗ Branch 0 not taken.
✓ Branch 1 taken 97 times.
✗ Branch 3 not taken.
97 OS_ASSERT(ok);
1347
1/1
✓ Branch 1 taken 97 times.
97 ok = setAncilliaryOffCycleElectricPower(0.0);
1348
1/3
✗ Branch 0 not taken.
✓ Branch 1 taken 97 times.
✗ Branch 3 not taken.
97 OS_ASSERT(ok);
1349 // ok = setMaximumTemperatureforHeatRecovery(80.0);
1350 // OS_ASSERT(ok);
1351 97 }
1352
1353 8785 IddObjectType AirLoopHVACUnitarySystem::iddObjectType() {
1354
1/1
✓ Branch 1 taken 8785 times.
8785 return {IddObjectType::OS_AirLoopHVAC_UnitarySystem};
1355 }
1356
1357 ✗ std::vector<std::string> AirLoopHVACUnitarySystem::controlTypeValues() {
1358 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_AirLoopHVAC_UnitarySystemFields::ControlType);
1359 }
1360
1361 ✗ std::vector<std::string> AirLoopHVACUnitarySystem::dehumidificationControlTypeValues() {
1362 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_AirLoopHVAC_UnitarySystemFields::DehumidificationControlType);
1363 }
1364
1365 ✗ std::vector<std::string> AirLoopHVACUnitarySystem::fanPlacementValues() {
1366 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_AirLoopHVAC_UnitarySystemFields::FanPlacement);
1367 }
1368
1369 ✗ std::vector<std::string> AirLoopHVACUnitarySystem::latentLoadControlValues() {
1370 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(), OS_AirLoopHVAC_UnitarySystemFields::LatentLoadControl);
1371 }
1372
1373 ✗ std::vector<std::string> AirLoopHVACUnitarySystem::supplyAirFlowRateMethodDuringCoolingOperationValues() {
1374 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(),
1375 ✗ OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringCoolingOperation);
1376 }
1377
1378 ✗ std::vector<std::string> AirLoopHVACUnitarySystem::supplyAirFlowRateMethodDuringHeatingOperationValues() {
1379 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(),
1380 ✗ OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodDuringHeatingOperation);
1381 }
1382
1383 ✗ std::vector<std::string> AirLoopHVACUnitarySystem::supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequiredValues() {
1384 ✗ return getIddKeyNames(IddFactory::instance().getObject(iddObjectType()).get(),
1385 ✗ OS_AirLoopHVAC_UnitarySystemFields::SupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired);
1386 }
1387
1388 75 std::string AirLoopHVACUnitarySystem::controlType() const {
1389
1/1
✓ Branch 3 taken 75 times.
75 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->controlType();
1390 }
1391
1392 3 bool AirLoopHVACUnitarySystem::isControlTypeDefaulted() const {
1393
1/1
✓ Branch 3 taken 3 times.
3 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isControlTypeDefaulted();
1394 }
1395
1396 73 boost::optional<ThermalZone> AirLoopHVACUnitarySystem::controllingZoneorThermostatLocation() const {
1397
1/1
✓ Branch 3 taken 73 times.
73 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->controllingZoneorThermostatLocation();
1398 }
1399
1400 75 std::string AirLoopHVACUnitarySystem::dehumidificationControlType() const {
1401
1/1
✓ Branch 3 taken 75 times.
75 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->dehumidificationControlType();
1402 }
1403
1404 ✗ bool AirLoopHVACUnitarySystem::isDehumidificationControlTypeDefaulted() const {
1405 ✗ return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isDehumidificationControlTypeDefaulted();
1406 }
1407
1408 73 boost::optional<Schedule> AirLoopHVACUnitarySystem::availabilitySchedule() const {
1409
1/1
✓ Branch 3 taken 73 times.
73 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->availabilitySchedule();
1410 }
1411
1412 86 boost::optional<HVACComponent> AirLoopHVACUnitarySystem::supplyFan() const {
1413
1/1
✓ Branch 3 taken 86 times.
86 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->supplyFan();
1414 }
1415
1416 74 boost::optional<std::string> AirLoopHVACUnitarySystem::fanPlacement() const {
1417
1/1
✓ Branch 3 taken 74 times.
74 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->fanPlacement();
1418 }
1419
1420 73 boost::optional<Schedule> AirLoopHVACUnitarySystem::supplyAirFanOperatingModeSchedule() const {
1421
1/1
✓ Branch 3 taken 73 times.
73 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->supplyAirFanOperatingModeSchedule();
1422 }
1423
1424 138 boost::optional<HVACComponent> AirLoopHVACUnitarySystem::heatingCoil() const {
1425
1/1
✓ Branch 3 taken 138 times.
138 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->heatingCoil();
1426 }
1427
1428 75 double AirLoopHVACUnitarySystem::dXHeatingCoilSizingRatio() const {
1429
1/1
✓ Branch 3 taken 75 times.
75 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->dXHeatingCoilSizingRatio();
1430 }
1431
1432 ✗ bool AirLoopHVACUnitarySystem::isDXHeatingCoilSizingRatioDefaulted() const {
1433 ✗ return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isDXHeatingCoilSizingRatioDefaulted();
1434 }
1435
1436 181 boost::optional<HVACComponent> AirLoopHVACUnitarySystem::coolingCoil() const {
1437
1/1
✓ Branch 3 taken 181 times.
181 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->coolingCoil();
1438 }
1439
1440 75 bool AirLoopHVACUnitarySystem::useDOASDXCoolingCoil() const {
1441
1/1
✓ Branch 3 taken 75 times.
75 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->useDOASDXCoolingCoil();
1442 }
1443
1444 ✗ bool AirLoopHVACUnitarySystem::isUseDOASDXCoolingCoilDefaulted() const {
1445 ✗ return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isUseDOASDXCoolingCoilDefaulted();
1446 }
1447
1448 75 double AirLoopHVACUnitarySystem::dOASDXCoolingCoilLeavingMinimumAirTemperature() const {
1449
1/1
✓ Branch 3 taken 75 times.
75 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->dOASDXCoolingCoilLeavingMinimumAirTemperature();
1450 }
1451
1452 3 bool AirLoopHVACUnitarySystem::isDOASDXCoolingCoilLeavingMinimumAirTemperatureDefaulted() const {
1453
1/1
✓ Branch 3 taken 3 times.
3 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isDOASDXCoolingCoilLeavingMinimumAirTemperatureDefaulted();
1454 }
1455
1456 76 bool AirLoopHVACUnitarySystem::isDOASDXCoolingCoilLeavingMinimumAirTemperatureAutosized() const {
1457
1/1
✓ Branch 3 taken 76 times.
76 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isDOASDXCoolingCoilLeavingMinimumAirTemperatureAutosized();
1458 }
1459
1460 75 std::string AirLoopHVACUnitarySystem::latentLoadControl() const {
1461
1/1
✓ Branch 3 taken 75 times.
75 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->latentLoadControl();
1462 }
1463
1464 ✗ bool AirLoopHVACUnitarySystem::isLatentLoadControlDefaulted() const {
1465 ✗ return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isLatentLoadControlDefaulted();
1466 }
1467
1468 91 boost::optional<HVACComponent> AirLoopHVACUnitarySystem::supplementalHeatingCoil() const {
1469
1/1
✓ Branch 3 taken 91 times.
91 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->supplementalHeatingCoil();
1470 }
1471
1472 58 std::string AirLoopHVACUnitarySystem::supplyAirFlowRateMethodDuringCoolingOperation() const {
1473
1/1
✓ Branch 3 taken 58 times.
58 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->supplyAirFlowRateMethodDuringCoolingOperation();
1474 }
1475
1476 21 boost::optional<double> AirLoopHVACUnitarySystem::supplyAirFlowRateDuringCoolingOperation() const {
1477
1/1
✓ Branch 3 taken 21 times.
21 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->supplyAirFlowRateDuringCoolingOperation();
1478 }
1479
1480 60 bool AirLoopHVACUnitarySystem::isSupplyAirFlowRateDuringCoolingOperationAutosized() const {
1481
1/1
✓ Branch 3 taken 60 times.
60 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isSupplyAirFlowRateDuringCoolingOperationAutosized();
1482 }
1483
1484 59 boost::optional<double> AirLoopHVACUnitarySystem::supplyAirFlowRatePerFloorAreaDuringCoolingOperation() const {
1485
1/1
✓ Branch 3 taken 59 times.
59 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->supplyAirFlowRatePerFloorAreaDuringCoolingOperation();
1486 }
1487
1488 59 boost::optional<double> AirLoopHVACUnitarySystem::fractionofAutosizedDesignCoolingSupplyAirFlowRate() const {
1489
1/1
✓ Branch 3 taken 59 times.
59 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->fractionofAutosizedDesignCoolingSupplyAirFlowRate();
1490 }
1491
1492 59 boost::optional<double> AirLoopHVACUnitarySystem::designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation() const {
1493
1/1
✓ Branch 3 taken 59 times.
59 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation();
1494 }
1495
1496 43 std::string AirLoopHVACUnitarySystem::supplyAirFlowRateMethodDuringHeatingOperation() const {
1497
1/1
✓ Branch 3 taken 43 times.
43 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->supplyAirFlowRateMethodDuringHeatingOperation();
1498 }
1499
1500 21 boost::optional<double> AirLoopHVACUnitarySystem::supplyAirFlowRateDuringHeatingOperation() const {
1501
1/1
✓ Branch 3 taken 21 times.
21 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->supplyAirFlowRateDuringHeatingOperation();
1502 }
1503
1504 45 bool AirLoopHVACUnitarySystem::isSupplyAirFlowRateDuringHeatingOperationAutosized() const {
1505
1/1
✓ Branch 3 taken 45 times.
45 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isSupplyAirFlowRateDuringHeatingOperationAutosized();
1506 }
1507
1508 44 boost::optional<double> AirLoopHVACUnitarySystem::supplyAirFlowRatePerFloorAreaduringHeatingOperation() const {
1509
1/1
✓ Branch 3 taken 44 times.
44 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->supplyAirFlowRatePerFloorAreaduringHeatingOperation();
1510 }
1511
1512 44 boost::optional<double> AirLoopHVACUnitarySystem::fractionofAutosizedDesignHeatingSupplyAirFlowRate() const {
1513
1/1
✓ Branch 3 taken 44 times.
44 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->fractionofAutosizedDesignHeatingSupplyAirFlowRate();
1514 }
1515
1516 44 boost::optional<double> AirLoopHVACUnitarySystem::designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation() const {
1517
1/1
✓ Branch 3 taken 44 times.
44 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation();
1518 }
1519
1520 85 std::string AirLoopHVACUnitarySystem::supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired() const {
1521
1/1
✓ Branch 3 taken 85 times.
85 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->supplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired();
1522 }
1523
1524 84 boost::optional<double> AirLoopHVACUnitarySystem::supplyAirFlowRateWhenNoCoolingorHeatingisRequired() const {
1525
1/1
✓ Branch 3 taken 84 times.
84 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->supplyAirFlowRateWhenNoCoolingorHeatingisRequired();
1526 }
1527
1528 85 bool AirLoopHVACUnitarySystem::isSupplyAirFlowRateWhenNoCoolingorHeatingisRequiredAutosized() const {
1529
1/1
✓ Branch 3 taken 85 times.
85 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isSupplyAirFlowRateWhenNoCoolingorHeatingisRequiredAutosized();
1530 }
1531
1532 84 boost::optional<double> AirLoopHVACUnitarySystem::supplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired() const {
1533
1/1
✓ Branch 3 taken 84 times.
84 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->supplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired();
1534 }
1535
1536 84 boost::optional<double> AirLoopHVACUnitarySystem::fractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired() const {
1537
1/1
✓ Branch 3 taken 84 times.
84 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->fractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
1538 }
1539
1540 84 boost::optional<double> AirLoopHVACUnitarySystem::fractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired() const {
1541
1/1
✓ Branch 3 taken 84 times.
84 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->fractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
1542 }
1543
1544 boost::optional<double>
1545 84 AirLoopHVACUnitarySystem::designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired() const {
1546 168 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()
1547
1/1
✓ Branch 2 taken 84 times.
168 ->designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired();
1548 }
1549
1550 boost::optional<double>
1551 84 AirLoopHVACUnitarySystem::designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired() const {
1552 168 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()
1553
1/1
✓ Branch 2 taken 84 times.
168 ->designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired();
1554 }
1555
1556 75 bool AirLoopHVACUnitarySystem::noLoadSupplyAirFlowRateControlSetToLowSpeed() const {
1557
1/1
✓ Branch 3 taken 75 times.
75 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->noLoadSupplyAirFlowRateControlSetToLowSpeed();
1558 }
1559
1560 74 boost::optional<double> AirLoopHVACUnitarySystem::maximumSupplyAirTemperature() const {
1561
1/1
✓ Branch 3 taken 74 times.
74 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->maximumSupplyAirTemperature();
1562 }
1563
1564 ✗ bool AirLoopHVACUnitarySystem::isMaximumSupplyAirTemperatureDefaulted() const {
1565 ✗ return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isMaximumSupplyAirTemperatureDefaulted();
1566 }
1567
1568 74 bool AirLoopHVACUnitarySystem::isMaximumSupplyAirTemperatureAutosized() const {
1569
1/1
✓ Branch 3 taken 74 times.
74 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isMaximumSupplyAirTemperatureAutosized();
1570 }
1571
1572 75 double AirLoopHVACUnitarySystem::maximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation() const {
1573
1/1
✓ Branch 3 taken 75 times.
75 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->maximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation();
1574 }
1575
1576 ✗ bool AirLoopHVACUnitarySystem::isMaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperationDefaulted() const {
1577 ✗ return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isMaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperationDefaulted();
1578 }
1579
1580 73 boost::optional<std::string> AirLoopHVACUnitarySystem::outdoorDryBulbTemperatureSensorNodeName() const {
1581
1/1
✓ Branch 3 taken 73 times.
73 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->outdoorDryBulbTemperatureSensorNodeName();
1582 }
1583
1584 75 double AirLoopHVACUnitarySystem::ancilliaryOnCycleElectricPower() const {
1585
1/1
✓ Branch 3 taken 75 times.
75 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->ancilliaryOnCycleElectricPower();
1586 }
1587
1588 ✗ bool AirLoopHVACUnitarySystem::isAncilliaryOnCycleElectricPowerDefaulted() const {
1589 ✗ return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isAncilliaryOnCycleElectricPowerDefaulted();
1590 }
1591
1592 75 double AirLoopHVACUnitarySystem::ancilliaryOffCycleElectricPower() const {
1593
1/1
✓ Branch 3 taken 75 times.
75 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->ancilliaryOffCycleElectricPower();
1594 }
1595
1596 ✗ bool AirLoopHVACUnitarySystem::isAncilliaryOffCycleElectricPowerDefaulted() const {
1597 ✗ return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isAncilliaryOffCycleElectricPowerDefaulted();
1598 }
1599
1600 // TODO: @kbenne, why is this not exposed?
1601 // double AirLoopHVACUnitarySystem::designHeatRecoveryWaterFlowRate() const {
1602 // return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->designHeatRecoveryWaterFlowRate();
1603 // }
1604
1605 // bool AirLoopHVACUnitarySystem::isDesignHeatRecoveryWaterFlowRateDefaulted() const {
1606 // return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isDesignHeatRecoveryWaterFlowRateDefaulted();
1607 // }
1608
1609 // double AirLoopHVACUnitarySystem::maximumTemperatureforHeatRecovery() const {
1610 // return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->maximumTemperatureforHeatRecovery();
1611 // }
1612
1613 // bool AirLoopHVACUnitarySystem::isMaximumTemperatureforHeatRecoveryDefaulted() const {
1614 // return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->isMaximumTemperatureforHeatRecoveryDefaulted();
1615 // }
1616
1617 76 boost::optional<UnitarySystemPerformanceMultispeed> AirLoopHVACUnitarySystem::designSpecificationMultispeedObject() const {
1618
1/1
✓ Branch 3 taken 76 times.
76 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->designSpecificationMultispeedObject();
1619 }
1620
1621 3 bool AirLoopHVACUnitarySystem::setControlType(const std::string& controlType) {
1622
1/1
✓ Branch 3 taken 3 times.
3 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setControlType(controlType);
1623 }
1624
1625 1 void AirLoopHVACUnitarySystem::resetControlType() {
1626
1/1
✓ Branch 3 taken 1 time.
1 getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetControlType();
1627 1 }
1628
1629 ✗ bool AirLoopHVACUnitarySystem::setControllingZoneorThermostatLocation(const ThermalZone& thermalZone) {
1630 ✗ return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setControllingZoneorThermostatLocation(thermalZone);
1631 }
1632
1633 ✗ void AirLoopHVACUnitarySystem::resetControllingZoneorThermostatLocation() {
1634 ✗ getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetControllingZoneorThermostatLocation();
1635 ✗ }
1636
1637 98 bool AirLoopHVACUnitarySystem::setDehumidificationControlType(const std::string& dehumidificationControlType) {
1638
1/1
✓ Branch 3 taken 98 times.
98 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setDehumidificationControlType(dehumidificationControlType);
1639 }
1640
1641 ✗ void AirLoopHVACUnitarySystem::resetDehumidificationControlType() {
1642 ✗ getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetDehumidificationControlType();
1643 ✗ }
1644
1645 ✗ bool AirLoopHVACUnitarySystem::setAvailabilitySchedule(Schedule& schedule) {
1646 ✗ return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setAvailabilitySchedule(schedule);
1647 }
1648
1649 ✗ void AirLoopHVACUnitarySystem::resetAvailabilitySchedule() {
1650 ✗ getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetAvailabilitySchedule();
1651 ✗ }
1652
1653 44 bool AirLoopHVACUnitarySystem::setSupplyFan(const HVACComponent& supplyFan) {
1654
1/1
✓ Branch 3 taken 44 times.
44 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setSupplyFan(supplyFan);
1655 }
1656
1657 ✗ void AirLoopHVACUnitarySystem::resetSupplyFan() {
1658 ✗ getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetSupplyFan();
1659 ✗ }
1660
1661 31 bool AirLoopHVACUnitarySystem::setFanPlacement(const std::string& fanPlacement) {
1662
1/1
✓ Branch 3 taken 31 times.
31 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setFanPlacement(fanPlacement);
1663 }
1664
1665 ✗ void AirLoopHVACUnitarySystem::resetFanPlacement() {
1666 ✗ getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetFanPlacement();
1667 ✗ }
1668
1669 ✗ bool AirLoopHVACUnitarySystem::setSupplyAirFanOperatingModeSchedule(Schedule& schedule) {
1670 ✗ return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setSupplyAirFanOperatingModeSchedule(schedule);
1671 }
1672
1673 ✗ void AirLoopHVACUnitarySystem::resetSupplyAirFanOperatingModeSchedule() {
1674 ✗ getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetSupplyAirFanOperatingModeSchedule();
1675 ✗ }
1676
1677 59 bool AirLoopHVACUnitarySystem::setHeatingCoil(const HVACComponent& heatingCoil) {
1678
1/1
✓ Branch 3 taken 59 times.
59 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setHeatingCoil(heatingCoil);
1679 }
1680
1681 2 void AirLoopHVACUnitarySystem::resetHeatingCoil() {
1682
1/1
✓ Branch 3 taken 2 times.
2 getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetHeatingCoil();
1683 2 }
1684
1685 98 bool AirLoopHVACUnitarySystem::setDXHeatingCoilSizingRatio(double dXHeatingCoilSizingRatio) {
1686
1/1
✓ Branch 3 taken 98 times.
98 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setDXHeatingCoilSizingRatio(dXHeatingCoilSizingRatio);
1687 }
1688
1689 ✗ void AirLoopHVACUnitarySystem::resetDXHeatingCoilSizingRatio() {
1690 ✗ getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetDXHeatingCoilSizingRatio();
1691 ✗ }
1692
1693 73 bool AirLoopHVACUnitarySystem::setCoolingCoil(const HVACComponent& coolingCoil) {
1694
1/1
✓ Branch 3 taken 73 times.
73 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setCoolingCoil(coolingCoil);
1695 }
1696
1697 2 void AirLoopHVACUnitarySystem::resetCoolingCoil() {
1698
1/1
✓ Branch 3 taken 2 times.
2 getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetCoolingCoil();
1699 2 }
1700
1701 98 bool AirLoopHVACUnitarySystem::setUseDOASDXCoolingCoil(bool useDOASDXCoolingCoil) {
1702
1/1
✓ Branch 3 taken 98 times.
98 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setUseDOASDXCoolingCoil(useDOASDXCoolingCoil);
1703 }
1704
1705 ✗ void AirLoopHVACUnitarySystem::resetUseDOASDXCoolingCoil() {
1706 ✗ getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetUseDOASDXCoolingCoil();
1707 ✗ }
1708
1709 98 bool AirLoopHVACUnitarySystem::setDOASDXCoolingCoilLeavingMinimumAirTemperature(double dOASDXCoolingCoilLeavingMinimumAirTemperature) {
1710
1/1
✓ Branch 3 taken 98 times.
196 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setDOASDXCoolingCoilLeavingMinimumAirTemperature(
1711 196 dOASDXCoolingCoilLeavingMinimumAirTemperature);
1712 }
1713
1714 1 void AirLoopHVACUnitarySystem::resetDOASDXCoolingCoilLeavingMinimumAirTemperature() {
1715
1/1
✓ Branch 3 taken 1 time.
1 getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetDOASDXCoolingCoilLeavingMinimumAirTemperature();
1716 1 }
1717
1718 1 void AirLoopHVACUnitarySystem::autosizeDOASDXCoolingCoilLeavingMinimumAirTemperature() {
1719
1/1
✓ Branch 3 taken 1 time.
1 getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->autosizeDOASDXCoolingCoilLeavingMinimumAirTemperature();
1720 1 }
1721
1722 98 bool AirLoopHVACUnitarySystem::setLatentLoadControl(const std::string& latentLoadControl) {
1723
1/1
✓ Branch 3 taken 98 times.
98 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setLatentLoadControl(latentLoadControl);
1724 }
1725
1726 ✗ void AirLoopHVACUnitarySystem::resetLatentLoadControl() {
1727 ✗ getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetLatentLoadControl();
1728 ✗ }
1729
1730 39 bool AirLoopHVACUnitarySystem::setSupplementalHeatingCoil(const HVACComponent& supplementalHeatingCoil) {
1731
1/1
✓ Branch 3 taken 39 times.
39 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setSupplementalHeatingCoil(supplementalHeatingCoil);
1732 }
1733
1734 ✗ void AirLoopHVACUnitarySystem::resetSupplementalHeatingCoil() {
1735 ✗ getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetSupplementalHeatingCoil();
1736 ✗ }
1737
1738 5 bool AirLoopHVACUnitarySystem::setSupplyAirFlowRateDuringCoolingOperation(double supplyAirFlowRateDuringCoolingOperation) {
1739
1/1
✓ Branch 3 taken 5 times.
5 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setSupplyAirFlowRateDuringCoolingOperation(supplyAirFlowRateDuringCoolingOperation);
1740 }
1741
1742 1 void AirLoopHVACUnitarySystem::autosizeSupplyAirFlowRateDuringCoolingOperation() {
1743
1/1
✓ Branch 3 taken 1 time.
1 getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->autosizeSupplyAirFlowRateDuringCoolingOperation();
1744 1 }
1745
1746 1 bool AirLoopHVACUnitarySystem::setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(double supplyAirFlowRatePerFloorAreaDuringCoolingOperation) {
1747
1/1
✓ Branch 3 taken 1 time.
2 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation(
1748 2 supplyAirFlowRatePerFloorAreaDuringCoolingOperation);
1749 }
1750
1751 1 bool AirLoopHVACUnitarySystem::setFractionofAutosizedDesignCoolingSupplyAirFlowRate(double fractionofAutosizedDesignCoolingSupplyAirFlowRate) {
1752
1/1
✓ Branch 3 taken 1 time.
2 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setFractionofAutosizedDesignCoolingSupplyAirFlowRate(
1753 2 fractionofAutosizedDesignCoolingSupplyAirFlowRate);
1754 }
1755
1756 1 bool AirLoopHVACUnitarySystem::setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(
1757 double designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation) {
1758
1/1
✓ Branch 3 taken 1 time.
2 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation(
1759 2 designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation);
1760 }
1761
1762 5 bool AirLoopHVACUnitarySystem::setSupplyAirFlowRateDuringHeatingOperation(double supplyAirFlowRateDuringHeatingOperation) {
1763
1/1
✓ Branch 3 taken 5 times.
5 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setSupplyAirFlowRateDuringHeatingOperation(supplyAirFlowRateDuringHeatingOperation);
1764 }
1765
1766 1 void AirLoopHVACUnitarySystem::autosizeSupplyAirFlowRateDuringHeatingOperation() {
1767
1/1
✓ Branch 3 taken 1 time.
1 getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->autosizeSupplyAirFlowRateDuringHeatingOperation();
1768 1 }
1769
1770 1 bool AirLoopHVACUnitarySystem::setSupplyAirFlowRatePerFloorAreaduringHeatingOperation(double supplyAirFlowRatePerFloorAreaduringHeatingOperation) {
1771
1/1
✓ Branch 3 taken 1 time.
2 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setSupplyAirFlowRatePerFloorAreaduringHeatingOperation(
1772 2 supplyAirFlowRatePerFloorAreaduringHeatingOperation);
1773 }
1774
1775 1 bool AirLoopHVACUnitarySystem::setFractionofAutosizedDesignHeatingSupplyAirFlowRate(double fractionofAutosizedDesignHeatingSupplyAirFlowRate) {
1776
1/1
✓ Branch 3 taken 1 time.
2 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setFractionofAutosizedDesignHeatingSupplyAirFlowRate(
1777 2 fractionofAutosizedDesignHeatingSupplyAirFlowRate);
1778 }
1779
1780 1 bool AirLoopHVACUnitarySystem::setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(
1781 double designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation) {
1782
1/1
✓ Branch 3 taken 1 time.
2 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation(
1783 2 designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation);
1784 }
1785
1786 1 void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired() {
1787
1/1
✓ Branch 3 taken 1 time.
1 getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired();
1788 1 }
1789
1790 1 bool AirLoopHVACUnitarySystem::setSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(double supplyAirFlowRateWhenNoCoolingorHeatingisRequired) {
1791
1/1
✓ Branch 3 taken 1 time.
2 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(
1792 2 supplyAirFlowRateWhenNoCoolingorHeatingisRequired);
1793 }
1794
1795 3 void AirLoopHVACUnitarySystem::autosizeSupplyAirFlowRateWhenNoCoolingorHeatingisRequired() {
1796
1/1
✓ Branch 3 taken 3 times.
3 getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->autosizeSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
1797 3 }
1798
1799 1 bool AirLoopHVACUnitarySystem::setSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired(
1800 double supplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired) {
1801
1/1
✓ Branch 3 taken 1 time.
2 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired(
1802 2 supplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired);
1803 }
1804
1805 1 bool AirLoopHVACUnitarySystem::setFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(
1806 double fractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired) {
1807
1/1
✓ Branch 3 taken 1 time.
2 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(
1808 2 fractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired);
1809 }
1810
1811 1 bool AirLoopHVACUnitarySystem::setFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(
1812 double fractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired) {
1813
1/1
✓ Branch 3 taken 1 time.
2 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired(
1814 2 fractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired);
1815 }
1816
1817 1 bool AirLoopHVACUnitarySystem::setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired(
1818 double designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired) {
1819 2 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()
1820
1/1
✓ Branch 2 taken 1 time.
1 ->setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired(
1821 2 designSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired);
1822 }
1823
1824 2 bool AirLoopHVACUnitarySystem::setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired(
1825 double designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired) {
1826 4 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()
1827
1/1
✓ Branch 2 taken 2 times.
2 ->setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired(
1828 4 designSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired);
1829 }
1830
1831 98 bool AirLoopHVACUnitarySystem::setNoLoadSupplyAirFlowRateControlSetToLowSpeed(bool noLoadSupplyAirFlowRateControlSetToLowSpeed) {
1832
1/1
✓ Branch 3 taken 98 times.
196 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setNoLoadSupplyAirFlowRateControlSetToLowSpeed(
1833 196 noLoadSupplyAirFlowRateControlSetToLowSpeed);
1834 }
1835
1836 97 bool AirLoopHVACUnitarySystem::setMaximumSupplyAirTemperature(double maximumSupplyAirTemperature) {
1837
1/1
✓ Branch 3 taken 97 times.
97 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setMaximumSupplyAirTemperature(maximumSupplyAirTemperature);
1838 }
1839
1840 ✗ void AirLoopHVACUnitarySystem::resetMaximumSupplyAirTemperature() {
1841 ✗ getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetMaximumSupplyAirTemperature();
1842 ✗ }
1843
1844 1 void AirLoopHVACUnitarySystem::autosizeMaximumSupplyAirTemperature() {
1845
1/1
✓ Branch 3 taken 1 time.
1 getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->autosizeMaximumSupplyAirTemperature();
1846 1 }
1847
1848 98 bool AirLoopHVACUnitarySystem::setMaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation(
1849 double maximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation) {
1850
1/1
✓ Branch 3 taken 98 times.
196 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setMaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation(
1851 196 maximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation);
1852 }
1853
1854 ✗ void AirLoopHVACUnitarySystem::resetMaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation() {
1855 ✗ getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetMaximumOutdoorDryBulbTemperatureforSupplementalHeaterOperation();
1856 ✗ }
1857
1858 ✗ bool AirLoopHVACUnitarySystem::setOutdoorDryBulbTemperatureSensorNodeName(const std::string& outdoorDryBulbTemperatureSensorNodeName) {
1859 ✗ return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setOutdoorDryBulbTemperatureSensorNodeName(outdoorDryBulbTemperatureSensorNodeName);
1860 }
1861
1862 ✗ void AirLoopHVACUnitarySystem::resetOutdoorDryBulbTemperatureSensorNodeName() {
1863 ✗ getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetOutdoorDryBulbTemperatureSensorNodeName();
1864 ✗ }
1865
1866 98 bool AirLoopHVACUnitarySystem::setAncilliaryOnCycleElectricPower(double ancilliaryOnCycleElectricPower) {
1867
1/1
✓ Branch 3 taken 98 times.
98 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setAncilliaryOnCycleElectricPower(ancilliaryOnCycleElectricPower);
1868 }
1869
1870 ✗ void AirLoopHVACUnitarySystem::resetAncilliaryOnCycleElectricPower() {
1871 ✗ getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetAncilliaryOnCycleElectricPower();
1872 ✗ }
1873
1874 98 bool AirLoopHVACUnitarySystem::setAncilliaryOffCycleElectricPower(double ancilliaryOffCycleElectricPower) {
1875
1/1
✓ Branch 3 taken 98 times.
98 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setAncilliaryOffCycleElectricPower(ancilliaryOffCycleElectricPower);
1876 }
1877
1878 ✗ void AirLoopHVACUnitarySystem::resetAncilliaryOffCycleElectricPower() {
1879 ✗ getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetAncilliaryOffCycleElectricPower();
1880 ✗ }
1881
1882 // bool AirLoopHVACUnitarySystem::setDesignHeatRecoveryWaterFlowRate(double designHeatRecoveryWaterFlowRate) {
1883 // return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setDesignHeatRecoveryWaterFlowRate(designHeatRecoveryWaterFlowRate);
1884 // }
1885
1886 // void AirLoopHVACUnitarySystem::resetDesignHeatRecoveryWaterFlowRate() {
1887 // getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetDesignHeatRecoveryWaterFlowRate();
1888 // }
1889
1890 // bool AirLoopHVACUnitarySystem::setMaximumTemperatureforHeatRecovery(double maximumTemperatureforHeatRecovery) {
1891 // return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setMaximumTemperatureforHeatRecovery(maximumTemperatureforHeatRecovery);
1892 // }
1893
1894 // void AirLoopHVACUnitarySystem::resetMaximumTemperatureforHeatRecovery() {
1895 // getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetMaximumTemperatureforHeatRecovery();
1896 // }
1897
1898 12 bool AirLoopHVACUnitarySystem::setDesignSpecificationMultispeedObject(const UnitarySystemPerformanceMultispeed& unitarySystemPerformace) {
1899
1/1
✓ Branch 3 taken 12 times.
12 return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->setDesignSpecificationMultispeedObject(unitarySystemPerformace);
1900 }
1901
1902 1 void AirLoopHVACUnitarySystem::resetDesignSpecificationMultispeedObject() {
1903
1/1
✓ Branch 3 taken 1 time.
1 getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->resetDesignSpecificationMultispeedObject();
1904 1 }
1905
1906 ✗ boost::optional<double> AirLoopHVACUnitarySystem::autosizedSupplyAirFlowRateDuringCoolingOperation() const {
1907 ✗ return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->autosizedSupplyAirFlowRateDuringCoolingOperation();
1908 }
1909
1910 ✗ boost::optional<double> AirLoopHVACUnitarySystem::autosizedSupplyAirFlowRateDuringHeatingOperation() const {
1911 ✗ return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->autosizedSupplyAirFlowRateDuringHeatingOperation();
1912 }
1913
1914 ✗ boost::optional<double> AirLoopHVACUnitarySystem::autosizedSupplyAirFlowRateWhenNoCoolingorHeatingisRequired() const {
1915 ✗ return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->autosizedSupplyAirFlowRateWhenNoCoolingorHeatingisRequired();
1916 }
1917
1918 ✗ boost::optional<double> AirLoopHVACUnitarySystem::autosizedMaximumSupplyAirTemperature() const {
1919 ✗ return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->autosizedMaximumSupplyAirTemperature();
1920 }
1921
1922 ✗ boost::optional<double> AirLoopHVACUnitarySystem::autosizedDOASDXCoolingCoilLeavingMinimumAirTemperature() const {
1923 ✗ return getImpl<detail::AirLoopHVACUnitarySystem_Impl>()->autosizedDOASDXCoolingCoilLeavingMinimumAirTemperature();
1924 }
1925
1926 /// @cond
1927 246 AirLoopHVACUnitarySystem::AirLoopHVACUnitarySystem(std::shared_ptr<detail::AirLoopHVACUnitarySystem_Impl> impl)
1928
1/1
✓ Branch 3 taken 246 times.
246 : ZoneHVACComponent(std::move(impl)) {}
1929
1930 // DEPRECATED
1931 1 bool AirLoopHVACUnitarySystem::setSupplyAirFlowRateMethodDuringCoolingOperation(const std::string& supplyAirFlowRateMethodDuringCoolingOperation) {
1932
5/5
✓ 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.
4 DEPRECATED_AT_MSG(3, 7, 0,
1933 "Use setSupplyAirFlowRateDuringCoolingOperation, autosizeSupplyAirFlowRateDuringCoolingOperation, "
1934 "setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation, setFractionofAutosizedDesignCoolingSupplyAirFlowRate, or "
1935 "setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation instead.");
1936 1 return false;
1937 }
1938
1939 1 void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateMethodDuringCoolingOperation() {
1940
5/5
✓ 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.
4 DEPRECATED_AT_MSG(3, 7, 0,
1941 "Use setSupplyAirFlowRateDuringCoolingOperation, autosizeSupplyAirFlowRateDuringCoolingOperation, "
1942 "setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation, setFractionofAutosizedDesignCoolingSupplyAirFlowRate, or "
1943 "setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation instead.");
1944 1 }
1945
1946 1 void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateDuringCoolingOperation() {
1947
5/5
✓ 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.
4 DEPRECATED_AT_MSG(3, 7, 0,
1948 "Use setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation, setFractionofAutosizedDesignCoolingSupplyAirFlowRate, or "
1949 "setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation instead.");
1950 1 }
1951
1952 1 void AirLoopHVACUnitarySystem::resetSupplyAirFlowRatePerFloorAreaDuringCoolingOperation() {
1953
5/5
✓ 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.
4 DEPRECATED_AT_MSG(
1954 3, 7, 0,
1955 "Use setSupplyAirFlowRateDuringCoolingOperation, autosizeSupplyAirFlowRateDuringCoolingOperation, "
1956 "setFractionofAutosizedDesignCoolingSupplyAirFlowRate, or setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation instead.");
1957 1 }
1958
1959 1 void AirLoopHVACUnitarySystem::resetFractionofAutosizedDesignCoolingSupplyAirFlowRate() {
1960
5/5
✓ 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.
4 DEPRECATED_AT_MSG(
1961 3, 7, 0,
1962 "Use setSupplyAirFlowRateDuringCoolingOperation, autosizeSupplyAirFlowRateDuringCoolingOperation, "
1963 "setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation, or setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation instead.");
1964 1 }
1965
1966 1 void AirLoopHVACUnitarySystem::resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperation() {
1967
5/5
✓ 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.
4 DEPRECATED_AT_MSG(3, 7, 0,
1968 "Use setSupplyAirFlowRateDuringCoolingOperation, autosizeSupplyAirFlowRateDuringCoolingOperation, "
1969 "setSupplyAirFlowRatePerFloorAreaDuringCoolingOperation, or setFractionofAutosizedDesignCoolingSupplyAirFlowRate instead.");
1970 1 }
1971
1972 1 bool AirLoopHVACUnitarySystem::setSupplyAirFlowRateMethodDuringHeatingOperation(const std::string& supplyAirFlowRateMethodDuringHeatingOperation) {
1973
5/5
✓ 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.
4 DEPRECATED_AT_MSG(3, 7, 0,
1974 "Use setSupplyAirFlowRateDuringHeatingOperation, autosizeSupplyAirFlowRateDuringHeatingOperation, "
1975 "setSupplyAirFlowRatePerFloorAreaduringHeatingOperation, setFractionofAutosizedDesignHeatingSupplyAirFlowRate, or "
1976 "setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation instead.");
1977 1 return false;
1978 }
1979
1980 1 void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateMethodDuringHeatingOperation() {
1981
5/5
✓ 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.
4 DEPRECATED_AT_MSG(3, 7, 0,
1982 "Use setSupplyAirFlowRateDuringHeatingOperation, autosizeSupplyAirFlowRateDuringHeatingOperation, "
1983 "setSupplyAirFlowRatePerFloorAreaduringHeatingOperation, setFractionofAutosizedDesignHeatingSupplyAirFlowRate, or "
1984 "setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation instead.");
1985 1 }
1986
1987 1 void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateDuringHeatingOperation() {
1988
5/5
✓ 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.
4 DEPRECATED_AT_MSG(3, 7, 0,
1989 "Use setSupplyAirFlowRatePerFloorAreaduringHeatingOperation, setFractionofAutosizedDesignHeatingSupplyAirFlowRate, or "
1990 "setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation instead.");
1991 1 }
1992
1993 1 void AirLoopHVACUnitarySystem::resetSupplyAirFlowRatePerFloorAreaduringHeatingOperation() {
1994
5/5
✓ 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.
4 DEPRECATED_AT_MSG(
1995 3, 7, 0,
1996 "Use setSupplyAirFlowRateDuringHeatingOperation, autosizeSupplyAirFlowRateDuringHeatingOperation, "
1997 "setFractionofAutosizedDesignHeatingSupplyAirFlowRate, or setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation instead.");
1998 1 }
1999
2000 1 void AirLoopHVACUnitarySystem::resetFractionofAutosizedDesignHeatingSupplyAirFlowRate() {
2001
5/5
✓ 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.
4 DEPRECATED_AT_MSG(
2002 3, 7, 0,
2003 "Use setSupplyAirFlowRateDuringHeatingOperation, autosizeSupplyAirFlowRateDuringHeatingOperation, "
2004 "setSupplyAirFlowRatePerFloorAreaduringHeatingOperation, or setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation instead.");
2005 1 }
2006
2007 1 void AirLoopHVACUnitarySystem::resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperation() {
2008
5/5
✓ 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.
4 DEPRECATED_AT_MSG(3, 7, 0,
2009 "Use setSupplyAirFlowRateDuringHeatingOperation, autosizeSupplyAirFlowRateDuringHeatingOperation, "
2010 "setSupplyAirFlowRatePerFloorAreaduringHeatingOperation, or setFractionofAutosizedDesignHeatingSupplyAirFlowRate instead.");
2011 1 }
2012
2013 ✗ bool AirLoopHVACUnitarySystem::setSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired(const std::string& noCoolHeatMethod) {
2014 // setSupplyAirFlowRateWhenNoCoolingorHeatingisRequired, setSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired, setFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired, setFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired, setDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired, setDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired
2015 ✗ DEPRECATED_AT_MSG(3, 7, 0,
2016 "Use resetSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired For 'None', one of the flow rate setters otherwise.");
2017
2018 ✗ if (openstudio::istringEqual("None", noCoolHeatMethod)) {
2019 ✗ resetSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired();
2020 ✗ return true;
2021 }
2022 ✗ return false;
2023 }
2024
2025 ✗ void AirLoopHVACUnitarySystem::resetSupplyAirFlowRateWhenNoCoolingorHeatingisRequired() {
2026 ✗ DEPRECATED_AT_MSG(
2027 3, 7, 0, "Use resetSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired to clear all fields, one of the flow rate setters otherwise.");
2028 ✗ }
2029
2030 ✗ void AirLoopHVACUnitarySystem::resetSupplyAirFlowRatePerFloorAreaWhenNoCoolingorHeatingisRequired() {
2031 ✗ DEPRECATED_AT_MSG(
2032 3, 7, 0, "Use resetSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired to clear all fields, one of the flow rate setters otherwise.");
2033 ✗ }
2034
2035 ✗ void AirLoopHVACUnitarySystem::resetFractionofAutosizedDesignCoolingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired() {
2036 ✗ DEPRECATED_AT_MSG(
2037 3, 7, 0, "Use resetSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired to clear all fields, one of the flow rate setters otherwise.");
2038 ✗ }
2039
2040 ✗ void AirLoopHVACUnitarySystem::resetFractionofAutosizedDesignHeatingSupplyAirFlowRateWhenNoCoolingorHeatingisRequired() {
2041 ✗ DEPRECATED_AT_MSG(
2042 3, 7, 0, "Use resetSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired to clear all fields, one of the flow rate setters otherwise.");
2043 ✗ }
2044
2045 ✗ void AirLoopHVACUnitarySystem::resetDesignSupplyAirFlowRatePerUnitofCapacityDuringCoolingOperationWhenNoCoolingorHeatingisRequired() {
2046 ✗ DEPRECATED_AT_MSG(
2047 3, 7, 0, "Use resetSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired to clear all fields, one of the flow rate setters otherwise.");
2048 ✗ }
2049
2050 ✗ void AirLoopHVACUnitarySystem::resetDesignSupplyAirFlowRatePerUnitofCapacityDuringHeatingOperationWhenNoCoolingorHeatingisRequired() {
2051 ✗ DEPRECATED_AT_MSG(
2052 3, 7, 0, "Use resetSupplyAirFlowRateMethodWhenNoCoolingorHeatingisRequired to clear all fields, one of the flow rate setters otherwise.");
2053 ✗ }
2054
2055 ✗ double AirLoopHVACUnitarySystem::maximumCyclingRate() const {
2056 ✗ DEPRECATED_AT_MSG(3, 7, 0,
2057 "As of EnergyPlus 23.2.0, this property is on the child cooling coil. Use coolingCoil()->maximumCyclingRate() instead.");
2058 ✗ double result = 2.5; // former default
2059 ✗ if (auto c_ = coolingCoil()) {
2060 ✗ if (auto c_eq_ = c_->optionalCast<CoilCoolingWaterToAirHeatPumpEquationFit>()) {
2061 ✗ result = c_eq_->maximumCyclingRate();
2062 ✗ } else if (auto c_vs_ = c_->optionalCast<CoilCoolingWaterToAirHeatPumpVariableSpeedEquationFit>()) {
2063 ✗ result = c_vs_->maximumCyclingRate();
2064 ✗ } else if (auto c_dx_ = c_->optionalCast<CoilCoolingDXVariableSpeed>()) {
2065 ✗ result = c_dx_->maximumCyclingRate();
2066 ✗ }
2067 ✗ }
2068 ✗ return result;
2069 }
2070
2071 ✗ bool AirLoopHVACUnitarySystem::isMaximumCyclingRateDefaulted() const {
2072 ✗ DEPRECATED_AT_MSG(3, 7, 0, "As of EnergyPlus 23.2.0, this property is on the child cooling coil and it's a required-field");
2073 ✗ return false;
2074 }
2075
2076 ✗ bool AirLoopHVACUnitarySystem::setMaximumCyclingRate(double maximumCyclingRate) {
2077 ✗ DEPRECATED_AT_MSG(3, 7, 0,
2078 "As of EnergyPlus 23.2.0, this property is on the child cooling coil. Use coolingCoil()->setMaximumCyclingRate() instead.");
2079 ✗ bool result = false;
2080 ✗ if (auto c_ = coolingCoil()) {
2081 ✗ if (auto c_eq_ = c_->optionalCast<CoilCoolingWaterToAirHeatPumpEquationFit>()) {
2082 ✗ result = c_eq_->setMaximumCyclingRate(maximumCyclingRate);
2083 ✗ } else if (auto c_vs_ = c_->optionalCast<CoilCoolingWaterToAirHeatPumpVariableSpeedEquationFit>()) {
2084 ✗ result = c_vs_->setMaximumCyclingRate(maximumCyclingRate);
2085 ✗ } else if (auto c_dx_ = c_->optionalCast<CoilCoolingDXVariableSpeed>()) {
2086 ✗ result = c_dx_->setMaximumCyclingRate(maximumCyclingRate);
2087 ✗ }
2088 ✗ }
2089 ✗ return result;
2090 }
2091
2092 ✗ void AirLoopHVACUnitarySystem::resetMaximumCyclingRate() {
2093 ✗ DEPRECATED_AT_MSG(3, 7, 0, "As of EnergyPlus 23.2.0, this property is on the child cooling coil and it's a required-field");
2094 ✗ }
2095
2096 ✗ double AirLoopHVACUnitarySystem::heatPumpTimeConstant() const {
2097 ✗ DEPRECATED_AT_MSG(
2098 3, 7, 0, "As of EnergyPlus 23.2.0, this property is on the child cooling coil. Use coolingCoil()->latentCapacityTimeConstant() instead.");
2099 ✗ double result = 60; // former default
2100 ✗ if (auto c_ = coolingCoil()) {
2101 ✗ if (auto c_eq_ = c_->optionalCast<CoilCoolingWaterToAirHeatPumpEquationFit>()) {
2102 ✗ result = c_eq_->latentCapacityTimeConstant();
2103 ✗ } else if (auto c_vs_ = c_->optionalCast<CoilCoolingWaterToAirHeatPumpVariableSpeedEquationFit>()) {
2104 ✗ result = c_vs_->latentCapacityTimeConstant();
2105 ✗ } else if (auto c_dx_ = c_->optionalCast<CoilCoolingDXVariableSpeed>()) {
2106 ✗ result = c_dx_->latentCapacityTimeConstant();
2107 ✗ }
2108 ✗ }
2109 ✗ return result;
2110 }
2111
2112 ✗ bool AirLoopHVACUnitarySystem::isHeatPumpTimeConstantDefaulted() const {
2113 ✗ DEPRECATED_AT_MSG(3, 7, 0, "As of EnergyPlus 23.2.0, this property is on the child cooling coil and it's a required-field");
2114 ✗ return false;
2115 }
2116
2117 ✗ bool AirLoopHVACUnitarySystem::setHeatPumpTimeConstant(double heatPumpTimeConstant) {
2118 ✗ DEPRECATED_AT_MSG(
2119 3, 7, 0, "As of EnergyPlus 23.2.0, this property is on the child cooling coil. Use coolingCoil()->setLatentCapacityTimeConstant() instead.");
2120 ✗ bool result = false;
2121 ✗ if (auto c_ = coolingCoil()) {
2122 ✗ if (auto c_eq_ = c_->optionalCast<CoilCoolingWaterToAirHeatPumpEquationFit>()) {
2123 ✗ result = c_eq_->setLatentCapacityTimeConstant(heatPumpTimeConstant);
2124 ✗ } else if (auto c_vs_ = c_->optionalCast<CoilCoolingWaterToAirHeatPumpVariableSpeedEquationFit>()) {
2125 ✗ result = c_vs_->setLatentCapacityTimeConstant(heatPumpTimeConstant);
2126 ✗ } else if (auto c_dx_ = c_->optionalCast<CoilCoolingDXVariableSpeed>()) {
2127 ✗ result = c_dx_->setLatentCapacityTimeConstant(heatPumpTimeConstant);
2128 ✗ }
2129 ✗ }
2130 ✗ return result;
2131 }
2132
2133 ✗ void AirLoopHVACUnitarySystem::resetHeatPumpTimeConstant() {
2134 ✗ DEPRECATED_AT_MSG(3, 7, 0, "As of EnergyPlus 23.2.0, this property is on the child cooling coil and it's a required-field");
2135 ✗ }
2136
2137 ✗ double AirLoopHVACUnitarySystem::fractionofOnCyclePowerUse() const {
2138 ✗ DEPRECATED_AT_MSG(3, 7, 0, "As of EnergyPlus 23.2.0, this property is no longer used.");
2139 ✗ const double result = 0.01; // former default
2140 ✗ return result;
2141 }
2142
2143 ✗ bool AirLoopHVACUnitarySystem::isFractionofOnCyclePowerUseDefaulted() const {
2144 ✗ DEPRECATED_AT_MSG(3, 7, 0, "As of EnergyPlus 23.2.0, this property is no longer used.");
2145 ✗ return false;
2146 }
2147
2148 ✗ bool AirLoopHVACUnitarySystem::setFractionofOnCyclePowerUse(double fractionofOnCyclePowerUse) {
2149 ✗ DEPRECATED_AT_MSG(3, 7, 0, "As of EnergyPlus 23.2.0, this property is no longer used.");
2150 ✗ return false;
2151 }
2152
2153 ✗ void AirLoopHVACUnitarySystem::resetFractionofOnCyclePowerUse() {
2154 ✗ DEPRECATED_AT_MSG(3, 7, 0, "As of EnergyPlus 23.2.0, this property is no longer used.");
2155 ✗ }
2156
2157 ✗ double AirLoopHVACUnitarySystem::heatPumpFanDelayTime() const {
2158 ✗ DEPRECATED_AT_MSG(3, 7, 0, "As of EnergyPlus 23.2.0, this property is on the child cooling coil. Use coolingCoil()->fanDelayTime() instead.");
2159 ✗ double result = 60; // former default
2160 ✗ if (auto c_ = coolingCoil()) {
2161 ✗ if (auto c_eq_ = c_->optionalCast<CoilCoolingWaterToAirHeatPumpEquationFit>()) {
2162 ✗ result = c_eq_->fanDelayTime();
2163 ✗ } else if (auto c_vs_ = c_->optionalCast<CoilCoolingWaterToAirHeatPumpVariableSpeedEquationFit>()) {
2164 ✗ result = c_vs_->fanDelayTime();
2165 ✗ } else if (auto c_dx_ = c_->optionalCast<CoilCoolingDXVariableSpeed>()) {
2166 ✗ result = c_dx_->fanDelayTime();
2167 ✗ }
2168 ✗ }
2169 ✗ return result;
2170 }
2171
2172 ✗ bool AirLoopHVACUnitarySystem::isHeatPumpFanDelayTimeDefaulted() const {
2173 ✗ DEPRECATED_AT_MSG(3, 7, 0, "As of EnergyPlus 23.2.0, this property is on the child cooling coil and it's a required-field");
2174 ✗ return false;
2175 }
2176
2177 ✗ bool AirLoopHVACUnitarySystem::setHeatPumpFanDelayTime(double heatPumpFanDelayTime) {
2178 ✗ DEPRECATED_AT_MSG(3, 7, 0, "As of EnergyPlus 23.2.0, this property is on the child cooling coil. Use coolingCoil()->setFanDelayTime() instead.");
2179 ✗ bool result = false;
2180 ✗ if (auto c_ = coolingCoil()) {
2181 ✗ if (auto c_eq_ = c_->optionalCast<CoilCoolingWaterToAirHeatPumpEquationFit>()) {
2182 ✗ result = c_eq_->setFanDelayTime(heatPumpFanDelayTime);
2183 ✗ } else if (auto c_vs_ = c_->optionalCast<CoilCoolingWaterToAirHeatPumpVariableSpeedEquationFit>()) {
2184 ✗ result = c_vs_->setFanDelayTime(heatPumpFanDelayTime);
2185 ✗ } else if (auto c_dx_ = c_->optionalCast<CoilCoolingDXVariableSpeed>()) {
2186 ✗ result = c_dx_->setFanDelayTime(heatPumpFanDelayTime);
2187 ✗ }
2188 ✗ }
2189 ✗ return result;
2190 }
2191
2192 ✗ void AirLoopHVACUnitarySystem::resetHeatPumpFanDelayTime() {
2193 ✗ DEPRECATED_AT_MSG(3, 7, 0, "As of EnergyPlus 23.2.0, this property is on the child cooling coil and it's a required-field");
2194 ✗ }
2195
2196 /// @endcond
2197
2198 } // namespace model
2199 } // namespace openstudio
2200