unsigned Mixer_Impl::nextBranchIndex()
{
unsigned i = 0;
OptionalModelObject modelObject;
modelObject = connectedObject( this->inletPort(i) );
while( modelObject )
{
i++;
modelObject = connectedObject( this->inletPort(i) );
}
return i;
}
unsigned PortList_Impl::nextPortIndex()
{
unsigned i = 0;
OptionalModelObject modelObject;
modelObject = connectedObject( this->port(i) );
while( modelObject )
{
i++;
modelObject = connectedObject( this->port(i) );
}
return i;
}
boost::optional<Node> AirTerminalSingleDuctInletSideMixer_Impl::secondaryAirInletNode() const
{
boost::optional<Node> result;
if( boost::optional<ModelObject> mo = connectedObject(secondaryAirInletPort()) ) {
result = mo->optionalCast<Node>();
}
return result;
}
boost::optional<Node> AirTerminalSingleDuctParallelPIUReheat_Impl::secondaryAirInletNode() const
{
boost::optional<ModelObject> mo = connectedObject(secondaryAirInletPort());
if( mo )
{
if( boost::optional<Node> node = mo->optionalCast<Node>() )
{
return node;
}
}
return boost::none;
}
boost::optional<Node> ZoneHVACComponent_Impl::outletNode() const
{
boost::optional<ModelObject> mo = connectedObject(outletPort());
boost::optional<Node> result;
if( mo )
{
if( boost::optional<Node> node = mo->optionalCast<Node>() )
{
result = node;
}
}
return result;
}
/* Air Nodes */
boost::optional<Node> AirTerminalSingleDuctConstantVolumeFourPipeBeam_Impl::primaryAirInletNode() const {
// TODO: Use this once port methods are set to const
// unsigned port = inletPort();
unsigned port = OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeBeamFields::PrimaryAirInletNodeName;
boost::optional<ModelObject> mo = connectedObject(port);
boost::optional<Node> result;
if( mo )
{
if( boost::optional<Node> node = mo->optionalCast<Node>() )
{
result = node;
}
}
return result;
}
boost::optional<Node> CoilHeatingFourPipeBeam_Impl::hotWaterInletNode() const {
// TODO: use this once port methods are set to const
// unsigned port = inletPort();
unsigned port = OS_Coil_Heating_FourPipeBeamFields::HotWaterInletNodeName;
boost::optional<ModelObject> mo = connectedObject(port);
boost::optional<Node> result;
if( mo )
{
if( boost::optional<Node> node = mo->optionalCast<Node>() )
{
result = node;
}
}
return result;
}
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;
}
boost::optional<ModelObject> Mixer_Impl::inletModelObject(unsigned branchIndex)
{
return connectedObject( inletPort( branchIndex ) );
}
boost::optional<ModelObject> Mixer_Impl::outletModelObject()
{
return connectedObject( outletPort() );
}
OptionalModelObject WaterToWaterComponent_Impl::demandOutletModelObject()
{
return connectedObject(demandOutletPort());
}
OptionalModelObject WaterToWaterComponent_Impl::supplyOutletModelObject()
{
return connectedObject(supplyOutletPort());
}
boost::optional<ModelObject> WaterToWaterComponent_Impl::tertiaryOutletModelObject() const
{
return connectedObject(tertiaryOutletPort());
}
boost::optional<ModelObject> Splitter_Impl::outletModelObject(unsigned branchIndex)
{
return connectedObject( outletPort( branchIndex ) );
}
boost::optional<ModelObject> Splitter_Impl::inletModelObject()
{
return connectedObject( inletPort() );
}
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;
}
boost::optional<ModelObject> WaterToAirComponent_Impl::waterOutletModelObject()
{
return connectedObject( waterOutletPort() );
}
boost::optional<ModelObject> PortList_Impl::modelObject(unsigned portIndex)
{
return connectedObject( port( portIndex ) );
}
