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 Splitter_Impl::removePortForBranch(unsigned branchIndex) { int _nextBranchIndex = nextBranchIndex(); model().disconnect(getObject<ModelObject>(),outletPort(branchIndex)); //std::vector<ModelObject> modelObjects = outletModelObjects(); for(int i = branchIndex + 1; i < _nextBranchIndex; i++ ) { ModelObject mo = outletModelObject(i).get(); unsigned port = connectedObjectPort( outletPort(i) ).get(); model().disconnect(getObject<ModelObject>(),outletPort(i)); model().connect(getObject<ModelObject>(),outletPort(i-1),mo,port); } }
unsigned Splitter_Impl::newOutletPortAfterBranch(unsigned branchIndex) { //std::vector<ModelObject> modelObjects = outletModelObjects(); int stop = nextBranchIndex() - 1; for(int i = branchIndex; i < stop; i++ ) { ModelObject mo = outletModelObject(i).get(); unsigned port = connectedObjectPort( outletPort(i) ).get(); model().connect(getObject<ModelObject>(),outletPort(i+2),mo,port); } Model _model = model(); Node node( _model ); _model.connect( getObject<ModelObject>(),outletPort(branchIndex+1),node,node.inletPort() ); return outletPort(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)); } }
bool AirTerminalSingleDuctVAVHeatAndCoolNoReheat_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); _model.connect( sourceModelObject.get(), sourcePort.get(), inletNode, inletNode.inletPort() ); _model.connect( inletNode, inletNode.outletPort(), this->getObject<ModelObject>(), this->inletPort() ); _model.connect( this->getObject<ModelObject>(), outletPort(), node, node.inletPort() ); if( thermalZone ) { AirTerminalSingleDuctVAVHeatAndCoolNoReheat mo = this->getObject<AirTerminalSingleDuctVAVHeatAndCoolNoReheat>(); thermalZone->addEquipment(mo); } return true; } } } } } return false; }
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 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::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; }
bool EvaporativeFluidCoolerSingleSpeed_Impl::addToNode(Node& node) { Model _model = node.model(); if( boost::optional<PlantLoop> _plantLoop = node.plantLoop() ) { PlantLoop plantLoop = _plantLoop.get(); if( plantLoop.supplyComponent(node.handle()) ) { if( boost::optional<ModelObject> outlet = node.outletModelObject() ) { if( outlet->optionalCast<ConnectorMixer>() ) { if( boost::optional<ModelObject> inlet = node.inletModelObject() ) { if( boost::optional<ConnectorSplitter> splitter = inlet->optionalCast<ConnectorSplitter>() ) { boost::optional<ModelObject> sourceModelObject = inlet; boost::optional<unsigned> sourcePort = node.connectedObjectPort(node.inletPort()); if( sourcePort && sourceModelObject ) { Node inletNode(_model); _model.connect( sourceModelObject.get(), sourcePort.get(), inletNode, inletNode.inletPort() ); _model.connect( inletNode, inletNode.outletPort(), this->getObject<ModelObject>(), this->inletPort() ); _model.connect( this->getObject<ModelObject>(), outletPort(), node, node.inletPort() ); return true; } } } } } } } return false; }
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; }
unsigned ConnectorSplitter_Impl::nextOutletPort() { return outletPort( this->nextBranchIndex() ); }
unsigned AirLoopHVACZoneSplitter_Impl::nextOutletPort() { return outletPort( this->nextBranchIndex() ); }
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(); }
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(); }
boost::optional<ModelObject> Mixer_Impl::outletModelObject() { return connectedObject( outletPort() ); }
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> Splitter_Impl::outletModelObject(unsigned branchIndex) { return connectedObject( outletPort( branchIndex ) ); }
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; }
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(); }