std::vector<ThermalZone> AirLoopHVACZoneSplitter_Impl::thermalZones()
{
std::vector<ThermalZone> zones;
std::vector<ModelObject> modelObjects;
std::vector<ModelObject> _outletModelObjects = outletModelObjects();
OptionalAirLoopHVAC _airLoopHVAC = airLoopHVAC();
OptionalNode demandOutletNode;
OptionalNode demandInletNode;
if( _airLoopHVAC )
{
demandOutletNode = _airLoopHVAC->demandOutletNode();
demandInletNode = _airLoopHVAC->demandInletNode();
}
else
{
return zones;
}
modelObjects = _airLoopHVAC->demandComponents( demandInletNode.get(),
demandOutletNode.get(),
ThermalZone::iddObjectType() );
for( std::vector<ModelObject>::iterator it = modelObjects.begin();
it < modelObjects.end();
it++ )
{
OptionalThermalZone zone;
zone = it->optionalCast<ThermalZone>();
if( zone )
{
zones.push_back(*zone);
}
}
return zones;
}
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;
}
TEST_F(ModelFixture,AirLoopHVAC_AirLoopHVAC)
{
Model model = Model();
OptionalModelObject modelObject;
AirLoopHVAC airLoopHVAC = AirLoopHVAC(model);
ASSERT_EQ(airLoopHVAC.iddObject().name(),"OS:AirLoopHVAC");
OptionalNode supplyInletNode = airLoopHVAC.supplyInletNode();
OptionalNode demandOutletNode = airLoopHVAC.demandOutletNode();
std::vector<Node> supplyOutletNodes = airLoopHVAC.supplyOutletNodes();
std::vector<Node> demandInletNodes = airLoopHVAC.demandInletNodes();
ASSERT_TRUE( supplyInletNode );
ASSERT_TRUE( demandOutletNode );
ASSERT_EQ( unsigned(1), supplyOutletNodes.size() );
ASSERT_EQ( unsigned(1), demandInletNodes.size() );
OptionalNode supplyOutletNode = OptionalNode(supplyOutletNodes.front());
OptionalNode demandInletNode = OptionalNode(demandInletNodes.front());
modelObject = demandInletNode->outletModelObject();
ASSERT_TRUE( modelObject );
OptionalAirLoopHVACZoneSplitter splitter;
splitter = modelObject->optionalCast<AirLoopHVACZoneSplitter>();
ASSERT_TRUE( splitter );
modelObject = splitter->lastOutletModelObject();
ASSERT_TRUE( modelObject );
OptionalNode splitterNode;
splitterNode = modelObject->optionalCast<Node>();
ASSERT_TRUE( splitterNode );
modelObject = splitterNode->outletModelObject();
ASSERT_TRUE(modelObject);
OptionalAirLoopHVACZoneMixer mixer;
mixer = modelObject->optionalCast<AirLoopHVACZoneMixer>();
ASSERT_TRUE( mixer );
modelObject = mixer->outletModelObject();
ASSERT_TRUE( modelObject );
OptionalNode _demandOutletNode;
_demandOutletNode = modelObject->optionalCast<Node>();
ASSERT_TRUE( _demandOutletNode );
modelObject = _demandOutletNode->outletModelObject();
ASSERT_TRUE( modelObject );
OptionalAirLoopHVAC _airLoopHVAC;
_airLoopHVAC = modelObject->optionalCast<AirLoopHVAC>();
ASSERT_TRUE( _airLoopHVAC );
ASSERT_EQ("StayOff",_airLoopHVAC->nightCycleControlType());
ASSERT_TRUE(_airLoopHVAC->setNightCycleControlType("CycleOnAny"));
ASSERT_TRUE(_airLoopHVAC->setNightCycleControlType("CycleOnAnyZoneFansOnly"));
::testing::FLAGS_gtest_death_test_style = "threadsafe";
ASSERT_EXIT (
{
Model m;
AirLoopHVAC airLoopHVAC(m);
airLoopHVAC.availabilitySchedule();
exit(0);
} ,
