GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 62.5% 10 / 0 / 16
Functions: 62.5% 5 / 0 / 8
Branches: 60.0% 3 / 0 / 5

src/model/AirflowNetworkComponent.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 "AirflowNetworkComponent.hpp"
7 #include "AirflowNetworkComponent_Impl.hpp"
8 #include "AirLoopHVAC.hpp"
9 #include "AirLoopHVAC_Impl.hpp"
10 #include "PlantLoop.hpp"
11 #include "PlantLoop_Impl.hpp"
12 #include "Node.hpp"
13 #include "Node_Impl.hpp"
14 #include "AirLoopHVACOutdoorAirSystem.hpp"
15 #include "AirLoopHVACOutdoorAirSystem_Impl.hpp"
16 #include "Model.hpp"
17 #include "Model_Impl.hpp"
18 #include "Splitter.hpp"
19 #include "Splitter_Impl.hpp"
20 #include "Mixer.hpp"
21 #include "Mixer_Impl.hpp"
22 #include "../utilities/core/Assert.hpp"
23
24 namespace openstudio {
25
26 namespace model {
27
28 namespace detail {
29
30 ✗ AirflowNetworkComponent_Impl::AirflowNetworkComponent_Impl(IddObjectType type, Model_Impl* model) : ModelObject_Impl(type, model) {}
31
32 31 AirflowNetworkComponent_Impl::AirflowNetworkComponent_Impl(const IdfObject& idfObject, Model_Impl* model, bool keepHandle)
33 31 : ModelObject_Impl(idfObject, model, keepHandle) {}
34
35 ✗ AirflowNetworkComponent_Impl::AirflowNetworkComponent_Impl(const openstudio::detail::WorkspaceObject_Impl& other, Model_Impl* model,
36 ✗ bool keepHandle)
37 ✗ : ModelObject_Impl(other, model, keepHandle) {}
38
39 8 AirflowNetworkComponent_Impl::AirflowNetworkComponent_Impl(const AirflowNetworkComponent_Impl& other, Model_Impl* model, bool keepHandles)
40 8 : ModelObject_Impl(other, model, keepHandles) {}
41
42 ✗ boost::optional<ModelObject> AirflowNetworkComponent_Impl::componentModelObject() const {
43 // base class implementation
44 ✗ return boost::none;
45 }
46
47 /*
48 OptionalModelObject AirflowNetworkComponent_Impl::inletModelObject() const
49 {
50 return connectedObject(inletPort());
51 }
52
53 OptionalModelObject AirflowNetworkComponent_Impl::outletModelObject() const
54 {
55 return connectedObject(outletPort());
56 }
57 bool AirflowNetworkComponent_Impl::removeFromLoop()
58 {
59 if( auto t_oaSystem = airLoopHVACOutdoorAirSystem() ) {
60 if( t_oaSystem->oaComponent(handle()) ) {
61 return HVACComponent_Impl::removeFromLoop(t_oaSystem->outboardOANode().get(),
62 t_oaSystem.get(),
63 inletPort(),
64 outletPort());
65 } else if( t_oaSystem->reliefComponent(handle()) ) {
66 return HVACComponent_Impl::removeFromLoop(t_oaSystem.get(),
67 t_oaSystem->outboardReliefNode().get(),
68 inletPort(),
69 outletPort());
70 }
71 } else if( auto t_loop = loop() ) {
72 if( t_loop->supplyComponent(handle()) ) {
73 return HVACComponent_Impl::removeFromLoop(t_loop->supplyInletNode(),
74 t_loop->supplyOutletNode(),
75 inletPort(),
76 outletPort());
77 } else if( t_loop->demandComponent(handle()) ) {
78 return HVACComponent_Impl::removeFromLoop(t_loop->demandInletNode(),
79 t_loop->demandOutletNode(),
80 inletPort(),
81 outletPort());
82 }
83 }
84
85 return false;
86 }
87
88 std::vector<openstudio::IdfObject> AirflowNetworkComponent_Impl::remove()
89 {
90 removeFromLoop();
91
92 return HVACComponent_Impl::remove();
93 }
94
95 boost::optional<ParentObject> AirflowNetworkComponent_Impl::parent() const
96 {
97 return boost::optional<ParentObject>();
98 }
99
100 std::vector<ModelObject> AirflowNetworkComponent_Impl::children() const
101 {
102 std::vector<ModelObject> result;
103 return result;
104 }
105
106 OptionalAirLoopHVAC AirflowNetworkComponent_Impl::airLoopHVAC() const
107 {
108 return HVACComponent_Impl::airLoopHVAC();
109 }
110
111 void AirflowNetworkComponent_Impl::disconnect()
112 {
113 ModelObject mo = this->getObject<ModelObject>();
114 this->model().disconnect(mo, this->inletPort());
115 this->model().disconnect(mo, this->outletPort());
116 }
117
118 std::vector<HVACComponent> AirflowNetworkComponent_Impl::edges(const boost::optional<HVACComponent> & prev)
119 {
120 std::vector<HVACComponent> edges;
121 if( auto edgeModelObject = outletModelObject() ) {
122 if( auto edgeObject = edgeModelObject->optionalCast<HVACComponent>() ) {
123 edges.push_back(*edgeObject);
124 }
125 }
126 return edges;
127 }
128
129 bool AirflowNetworkComponent_Impl::addToNode(Node & node)
130 {
131 Model _model = node.model();
132 ModelObject thisModelObject = getObject<ModelObject>();
133 auto t_loop = node.loop();
134 auto t_oaSystem = node.airLoopHVACOutdoorAirSystem();
135
136 auto componentInletPort = inletPort();
137 auto componentOutletPort = outletPort();
138
139 boost::optional<HVACComponent> systemStartComponent;
140 boost::optional<HVACComponent> systemEndComponent;
141
142 if( node.getImpl<Node_Impl>()->isConnected(thisModelObject) ) return false;
143
144 if( t_loop && ! t_oaSystem ) {
145 if( t_loop->supplyComponent(node.handle()) ) {
146 systemStartComponent = t_loop->supplyInletNode();
147 auto nodes = t_loop->supplyOutletNodes();
148 OS_ASSERT( ! nodes.empty() );
149 if( (nodes.size() == 2u) && (! t_loop->supplyComponents(node,nodes[1]).empty()) ) {
150 systemEndComponent = nodes[1];
151 } else {
152 systemEndComponent = nodes[0];
153 }
154 OS_ASSERT(systemEndComponent);
155 } else if( t_loop->demandComponent(node.handle()) ) {
156 systemStartComponent = t_loop->demandInletNode();
157 systemEndComponent = t_loop->demandOutletNode();
158 }
159 } else if( t_oaSystem ) {
160 if( t_oaSystem->oaComponent(node.handle()) ) {
161 systemStartComponent = t_oaSystem->outboardOANode();
162 systemEndComponent = t_oaSystem.get();
163 } else if( t_oaSystem->reliefComponent(node.handle()) ) {
164 systemStartComponent = t_oaSystem.get();
165 systemEndComponent = t_oaSystem->outboardReliefNode();
166 }
167 }
168
169 if( systemStartComponent && systemEndComponent ) {
170 removeFromLoop();
171 return HVACComponent_Impl::addToNode(node,systemStartComponent.get(),systemEndComponent.get(),componentInletPort,componentOutletPort);
172 } else {
173 return false;
174 }
175 }
176
177 ModelObject AirflowNetworkComponent_Impl::clone(Model model) const
178 {
179 AirflowNetworkComponent mo = HVACComponent_Impl::clone( model ).cast<AirflowNetworkComponent>();
180
181 mo.setString(mo.inletPort(),"");
182 mo.setString(mo.outletPort(),"");
183
184 return mo;
185 }
186 */
187
188 } // namespace detail
189
190 31 AirflowNetworkComponent::AirflowNetworkComponent(IddObjectType type, const Model& model) : ModelObject(type, model) {
191
1/3
✗ Branch 2 not taken.
✓ Branch 3 taken 31 times.
✗ Branch 5 not taken.
31 OS_ASSERT(getImpl<detail::AirflowNetworkComponent_Impl>());
192 31 }
193
194
1/1
✓ Branch 2 taken 39 times.
39 AirflowNetworkComponent::AirflowNetworkComponent(std::shared_ptr<detail::AirflowNetworkComponent_Impl> p) : ModelObject(p) {}
195
196 8 OptionalModelObject AirflowNetworkComponent::componentModelObject() const {
197
1/1
✓ Branch 3 taken 8 times.
8 return getImpl<detail::AirflowNetworkComponent_Impl>()->componentModelObject();
198 }
199
200 /*
201 OptionalModelObject AirflowNetworkComponent::outletModelObject()
202 {
203 return getImpl<detail::AirflowNetworkComponent_Impl>()->outletModelObject();
204 }
205
206 std::vector<IdfObject> AirflowNetworkComponent::remove()
207 {
208 return getImpl<detail::AirflowNetworkComponent_Impl>()->remove();
209 }
210
211 bool AirflowNetworkComponent::removeFromLoop()
212 {
213 return getImpl<detail::AirflowNetworkComponent_Impl>()->removeFromLoop();
214 }
215
216 OptionalAirLoopHVAC AirflowNetworkComponent::airLoopHVAC() const
217 {
218 return getImpl<detail::AirflowNetworkComponent_Impl>()->airLoopHVAC();
219 }
220
221 bool AirflowNetworkComponent::addToNode(Node & node)
222 {
223 return getImpl<detail::AirflowNetworkComponent_Impl>()->addToNode( node );
224 }
225
226 ModelObject AirflowNetworkComponent::clone(Model model) const
227 {
228 return getImpl<detail::AirflowNetworkComponent_Impl>()->clone( model );
229 }
230
231 void AirflowNetworkComponent::disconnect()
232 {
233 getImpl<detail::AirflowNetworkComponent_Impl>()->disconnect();
234 }
235 */
236
237 } // namespace model
238
239 } // namespace openstudio
240