diff --git a/idd/Energy+.idd.in b/idd/Energy+.idd.in index 0193d450215..cbcbd5bf499 100644 --- a/idd/Energy+.idd.in +++ b/idd/Energy+.idd.in @@ -21309,7 +21309,8 @@ RoomAir:Node:AirflowNetwork:HVACEquipment, \key ZoneHVAC:IdealLoadsAirSystem \key ZoneHVAC:RefrigerationChillerSet \key Fan:ZoneExhaust - \key WaterHeater:HeatPump + \key WaterHeater:HeatPump:PumpedCondenser + \key WaterHeater:HeatPump:WrappedCondenser \key AirTerminal:DualDuct:ConstantVolume \key AirTerminal:DualDuct:VAV \key AirTerminal:SingleDuct:ConstantVolume:Reheat @@ -21359,7 +21360,8 @@ RoomAir:Node:AirflowNetwork:HVACEquipment, \key ZoneHVAC:IdealLoadsAirSystem \key ZoneHVAC:RefrigerationChillerSet \key Fan:ZoneExhaust - \key WaterHeater:HeatPump + \key WaterHeater:HeatPump:PumpedCondenser + \key WaterHeater:HeatPump:WrappedCondenser \key AirTerminal:DualDuct:ConstantVolume \key AirTerminal:DualDuct:VAV \key AirTerminal:SingleDuct:ConstantVolume:Reheat diff --git a/src/EnergyPlus/FanCoilUnits.cc b/src/EnergyPlus/FanCoilUnits.cc index 2b9680775cc..7c27178d74f 100644 --- a/src/EnergyPlus/FanCoilUnits.cc +++ b/src/EnergyPlus/FanCoilUnits.cc @@ -4419,6 +4419,23 @@ namespace FanCoilUnits { } } + int getEqIndex(EnergyPlusData &state, std::string_view CompName) + { + if (state.dataFanCoilUnits->GetFanCoilInputFlag) { + GetFanCoilUnits(state); + state.dataFanCoilUnits->GetFanCoilInputFlag = false; + } + + for (int FanCoilIndex = 1; FanCoilIndex <= state.dataFanCoilUnits->NumFanCoils; ++FanCoilIndex) { + auto &fanCoil = state.dataFanCoilUnits->FanCoil(FanCoilIndex); + if (Util::SameString(fanCoil.Name, CompName)) { + return FanCoilIndex; + } + } + + return 0; + } + } // namespace FanCoilUnits } // namespace EnergyPlus diff --git a/src/EnergyPlus/FanCoilUnits.hh b/src/EnergyPlus/FanCoilUnits.hh index f06fc6762d5..68983667875 100644 --- a/src/EnergyPlus/FanCoilUnits.hh +++ b/src/EnergyPlus/FanCoilUnits.hh @@ -319,7 +319,7 @@ namespace FanCoilUnits { void ReportFanCoilUnit(EnergyPlusData &state, int FanCoilNum); // number of the current fan coil unit being simulated - int GetFanCoilZoneInletAirNode(EnergyPlusData &state, int FanCoilNum); + int GetFanCoilZoneInletAirNode(EnergyPlusData &state, int const FanCoilNum); int GetFanCoilOutAirNode(EnergyPlusData &state, int FanCoilNum); @@ -380,6 +380,7 @@ namespace FanCoilUnits { int WaterControlNode, Real64 MinWaterFlow); + int getEqIndex(EnergyPlusData &state, std::string_view CompName); } // namespace FanCoilUnits struct FanCoilUnitsData : BaseGlobalStruct diff --git a/src/EnergyPlus/HVACStandAloneERV.cc b/src/EnergyPlus/HVACStandAloneERV.cc index 63c9dbae8fa..15438f65487 100644 --- a/src/EnergyPlus/HVACStandAloneERV.cc +++ b/src/EnergyPlus/HVACStandAloneERV.cc @@ -1685,4 +1685,20 @@ bool GetStandAloneERVNodeNumber(EnergyPlusData &state, int const NodeNumber) return false; } +int getEqIndex(EnergyPlusData &state, std::string_view CompName) +{ + if (state.dataHVACStandAloneERV->GetERVInputFlag) { + GetStandAloneERV(state); + state.dataHVACStandAloneERV->GetERVInputFlag = false; + } + + for (int StandAloneERVNum = 1; StandAloneERVNum <= state.dataHVACStandAloneERV->NumStandAloneERVs; StandAloneERVNum++) { + if (Util::SameString(CompName, state.dataHVACStandAloneERV->StandAloneERV(StandAloneERVNum).Name)) { + return StandAloneERVNum; + break; + } + } + return 0; +} + } // namespace EnergyPlus::HVACStandAloneERV diff --git a/src/EnergyPlus/HVACStandAloneERV.hh b/src/EnergyPlus/HVACStandAloneERV.hh index 98c1eb381e3..382cbea51bb 100644 --- a/src/EnergyPlus/HVACStandAloneERV.hh +++ b/src/EnergyPlus/HVACStandAloneERV.hh @@ -186,6 +186,8 @@ namespace HVACStandAloneERV { bool GetStandAloneERVNodeNumber(EnergyPlusData &state, int NodeNumber); + int getEqIndex(EnergyPlusData &state, std::string_view CompName); + } // namespace HVACStandAloneERV struct HVACStandAloneERVData : BaseGlobalStruct diff --git a/src/EnergyPlus/HVACVariableRefrigerantFlow.cc b/src/EnergyPlus/HVACVariableRefrigerantFlow.cc index ea402f0ea39..93b4c6670b0 100644 --- a/src/EnergyPlus/HVACVariableRefrigerantFlow.cc +++ b/src/EnergyPlus/HVACVariableRefrigerantFlow.cc @@ -10753,6 +10753,21 @@ int GetVRFTUReturnAirNode(EnergyPlusData &state, int const VRFTUNum) } } +int getEqIndex(EnergyPlusData &state, std::string_view VRFTUName) +{ + if (state.dataHVACVarRefFlow->GetVRFInputFlag) { + GetVRFInput(state); + state.dataHVACVarRefFlow->GetVRFInputFlag = false; + } + + for (int VRFTUNum = 1; VRFTUNum <= state.dataHVACVarRefFlow->NumVRFTU; VRFTUNum++) { + if (Util::SameString(VRFTUName, state.dataHVACVarRefFlow->VRFTU(VRFTUNum).Name)) { + return VRFTUNum; + } + } + return 0; +} + void getVRFTUZoneLoad( EnergyPlusData &state, int const VRFTUNum, Real64 &zoneLoad, Real64 &LoadToHeatingSP, Real64 &LoadToCoolingSP, bool const InitFlag) { diff --git a/src/EnergyPlus/HVACVariableRefrigerantFlow.hh b/src/EnergyPlus/HVACVariableRefrigerantFlow.hh index 480aa67321a..71e60fa8ea7 100644 --- a/src/EnergyPlus/HVACVariableRefrigerantFlow.hh +++ b/src/EnergyPlus/HVACVariableRefrigerantFlow.hh @@ -974,6 +974,8 @@ namespace HVACVariableRefrigerantFlow { Real64 const T_suc // Compressor suction temperature Te' [C] ); + int getEqIndex(EnergyPlusData &state, std::string_view VRFTUName); + } // namespace HVACVariableRefrigerantFlow struct HVACVarRefFlowData : BaseGlobalStruct diff --git a/src/EnergyPlus/HybridUnitaryAirConditioners.cc b/src/EnergyPlus/HybridUnitaryAirConditioners.cc index 9d9147a0487..53b21ca0716 100644 --- a/src/EnergyPlus/HybridUnitaryAirConditioners.cc +++ b/src/EnergyPlus/HybridUnitaryAirConditioners.cc @@ -1366,6 +1366,23 @@ int GetHybridUnitaryACReturnAirNode(EnergyPlusData &state, int const CompNum) return GetHybridUnitaryACReturnAirNode; } +int getHybridUnitaryACIndex(EnergyPlusData &state, std::string_view CompName) +{ + bool errFlag = false; + if (state.dataHybridUnitaryAC->GetInputZoneHybridEvap) { + GetInputZoneHybridUnitaryAirConditioners(state, errFlag); + state.dataHybridUnitaryAC->GetInputZoneHybridEvap = false; + } + + for (int UnitLoop = 1; UnitLoop <= state.dataHybridUnitaryAC->NumZoneHybridEvap; ++UnitLoop) { + if (Util::SameString(state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitLoop).Name, CompName)) { + return UnitLoop; + } + } + + return 0; +} + //***************************************************************************************** } // namespace EnergyPlus::HybridUnitaryAirConditioners diff --git a/src/EnergyPlus/HybridUnitaryAirConditioners.hh b/src/EnergyPlus/HybridUnitaryAirConditioners.hh index 49ea36b3d97..c93210bcff9 100644 --- a/src/EnergyPlus/HybridUnitaryAirConditioners.hh +++ b/src/EnergyPlus/HybridUnitaryAirConditioners.hh @@ -98,6 +98,8 @@ namespace HybridUnitaryAirConditioners { int GetHybridUnitaryACReturnAirNode(EnergyPlusData &state, int UnitNum); + int getHybridUnitaryACIndex(EnergyPlusData &state, std::string_view CompName); + } // namespace HybridUnitaryAirConditioners struct HybridUnitaryAirConditionersData : BaseGlobalStruct diff --git a/src/EnergyPlus/OutdoorAirUnit.cc b/src/EnergyPlus/OutdoorAirUnit.cc index 2dcc30e4a61..153fa01875b 100644 --- a/src/EnergyPlus/OutdoorAirUnit.cc +++ b/src/EnergyPlus/OutdoorAirUnit.cc @@ -2471,6 +2471,22 @@ namespace OutdoorAirUnit { return GetOutdoorAirUnitReturnAirNode; } + int getOutdoorAirUnitEqIndex(EnergyPlusData &state, std::string_view EquipName) + { + if (state.dataOutdoorAirUnit->GetOutdoorAirUnitInputFlag) { + OutdoorAirUnit::GetOutdoorAirUnitInputs(state); + state.dataOutdoorAirUnit->GetOutdoorAirUnitInputFlag = false; + } + + for (int OAUnitNum = 1; OAUnitNum <= state.dataOutdoorAirUnit->NumOfOAUnits; ++OAUnitNum) { + if (Util::SameString(state.dataOutdoorAirUnit->OutAirUnit(OAUnitNum).Name, EquipName)) { + return OAUnitNum; + } + } + + return 0; + } + } // namespace OutdoorAirUnit } // namespace EnergyPlus diff --git a/src/EnergyPlus/OutdoorAirUnit.hh b/src/EnergyPlus/OutdoorAirUnit.hh index 32ab3ed12e1..977c9c4f3fc 100644 --- a/src/EnergyPlus/OutdoorAirUnit.hh +++ b/src/EnergyPlus/OutdoorAirUnit.hh @@ -309,6 +309,8 @@ namespace OutdoorAirUnit { int GetOutdoorAirUnitZoneInletNode(EnergyPlusData &state, int OAUnitNum); int GetOutdoorAirUnitReturnAirNode(EnergyPlusData &state, int OAUnitNum); + + int getOutdoorAirUnitEqIndex(EnergyPlusData &state, std::string_view EquipName); } // namespace OutdoorAirUnit struct OutdoorAirUnitData : BaseGlobalStruct diff --git a/src/EnergyPlus/PurchasedAirManager.cc b/src/EnergyPlus/PurchasedAirManager.cc index fa358b41a73..3fd4bf0c89d 100644 --- a/src/EnergyPlus/PurchasedAirManager.cc +++ b/src/EnergyPlus/PurchasedAirManager.cc @@ -3318,6 +3318,22 @@ int GetPurchasedAirReturnAirNode(EnergyPlusData &state, int const PurchAirNum) return GetPurchasedAirReturnAirNode; } +int getPurchasedAirIndex(EnergyPlusData &state, std::string_view PurchAirName) +{ + if (state.dataPurchasedAirMgr->GetPurchAirInputFlag) { + GetPurchasedAir(state); + state.dataPurchasedAirMgr->GetPurchAirInputFlag = false; + } + + for (int PurchAirNum = 1; PurchAirNum <= state.dataPurchasedAirMgr->NumPurchAir; ++PurchAirNum) { + if (Util::SameString(state.dataPurchasedAirMgr->PurchAir(PurchAirNum).Name, PurchAirName)) { + return PurchAirNum; + } + } + + return 0; +} + Real64 GetPurchasedAirMixedAirTemp(EnergyPlusData &state, int const PurchAirNum) { diff --git a/src/EnergyPlus/PurchasedAirManager.hh b/src/EnergyPlus/PurchasedAirManager.hh index d31939f1250..d8c7ee1c36d 100644 --- a/src/EnergyPlus/PurchasedAirManager.hh +++ b/src/EnergyPlus/PurchasedAirManager.hh @@ -379,6 +379,8 @@ namespace PurchasedAirManager { int GetPurchasedAirReturnAirNode(EnergyPlusData &state, int PurchAirNum); + int getPurchasedAirIndex(EnergyPlusData &state, std::string_view PurchAirName); + Real64 GetPurchasedAirMixedAirTemp(EnergyPlusData &state, int PurchAirNum); Real64 GetPurchasedAirMixedAirHumRat(EnergyPlusData &state, int PurchAirNum); diff --git a/src/EnergyPlus/RoomAirModelManager.cc b/src/EnergyPlus/RoomAirModelManager.cc index c25abc8282e..8c890593867 100644 --- a/src/EnergyPlus/RoomAirModelManager.cc +++ b/src/EnergyPlus/RoomAirModelManager.cc @@ -58,6 +58,7 @@ // EnergyPlus Headers #include +#include #include #include #include @@ -71,19 +72,31 @@ #include #include #include +#include #include #include +#include +#include +#include #include #include #include +#include #include #include +#include #include #include #include #include #include +#include +#include #include +#include +#include +#include +#include #include namespace EnergyPlus { @@ -1250,7 +1263,7 @@ namespace RoomAir { int TotNumOfRAFNNodeGainsLists; int TotNumOfRAFNNodeHVACLists; int TotNumEquip; - bool IntEquipError; + bool IntEquipFound; auto &ipsc = state.dataIPShortCut; ipsc->cCurrentModuleObject = "RoomAirSettings:AirflowNetwork"; @@ -1564,11 +1577,11 @@ namespace RoomAir { } // loop thru TotNumOfRAFNNodeGainsLists // Get data of HVAC equipment - ipsc->cCurrentModuleObject = "RoomAir:Node:AirflowNetwork:HVACEquipment"; - TotNumOfRAFNNodeHVACLists = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, ipsc->cCurrentModuleObject); + std::string const cCurrentModuleObject = "RoomAir:Node:AirflowNetwork:HVACEquipment"; + TotNumOfRAFNNodeHVACLists = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, cCurrentModuleObject); for (int Loop = 1; Loop <= TotNumOfRAFNNodeHVACLists; ++Loop) { state.dataInputProcessing->inputProcessor->getObjectItem(state, - ipsc->cCurrentModuleObject, + cCurrentModuleObject, Loop, ipsc->cAlphaArgs, NumAlphas, @@ -1580,10 +1593,10 @@ namespace RoomAir { ipsc->cAlphaFieldNames, ipsc->cNumericFieldNames); - ErrorObjectHeader eoh{routineName, ipsc->cCurrentModuleObject, ipsc->cAlphaArgs(1)}; + ErrorObjectHeader eoh{routineName, cCurrentModuleObject, ipsc->cAlphaArgs(1)}; if (mod((NumAlphas + NumNumbers - 1), 4) != 0) { - ShowSevereError(state, format("GetRoomAirflowNetworkData: For {}: {}", ipsc->cCurrentModuleObject, ipsc->cAlphaArgs(1))); + ShowSevereError(state, format("GetRoomAirflowNetworkData: For {}: {}", cCurrentModuleObject, ipsc->cAlphaArgs(1))); ShowContinueError(state, format("Extensible field set are not evenly divisable by 4. Number of data entries = {}", fmt::to_string(NumAlphas + NumNumbers - 1))); @@ -1606,8 +1619,8 @@ namespace RoomAir { auto &roomAFNNode = roomAFNZoneInfo.Node(RAFNNodeNum); if (allocated(roomAFNNode.HVAC)) { ShowSevereError(state, format("GetRoomAirflowNetworkData: Invalid {} = {}", ipsc->cAlphaFieldNames(1), ipsc->cAlphaArgs(1))); - ShowContinueError(state, format("Entered in {} = {}", ipsc->cCurrentModuleObject, ipsc->cAlphaArgs(1))); - ShowContinueError(state, format("Duplicate {} name.", ipsc->cCurrentModuleObject)); + ShowContinueError(state, format("Entered in {} = {}", cCurrentModuleObject, ipsc->cAlphaArgs(1))); + ShowContinueError(state, format("Duplicate {} name.", cCurrentModuleObject)); ErrorsFound = true; continue; } @@ -1635,19 +1648,25 @@ namespace RoomAir { roomAFNNodeHVAC.SupplyFraction = ipsc->rNumericArgs(iEquipArg); roomAFNNodeHVAC.ReturnFraction = ipsc->rNumericArgs(iEquipArg); - IntEquipError = CheckEquipName(state, - roomAFNNodeHVAC.Name, - roomAFNNodeHVAC.SupplyNodeName, - roomAFNNodeHVAC.ReturnNodeName, - TotNumEquip, - roomAFNNodeHVAC.zoneEquipType); + // get equipment index + int EquipIndex = 0; + for (int thisZoneEquipNum = 1; thisZoneEquipNum <= state.dataZoneEquip->ZoneEquipList(iZone).NumOfEquipTypes; + ++thisZoneEquipNum) { + if (Util::SameString(state.dataZoneEquip->ZoneEquipList(iZone).EquipName(thisZoneEquipNum), roomAFNNodeHVAC.Name) && + roomAFNNodeHVAC.zoneEquipType == state.dataZoneEquip->ZoneEquipList(iZone).EquipType(thisZoneEquipNum)) { + EquipIndex = state.dataZoneEquip->ZoneEquipList(iZone).EquipIndex(thisZoneEquipNum); + break; + } + } + IntEquipFound = CheckEquipName( + state, roomAFNNodeHVAC.Name, roomAFNNodeHVAC.SupplyNodeName, roomAFNNodeHVAC.ReturnNodeName, roomAFNNodeHVAC.zoneEquipType); - if (!IntEquipError) { + if (!IntEquipFound) { ShowSevereError(state, format("GetRoomAirflowNetworkData: Invalid {} = {}", ipsc->cAlphaFieldNames(3 + (iEquip - 1) * 2), ipsc->cAlphaArgs(2 + (iEquip - 1) * 2))); - ShowContinueError(state, format("Entered in {} = {}", ipsc->cCurrentModuleObject, ipsc->cAlphaArgs(1))); + ShowContinueError(state, format("Entered in {} = {}", cCurrentModuleObject, ipsc->cAlphaArgs(1))); ShowContinueError(state, "Internal gain did not match correctly"); ErrorsFound = true; } @@ -2676,7 +2695,6 @@ namespace RoomAir { std::string const &EquipName, // Equipment Name std::string &SupplyNodeName, // Supply node name std::string &ReturnNodeName, // Return node name - int TotNumEquip, // how many of this equipment type DataZoneEquipment::ZoneEquipType zoneEquipType) { @@ -2692,218 +2710,219 @@ namespace RoomAir { static constexpr std::string_view routineName = "CheckEquipName"; // Return value - bool EquipFind; // True if an error is found + bool EquipFind = false; // if true, equip is found - // FUNCTION LOCAL VARIABLE DECLARATIONS: - int NumAlphas; - int NumNumbers; - int Status; // Used in GetObjectItem - int MaxNums = 0; // Maximum number of numeric input fields - int MaxAlphas = 0; // Maximum number of alpha input fields - int TotalArgs = 0; // Total number of alpha and numeric arguments(max) for a - Array1D_string Alphas; // Alpha input items for object - Array1D Numbers; // Numeric input items for object bool errorfound; - - NumAlphas = 1; - NumNumbers = 1; - EquipFind = false; + int SupplyNodeNum = 0; + int ReturnNodeNum = 0; SupplyNodeName = ""; + int EquipIndex; if (zoneEquipType == DataZoneEquipment::ZoneEquipType::Invalid) return EquipFind; - std::string_view equipTypeName = DataZoneEquipment::zoneEquipTypeNamesUC[(int)zoneEquipType]; - state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(state, equipTypeName, TotalArgs, NumAlphas, NumNumbers); - - MaxNums = max(MaxNums, NumNumbers); - MaxAlphas = max(MaxAlphas, NumAlphas); - - if (MaxNums > NumNumbers) { - Numbers.allocate(MaxNums); - Numbers = 0.0; - } else if (!allocated(Numbers)) { - Numbers.allocate(MaxNums); - } - - if (MaxAlphas > NumAlphas) { - Alphas.allocate(MaxAlphas); - Alphas = ""; - } else if (!allocated(Alphas)) { - Alphas.allocate(NumAlphas); - } - - for (int I = 1; I <= TotNumEquip; ++I) { - state.dataInputProcessing->inputProcessor->getObjectItem(state, equipTypeName, I, Alphas, NumAlphas, Numbers, NumNumbers, Status); - if (Util::SameString(Alphas(1), EquipName)) { - EquipFind = true; - break; - } - } - - ErrorObjectHeader eoh{routineName, equipTypeName, EquipName}; - switch (zoneEquipType) { case DataZoneEquipment::ZoneEquipType::VariableRefrigerantFlowTerminal: { // ZoneHVAC:TerminalUnit : VariableRefrigerantFlow - SupplyNodeName = Alphas(4); - ReturnNodeName = ""; // Zone return node + EquipIndex = HVACVariableRefrigerantFlow::getEqIndex(state, EquipName); + if (EquipIndex == 0) return EquipFind; + SupplyNodeNum = state.dataHVACVarRefFlow->VRFTU(EquipIndex).VRFTUOutletNodeNum; } break; case DataZoneEquipment::ZoneEquipType::EnergyRecoveryVentilator: { // ZoneHVAC : EnergyRecoveryVentilator - int fanIndex = Fans::GetFanIndex(state, Alphas(4)); - if (fanIndex == 0) { - ShowSevereItemNotFound(state, eoh, "", Alphas(4)); - errorfound = true; - } - - int nodeNum = state.dataFans->fans(fanIndex)->outletNodeNum; - if (errorfound) { - } - SupplyNodeName = state.dataLoopNodes->NodeID(nodeNum); // ????? - ReturnNodeName = ""; // Zone exhaust node + EquipIndex = HVACStandAloneERV::getEqIndex(state, EquipName); + if (EquipIndex == 0) return EquipFind; + SupplyNodeNum = state.dataHVACStandAloneERV->StandAloneERV(EquipIndex).SupplyAirInletNode; } break; case DataZoneEquipment::ZoneEquipType::FourPipeFanCoil: { // ZoneHVAC : FourPipeFanCoil - SupplyNodeName = Alphas(6); - ReturnNodeName = Alphas(5); + EquipIndex = FanCoilUnits::getEqIndex(state, EquipName); + if (EquipIndex == 0) return EquipFind; + SupplyNodeNum = state.dataFanCoilUnits->FanCoil(EquipIndex).AirOutNode; + ReturnNodeNum = state.dataFanCoilUnits->FanCoil(EquipIndex).AirInNode; } break; case DataZoneEquipment::ZoneEquipType::OutdoorAirUnit: { // ZoneHVAC : OutdoorAirUnit - SupplyNodeName = Alphas(13); - ReturnNodeName = Alphas(14); + EquipIndex = OutdoorAirUnit::getOutdoorAirUnitEqIndex(state, EquipName); + if (EquipIndex == 0) return EquipFind; + SupplyNodeNum = state.dataOutdoorAirUnit->OutAirUnit(EquipIndex).AirOutletNode; + ReturnNodeNum = state.dataOutdoorAirUnit->OutAirUnit(EquipIndex).AirInletNode; } break; case DataZoneEquipment::ZoneEquipType::PackagedTerminalAirConditioner: { // ZoneHVAC : PackagedTerminalAirConditioner - SupplyNodeName = Alphas(4); - ReturnNodeName = Alphas(3); + EquipIndex = UnitarySystems::getZoneEqIndex(state, EquipName, zoneEquipType); + if (EquipIndex == -1) return EquipFind; + SupplyNodeNum = state.dataUnitarySystems->unitarySys[EquipIndex].AirOutNode; + ReturnNodeNum = state.dataUnitarySystems->unitarySys[EquipIndex].AirInNode; } break; case DataZoneEquipment::ZoneEquipType::PackagedTerminalHeatPump: { // ZoneHVAC : PackagedTerminalHeatPump - SupplyNodeName = Alphas(4); - ReturnNodeName = Alphas(3); + EquipIndex = UnitarySystems::getZoneEqIndex(state, EquipName, zoneEquipType); + if (EquipIndex == -1) return EquipFind; + SupplyNodeNum = state.dataUnitarySystems->unitarySys[EquipIndex].AirOutNode; + ReturnNodeNum = state.dataUnitarySystems->unitarySys[EquipIndex].AirInNode; } break; case DataZoneEquipment::ZoneEquipType::UnitHeater: { // ZoneHVAC : UnitHeater - SupplyNodeName = Alphas(4); - ReturnNodeName = Alphas(3); + EquipIndex = UnitHeater::getUnitHeaterIndex(state, EquipName); + if (EquipIndex == 0) return EquipFind; + ReturnNodeNum = state.dataUnitHeaters->UnitHeat(EquipIndex).AirInNode; + SupplyNodeNum = state.dataUnitHeaters->UnitHeat(EquipIndex).AirOutNode; } break; case DataZoneEquipment::ZoneEquipType::UnitVentilator: { // ZoneHVAC : UnitVentilator - SupplyNodeName = Alphas(7); - ReturnNodeName = Alphas(6); + EquipIndex = UnitVentilator::getUnitVentilatorIndex(state, EquipName); + if (EquipIndex == 0) return EquipFind; + ReturnNodeNum = state.dataUnitVentilators->UnitVent(EquipIndex).AirInNode; + SupplyNodeNum = state.dataUnitVentilators->UnitVent(EquipIndex).AirOutNode; } break; case DataZoneEquipment::ZoneEquipType::VentilatedSlab: { // ZoneHVAC : VentilatedSlab - SupplyNodeName = Alphas(20); - ReturnNodeName = Alphas(18); + EquipIndex = VentilatedSlab::getVentilatedSlabIndex(state, EquipName); + if (EquipIndex == 0) return EquipFind; + ReturnNodeNum = state.dataVentilatedSlab->VentSlab(EquipIndex).ReturnAirNode; + SupplyNodeNum = state.dataVentilatedSlab->VentSlab(EquipIndex).ZoneAirInNode; } break; case DataZoneEquipment::ZoneEquipType::PackagedTerminalHeatPumpWaterToAir: { // ZoneHVAC : WaterToAirHeatPump - SupplyNodeName = Alphas(4); - ReturnNodeName = Alphas(3); + EquipIndex = UnitarySystems::getZoneEqIndex(state, EquipName, zoneEquipType); + if (EquipIndex == -1) return EquipFind; + SupplyNodeNum = state.dataUnitarySystems->unitarySys[EquipIndex].AirOutNode; + ReturnNodeNum = state.dataUnitarySystems->unitarySys[EquipIndex].AirInNode; } break; case DataZoneEquipment::ZoneEquipType::WindowAirConditioner: { // ZoneHVAC : WindowAirConditioner - SupplyNodeName = Alphas(4); - ReturnNodeName = Alphas(3); + EquipIndex = WindowAC::getWindowACIndex(state, EquipName); + if (EquipIndex == 0) return EquipFind; + ReturnNodeNum = state.dataWindowAC->WindAC(EquipIndex).AirInNode; + SupplyNodeNum = state.dataWindowAC->WindAC(EquipIndex).AirOutNode; } break; case DataZoneEquipment::ZoneEquipType::BaseboardElectric: { // ZoneHVAC : Baseboard : RadiantConvective : Electric + // convective equipment without node connection. Will handle later SupplyNodeName = ""; // convection only } break; case DataZoneEquipment::ZoneEquipType::BaseboardWater: { // ZoneHVAC : Baseboard : RadiantConvective : Water + // convective equipment without node connection. Will handle later SupplyNodeName = ""; } break; case DataZoneEquipment::ZoneEquipType::BaseboardSteam: { // ZoneHVAC : Baseboard : RadiantConvective : Steam + // convective equipment without node connection. Will handle later SupplyNodeName = ""; } break; case DataZoneEquipment::ZoneEquipType::BaseboardConvectiveElectric: { // ZoneHVAC : Baseboard : Convective : Electric + // convective equipment without node connection. Will handle later SupplyNodeName = ""; } break; case DataZoneEquipment::ZoneEquipType::BaseboardConvectiveWater: { // ZoneHVAC : Baseboard : Convective : Water + // convective equipment without node connection. Will handle later SupplyNodeName = ""; } break; case DataZoneEquipment::ZoneEquipType::HighTemperatureRadiant: { // ZoneHVAC : HighTemperatureRadiant + // Radiative equipment without node connection. Will handle later SupplyNodeName = ""; } break; case DataZoneEquipment::ZoneEquipType::DehumidifierDX: { // ZoneHVAC : Dehumidifier : DX - SupplyNodeName = Alphas(4); - ReturnNodeName = Alphas(3); + EquipIndex = ZoneDehumidifier::getZoneDehumidifierIndex(state, EquipName); + if (EquipIndex == 0) return EquipFind; + ReturnNodeNum = state.dataZoneDehumidifier->ZoneDehumid(EquipIndex).AirInletNodeNum; + SupplyNodeNum = state.dataZoneDehumidifier->ZoneDehumid(EquipIndex).AirOutletNodeNum; } break; case DataZoneEquipment::ZoneEquipType::PurchasedAir: { // ZoneHVAC : IdealLoadsAirSystem - SupplyNodeName = Alphas(3); - ReturnNodeName = Alphas(4); + EquipIndex = PurchasedAirManager::getPurchasedAirIndex(state, EquipName); + if (EquipIndex == 0) return EquipFind; + ReturnNodeNum = state.dataPurchasedAirMgr->PurchAir(EquipIndex).ZoneExhaustAirNodeNum; + SupplyNodeNum = state.dataPurchasedAirMgr->PurchAir(EquipIndex).ZoneSupplyAirNodeNum; } break; case DataZoneEquipment::ZoneEquipType::RefrigerationChillerSet: { // ZoneHVAC : RefrigerationChillerSet - SupplyNodeName = Alphas(5); - ReturnNodeName = Alphas(4); + // May not apply + // SupplyNodeName = Alphas(5); + // ReturnNodeName = Alphas(4); } break; case DataZoneEquipment::ZoneEquipType::HybridEvaporativeCooler: { // ZoneHVAC : HybridUnitaryAirConditioners - SupplyNodeName = Alphas(11); - ReturnNodeName = Alphas(9); + EquipIndex = HybridUnitaryAirConditioners::getHybridUnitaryACIndex(state, EquipName); + if (EquipIndex == 0) return EquipFind; + ReturnNodeNum = state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(EquipIndex).InletNode; + SupplyNodeNum = state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(EquipIndex).OutletNode; } break; case DataZoneEquipment::ZoneEquipType::ExhaustFan: { // Fan : ZoneExhaust - SupplyNodeName = ""; // ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? May not use + + // SupplyNodeName = ""; // ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? May not use } break; case DataZoneEquipment::ZoneEquipType::HeatPumpWaterHeater: { // WaterHeater : HeatPump - SupplyNodeName = Alphas(8); - ReturnNodeName = Alphas(7); + EquipIndex = WaterThermalTanks::getHeatPumpWaterHeaterIndex(state, EquipName); + if (EquipIndex == 0) return EquipFind; + ReturnNodeNum = state.dataWaterThermalTanks->HPWaterHeater(EquipIndex).HeatPumpAirInletNode; + SupplyNodeNum = state.dataWaterThermalTanks->HPWaterHeater(EquipIndex).HeatPumpAirOutletNode; // For AirTerminals, find matching return node later } break; case DataZoneEquipment::ZoneEquipType::AirTerminalDualDuctConstantVolume: { // AirTerminal : DualDuct : ConstantVolume - SupplyNodeName = Alphas(1); - ReturnNodeName = ""; + // Air teminal components are handled later + // SupplyNodeName = Alphas(1); + // ReturnNodeName = ""; } break; case DataZoneEquipment::ZoneEquipType::AirTerminalDualDuctVAV: { // AirTerminal : DualDuct : VAV - SupplyNodeName = Alphas(1); - ReturnNodeName = ""; + // Air teminal components are handled later + // SupplyNodeName = Alphas(1); + // ReturnNodeName = ""; } break; case DataZoneEquipment::ZoneEquipType::AirTerminalSingleDuctConstantVolumeReheat: { // AirTerminal : SingleDuct : ConstantVolume : Reheat - SupplyNodeName = Alphas(1); - ReturnNodeName = ""; + // Air teminal components are handled later + // SupplyNodeName = Alphas(1); + // ReturnNodeName = ""; } break; case DataZoneEquipment::ZoneEquipType::AirTerminalSingleDuctConstantVolumeNoReheat: { // AirTerminal : SingleDuct : - // ConstantVolume : NoReheat - SupplyNodeName = Alphas(4); - ReturnNodeName = ""; + // Air teminal components are handled later + // SupplyNodeName = Alphas(4); + // ReturnNodeName = ""; } break; case DataZoneEquipment::ZoneEquipType::AirTerminalSingleDuctVAVReheat: { // AirTerminal : SingleDuct : VAV : Reheat - SupplyNodeName = Alphas(1); - ReturnNodeName = ""; + // Air teminal components are handled later + // SupplyNodeName = Alphas(1); + // ReturnNodeName = ""; } break; case DataZoneEquipment::ZoneEquipType::AirTerminalSingleDuctVAVNoReheat: { // AirTerminal : SingleDuct : VAV : NoReheat - SupplyNodeName = Alphas(1); - ReturnNodeName = ""; + // Air teminal components are handled later + // SupplyNodeName = Alphas(1); + // ReturnNodeName = ""; } break; case DataZoneEquipment::ZoneEquipType::AirTerminalSingleDuctSeriesPIUReheat: { // AirTerminal : SingleDuct : SeriesPIU : Reheat - SupplyNodeName = Alphas(1); - ReturnNodeName = ""; + // Air teminal components are handled later + // SupplyNodeName = Alphas(1); + // ReturnNodeName = ""; } break; case DataZoneEquipment::ZoneEquipType::AirTerminalSingleDuctParallelPIUReheat: { // AirTerminal : SingleDuct : ParallelPIU : Reheat - SupplyNodeName = Alphas(1); - ReturnNodeName = ""; + // Air teminal components are handled later + // SupplyNodeName = Alphas(1); + // ReturnNodeName = ""; } break; case DataZoneEquipment::ZoneEquipType::AirTerminalSingleDuctCAVFourPipeInduction: { // AirTerminal : SingleDuct : - // ConstantVolume : FourPipeInduction - SupplyNodeName = Alphas(1); - ReturnNodeName = ""; + // Air teminal components are handled later + // ConstantVolume : FourPipeInduction + // SupplyNodeName = Alphas(1); + // ReturnNodeName = ""; } break; case DataZoneEquipment::ZoneEquipType::AirTerminalSingleDuctVAVReheatVariableSpeedFan: { // AirTerminal : SingleDuct : VAV - // : Reheat : VariableSpeedFan - SupplyNodeName = Alphas(1); - ReturnNodeName = ""; + // Air teminal components are handled later + // : Reheat : VariableSpeedFan + // SupplyNodeName = Alphas(1); + // ReturnNodeName = ""; } break; case DataZoneEquipment::ZoneEquipType::AirTerminalSingleDuctVAVHeatAndCoolReheat: { // AirTerminal : SingleDuct : VAV : // HeatAndCool : Reheat - SupplyNodeName = Alphas(1); - ReturnNodeName = ""; + // Air teminal components are handled later + // SupplyNodeName = Alphas(1); + // ReturnNodeName = ""; } break; case DataZoneEquipment::ZoneEquipType::AirTerminalSingleDuctVAVHeatAndCoolNoReheat: { // AirTerminal : SingleDuct : VAV : // HeatAndCool : NoReheat - SupplyNodeName = Alphas(1); - ReturnNodeName = ""; + // Air teminal components are handled later + // SupplyNodeName = Alphas(1); + // ReturnNodeName = ""; } break; case DataZoneEquipment::ZoneEquipType::AirTerminalSingleDuctConstantVolumeCooledBeam: { // AirTerminal : SingleDuct : // ConstantVolume : CooledBeam - SupplyNodeName = Alphas(5); - ReturnNodeName = ""; + // Air teminal components are handled later + // SupplyNodeName = Alphas(5); + // ReturnNodeName = ""; } break; case DataZoneEquipment::ZoneEquipType::AirTerminalDualDuctVAVOutdoorAir: { // AirTerminal : DualDuct : VAV : OutdoorAir - SupplyNodeName = Alphas(3); - ReturnNodeName = ""; + // Air teminal components are handled later + // SupplyNodeName = Alphas(3); + // ReturnNodeName = ""; } break; case DataZoneEquipment::ZoneEquipType::AirLoopHVACReturnAir: { // AirLoopHVACReturnAir - SupplyNodeName = Alphas(4); // - ReturnNodeName = ""; // + // Air teminal components are handled later + // SupplyNodeName = Alphas(4); // + // ReturnNodeName = ""; // } break; default: { assert(false); @@ -2911,14 +2930,15 @@ namespace RoomAir { } // switch - // Need to find a better to handle allocate and deallocate - if (MaxAlphas > NumAlphas) { - Alphas.deallocate(); + if (SupplyNodeNum > 0) { + SupplyNodeName = state.dataLoopNodes->NodeID(SupplyNodeNum); + EquipFind = true; } - if (MaxNums > NumNumbers) { - Numbers.deallocate(); + if (ReturnNodeNum > 0) { + ReturnNodeName = state.dataLoopNodes->NodeID(ReturnNodeNum); + } else { + ReturnNodeName = ""; } - return EquipFind; } diff --git a/src/EnergyPlus/RoomAirModelManager.hh b/src/EnergyPlus/RoomAirModelManager.hh index 3b5f3b9751d..6f2082797fb 100644 --- a/src/EnergyPlus/RoomAirModelManager.hh +++ b/src/EnergyPlus/RoomAirModelManager.hh @@ -89,7 +89,6 @@ namespace RoomAir { std::string const &EquipName, // Equipment Name std::string &SupplyNodeName, // Supply node name std::string &ReturnNodeName, // Return node name - int TotNumEquip, // how many of this equipment type DataZoneEquipment::ZoneEquipType zoneEquipType); // equipment type number } // namespace RoomAir diff --git a/src/EnergyPlus/UnitHeater.cc b/src/EnergyPlus/UnitHeater.cc index c93ef135ae0..ab65383c24d 100644 --- a/src/EnergyPlus/UnitHeater.cc +++ b/src/EnergyPlus/UnitHeater.cc @@ -1894,6 +1894,22 @@ namespace UnitHeater { } } + int getUnitHeaterIndex(EnergyPlusData &state, std::string_view CompName) + { + if (state.dataUnitHeaters->GetUnitHeaterInputFlag) { + GetUnitHeaterInput(state); + state.dataUnitHeaters->GetUnitHeaterInputFlag = false; + } + + for (int UnitHeatNum = 1; UnitHeatNum <= state.dataUnitHeaters->NumOfUnitHeats; ++UnitHeatNum) { + if (Util::SameString(state.dataUnitHeaters->UnitHeat(UnitHeatNum).Name, CompName)) { + return UnitHeatNum; + } + } + + return 0; + } + } // namespace UnitHeater } // namespace EnergyPlus diff --git a/src/EnergyPlus/UnitHeater.hh b/src/EnergyPlus/UnitHeater.hh index ddce44a2773..d0a95f1011e 100644 --- a/src/EnergyPlus/UnitHeater.hh +++ b/src/EnergyPlus/UnitHeater.hh @@ -202,6 +202,7 @@ namespace UnitHeater { void ReportUnitHeater(EnergyPlusData &state, int const UnitHeatNum); // Unit index in unit heater array + int getUnitHeaterIndex(EnergyPlusData &state, std::string_view CompName); } // namespace UnitHeater struct UnitHeatersData : BaseGlobalStruct diff --git a/src/EnergyPlus/UnitVentilator.cc b/src/EnergyPlus/UnitVentilator.cc index 6e72faa07bc..3d9352d8a1a 100644 --- a/src/EnergyPlus/UnitVentilator.cc +++ b/src/EnergyPlus/UnitVentilator.cc @@ -3365,6 +3365,21 @@ namespace UnitVentilator { return GetUnitVentilatorReturnAirNode; } + int getUnitVentilatorIndex(EnergyPlusData &state, std::string_view CompName) + { + if (state.dataUnitVentilators->GetUnitVentilatorInputFlag) { + GetUnitVentilatorInput(state); + state.dataUnitVentilators->GetUnitVentilatorInputFlag = false; + } + for (int UnitVentNum = 1; UnitVentNum <= state.dataUnitVentilators->NumOfUnitVents; ++UnitVentNum) { + if (Util::SameString(state.dataUnitVentilators->UnitVent(UnitVentNum).Name, CompName)) { + return UnitVentNum; + } + } + + return 0; + } + Real64 SetOAMassFlowRateForCoolingVariablePercent(EnergyPlusData &state, int const UnitVentNum, // Unit Ventilator index Real64 const MinOAFrac, // Minimum Outside Air Fraction diff --git a/src/EnergyPlus/UnitVentilator.hh b/src/EnergyPlus/UnitVentilator.hh index 8d81cbc77c2..2dada2c6b8f 100644 --- a/src/EnergyPlus/UnitVentilator.hh +++ b/src/EnergyPlus/UnitVentilator.hh @@ -262,6 +262,8 @@ namespace UnitVentilator { int GetUnitVentilatorReturnAirNode(EnergyPlusData &state, int const UnitVentNum); + int getUnitVentilatorIndex(EnergyPlusData &state, std::string_view CompName); + Real64 SetOAMassFlowRateForCoolingVariablePercent(EnergyPlusData &state, int const UnitVentNum, // Unit Ventilator index number Real64 const MinOAFrac, // Minimum Outside Air Fraction diff --git a/src/EnergyPlus/UnitarySystem.cc b/src/EnergyPlus/UnitarySystem.cc index 29cf56ad968..c0d003c7121 100644 --- a/src/EnergyPlus/UnitarySystem.cc +++ b/src/EnergyPlus/UnitarySystem.cc @@ -16581,6 +16581,27 @@ namespace UnitarySystems { return airNode; } + int getZoneEqIndex(EnergyPlusData &state, std::string const &UnitarySysName, DataZoneEquipment::ZoneEquipType zoneEquipType, int const OAUnitNum) + { + + if (state.dataUnitarySystems->getInputOnceFlag) { + UnitarySystems::UnitarySys::getUnitarySystemInput(state, UnitarySysName, true, OAUnitNum); + state.dataUnitarySystems->getInputOnceFlag = false; + } + + for (int UnitarySysNum = 0; UnitarySysNum < state.dataUnitarySystems->numUnitarySystems; ++UnitarySysNum) { + if (Util::SameString(UnitarySysName, state.dataUnitarySystems->unitarySys[UnitarySysNum].Name)) { + if (zoneEquipType == DataZoneEquipment::ZoneEquipType::PackagedTerminalAirConditioner || + zoneEquipType == DataZoneEquipment::ZoneEquipType::PackagedTerminalHeatPump || + zoneEquipType == DataZoneEquipment::ZoneEquipType::PackagedTerminalHeatPumpWaterToAir || + zoneEquipType == DataZoneEquipment::ZoneEquipType::UnitarySystem) { + return UnitarySysNum; + } + } + } + return -1; + } + int UnitarySys::getAirOutNode(EnergyPlusData &state, std::string_view UnitarySysName, int const ZoneOAUnitNum, bool &errFlag) { if (state.dataUnitarySystems->getInputOnceFlag) { diff --git a/src/EnergyPlus/UnitarySystem.hh b/src/EnergyPlus/UnitarySystem.hh index 298d986a33b..287bd57cac3 100644 --- a/src/EnergyPlus/UnitarySystem.hh +++ b/src/EnergyPlus/UnitarySystem.hh @@ -966,6 +966,9 @@ namespace UnitarySystems { void setupAllOutputVars(EnergyPlusData &state, int const numAllSystemTypes); void isWaterCoilHeatRecoveryType(EnergyPlusData const &state, int const waterCoilNodeNum, bool &nodeNotFound); + int + getZoneEqIndex(EnergyPlusData &state, std::string const &UnitarySysName, DataZoneEquipment::ZoneEquipType zoneEquipType, int const OAUnitNum = 0); + } // namespace UnitarySystems struct UnitarySystemsData : BaseGlobalStruct { diff --git a/src/EnergyPlus/VentilatedSlab.cc b/src/EnergyPlus/VentilatedSlab.cc index b190ddafc75..396d604b928 100644 --- a/src/EnergyPlus/VentilatedSlab.cc +++ b/src/EnergyPlus/VentilatedSlab.cc @@ -4762,6 +4762,21 @@ namespace VentilatedSlab { } } + int getVentilatedSlabIndex(EnergyPlusData &state, std::string_view CompName) + { + if (state.dataVentilatedSlab->GetInputFlag) { + GetVentilatedSlabInput(state); + state.dataVentilatedSlab->GetInputFlag = false; + } + + for (int VentSlabNum = 1; VentSlabNum <= state.dataVentilatedSlab->NumOfVentSlabs; ++VentSlabNum) { + if (Util::SameString(state.dataVentilatedSlab->VentSlab(VentSlabNum).Name, CompName)) { + return VentSlabNum; + } + } + + return 0; + } //***************************************************************************************** } // namespace VentilatedSlab diff --git a/src/EnergyPlus/VentilatedSlab.hh b/src/EnergyPlus/VentilatedSlab.hh index 57424e337ba..7d2437567aa 100644 --- a/src/EnergyPlus/VentilatedSlab.hh +++ b/src/EnergyPlus/VentilatedSlab.hh @@ -383,6 +383,7 @@ namespace VentilatedSlab { void ReportVentilatedSlab(EnergyPlusData &state, int const Item); // Index for the ventilated slab under consideration within the derived types + int getVentilatedSlabIndex(EnergyPlusData &state, std::string_view CompName); //***************************************************************************************** } // namespace VentilatedSlab diff --git a/src/EnergyPlus/WaterThermalTanks.cc b/src/EnergyPlus/WaterThermalTanks.cc index 8c437ca73ac..797bf7b5e14 100644 --- a/src/EnergyPlus/WaterThermalTanks.cc +++ b/src/EnergyPlus/WaterThermalTanks.cc @@ -12464,4 +12464,20 @@ bool GetHeatPumpWaterHeaterNodeNumber(EnergyPlusData &state, int const NodeNumbe return HeatPumpWaterHeaterNodeException; } +int getHeatPumpWaterHeaterIndex(EnergyPlusData &state, std::string_view CompName) +{ + if (state.dataWaterThermalTanks->getWaterThermalTankInputFlag) { + GetWaterThermalTankInput(state); + state.dataWaterThermalTanks->getWaterThermalTankInputFlag = false; + } + + for (int HPNum = 1; HPNum <= state.dataWaterThermalTanks->numHeatPumpWaterHeater; ++HPNum) { + if (Util::SameString(state.dataWaterThermalTanks->HPWaterHeater(HPNum).Name, CompName)) { + return HPNum; + } + } + + return 0; +} + } // namespace EnergyPlus::WaterThermalTanks diff --git a/src/EnergyPlus/WaterThermalTanks.hh b/src/EnergyPlus/WaterThermalTanks.hh index 9ee35155385..db9657f0809 100644 --- a/src/EnergyPlus/WaterThermalTanks.hh +++ b/src/EnergyPlus/WaterThermalTanks.hh @@ -991,6 +991,8 @@ namespace WaterThermalTanks { bool GetHeatPumpWaterHeaterNodeNumber(EnergyPlusData &state, int NodeNumber); + int getHeatPumpWaterHeaterIndex(EnergyPlusData &state, std::string_view CompName); + } // namespace WaterThermalTanks struct WaterThermalTanksData : BaseGlobalStruct diff --git a/src/EnergyPlus/WindowAC.cc b/src/EnergyPlus/WindowAC.cc index 6dad593cbcc..29d26ebe298 100644 --- a/src/EnergyPlus/WindowAC.cc +++ b/src/EnergyPlus/WindowAC.cc @@ -1619,6 +1619,22 @@ namespace WindowAC { return GetWindowACMixedAirNode; } + int getWindowACIndex(EnergyPlusData &state, std::string_view CompName) + { + if (state.dataWindowAC->GetWindowACInputFlag) { + GetWindowAC(state); + state.dataWindowAC->GetWindowACInputFlag = false; + } + + for (int WindACIndex = 1; WindACIndex <= state.dataWindowAC->NumWindAC; ++WindACIndex) { + if (Util::SameString(state.dataWindowAC->WindAC(WindACIndex).Name, CompName)) { + return WindACIndex; + } + } + + return 0; + } + } // namespace WindowAC } // namespace EnergyPlus diff --git a/src/EnergyPlus/WindowAC.hh b/src/EnergyPlus/WindowAC.hh index 1520ddcf6a4..81db5207b14 100644 --- a/src/EnergyPlus/WindowAC.hh +++ b/src/EnergyPlus/WindowAC.hh @@ -205,6 +205,8 @@ namespace WindowAC { int GetWindowACMixedAirNode(EnergyPlusData &state, int const WindACNum); + int getWindowACIndex(EnergyPlusData &state, std::string_view CompName); + } // namespace WindowAC struct WindowACData : BaseGlobalStruct diff --git a/src/EnergyPlus/ZoneDehumidifier.cc b/src/EnergyPlus/ZoneDehumidifier.cc index 6b88b5b327b..95ec5aa25d2 100644 --- a/src/EnergyPlus/ZoneDehumidifier.cc +++ b/src/EnergyPlus/ZoneDehumidifier.cc @@ -1179,6 +1179,22 @@ namespace ZoneDehumidifier { return FindZoneDehumidifierNodeNumber; } + int getZoneDehumidifierIndex(EnergyPlusData &state, std::string_view CompName) + { + if (state.dataZoneDehumidifier->GetInputFlag) { + GetZoneDehumidifierInput(state); + state.dataZoneDehumidifier->GetInputFlag = false; + } + + for (int ZoneDehumidNum = 1; ZoneDehumidNum <= (int)state.dataZoneDehumidifier->ZoneDehumid.size(); ++ZoneDehumidNum) { + if (Util::SameString(state.dataZoneDehumidifier->ZoneDehumid(ZoneDehumidNum).Name, CompName)) { + return ZoneDehumidNum; + } + } + + return 0; + } + } // namespace ZoneDehumidifier } // namespace EnergyPlus diff --git a/src/EnergyPlus/ZoneDehumidifier.hh b/src/EnergyPlus/ZoneDehumidifier.hh index 5bde9abd93a..1e62add786d 100644 --- a/src/EnergyPlus/ZoneDehumidifier.hh +++ b/src/EnergyPlus/ZoneDehumidifier.hh @@ -153,6 +153,8 @@ namespace ZoneDehumidifier { bool GetZoneDehumidifierNodeNumber(EnergyPlusData &state, int NodeNumber); // Node being tested + int getZoneDehumidifierIndex(EnergyPlusData &state, std::string_view CompName); + } // namespace ZoneDehumidifier struct ZoneDehumidifierData : BaseGlobalStruct diff --git a/tst/EnergyPlus/unit/RoomAirflowNetwork.unit.cc b/tst/EnergyPlus/unit/RoomAirflowNetwork.unit.cc index a7bf1ae3cc5..7522f82eb6a 100644 --- a/tst/EnergyPlus/unit/RoomAirflowNetwork.unit.cc +++ b/tst/EnergyPlus/unit/RoomAirflowNetwork.unit.cc @@ -53,6 +53,7 @@ // EnergyPlus Headers #include "Fixtures/EnergyPlusFixture.hh" #include +#include #include #include #include @@ -67,15 +68,37 @@ #include #include #include +#include +#include +#include +#include +#include +#include #include +#include +#include #include #include +#include +#include +#include +#include #include +#include #include #include +#include #include #include +#include +#include +#include +#include +#include +#include +#include #include +#include #include #include @@ -580,3 +603,232 @@ TEST_F(EnergyPlusFixture, RoomAirInternalGains_InternalHeatGains_Check) EXPECT_TRUE(compare_err_stream(error_string, true)); } + +TEST_F(EnergyPlusFixture, RoomAirflowNetwork_CheckEquipName_Test) +{ + // Test #6321 + bool check; + std::string const EquipName = "ZoneEquip"; + std::string SupplyNodeName; + std::string ReturnNodeName; + int TotNumEquip = 1; + int EquipIndex = 1; // Equipment index + DataZoneEquipment::ZoneEquipType zoneEquipType; + + state->dataLoopNodes->NodeID.allocate(2); + state->dataLoopNodes->Node.allocate(2); + state->dataLoopNodes->NodeID(1) = "SupplyNode"; + state->dataLoopNodes->NodeID(2) = "ReturnNode"; + + state->dataHVACVarRefFlow->GetVRFInputFlag = false; + state->dataHVACVarRefFlow->VRFTU.allocate(1); + state->dataHVACVarRefFlow->VRFTU(1).VRFTUOutletNodeNum = 1; + + zoneEquipType = DataZoneEquipment::ZoneEquipType::VariableRefrigerantFlowTerminal; + state->dataHVACVarRefFlow->NumVRFTU = 1; + state->dataHVACVarRefFlow->VRFTU(1).Name = EquipName; + check = CheckEquipName(*state, EquipName, SupplyNodeName, ReturnNodeName, zoneEquipType); + EXPECT_TRUE(check); + EXPECT_EQ("SupplyNode", SupplyNodeName); + + state->dataLoopNodes->NodeID(1) = "SupplyNode1"; + state->dataLoopNodes->NodeID(2) = "ReturnNode1"; + zoneEquipType = DataZoneEquipment::ZoneEquipType::EnergyRecoveryVentilator; + state->dataHVACStandAloneERV->GetERVInputFlag = false; + state->dataHVACStandAloneERV->StandAloneERV.allocate(1); + state->dataHVACStandAloneERV->NumStandAloneERVs = 1; + state->dataHVACStandAloneERV->StandAloneERV(1).SupplyAirInletNode = 1; + state->dataHVACStandAloneERV->StandAloneERV(1).Name = EquipName; + check = CheckEquipName(*state, EquipName, SupplyNodeName, ReturnNodeName, zoneEquipType); + EXPECT_TRUE(check); + EXPECT_EQ("SupplyNode1", SupplyNodeName); + + state->dataLoopNodes->NodeID(1) = "SupplyNode2"; + state->dataLoopNodes->NodeID(2) = "ReturnNode2"; + zoneEquipType = DataZoneEquipment::ZoneEquipType::FourPipeFanCoil; + state->dataFanCoilUnits->FanCoil.allocate(1); + state->dataFanCoilUnits->FanCoil(EquipIndex).AirOutNode = 1; + state->dataFanCoilUnits->FanCoil(EquipIndex).AirInNode = 2; + state->dataFanCoilUnits->NumFanCoils = 1; + state->dataFanCoilUnits->GetFanCoilInputFlag = false; + state->dataFanCoilUnits->FanCoil(EquipIndex).Name = EquipName; + check = CheckEquipName(*state, EquipName, SupplyNodeName, ReturnNodeName, zoneEquipType); + EXPECT_TRUE(check); + EXPECT_EQ("SupplyNode2", SupplyNodeName); + EXPECT_EQ("ReturnNode2", ReturnNodeName); + + state->dataLoopNodes->NodeID(1) = "SupplyNode3"; + state->dataLoopNodes->NodeID(2) = "ReturnNode3"; + zoneEquipType = DataZoneEquipment::ZoneEquipType::OutdoorAirUnit; + state->dataOutdoorAirUnit->OutAirUnit.allocate(1); + state->dataOutdoorAirUnit->OutAirUnit(EquipIndex).AirOutletNode = 1; + state->dataOutdoorAirUnit->OutAirUnit(EquipIndex).AirInletNode = 2; + state->dataOutdoorAirUnit->NumOfOAUnits = 1; + state->dataOutdoorAirUnit->GetOutdoorAirUnitInputFlag = false; + state->dataOutdoorAirUnit->OutAirUnit(EquipIndex).Name = EquipName; + check = CheckEquipName(*state, EquipName, SupplyNodeName, ReturnNodeName, zoneEquipType); + EXPECT_TRUE(check); + EXPECT_EQ("SupplyNode3", SupplyNodeName); + EXPECT_EQ("ReturnNode3", ReturnNodeName); + + state->dataLoopNodes->NodeID(1) = "SupplyNode4"; + state->dataLoopNodes->NodeID(2) = "ReturnNode4"; + zoneEquipType = DataZoneEquipment::ZoneEquipType::PackagedTerminalAirConditioner; + UnitarySystems::UnitarySys thisUnit; + state->dataUnitarySystems->unitarySys.push_back(thisUnit); + state->dataUnitarySystems->getInputOnceFlag = false; + state->dataUnitarySystems->unitarySys[EquipIndex - 1].Name = EquipName; + state->dataUnitarySystems->numUnitarySystems = 1; + state->dataUnitarySystems->unitarySys[EquipIndex - 1].AirOutNode = 1; + state->dataUnitarySystems->unitarySys[EquipIndex - 1].AirInNode = 2; + check = CheckEquipName(*state, EquipName, SupplyNodeName, ReturnNodeName, zoneEquipType); + EXPECT_TRUE(check); + EXPECT_EQ("SupplyNode4", SupplyNodeName); + EXPECT_EQ("ReturnNode4", ReturnNodeName); + + state->dataLoopNodes->NodeID(1) = "SupplyNode5"; + state->dataLoopNodes->NodeID(2) = "ReturnNode5"; + zoneEquipType = DataZoneEquipment::ZoneEquipType::PackagedTerminalHeatPump; + // UnitarySystems::UnitarySys thisUnit; + // state->dataUnitarySystems->unitarySys.push_back(thisUnit); + state->dataUnitarySystems->getInputOnceFlag = false; + state->dataUnitarySystems->unitarySys[EquipIndex - 1].Name = EquipName; + state->dataUnitarySystems->numUnitarySystems = 1; + state->dataUnitarySystems->unitarySys[EquipIndex - 1].AirOutNode = 1; + state->dataUnitarySystems->unitarySys[EquipIndex - 1].AirInNode = 2; + check = CheckEquipName(*state, EquipName, SupplyNodeName, ReturnNodeName, zoneEquipType); + EXPECT_TRUE(check); + EXPECT_EQ("SupplyNode5", SupplyNodeName); + EXPECT_EQ("ReturnNode5", ReturnNodeName); + + state->dataLoopNodes->NodeID(1) = "SupplyNode6"; + state->dataLoopNodes->NodeID(2) = "ReturnNode6"; + zoneEquipType = DataZoneEquipment::ZoneEquipType::PackagedTerminalHeatPumpWaterToAir; + // UnitarySystems::UnitarySys thisUnit; + // state->dataUnitarySystems->unitarySys.push_back(thisUnit); + state->dataUnitarySystems->getInputOnceFlag = false; + state->dataUnitarySystems->unitarySys[EquipIndex - 1].Name = EquipName; + state->dataUnitarySystems->numUnitarySystems = 1; + state->dataUnitarySystems->unitarySys[EquipIndex - 1].AirOutNode = 1; + state->dataUnitarySystems->unitarySys[EquipIndex - 1].AirInNode = 2; + check = CheckEquipName(*state, EquipName, SupplyNodeName, ReturnNodeName, zoneEquipType); + EXPECT_TRUE(check); + EXPECT_EQ("SupplyNode6", SupplyNodeName); + EXPECT_EQ("ReturnNode6", ReturnNodeName); + + state->dataLoopNodes->NodeID(1) = "SupplyNode7"; + state->dataLoopNodes->NodeID(2) = "ReturnNode7"; + zoneEquipType = DataZoneEquipment::ZoneEquipType::UnitHeater; + state->dataUnitHeaters->UnitHeat.allocate(1); + state->dataUnitHeaters->UnitHeat(EquipIndex).AirOutNode = 1; + state->dataUnitHeaters->UnitHeat(EquipIndex).AirInNode = 2; + state->dataUnitHeaters->NumOfUnitHeats = 1; + state->dataUnitHeaters->GetUnitHeaterInputFlag = false; + state->dataUnitHeaters->UnitHeat(EquipIndex).Name = EquipName; + check = CheckEquipName(*state, EquipName, SupplyNodeName, ReturnNodeName, zoneEquipType); + EXPECT_TRUE(check); + EXPECT_EQ("SupplyNode7", SupplyNodeName); + EXPECT_EQ("ReturnNode7", ReturnNodeName); + + state->dataLoopNodes->NodeID(1) = "SupplyNode8"; + state->dataLoopNodes->NodeID(2) = "ReturnNode8"; + zoneEquipType = DataZoneEquipment::ZoneEquipType::UnitVentilator; + state->dataUnitVentilators->UnitVent.allocate(1); + state->dataUnitVentilators->UnitVent(EquipIndex).AirOutNode = 1; + state->dataUnitVentilators->UnitVent(EquipIndex).AirInNode = 2; + state->dataUnitVentilators->NumOfUnitVents = 1; + state->dataUnitVentilators->UnitVent(EquipIndex).Name = EquipName; + state->dataUnitVentilators->GetUnitVentilatorInputFlag = false; + check = CheckEquipName(*state, EquipName, SupplyNodeName, ReturnNodeName, zoneEquipType); + EXPECT_TRUE(check); + EXPECT_EQ("SupplyNode8", SupplyNodeName); + EXPECT_EQ("ReturnNode8", ReturnNodeName); + + state->dataLoopNodes->NodeID(1) = "SupplyNode9"; + state->dataLoopNodes->NodeID(2) = "ReturnNode9"; + zoneEquipType = DataZoneEquipment::ZoneEquipType::VentilatedSlab; + state->dataVentilatedSlab->VentSlab.allocate(1); + state->dataVentilatedSlab->VentSlab(EquipIndex).ZoneAirInNode = 1; + state->dataVentilatedSlab->VentSlab(EquipIndex).ReturnAirNode = 2; + state->dataVentilatedSlab->NumOfVentSlabs = 1; + state->dataVentilatedSlab->GetInputFlag = false; + state->dataVentilatedSlab->VentSlab(EquipIndex).Name = EquipName; + check = CheckEquipName(*state, EquipName, SupplyNodeName, ReturnNodeName, zoneEquipType); + EXPECT_TRUE(check); + EXPECT_EQ("SupplyNode9", SupplyNodeName); + EXPECT_EQ("ReturnNode9", ReturnNodeName); + + state->dataLoopNodes->NodeID(1) = "SupplyNode10"; + state->dataLoopNodes->NodeID(2) = "ReturnNode10"; + zoneEquipType = DataZoneEquipment::ZoneEquipType::WindowAirConditioner; + state->dataWindowAC->WindAC.allocate(1); + state->dataWindowAC->WindAC(EquipIndex).AirOutNode = 1; + state->dataWindowAC->WindAC(EquipIndex).AirInNode = 2; + state->dataWindowAC->WindAC(EquipIndex).OAMixIndex = 1; + state->dataWindowAC->NumWindAC = 1; + state->dataWindowAC->GetWindowACInputFlag = false; + state->dataMixedAir->NumOAMixers = 1; + state->dataMixedAir->OAMixer.allocate(1); + state->dataMixedAir->OAMixer(1).RetNode = 2; + state->dataWindowAC->WindAC(EquipIndex).Name = EquipName; + state->dataMixedAir->GetOAMixerInputFlag = false; + check = CheckEquipName(*state, EquipName, SupplyNodeName, ReturnNodeName, zoneEquipType); + EXPECT_TRUE(check); + EXPECT_EQ("SupplyNode10", SupplyNodeName); + EXPECT_EQ("ReturnNode10", ReturnNodeName); + + state->dataLoopNodes->NodeID(1) = "SupplyNode11"; + state->dataLoopNodes->NodeID(2) = "ReturnNode11"; + zoneEquipType = DataZoneEquipment::ZoneEquipType::DehumidifierDX; + state->dataZoneDehumidifier->ZoneDehumid.allocate(1); + state->dataZoneDehumidifier->ZoneDehumid(EquipIndex).AirOutletNodeNum = 1; + state->dataZoneDehumidifier->ZoneDehumid(EquipIndex).AirInletNodeNum = 2; + state->dataZoneDehumidifier->ZoneDehumid(EquipIndex).Name = EquipName; + state->dataZoneDehumidifier->GetInputFlag = false; + check = CheckEquipName(*state, EquipName, SupplyNodeName, ReturnNodeName, zoneEquipType); + EXPECT_TRUE(check); + EXPECT_EQ("SupplyNode11", SupplyNodeName); + EXPECT_EQ("ReturnNode11", ReturnNodeName); + + state->dataLoopNodes->NodeID(1) = "SupplyNode12"; + state->dataLoopNodes->NodeID(2) = "ReturnNode12"; + zoneEquipType = DataZoneEquipment::ZoneEquipType::PurchasedAir; + state->dataPurchasedAirMgr->PurchAir.allocate(1); + state->dataPurchasedAirMgr->PurchAir(EquipIndex).ZoneSupplyAirNodeNum = 1; + state->dataPurchasedAirMgr->PurchAir(EquipIndex).ZoneExhaustAirNodeNum = 2; + state->dataPurchasedAirMgr->NumPurchAir = 1; + state->dataPurchasedAirMgr->PurchAir(EquipIndex).Name = EquipName; + state->dataPurchasedAirMgr->GetPurchAirInputFlag = false; + check = CheckEquipName(*state, EquipName, SupplyNodeName, ReturnNodeName, zoneEquipType); + EXPECT_TRUE(check); + EXPECT_EQ("SupplyNode12", SupplyNodeName); + EXPECT_EQ("ReturnNode12", ReturnNodeName); + + state->dataLoopNodes->NodeID(1) = "SupplyNode13"; + state->dataLoopNodes->NodeID(2) = "ReturnNode13"; + zoneEquipType = DataZoneEquipment::ZoneEquipType::PurchasedAir; + state->dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner.allocate(1); + state->dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(EquipIndex).OutletNode = 1; + state->dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(EquipIndex).InletNode = 2; + state->dataHybridUnitaryAC->NumZoneHybridEvap = 1; + state->dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(EquipIndex).Name = EquipName; + state->dataHybridUnitaryAC->GetInputZoneHybridEvap = false; + check = CheckEquipName(*state, EquipName, SupplyNodeName, ReturnNodeName, zoneEquipType); + EXPECT_TRUE(check); + EXPECT_EQ("SupplyNode13", SupplyNodeName); + EXPECT_EQ("ReturnNode13", ReturnNodeName); + + state->dataLoopNodes->NodeID(1) = "SupplyNode14"; + state->dataLoopNodes->NodeID(2) = "ReturnNode14"; + zoneEquipType = DataZoneEquipment::ZoneEquipType::PurchasedAir; + state->dataWaterThermalTanks->HPWaterHeater.allocate(1); + state->dataWaterThermalTanks->HPWaterHeater(EquipIndex).HeatPumpAirOutletNode = 1; + state->dataWaterThermalTanks->HPWaterHeater(EquipIndex).HeatPumpAirInletNode = 2; + state->dataWaterThermalTanks->numHeatPumpWaterHeater = 1; + state->dataWaterThermalTanks->HPWaterHeater(EquipIndex).Name = EquipName; + state->dataWaterThermalTanks->getWaterThermalTankInputFlag = false; + check = CheckEquipName(*state, EquipName, SupplyNodeName, ReturnNodeName, zoneEquipType); + EXPECT_TRUE(check); + EXPECT_EQ("SupplyNode14", SupplyNodeName); + EXPECT_EQ("ReturnNode14", ReturnNodeName); +}