bool WaterToAirComponent_Impl::removeFromPlantLoop()
{
if( auto plant = plantLoop() ) {
return HVACComponent_Impl::removeFromLoop(plant->demandInletNode(),
plant->demandOutletNode(),
waterInletPort(),
waterOutletPort());
}
return false;
}
boost::optional<ModelObject> WaterToAirComponent_Impl::waterOutletModelObject()
{
return connectedObject( waterOutletPort() );
}
bool WaterToAirComponent_Impl::removeFromPlantLoop()
{
boost::optional<PlantLoop> _loop = plantLoop();
OptionalNode targetModelObject;
OptionalNode sourceModelObject;
OptionalUnsigned targetPort;
OptionalUnsigned sourcePort;
OptionalModelObject target2ModelObject;
OptionalModelObject source2ModelObject;
OptionalUnsigned target2Port;
OptionalUnsigned source2Port;
HVACComponent thisObject = getObject<HVACComponent>();
if( _loop && _loop->demandComponent(handle()) )
{
targetModelObject = waterOutletModelObject()->optionalCast<Node>();
sourceModelObject = waterInletModelObject()->optionalCast<Node>();
targetPort = connectedObjectPort(waterOutletPort());
sourcePort = connectedObjectPort(waterInletPort());
target2ModelObject = targetModelObject->outletModelObject();
source2ModelObject = sourceModelObject->inletModelObject();
target2Port = targetModelObject->connectedObjectPort(targetModelObject->outletPort());
source2Port = sourceModelObject->connectedObjectPort(sourceModelObject->inletPort());
boost::optional<Node> demandInletNode = _loop->demandInletNode();
boost::optional<Node> demandOutletNode = _loop->demandOutletNode();
Mixer mixer = _loop->demandMixer();
Splitter splitter = _loop->demandSplitter();
// If the component is stuck directly between the inlet and outlet node.
if( demandInletNode->handle() == waterInletModelObject()->handle()
&&
demandOutletNode->handle() == waterOutletModelObject()->handle() )
{
model().disconnect(thisObject,waterOutletPort());
model().disconnect(thisObject,waterInletPort());
model().connect( demandInletNode.get(), demandInletNode->outletPort(),
demandOutletNode.get(), demandOutletNode->inletPort() );
return true;
}
// If the component is at the very end of the supply path, but there is another component preceeding this one.
else if( demandOutletNode->handle() == waterOutletModelObject()->handle() )
{
model().disconnect(thisObject,waterOutletPort());
model().disconnect(thisObject,waterInletPort());
model().connect( source2ModelObject.get(), source2Port.get(),
demandOutletNode.get(), demandOutletNode->inletPort() );
sourceModelObject->remove();
return true;
}
// If the component is the only component (except nodes) between a splitter mixer pair
else if( (target2ModelObject.get() == mixer) &&
(source2ModelObject.get() == splitter) )
{
Model _model = model();
int i = splitter.branchIndexForOutletModelObject(sourceModelObject.get());
int j = mixer.branchIndexForInletModelObject(targetModelObject.get());
BOOST_ASSERT(i == j);
splitter.removePortForBranch(i);
mixer.removePortForBranch(i);
_model.disconnect(thisObject,waterOutletPort());
_model.disconnect(thisObject,waterInletPort());
targetModelObject->remove();
sourceModelObject->remove();
if( ! splitter.lastOutletModelObject() )
{
Node newNode(_model);
_model.connect(splitter,splitter.nextOutletPort(),newNode,newNode.inletPort());
_model.connect(newNode,newNode.outletPort(),mixer,mixer.nextInletPort());
}
return true;
}
// Else remove the component and the outlet node
else
{
model().disconnect(thisObject,waterOutletPort());
model().disconnect(thisObject,waterInletPort());
model().connect( sourceModelObject.get(), sourcePort.get(),
target2ModelObject.get(), target2Port.get() );
targetModelObject->remove();
return true;
}
}
return false;
}
bool WaterToAirComponent_Impl::addToNode(Node & node)
{
Model _model = node.model();
ModelObject thisModelObject = getObject<ModelObject>();
boost::optional<AirLoopHVACOutdoorAirSystem> oaSystem = node.airLoopHVACOutdoorAirSystem();
if( node.airLoopHVAC() && ! oaSystem )
{
AirLoopHVAC airLoop = node.airLoopHVAC().get();
if( airLoop.demandComponent( node.handle() ) )
{
return false;
}
else
{
if( airLoopHVAC() )
{
removeFromAirLoopHVAC();
}
if( node == airLoop.supplyOutletNode() &&
node.inletModelObject().get() == airLoop.supplyInletNode() )
{
unsigned oldOutletPort = node.connectedObjectPort( node.inletPort() ).get();
unsigned oldInletPort = node.inletPort();
ModelObject oldSourceModelObject = node.connectedObject( node.inletPort() ).get();
ModelObject oldTargetModelObject = node;
_model.connect( oldSourceModelObject, oldOutletPort,
thisModelObject, airInletPort() );
_model.connect( thisModelObject, airOutletPort(),
oldTargetModelObject, oldInletPort );
return true;
}
if( node == airLoop.supplyInletNode() &&
node.outletModelObject().get() == airLoop.supplyOutletNode() )
{
unsigned oldOutletPort = node.outletPort();
unsigned oldInletPort = node.connectedObjectPort( node.outletPort() ).get();
ModelObject oldSourceModelObject = node;
ModelObject oldTargetModelObject = node.outletModelObject().get();
_model.connect( oldSourceModelObject, oldOutletPort,
thisModelObject, airInletPort() );
_model.connect( thisModelObject, airOutletPort(),
oldTargetModelObject, oldInletPort );
return true;
}
else if( node == airLoop.supplyOutletNode() )
{
unsigned oldOutletPort = node.connectedObjectPort( node.inletPort() ).get();
unsigned oldInletPort = node.inletPort();
ModelObject oldSourceModelObject = node.connectedObject( node.inletPort() ).get();
ModelObject oldTargetModelObject = node;
Node newNode( _model );
_model.connect( oldSourceModelObject, oldOutletPort,
newNode, newNode.inletPort() );
_model.connect( newNode, newNode.outletPort(),
thisModelObject, airInletPort() );
_model.connect( thisModelObject, airOutletPort(),
oldTargetModelObject, oldInletPort );
return true;
}
else
{
unsigned oldOutletPort = node.outletPort();
unsigned oldInletPort = node.connectedObjectPort( node.outletPort() ).get();
ModelObject oldSourceModelObject = node;
ModelObject oldTargetModelObject = node.connectedObject( node.outletPort() ).get();
Node newNode( _model );
_model.connect( oldSourceModelObject, oldOutletPort,
thisModelObject, airInletPort() );
_model.connect( thisModelObject, airOutletPort(),
newNode, newNode.inletPort() );
_model.connect( newNode, newNode.outletPort(),
oldTargetModelObject, oldInletPort );
return true;
}
}
}
else if( node.plantLoop() )
{
PlantLoop _plantLoop = node.plantLoop().get();
if( ! _plantLoop.demandComponent( node.handle() ) )
{
return false;
}
else
{
if( plantLoop() )
{
removeFromPlantLoop();
}
if( node == _plantLoop.demandOutletNode() &&
node.inletModelObject().get() == _plantLoop.demandInletNode() )
{
unsigned oldOutletPort = node.connectedObjectPort( node.inletPort() ).get();
unsigned oldInletPort = node.inletPort();
ModelObject oldSourceModelObject = node.connectedObject( node.inletPort() ).get();
ModelObject oldTargetModelObject = node;
_model.connect( oldSourceModelObject, oldOutletPort,
thisModelObject, waterInletPort() );
_model.connect( thisModelObject, waterOutletPort(),
oldTargetModelObject, oldInletPort );
return true;
}
else if( node == _plantLoop.demandOutletNode() )
{
unsigned oldOutletPort = node.connectedObjectPort( node.inletPort() ).get();
unsigned oldInletPort = node.inletPort();
ModelObject oldSourceModelObject = node.connectedObject( node.inletPort() ).get();
ModelObject oldTargetModelObject = node;
Node newNode( _model );
_model.connect( oldSourceModelObject, oldOutletPort,
newNode, newNode.inletPort() );
_model.connect( newNode, newNode.outletPort(),
thisModelObject, waterInletPort() );
_model.connect( thisModelObject, waterOutletPort(),
oldTargetModelObject, oldInletPort );
return true;
}
else
{
unsigned oldOutletPort = node.outletPort();
unsigned oldInletPort = node.connectedObjectPort( node.outletPort() ).get();
ModelObject oldSourceModelObject = node;
ModelObject oldTargetModelObject = node.connectedObject( node.outletPort() ).get();
Node newNode( _model );
_model.connect( oldSourceModelObject, oldOutletPort,
thisModelObject, waterInletPort() );
_model.connect( thisModelObject, waterOutletPort(),
newNode, newNode.inletPort() );
_model.connect( newNode, newNode.outletPort(),
oldTargetModelObject, oldInletPort );
return true;
}
}
}
else
{
return false;
}
}
bool WaterToAirComponent_Impl::addToNode(Node & node)
{
auto _model = node.model();
auto thisModelObject = getObject<ModelObject>();
auto t_airLoop = node.airLoopHVAC();
auto t_plantLoop = node.plantLoop();
auto t_oaSystem = node.airLoopHVACOutdoorAirSystem();
boost::optional<unsigned> componentInletPort;
boost::optional<unsigned> componentOutletPort;
boost::optional<HVACComponent> systemStartComponent;
boost::optional<HVACComponent> systemEndComponent;
if( node.getImpl<Node_Impl>()->isConnected(thisModelObject) ) return false;
if( t_airLoop && ! t_oaSystem )
{
if( t_airLoop->demandComponent( node.handle() ) ) return false;
systemStartComponent = t_airLoop->supplyInletNode();
auto nodes = t_airLoop->supplyOutletNodes();
OS_ASSERT( ! nodes.empty() );
if( (nodes.size() == 2u) && (! t_airLoop->supplyComponents(node,nodes[1]).empty()) ) {
systemEndComponent = nodes[1];
} else {
systemEndComponent = nodes[0];
}
OS_ASSERT(systemEndComponent);
componentInletPort = airInletPort();
componentOutletPort = airOutletPort();
removeFromAirLoopHVAC();
} else if( t_oaSystem ) {
if( t_oaSystem->oaComponent(node.handle()) ) {
systemStartComponent = t_oaSystem->outboardOANode();
systemEndComponent = t_oaSystem.get();
componentInletPort = airInletPort();
componentOutletPort = airOutletPort();
} else if( t_oaSystem->reliefComponent(node.handle()) ) {
systemStartComponent = t_oaSystem.get();
systemEndComponent = t_oaSystem->outboardReliefNode();
componentInletPort = airInletPort();
componentOutletPort = airOutletPort();
}
removeFromAirLoopHVAC();
} else if( t_plantLoop ) {
if( ! t_plantLoop->demandComponent( node.handle() ) ) return false;
systemStartComponent = t_plantLoop->demandInletNode();
systemEndComponent = t_plantLoop->demandOutletNode();
componentInletPort = waterInletPort();
componentOutletPort = waterOutletPort();
removeFromPlantLoop();
}
if( systemStartComponent && systemEndComponent && componentOutletPort && componentInletPort ) {
return HVACComponent_Impl::addToNode(node,systemStartComponent.get(),systemEndComponent.get(),componentInletPort.get(),componentOutletPort.get());
} else {
return false;
}
}
