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 |