ModelObject ZoneHVACComponent_Impl::clone(Model model) const
{
auto clone = ModelObject_Impl::clone(model).cast<ZoneHVACComponent>();
if( clone.inletPort() != 0u ) {
clone.setString(clone.inletPort(),"");
}
if( clone.outletPort() != 0u ) {
clone.setString(clone.outletPort(),"");
}
return clone;
}
void Mixer_Impl::removePortForBranch(unsigned branchIndex)
{
int _nextBranchIndex = nextBranchIndex();
model().disconnect(getObject<ModelObject>(),inletPort(branchIndex));
for(int i = branchIndex + 1; i < _nextBranchIndex; i++ )
{
ModelObject mo = inletModelObject(i).get();
unsigned port = connectedObjectPort( inletPort(i) ).get();
model().disconnect(getObject<ModelObject>(),inletPort(i));
model().connect(mo,port,getObject<ModelObject>(),inletPort(i-1));
}
}
unsigned Mixer_Impl::newInletPortAfterBranch(unsigned branchIndex)
{
//std::vector<ModelObject> modelObjects = inletModelObjects();
unsigned stop = nextBranchIndex();
for(unsigned i = branchIndex; i < stop; i++ )
{
ModelObject mo = inletModelObject(i).get();
unsigned port = connectedObjectPort( inletPort(i) ).get();
model().connect(getObject<ModelObject>(),inletPort(i+2),mo,port);
}
Model _model = model();
Node node( _model );
_model.connect( node,node.outletPort(),getObject<ModelObject>(),inletPort(branchIndex+1) );
return inletPort(branchIndex++);
}
void AirLoopHVACZoneMixer_Impl::disconnect()
{
ModelObject mo = this->getObject<ModelObject>();
model().disconnect(mo,outletPort());
for( int i = 0; i < int(nextBranchIndex()); i++ )
{
model().disconnect(mo,inletPort(i));
}
}
std::vector<openstudio::IdfObject> ConnectorMixer_Impl::remove()
{
OptionalMixer self = model().getModelObject<Mixer>(handle());
model().disconnect(*self,outletPort());
for( int i = 0; i < int(nextBranchIndex()) - 1; i++ )
{
model().disconnect(*self,inletPort(i));
}
return ModelObject_Impl::remove();
}
std::vector<IdfObject> AirTerminalSingleDuctVAVHeatAndCoolNoReheat_Impl::remove()
{
Model _model = this->model();
ModelObject thisObject = this->getObject<ModelObject>();
boost::optional<ModelObject> sourceModelObject = this->inletModelObject();
boost::optional<unsigned> sourcePort = this->connectedObjectPort(this->inletPort());
boost::optional<ModelObject> targetModelObject = this->outletModelObject();
boost::optional<unsigned> targetPort = this->connectedObjectPort(this->outletPort());
std::vector<ThermalZone> thermalZones = _model.getConcreteModelObjects<ThermalZone>();
for( auto & thermalZone : thermalZones )
{
std::vector<ModelObject> equipment = thermalZone.equipment();
if( std::find(equipment.begin(),equipment.end(),thisObject) != equipment.end() )
{
thermalZone.removeEquipment(thisObject);
break;
}
}
if( sourcePort && sourceModelObject
&& targetPort && targetModelObject )
{
if( boost::optional<Node> inletNode = sourceModelObject->optionalCast<Node>() )
{
if( boost::optional<ModelObject> source2ModelObject = inletNode->inletModelObject() )
{
if( boost::optional<unsigned> source2Port = inletNode->connectedObjectPort(inletNode->inletPort()) )
{
_model.connect( source2ModelObject.get(),
source2Port.get(),
targetModelObject.get(),
targetPort.get() );
inletNode->disconnect();
inletNode->remove();
return StraightComponent_Impl::remove();
}
}
}
}
model().disconnect(getObject<ModelObject>(),inletPort());
model().disconnect(getObject<ModelObject>(),outletPort());
return StraightComponent_Impl::remove();
}
bool ConnectorSplitter_Impl::addToNode(Node & node)
{
auto t_model = model();
if( node.model() != t_model ) {
return false;
}
if( loop() ) {
return false;
}
if( ! outletModelObjects().empty() ) {
LOG(Warn, briefDescription() << " must not have existing outlet connections to use addToNode method.");
return false;
}
auto t_nodeAirLoop = node.airLoopHVAC();
if( ! t_nodeAirLoop ) {
LOG(Warn, briefDescription() << " must be added to an AirLoopHVAC supply node use addToNode method.");
return false;
}
if( ! t_nodeAirLoop->supplyComponent(node.handle()) ) {
LOG(Warn, briefDescription() << " must be added to an AirLoopHVAC supply node use addToNode method.");
return false;
}
if( ! t_nodeAirLoop->supplyComponents(iddObjectType()).empty() ) {
LOG(Warn, briefDescription() << " already has a splitter.");
return false;
}
auto supplyInletNode = t_nodeAirLoop->supplyInletNode();
auto supplyOutletNode = t_nodeAirLoop->supplyOutletNode();
// Hook Up Duct "A"
auto t_inletPort = inletPort();
auto portA = nextOutletPort();
HVACComponent_Impl::addToNode(node, supplyInletNode, supplyOutletNode, t_inletPort, portA);
// Hook Up Duct "B"
Node supplyOutletNodeB(t_model);
auto thisObject = getObject<model::HVACComponent>();
auto portB = nextOutletPort();
t_model.connect(thisObject,portB,supplyOutletNodeB,supplyOutletNodeB.inletPort());
t_model.connect(supplyOutletNodeB,supplyOutletNodeB.outletPort(),t_nodeAirLoop.get(),t_nodeAirLoop->getImpl<detail::AirLoopHVAC_Impl>()->supplyOutletPortB());
return true;
}
bool AirTerminalSingleDuctUncontrolled_Impl::addToNode(Node & node)
{
Model _model = node.model();
if( boost::optional<ModelObject> outlet = node.outletModelObject() )
{
boost::optional<ThermalZone> thermalZone;
if( boost::optional<PortList> portList = outlet->optionalCast<PortList>() )
{
thermalZone = portList->thermalZone();
}
if( thermalZone || (outlet->optionalCast<Mixer>() && node.airLoopHVAC()) )
{
if( boost::optional<ModelObject> inlet = node.inletModelObject() )
{
if( boost::optional<Splitter> splitter = inlet->optionalCast<Splitter>() )
{
boost::optional<ModelObject> sourceModelObject = node.inletModelObject();
boost::optional<unsigned> sourcePort = node.connectedObjectPort(node.inletPort());
if( sourcePort && sourceModelObject )
{
_model.connect( sourceModelObject.get(),
sourcePort.get(),
this->getObject<ModelObject>(),
inletPort() );
_model.connect( this->getObject<ModelObject>(),
outletPort(),
node,
node.inletPort() );
if( thermalZone )
{
AirTerminalSingleDuctUncontrolled mo = this->getObject<AirTerminalSingleDuctUncontrolled>();
thermalZone->addEquipment(mo);
}
return true;
}
}
}
}
}
return false;
}
bool ZoneHVACComponent_Impl::addToNode(Node & node)
{
bool result = false;
boost::optional<ThermalZone> thermalZone;
boost::optional<AirTerminalSingleDuctInletSideMixer> terminal;
if( boost::optional<ModelObject> outlet = node.outletModelObject() ) {
if( boost::optional<PortList> pl = outlet->optionalCast<PortList>() ) {
thermalZone = pl->thermalZone();
}
}
if( boost::optional<ModelObject> inlet = node.inletModelObject() ) {
terminal = inlet->optionalCast<AirTerminalSingleDuctInletSideMixer>();
}
if( thermalZone && terminal ) {
if( this->thermalZone() ) {
removeFromThermalZone();
}
thermalZone->setUseIdealAirLoads(false);
ZoneHVACComponent thisObject = getObject<ZoneHVACComponent>();
thermalZone->addEquipment(thisObject);
thermalZone->setCoolingPriority(thisObject,1);
thermalZone->setHeatingPriority(thisObject,1);
Model t_model = model();
ModelObject thisModelObject = getObject<model::ZoneHVACComponent>();
unsigned targetPort = node.connectedObjectPort( node.outletPort() ).get();
ModelObject targetModelObject = node.connectedObject( node.outletPort() ).get();
Node newNode( t_model );
t_model.connect( node, node.outletPort(),
thisModelObject, inletPort() );
t_model.connect( thisModelObject, outletPort(),
newNode, newNode.inletPort() );
t_model.connect( newNode, newNode.outletPort(),
targetModelObject, targetPort );
Node exhaustNode(t_model);
PortList exhaustPortList = thermalZone->exhaustPortList();
unsigned nextPort = exhaustPortList.nextPort();
t_model.connect(exhaustPortList,nextPort,exhaustNode,exhaustNode.inletPort());
t_model.connect(exhaustNode,exhaustNode.outletPort(),terminal.get(),terminal->secondaryAirInletPort());
result = true;
}
return result;
}
boost::optional<Node> ZoneHVACComponent_Impl::inletNode() const
{
boost::optional<ModelObject> mo = connectedObject(inletPort());
boost::optional<Node> result;
if( mo )
{
if( boost::optional<Node> node = mo->optionalCast<Node>() )
{
result = node;
}
}
return result;
}
std::vector<openstudio::IdfObject> AirLoopHVACZoneSplitter_Impl::remove()
{
if( this->airLoopHVAC() )
{
return std::vector<openstudio::IdfObject>();
}
else
{
OptionalAirLoopHVACZoneSplitter self = model().getModelObject<AirLoopHVACZoneSplitter>(handle());
model().disconnect(*self,inletPort());
for( int i = 0; i < int(nextBranchIndex()) - 1; i++ )
{
model().disconnect(*self,outletPort(i));
}
return HVACComponent_Impl::remove();
}
}
std::vector<IdfObject> AirTerminalSingleDuctUncontrolled_Impl::remove()
{
Model _model = this->model();
ModelObject thisObject = this->getObject<ModelObject>();
boost::optional<ModelObject> sourceModelObject = this->inletModelObject();
boost::optional<unsigned> sourcePort = this->connectedObjectPort(this->inletPort());
boost::optional<ModelObject> targetModelObject = this->outletModelObject();
boost::optional<unsigned> targetPort = this->connectedObjectPort(this->outletPort());
std::vector<ThermalZone> thermalZones = _model.getConcreteModelObjects<ThermalZone>();
for( auto & thermalZone : thermalZones )
{
std::vector<ModelObject> equipment = thermalZone.equipment();
if( std::find(equipment.begin(),equipment.end(),thisObject) != equipment.end() )
{
thermalZone.removeEquipment(thisObject);
break;
}
}
if( sourcePort && sourceModelObject
&& targetPort && targetModelObject )
{
_model.connect( sourceModelObject.get(),
sourcePort.get(),
targetModelObject.get(),
targetPort.get() );
return ModelObject_Impl::remove();
}
else
{
model().disconnect(getObject<ModelObject>(),inletPort());
model().disconnect(getObject<ModelObject>(),outletPort());
return ModelObject_Impl::remove();
}
}
bool ZoneHVACComponent_Impl::addToThermalZone(ThermalZone & thermalZone)
{
Model m = this->model();
if( thermalZone.model() != m ) {
return false;
}
if( thermalZone.isPlenum() ) {
return false;
}
removeFromThermalZone();
thermalZone.setUseIdealAirLoads(false);
// Connect nodes if this is an air based zone hvac component
if( inletPort() != 0u && outletPort() != 0u ) {
// Exhaust Node
Node exhaustNode(m);
PortList exhaustPortList = thermalZone.exhaustPortList();
unsigned nextPort = exhaustPortList.nextPort();
m.connect(exhaustPortList,nextPort,exhaustNode,exhaustNode.inletPort());
ModelObject mo = this->getObject<ModelObject>();
m.connect(exhaustNode,exhaustNode.outletPort(),mo,this->inletPort());
// Air Inlet Node
Node airInletNode(m);
PortList inletPortList = thermalZone.inletPortList();
unsigned nextInletPort = inletPortList.nextPort();
m.connect(airInletNode,airInletNode.outletPort(),inletPortList,nextInletPort);
m.connect(mo,this->outletPort(),airInletNode,airInletNode.inletPort());
}
thermalZone.addEquipment(this->getObject<ZoneHVACComponent>());
return true;
}
boost::optional<ThermalZone> FanZoneExhaust_Impl::thermalZone()
{
boost::optional<ThermalZone> result;
if( boost::optional<ModelObject> mo1 = connectedObject(inletPort()) )
{
if( boost::optional<Node> node = mo1->optionalCast<Node>() )
{
if( boost::optional<ModelObject> mo2 = node->inletModelObject() )
{
if( boost::optional<PortList> pl = mo2->optionalCast<PortList>() )
{
if( boost::optional<ThermalZone> tz = pl->thermalZone() )
{
result = tz;
}
}
}
}
}
return result;
}
bool AirTerminalDualDuctVAVOutdoorAir_Impl::addToNode(Node & node)
{
auto mo = getObject<AirTerminalDualDuctVAVOutdoorAir>();
return AirLoopHVAC_Impl::addDualDuctTerminalToNode(mo,inletPort(0),inletPort(1),outletPort(),node);
}
std::vector<IdfObject> AirTerminalDualDuctVAVOutdoorAir_Impl::remove() {
auto modelObject = getObject<AirTerminalDualDuctVAVOutdoorAir>();
AirLoopHVAC_Impl::removeDualDuctTerminalFromAirLoopHVAC(modelObject,inletPort(0),inletPort(1),outletPort());
return Mixer_Impl::remove();
}
boost::optional<ModelObject> Splitter_Impl::inletModelObject()
{
return connectedObject( inletPort() );
}
boost::optional<ModelObject> Mixer_Impl::inletModelObject(unsigned branchIndex)
{
return connectedObject( inletPort( branchIndex ) );
}
bool HVACComponent_Impl::removeFromLoop( const HVACComponent & systemStartComponent,
const HVACComponent & systemEndComponent,
unsigned componentInletPort,
unsigned componentOutletPort )
{
auto _model = model();
auto thisObject = getObject<HVACComponent>();
if( systemStartComponent.model() != _model ) return false;
if( systemEndComponent.model() != _model ) return false;
auto inletComponent = connectedObject( componentInletPort );
auto outletComponent = connectedObject( componentOutletPort );
auto inletComponentOutletPort = connectedObjectPort( componentInletPort );
auto outletComponentInletPort = connectedObjectPort( componentOutletPort );
if( ! inletComponent ) return false;
if( ! outletComponent ) return false;
if( ! inletComponentOutletPort ) return false;
if( ! outletComponentInletPort ) return false;
auto inletNode = inletComponent->optionalCast<Node>();
auto outletNode = outletComponent->optionalCast<Node>();
boost::optional<Splitter> splitter;
boost::optional<Mixer> mixer;
if( inletNode ) {
if( auto mo = inletNode->inletModelObject() ) {
splitter = mo->optionalCast<Splitter>();
}
}
if( outletNode ) {
if( auto mo = outletNode->outletModelObject() ) {
mixer = mo->optionalCast<Mixer>();
}
}
if( systemStartComponent.handle() == inletComponent->handle()
&& systemEndComponent.handle() == outletComponent->handle() ) {
// This component is between the systemStartComponent and the systemEndComponent
// ie. the supply or demand inlet or outlet Nodes,
// or the oa system end points on either the relief or inlet air streams.
_model.disconnect(thisObject,componentInletPort);
_model.disconnect(thisObject,componentOutletPort);
_model.connect( inletComponent.get(), inletComponentOutletPort.get(),
outletComponent.get(), outletComponentInletPort.get() );
return true;
} else if( systemEndComponent.handle() == outletComponent->handle() ) {
// Here the systemEndComponent is immediately downstream of this component,
// but there are other components (besides systemStartComponent) upstream.
boost::optional<ModelObject> newInletComponent;
boost::optional<unsigned> newInletComponentOutletPort;
// Make sure we don't end up with two nodes next to each other after this component is removed
if( inletNode && outletNode ) {
newInletComponent = inletNode->inletModelObject();
newInletComponentOutletPort = inletNode->connectedObjectPort(inletNode->inletPort());
OS_ASSERT(newInletComponent);
OS_ASSERT(newInletComponentOutletPort);
} else {
newInletComponent = inletComponent;
newInletComponentOutletPort = inletComponentOutletPort;
}
_model.disconnect(thisObject,componentInletPort);
_model.disconnect(thisObject,componentOutletPort);
// inletNode->remove() would have failed if we did it before the disconnect
if( inletNode && outletNode ) {
inletNode->remove();
}
_model.connect( newInletComponent.get(), newInletComponentOutletPort.get(),
outletComponent.get(), outletComponentInletPort.get() );
return true;
} else if( splitter && mixer ) {
// If the component is the only component (except nodes) between a splitter mixer pair
OS_ASSERT(inletNode);
OS_ASSERT(outletNode);
int i = splitter->branchIndexForOutletModelObject(inletNode.get());
int j = mixer->branchIndexForInletModelObject(outletNode.get());
OS_ASSERT(i == j);
splitter->removePortForBranch(i);
mixer->removePortForBranch(i);
_model.disconnect(thisObject,componentInletPort);
_model.disconnect(thisObject,componentOutletPort);
inletNode->remove();
outletNode->remove();
if( ! splitter->lastOutletModelObject() )
{
Node newNode(_model);
_model.connect(splitter.get(),splitter->nextOutletPort(),newNode,newNode.inletPort());
_model.connect(newNode,newNode.outletPort(),mixer.get(),mixer->nextInletPort());
}
return true;
} else {
boost::optional<ModelObject> newOutletComponent;
boost::optional<unsigned> newOutletComponentInletPort;
if( inletNode && outletNode ) {
newOutletComponent = outletNode->outletModelObject();
newOutletComponentInletPort = outletNode->connectedObjectPort(outletNode->outletPort());
}
if( ! newOutletComponent ) newOutletComponent = outletComponent;
if( ! newOutletComponentInletPort ) newOutletComponentInletPort = outletComponentInletPort;
_model.disconnect(thisObject,componentInletPort);
_model.disconnect(thisObject,componentOutletPort);
// outletNode->remove() would have failed if we did it before the disconnect
if( inletNode && outletNode ) {
outletNode->remove();
}
model().connect( inletComponent.get(), inletComponentOutletPort.get(),
newOutletComponent.get(), newOutletComponentInletPort.get() );
return true;
}
return false;
}
unsigned ConnectorMixer_Impl::nextInletPort() const
{
return inletPort( this->nextBranchIndex() );
}
bool AirTerminalSingleDuctParallelPIUReheat_Impl::addToNode(Node & node)
{
Model _model = node.model();
if( boost::optional<ModelObject> outlet = node.outletModelObject() )
{
boost::optional<ThermalZone> thermalZone;
if( boost::optional<PortList> portList = outlet->optionalCast<PortList>() )
{
thermalZone = portList->thermalZone();
}
if( thermalZone || (outlet->optionalCast<Mixer>() && node.airLoopHVAC()) )
{
if( boost::optional<ModelObject> inlet = node.inletModelObject() )
{
if( boost::optional<Splitter> splitter = inlet->optionalCast<Splitter>() )
{
boost::optional<ModelObject> sourceModelObject = inlet;
boost::optional<unsigned> sourcePort = node.connectedObjectPort(node.inletPort());
if( sourcePort && sourceModelObject )
{
Node inletNode(_model);
ModelObject thisObject = getObject<ModelObject>();
_model.connect( sourceModelObject.get(),
sourcePort.get(),
inletNode,
inletNode.inletPort() );
_model.connect( inletNode,
inletNode.outletPort(),
thisObject,
inletPort() );
_model.connect( thisObject,
outletPort(),
node,
node.inletPort() );
if( thermalZone )
{
Node secondaryInletNode(_model);
PortList exhaustPortList = thermalZone->exhaustPortList();
_model.connect( exhaustPortList,
exhaustPortList.nextPort(),
secondaryInletNode,
secondaryInletNode.inletPort() );
_model.connect( secondaryInletNode,
secondaryInletNode.outletPort(),
thisObject,
secondaryAirInletPort() );
ModelObject mo = this->getObject<ModelObject>();
thermalZone->addEquipment(mo);
}
if( auto airLoopHVAC = node.airLoopHVAC() ) {
auto schedule = airLoopHVAC->availabilitySchedule();
setFanAvailabilitySchedule(schedule);
}
return true;
}
}
}
}
}
return false;
}
unsigned AirLoopHVACZoneMixer_Impl::nextInletPort()
{
return inletPort( this->nextBranchIndex() );
}
std::vector<IdfObject> AirTerminalSingleDuctInletSideMixer_Impl::remove()
{
Model _model = this->model();
AirTerminalSingleDuctInletSideMixer thisObject = this->getObject<AirTerminalSingleDuctInletSideMixer>();
boost::optional<ThermalZone> t_thermalZone;
boost::optional<ZoneHVACComponent> t_zoneComp;
if( boost::optional<AirLoopHVAC> t_airLoopHVAC = airLoopHVAC() ) {
std::vector<ZoneHVACComponent> zoneComps =
subsetCastVector<ZoneHVACComponent>(t_airLoopHVAC->demandComponents(thisObject,t_airLoopHVAC->demandOutletNode()));
if( ! zoneComps.empty() ) {
t_zoneComp = zoneComps.front();
t_thermalZone = t_zoneComp->thermalZone();
t_zoneComp->removeFromThermalZone();
}
}
boost::optional<ModelObject> sourceModelObject = this->inletModelObject();
boost::optional<unsigned> sourcePort = this->connectedObjectPort(this->inletPort());
boost::optional<ModelObject> targetModelObject = this->outletModelObject();
boost::optional<unsigned> targetPort = this->connectedObjectPort(this->outletPort());
std::vector<ThermalZone> thermalZones = _model.getConcreteModelObjects<ThermalZone>();
for( auto & thermalZone : thermalZones )
{
std::vector<ModelObject> equipment = thermalZone.equipment();
if( std::find(equipment.begin(),equipment.end(),thisObject) != equipment.end() )
{
thermalZone.removeEquipment(thisObject);
break;
}
}
if( sourcePort && sourceModelObject
&& targetPort && targetModelObject )
{
if( boost::optional<Node> inletNode = sourceModelObject->optionalCast<Node>() )
{
if( boost::optional<ModelObject> source2ModelObject = inletNode->inletModelObject() )
{
if( boost::optional<unsigned> source2Port = inletNode->connectedObjectPort(inletNode->inletPort()) )
{
_model.connect( source2ModelObject.get(),
source2Port.get(),
targetModelObject.get(),
targetPort.get() );
inletNode->disconnect();
inletNode->remove();
std::vector<IdfObject> result = StraightComponent_Impl::remove();
if( t_thermalZone ) {
t_zoneComp->addToThermalZone(t_thermalZone.get());
}
return result;
}
}
}
}
model().disconnect(getObject<ModelObject>(),inletPort());
model().disconnect(getObject<ModelObject>(),outletPort());
return StraightComponent_Impl::remove();
}
std::vector<IdfObject> AirTerminalSingleDuctParallelPIUReheat_Impl::remove()
{
Model _model = this->model();
ModelObject thisObject = this->getObject<ModelObject>();
HVACComponent _reheatCoil = reheatCoil();
boost::optional<ModelObject> sourceModelObject = this->inletModelObject();
boost::optional<unsigned> sourcePort = this->connectedObjectPort(this->inletPort());
boost::optional<ModelObject> targetModelObject = this->outletModelObject();
boost::optional<unsigned> targetPort = this->connectedObjectPort(this->outletPort());
std::vector<ThermalZone> thermalZones = _model.getConcreteModelObjects<ThermalZone>();
for( auto & thermalZone : thermalZones )
{
std::vector<ModelObject> equipment = thermalZone.equipment();
if( std::find(equipment.begin(),equipment.end(),thisObject) != equipment.end() )
{
thermalZone.removeEquipment(thisObject);
break;
}
}
if( boost::optional<Node> secondaryAirInletNode = this->secondaryAirInletNode() )
{
secondaryAirInletNode->disconnect();
secondaryAirInletNode->remove();
}
if( sourcePort && sourceModelObject
&& targetPort && targetModelObject )
{
if( boost::optional<Node> inletNode = sourceModelObject->optionalCast<Node>() )
{
if( boost::optional<ModelObject> source2ModelObject = inletNode->inletModelObject() )
{
if( boost::optional<unsigned> source2Port = inletNode->connectedObjectPort(inletNode->inletPort()) )
{
_model.connect( source2ModelObject.get(),
source2Port.get(),
targetModelObject.get(),
targetPort.get() );
inletNode->disconnect();
inletNode->remove();
if( boost::optional<PlantLoop> loop = _reheatCoil.plantLoop() )
{
loop->removeDemandBranchWithComponent(_reheatCoil);
}
return StraightComponent_Impl::remove();
}
}
}
}
model().disconnect(getObject<ModelObject>(),inletPort());
model().disconnect(getObject<ModelObject>(),outletPort());
if( boost::optional<PlantLoop> loop = _reheatCoil.plantLoop() )
{
loop->removeDemandBranchWithComponent(_reheatCoil);
}
return StraightComponent_Impl::remove();
}
