GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 16.9% 24 / 0 / 142
Functions: 20.6% 7 / 0 / 34
Branches: 13.2% 19 / 0 / 144

src/model/TemperingValve.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 "TemperingValve.hpp"
7 #include "TemperingValve_Impl.hpp"
8 #include "Node.hpp"
9 #include "Node_Impl.hpp"
10 #include "Mixer.hpp"
11 #include "Mixer_Impl.hpp"
12 #include "PumpConstantSpeed.hpp"
13 #include "PumpConstantSpeed_Impl.hpp"
14 #include "PumpVariableSpeed.hpp"
15 #include "PumpVariableSpeed_Impl.hpp"
16 #include "HeaderedPumpsConstantSpeed.hpp"
17 #include "HeaderedPumpsConstantSpeed_Impl.hpp"
18 #include "HeaderedPumpsVariableSpeed.hpp"
19 #include "HeaderedPumpsVariableSpeed_Impl.hpp"
20
21 #include "../utilities/core/Assert.hpp"
22 #include "../utilities/data/DataEnums.hpp"
23
24 #include <utilities/idd/IddFactory.hxx>
25 #include <utilities/idd/OS_TemperingValve_FieldEnums.hxx>
26
27 namespace openstudio {
28 namespace model {
29
30 namespace detail {
31
32 4 TemperingValve_Impl::TemperingValve_Impl(const IdfObject& idfObject, Model_Impl* model, bool keepHandle)
33 4 : StraightComponent_Impl(idfObject, model, keepHandle) {
34
4/6
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
✓ Branch 7 taken 4 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 4 times.
✗ Branch 13 not taken.
4 OS_ASSERT(idfObject.iddObject().type() == TemperingValve::iddObjectType());
35 4 }
36
37 ✗ TemperingValve_Impl::TemperingValve_Impl(const openstudio::detail::WorkspaceObject_Impl& other, Model_Impl* model, bool keepHandle)
38 ✗ : StraightComponent_Impl(other, model, keepHandle) {
39 ✗ OS_ASSERT(other.iddObject().type() == TemperingValve::iddObjectType());
40 ✗ }
41
42 ✗ TemperingValve_Impl::TemperingValve_Impl(const TemperingValve_Impl& other, Model_Impl* model, bool keepHandle)
43 ✗ : StraightComponent_Impl(other, model, keepHandle) {}
44
45 ✗ const std::vector<std::string>& TemperingValve_Impl::outputVariableNames() const {
46 ✗ static const std::vector<std::string> result;
47 // Not appropriate: no specific output variables
48 ✗ return result;
49 }
50
51 27 IddObjectType TemperingValve_Impl::iddObjectType() const {
52 27 return TemperingValve::iddObjectType();
53 }
54
55 ✗ boost::optional<Node> TemperingValve_Impl::stream2SourceNode() const {
56 ✗ return getObject<ModelObject>().getModelObjectTarget<Node>(OS_TemperingValveFields::Stream2SourceNode);
57 }
58
59 ✗ boost::optional<Node> TemperingValve_Impl::temperatureSetpointNode() const {
60 ✗ return getObject<ModelObject>().getModelObjectTarget<Node>(OS_TemperingValveFields::TemperatureSetpointNode);
61 }
62
63 ✗ boost::optional<Node> TemperingValve_Impl::pumpOutletNode() const {
64 ✗ return getObject<ModelObject>().getModelObjectTarget<Node>(OS_TemperingValveFields::PumpOutletNode);
65 }
66
67 ✗ bool TemperingValve_Impl::setStream2SourceNode(const boost::optional<Node>& stream2SourceNode) {
68 ✗ bool result(false);
69 ✗ if (stream2SourceNode) {
70 ✗ result = setPointer(OS_TemperingValveFields::Stream2SourceNode, stream2SourceNode.get().handle());
71 } else {
72 ✗ resetStream2SourceNode();
73 ✗ result = true;
74 }
75 ✗ return result;
76 }
77
78 ✗ void TemperingValve_Impl::resetStream2SourceNode() {
79 ✗ bool result = setString(OS_TemperingValveFields::Stream2SourceNode, "");
80 ✗ OS_ASSERT(result);
81 ✗ }
82
83 ✗ bool TemperingValve_Impl::setTemperatureSetpointNode(const boost::optional<Node>& temperatureSetpointNode) {
84 ✗ bool result(false);
85 ✗ if (temperatureSetpointNode) {
86 ✗ result = setPointer(OS_TemperingValveFields::TemperatureSetpointNode, temperatureSetpointNode.get().handle());
87 } else {
88 ✗ resetTemperatureSetpointNode();
89 ✗ result = true;
90 }
91 ✗ return result;
92 }
93
94 ✗ void TemperingValve_Impl::resetTemperatureSetpointNode() {
95 ✗ bool result = setString(OS_TemperingValveFields::TemperatureSetpointNode, "");
96 ✗ OS_ASSERT(result);
97 ✗ }
98
99 ✗ bool TemperingValve_Impl::setPumpOutletNode(const boost::optional<Node>& pumpOutletNode) {
100 ✗ bool result(false);
101 ✗ if (pumpOutletNode) {
102 ✗ result = setPointer(OS_TemperingValveFields::PumpOutletNode, pumpOutletNode.get().handle());
103 } else {
104 ✗ resetPumpOutletNode();
105 ✗ result = true;
106 }
107 ✗ return result;
108 }
109
110 ✗ void TemperingValve_Impl::resetPumpOutletNode() {
111 ✗ bool result = setString(OS_TemperingValveFields::PumpOutletNode, "");
112 ✗ OS_ASSERT(result);
113 ✗ }
114
115 3 unsigned TemperingValve_Impl::inletPort() const {
116 3 return OS_TemperingValveFields::InletNodeName;
117 }
118
119 51 unsigned TemperingValve_Impl::outletPort() const {
120 51 return OS_TemperingValveFields::OutletNodeName;
121 }
122
123 ✗ bool TemperingValve_Impl::setControlNodes() {
124 ✗ auto plant = plantLoop();
125
126 ✗ if (!plant) {
127 ✗ return false;
128 }
129
130 ✗ bool ok = true;
131
132 ✗ if (!pumpOutletNode()) {
133 ✗ std::vector<ModelObject> allpumps;
134 ✗ auto pumps = plant->supplyComponents(PumpVariableSpeed::iddObjectType());
135 ✗ allpumps.insert(allpumps.end(), pumps.begin(), pumps.end());
136 ✗ pumps = plant->supplyComponents(PumpConstantSpeed::iddObjectType());
137 ✗ allpumps.insert(allpumps.end(), pumps.begin(), pumps.end());
138 ✗ pumps = plant->supplyComponents(HeaderedPumpsConstantSpeed::iddObjectType());
139 ✗ allpumps.insert(allpumps.end(), pumps.begin(), pumps.end());
140 ✗ pumps = plant->supplyComponents(HeaderedPumpsVariableSpeed::iddObjectType());
141 ✗ allpumps.insert(allpumps.end(), pumps.begin(), pumps.end());
142
143 ✗ if (!allpumps.empty()) {
144 ✗ if (auto mo = allpumps.back().cast<StraightComponent>().outletModelObject()) {
145 ✗ if (auto node = mo->optionalCast<Node>()) {
146 ✗ ok &= setPumpOutletNode(node);
147 ✗ }
148 ✗ }
149 }
150 ✗ }
151
152 ✗ if (!temperatureSetpointNode()) {
153 ✗ auto node = plant->supplyOutletNode();
154 ✗ ok &= setTemperatureSetpointNode(node);
155 ✗ }
156
157 ✗ auto mixer = plant->supplyMixer();
158
159 ✗ if (!stream2SourceNode()) {
160 ✗ auto thisObject = getObject<TemperingValve>();
161 ✗ auto inletObjects = mixer.inletModelObjects();
162 ✗ for (auto& inletObject : inletObjects) {
163 ✗ if (auto node = inletObject.optionalCast<Node>()) {
164 ✗ if (plant->supplyComponents(thisObject, node.get()).empty()) {
165 ✗ ok &= setStream2SourceNode(node.get());
166 }
167 ✗ }
168 }
169 ✗ }
170
171 ✗ return ok;
172 ✗ }
173
174 3 bool TemperingValve_Impl::addToNode(Node& node) {
175
1/1
✓ Branch 1 taken 3 times.
3 auto plant = node.plantLoop();
176
177
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
3 if (!plant) {
178 ✗ return false;
179 }
180
181
4/5
✓ Branch 1 taken 3 times.
✓ Branch 4 taken 3 times.
✓ Branch 7 taken 3 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 3 times.
3 if (!plant->supplyComponent(node.handle())) {
182 ✗ return false;
183 }
184
185
1/1
✓ Branch 1 taken 3 times.
3 return StraightComponent_Impl::addToNode(node);
186 3 }
187
188 ✗ ComponentType TemperingValve_Impl::componentType() const {
189 ✗ return ComponentType::None;
190 }
191
192 ✗ std::vector<FuelType> TemperingValve_Impl::coolingFuelTypes() const {
193 ✗ return {};
194 }
195
196 ✗ std::vector<FuelType> TemperingValve_Impl::heatingFuelTypes() const {
197 ✗ return {};
198 }
199
200 ✗ std::vector<AppGFuelType> TemperingValve_Impl::appGHeatingFuelTypes() const {
201 ✗ return {};
202 }
203
204 } // namespace detail
205
206 4 TemperingValve::TemperingValve(const Model& model) : StraightComponent(TemperingValve::iddObjectType(), model) {
207
1/3
✗ Branch 2 not taken.
✓ Branch 3 taken 4 times.
✗ Branch 5 not taken.
4 OS_ASSERT(getImpl<detail::TemperingValve_Impl>());
208
2/2
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
8 setString(OS_TemperingValveFields::Stream2SourceNode, " ");
209
2/2
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
8 setString(OS_TemperingValveFields::TemperatureSetpointNode, " ");
210
2/2
✓ Branch 1 taken 4 times.
✓ Branch 4 taken 4 times.
8 setString(OS_TemperingValveFields::PumpOutletNode, " ");
211 4 }
212
213 7642 IddObjectType TemperingValve::iddObjectType() {
214
1/1
✓ Branch 1 taken 7642 times.
7642 return {IddObjectType::OS_TemperingValve};
215 }
216
217 ✗ boost::optional<Node> TemperingValve::stream2SourceNode() const {
218 ✗ return getImpl<detail::TemperingValve_Impl>()->stream2SourceNode();
219 }
220
221 ✗ boost::optional<Node> TemperingValve::temperatureSetpointNode() const {
222 ✗ return getImpl<detail::TemperingValve_Impl>()->temperatureSetpointNode();
223 }
224
225 ✗ boost::optional<Node> TemperingValve::pumpOutletNode() const {
226 ✗ return getImpl<detail::TemperingValve_Impl>()->pumpOutletNode();
227 }
228
229 ✗ bool TemperingValve::setStream2SourceNode(const Node& stream2SourceNode) {
230 ✗ return getImpl<detail::TemperingValve_Impl>()->setStream2SourceNode(stream2SourceNode);
231 }
232
233 ✗ void TemperingValve::resetStream2SourceNode() {
234 ✗ getImpl<detail::TemperingValve_Impl>()->resetStream2SourceNode();
235 ✗ }
236
237 ✗ bool TemperingValve::setTemperatureSetpointNode(const Node& temperatureSetpointNode) {
238 ✗ return getImpl<detail::TemperingValve_Impl>()->setTemperatureSetpointNode(temperatureSetpointNode);
239 }
240
241 ✗ void TemperingValve::resetTemperatureSetpointNode() {
242 ✗ getImpl<detail::TemperingValve_Impl>()->resetTemperatureSetpointNode();
243 ✗ }
244
245 ✗ bool TemperingValve::setPumpOutletNode(const Node& pumpOutletNode) {
246 ✗ return getImpl<detail::TemperingValve_Impl>()->setPumpOutletNode(pumpOutletNode);
247 }
248
249 ✗ void TemperingValve::resetPumpOutletNode() {
250 ✗ getImpl<detail::TemperingValve_Impl>()->resetPumpOutletNode();
251 ✗ }
252
253 /// @cond
254 ✗ TemperingValve::TemperingValve(std::shared_ptr<detail::TemperingValve_Impl> impl) : StraightComponent(std::move(impl)) {}
255 /// @endcond
256
257 } // namespace model
258 } // namespace openstudio
259