bool CoilSystemCoolingWaterHeatExchangerAssisted_Impl::addToNode(Node & node)
{
bool result = false;
if( boost::optional<AirLoopHVAC> airLoop = node.airLoopHVAC() ) {
if( ! airLoop->demandComponent(node.handle()) ) {
result = StraightComponent_Impl::addToNode( node );
if( result ) {
auto t_coolingCoil = coolingCoil();
if( auto waterInletModelObject = t_coolingCoil.waterInletModelObject() ) {
if( auto coilCoolingWater = t_coolingCoil.optionalCast<CoilCoolingWater>() ) {
if( auto oldController = coilCoolingWater->controllerWaterCoil() ) {
oldController->remove();
}
}
auto t_model = model();
ControllerWaterCoil controller(t_model);
auto coilWaterInletNode = waterInletModelObject->optionalCast<Node>();
OS_ASSERT(coilWaterInletNode);
controller.setActuatorNode(coilWaterInletNode.get());
// sensor node will be established in translator since that node does not yet exist
controller.setAction("Reverse");
}
}
}
}
return result;
}
boost::optional<ControllerWaterCoil> CoilCoolingWater_Impl::controllerWaterCoil()
{
boost::optional<Node> coilWaterInletNode;
if( boost::optional<ModelObject> mo = waterInletModelObject() )
{
coilWaterInletNode = mo->optionalCast<Node>();
}
if( coilWaterInletNode )
{
std::vector<ControllerWaterCoil> controllers = this->model().getConcreteModelObjects<ControllerWaterCoil>();
for( std::vector<ControllerWaterCoil>::iterator it = controllers.begin();
it < controllers.end();
++it )
{
if( it->actuatorNode() == coilWaterInletNode )
{
return *it;
}
}
}
return boost::none;
}
bool CoilHeatingWater_Impl::addToNode(Node & node)
{
bool success = WaterToAirComponent_Impl::addToNode( node );
if( success && (! containingHVACComponent()) && (! containingZoneHVACComponent()) ) {
if( boost::optional<ModelObject> _waterInletModelObject = waterInletModelObject() ) {
if( auto oldController = controllerWaterCoil() ) {
oldController->remove();
}
Model _model = model();
ControllerWaterCoil controller(_model);
controller.getImpl<detail::ControllerWaterCoil_Impl>()->setWaterCoil(getObject<HVACComponent>());
controller.setAction("Normal");
}
}
return success;
}
bool CoilCoolingWater_Impl::addToNode(Node & node)
{
bool success;
success = WaterToAirComponent_Impl::addToNode( node );
if( success && (! containingHVACComponent()) && (! containingZoneHVACComponent()) )
{
if( boost::optional<ModelObject> _waterInletModelObject = waterInletModelObject() )
{
Model _model = model();
boost::optional<ControllerWaterCoil> oldController;
oldController = controllerWaterCoil();
if( oldController )
{
oldController->remove();
}
ControllerWaterCoil controller(_model);
boost::optional<Node> coilWaterInletNode = _waterInletModelObject->optionalCast<Node>();
OS_ASSERT(coilWaterInletNode);
controller.setActuatorNode(coilWaterInletNode.get());
if( boost::optional<ModelObject> mo = airOutletModelObject() )
{
if( boost::optional<Node> coilAirOutletNode = mo->optionalCast<Node>() )
{
controller.setSensorNode(coilAirOutletNode.get());
}
}
controller.setAction("Reverse");
}
}
return success;
}
std::vector<HVACComponent> WaterToAirComponent_Impl::edges(const boost::optional<HVACComponent> & prev)
{
std::vector<HVACComponent> edges;
auto pushWaterOutletModelObject = [&]() {
if( auto edgeModelObject = waterOutletModelObject() ) {
auto edgeHVACComponent = edgeModelObject->optionalCast<HVACComponent>();
OS_ASSERT(edgeHVACComponent);
edges.push_back(edgeHVACComponent.get());
}
};
auto pushAirOutletModelObject = [&]() {
if( auto edgeModelObject = airOutletModelObject() ) {
auto edgeHVACComponent = edgeModelObject->optionalCast<HVACComponent>();
OS_ASSERT(edgeHVACComponent);
edges.push_back(edgeHVACComponent.get());
}
};
if( prev) {
if( auto inletModelObject = waterInletModelObject() ) {
if( prev.get() == inletModelObject.get() ) {
pushWaterOutletModelObject();
return edges;
}
}
if( auto inletModelObject = airInletModelObject() ) {
if( prev.get() == inletModelObject.get() ) {
pushAirOutletModelObject();
return edges;
}
}
} else {
pushWaterOutletModelObject();
pushAirOutletModelObject();
return edges;
}
return edges;
}
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;
}
