boost::optional<IdfObject> ForwardTranslator::createAirLoopHVACSupplyPath( AirLoopHVAC & airLoopHVAC )
{
std::string s;
IdfObject supplyPathIdf(openstudio::IddObjectType::AirLoopHVAC_SupplyPath);
m_idfObjects.push_back(supplyPathIdf);
supplyPathIdf.setName(airLoopHVAC.name().get() + " Supply Path");
model::Node node = airLoopHVAC.demandInletNode();
supplyPathIdf.setString(openstudio::AirLoopHVAC_SupplyPathFields::SupplyAirPathInletNodeName,node.name().get());
model::AirLoopHVACZoneSplitter zoneSplitter = airLoopHVAC.zoneSplitter();
boost::optional<IdfObject> _zoneSplitter = translateAndMapModelObject(zoneSplitter);
OS_ASSERT(_zoneSplitter);
IdfExtensibleGroup eg = supplyPathIdf.pushExtensibleGroup();
eg.setString(AirLoopHVAC_SupplyPathExtensibleFields::ComponentObjectType,_zoneSplitter->iddObject().name());
eg.setString(AirLoopHVAC_SupplyPathExtensibleFields::ComponentName,_zoneSplitter->name().get());
std::vector<ModelObject> supplyPlenums = airLoopHVAC.demandComponents(AirLoopHVACSupplyPlenum::iddObjectType());
for( std::vector<ModelObject>::iterator it = supplyPlenums.begin();
it != supplyPlenums.end();
it++ )
{
eg = supplyPathIdf.pushExtensibleGroup();
boost::optional<IdfObject> _supplyPlenum = translateAndMapModelObject(*it);
OS_ASSERT(_supplyPlenum);
eg.setString(AirLoopHVAC_SupplyPathExtensibleFields::ComponentObjectType,_supplyPlenum->iddObject().name());
eg.setString(AirLoopHVAC_SupplyPathExtensibleFields::ComponentName,_supplyPlenum->name().get());
}
return boost::optional<IdfObject>(supplyPathIdf);
}
boost::optional<IdfObject> ForwardTranslator::createAirLoopHVACReturnPath( AirLoopHVAC & airLoopHVAC )
{
IdfObject returnPathIdf(openstudio::IddObjectType::AirLoopHVAC_ReturnPath);
m_idfObjects.push_back(returnPathIdf);
returnPathIdf.setName(airLoopHVAC.name().get() + " Return Path");
Node node = airLoopHVAC.demandOutletNode();
returnPathIdf.setString(openstudio::AirLoopHVAC_ReturnPathFields::ReturnAirPathOutletNodeName,node.name().get());
std::vector<ModelObject> returnPlenums = airLoopHVAC.demandComponents(AirLoopHVACReturnPlenum::iddObjectType());
for( auto & returnPlenum : returnPlenums )
{
IdfExtensibleGroup eg = returnPathIdf.pushExtensibleGroup();
boost::optional<IdfObject> _returnPlenum = translateAndMapModelObject(returnPlenum);
OS_ASSERT(_returnPlenum);
eg.setString(AirLoopHVAC_ReturnPathExtensibleFields::ComponentObjectType,_returnPlenum->iddObject().name());
eg.setString(AirLoopHVAC_ReturnPathExtensibleFields::ComponentName,_returnPlenum->name().get());
}
AirLoopHVACZoneMixer zoneMixer = airLoopHVAC.zoneMixer();
boost::optional<IdfObject> _zoneMixer = translateAndMapModelObject(zoneMixer);
OS_ASSERT(_zoneMixer);
IdfExtensibleGroup eg = returnPathIdf.pushExtensibleGroup();
eg.setString(AirLoopHVAC_ReturnPathExtensibleFields::ComponentObjectType,_zoneMixer->iddObject().name());
eg.setString(AirLoopHVAC_ReturnPathExtensibleFields::ComponentName,_zoneMixer->name().get());
return boost::optional<IdfObject>(returnPathIdf);
}
boost::optional<IdfObject> ForwardTranslator::createAirLoopHVACSupplyPath( AirLoopHVAC & airLoopHVAC )
{
std::string s;
IdfObject supplyPathIdf(openstudio::IddObjectType::AirLoopHVAC_SupplyPath);
m_idfObjects.push_back(supplyPathIdf);
supplyPathIdf.createName();
s = airLoopHVAC.demandInletNodes().front().name().get();
supplyPathIdf.setString(openstudio::AirLoopHVAC_SupplyPathFields::SupplyAirPathInletNodeName,s);
ModelObjectVector modelObjects;
modelObjects = airLoopHVAC.demandComponents( airLoopHVAC.demandInletNodes().front(),
airLoopHVAC.demandOutletNode(),
openstudio::IddObjectType::OS_AirLoopHVAC_ZoneSplitter );
if( modelObjects.size() == 1 )
{
ModelObject modelObject = modelObjects.front();
OptionalAirLoopHVACZoneSplitter zoneSplitter = modelObject.optionalCast<AirLoopHVACZoneSplitter>();
translateAndMapModelObject(*zoneSplitter);
s = stripOS2(zoneSplitter->iddObject().name());
supplyPathIdf.setString(2,s);
s = zoneSplitter->name().get();
supplyPathIdf.setString(3,s);
}
return boost::optional<IdfObject>(supplyPathIdf);
}
void SizingSystem_Impl::setAirLoopHVAC(const AirLoopHVAC & airLoopHVAC)
{
if( model() != airLoopHVAC.model() )
{
return;
}
BOOST_ASSERT(this->setPointer(OS_Sizing_SystemFields::AirLoopName, airLoopHVAC.handle()));
}
void SetpointManagerMixedAir::updateFanInletOutletNodes(AirLoopHVAC & airLoopHVAC)
{
boost::optional<Node> fanInletNode;
boost::optional<Node> fanOutletNode;
std::vector<StraightComponent> fans;
std::vector<ModelObject> supplyComponents = airLoopHVAC.supplyComponents();
for( const auto & supplyComponent : supplyComponents )
{
if( boost::optional<FanVariableVolume> variableFan = supplyComponent.optionalCast<FanVariableVolume>() ) {
fans.insert(fans.begin(), *variableFan);
}
else if( boost::optional<FanConstantVolume> constantFan = supplyComponent.optionalCast<FanConstantVolume>() ) {
fans.insert(fans.begin(), *constantFan);
}
else if( boost::optional<FanOnOff> onOffFan = supplyComponent.optionalCast<FanOnOff>() ) {
fans.insert(fans.begin(), *onOffFan);
}
}
if( fans.size() > 0 )
{
boost::optional<ModelObject> mo;
mo = fans.front().inletModelObject();
if( mo )
{
fanInletNode = mo->optionalCast<Node>();
}
mo = fans.front().outletModelObject();
if( mo )
{
fanOutletNode = mo->optionalCast<Node>();
}
}
if( fanInletNode && fanOutletNode )
{
std::vector<model::Node> nodes = subsetCastVector<model::Node>(airLoopHVAC.supplyComponents());
for( auto & node : nodes )
{
std::vector<SetpointManagerMixedAir> setpointManagers = subsetCastVector<SetpointManagerMixedAir>(node.setpointManagers());
if( ! setpointManagers.empty() ) {
SetpointManagerMixedAir spm = setpointManagers.front();
spm.setFanInletNode(fanInletNode.get());
spm.setFanOutletNode(fanOutletNode.get());
}
}
}
}
TEST_F(ModelFixture,HeatExchangerAirToAirSensibleAndLatent_addToNode) {
Model model;
HeatExchangerAirToAirSensibleAndLatent heatExchangerAirToAirSensibleAndLatent(model);
AirLoopHVAC loop = addSystemType3(model).cast<AirLoopHVAC>();
AirLoopHVACOutdoorAirSystem oaSystem = loop.airLoopHVACOutdoorAirSystem().get();
Node oaNode = oaSystem.outboardOANode().get();
Node reliefNode = oaSystem.outboardReliefNode().get();
HeatExchangerAirToAirSensibleAndLatent hx1(model);
EXPECT_TRUE(hx1.addToNode(oaNode));
HeatExchangerAirToAirSensibleAndLatent hx2(model);
EXPECT_TRUE(hx2.addToNode(oaNode));
HeatExchangerAirToAirSensibleAndLatent hx3(model);
EXPECT_TRUE(hx3.addToNode(reliefNode));
oaNode = oaSystem.outdoorAirModelObject()->cast<Node>();
reliefNode = oaSystem.reliefAirModelObject()->cast<Node>();
HeatExchangerAirToAirSensibleAndLatent hx4(model);
EXPECT_TRUE(hx4.addToNode(reliefNode));
HeatExchangerAirToAirSensibleAndLatent hx5(model);
EXPECT_TRUE(hx5.addToNode(oaNode));
Schedule schedule = model.alwaysOnDiscreteSchedule();
EvaporativeCoolerDirectResearchSpecial evap(model,schedule);
EXPECT_TRUE(evap.addToNode(oaNode));
Node inletNode = evap.inletModelObject()->cast<Node>();
Node outletNode = evap.outletModelObject()->cast<Node>();
HeatExchangerAirToAirSensibleAndLatent hx6(model);
EXPECT_TRUE(hx6.addToNode(inletNode));
HeatExchangerAirToAirSensibleAndLatent hx7(model);
EXPECT_TRUE(hx7.addToNode(outletNode));
hx1.remove();
hx2.remove();
hx3.remove();
hx4.remove();
hx5.remove();
hx6.remove();
hx7.remove();
evap.remove();
EXPECT_EQ(1u,oaSystem.oaComponents().size());
EXPECT_EQ(1u,oaSystem.reliefComponents().size());
}
void SetpointManagerMixedAir::updateFanInletOutletNodes(AirLoopHVAC & airLoopHVAC)
{
boost::optional<Node> fanInletNode;
boost::optional<Node> fanOutletNode;
std::vector<StraightComponent> fans;
std::vector<ModelObject> supplyComponents = airLoopHVAC.supplyComponents();
std::vector<FanConstantVolume> constantFans = subsetCastVector<FanConstantVolume>(supplyComponents);
std::vector<FanVariableVolume> variableFans = subsetCastVector<FanVariableVolume>(supplyComponents);
std::vector<FanOnOff> onoffFans = subsetCastVector<FanOnOff>(supplyComponents);
fans.insert(fans.begin(),constantFans.begin(),constantFans.end());
fans.insert(fans.begin(),variableFans.begin(),variableFans.end());
fans.insert(fans.begin(),onoffFans.begin(),onoffFans.end());
if( fans.size() > 0 )
{
boost::optional<ModelObject> mo;
mo = fans.front().inletModelObject();
if( mo )
{
fanInletNode = mo->optionalCast<Node>();
}
mo = fans.front().outletModelObject();
if( mo )
{
fanOutletNode = mo->optionalCast<Node>();
}
}
if( fanInletNode && fanOutletNode )
{
std::vector<model::Node> nodes = subsetCastVector<model::Node>(airLoopHVAC.supplyComponents());
for( std::vector<model::Node>::iterator it = nodes.begin();
it != nodes.end();
++it )
{
if( boost::optional<model::SetpointManagerMixedAir> spm = it->getSetpointManagerMixedAir() )
{
spm->setFanInletNode(fanInletNode.get());
spm->setFanOutletNode(fanOutletNode.get());
}
}
}
}
bool WaterToAirComponent_Impl::addToNode(Node & node)
{
Model _model = node.model();
ModelObject thisModelObject = getObject<ModelObject>();
boost::optional<AirLoopHVACOutdoorAirSystem> oaSystem = node.airLoopHVACOutdoorAirSystem();
if( node.airLoopHVAC() && ! oaSystem )
{
AirLoopHVAC airLoop = node.airLoopHVAC().get();
if( airLoop.demandComponent( node.handle() ) )
{
return false;
}
else
{
if( airLoopHVAC() )
{
removeFromAirLoopHVAC();
}
if( node == airLoop.supplyOutletNode() &&
node.inletModelObject().get() == airLoop.supplyInletNode() )
{
unsigned oldOutletPort = node.connectedObjectPort( node.inletPort() ).get();
unsigned oldInletPort = node.inletPort();
ModelObject oldSourceModelObject = node.connectedObject( node.inletPort() ).get();
ModelObject oldTargetModelObject = node;
_model.connect( oldSourceModelObject, oldOutletPort,
thisModelObject, airInletPort() );
_model.connect( thisModelObject, airOutletPort(),
oldTargetModelObject, oldInletPort );
return true;
}
if( node == airLoop.supplyInletNode() &&
node.outletModelObject().get() == airLoop.supplyOutletNode() )
{
unsigned oldOutletPort = node.outletPort();
unsigned oldInletPort = node.connectedObjectPort( node.outletPort() ).get();
ModelObject oldSourceModelObject = node;
ModelObject oldTargetModelObject = node.outletModelObject().get();
_model.connect( oldSourceModelObject, oldOutletPort,
thisModelObject, airInletPort() );
_model.connect( thisModelObject, airOutletPort(),
oldTargetModelObject, oldInletPort );
return true;
}
else if( node == airLoop.supplyOutletNode() )
{
unsigned oldOutletPort = node.connectedObjectPort( node.inletPort() ).get();
unsigned oldInletPort = node.inletPort();
ModelObject oldSourceModelObject = node.connectedObject( node.inletPort() ).get();
ModelObject oldTargetModelObject = node;
Node newNode( _model );
_model.connect( oldSourceModelObject, oldOutletPort,
newNode, newNode.inletPort() );
_model.connect( newNode, newNode.outletPort(),
thisModelObject, airInletPort() );
_model.connect( thisModelObject, airOutletPort(),
oldTargetModelObject, oldInletPort );
return true;
}
else
{
unsigned oldOutletPort = node.outletPort();
unsigned oldInletPort = node.connectedObjectPort( node.outletPort() ).get();
ModelObject oldSourceModelObject = node;
ModelObject oldTargetModelObject = node.connectedObject( node.outletPort() ).get();
Node newNode( _model );
_model.connect( oldSourceModelObject, oldOutletPort,
thisModelObject, airInletPort() );
_model.connect( thisModelObject, airOutletPort(),
newNode, newNode.inletPort() );
_model.connect( newNode, newNode.outletPort(),
oldTargetModelObject, oldInletPort );
return true;
}
}
}
else if( node.plantLoop() )
{
PlantLoop _plantLoop = node.plantLoop().get();
if( ! _plantLoop.demandComponent( node.handle() ) )
{
return false;
}
else
{
if( plantLoop() )
{
removeFromPlantLoop();
}
if( node == _plantLoop.demandOutletNode() &&
node.inletModelObject().get() == _plantLoop.demandInletNode() )
{
unsigned oldOutletPort = node.connectedObjectPort( node.inletPort() ).get();
unsigned oldInletPort = node.inletPort();
ModelObject oldSourceModelObject = node.connectedObject( node.inletPort() ).get();
ModelObject oldTargetModelObject = node;
_model.connect( oldSourceModelObject, oldOutletPort,
thisModelObject, waterInletPort() );
_model.connect( thisModelObject, waterOutletPort(),
oldTargetModelObject, oldInletPort );
return true;
}
else if( node == _plantLoop.demandOutletNode() )
{
unsigned oldOutletPort = node.connectedObjectPort( node.inletPort() ).get();
unsigned oldInletPort = node.inletPort();
ModelObject oldSourceModelObject = node.connectedObject( node.inletPort() ).get();
ModelObject oldTargetModelObject = node;
Node newNode( _model );
_model.connect( oldSourceModelObject, oldOutletPort,
newNode, newNode.inletPort() );
_model.connect( newNode, newNode.outletPort(),
thisModelObject, waterInletPort() );
_model.connect( thisModelObject, waterOutletPort(),
oldTargetModelObject, oldInletPort );
return true;
}
else
{
unsigned oldOutletPort = node.outletPort();
unsigned oldInletPort = node.connectedObjectPort( node.outletPort() ).get();
ModelObject oldSourceModelObject = node;
ModelObject oldTargetModelObject = node.connectedObject( node.outletPort() ).get();
Node newNode( _model );
_model.connect( oldSourceModelObject, oldOutletPort,
thisModelObject, waterInletPort() );
_model.connect( thisModelObject, waterOutletPort(),
newNode, newNode.inletPort() );
_model.connect( newNode, newNode.outletPort(),
oldTargetModelObject, oldInletPort );
return true;
}
}
}
else
{
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);
} ,
