From f57c2fbcf60b37b43453fc5bd2ae3d390b38d8af Mon Sep 17 00:00:00 2001 From: "Lerond, Jeremy" Date: Fri, 26 Jul 2024 15:22:17 -0700 Subject: [PATCH] Add support for VRF terminals and zonal unitary systems (PTHP, PTAC, WAHP). Missing unit test for the latter. --- src/EnergyPlus/AirflowNetwork/src/Solver.cpp | 41 ++++- src/EnergyPlus/HVACVariableRefrigerantFlow.cc | 22 +++ src/EnergyPlus/HVACVariableRefrigerantFlow.hh | 2 + src/EnergyPlus/UnitarySystem.cc | 51 +++++- src/EnergyPlus/UnitarySystem.hh | 1 + .../unit/AirflowNetworkHVAC.unit.cc | 155 ++++++++++++++++++ 6 files changed, 258 insertions(+), 14 deletions(-) diff --git a/src/EnergyPlus/AirflowNetwork/src/Solver.cpp b/src/EnergyPlus/AirflowNetwork/src/Solver.cpp index 8d583fbb388..f52280bca16 100644 --- a/src/EnergyPlus/AirflowNetwork/src/Solver.cpp +++ b/src/EnergyPlus/AirflowNetwork/src/Solver.cpp @@ -88,6 +88,7 @@ #include #include #include +#include #include #include #include @@ -100,6 +101,7 @@ #include #include #include +#include #include #include #include @@ -10159,8 +10161,11 @@ namespace AirflowNetwork { EPVector NodeConnectionType; // Specifies the type of node connection std::string CurrentModuleObject; - bool HPWHFound(false); // Flag for HPWH identification - bool StandaloneERVFound(false); // Flag for Standalone ERV (ZoneHVAC:EnergyRecoveryVentilator) identification + bool hpwhFound(false); // Flag for HPWH identification + bool standaloneERVFound(false); // Flag for Standalone ERV (ZoneHVAC:EnergyRecoveryVentilator) identification + bool packagedUnitaryFound(false); // Flag for packaged unitary systems (ZoneHVAC:PackagedTerminalAirConditioner, + // ZoneHVAC:PackagedTerminalHeatPump, ZoneHVAC:WaterToAirHeatPump) identification + bool vrfTUFound(false); // Validate supply and return connections NodeFound.dimension(m_state.dataLoopNodes->NumOfNodes, false); @@ -10265,13 +10270,25 @@ namespace AirflowNetwork { // Skip HPWH nodes that don't have to be included in the AFN if (GetHeatPumpWaterHeaterNodeNumber(m_state, i)) { NodeFound(i) = true; - HPWHFound = true; + hpwhFound = true; } // Skip Standalone ERV nodes that don't have to be included in the AFN if (GetStandAloneERVNodeNumber(m_state, i)) { NodeFound(i) = true; - StandaloneERVFound = true; + standaloneERVFound = true; + } + + // Skip zonal unitary system based nodes that don't have to be included in the AFN + if (UnitarySystems::getUnitarySystemNodeNumber(m_state, i)) { + NodeFound(i) = true; + packagedUnitaryFound = true; + } + + // Skip zonal vrf terminal nodes that don't have to be included in the AFN + if (HVACVariableRefrigerantFlow::getVRFTUNodeNumber(m_state, i)) { + NodeFound(i) = true; + vrfTUFound = true; } } @@ -10403,16 +10420,28 @@ namespace AirflowNetwork { } } } - if (HPWHFound) { + if (hpwhFound) { ShowWarningError(m_state, format(RoutineName) + "Heat pump water heater is simulated along with an AirflowNetwork but is not included in " "the AirflowNetwork."); } - if (StandaloneERVFound) { + if (standaloneERVFound) { ShowWarningError(m_state, format(RoutineName) + "A ZoneHVAC:EnergyRecoveryVentilator is simulated along with an AirflowNetwork but is not " "included in the AirflowNetwork."); } + if (packagedUnitaryFound) { + ShowWarningError(m_state, + format(RoutineName) + "A ZoneHVAC:PackagedTerminalAirConditioner, ZoneHVAC:PackagedTerminalHeatPump, or " + "ZoneHVAC:WaterToAirHeatPump is simulated along with an AirflowNetwork but is not " + "included in the AirflowNetwork."); + } + if (vrfTUFound) { + ShowWarningError(m_state, + format(RoutineName) + + "A ZoneHVAC:TerminalUnit:VariableRefrigerantFlow is simulated along with an AirflowNetwork but is not " + "included in the AirflowNetwork."); + } NodeFound.deallocate(); // Assign AirLoop Number to every node and linkage diff --git a/src/EnergyPlus/HVACVariableRefrigerantFlow.cc b/src/EnergyPlus/HVACVariableRefrigerantFlow.cc index ea402f0ea39..de42c32347e 100644 --- a/src/EnergyPlus/HVACVariableRefrigerantFlow.cc +++ b/src/EnergyPlus/HVACVariableRefrigerantFlow.cc @@ -10822,6 +10822,28 @@ void getVRFTUZoneLoad( } } +bool getVRFTUNodeNumber(EnergyPlusData &state, int const nodeNumber) +{ + for (int vrfTUIndex = 1; vrfTUIndex <= state.dataHVACVarRefFlow->NumVRFTU; ++vrfTUIndex) { + auto &vrfTU = state.dataHVACVarRefFlow->VRFTU(vrfTUIndex); + + bool vrfTUOutdoorAir = false; + if (vrfTU.CoolOutAirVolFlow == 0 && vrfTU.HeatOutAirVolFlow == 0 && vrfTU.NoCoolHeatOutAirVolFlow == 0) { + vrfTUOutdoorAir = true; + } + + if (vrfTUOutdoorAir && + (nodeNumber == vrfTU.VRFTUInletNodeNum || nodeNumber == vrfTU.VRFTUOutletNodeNum || nodeNumber == vrfTU.fanInletNode || + nodeNumber == vrfTU.fanOutletNode || nodeNumber == vrfTU.heatCoilAirOutNode || nodeNumber == vrfTU.coolCoilAirOutNode || + nodeNumber == vrfTU.VRFTUOAMixerOANodeNum || nodeNumber == vrfTU.VRFTUOAMixerRelNodeNum || nodeNumber == vrfTU.VRFTUOAMixerRetNodeNum || + nodeNumber == vrfTU.VRFTUOAMixerMixedNodeNum || nodeNumber == vrfTU.SuppHeatCoilAirInletNode || + nodeNumber == vrfTU.SuppHeatCoilAirOutletNode)) { + return true; + } + return false; + } +} + void VRFCondenserEquipment::CalcVRFIUTeTc_FluidTCtrl(EnergyPlusData &state) { // SUBROUTINE INFORMATION: diff --git a/src/EnergyPlus/HVACVariableRefrigerantFlow.hh b/src/EnergyPlus/HVACVariableRefrigerantFlow.hh index 480aa67321a..590fc89e9da 100644 --- a/src/EnergyPlus/HVACVariableRefrigerantFlow.hh +++ b/src/EnergyPlus/HVACVariableRefrigerantFlow.hh @@ -929,6 +929,8 @@ namespace HVACVariableRefrigerantFlow { void getVRFTUZoneLoad( EnergyPlusData &state, int const VRFTUNum, Real64 &zoneLoad, Real64 &LoadToHeatingSP, Real64 &LoadToCoolingSP, bool const InitFlag); + bool getVRFTUNodeNumber(EnergyPlusData &state, int const nodeNumber); + void ReportVRFTerminalUnit(EnergyPlusData &state, int VRFTUNum); // index to VRF terminal unit void ReportVRFCondenser(EnergyPlusData &state, int VRFCond); // index to VRF condensing unit diff --git a/src/EnergyPlus/UnitarySystem.cc b/src/EnergyPlus/UnitarySystem.cc index 29cf56ad968..d89f4f03bda 100644 --- a/src/EnergyPlus/UnitarySystem.cc +++ b/src/EnergyPlus/UnitarySystem.cc @@ -10149,7 +10149,8 @@ namespace UnitarySystems { Real64 TotalOutputDelta = 0.0; // delta total output rate, {W} int ZoneInNode = this->m_ZoneInletNode; Real64 MassFlowRate = state.dataLoopNodes->Node(ZoneInNode).MassFlowRate / this->ControlZoneMassFlowFrac; - if (state.afn->distribution_simulated) { + if (state.afn->distribution_simulated && this->m_sysType != SysType::PackagedAC && this->m_sysType != SysType::PackagedHP && + this->m_sysType != SysType::PackagedWSHP) { DeltaMassRate = state.dataLoopNodes->Node(this->AirOutNode).MassFlowRate - state.dataLoopNodes->Node(ZoneInNode).MassFlowRate / this->ControlZoneMassFlowFrac; if (DeltaMassRate < 0.0) DeltaMassRate = 0.0; @@ -12143,7 +12144,8 @@ namespace UnitarySystems { Real64 DesOutHumRat = this->m_DesiredOutletHumRat; int CoilType_Num = this->m_CoolingCoilType_Num; Real64 LoopDXCoilMaxRTFSave = 0.0; - if (state.afn->distribution_simulated) { + if (state.afn->distribution_simulated && this->m_sysType != SysType::PackagedAC && this->m_sysType != SysType::PackagedHP && + this->m_sysType != SysType::PackagedWSHP) { LoopDXCoilMaxRTFSave = state.dataAirLoop->AirLoopAFNInfo(AirLoopNum).AFNLoopDXCoilRTF; state.dataAirLoop->AirLoopAFNInfo(AirLoopNum).AFNLoopDXCoilRTF = 0.0; } @@ -13897,7 +13899,8 @@ namespace UnitarySystems { this->m_CoolingCycRatio = CycRatio; this->m_DehumidificationMode = DehumidMode; - if (state.afn->distribution_simulated) { + if (state.afn->distribution_simulated && this->m_sysType != SysType::PackagedAC && this->m_sysType != SysType::PackagedHP && + this->m_sysType != SysType::PackagedWSHP) { state.dataAirLoop->AirLoopAFNInfo(AirLoopNum).AFNLoopDXCoilRTF = max(state.dataAirLoop->AirLoopAFNInfo(AirLoopNum).AFNLoopDXCoilRTF, LoopDXCoilMaxRTFSave); } @@ -13952,7 +13955,8 @@ namespace UnitarySystems { Real64 LoopHeatingCoilMaxRTFSave = 0.0; Real64 LoopDXCoilMaxRTFSave = 0.0; - if (state.afn->distribution_simulated) { + if (state.afn->distribution_simulated && this->m_sysType != SysType::PackagedAC && this->m_sysType != SysType::PackagedHP && + this->m_sysType != SysType::PackagedWSHP) { LoopHeatingCoilMaxRTFSave = state.dataAirLoop->AirLoopAFNInfo(AirLoopNum).AFNLoopHeatingCoilMaxRTF; state.dataAirLoop->AirLoopAFNInfo(AirLoopNum).AFNLoopHeatingCoilMaxRTF = 0.0; LoopDXCoilMaxRTFSave = state.dataAirLoop->AirLoopAFNInfo(AirLoopNum).AFNLoopDXCoilRTF; @@ -14571,7 +14575,8 @@ namespace UnitarySystems { this->m_HeatingCycRatio = CycRatio; HeatCoilLoad = ReqOutput; - if (state.afn->distribution_simulated) { + if (state.afn->distribution_simulated && this->m_sysType != SysType::PackagedAC && this->m_sysType != SysType::PackagedHP && + this->m_sysType != SysType::PackagedWSHP) { state.dataAirLoop->AirLoopAFNInfo(AirLoopNum).AFNLoopHeatingCoilMaxRTF = max(state.dataAirLoop->AirLoopAFNInfo(AirLoopNum).AFNLoopHeatingCoilMaxRTF, LoopHeatingCoilMaxRTFSave); state.dataAirLoop->AirLoopAFNInfo(AirLoopNum).AFNLoopDXCoilRTF = @@ -14622,7 +14627,8 @@ namespace UnitarySystems { Real64 LoopHeatingCoilMaxRTFSave = 0.0; Real64 LoopDXCoilMaxRTFSave = 0.0; - if (state.afn->distribution_simulated) { + if (state.afn->distribution_simulated && this->m_sysType != SysType::PackagedAC && this->m_sysType != SysType::PackagedHP && + this->m_sysType != SysType::PackagedWSHP) { auto &afnInfo = state.dataAirLoop->AirLoopAFNInfo(AirLoopNum); LoopHeatingCoilMaxRTFSave = afnInfo.AFNLoopHeatingCoilMaxRTF; afnInfo.AFNLoopHeatingCoilMaxRTF = 0.0; @@ -14975,7 +14981,8 @@ namespace UnitarySystems { } // IF((GetCurrentScheduleValue(state, UnitarySystem(UnitarySysNum)%m_SysAvailSchedPtr) > 0.0d0) .AND. & // LoopHeatingCoilMaxRTF used for AirflowNetwork gets set in child components (gas and fuel) - if (state.afn->distribution_simulated) { + if (state.afn->distribution_simulated && this->m_sysType != SysType::PackagedAC && this->m_sysType != SysType::PackagedHP && + this->m_sysType != SysType::PackagedWSHP) { auto &afnInfo = state.dataAirLoop->AirLoopAFNInfo(AirLoopNum); afnInfo.AFNLoopHeatingCoilMaxRTF = max(afnInfo.AFNLoopHeatingCoilMaxRTF, LoopHeatingCoilMaxRTFSave); afnInfo.AFNLoopDXCoilRTF = max(afnInfo.AFNLoopDXCoilRTF, LoopDXCoilMaxRTFSave); @@ -15664,7 +15671,8 @@ namespace UnitarySystems { this->m_ElecPower = locFanElecPower + elecCoolingPower + elecHeatingPower + suppHeatingPower + defrostElecPower + this->m_TotalAuxElecPower; this->m_ElecPowerConsumption = this->m_ElecPower * ReportingConstant; - if (state.afn->distribution_simulated) { + if (state.afn->distribution_simulated && this->m_sysType != SysType::PackagedAC && this->m_sysType != SysType::PackagedHP && + this->m_sysType != SysType::PackagedWSHP) { state.dataAirLoop->AirLoopAFNInfo(AirLoopNum).LoopSystemOnMassFlowrate = state.dataUnitarySystems->CompOnMassFlow; state.dataAirLoop->AirLoopAFNInfo(AirLoopNum).LoopSystemOffMassFlowrate = state.dataUnitarySystems->CompOffMassFlow; state.dataAirLoop->AirLoopAFNInfo(AirLoopNum).LoopFanOperationMode = this->m_FanOpMode; @@ -16718,6 +16726,33 @@ namespace UnitarySystems { return false; } + bool getUnitarySystemNodeNumber(EnergyPlusData &state, int const nodeNumber) + { + for (int unitarySysIndex = 0; unitarySysIndex <= state.dataUnitarySystems->numUnitarySystems - 1; ++unitarySysIndex) { + auto &unitarySys = state.dataUnitarySystems->unitarySys[unitarySysIndex]; + + int FanInletNodeIndex = state.dataFans->fans(unitarySys.m_FanIndex)->inletNodeNum; + int FanOutletNodeIndex = state.dataFans->fans(unitarySys.m_FanIndex)->outletNodeNum; + + bool unitarySysOutdoorAir = false; + if (unitarySys.m_CoolOutAirVolFlow == 0 && unitarySys.m_HeatOutAirVolFlow == 0 && unitarySys.m_NoCoolHeatOutAirVolFlow == 0) { + unitarySysOutdoorAir = true; + } + + if (unitarySys.m_sysType == UnitarySys::SysType::PackagedWSHP || unitarySys.m_sysType == UnitarySys::SysType::PackagedAC || + unitarySys.m_sysType == UnitarySys::SysType::PackagedHP) { + if (unitarySysOutdoorAir && (nodeNumber == FanInletNodeIndex || nodeNumber == FanOutletNodeIndex || + nodeNumber == unitarySys.AirInNode || nodeNumber == unitarySys.m_OAMixerNodes[0] || + nodeNumber == unitarySys.m_OAMixerNodes[1] || nodeNumber == unitarySys.m_OAMixerNodes[2]) || + nodeNumber == unitarySys.m_OAMixerNodes[3] || nodeNumber == unitarySys.CoolCoilOutletNodeNum || + nodeNumber == unitarySys.HeatCoilOutletNodeNum) { + return true; + } + } + } + return false; + } + void setupAllOutputVars(EnergyPlusData &state, int const numAllSystemTypes) { // setup reports only once diff --git a/src/EnergyPlus/UnitarySystem.hh b/src/EnergyPlus/UnitarySystem.hh index 298d986a33b..f2330dc748b 100644 --- a/src/EnergyPlus/UnitarySystem.hh +++ b/src/EnergyPlus/UnitarySystem.hh @@ -952,6 +952,7 @@ namespace UnitarySystems { int getDesignSpecMSHPIndex(EnergyPlusData &state, std::string_view objectName); int getUnitarySystemIndex(EnergyPlusData &state, std::string_view objectName); + bool getUnitarySystemNodeNumber(EnergyPlusData &state, int const nodeNumber); bool searchZoneInletNodes(EnergyPlusData &state, int nodeToFind, int &ZoneEquipConfigIndex, int &InletNodeIndex); bool searchZoneInletNodesByEquipmentIndex(EnergyPlusData &state, int nodeToFind, int zoneEquipmentIndex); diff --git a/tst/EnergyPlus/unit/AirflowNetworkHVAC.unit.cc b/tst/EnergyPlus/unit/AirflowNetworkHVAC.unit.cc index 712f22d1fba..2753d5c752e 100644 --- a/tst/EnergyPlus/unit/AirflowNetworkHVAC.unit.cc +++ b/tst/EnergyPlus/unit/AirflowNetworkHVAC.unit.cc @@ -69,6 +69,7 @@ #include #include #include +#include #include #include #include @@ -81,6 +82,7 @@ #include #include #include +#include #include #include #include @@ -19767,4 +19769,157 @@ TEST_F(EnergyPlusFixture, AirflowNetwork_ZoneOrderTest) state->afn->AirflowNetworkNodeData(3).EPlusNodeNum = 0; } +TEST_F(EnergyPlusFixture, AirflowNetwork_TestZoneEqpSupportZoneVRF) +{ + // Create zone + state->dataGlobal->NumOfZones = 1; + state->dataHeatBal->Zone.allocate(1); + state->dataHeatBal->Zone(1).Name = "ZONE 1"; + + // Create surfaces + state->dataSurface->Surface.allocate(1); + state->dataSurface->Surface(1).Name = "ZN004:ROOF001"; + state->dataSurface->Surface(1).Zone = 1; + state->dataSurface->Surface(1).ZoneName = "ZONE 1"; + state->dataSurface->Surface(1).Azimuth = 0.0; + state->dataSurface->Surface(1).ExtBoundCond = 0; + state->dataSurface->Surface(1).HeatTransSurf = true; + state->dataSurface->Surface(1).Tilt = 180.0; + state->dataSurface->Surface(1).Sides = 4; + state->dataSurface->Surface(1).Name = "ZN004:ROOF002"; + state->dataSurface->Surface(1).Zone = 1; + state->dataSurface->Surface(1).ZoneName = "ZONE 1"; + state->dataSurface->Surface(1).Azimuth = 0.0; + state->dataSurface->Surface(1).ExtBoundCond = 0; + state->dataSurface->Surface(1).HeatTransSurf = true; + state->dataSurface->Surface(1).Tilt = 180.0; + state->dataSurface->Surface(1).Sides = 4; + + state->dataSurface->Surface(1).OriginalClass = DataSurfaces::SurfaceClass::Window; + + // Create air system + state->dataAirSystemsData->PrimaryAirSystems.allocate(1); + state->dataAirSystemsData->PrimaryAirSystems(1).NumBranches = 1; + state->dataAirSystemsData->PrimaryAirSystems(1).Branch.allocate(1); + state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).TotalComponents = 1; + state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp.allocate(1); + state->dataAirSystemsData->PrimaryAirSystems(1).Branch(1).Comp(1).TypeOf = "Fan:ConstantVolume"; + + // Create air nodes + state->dataLoopNodes->NumOfNodes = 11; + state->dataLoopNodes->Node.allocate(11); + state->dataLoopNodes->Node(1).FluidType = DataLoopNode::NodeFluidType::Air; + state->dataLoopNodes->Node(2).FluidType = DataLoopNode::NodeFluidType::Air; + state->dataLoopNodes->Node(3).FluidType = DataLoopNode::NodeFluidType::Air; + state->dataLoopNodes->NodeID.allocate(11); + state->dataLoopNodes->NodeID(1) = "ZONE 1 AIR NODE"; + bool errFlag{false}; + BranchNodeConnections::RegisterNodeConnection(*state, + 1, + "ZONE 1 AIR NODE", + DataLoopNode::ConnectionObjectType::FanOnOff, + "Object1", + DataLoopNode::ConnectionType::ZoneNode, + NodeInputManager::CompFluidStream::Primary, + false, + errFlag); + EXPECT_FALSE(errFlag); + + // Connect zone to air node + state->dataZoneEquip->ZoneEquipConfig.allocate(1); + state->dataZoneEquip->ZoneEquipConfig(1).IsControlled = true; + state->dataZoneEquip->ZoneEquipConfig(1).ZoneName = "ZONE 1"; + state->dataZoneEquip->ZoneEquipConfig(1).ZoneNode = 1; + state->dataZoneEquip->ZoneEquipConfig(1).NumInletNodes = 0; + state->dataZoneEquip->ZoneEquipConfig(1).NumReturnNodes = 0; + state->dataZoneEquip->ZoneEquipConfig(1).IsControlled = true; + + // One AirflowNetwork:MultiZone:Zone object + state->afn->AirflowNetworkNumOfZones = 1; + state->afn->MultizoneZoneData.allocate(1); + state->afn->MultizoneZoneData(1).ZoneNum = 1; + state->afn->MultizoneZoneData(1).ZoneName = "ZONE 1"; + + // Assume only one AirflowNetwork:Distribution:Node object is set for the Zone Air Node + state->afn->AirflowNetworkNumOfNodes = 1; + state->afn->AirflowNetworkNodeData.allocate(1); + state->afn->AirflowNetworkNodeData(1).Name = "ZONE 1"; + state->afn->AirflowNetworkNodeData(1).EPlusZoneNum = 1; + + state->afn->SplitterNodeNumbers.allocate(2); + state->afn->SplitterNodeNumbers(1) = 0; + state->afn->SplitterNodeNumbers(2) = 0; + + // Set flag to support zone equipment + state->afn->simulation_control.allow_unsupported_zone_equipment = true; + + // Create Fans + Real64 supplyFlowRate = 0.005; + Real64 exhaustFlowRate = 0.005; + + auto *fan1 = new Fans::FanComponent; + fan1->Name = "SupplyFan"; + + fan1->inletNodeNum = 2; + fan1->outletNodeNum = 3; + fan1->type = HVAC::FanType::OnOff; + fan1->maxAirFlowRate = supplyFlowRate; + + state->dataFans->fans.push_back(fan1); + state->dataFans->fanMap.insert_or_assign(fan1->Name, state->dataFans->fans.size()); + + state->dataLoopNodes->NodeID(2) = "SupplyFanInletNode"; + BranchNodeConnections::RegisterNodeConnection(*state, + 2, + state->dataLoopNodes->NodeID(2), + DataLoopNode::ConnectionObjectType::FanOnOff, + state->dataFans->fans(1)->Name, + DataLoopNode::ConnectionType::Inlet, + NodeInputManager::CompFluidStream::Primary, + false, + errFlag); + state->dataLoopNodes->NodeID(3) = "SupplyFanOutletNode"; + BranchNodeConnections::RegisterNodeConnection(*state, + 3, + state->dataLoopNodes->NodeID(3), + DataLoopNode::ConnectionObjectType::FanOnOff, + state->dataFans->fans(1)->Name, + DataLoopNode::ConnectionType::Outlet, + NodeInputManager::CompFluidStream::Primary, + false, + errFlag); + + // Create VRF Terminal + state->dataHVACVarRefFlow->VRFTU.allocate(1); + state->dataHVACVarRefFlow->GetVRFInputFlag = false; + state->dataHVACVarRefFlow->NumVRFTU = 1; + state->dataHVACVarRefFlow->VRFTU(1).CoolOutAirVolFlow = 0.0; + state->dataHVACVarRefFlow->VRFTU(1).HeatOutAirVolFlow = 0.0; + state->dataHVACVarRefFlow->VRFTU(1).NoCoolHeatOutAirVolFlow = 0.0; + state->dataHVACVarRefFlow->VRFTU(1).FanIndex = 1; + state->dataHVACVarRefFlow->VRFTU(1).fanInletNode = 2; + state->dataHVACVarRefFlow->VRFTU(1).fanOutletNode = 3; + state->dataHVACVarRefFlow->VRFTU(1).VRFTUInletNodeNum = 4; + state->dataHVACVarRefFlow->VRFTU(1).VRFTUOutletNodeNum = 5; + state->dataHVACVarRefFlow->VRFTU(1).heatCoilAirOutNode = 6; + state->dataHVACVarRefFlow->VRFTU(1).coolCoilAirOutNode = 7; + state->dataHVACVarRefFlow->VRFTU(1).VRFTUOAMixerOANodeNum = 8; + state->dataHVACVarRefFlow->VRFTU(1).VRFTUOAMixerRelNodeNum = 9; + state->dataHVACVarRefFlow->VRFTU(1).VRFTUOAMixerRetNodeNum = 10; + state->dataHVACVarRefFlow->VRFTU(1).VRFTUOAMixerMixedNodeNum = 11; + + state->dataLoopNodes->NodeID(4) = "Test"; + + // Check validation and expected warning + state->afn->validate_distribution(); + + EXPECT_TRUE(compare_err_stream_substring( + " ** Warning ** AirflowNetwork::Solver::validate_distribution: A ZoneHVAC:TerminalUnit:VariableRefrigerantFlow is simulated " + "along with an AirflowNetwork but is not included in the AirflowNetwork.\n", + true)); + + // Unset flag to support zone equipment + state->afn->simulation_control.allow_unsupported_zone_equipment = false; +} + } // namespace EnergyPlus