diff --git a/src/EnergyPlus/AirLoopHVACDOAS.cc b/src/EnergyPlus/AirLoopHVACDOAS.cc index a840d9000bb..81691eb8e37 100644 --- a/src/EnergyPlus/AirLoopHVACDOAS.cc +++ b/src/EnergyPlus/AirLoopHVACDOAS.cc @@ -915,7 +915,7 @@ namespace AirLoopHVACDOAS { if (Util::SameString(CompType, "COIL:HEATING:WATER")) { WaterCoils::SimulateWaterCoilComponents(state, CompName, FirstHVACIteration, this->m_HeatCoilNum); Real64 const CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", CompName, ErrorsFound); - rho = state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + rho = this->HWPlantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); PlantUtilities::InitComponentNodes(state, 0.0, CoilMaxVolFlowRate * rho, @@ -925,7 +925,7 @@ namespace AirLoopHVACDOAS { if (Util::SameString(CompType, "COIL:COOLING:WATER")) { WaterCoils::SimulateWaterCoilComponents(state, CompName, FirstHVACIteration, this->m_CoolCoilNum); Real64 const CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Cooling:Water", CompName, ErrorsFound); - rho = state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); + rho = this->CWPlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); PlantUtilities::InitComponentNodes(state, 0.0, CoilMaxVolFlowRate * rho, @@ -936,7 +936,7 @@ namespace AirLoopHVACDOAS { WaterCoils::SimulateWaterCoilComponents(state, CompName, FirstHVACIteration, this->m_CoolCoilNum); Real64 const CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Cooling:Water:DetailedGeometry", CompName, ErrorsFound); - rho = state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); + rho = this->CWPlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); PlantUtilities::InitComponentNodes(state, 0.0, CoilMaxVolFlowRate * rho, diff --git a/src/EnergyPlus/Boilers.cc b/src/EnergyPlus/Boilers.cc index d52034a1394..156c7f97f4d 100644 --- a/src/EnergyPlus/Boilers.cc +++ b/src/EnergyPlus/Boilers.cc @@ -491,7 +491,7 @@ void BoilerSpecs::oneTimeInit(EnergyPlusData &state) void BoilerSpecs::initEachEnvironment(EnergyPlusData &state) { static constexpr std::string_view RoutineName("BoilerSpecs::initEachEnvironment"); - Real64 const rho = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + Real64 const rho = this->plantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); this->DesMassFlowRate = this->VolFlowRate * rho; PlantUtilities::InitComponentNodes(state, 0.0, this->DesMassFlowRate, this->BoilerInletNodeNum, this->BoilerOutletNodeNum); @@ -604,8 +604,8 @@ void BoilerSpecs::SizeBoiler(EnergyPlusData &state) if (PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 const rho = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); - Real64 const Cp = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getSpecificHeat(state, Constant::HWInitConvTemp, RoutineName); + Real64 const rho = this->plantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + Real64 const Cp = this->plantLoc.loop->glycol->getSpecificHeat(state, Constant::HWInitConvTemp, RoutineName); tmpNomCap = Cp * rho * this->SizFac * state.dataSize->PlantSizData(PltSizNum).DeltaT * state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate; } else { @@ -791,8 +791,7 @@ void BoilerSpecs::CalcBoilerModel(EnergyPlusData &state, Real64 const TempUpLimitBout = this->TempUpLimitBoilerOut; // C - boiler high temperature limit Real64 const BoilerMassFlowRateMax = this->DesMassFlowRate; // Max Design Boiler Mass Flow Rate converted from Volume Flow Rate - Real64 Cp = state.dataPlnt->PlantLoop(this->plantLoc.loopNum) - .glycol->getSpecificHeat(state, state.dataLoopNodes->Node(BoilerInletNode).Temp, RoutineName); + Real64 Cp = this->plantLoc.loop->glycol->getSpecificHeat(state, state.dataLoopNodes->Node(BoilerInletNode).Temp, RoutineName); // If the specified load is 0.0 or the boiler should not run then we leave this subroutine. Before leaving // if the component control is SERIESACTIVE we set the component flow to inlet flow so that flow resolver diff --git a/src/EnergyPlus/CTElectricGenerator.cc b/src/EnergyPlus/CTElectricGenerator.cc index 4bca3070ef2..6e030e84420 100644 --- a/src/EnergyPlus/CTElectricGenerator.cc +++ b/src/EnergyPlus/CTElectricGenerator.cc @@ -548,7 +548,7 @@ namespace CTElectricGenerator { int heatRecInNode = this->HeatRecInletNodeNum; heatRecInTemp = state.dataLoopNodes->Node(heatRecInNode).Temp; - heatRecCp = state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).glycol->getSpecificHeat(state, heatRecInTemp, RoutineName); + heatRecCp = this->HRPlantLoc.loop->glycol->getSpecificHeat(state, heatRecInTemp, RoutineName); if (FirstHVACIteration && RunFlag) { heatRecMdot = this->DesignHeatRecMassFlowRate; } else { @@ -800,7 +800,7 @@ namespace CTElectricGenerator { int HeatRecOutletNode = this->HeatRecOutletNodeNum; // size mass flow rate - Real64 rho = state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, RoutineName); + Real64 rho = this->HRPlantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, RoutineName); this->DesignHeatRecMassFlowRate = rho * this->DesignHeatRecVolFlowRate; diff --git a/src/EnergyPlus/ChillerAbsorption.cc b/src/EnergyPlus/ChillerAbsorption.cc index a8bbebc56f3..8454150ceb5 100644 --- a/src/EnergyPlus/ChillerAbsorption.cc +++ b/src/EnergyPlus/ChillerAbsorption.cc @@ -754,13 +754,13 @@ void BLASTAbsorberSpecs::initEachEnvironment(EnergyPlusData &state) { constexpr std::string_view RoutineName("BLASTAbsorberSpecs::initEachEnvironment"); - Real64 rho = state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); + Real64 rho = this->CWPlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); this->EvapMassFlowRateMax = this->EvapVolFlowRate * rho; PlantUtilities::InitComponentNodes(state, 0.0, this->EvapMassFlowRateMax, this->EvapInletNodeNum, this->EvapOutletNodeNum); - rho = state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); + rho = this->CDPlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); this->CondMassFlowRateMax = rho * this->CondVolFlowRate; @@ -770,7 +770,7 @@ void BLASTAbsorberSpecs::initEachEnvironment(EnergyPlusData &state) if (this->GeneratorInletNodeNum > 0) { if (this->GenHeatSourceType == DataLoopNode::NodeFluidType::Water) { - rho = state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + rho = this->GenPlantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); this->GenMassFlowRateMax = rho * this->GeneratorVolFlowRate; } else if (this->GenHeatSourceType == DataLoopNode::NodeFluidType::Steam) { @@ -929,9 +929,9 @@ void BLASTAbsorberSpecs::sizeChiller(EnergyPlusData &state) if (PltSizNum > 0) { if (state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 Cp = state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).glycol->getSpecificHeat(state, Constant::CWInitConvTemp, RoutineName); + Real64 Cp = this->CWPlantLoc.loop->glycol->getSpecificHeat(state, Constant::CWInitConvTemp, RoutineName); - Real64 rho = state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); + Real64 rho = this->CWPlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); tmpNomCap = Cp * rho * state.dataSize->PlantSizData(PltSizNum).DeltaT * state.dataSize->PlantSizData(PltSizNum).DesVolFlowRate * this->SizFac; if (!this->NomCapWasAutoSized) { @@ -1097,9 +1097,9 @@ void BLASTAbsorberSpecs::sizeChiller(EnergyPlusData &state) if (this->EvapVolFlowRate >= HVAC::SmallWaterVolFlow && tmpNomCap > 0.0) { // QCondenser = QEvaporator + QGenerator + PumpingPower - Real64 Cp = state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).glycol->getSpecificHeat(state, this->TempDesCondIn, RoutineName); + Real64 Cp = this->CDPlantLoc.loop->glycol->getSpecificHeat(state, this->TempDesCondIn, RoutineName); - Real64 rho = state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); + Real64 rho = this->CDPlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); tmpCondVolFlowRate = tmpNomCap * (1.0 + SteamInputRatNom + tmpNomPumpPower / tmpNomCap) / (state.dataSize->PlantSizData(PltSizCondNum).DeltaT * Cp * rho); if (!this->CondVolFlowRateWasAutoSized) { @@ -1171,12 +1171,11 @@ void BLASTAbsorberSpecs::sizeChiller(EnergyPlusData &state) (PltSizHeatingNum > 0 && this->GenHeatSourceType == DataLoopNode::NodeFluidType::Water)) { if (this->EvapVolFlowRate >= HVAC::SmallWaterVolFlow && tmpNomCap > 0.0) { if (this->GenHeatSourceType == DataLoopNode::NodeFluidType::Water) { - Real64 CpWater = state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum) - .glycol->getSpecificHeat(state, state.dataSize->PlantSizData(PltSizHeatingNum).ExitTemp, RoutineName); + Real64 CpWater = + this->GenPlantLoc.loop->glycol->getSpecificHeat(state, state.dataSize->PlantSizData(PltSizHeatingNum).ExitTemp, RoutineName); Real64 SteamDeltaT = max(0.5, state.dataSize->PlantSizData(PltSizHeatingNum).DeltaT); - Real64 RhoWater = - state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum) - .glycol->getDensity(state, (state.dataSize->PlantSizData(PltSizHeatingNum).ExitTemp - SteamDeltaT), RoutineName); + Real64 RhoWater = this->GenPlantLoc.loop->glycol->getDensity( + state, (state.dataSize->PlantSizData(PltSizHeatingNum).ExitTemp - SteamDeltaT), RoutineName); tmpGeneratorVolFlowRate = (this->NomCap * SteamInputRatNom) / (CpWater * SteamDeltaT * RhoWater); if (!this->GeneratorVolFlowRateWasAutoSized) { tmpGeneratorVolFlowRate = this->GeneratorVolFlowRate; @@ -1328,9 +1327,8 @@ void BLASTAbsorberSpecs::sizeChiller(EnergyPlusData &state) this->GeneratorDeltaTemp = max(0.5, state.dataSize->PlantSizData(PltSizHeatingNum).DeltaT); } else if (this->GenHeatSourceType == DataLoopNode::NodeFluidType::Water) { if (state.dataPlnt->PlantFirstSizesOkayToFinalize) { - Real64 Cp = - state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).glycol->getSpecificHeat(state, Constant::HWInitConvTemp, RoutineName); - Real64 rho = state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + Real64 Cp = this->GenPlantLoc.loop->glycol->getSpecificHeat(state, Constant::HWInitConvTemp, RoutineName); + Real64 rho = this->GenPlantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); this->GeneratorDeltaTemp = (SteamInputRatNom * this->NomCap) / (Cp * rho * this->GeneratorVolFlowRate); } @@ -1441,8 +1439,7 @@ void BLASTAbsorberSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, bool R Real64 TempEvapOut = state.dataLoopNodes->Node(this->EvapOutletNodeNum).Temp; - Real64 CpFluid = state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum) - .glycol->getSpecificHeat(state, state.dataLoopNodes->Node(this->EvapInletNodeNum).Temp, RoutineName); + Real64 CpFluid = this->CWPlantLoc.loop->glycol->getSpecificHeat(state, state.dataLoopNodes->Node(this->EvapInletNodeNum).Temp, RoutineName); // If there is a fault of Chiller SWT Sensor if (this->FaultyChillerSWTFlag && (!state.dataGlobal->WarmupFlag) && (!state.dataGlobal->DoingSizing) && (!state.dataGlobal->KickOffSimulation)) { @@ -1670,8 +1667,7 @@ void BLASTAbsorberSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, bool R this->QCondenser = this->QEvaporator + this->QGenerator + this->PumpingPower; - CpFluid = state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum) - .glycol->getSpecificHeat(state, state.dataLoopNodes->Node(this->CondInletNodeNum).Temp, RoutineName); + CpFluid = this->CDPlantLoc.loop->glycol->getSpecificHeat(state, state.dataLoopNodes->Node(this->CondInletNodeNum).Temp, RoutineName); if (this->CondMassFlowRate > DataBranchAirLoopPlant::MassFlowTolerance) { this->CondOutletTemp = this->QCondenser / this->CondMassFlowRate / CpFluid + state.dataLoopNodes->Node(this->CondInletNodeNum).Temp; @@ -1691,8 +1687,8 @@ void BLASTAbsorberSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad, bool R if (this->GenHeatSourceType == DataLoopNode::NodeFluidType::Water) { Real64 GenMassFlowRate = 0.0; // Hot water plant is used for the generator - CpFluid = state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum) - .glycol->getSpecificHeat(state, state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Temp, RoutineName); + CpFluid = + this->GenPlantLoc.loop->glycol->getSpecificHeat(state, state.dataLoopNodes->Node(this->GeneratorInletNodeNum).Temp, RoutineName); if (state.dataPlnt->PlantLoop(this->GenPlantLoc.loopNum).LoopSide(this->GenPlantLoc.loopSideNum).FlowLock == DataPlant::FlowLock::Unlocked) { if ((this->FlowMode == DataPlant::FlowMode::Constant) || (this->FlowMode == DataPlant::FlowMode::NotModulated)) { diff --git a/src/EnergyPlus/ChillerExhaustAbsorption.cc b/src/EnergyPlus/ChillerExhaustAbsorption.cc index 0cccbf00ef7..c4c88b81224 100644 --- a/src/EnergyPlus/ChillerExhaustAbsorption.cc +++ b/src/EnergyPlus/ChillerExhaustAbsorption.cc @@ -995,7 +995,7 @@ void ExhaustAbsorberSpecs::initialize(EnergyPlusData &state) if (this->isWaterCooled) { // init max available condenser water flow rate if (this->CDPlantLoc.loopNum > 0) { - rho = state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); + rho = this->CDPlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); } else { rho = Psychrometrics::RhoH2O(Constant::InitConvTemp); } @@ -1005,7 +1005,7 @@ void ExhaustAbsorberSpecs::initialize(EnergyPlusData &state) } if (this->HWPlantLoc.loopNum > 0) { - rho = state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + rho = this->HWPlantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); } else { rho = Psychrometrics::RhoH2O(Constant::InitConvTemp); } @@ -1014,7 +1014,7 @@ void ExhaustAbsorberSpecs::initialize(EnergyPlusData &state) PlantUtilities::InitComponentNodes(state, 0.0, this->DesHeatMassFlowRate, HeatInletNode, HeatOutletNode); if (this->CWPlantLoc.loopNum > 0) { - rho = state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); + rho = this->CWPlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); } else { rho = Psychrometrics::RhoH2O(Constant::InitConvTemp); } @@ -1102,8 +1102,8 @@ void ExhaustAbsorberSpecs::size(EnergyPlusData &state) if (PltSizCoolNum > 0) { if (state.dataSize->PlantSizData(PltSizCoolNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Cp = state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).glycol->getSpecificHeat(state, Constant::CWInitConvTemp, RoutineName); - rho = state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); + Cp = this->CWPlantLoc.loop->glycol->getSpecificHeat(state, Constant::CWInitConvTemp, RoutineName); + rho = this->CWPlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); tmpNomCap = Cp * rho * state.dataSize->PlantSizData(PltSizCoolNum).DeltaT * state.dataSize->PlantSizData(PltSizCoolNum).DesVolFlowRate * this->SizFac; if (!this->NomCoolingCapWasAutoSized) { @@ -1336,8 +1336,8 @@ void ExhaustAbsorberSpecs::size(EnergyPlusData &state) if (PltSizCondNum > 0 && PltSizCoolNum > 0) { if (state.dataSize->PlantSizData(PltSizCoolNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow && tmpNomCap > 0.0) { - Cp = state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).glycol->getSpecificHeat(state, this->TempDesCondReturn, RoutineName); - rho = state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).glycol->getDensity(state, this->TempDesCondReturn, RoutineName); + Cp = this->CDPlantLoc.loop->glycol->getSpecificHeat(state, this->TempDesCondReturn, RoutineName); + rho = this->CDPlantLoc.loop->glycol->getDensity(state, this->TempDesCondReturn, RoutineName); tmpCondVolFlowRate = tmpNomCap * (1.0 + this->ThermalEnergyCoolRatio) / (state.dataSize->PlantSizData(PltSizCondNum).DeltaT * Cp * rho); if (!this->CondVolFlowRateWasAutoSized) { tmpCondVolFlowRate = this->CondVolFlowRate; @@ -1575,9 +1575,9 @@ void ExhaustAbsorberSpecs::calcChiller(EnergyPlusData &state, Real64 &MyLoad) Real64 lExhaustInFlow = state.dataLoopNodes->Node(lExhaustAirInletNodeNum).MassFlowRate; Real64 lExhaustAirHumRat = state.dataLoopNodes->Node(lExhaustAirInletNodeNum).HumRat; - Real64 Cp_CW = state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).glycol->getSpecificHeat(state, lChillReturnTemp, RoutineName); + Real64 Cp_CW = this->CWPlantLoc.loop->glycol->getSpecificHeat(state, lChillReturnTemp, RoutineName); if (this->CDPlantLoc.loopNum > 0) { - Cp_CD = state.dataPlnt->PlantLoop(this->CDPlantLoc.loopNum).glycol->getSpecificHeat(state, lChillReturnTemp, RoutineName); + Cp_CD = this->CDPlantLoc.loop->glycol->getSpecificHeat(state, lChillReturnTemp, RoutineName); } // If no loop demand or Absorber OFF, return diff --git a/src/EnergyPlus/DesiccantDehumidifiers.cc b/src/EnergyPlus/DesiccantDehumidifiers.cc index c28a774770b..3a42514244b 100644 --- a/src/EnergyPlus/DesiccantDehumidifiers.cc +++ b/src/EnergyPlus/DesiccantDehumidifiers.cc @@ -1653,8 +1653,7 @@ namespace DesiccantDehumidifiers { desicDehum.MaxCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", desicDehum.RegenCoilName, ErrorFlag); if (desicDehum.MaxCoilFluidFlow > 0.0) { - Real64 FluidDensity = - state.dataPlnt->PlantLoop(desicDehum.plantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, initCBVAV); + Real64 FluidDensity = desicDehum.plantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, initCBVAV); desicDehum.MaxCoilFluidFlow *= FluidDensity; } @@ -1764,8 +1763,7 @@ namespace DesiccantDehumidifiers { // ErrorsFound = true; //} if (CoilMaxVolFlowRate != DataSizing::AutoSize) { - Real64 FluidDensity = state.dataPlnt->PlantLoop(desicDehum.plantLoc.loopNum) - .glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + Real64 FluidDensity = desicDehum.plantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); desicDehum.MaxCoilFluidFlow = CoilMaxVolFlowRate * FluidDensity; } } diff --git a/src/EnergyPlus/EvaporativeFluidCoolers.cc b/src/EnergyPlus/EvaporativeFluidCoolers.cc index d201e20d9dd..7c11e7c0c33 100644 --- a/src/EnergyPlus/EvaporativeFluidCoolers.cc +++ b/src/EnergyPlus/EvaporativeFluidCoolers.cc @@ -1290,7 +1290,7 @@ namespace EvaporativeFluidCoolers { // Begin environment initializations if (this->MyEnvrnFlag && state.dataGlobal->BeginEnvrnFlag && (state.dataPlnt->PlantFirstSizesOkayToFinalize)) { - Real64 rho = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, RoutineName); + Real64 rho = this->plantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, RoutineName); this->DesWaterMassFlowRate = this->DesignWaterFlowRate * rho; PlantUtilities::InitComponentNodes(state, 0.0, this->DesWaterMassFlowRate, this->WaterInletNodeNum, this->WaterOutletNodeNum); this->MyEnvrnFlag = false; @@ -1459,8 +1459,8 @@ namespace EvaporativeFluidCoolers { if (this->PerformanceInputMethod_Num == PIM::UFactor && !this->HighSpeedEvapFluidCoolerUAWasAutoSized) { if (PltSizCondNum > 0) { - Real64 rho = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, CalledFrom); - Real64 Cp = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getSpecificHeat(state, this->DesignExitWaterTemp, CalledFrom); + Real64 rho = this->plantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, CalledFrom); + Real64 Cp = this->plantLoc.loop->glycol->getSpecificHeat(state, this->DesignExitWaterTemp, CalledFrom); DesEvapFluidCoolerLoad = rho * Cp * tmpDesignWaterFlowRate * state.dataSize->PlantSizData(PltSizCondNum).DeltaT; this->HighSpeedStandardDesignCapacity = DesEvapFluidCoolerLoad / this->HeatRejectCapNomCapSizingRatio; } else { @@ -1532,9 +1532,8 @@ namespace EvaporativeFluidCoolers { } } else if (PltSizCondNum > 0) { if (state.dataSize->PlantSizData(PltSizCondNum).DesVolFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 rho = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, CalledFrom); - Real64 Cp = - state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getSpecificHeat(state, this->DesignExitWaterTemp, CalledFrom); + Real64 rho = this->plantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, CalledFrom); + Real64 Cp = this->plantLoc.loop->glycol->getSpecificHeat(state, this->DesignExitWaterTemp, CalledFrom); DesEvapFluidCoolerLoad = rho * Cp * tmpDesignWaterFlowRate * state.dataSize->PlantSizData(PltSizCondNum).DeltaT; tmpHighSpeedFanPower = 0.0105 * DesEvapFluidCoolerLoad; if (state.dataPlnt->PlantFirstSizesOkayToFinalize) { @@ -1634,9 +1633,8 @@ namespace EvaporativeFluidCoolers { "must be > 25.6 C if autosizing the Evaporative Fluid Cooler."); ShowFatalError(state, "Review and revise design input values as appropriate."); } - Real64 rho = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, CalledFrom); - Real64 Cp = - state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getSpecificHeat(state, this->DesignExitWaterTemp, CalledFrom); + Real64 rho = this->plantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, CalledFrom); + Real64 Cp = this->plantLoc.loop->glycol->getSpecificHeat(state, this->DesignExitWaterTemp, CalledFrom); DesEvapFluidCoolerLoad = rho * Cp * tmpDesignWaterFlowRate * state.dataSize->PlantSizData(PltSizCondNum).DeltaT; Real64 const par1 = rho * tmpDesignWaterFlowRate; // Design water mass flow rate Real64 const par2 = tmpHighSpeedAirFlowRate; // Design air volume flow rate @@ -1756,8 +1754,8 @@ namespace EvaporativeFluidCoolers { if (this->DesignWaterFlowRate >= HVAC::SmallWaterVolFlow) { // Standard Design Capacity doesn't include compressor heat; // predefined factor was 1.25 W heat rejection per W of delivered cooling, now a user input with 1.25 default - Real64 rho = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, CalledFrom); - Real64 Cp = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getSpecificHeat(state, 35.0, CalledFrom); + Real64 rho = this->plantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, CalledFrom); + Real64 Cp = this->plantLoc.loop->glycol->getSpecificHeat(state, 35.0, CalledFrom); DesEvapFluidCoolerLoad = this->HighSpeedStandardDesignCapacity * this->HeatRejectCapNomCapSizingRatio; Real64 const par1 = rho * this->DesignWaterFlowRate; // Design water mass flow rate Real64 const par2 = this->HighSpeedAirFlowRate; // Design air volume flow rate @@ -1827,9 +1825,8 @@ namespace EvaporativeFluidCoolers { if (this->PerformanceInputMethod_Num == PIM::UserSpecifiedDesignCapacity) { if (this->DesignWaterFlowRate >= HVAC::SmallWaterVolFlow) { - Real64 rho = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, CalledFrom); - Real64 Cp = - state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getSpecificHeat(state, this->DesignEnteringWaterTemp, CalledFrom); + Real64 rho = this->plantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, CalledFrom); + Real64 Cp = this->plantLoc.loop->glycol->getSpecificHeat(state, this->DesignEnteringWaterTemp, CalledFrom); DesEvapFluidCoolerLoad = this->HighSpeedUserSpecifiedDesignCapacity; Real64 const par1 = rho * tmpDesignWaterFlowRate; // Design water mass flow rate Real64 const par2 = tmpHighSpeedAirFlowRate; // Design air volume flow rate @@ -1980,9 +1977,8 @@ namespace EvaporativeFluidCoolers { if (this->DesignWaterFlowRate >= HVAC::SmallWaterVolFlow && this->LowSpeedStandardDesignCapacity > 0.0) { // Standard design capacity doesn't include compressor heat; // predefined factor was 1.25 W heat rejection per W of delivered cooling, now user input with default 1.25 - Real64 rho = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, CalledFrom); - Real64 Cp = - state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getSpecificHeat(state, this->DesignEnteringWaterTemp, CalledFrom); + Real64 rho = this->plantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, CalledFrom); + Real64 Cp = this->plantLoc.loop->glycol->getSpecificHeat(state, this->DesignEnteringWaterTemp, CalledFrom); DesEvapFluidCoolerLoad = this->LowSpeedStandardDesignCapacity * this->HeatRejectCapNomCapSizingRatio; Real64 const par1 = rho * tmpDesignWaterFlowRate; // Design water mass flow rate Real64 const par2 = this->LowSpeedAirFlowRate; // Air volume flow rate at low fan speed @@ -2034,9 +2030,8 @@ namespace EvaporativeFluidCoolers { if (this->PerformanceInputMethod_Num == PIM::UserSpecifiedDesignCapacity && this->Type == DataPlant::PlantEquipmentType::EvapFluidCooler_TwoSpd) { if (this->DesignWaterFlowRate >= HVAC::SmallWaterVolFlow && this->LowSpeedUserSpecifiedDesignCapacity > 0.0) { - Real64 rho = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, CalledFrom); - Real64 Cp = - state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getSpecificHeat(state, this->DesignEnteringWaterTemp, CalledFrom); + Real64 rho = this->plantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, CalledFrom); + Real64 Cp = this->plantLoc.loop->glycol->getSpecificHeat(state, this->DesignEnteringWaterTemp, CalledFrom); DesEvapFluidCoolerLoad = this->LowSpeedUserSpecifiedDesignCapacity; Real64 const par1 = rho * tmpDesignWaterFlowRate; // Design water mass flow rate Real64 const par2 = this->LowSpeedAirFlowRate; // Air volume flow rate at low fan speed @@ -2344,8 +2339,7 @@ namespace EvaporativeFluidCoolers { } // Should this be water inlet node num????? - CpWater = state.dataPlnt->PlantLoop(this->plantLoc.loopNum) - .glycol->getSpecificHeat(state, state.dataLoopNodes->Node(this->WaterInletNode).Temp, RoutineName); + CpWater = this->plantLoc.loop->glycol->getSpecificHeat(state, state.dataLoopNodes->Node(this->WaterInletNode).Temp, RoutineName); this->Qactual = this->WaterMassFlowRate * CpWater * (state.dataLoopNodes->Node(this->WaterInletNode).Temp - this->OutletWaterTemp); this->AirFlowRateRatio = AirFlowRate / this->HighSpeedAirFlowRate; } @@ -2467,8 +2461,7 @@ namespace EvaporativeFluidCoolers { } // Should this be water inlet node num?? - Real64 CpWater = state.dataPlnt->PlantLoop(this->plantLoc.loopNum) - .glycol->getSpecificHeat(state, state.dataLoopNodes->Node(this->WaterInletNode).Temp, RoutineName); + Real64 CpWater = this->plantLoc.loop->glycol->getSpecificHeat(state, state.dataLoopNodes->Node(this->WaterInletNode).Temp, RoutineName); this->Qactual = this->WaterMassFlowRate * CpWater * (state.dataLoopNodes->Node(this->WaterInletNode).Temp - this->OutletWaterTemp); this->AirFlowRateRatio = AirFlowRate / this->HighSpeedAirFlowRate; } @@ -2519,7 +2512,7 @@ namespace EvaporativeFluidCoolers { Real64 AirDensity = Psychrometrics::PsyRhoAirFnPbTdbW(state, this->inletConds.AirPress, InletAirTemp, this->inletConds.AirHumRat); Real64 AirMassFlowRate = AirFlowRate * AirDensity; Real64 CpAir = Psychrometrics::PsyCpAirFnW(this->inletConds.AirHumRat); - Real64 CpWater = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getSpecificHeat(state, this->InletWaterTemp, RoutineName); + Real64 CpWater = this->plantLoc.loop->glycol->getSpecificHeat(state, this->InletWaterTemp, RoutineName); Real64 InletAirEnthalpy = Psychrometrics::PsyHFnTdbRhPb(state, InletAirWetBulb, 1.0, this->inletConds.AirPress); // initialize exiting wet bulb temperature before iterating on final solution @@ -2614,7 +2607,7 @@ namespace EvaporativeFluidCoolers { Real64 TairAvg = (this->inletConds.AirTemp + OutletAirTSat) / 2.0; // Amount of water evaporated - Real64 rho = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getDensity(state, TairAvg, RoutineName); + Real64 rho = this->plantLoc.loop->glycol->getDensity(state, TairAvg, RoutineName); this->EvaporationVdot = (AirMassFlowRate * (OutSpecificHumRat - InSpecificHumRat)) / rho; // [m3/s] if (this->EvaporationVdot < 0.0) { this->EvaporationVdot = 0.0; @@ -2624,7 +2617,7 @@ namespace EvaporativeFluidCoolers { } } else if (this->EvapLossMode == EvapLoss::ByUserFactor) { - Real64 rho = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getDensity(state, AverageWaterTemp, RoutineName); + Real64 rho = this->plantLoc.loop->glycol->getDensity(state, AverageWaterTemp, RoutineName); this->EvaporationVdot = this->UserEvapLossFactor * (this->InletWaterTemp - this->OutletWaterTemp) * (this->WaterMassFlowRate / rho); if (this->EvaporationVdot < 0.0) { this->EvaporationVdot = 0.0; diff --git a/src/EnergyPlus/FanCoilUnits.cc b/src/EnergyPlus/FanCoilUnits.cc index d6efc10e465..d626b491564 100644 --- a/src/EnergyPlus/FanCoilUnits.cc +++ b/src/EnergyPlus/FanCoilUnits.cc @@ -1072,13 +1072,12 @@ namespace FanCoilUnits { fanCoil.OutAirMassFlow = RhoAir * fanCoil.OutAirVolFlow; if (fanCoil.HCoilType_Num == HCoil::Water) { - Real64 rho = - state.dataPlnt->PlantLoop(fanCoil.HeatCoilPlantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + Real64 rho = fanCoil.HeatCoilPlantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); fanCoil.MaxHeatCoilFluidFlow = rho * fanCoil.MaxHotWaterVolFlow; fanCoil.MinHotWaterFlow = rho * fanCoil.MinHotWaterVolFlow; } - Real64 rho = state.dataPlnt->PlantLoop(fanCoil.CoolCoilPlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); + Real64 rho = fanCoil.CoolCoilPlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); fanCoil.MaxCoolCoilFluidFlow = rho * fanCoil.MaxColdWaterVolFlow; fanCoil.MinColdWaterFlow = rho * fanCoil.MinColdWaterVolFlow; @@ -1608,10 +1607,8 @@ namespace FanCoilUnits { } fanCoil.DesHeatingLoad = DesCoilLoad; if (DesCoilLoad >= HVAC::SmallLoad) { - rho = state.dataPlnt->PlantLoop(fanCoil.HeatCoilPlantLoc.loopNum) - .glycol->getDensity(state, Constant::HWInitConvTemp, RoutineNameNoSpace); - Cp = state.dataPlnt->PlantLoop(fanCoil.HeatCoilPlantLoc.loopNum) - .glycol->getSpecificHeat(state, Constant::HWInitConvTemp, RoutineNameNoSpace); + rho = fanCoil.HeatCoilPlantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineNameNoSpace); + Cp = fanCoil.HeatCoilPlantLoc.loop->glycol->getSpecificHeat(state, Constant::HWInitConvTemp, RoutineNameNoSpace); MaxHotWaterVolFlowDes = DesCoilLoad / (WaterCoilSizDeltaT * Cp * rho); } else { @@ -1787,8 +1784,8 @@ namespace FanCoilUnits { } fanCoil.DesCoolingLoad = DesCoilLoad; if (DesCoilLoad >= HVAC::SmallLoad) { - rho = state.dataPlnt->PlantLoop(fanCoil.CoolCoilPlantLoc.loopNum).glycol->getDensity(state, 5., RoutineNameNoSpace); - Cp = state.dataPlnt->PlantLoop(fanCoil.CoolCoilPlantLoc.loopNum).glycol->getSpecificHeat(state, 5., RoutineNameNoSpace); + rho = fanCoil.CoolCoilPlantLoc.loop->glycol->getDensity(state, 5., RoutineNameNoSpace); + Cp = fanCoil.CoolCoilPlantLoc.loop->glycol->getSpecificHeat(state, 5., RoutineNameNoSpace); MaxColdWaterVolFlowDes = DesCoilLoad / (WaterCoilSizDeltaT * Cp * rho); } else { MaxColdWaterVolFlowDes = 0.0; diff --git a/src/EnergyPlus/FluidCoolers.cc b/src/EnergyPlus/FluidCoolers.cc index 438b0e8aa51..07093e6798f 100644 --- a/src/EnergyPlus/FluidCoolers.cc +++ b/src/EnergyPlus/FluidCoolers.cc @@ -856,7 +856,7 @@ void FluidCoolerspecs::oneTimeInit_new(EnergyPlusData &state) void FluidCoolerspecs::initEachEnvironment(EnergyPlusData &state) { static constexpr std::string_view RoutineName("FluidCoolerspecs::initEachEnvironment"); - Real64 const rho = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, RoutineName); + Real64 const rho = this->plantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, RoutineName); this->DesWaterMassFlowRate = this->DesignWaterFlowRate * rho; PlantUtilities::InitComponentNodes(state, 0.0, this->DesWaterMassFlowRate, this->WaterInletNodeNum, this->WaterOutletNodeNum); } @@ -1020,9 +1020,8 @@ void FluidCoolerspecs::size(EnergyPlusData &state) if (this->PerformanceInputMethod_Num == PerfInputMethod::U_FACTOR && this->HighSpeedFluidCoolerUAWasAutoSized) { if (PltSizCondNum > 0) { - rho = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, CalledFrom); - Cp = state.dataPlnt->PlantLoop(this->plantLoc.loopNum) - .glycol->getSpecificHeat(state, state.dataSize->PlantSizData(PltSizCondNum).ExitTemp, CalledFrom); + rho = this->plantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, CalledFrom); + Cp = this->plantLoc.loop->glycol->getSpecificHeat(state, state.dataSize->PlantSizData(PltSizCondNum).ExitTemp, CalledFrom); DesFluidCoolerLoad = rho * Cp * tmpDesignWaterFlowRate * state.dataSize->PlantSizData(PltSizCondNum).DeltaT; if (state.dataPlnt->PlantFirstSizesOkayToFinalize) { this->FluidCoolerNominalCapacity = DesFluidCoolerLoad; @@ -1052,9 +1051,8 @@ void FluidCoolerspecs::size(EnergyPlusData &state) ensureSizingPlantExitTempIsNotLessThanDesignEnteringAirTemp(); - rho = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, CalledFrom); - Cp = state.dataPlnt->PlantLoop(this->plantLoc.loopNum) - .glycol->getSpecificHeat(state, state.dataSize->PlantSizData(PltSizCondNum).ExitTemp, CalledFrom); + rho = this->plantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, CalledFrom); + Cp = this->plantLoc.loop->glycol->getSpecificHeat(state, state.dataSize->PlantSizData(PltSizCondNum).ExitTemp, CalledFrom); DesFluidCoolerLoad = rho * Cp * tmpDesignWaterFlowRate * state.dataSize->PlantSizData(PltSizCondNum).DeltaT; tmpHighSpeedFanPower = 0.0105 * DesFluidCoolerLoad; @@ -1128,9 +1126,8 @@ void FluidCoolerspecs::size(EnergyPlusData &state) ensureSizingPlantExitTempIsNotLessThanDesignEnteringAirTemp(); - rho = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, CalledFrom); - Cp = state.dataPlnt->PlantLoop(this->plantLoc.loopNum) - .glycol->getSpecificHeat(state, state.dataSize->PlantSizData(PltSizCondNum).ExitTemp, CalledFrom); + rho = this->plantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, CalledFrom); + Cp = this->plantLoc.loop->glycol->getSpecificHeat(state, state.dataSize->PlantSizData(PltSizCondNum).ExitTemp, CalledFrom); DesFluidCoolerLoad = rho * Cp * tmpDesignWaterFlowRate * state.dataSize->PlantSizData(PltSizCondNum).DeltaT; tmpHighSpeedAirFlowRate = DesFluidCoolerLoad / (this->DesignEnteringWaterTemp - this->DesignEnteringAirTemp) * 4.0; @@ -1193,9 +1190,8 @@ void FluidCoolerspecs::size(EnergyPlusData &state) ensureSizingPlantExitTempIsNotLessThanDesignEnteringAirTemp(); - rho = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, CalledFrom); - Cp = state.dataPlnt->PlantLoop(this->plantLoc.loopNum) - .glycol->getSpecificHeat(state, state.dataSize->PlantSizData(PltSizCondNum).ExitTemp, CalledFrom); + rho = this->plantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, CalledFrom); + Cp = this->plantLoc.loop->glycol->getSpecificHeat(state, state.dataSize->PlantSizData(PltSizCondNum).ExitTemp, CalledFrom); DesFluidCoolerLoad = rho * Cp * tmpDesignWaterFlowRate * state.dataSize->PlantSizData(PltSizCondNum).DeltaT; UA0 = 0.0001 * DesFluidCoolerLoad; // Assume deltaT = 10000K (limit) @@ -1305,8 +1301,8 @@ void FluidCoolerspecs::size(EnergyPlusData &state) if (this->PerformanceInputMethod_Num == PerfInputMethod::NOMINAL_CAPACITY) { if (this->DesignWaterFlowRate >= HVAC::SmallWaterVolFlow) { - rho = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, CalledFrom); - Cp = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getSpecificHeat(state, this->DesignEnteringWaterTemp, CalledFrom); + rho = this->plantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, CalledFrom); + Cp = this->plantLoc.loop->glycol->getSpecificHeat(state, this->DesignEnteringWaterTemp, CalledFrom); DesFluidCoolerLoad = this->FluidCoolerNominalCapacity; Real64 par2_WaterFlow = rho * tmpDesignWaterFlowRate; UA0 = 0.0001 * DesFluidCoolerLoad; // Assume deltaT = 10000K (limit) @@ -1485,8 +1481,8 @@ void FluidCoolerspecs::size(EnergyPlusData &state) } if (this->DesignWaterFlowRate >= HVAC::SmallWaterVolFlow && this->FluidCoolerLowSpeedNomCap > 0.0) { - rho = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, CalledFrom); - Cp = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getSpecificHeat(state, this->DesignEnteringWaterTemp, CalledFrom); + rho = this->plantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, CalledFrom); + Cp = this->plantLoc.loop->glycol->getSpecificHeat(state, this->DesignEnteringWaterTemp, CalledFrom); DesFluidCoolerLoad = this->FluidCoolerLowSpeedNomCap; UA0 = 0.0001 * DesFluidCoolerLoad; // Assume deltaT = 10000K (limit) UA1 = DesFluidCoolerLoad; // Assume deltaT = 1K @@ -1576,7 +1572,7 @@ void FluidCoolerspecs::size(EnergyPlusData &state) this->AirPress = state.dataEnvrn->StdBaroPress; this->AirHumRat = Psychrometrics::PsyWFnTdbTwbPb(state, this->AirTemp, this->AirWetBulb, this->AirPress); Real64 OutletTemp = 0; - rho = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, CalledFrom); + rho = this->plantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, CalledFrom); CalcFluidCoolerOutlet( state, this->indexInArray, rho * this->DesignWaterFlowRate, this->HighSpeedAirFlowRate, this->HighSpeedFluidCoolerUA, OutletTemp); this->DesignLeavingWaterTemp = OutletTemp; @@ -1734,8 +1730,7 @@ void FluidCoolerspecs::calcSingleSpeed(EnergyPlusData &state) // Setpoint was not met, fluid cooler ran at full capacity this->FanPower = FanPowerOn; } - Real64 CpWater = state.dataPlnt->PlantLoop(this->plantLoc.loopNum) - .glycol->getSpecificHeat(state, state.dataLoopNodes->Node(this->WaterInletNodeNum).Temp, RoutineName); + Real64 CpWater = this->plantLoc.loop->glycol->getSpecificHeat(state, state.dataLoopNodes->Node(this->WaterInletNodeNum).Temp, RoutineName); this->Qactual = this->WaterMassFlowRate * CpWater * (state.dataLoopNodes->Node(this->WaterInletNodeNum).Temp - this->OutletWaterTemp); } @@ -1858,8 +1853,7 @@ void FluidCoolerspecs::calcTwoSpeed(EnergyPlusData &state) this->FanPower = FanPowerHigh; } } - Real64 CpWater = state.dataPlnt->PlantLoop(this->plantLoc.loopNum) - .glycol->getSpecificHeat(state, state.dataLoopNodes->Node(this->WaterInletNodeNum).Temp, RoutineName); + Real64 CpWater = this->plantLoc.loop->glycol->getSpecificHeat(state, state.dataLoopNodes->Node(this->WaterInletNodeNum).Temp, RoutineName); this->Qactual = this->WaterMassFlowRate * CpWater * (state.dataLoopNodes->Node(this->WaterInletNodeNum).Temp - this->OutletWaterTemp); } @@ -1898,7 +1892,7 @@ void CalcFluidCoolerOutlet( Real64 AirDensity = Psychrometrics::PsyRhoAirFnPbTdbW(state, fluidCooler.AirPress, InletAirTemp, fluidCooler.AirHumRat); Real64 AirMassFlowRate = AirFlowRate * AirDensity; Real64 CpAir = Psychrometrics::PsyCpAirFnW(fluidCooler.AirHumRat); - Real64 CpWater = state.dataPlnt->PlantLoop(fluidCooler.plantLoc.loopNum).glycol->getSpecificHeat(state, _InletWaterTemp, RoutineName); + Real64 CpWater = fluidCooler.plantLoc.loop->glycol->getSpecificHeat(state, _InletWaterTemp, RoutineName); // Calculate mass flow rates Real64 MdotCpWater = _WaterMassFlowRate * CpWater; diff --git a/src/EnergyPlus/FuelCellElectricGenerator.cc b/src/EnergyPlus/FuelCellElectricGenerator.cc index 2536d05c42f..081fd30732b 100644 --- a/src/EnergyPlus/FuelCellElectricGenerator.cc +++ b/src/EnergyPlus/FuelCellElectricGenerator.cc @@ -3029,7 +3029,7 @@ namespace FuelCellElectricGenerator { this->ExhaustHX.THXexh = TprodGasIn - this->ExhaustHX.qHX / (NdotGas * CpProdGasMol * 1000.0); - Real64 Cp = state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).glycol->getSpecificHeat(state, TwaterIn, RoutineName); + Real64 Cp = this->CWPlantLoc.loop->glycol->getSpecificHeat(state, TwaterIn, RoutineName); if (this->ExhaustHX.WaterMassFlowRate * Cp <= 0.0) { this->ExhaustHX.WaterOutletTemp = TwaterIn; @@ -3365,7 +3365,7 @@ namespace FuelCellElectricGenerator { this->Inverter.PCUlosses = 0.0; this->Inverter.QairIntake = 0.0; - Real64 rho = state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).glycol->getDensity(state, DataGenerators::InitHRTemp, RoutineName); + Real64 rho = this->CWPlantLoc.loop->glycol->getDensity(state, DataGenerators::InitHRTemp, RoutineName); this->ExhaustHX.WaterMassFlowRateDesign = this->ExhaustHX.WaterVolumeFlowMax * rho; this->ExhaustHX.WaterMassFlowRate = this->ExhaustHX.WaterMassFlowRateDesign; diff --git a/src/EnergyPlus/Furnaces.cc b/src/EnergyPlus/Furnaces.cc index 63a98cebea6..184f3268b35 100644 --- a/src/EnergyPlus/Furnaces.cc +++ b/src/EnergyPlus/Furnaces.cc @@ -4877,8 +4877,7 @@ namespace Furnaces { thisFurnace.MaxHeatCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", thisFurnace.HeatingCoilName, ErrorsFound); if (thisFurnace.MaxHeatCoilFluidFlow > 0.0) { - rho = - state.dataPlnt->PlantLoop(thisFurnace.plantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + rho = thisFurnace.plantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); thisFurnace.MaxHeatCoilFluidFlow *= rho; } } else if (thisFurnace.HeatingCoilType_Num == HVAC::Coil_HeatingSteam) { diff --git a/src/EnergyPlus/HVACControllers.cc b/src/EnergyPlus/HVACControllers.cc index 6bcba779399..ab2b126c457 100644 --- a/src/EnergyPlus/HVACControllers.cc +++ b/src/EnergyPlus/HVACControllers.cc @@ -1026,8 +1026,7 @@ void InitController(EnergyPlusData &state, int const ControlNum, bool &IsConverg // Do the Begin Environment initializations if (state.dataGlobal->BeginEnvrnFlag && MyEnvrnFlag(ControlNum)) { - Real64 rho = - state.dataPlnt->PlantLoop(thisController.ActuatedNodePlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); + Real64 rho = thisController.ActuatedNodePlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); thisController.MinActuated = rho * thisController.MinVolFlowActuated; thisController.MaxActuated = rho * thisController.MaxVolFlowActuated; diff --git a/src/EnergyPlus/HVACCooledBeam.cc b/src/EnergyPlus/HVACCooledBeam.cc index 12b950378ec..bfcd7f65154 100644 --- a/src/EnergyPlus/HVACCooledBeam.cc +++ b/src/EnergyPlus/HVACCooledBeam.cc @@ -556,7 +556,7 @@ namespace HVACCooledBeam { InWaterNode = coolBeam.CWInNode; OutWaterNode = coolBeam.CWOutNode; - rho = state.dataPlnt->PlantLoop(coolBeam.CWPlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); + rho = coolBeam.CWPlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); coolBeam.MaxCoolWaterMassFlow = rho * coolBeam.MaxCoolWaterVolFlow; InitComponentNodes(state, 0.0, coolBeam.MaxCoolWaterMassFlow, InWaterNode, OutWaterNode); coolBeam.MySizeFlag = false; @@ -725,10 +725,9 @@ namespace HVACCooledBeam { state.dataSize->TermUnitFinalZoneSizing(state.dataSize->CurTermUnitSizingNum).ZoneSizThermSetPtHi); } - rho = state.dataPlnt->PlantLoop(coolBeam.CWPlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); + rho = coolBeam.CWPlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); - Cp = state.dataPlnt->PlantLoop(coolBeam.CWPlantLoc.loopNum) - .glycol->getSpecificHeat(state, Constant::CWInitConvTemp, RoutineName); + Cp = coolBeam.CWPlantLoc.loop->glycol->getSpecificHeat(state, Constant::CWInitConvTemp, RoutineName); coolBeam.MaxCoolWaterVolFlow = DesCoilLoad / ((coolBeam.DesOutletWaterTemp - coolBeam.DesInletWaterTemp) * Cp * rho); coolBeam.MaxCoolWaterVolFlow = max(coolBeam.MaxCoolWaterVolFlow, 0.0); @@ -761,7 +760,7 @@ namespace HVACCooledBeam { state.dataSize->FinalSysSizing); if (coolBeam.NumBeams == AutoSize) { - rho = state.dataPlnt->PlantLoop(coolBeam.CWPlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); + rho = coolBeam.CWPlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); NumBeams = int(coolBeam.MaxCoolWaterVolFlow * rho / NomMassFlowPerBeam) + 1; coolBeam.NumBeams = double(NumBeams); @@ -775,9 +774,8 @@ namespace HVACCooledBeam { CheckZoneSizing(state, coolBeam.UnitType, coolBeam.Name); if (PltSizCoolNum > 0) { - rho = state.dataPlnt->PlantLoop(coolBeam.CWPlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); - - Cp = state.dataPlnt->PlantLoop(coolBeam.CWPlantLoc.loopNum).glycol->getSpecificHeat(state, Constant::CWInitConvTemp, RoutineName); + rho = coolBeam.CWPlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); + Cp = coolBeam.CWPlantLoc.loop->glycol->getSpecificHeat(state, Constant::CWInitConvTemp, RoutineName); DesCoilLoad = coolBeam.MaxCoolWaterVolFlow * (coolBeam.DesOutletWaterTemp - coolBeam.DesInletWaterTemp) * Cp * rho; if (DesCoilLoad > 0.0) { DesLoadPerBeam = DesCoilLoad / NumBeams; @@ -1052,9 +1050,9 @@ namespace HVACCooledBeam { CWFlowPerBeam = mdot / coolBeam.NumBeams; TWIn = coolBeam.TWIn; - Cp = state.dataPlnt->PlantLoop(coolBeam.CWPlantLoc.loopNum).glycol->getSpecificHeat(state, TWIn, RoutineName); + Cp = coolBeam.CWPlantLoc.loop->glycol->getSpecificHeat(state, TWIn, RoutineName); - rho = state.dataPlnt->PlantLoop(coolBeam.CWPlantLoc.loopNum).glycol->getDensity(state, TWIn, RoutineName); + rho = coolBeam.CWPlantLoc.loop->glycol->getDensity(state, TWIn, RoutineName); TWOut = TWIn + 2.0; ZTemp = state.dataLoopNodes->Node(ZoneNode).Temp; diff --git a/src/EnergyPlus/HVACFourPipeBeam.cc b/src/EnergyPlus/HVACFourPipeBeam.cc index d34f4125032..c743da60847 100644 --- a/src/EnergyPlus/HVACFourPipeBeam.cc +++ b/src/EnergyPlus/HVACFourPipeBeam.cc @@ -831,8 +831,7 @@ namespace FourPipeBeam { this->totBeamLength = this->vDotDesignPrimAir / this->vDotNormRatedPrimAir; if (this->vDotDesignCWWasAutosized) { this->vDotDesignCW = this->vDotNormRatedCW * this->totBeamLength; - Real64 const rho = - state.dataPlnt->PlantLoop(this->cWplantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, routineName); + Real64 const rho = this->cWplantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, routineName); this->mDotNormRatedCW = this->vDotNormRatedCW * rho; this->mDotCW = this->vDotDesignCW * rho; if (this->beamCoolingPresent) { @@ -841,8 +840,7 @@ namespace FourPipeBeam { } if (vDotDesignHWWasAutosized) { this->vDotDesignHW = this->vDotNormRatedHW * this->totBeamLength; - Real64 const rho = - state.dataPlnt->PlantLoop(this->hWplantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, routineName); + Real64 const rho = this->hWplantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, routineName); this->mDotNormRatedHW = this->vDotNormRatedHW * rho; this->mDotHW = this->vDotDesignHW * rho; if (this->beamHeatingPresent) { @@ -904,8 +902,7 @@ namespace FourPipeBeam { this->totBeamLength = this->vDotDesignPrimAir / this->vDotNormRatedPrimAir; if (this->vDotDesignCWWasAutosized) { this->vDotDesignCW = this->vDotNormRatedCW * this->totBeamLength; - Real64 const rho = - state.dataPlnt->PlantLoop(this->cWplantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, routineName); + Real64 const rho = this->cWplantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, routineName); this->mDotNormRatedCW = this->vDotNormRatedCW * rho; this->mDotCW = this->vDotDesignCW * rho; if (this->beamCoolingPresent) { @@ -914,8 +911,7 @@ namespace FourPipeBeam { } if (vDotDesignHWWasAutosized) { this->vDotDesignHW = this->vDotNormRatedHW * this->totBeamLength; - Real64 const rho = - state.dataPlnt->PlantLoop(this->hWplantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, routineName); + Real64 const rho = this->hWplantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, routineName); this->mDotNormRatedHW = this->vDotNormRatedHW * rho; this->mDotHW = this->vDotDesignHW * rho; if (this->beamHeatingPresent) { @@ -980,13 +976,13 @@ namespace FourPipeBeam { } if (this->beamCoolingPresent) { - rho = state.dataPlnt->PlantLoop(this->cWplantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, routineName); + rho = this->cWplantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, routineName); this->mDotNormRatedCW = this->vDotNormRatedCW * rho; this->mDotDesignCW = this->vDotDesignCW * rho; PlantUtilities::InitComponentNodes(state, 0.0, this->mDotDesignCW, this->cWInNodeNum, this->cWOutNodeNum); } if (this->beamHeatingPresent) { - rho = state.dataPlnt->PlantLoop(this->hWplantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, routineName); + rho = this->hWplantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, routineName); this->mDotNormRatedHW = this->vDotNormRatedHW * rho; this->mDotDesignHW = this->vDotDesignHW * rho; PlantUtilities::InitComponentNodes(state, 0.0, this->mDotDesignHW, this->hWInNodeNum, this->hWOutNodeNum); @@ -1235,7 +1231,7 @@ namespace FourPipeBeam { fModCoolAirMdot = Curve::CurveValue( state, this->modCoolingQdotAirFlowFuncNum, ((this->mDotSystemAir / this->totBeamLength) / this->mDotNormRatedPrimAir)); this->qDotBeamCooling = -1.0 * this->qDotNormRatedCooling * fModCoolDeltaT * fModCoolAirMdot * fModCoolCWMdot * this->totBeamLength; - cp = state.dataPlnt->PlantLoop(this->cWplantLoc.loopNum).glycol->getSpecificHeat(state, this->cWTempIn, routineName); + cp = this->cWplantLoc.loop->glycol->getSpecificHeat(state, this->cWTempIn, routineName); if (this->mDotCW > 0.0) { this->cWTempOut = this->cWTempIn - (this->qDotBeamCooling / (this->mDotCW * cp)); } else { @@ -1272,7 +1268,7 @@ namespace FourPipeBeam { fModHeatAirMdot = Curve::CurveValue( state, this->modHeatingQdotAirFlowFuncNum, ((this->mDotSystemAir / this->totBeamLength) / this->mDotNormRatedPrimAir)); this->qDotBeamHeating = this->qDotNormRatedHeating * fModHeatDeltaT * fModHeatAirMdot * fModHeatHWMdot * this->totBeamLength; - cp = state.dataPlnt->PlantLoop(this->hWplantLoc.loopNum).glycol->getSpecificHeat(state, this->hWTempIn, routineName); + cp = this->hWplantLoc.loop->glycol->getSpecificHeat(state, this->hWTempIn, routineName); if (this->mDotHW > 0.0) { this->hWTempOut = this->hWTempIn - (this->qDotBeamHeating / (this->mDotHW * cp)); } else { diff --git a/src/EnergyPlus/HVACMultiSpeedHeatPump.cc b/src/EnergyPlus/HVACMultiSpeedHeatPump.cc index 9947a20dff3..952cd32c095 100644 --- a/src/EnergyPlus/HVACMultiSpeedHeatPump.cc +++ b/src/EnergyPlus/HVACMultiSpeedHeatPump.cc @@ -1855,8 +1855,7 @@ namespace HVACMultiSpeedHeatPump { WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", MSHeatPump(MSHeatPumpNum).HeatCoilName, ErrorsFound); if (MSHeatPump(MSHeatPumpNum).MaxCoilFluidFlow > 0.0) { - rho = state.dataPlnt->PlantLoop(MSHeatPump(MSHeatPumpNum).plantLoc.loopNum) - .glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + rho = MSHeatPump(MSHeatPumpNum).plantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); MSHeatPump(MSHeatPumpNum).MaxCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", MSHeatPump(MSHeatPumpNum).HeatCoilName, ErrorsFound) * rho; } @@ -1911,8 +1910,7 @@ namespace HVACMultiSpeedHeatPump { WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", MSHeatPump(MSHeatPumpNum).SuppHeatCoilName, ErrorsFound); if (MSHeatPump(MSHeatPumpNum).MaxSuppCoilFluidFlow > 0.0) { - rho = state.dataPlnt->PlantLoop(MSHeatPump(MSHeatPumpNum).SuppPlantLoc.loopNum) - .glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + rho = MSHeatPump(MSHeatPumpNum).SuppPlantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); MSHeatPump(MSHeatPumpNum).MaxSuppCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", MSHeatPump(MSHeatPumpNum).SuppHeatCoilName, ErrorsFound) * rho; @@ -2145,8 +2143,7 @@ namespace HVACMultiSpeedHeatPump { if ((MSHeatPump(MSHeatPumpNum).HeatRecActive) && (!MSHeatPump(MSHeatPumpNum).MyPlantScantFlag)) { - rho = state.dataPlnt->PlantLoop(MSHeatPump(MSHeatPumpNum).HRPlantLoc.loopNum) - .glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + rho = MSHeatPump(MSHeatPumpNum).HRPlantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); MSHeatPump(MSHeatPumpNum).DesignHeatRecMassFlowRate = MSHeatPump(MSHeatPumpNum).DesignHeatRecFlowRate * rho; @@ -2165,8 +2162,7 @@ namespace HVACMultiSpeedHeatPump { CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", MSHeatPump(MSHeatPumpNum).HeatCoilName, ErrorsFound); if (CoilMaxVolFlowRate != DataSizing::AutoSize) { - rho = state.dataPlnt->PlantLoop(MSHeatPump(MSHeatPumpNum).plantLoc.loopNum) - .glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + rho = MSHeatPump(MSHeatPumpNum).plantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); MSHeatPump(MSHeatPumpNum).MaxCoilFluidFlow = CoilMaxVolFlowRate * rho; } PlantUtilities::InitComponentNodes(state, @@ -2206,8 +2202,7 @@ namespace HVACMultiSpeedHeatPump { CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", MSHeatPump(MSHeatPumpNum).SuppHeatCoilName, ErrorsFound); if (CoilMaxVolFlowRate != DataSizing::AutoSize) { - rho = state.dataPlnt->PlantLoop(MSHeatPump(MSHeatPumpNum).SuppPlantLoc.loopNum) - .glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + rho = MSHeatPump(MSHeatPumpNum).SuppPlantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); MSHeatPump(MSHeatPumpNum).MaxSuppCoilFluidFlow = CoilMaxVolFlowRate * rho; } PlantUtilities::InitComponentNodes(state, @@ -4083,7 +4078,7 @@ namespace HVACMultiSpeedHeatPump { if (HeatRecMassFlowRate > 0.0) { // Heat reclaim water inlet specific heat [J/kg-K] - Real64 CpHeatRec = state.dataPlnt->PlantLoop(mshp.HRPlantLoc.loopNum).glycol->getSpecificHeat(state, HeatRecInletTemp, RoutineName); + Real64 CpHeatRec = mshp.HRPlantLoc.loop->glycol->getSpecificHeat(state, HeatRecInletTemp, RoutineName); HeatRecOutletTemp = QHeatRec / (HeatRecMassFlowRate * CpHeatRec) + HeatRecInletTemp; if (HeatRecOutletTemp > mshp.MaxHeatRecOutletTemp) { diff --git a/src/EnergyPlus/HVACUnitaryBypassVAV.cc b/src/EnergyPlus/HVACUnitaryBypassVAV.cc index 45606dfaa26..e9a5b623756 100644 --- a/src/EnergyPlus/HVACUnitaryBypassVAV.cc +++ b/src/EnergyPlus/HVACUnitaryBypassVAV.cc @@ -1369,8 +1369,7 @@ namespace HVACUnitaryBypassVAV { cBVAV.MaxHeatCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", cBVAV.HeatCoilName, ErrorsFound); if (cBVAV.MaxHeatCoilFluidFlow > 0.0) { - Real64 FluidDensity = - state.dataPlnt->PlantLoop(cBVAV.plantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + Real64 FluidDensity = cBVAV.plantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); cBVAV.MaxHeatCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", cBVAV.HeatCoilName, ErrorsFound) * FluidDensity; } @@ -1465,8 +1464,7 @@ namespace HVACUnitaryBypassVAV { ShowContinueError(state, format("Occurs in {} = {}", "AirLoopHVAC:UnitaryHeatCool:VAVChangeoverBypass", cBVAV.Name)); } if (CoilMaxVolFlowRate != DataSizing::AutoSize) { - Real64 FluidDensity = - state.dataPlnt->PlantLoop(cBVAV.plantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + Real64 FluidDensity = cBVAV.plantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); cBVAV.MaxHeatCoilFluidFlow = CoilMaxVolFlowRate * FluidDensity; } } diff --git a/src/EnergyPlus/HVACVariableRefrigerantFlow.cc b/src/EnergyPlus/HVACVariableRefrigerantFlow.cc index a0a54fd9579..f5f345987e0 100644 --- a/src/EnergyPlus/HVACVariableRefrigerantFlow.cc +++ b/src/EnergyPlus/HVACVariableRefrigerantFlow.cc @@ -1284,7 +1284,7 @@ void CalcVRFCondenser(EnergyPlusData &state, int const VRFCond) // VRF( VRFCond ).CondenserInletTemp = state.dataLoopNodes->Node(VRF(VRFCond).CondenserNodeNum).Temp; vrf.WaterCondenserMassFlow = state.dataLoopNodes->Node(vrf.CondenserNodeNum).MassFlowRate; - CpCond = state.dataPlnt->PlantLoop(vrf.SourcePlantLoc.loopNum).glycol->getSpecificHeat(state, vrf.CondenserInletTemp, RoutineName); + CpCond = vrf.SourcePlantLoc.loop->glycol->getSpecificHeat(state, vrf.CondenserInletTemp, RoutineName); if (CondWaterMassFlow > 0.0) { CondOutletTemp = vrf.QCondenser / (CondWaterMassFlow * CpCond) + CondInletTemp; } else { @@ -5668,8 +5668,8 @@ void InitVRF(EnergyPlusData &state, int const VRFTUNum, int const ZoneNum, bool state, "Coil:Heating:Water", state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilName, ErrorsFound); if (state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilFluidMaxFlow > 0.0) { - rho = state.dataPlnt->PlantLoop(state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilPlantLoc.loopNum) - .glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + rho = state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilPlantLoc.loop->glycol->getDensity( + state, Constant::HWInitConvTemp, RoutineName); state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilFluidMaxFlow = state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilFluidMaxFlow * rho; } @@ -6316,8 +6316,7 @@ void InitVRF(EnergyPlusData &state, int const VRFTUNum, int const ZoneNum, bool state.dataHVACVarRefFlow->MyEnvrnFlag(VRFTUNum) = false; if (state.dataHVACVarRefFlow->VRF(VRFCond).CondenserType == DataHeatBalance::RefrigCondenserType::Water) { - rho = state.dataPlnt->PlantLoop(state.dataHVACVarRefFlow->VRF(VRFCond).SourcePlantLoc.loopNum) - .glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); + rho = state.dataHVACVarRefFlow->VRF(VRFCond).SourcePlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); state.dataHVACVarRefFlow->VRF(VRFCond).WaterCondenserDesignMassFlow = state.dataHVACVarRefFlow->VRF(VRFCond).WaterCondVolFlowRate * rho; InitComponentNodes(state, @@ -6344,8 +6343,8 @@ void InitVRF(EnergyPlusData &state, int const VRFTUNum, int const ZoneNum, bool Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate( state, "Coil:Heating:Water", state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilName, ErrorsFound); if (CoilMaxVolFlowRate != DataSizing::AutoSize) { - rho = state.dataPlnt->PlantLoop(state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilPlantLoc.loopNum) - .glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + rho = state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilPlantLoc.loop->glycol->getDensity( + state, Constant::HWInitConvTemp, RoutineName); state.dataHVACVarRefFlow->VRFTU(VRFTUNum).SuppHeatCoilFluidMaxFlow = CoilMaxVolFlowRate * rho; } } @@ -9001,11 +9000,8 @@ void VRFCondenserEquipment::SizeVRFCondenser(EnergyPlusData &state) PltSizCondNum = state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).PlantSizNum; } if (PltSizCondNum > 0) { - rho = state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum) - .glycol->getDensity(state, state.dataSize->PlantSizData(PltSizCondNum).ExitTemp, RoutineName); - - Cp = state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum) - .glycol->getSpecificHeat(state, state.dataSize->PlantSizData(PltSizCondNum).ExitTemp, RoutineName); + rho = this->SourcePlantLoc.loop->glycol->getDensity(state, state.dataSize->PlantSizData(PltSizCondNum).ExitTemp, RoutineName); + Cp = this->SourcePlantLoc.loop->glycol->getSpecificHeat(state, state.dataSize->PlantSizData(PltSizCondNum).ExitTemp, RoutineName); tmpCondVolFlowRate = max(this->CoolingCapacity, this->HeatingCapacity) / (state.dataSize->PlantSizData(PltSizCondNum).DeltaT * Cp * rho); if (this->HeatingCapacity != DataSizing::AutoSize && this->CoolingCapacity != DataSizing::AutoSize) { @@ -9017,7 +9013,7 @@ void VRFCondenserEquipment::SizeVRFCondenser(EnergyPlusData &state) this->WaterCondVolFlowRate); } - rho = state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); + rho = this->SourcePlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); this->WaterCondenserDesignMassFlow = this->WaterCondVolFlowRate * rho; PlantUtilities::InitComponentNodes( state, 0.0, this->WaterCondenserDesignMassFlow, this->CondenserNodeNum, this->CondenserOutletNodeNum); diff --git a/src/EnergyPlus/HWBaseboardRadiator.cc b/src/EnergyPlus/HWBaseboardRadiator.cc index c96605d2e73..d12847254db 100644 --- a/src/EnergyPlus/HWBaseboardRadiator.cc +++ b/src/EnergyPlus/HWBaseboardRadiator.cc @@ -884,7 +884,7 @@ namespace HWBaseboardRadiator { // Initialize WaterInletNode = HWBaseboard.WaterInletNode; - rho = state.dataPlnt->PlantLoop(HWBaseboard.plantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + rho = HWBaseboard.plantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); HWBaseboard.WaterMassFlowRateMax = rho * HWBaseboard.WaterVolFlowRateMax; @@ -892,8 +892,7 @@ namespace HWBaseboardRadiator { state.dataLoopNodes->Node(WaterInletNode).Temp = 60.0; - Cp = state.dataPlnt->PlantLoop(HWBaseboard.plantLoc.loopNum) - .glycol->getSpecificHeat(state, state.dataLoopNodes->Node(WaterInletNode).Temp, RoutineName); + Cp = HWBaseboard.plantLoc.loop->glycol->getSpecificHeat(state, state.dataLoopNodes->Node(WaterInletNode).Temp, RoutineName); state.dataLoopNodes->Node(WaterInletNode).Enthalpy = Cp * state.dataLoopNodes->Node(WaterInletNode).Temp; state.dataLoopNodes->Node(WaterInletNode).Quality = 0.0; @@ -1064,10 +1063,8 @@ namespace HWBaseboardRadiator { CheckZoneSizing(state, cCMO_BBRadiator_Water, hWBaseboard.Name); DesCoilLoad = RatedCapacityDes; if (DesCoilLoad >= HVAC::SmallLoad) { - Cp = state.dataPlnt->PlantLoop(hWBaseboard.plantLoc.loopNum) - .glycol->getSpecificHeat(state, Constant::HWInitConvTemp, RoutineName); - rho = - state.dataPlnt->PlantLoop(hWBaseboard.plantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + Cp = hWBaseboard.plantLoc.loop->glycol->getSpecificHeat(state, Constant::HWInitConvTemp, RoutineName); + rho = hWBaseboard.plantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); WaterVolFlowRateMaxDes = DesCoilLoad / (state.dataSize->PlantSizData(PltSizHeatNum).DeltaT * Cp * rho); } else { WaterVolFlowRateMaxDes = 0.0; @@ -1110,8 +1107,7 @@ namespace HWBaseboardRadiator { WaterMassFlowRateStd = hWBaseboard.WaterMassFlowRateStd; } else if (hWBaseboard.RatedCapacity == DataSizing::AutoSize || hWBaseboard.RatedCapacity == 0.0) { DesCoilLoad = RatedCapacityDes; - rho = - state.dataPlnt->PlantLoop(hWBaseboard.plantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineNameFull); + rho = hWBaseboard.plantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineNameFull); WaterMassFlowRateStd = hWBaseboard.WaterVolFlowRateMax * rho; } if (DesCoilLoad >= HVAC::SmallLoad) { @@ -1119,8 +1115,7 @@ namespace HWBaseboardRadiator { // Air mass flow rate is obtained from the following linear equation // m_dot = 0.0062 + 2.75e-05*q AirMassFlowRate = Constant + Coeff * DesCoilLoad; - Cp = - state.dataPlnt->PlantLoop(hWBaseboard.plantLoc.loopNum).glycol->getSpecificHeat(state, hWBaseboard.WaterTempAvg, RoutineName); + Cp = hWBaseboard.plantLoc.loop->glycol->getSpecificHeat(state, hWBaseboard.WaterTempAvg, RoutineName); WaterInletTempStd = (DesCoilLoad / (2.0 * WaterMassFlowRateStd * Cp)) + hWBaseboard.WaterTempAvg; WaterOutletTempStd = std::abs((2.0 * hWBaseboard.WaterTempAvg) - WaterInletTempStd); AirOutletTempStd = (DesCoilLoad / (AirMassFlowRate * CPAirStd)) + AirInletTempStd; @@ -1172,7 +1167,7 @@ namespace HWBaseboardRadiator { WaterMassFlowRateStd = hWBaseboard.WaterMassFlowRateStd; // m_dot = 0.0062 + 2.75e-05*q AirMassFlowRate = Constant + Coeff * DesCoilLoad; - Cp = state.dataPlnt->PlantLoop(hWBaseboard.plantLoc.loopNum).glycol->getSpecificHeat(state, hWBaseboard.WaterTempAvg, RoutineName); + Cp = hWBaseboard.plantLoc.loop->glycol->getSpecificHeat(state, hWBaseboard.WaterTempAvg, RoutineName); WaterInletTempStd = (DesCoilLoad / (2.0 * WaterMassFlowRateStd * Cp)) + hWBaseboard.WaterTempAvg; WaterOutletTempStd = std::abs((2.0 * hWBaseboard.WaterTempAvg) - WaterInletTempStd); AirOutletTempStd = (DesCoilLoad / (AirMassFlowRate * CPAirStd)) + AirInletTempStd; @@ -1273,7 +1268,7 @@ namespace HWBaseboardRadiator { // Calculate air mass flow rate AirMassFlowRate = hWBaseboard.AirMassFlowRateStd * (WaterMassFlowRate / hWBaseboard.WaterMassFlowRateMax); CapacitanceAir = Psychrometrics::PsyCpAirFnW(hWBaseboard.AirInletHumRat) * AirMassFlowRate; - Cp = state.dataPlnt->PlantLoop(hWBaseboard.plantLoc.loopNum).glycol->getSpecificHeat(state, WaterInletTemp, RoutineName); + Cp = hWBaseboard.plantLoc.loop->glycol->getSpecificHeat(state, WaterInletTemp, RoutineName); CapacitanceWater = Cp * WaterMassFlowRate; CapacitanceMax = max(CapacitanceAir, CapacitanceWater); diff --git a/src/EnergyPlus/HeatPumpWaterToWaterCOOLING.cc b/src/EnergyPlus/HeatPumpWaterToWaterCOOLING.cc index 0cbc3bc1b85..d5c08b497bc 100644 --- a/src/EnergyPlus/HeatPumpWaterToWaterCOOLING.cc +++ b/src/EnergyPlus/HeatPumpWaterToWaterCOOLING.cc @@ -493,12 +493,12 @@ void GshpPeCoolingSpecs::initialize(EnergyPlusData &state) this->MustRun = true; this->beginEnvironFlag = false; - Real64 rho = state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); + Real64 rho = this->LoadPlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); this->LoadSideDesignMassFlow = this->LoadSideVolFlowRate * rho; PlantUtilities::InitComponentNodes(state, 0.0, this->LoadSideDesignMassFlow, this->LoadSideInletNodeNum, this->LoadSideOutletNodeNum); - rho = state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); + rho = this->SourcePlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); this->SourceSideDesignMassFlow = this->SourceSideVolFlowRate * rho; PlantUtilities::InitComponentNodes(state, 0.0, this->SourceSideDesignMassFlow, this->SourceSideInletNodeNum, this->SourceSideOutletNodeNum); @@ -657,10 +657,8 @@ void GshpPeCoolingSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad) initialQLoad = 0.0; IterationCount = 0; - CpSourceSide = - state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).glycol->getSpecificHeat(state, this->SourceSideWaterInletTemp, RoutineName); - - CpLoadSide = state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).glycol->getSpecificHeat(state, this->LoadSideWaterInletTemp, RoutineName); + CpSourceSide = this->SourcePlantLoc.loop->glycol->getSpecificHeat(state, this->SourceSideWaterInletTemp, RoutineName); + CpLoadSide = this->LoadPlantLoc.loop->glycol->getSpecificHeat(state, this->LoadSideWaterInletTemp, RoutineName); // Determine effectiveness of Load Side LoadSideEffect = 1.0 - std::exp(-this->LoadSideUACoeff / (CpLoadSide * this->LoadSideWaterMassFlowRate)); diff --git a/src/EnergyPlus/HeatPumpWaterToWaterHEATING.cc b/src/EnergyPlus/HeatPumpWaterToWaterHEATING.cc index 4977043350e..b1d9702c730 100644 --- a/src/EnergyPlus/HeatPumpWaterToWaterHEATING.cc +++ b/src/EnergyPlus/HeatPumpWaterToWaterHEATING.cc @@ -484,12 +484,12 @@ void GshpPeHeatingSpecs::initialize(EnergyPlusData &state) this->MustRun = true; this->beginEnvironFlag = false; - Real64 rho = state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); + Real64 rho = this->LoadPlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); this->LoadSideDesignMassFlow = this->LoadSideVolFlowRate * rho; PlantUtilities::InitComponentNodes(state, 0.0, this->LoadSideDesignMassFlow, this->LoadSideInletNodeNum, this->LoadSideOutletNodeNum); - rho = state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); + rho = this->SourcePlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); this->SourceSideDesignMassFlow = this->SourceSideVolFlowRate * rho; PlantUtilities::InitComponentNodes(state, 0.0, this->SourceSideDesignMassFlow, this->SourceSideInletNodeNum, this->SourceSideOutletNodeNum); @@ -612,11 +612,9 @@ void GshpPeHeatingSpecs::calculate(EnergyPlusData &state, Real64 &MyLoad) Real64 initialQLoad = 0.0; int IterationCount = 0; - Real64 CpSourceSide = - state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).glycol->getSpecificHeat(state, this->SourceSideWaterInletTemp, RoutineName); + Real64 CpSourceSide = this->SourcePlantLoc.loop->glycol->getSpecificHeat(state, this->SourceSideWaterInletTemp, RoutineName); - Real64 CpLoadSide = - state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).glycol->getSpecificHeat(state, this->LoadSideWaterInletTemp, RoutineName); + Real64 CpLoadSide = this->LoadPlantLoc.loop->glycol->getSpecificHeat(state, this->LoadSideWaterInletTemp, RoutineName); // Determine effectiveness of Source Side (the Evaporator in heating mode) Real64 SourceSideEffect = 1.0 - std::exp(-this->SourceSideUACoeff / (CpSourceSide * this->SourceSideWaterMassFlowRate)); diff --git a/src/EnergyPlus/HeatPumpWaterToWaterSimple.cc b/src/EnergyPlus/HeatPumpWaterToWaterSimple.cc index 69ce28304e1..d42a3db1db2 100644 --- a/src/EnergyPlus/HeatPumpWaterToWaterSimple.cc +++ b/src/EnergyPlus/HeatPumpWaterToWaterSimple.cc @@ -731,14 +731,14 @@ void GshpSpecs::InitWatertoWaterHP(EnergyPlusData &state, this->MustRun = true; if (this->WWHPType == DataPlant::PlantEquipmentType::HPWaterEFHeating) { - rho = state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + rho = this->LoadPlantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); this->LoadSideDesignMassFlow = this->RatedLoadVolFlowHeat * rho; - rho = state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); + rho = this->SourcePlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); this->SourceSideDesignMassFlow = this->RatedSourceVolFlowHeat * rho; } else if (this->WWHPType == DataPlant::PlantEquipmentType::HPWaterEFCooling) { - rho = state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); + rho = this->LoadPlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); this->LoadSideDesignMassFlow = this->RatedLoadVolFlowCool * rho; - rho = state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + rho = this->SourcePlantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); this->SourceSideDesignMassFlow = this->RatedSourceVolFlowCool * rho; } @@ -870,13 +870,14 @@ void GshpSpecs::sizeCoolingWaterToWaterHP(EnergyPlusData &state) // store flow rate right away regardless of PlantFirstSizesOkayToFinalize so that data are available this->RatedLoadVolFlowCool = tmpLoadSideVolFlowRate; } - Real64 rho = state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); - Real64 Cp = state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).glycol->getSpecificHeat(state, Constant::CWInitConvTemp, RoutineName); + Real64 rho = this->LoadPlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); + Real64 Cp = this->LoadPlantLoc.loop->glycol->getSpecificHeat(state, Constant::CWInitConvTemp, RoutineName); tmpCoolingCap = Cp * rho * state.dataSize->PlantSizData(pltLoadSizNum).DeltaT * tmpLoadSideVolFlowRate; + } else if (this->companionIdentified && this->RatedLoadVolFlowHeat > 0.0) { tmpLoadSideVolFlowRate = this->RatedLoadVolFlowHeat; - Real64 rho = state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); - Real64 Cp = state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).glycol->getSpecificHeat(state, Constant::CWInitConvTemp, RoutineName); + Real64 rho = this->LoadPlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); + Real64 Cp = this->LoadPlantLoc.loop->glycol->getSpecificHeat(state, Constant::CWInitConvTemp, RoutineName); tmpCoolingCap = Cp * rho * state.dataSize->PlantSizData(pltLoadSizNum).DeltaT * tmpLoadSideVolFlowRate; } else { if (this->ratedCapCoolWasAutoSized) { @@ -1048,8 +1049,8 @@ void GshpSpecs::sizeCoolingWaterToWaterHP(EnergyPlusData &state) } int pltSourceSizNum = state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).PlantSizNum; if (pltSourceSizNum > 0) { - Real64 rho = state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); - Real64 Cp = state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).glycol->getSpecificHeat(state, Constant::CWInitConvTemp, RoutineName); + Real64 rho = this->SourcePlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); + Real64 Cp = this->SourcePlantLoc.loop->glycol->getSpecificHeat(state, Constant::CWInitConvTemp, RoutineName); tmpSourceSideVolFlowRate = tmpCoolingCap * (1.0 + (1.0 / this->refCOP)) / (state.dataSize->PlantSizData(pltSourceSizNum).DeltaT * Cp * rho); } else { tmpSourceSideVolFlowRate = tmpLoadSideVolFlowRate; // set source side flow equal to load side flow, assumption @@ -1212,13 +1213,13 @@ void GshpSpecs::sizeHeatingWaterToWaterHP(EnergyPlusData &state) // PlantFirstSizesOkayToFinalize is true this->RatedLoadVolFlowHeat = tmpLoadSideVolFlowRate; } - Real64 rho = state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); - Real64 Cp = state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).glycol->getSpecificHeat(state, Constant::HWInitConvTemp, RoutineName); + Real64 rho = this->LoadPlantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + Real64 Cp = this->LoadPlantLoc.loop->glycol->getSpecificHeat(state, Constant::HWInitConvTemp, RoutineName); tmpHeatingCap = Cp * rho * state.dataSize->PlantSizData(pltLoadSizNum).DeltaT * tmpLoadSideVolFlowRate; } else if (this->companionIdentified && this->RatedLoadVolFlowCool > 0.0) { tmpLoadSideVolFlowRate = this->RatedLoadVolFlowCool; - Real64 rho = state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); - Real64 Cp = state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).glycol->getSpecificHeat(state, Constant::HWInitConvTemp, RoutineName); + Real64 rho = this->LoadPlantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + Real64 Cp = this->LoadPlantLoc.loop->glycol->getSpecificHeat(state, Constant::HWInitConvTemp, RoutineName); tmpHeatingCap = Cp * rho * state.dataSize->PlantSizData(pltLoadSizNum).DeltaT * tmpLoadSideVolFlowRate; } else { if (this->ratedCapHeatWasAutoSized) { @@ -1387,10 +1388,10 @@ void GshpSpecs::sizeHeatingWaterToWaterHP(EnergyPlusData &state) if (!this->ratedLoadVolFlowHeatWasAutoSized) { tmpLoadSideVolFlowRate = this->RatedLoadVolFlowHeat; } - int pltSourceSizNum = state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).PlantSizNum; + int pltSourceSizNum = this->SourcePlantLoc.loop->PlantSizNum; if (pltSourceSizNum > 0) { - Real64 rho = state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); - Real64 Cp = state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).glycol->getSpecificHeat(state, Constant::HWInitConvTemp, RoutineName); + Real64 rho = this->SourcePlantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + Real64 Cp = this->SourcePlantLoc.loop->glycol->getSpecificHeat(state, Constant::HWInitConvTemp, RoutineName); tmpSourceSideVolFlowRate = tmpHeatingCap * (1.0 - (1.0 / this->refCOP)) / (state.dataSize->PlantSizData(pltSourceSizNum).DeltaT * Cp * rho); } else { tmpSourceSideVolFlowRate = tmpLoadSideVolFlowRate; // set source side flow equal to load side flow, assumption @@ -1583,9 +1584,9 @@ void GshpSpecs::CalcWatertoWaterHPCooling(EnergyPlusData &state, Real64 const My return; } - rhoLoadSide = state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).glycol->getDensity(state, LoadSideInletTemp, RoutineName); + rhoLoadSide = this->LoadPlantLoc.loop->glycol->getDensity(state, LoadSideInletTemp, RoutineName); - rhoSourceSide = state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).glycol->getDensity(state, SourceSideInletTemp, RoutineName); + rhoSourceSide = this->SourcePlantLoc.loop->glycol->getDensity(state, SourceSideInletTemp, RoutineName); func1 = ((LoadSideInletTemp + CelsiustoKelvin) / Tref); func2 = ((SourceSideInletTemp + CelsiustoKelvin) / Tref); @@ -1650,9 +1651,9 @@ void GshpSpecs::CalcWatertoWaterHPCooling(EnergyPlusData &state, Real64 const My QSource *= PartLoadRatio; } - CpLoadSide = state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).glycol->getSpecificHeat(state, LoadSideInletTemp, RoutineName); + CpLoadSide = this->LoadPlantLoc.loop->glycol->getSpecificHeat(state, LoadSideInletTemp, RoutineName); - CpSourceSide = state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).glycol->getSpecificHeat(state, SourceSideInletTemp, RoutineName); + CpSourceSide = this->SourcePlantLoc.loop->glycol->getSpecificHeat(state, SourceSideInletTemp, RoutineName); LoadSideOutletTemp = LoadSideInletTemp - QLoad / (LoadSideMassFlowRate * CpLoadSide); SourceSideOutletTemp = SourceSideInletTemp + QSource / (SourceSideMassFlowRate * CpSourceSide); @@ -1731,9 +1732,9 @@ void GshpSpecs::CalcWatertoWaterHPHeating(EnergyPlusData &state, Real64 const My if (!this->MustRun) { return; } - rhoLoadSide = state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).glycol->getDensity(state, LoadSideInletTemp, RoutineName); + rhoLoadSide = this->LoadPlantLoc.loop->glycol->getDensity(state, LoadSideInletTemp, RoutineName); - rhoSourceSide = state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).glycol->getDensity(state, SourceSideInletTemp, RoutineName); + rhoSourceSide = this->SourcePlantLoc.loop->glycol->getDensity(state, SourceSideInletTemp, RoutineName); func1 = ((LoadSideInletTemp + CelsiustoKelvin) / Tref); func2 = ((SourceSideInletTemp + CelsiustoKelvin) / Tref); @@ -1797,9 +1798,9 @@ void GshpSpecs::CalcWatertoWaterHPHeating(EnergyPlusData &state, Real64 const My QSource *= PartLoadRatio; } - CpLoadSide = state.dataPlnt->PlantLoop(this->LoadPlantLoc.loopNum).glycol->getSpecificHeat(state, LoadSideInletTemp, RoutineName); + CpLoadSide = this->LoadPlantLoc.loop->glycol->getSpecificHeat(state, LoadSideInletTemp, RoutineName); - CpSourceSide = state.dataPlnt->PlantLoop(this->SourcePlantLoc.loopNum).glycol->getSpecificHeat(state, SourceSideInletTemp, RoutineName); + CpSourceSide = this->SourcePlantLoc.loop->glycol->getSpecificHeat(state, SourceSideInletTemp, RoutineName); LoadSideOutletTemp = LoadSideInletTemp + QLoad / (LoadSideMassFlowRate * CpLoadSide); SourceSideOutletTemp = SourceSideInletTemp - QSource / (SourceSideMassFlowRate * CpSourceSide); diff --git a/src/EnergyPlus/ICEngineElectricGenerator.cc b/src/EnergyPlus/ICEngineElectricGenerator.cc index fc52bdd7a42..993a3d2e621 100644 --- a/src/EnergyPlus/ICEngineElectricGenerator.cc +++ b/src/EnergyPlus/ICEngineElectricGenerator.cc @@ -748,7 +748,7 @@ namespace ICEngineElectricGenerator { HRecRatio = 1.0; Real64 HeatRecInTemp = state.dataLoopNodes->Node(this->HeatRecInletNodeNum).Temp; - Real64 HeatRecCp = state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).glycol->getSpecificHeat(state, HeatRecInTemp, RoutineName); + Real64 HeatRecCp = this->HRPlantLoc.loop->glycol->getSpecificHeat(state, HeatRecInTemp, RoutineName); // Don't divide by zero - Note This also results in no heat recovery when // design Mdot for Heat Recovery - Specified on Chiller Input - is zero @@ -872,7 +872,7 @@ namespace ICEngineElectricGenerator { if (this->MySizeAndNodeInitFlag && (!this->MyPlantScanFlag) && this->HeatRecActive) { // size mass flow rate - Real64 rho = state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, RoutineName); + Real64 rho = this->HRPlantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, RoutineName); this->DesignHeatRecMassFlowRate = rho * this->DesignHeatRecVolFlowRate; this->HeatRecMdotDesign = this->DesignHeatRecMassFlowRate; diff --git a/src/EnergyPlus/IceThermalStorage.cc b/src/EnergyPlus/IceThermalStorage.cc index 52ae8e73c73..e4271e0ecc3 100644 --- a/src/EnergyPlus/IceThermalStorage.cc +++ b/src/EnergyPlus/IceThermalStorage.cc @@ -229,7 +229,7 @@ namespace IceThermalStorage { } Real64 DemandMdot = this->DesignMassFlowRate; - Real64 Cp = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getSpecificHeat(state, TempIn, RoutineName); + Real64 Cp = this->plantLoc.loop->glycol->getSpecificHeat(state, TempIn, RoutineName); Real64 MyLoad2 = (DemandMdot * Cp * (TempIn - TempSetPt)); MyLoad = MyLoad2; @@ -376,7 +376,7 @@ namespace IceThermalStorage { } // Calculate the current load on the ice storage unit - Real64 Cp = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getSpecificHeat(state, TempIn, RoutineName); + Real64 Cp = this->plantLoc.loop->glycol->getSpecificHeat(state, TempIn, RoutineName); // Estimated load on the ice storage unit [W] Real64 LocalLoad = this->MassFlowRate * Cp * (TempIn - TempSetPt); @@ -1885,10 +1885,7 @@ namespace IceThermalStorage { // then based on MyLoad, new ITSMassFlowRate will be calculated. //---------------------------- - int loopNum = this->plantLoc.loopNum; - - Real64 CpFluid = - state.dataPlnt->PlantLoop(loopNum).glycol->getSpecificHeat(state, state.dataLoopNodes->Node(this->PltInletNodeNum).Temp, RoutineName); + Real64 CpFluid = this->plantLoc.loop->glycol->getSpecificHeat(state, state.dataLoopNodes->Node(this->PltInletNodeNum).Temp, RoutineName); // Calculate Umyload based on MyLoad from E+ Real64 Umyload = -myLoad * TimeInterval / this->ITSNomCap; diff --git a/src/EnergyPlus/LowTempRadiantSystem.cc b/src/EnergyPlus/LowTempRadiantSystem.cc index 41e6c7dbccd..f5a3f2bb578 100644 --- a/src/EnergyPlus/LowTempRadiantSystem.cc +++ b/src/EnergyPlus/LowTempRadiantSystem.cc @@ -2157,8 +2157,8 @@ namespace LowTempRadiantSystem { // set design mass flow rates if (state.dataLowTempRadSys->HydrRadSys(RadSysNum).HotWaterInNode > 0) { - rho = state.dataPlnt->PlantLoop(state.dataLowTempRadSys->HydrRadSys(RadSysNum).HWPlantLoc.loopNum) - .glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + rho = state.dataLowTempRadSys->HydrRadSys(RadSysNum).HWPlantLoc.loop->glycol->getDensity( + state, Constant::HWInitConvTemp, RoutineName); state.dataLowTempRadSys->HydrRadSys(RadSysNum).WaterFlowMaxHeat = rho * state.dataLowTempRadSys->HydrRadSys(RadSysNum).WaterVolFlowMaxHeat; InitComponentNodes(state, @@ -2168,8 +2168,8 @@ namespace LowTempRadiantSystem { state.dataLowTempRadSys->HydrRadSys(RadSysNum).HotWaterOutNode); } if (state.dataLowTempRadSys->HydrRadSys(RadSysNum).ColdWaterInNode > 0) { - rho = state.dataPlnt->PlantLoop(state.dataLowTempRadSys->HydrRadSys(RadSysNum).CWPlantLoc.loopNum) - .glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); + rho = state.dataLowTempRadSys->HydrRadSys(RadSysNum).CWPlantLoc.loop->glycol->getDensity( + state, Constant::CWInitConvTemp, RoutineName); state.dataLowTempRadSys->HydrRadSys(RadSysNum).WaterFlowMaxCool = rho * state.dataLowTempRadSys->HydrRadSys(RadSysNum).WaterVolFlowMaxCool; InitComponentNodes(state, @@ -2188,8 +2188,8 @@ namespace LowTempRadiantSystem { // set design mass flow rates if (state.dataLowTempRadSys->CFloRadSys(RadSysNum).HotWaterInNode > 0) { - rho = state.dataPlnt->PlantLoop(state.dataLowTempRadSys->CFloRadSys(RadSysNum).HWPlantLoc.loopNum) - .glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + rho = state.dataLowTempRadSys->CFloRadSys(RadSysNum).HWPlantLoc.loop->glycol->getDensity( + state, Constant::HWInitConvTemp, RoutineName); state.dataLowTempRadSys->CFloRadSys(RadSysNum).HotDesignWaterMassFlowRate = rho * state.dataLowTempRadSys->CFloRadSys(RadSysNum).WaterVolFlowMax; InitComponentNodes(state, @@ -2199,8 +2199,8 @@ namespace LowTempRadiantSystem { state.dataLowTempRadSys->CFloRadSys(RadSysNum).HotWaterOutNode); } if (state.dataLowTempRadSys->CFloRadSys(RadSysNum).ColdWaterInNode > 0) { - rho = state.dataPlnt->PlantLoop(state.dataLowTempRadSys->CFloRadSys(RadSysNum).CWPlantLoc.loopNum) - .glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); + rho = state.dataLowTempRadSys->CFloRadSys(RadSysNum).CWPlantLoc.loop->glycol->getDensity( + state, Constant::CWInitConvTemp, RoutineName); state.dataLowTempRadSys->CFloRadSys(RadSysNum).ColdDesignWaterMassFlowRate = rho * state.dataLowTempRadSys->CFloRadSys(RadSysNum).WaterVolFlowMax; InitComponentNodes(state, @@ -2909,10 +2909,10 @@ namespace LowTempRadiantSystem { ErrorsFound); if (PltSizHeatNum > 0) { if (DesCoilLoad >= SmallLoad) { - rho = state.dataPlnt->PlantLoop(state.dataLowTempRadSys->HydrRadSys(RadSysNum).HWPlantLoc.loopNum) - .glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); - Cp = state.dataPlnt->PlantLoop(state.dataLowTempRadSys->HydrRadSys(RadSysNum).HWPlantLoc.loopNum) - .glycol->getSpecificHeat(state, Constant::HWInitConvTemp, RoutineName); + rho = state.dataLowTempRadSys->HydrRadSys(RadSysNum).HWPlantLoc.loop->glycol->getDensity( + state, Constant::HWInitConvTemp, RoutineName); + Cp = state.dataLowTempRadSys->HydrRadSys(RadSysNum).HWPlantLoc.loop->glycol->getSpecificHeat( + state, Constant::HWInitConvTemp, RoutineName); WaterVolFlowMaxHeatDes = DesCoilLoad / (state.dataSize->PlantSizData(PltSizHeatNum).DeltaT * Cp * rho); } else { WaterVolFlowMaxHeatDes = 0.0; @@ -3080,10 +3080,10 @@ namespace LowTempRadiantSystem { ErrorsFound); if (PltSizCoolNum > 0) { if (DesCoilLoad >= SmallLoad) { - rho = state.dataPlnt->PlantLoop(state.dataLowTempRadSys->HydrRadSys(RadSysNum).CWPlantLoc.loopNum) - .glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); - Cp = state.dataPlnt->PlantLoop(state.dataLowTempRadSys->HydrRadSys(RadSysNum).CWPlantLoc.loopNum) - .glycol->getSpecificHeat(state, Constant::CWInitConvTemp, RoutineName); + rho = state.dataLowTempRadSys->HydrRadSys(RadSysNum).CWPlantLoc.loop->glycol->getDensity( + state, Constant::CWInitConvTemp, RoutineName); + Cp = state.dataLowTempRadSys->HydrRadSys(RadSysNum).CWPlantLoc.loop->glycol->getSpecificHeat( + state, Constant::CWInitConvTemp, RoutineName); WaterVolFlowMaxCoolDes = DesCoilLoad / (state.dataSize->PlantSizData(PltSizCoolNum).DeltaT * Cp * rho); } else { WaterVolFlowMaxCoolDes = 0.0; @@ -3252,10 +3252,10 @@ namespace LowTempRadiantSystem { } if (PltSizHeatNum > 0) { if (state.dataSize->FinalZoneSizing(state.dataSize->CurZoneEqNum).NonAirSysDesHeatLoad >= SmallLoad) { - rho = state.dataPlnt->PlantLoop(state.dataLowTempRadSys->CFloRadSys(RadSysNum).HWPlantLoc.loopNum) - .glycol->getDensity(state, Constant::HWInitConvTemp, "SizeLowTempRadiantSystem"); - Cp = state.dataPlnt->PlantLoop(state.dataLowTempRadSys->CFloRadSys(RadSysNum).HWPlantLoc.loopNum) - .glycol->getSpecificHeat(state, Constant::HWInitConvTemp, "SizeLowTempRadiantSystem"); + rho = state.dataLowTempRadSys->CFloRadSys(RadSysNum).HWPlantLoc.loop->glycol->getDensity( + state, Constant::HWInitConvTemp, "SizeLowTempRadiantSystem"); + Cp = state.dataLowTempRadSys->CFloRadSys(RadSysNum).HWPlantLoc.loop->glycol->getSpecificHeat( + state, Constant::HWInitConvTemp, "SizeLowTempRadiantSystem"); WaterVolFlowMaxHeatDes = state.dataSize->FinalZoneSizing(state.dataSize->CurZoneEqNum).NonAirSysDesHeatLoad / (state.dataSize->PlantSizData(PltSizHeatNum).DeltaT * Cp * rho); } else { @@ -3282,10 +3282,10 @@ namespace LowTempRadiantSystem { } if (PltSizCoolNum > 0) { if (state.dataSize->FinalZoneSizing(state.dataSize->CurZoneEqNum).NonAirSysDesCoolLoad >= SmallLoad) { - rho = state.dataPlnt->PlantLoop(state.dataLowTempRadSys->CFloRadSys(RadSysNum).CWPlantLoc.loopNum) - .glycol->getDensity(state, Constant::CWInitConvTemp, "SizeLowTempRadiantSystem"); - Cp = state.dataPlnt->PlantLoop(state.dataLowTempRadSys->CFloRadSys(RadSysNum).CWPlantLoc.loopNum) - .glycol->getSpecificHeat(state, Constant::CWInitConvTemp, "SizeLowTempRadiantSystem"); + rho = state.dataLowTempRadSys->CFloRadSys(RadSysNum).CWPlantLoc.loop->glycol->getDensity( + state, Constant::CWInitConvTemp, "SizeLowTempRadiantSystem"); + Cp = state.dataLowTempRadSys->CFloRadSys(RadSysNum).CWPlantLoc.loop->glycol->getSpecificHeat( + state, Constant::CWInitConvTemp, "SizeLowTempRadiantSystem"); WaterVolFlowMaxCoolDes = state.dataSize->FinalZoneSizing(state.dataSize->CurZoneEqNum).NonAirSysDesCoolLoad / (state.dataSize->PlantSizData(PltSizCoolNum).DeltaT * Cp * rho); } else { @@ -5319,7 +5319,7 @@ namespace LowTempRadiantSystem { waterOutletNode = this->HotWaterOutNode; waterMassFlow = Node(waterInletNode).MassFlowRate; - cpWater = state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).glycol->getSpecificHeat(state, Node(waterInletNode).Temp, RoutineName); + cpWater = this->HWPlantLoc.loop->glycol->getSpecificHeat(state, Node(waterInletNode).Temp, RoutineName); if (this->opMode == OpMode::Heat) { if ((cpWater > 0.0) && (waterMassFlow > 0.0)) { @@ -5342,7 +5342,7 @@ namespace LowTempRadiantSystem { waterOutletNode = this->ColdWaterOutNode; waterMassFlow = Node(waterInletNode).MassFlowRate; - cpWater = state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).glycol->getSpecificHeat(state, Node(waterInletNode).Temp, RoutineName); + cpWater = this->CWPlantLoc.loop->glycol->getSpecificHeat(state, Node(waterInletNode).Temp, RoutineName); if (this->opMode == OpMode::Cool) { if ((cpWater > 0.0) && (waterMassFlow > 0.0)) { @@ -5680,10 +5680,10 @@ namespace LowTempRadiantSystem { // arguments are glycol name, temperature, and concentration switch (this->opMode) { case OpMode::Heat: { - CpWater = state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum).glycol->getSpecificHeat(state, Temperature, RoutineName); + CpWater = this->HWPlantLoc.loop->glycol->getSpecificHeat(state, Temperature, RoutineName); } break; case OpMode::Cool: { - CpWater = state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).glycol->getSpecificHeat(state, Temperature, RoutineName); + CpWater = this->CWPlantLoc.loop->glycol->getSpecificHeat(state, Temperature, RoutineName); } break; default: { assert(false); @@ -5949,8 +5949,7 @@ namespace LowTempRadiantSystem { // in another routine, but just in case...). if (this->opMode == OpMode::Heat) { - cpFluid = state.dataPlnt->PlantLoop(this->HWPlantLoc.loopNum) - .glycol->getSpecificHeat(state, state.dataLoopNodes->Node(this->HotWaterInNode).Temp, routineName); + cpFluid = this->HWPlantLoc.loop->glycol->getSpecificHeat(state, state.dataLoopNodes->Node(this->HotWaterInNode).Temp, routineName); this->HeatPower = totalRadSysPower; if (this->PumpMassFlowRate > 0.0) { @@ -5960,8 +5959,7 @@ namespace LowTempRadiantSystem { } } else if (this->opMode == OpMode::Cool) { - cpFluid = state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum) - .glycol->getSpecificHeat(state, state.dataLoopNodes->Node(this->ColdWaterInNode).Temp, routineName); + cpFluid = this->CWPlantLoc.loop->glycol->getSpecificHeat(state, state.dataLoopNodes->Node(this->ColdWaterInNode).Temp, routineName); this->CoolPower = -totalRadSysPower; this->PumpInletTemp = this->WaterInletTemp - (this->PumpHeattoFluid / (this->PumpMassFlowRate * cpFluid)); diff --git a/src/EnergyPlus/MicroCHPElectricGenerator.cc b/src/EnergyPlus/MicroCHPElectricGenerator.cc index 074125f2fc1..b42cafa4ca1 100644 --- a/src/EnergyPlus/MicroCHPElectricGenerator.cc +++ b/src/EnergyPlus/MicroCHPElectricGenerator.cc @@ -711,8 +711,7 @@ void MicroCHPDataStruct::onInitLoopEquip(EnergyPlusData &state, const EnergyPlus { static constexpr std::string_view RoutineName("MicroCHPDataStruct::onInitLoopEquip"); - Real64 rho = state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum) - .glycol->getDensity(state, state.dataLoopNodes->Node(this->PlantInletNodeID).Temp, RoutineName); + Real64 rho = this->CWPlantLoc.loop->glycol->getDensity(state, state.dataLoopNodes->Node(this->PlantInletNodeID).Temp, RoutineName); if (this->A42Model.InternalFlowControl) { // got a curve this->PlantMassFlowRateMax = 2.0 * this->A42Model.WaterFlowCurve->value(state, this->A42Model.MaxElecPower, state.dataLoopNodes->Node(this->PlantInletNodeID).Temp); @@ -1170,7 +1169,7 @@ void MicroCHPDataStruct::CalcMicroCHPNoNormalizeGeneratorModel(EnergyPlusData &s Teng = FuncDetermineEngineTemp( TcwOut, this->A42Model.MCeng, this->A42Model.UAhx, this->A42Model.UAskin, thisAmbientTemp, Qgenss, this->A42Model.TengLast, dt); - Real64 Cp = state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).glycol->getSpecificHeat(state, TcwIn, RoutineName); + Real64 Cp = this->CWPlantLoc.loop->glycol->getSpecificHeat(state, TcwIn, RoutineName); TcwOut = FuncDetermineCoolantWaterExitTemp(TcwIn, this->A42Model.MCcw, this->A42Model.UAhx, MdotCW * Cp, Teng, this->A42Model.TempCWOutLast, dt); @@ -1389,7 +1388,7 @@ void MicroCHPDataStruct::CalcUpdateHeatRecovery(EnergyPlusData &state) const state.dataLoopNodes->Node(this->PlantOutletNodeID).Temp = this->A42Model.TcwOut; - Real64 Cp = state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).glycol->getSpecificHeat(state, this->A42Model.TcwIn, RoutineName); + Real64 Cp = this->CWPlantLoc.loop->glycol->getSpecificHeat(state, this->A42Model.TcwIn, RoutineName); state.dataLoopNodes->Node(this->PlantOutletNodeID).Enthalpy = this->A42Model.TcwOut * Cp; } @@ -1420,7 +1419,7 @@ void MicroCHPDataStruct::UpdateMicroCHPGeneratorRecords(EnergyPlusData &state) / this->A42Model.ACEnergyGen = this->A42Model.Pnet * state.dataHVACGlobal->TimeStepSysSec; // energy produced (J) this->A42Model.QdotHX = this->A42Model.UAhx * (this->A42Model.Teng - this->A42Model.TcwOut); // heat recovered rate (W) - Real64 Cp = state.dataPlnt->PlantLoop(this->CWPlantLoc.loopNum).glycol->getSpecificHeat(state, this->A42Model.TcwIn, RoutineName); + Real64 Cp = this->CWPlantLoc.loop->glycol->getSpecificHeat(state, this->A42Model.TcwIn, RoutineName); this->A42Model.QdotHR = this->PlantMassFlowRate * Cp * (this->A42Model.TcwOut - this->A42Model.TcwIn); this->A42Model.TotalHeatEnergyRec = this->A42Model.QdotHR * state.dataHVACGlobal->TimeStepSysSec; // heat recovered energy (J) diff --git a/src/EnergyPlus/MicroturbineElectricGenerator.cc b/src/EnergyPlus/MicroturbineElectricGenerator.cc index 1649d0a9bd2..4159934aa8d 100644 --- a/src/EnergyPlus/MicroturbineElectricGenerator.cc +++ b/src/EnergyPlus/MicroturbineElectricGenerator.cc @@ -1253,7 +1253,7 @@ void MTGeneratorSpecs::CalcMTGeneratorModel(EnergyPlusData &state, if (this->HeatRecActive) { HeatRecInTemp = state.dataLoopNodes->Node(this->HeatRecInletNodeNum).Temp; - HeatRecCp = state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).glycol->getSpecificHeat(state, HeatRecInTemp, RoutineName); + HeatRecCp = this->HRPlantLoc.loop->glycol->getSpecificHeat(state, HeatRecInTemp, RoutineName); heatRecMdot = state.dataLoopNodes->Node(this->HeatRecInletNodeNum).MassFlowRate; } else { HeatRecInTemp = 0.0; @@ -1583,7 +1583,7 @@ void MTGeneratorSpecs::CalcMTGeneratorModel(EnergyPlusData &state, // Calculate heat recovery rate modifier curve output (function of water [volumetric] flow rate) if (this->HeatRecRateFWaterFlowCurveNum > 0) { - Real64 rho = state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).glycol->getDensity(state, HeatRecInTemp, RoutineName); + Real64 rho = this->HRPlantLoc.loop->glycol->getDensity(state, HeatRecInTemp, RoutineName); // Heat recovery fluid flow rate (m3/s) Real64 HeatRecVolFlowRate = heatRecMdot / rho; @@ -1953,7 +1953,7 @@ void MTGeneratorSpecs::oneTimeInit(EnergyPlusData &state) if (this->MySizeAndNodeInitFlag && (!this->MyPlantScanFlag) && this->HeatRecActive) { // size mass flow rate - Real64 rho = state.dataPlnt->PlantLoop(this->HRPlantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, RoutineName); + Real64 rho = this->HRPlantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, RoutineName); this->DesignHeatRecMassFlowRate = rho * this->RefHeatRecVolFlowRate; this->HeatRecMaxMassFlowRate = rho * this->HeatRecMaxVolFlowRate; diff --git a/src/EnergyPlus/PhotovoltaicThermalCollectors.cc b/src/EnergyPlus/PhotovoltaicThermalCollectors.cc index 45de53afcca..8fefa459a49 100644 --- a/src/EnergyPlus/PhotovoltaicThermalCollectors.cc +++ b/src/EnergyPlus/PhotovoltaicThermalCollectors.cc @@ -705,7 +705,7 @@ namespace PhotovoltaicThermalCollectors { switch (this->WorkingFluidType) { case WorkingFluidEnum::LIQUID: { - Real64 rho = state.dataPlnt->PlantLoop(this->WPlantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + Real64 rho = this->WPlantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); this->MaxMassFlowRate = this->DesignVolFlowRate * rho; diff --git a/src/EnergyPlus/PipeHeatTransfer.cc b/src/EnergyPlus/PipeHeatTransfer.cc index 65558ef5d82..e6ca92c27a1 100644 --- a/src/EnergyPlus/PipeHeatTransfer.cc +++ b/src/EnergyPlus/PipeHeatTransfer.cc @@ -1100,9 +1100,8 @@ void PipeHTData::InitPipesHeatTransfer(EnergyPlusData &state, bool const FirstHV // Even though the loop eventually has no flow rate, it appears it initializes to a value, then converges to OFF // Thus, this is called at the beginning of every time step once. - this->FluidSpecHeat = - state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getSpecificHeat(state, state.dataPipeHT->nsvInletTemp, RoutineName); - this->FluidDensity = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getDensity(state, state.dataPipeHT->nsvInletTemp, RoutineName); + this->FluidSpecHeat = this->plantLoc.loop->glycol->getSpecificHeat(state, state.dataPipeHT->nsvInletTemp, RoutineName); + this->FluidDensity = this->plantLoc.loop->glycol->getDensity(state, state.dataPipeHT->nsvInletTemp, RoutineName); // At this point, for all Pipe:Interior objects we should zero out the energy and rate arrays this->FluidHeatLossRate = 0.0; diff --git a/src/EnergyPlus/Plant/LoopSide.cc b/src/EnergyPlus/Plant/LoopSide.cc index a9f18bebb13..8f2b4557244 100644 --- a/src/EnergyPlus/Plant/LoopSide.cc +++ b/src/EnergyPlus/Plant/LoopSide.cc @@ -1727,6 +1727,11 @@ namespace DataPlant { auto &this_comp(branch.Comp(CompCounter)); PlantLocation this_plantLoc = {this->plantLoc.loopNum, this->plantLoc.loopSideNum, BranchCounter, CompCounter}; + this_plantLoc.loop = &state.dataPlnt->PlantLoop(this_plantLoc.loopNum); + this_plantLoc.side = &this_plantLoc.loop->LoopSide(this_plantLoc.loopSideNum); + this_plantLoc.branch = &this_plantLoc.side->Branch(this_plantLoc.branchNum); + this_plantLoc.comp = &this_plantLoc.branch->Comp(this_plantLoc.compNum); + DataPlant::OpScheme const CurOpSchemeType(this_comp.CurOpSchemeType); switch (CurOpSchemeType) { diff --git a/src/EnergyPlus/PlantComponentTemperatureSources.cc b/src/EnergyPlus/PlantComponentTemperatureSources.cc index e98a0db25f3..8d015bc7881 100644 --- a/src/EnergyPlus/PlantComponentTemperatureSources.cc +++ b/src/EnergyPlus/PlantComponentTemperatureSources.cc @@ -132,7 +132,7 @@ namespace PlantComponentTemperatureSources { // Initialize critical Demand Side Variables at the beginning of each environment if (this->MyEnvironFlag && state.dataGlobal->BeginEnvrnFlag && (state.dataPlnt->PlantFirstSizesOkayToFinalize)) { - Real64 rho = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, RoutineName); + Real64 rho = this->plantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, RoutineName); this->MassFlowRateMax = this->DesVolFlowRate * rho; PlantUtilities::InitComponentNodes(state, 0.0, this->MassFlowRateMax, this->InletNodeNum, this->OutletNodeNum); @@ -150,7 +150,7 @@ namespace PlantComponentTemperatureSources { } // Calculate specific heat - Real64 cp = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getSpecificHeat(state, this->BoundaryTemp, RoutineName); + Real64 cp = this->plantLoc.loop->glycol->getSpecificHeat(state, this->BoundaryTemp, RoutineName); // Calculate deltaT Real64 delta_temp = this->BoundaryTemp - this->InletTemp; @@ -360,7 +360,7 @@ namespace PlantComponentTemperatureSources { if (this->MassFlowRate > 0.0) { this->OutletTemp = this->BoundaryTemp; - Real64 Cp = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getSpecificHeat(state, this->BoundaryTemp, RoutineName); + Real64 Cp = this->plantLoc.loop->glycol->getSpecificHeat(state, this->BoundaryTemp, RoutineName); this->HeatRate = this->MassFlowRate * Cp * (this->OutletTemp - this->InletTemp); this->HeatEnergy = this->HeatRate * state.dataHVACGlobal->TimeStepSysSec; } else { diff --git a/src/EnergyPlus/PlantCondLoopOperation.cc b/src/EnergyPlus/PlantCondLoopOperation.cc index 93bbfe7b924..6c09ea88af2 100644 --- a/src/EnergyPlus/PlantCondLoopOperation.cc +++ b/src/EnergyPlus/PlantCondLoopOperation.cc @@ -3058,11 +3058,22 @@ void DistributePlantLoad(EnergyPlusData &state, ChangeInLoad = std::abs(RemLoopDemand); } + PlantLocation plantLoc; + plantLoc.loopNum = LoopNum; + plantLoc.loopSideNum = LoopSideNum; + plantLoc.branchNum = BranchNum; + plantLoc.compNum = CompNum; + + plantLoc.loop = &state.dataPlnt->PlantLoop(LoopNum); + plantLoc.side = &plantLoc.loop->LoopSide(LoopSideNum); + plantLoc.branch = &plantLoc.side->Branch(BranchNum); + plantLoc.comp = &plantLoc.branch->Comp(CompNum); + AdjustChangeInLoadForLastStageUpperRangeLimit(state, LoopNum, CurSchemePtr, ListPtr, ChangeInLoad); - AdjustChangeInLoadByEMSControls(state, {LoopNum, LoopSideNum, BranchNum, CompNum}, ChangeInLoad); + AdjustChangeInLoadByEMSControls(state, plantLoc, ChangeInLoad); - AdjustChangeInLoadByHowServed(state, {LoopNum, LoopSideNum, BranchNum, CompNum}, ChangeInLoad); + AdjustChangeInLoadByHowServed(state, plantLoc, ChangeInLoad); ChangeInLoad = max(0.0, ChangeInLoad); this_component.MyLoad = sign(ChangeInLoad, RemLoopDemand); @@ -3149,11 +3160,22 @@ void DistributePlantLoad(EnergyPlusData &state, ChangeInLoad = std::abs(RemLoopDemand); } + PlantLocation plantLoc; + plantLoc.loopNum = LoopNum; + plantLoc.loopSideNum = LoopSideNum; + plantLoc.branchNum = BranchNum; + plantLoc.compNum = CompNum; + + plantLoc.loop = &state.dataPlnt->PlantLoop(LoopNum); + plantLoc.side = &plantLoc.loop->LoopSide(LoopSideNum); + plantLoc.branch = &plantLoc.side->Branch(BranchNum); + plantLoc.comp = &plantLoc.branch->Comp(CompNum); + AdjustChangeInLoadForLastStageUpperRangeLimit(state, LoopNum, CurSchemePtr, ListPtr, ChangeInLoad); - AdjustChangeInLoadByEMSControls(state, {LoopNum, LoopSideNum, BranchNum, CompNum}, ChangeInLoad); + AdjustChangeInLoadByEMSControls(state, plantLoc, ChangeInLoad); - AdjustChangeInLoadByHowServed(state, {LoopNum, LoopSideNum, BranchNum, CompNum}, ChangeInLoad); + AdjustChangeInLoadByHowServed(state, plantLoc, ChangeInLoad); ChangeInLoad = max(0.0, ChangeInLoad); this_component.MyLoad = sign(ChangeInLoad, RemLoopDemand); @@ -3205,11 +3227,22 @@ void DistributePlantLoad(EnergyPlusData &state, ChangeInLoad = std::abs(RemLoopDemand); } + PlantLocation plantLoc; + plantLoc.loopNum = LoopNum; + plantLoc.loopSideNum = LoopSideNum; + plantLoc.branchNum = BranchNum; + plantLoc.compNum = CompNum; + + plantLoc.loop = &state.dataPlnt->PlantLoop(LoopNum); + plantLoc.side = &plantLoc.loop->LoopSide(LoopSideNum); + plantLoc.branch = &plantLoc.side->Branch(BranchNum); + plantLoc.comp = &plantLoc.branch->Comp(CompNum); + AdjustChangeInLoadForLastStageUpperRangeLimit(state, LoopNum, CurSchemePtr, ListPtr, ChangeInLoad); - AdjustChangeInLoadByEMSControls(state, {LoopNum, LoopSideNum, BranchNum, CompNum}, ChangeInLoad); + AdjustChangeInLoadByEMSControls(state, plantLoc, ChangeInLoad); - AdjustChangeInLoadByHowServed(state, {LoopNum, LoopSideNum, BranchNum, CompNum}, ChangeInLoad); + AdjustChangeInLoadByHowServed(state, plantLoc, ChangeInLoad); ChangeInLoad = max(0.0, ChangeInLoad); this_component.MyLoad = sign(ChangeInLoad, RemLoopDemand); RemLoopDemand -= sign(ChangeInLoad, RemLoopDemand); @@ -3335,11 +3368,22 @@ void DistributePlantLoad(EnergyPlusData &state, ChangeInLoad = std::abs(RemLoopDemand); } + PlantLocation plantLoc; + plantLoc.loopNum = LoopNum; + plantLoc.loopSideNum = LoopSideNum; + plantLoc.branchNum = BranchNum; + plantLoc.compNum = CompNum; + + plantLoc.loop = &state.dataPlnt->PlantLoop(LoopNum); + plantLoc.side = &plantLoc.loop->LoopSide(LoopSideNum); + plantLoc.branch = &plantLoc.side->Branch(BranchNum); + plantLoc.comp = &plantLoc.branch->Comp(CompNum); + AdjustChangeInLoadForLastStageUpperRangeLimit(state, LoopNum, CurSchemePtr, ListPtr, ChangeInLoad); - AdjustChangeInLoadByEMSControls(state, {LoopNum, LoopSideNum, BranchNum, CompNum}, ChangeInLoad); + AdjustChangeInLoadByEMSControls(state, plantLoc, ChangeInLoad); - AdjustChangeInLoadByHowServed(state, {LoopNum, LoopSideNum, BranchNum, CompNum}, ChangeInLoad); + AdjustChangeInLoadByHowServed(state, plantLoc, ChangeInLoad); ChangeInLoad = max(0.0, ChangeInLoad); @@ -3426,11 +3470,22 @@ void DistributePlantLoad(EnergyPlusData &state, ChangeInLoad = std::abs(RemLoopDemand); } + PlantLocation plantLoc; + plantLoc.loopNum = LoopNum; + plantLoc.loopSideNum = LoopSideNum; + plantLoc.branchNum = BranchNum; + plantLoc.compNum = CompNum; + + plantLoc.loop = &state.dataPlnt->PlantLoop(LoopNum); + plantLoc.side = &plantLoc.loop->LoopSide(LoopSideNum); + plantLoc.branch = &plantLoc.side->Branch(BranchNum); + plantLoc.comp = &plantLoc.branch->Comp(CompNum); + AdjustChangeInLoadForLastStageUpperRangeLimit(state, LoopNum, CurSchemePtr, ListPtr, ChangeInLoad); - AdjustChangeInLoadByEMSControls(state, {LoopNum, LoopSideNum, BranchNum, CompNum}, ChangeInLoad); + AdjustChangeInLoadByEMSControls(state, plantLoc, ChangeInLoad); - AdjustChangeInLoadByHowServed(state, {LoopNum, LoopSideNum, BranchNum, CompNum}, ChangeInLoad); + AdjustChangeInLoadByHowServed(state, plantLoc, ChangeInLoad); ChangeInLoad = max(0.0, ChangeInLoad); @@ -3561,7 +3616,7 @@ void AdjustChangeInLoadByHowServed(EnergyPlusData &state, CurMassFlowRate = state.dataLoopNodes->Node(this_component.NodeNumIn).MassFlowRate; ToutLowLimit = this_component.MinOutletTemp; Tinlet = state.dataLoopNodes->Node(this_component.NodeNumIn).Temp; - CurSpecHeat = state.dataPlnt->PlantLoop(plantLoc.loopNum).glycol->getSpecificHeat(state, Tinlet, RoutineName); + CurSpecHeat = plantLoc.loop->glycol->getSpecificHeat(state, Tinlet, RoutineName); QdotTmp = CurMassFlowRate * CurSpecHeat * (Tinlet - ToutLowLimit); // !- Don't correct if Q is zero, as this could indicate a component which this hasn't been implemented or not yet turned on @@ -3645,7 +3700,7 @@ void AdjustChangeInLoadByHowServed(EnergyPlusData &state, CurMassFlowRate = state.dataLoopNodes->Node(this_component.NodeNumIn).MassFlowRate; ToutLowLimit = this_component.MinOutletTemp; Tinlet = state.dataLoopNodes->Node(this_component.NodeNumIn).Temp; - CurSpecHeat = state.dataPlnt->PlantLoop(plantLoc.loopNum).glycol->getSpecificHeat(state, Tinlet, RoutineName); + CurSpecHeat = plantLoc.loop->glycol->getSpecificHeat(state, Tinlet, RoutineName); QdotTmp = CurMassFlowRate * CurSpecHeat * (Tinlet - ToutLowLimit); // !- Don't correct if Q is zero, as this could indicate a component which this hasn't been implemented or not yet turned @@ -3662,7 +3717,7 @@ void AdjustChangeInLoadByHowServed(EnergyPlusData &state, CurMassFlowRate = state.dataLoopNodes->Node(this_component.NodeNumIn).MassFlowRate; ToutHiLimit = this_component.MaxOutletTemp; Tinlet = state.dataLoopNodes->Node(this_component.NodeNumIn).Temp; - CurSpecHeat = state.dataPlnt->PlantLoop(plantLoc.loopNum).glycol->getSpecificHeat(state, Tinlet, RoutineName); + CurSpecHeat = plantLoc.loop->glycol->getSpecificHeat(state, Tinlet, RoutineName); QdotTmp = CurMassFlowRate * CurSpecHeat * (ToutHiLimit - Tinlet); if (CurMassFlowRate > 0.0) { @@ -3744,12 +3799,12 @@ void FindCompSPLoad(EnergyPlusData &state, DemandNode = state.dataPlnt->PlantLoop(plantLoc.loopNum).OpScheme(OpSchemePtr).EquipList(ListPtr).Comp(CompPtr).DemandNodeNum; SetPtNode = state.dataPlnt->PlantLoop(plantLoc.loopNum).OpScheme(OpSchemePtr).EquipList(ListPtr).Comp(CompPtr).SetPointNodeNum; TempIn = state.dataLoopNodes->Node(DemandNode).Temp; - rho = state.dataPlnt->PlantLoop(plantLoc.loopNum).glycol->getDensity(state, TempIn, RoutineName); + rho = plantLoc.loop->glycol->getDensity(state, TempIn, RoutineName); - DemandMdot = state.dataPlnt->PlantLoop(plantLoc.loopNum).OpScheme(OpSchemePtr).EquipList(ListPtr).Comp(CompPtr).SetPointFlowRate * rho; + DemandMdot = plantLoc.loop->OpScheme(OpSchemePtr).EquipList(ListPtr).Comp(CompPtr).SetPointFlowRate * rho; // DemandMDot is a constant design flow rate, next based on actual current flow rate for accurate current demand? ActualMdot = state.dataLoopNodes->Node(DemandNode).MassFlowRate; - CurSpecHeat = state.dataPlnt->PlantLoop(plantLoc.loopNum).glycol->getSpecificHeat(state, TempIn, RoutineName); + CurSpecHeat = plantLoc.loop->glycol->getSpecificHeat(state, TempIn, RoutineName); if ((ActualMdot > 0.0) && (ActualMdot != DemandMdot)) { DemandMdot = ActualMdot; } diff --git a/src/EnergyPlus/PoweredInductionUnits.cc b/src/EnergyPlus/PoweredInductionUnits.cc index 8d78e010955..7059d93583d 100644 --- a/src/EnergyPlus/PoweredInductionUnits.cc +++ b/src/EnergyPlus/PoweredInductionUnits.cc @@ -808,7 +808,7 @@ void InitPIU(EnergyPlusData &state, if (thisPIU.HotControlNode > 0) { // plant upgrade note? why no separate handling of steam coil? add it ? // local plant fluid density - Real64 const rho = state.dataPlnt->PlantLoop(thisPIU.HWplantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + Real64 const rho = thisPIU.HWplantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); thisPIU.MaxHotWaterFlow = rho * thisPIU.MaxVolHotWaterFlow; thisPIU.MinHotWaterFlow = rho * thisPIU.MinVolHotWaterFlow; @@ -1291,10 +1291,8 @@ void SizePIU(EnergyPlusData &state, int const PIUNum) Real64 const DesMassFlow = state.dataEnvrn->StdRhoAir * TermUnitSizing(CurTermUnitSizingNum).AirVolFlow; DesCoilLoad = PsyCpAirFnW(CoilOutHumRat) * DesMassFlow * (CoilOutTemp - CoilInTemp); - Real64 const rho = state.dataPlnt->PlantLoop(thisPIU.HWplantLoc.loopNum) - .glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); - Real64 const Cp = state.dataPlnt->PlantLoop(thisPIU.HWplantLoc.loopNum) - .glycol->getSpecificHeat(state, Constant::HWInitConvTemp, RoutineName); + Real64 const rho = thisPIU.HWplantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + Real64 const Cp = thisPIU.HWplantLoc.loop->glycol->getSpecificHeat(state, Constant::HWInitConvTemp, RoutineName); MaxVolHotWaterFlowDes = DesCoilLoad / (state.dataSize->PlantSizData(PltSizHeatNum).DeltaT * Cp * rho); } else { diff --git a/src/EnergyPlus/RefrigeratedCase.cc b/src/EnergyPlus/RefrigeratedCase.cc index e85223272f8..731955cb305 100644 --- a/src/EnergyPlus/RefrigeratedCase.cc +++ b/src/EnergyPlus/RefrigeratedCase.cc @@ -10513,7 +10513,7 @@ void InitRefrigerationPlantConnections(EnergyPlusData &state) ShowFatalError(state, "InitRefrigerationPlantConnections: Program terminated due to previous condition(s)."); } - Real64 rho = state.dataPlnt->PlantLoop(Condenser(RefCondLoop).plantLoc.loopNum).glycol->getDensity(state, 20.0, RoutineName); + Real64 rho = Condenser(RefCondLoop).plantLoc.loop->glycol->getDensity(state, 20.0, RoutineName); if (Condenser(RefCondLoop).FlowType == CndsrFlowType::Constant) { Condenser(RefCondLoop).MassFlowRateMax = Condenser(RefCondLoop).DesVolFlowRate * rho; @@ -10542,7 +10542,7 @@ void InitRefrigerationPlantConnections(EnergyPlusData &state) ShowFatalError(state, "InitRefrigerationPlantConnections: Program terminated due to previous condition(s)."); } - Real64 rho = state.dataPlnt->PlantLoop(RefrigRack(RefCompRackLoop).plantLoc.loopNum).glycol->getDensity(state, 20.0, RoutineName); + Real64 rho = RefrigRack(RefCompRackLoop).plantLoc.loop->glycol->getDensity(state, 20.0, RoutineName); if (RefrigRack(RefCompRackLoop).FlowType == CndsrFlowType::Constant) { RefrigRack(RefCompRackLoop).MassFlowRateMax = RefrigRack(RefCompRackLoop).DesVolFlowRate * rho; @@ -10565,7 +10565,7 @@ void InitRefrigerationPlantConnections(EnergyPlusData &state) continue; } - Real64 rho = state.dataPlnt->PlantLoop(Condenser(RefCondLoop).plantLoc.loopNum).glycol->getDensity(state, 20.0, RoutineName); + Real64 rho = Condenser(RefCondLoop).plantLoc.loop->glycol->getDensity(state, 20.0, RoutineName); if (Condenser(RefCondLoop).FlowType == CndsrFlowType::Constant) { Condenser(RefCondLoop).MassFlowRateMax = Condenser(RefCondLoop).DesVolFlowRate * rho; @@ -10581,7 +10581,7 @@ void InitRefrigerationPlantConnections(EnergyPlusData &state) continue; } - Real64 rho = state.dataPlnt->PlantLoop(RefrigRack(RefCompRackLoop).plantLoc.loopNum).glycol->getDensity(state, 20.0, RoutineName); + Real64 rho = RefrigRack(RefCompRackLoop).plantLoc.loop->glycol->getDensity(state, 20.0, RoutineName); if (RefrigRack(RefCompRackLoop).FlowType == CndsrFlowType::Constant) { RefrigRack(RefCompRackLoop).MassFlowRateMax = RefrigRack(RefCompRackLoop).DesVolFlowRate * rho; @@ -11469,8 +11469,8 @@ void RefrigCondenserData::simulate(EnergyPlusData &state, // Make demand request on first HVAC iteration // get cooling fluid properties - Real64 rho = state.dataPlnt->PlantLoop(PlantLoc.loopNum).glycol->getDensity(state, this->InletTemp, RoutineName); - Real64 Cp = state.dataPlnt->PlantLoop(PlantLoc.loopNum).glycol->getSpecificHeat(state, this->InletTemp, RoutineName); + Real64 rho = PlantLoc.loop->glycol->getDensity(state, this->InletTemp, RoutineName); + Real64 Cp = PlantLoc.loop->glycol->getSpecificHeat(state, this->InletTemp, RoutineName); if (this->FlowType == CndsrFlowType::Variable && state.dataRefrigCase->TotalCondenserHeat > 0.0) { @@ -11621,8 +11621,8 @@ void RefrigRackData::simulate(EnergyPlusData &state, // Make demand request on first HVAC iteration // get cooling fluid properties - Real64 rho = state.dataPlnt->PlantLoop(PlantLoc.loopNum).glycol->getDensity(state, this->InletTemp, RoutineName); - Real64 Cp = state.dataPlnt->PlantLoop(PlantLoc.loopNum).glycol->getSpecificHeat(state, this->InletTemp, RoutineName); + Real64 rho = PlantLoc.loop->glycol->getDensity(state, this->InletTemp, RoutineName); + Real64 Cp = PlantLoc.loop->glycol->getSpecificHeat(state, this->InletTemp, RoutineName); if (this->FlowType == CndsrFlowType::Variable && state.dataRefrigCase->TotalCondenserHeat > 0.0) { this->OutletTemp = this->outletTempSched->getCurrentVal(); diff --git a/src/EnergyPlus/SingleDuct.cc b/src/EnergyPlus/SingleDuct.cc index 6f91b77e755..4b91a12a837 100644 --- a/src/EnergyPlus/SingleDuct.cc +++ b/src/EnergyPlus/SingleDuct.cc @@ -2137,7 +2137,7 @@ void SingleDuctAirTerminal::InitSys(EnergyPlusData &state, bool const FirstHVACI this->MassFlowDiff = 1.0e-10 * this->AirMassFlowRateMax; if (this->HWplantLoc.loopNum > 0 && this->ReheatComp_Num != HeatingCoilType::SteamAirHeating) { // protect early calls before plant is setup - rho = state.dataPlnt->PlantLoop(this->HWplantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + rho = this->HWplantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); } else { rho = 1000.0; } @@ -3086,11 +3086,9 @@ void SingleDuctAirTerminal::SizeSys(EnergyPlusData &state) (state.dataSingleDuct->ZoneDesTempSS - state.dataSingleDuct->CoilInTempSS); if (state.dataSingleDuct->DesCoilLoadSS >= SmallLoad) { - rho = - state.dataPlnt->PlantLoop(this->HWplantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + rho = this->HWplantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); - Cp = state.dataPlnt->PlantLoop(this->HWplantLoc.loopNum) - .glycol->getSpecificHeat(state, Constant::HWInitConvTemp, RoutineName); + Cp = this->HWplantLoc.loop->glycol->getSpecificHeat(state, Constant::HWInitConvTemp, RoutineName); MaxReheatWaterVolFlowDes = state.dataSingleDuct->DesCoilLoadSS / (state.dataSize->PlantSizData(PltSizHeatNum).DeltaT * Cp * rho); diff --git a/src/EnergyPlus/SurfaceGroundHeatExchanger.cc b/src/EnergyPlus/SurfaceGroundHeatExchanger.cc index adb6d7b73e3..58a5d6547eb 100644 --- a/src/EnergyPlus/SurfaceGroundHeatExchanger.cc +++ b/src/EnergyPlus/SurfaceGroundHeatExchanger.cc @@ -1164,7 +1164,7 @@ namespace SurfaceGroundHeatExchanger { this->InletTemp = max(this->InletTemp, 0.0); } } - CpWater = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getSpecificHeat(state, Temperature, RoutineName); + CpWater = this->plantLoc.loop->glycol->getSpecificHeat(state, Temperature, RoutineName); // Calculate the Reynold's number from RE=(4*Mdot)/(Pi*Mu*Diameter) ReD = 4.0 * WaterMassFlow / (Constant::Pi * MUactual * this->TubeDiameter * this->TubeCircuits); @@ -1378,7 +1378,7 @@ namespace SurfaceGroundHeatExchanger { this->InletTemp = max(this->InletTemp, 0.0); } - CpFluid = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getSpecificHeat(state, this->InletTemp, RoutineName); + CpFluid = this->plantLoc.loop->glycol->getSpecificHeat(state, this->InletTemp, RoutineName); SafeCopyPlantNode(state, this->InletNodeNum, this->OutletNodeNum); // check for flow @@ -1442,7 +1442,7 @@ namespace SurfaceGroundHeatExchanger { if (errFlag) { ShowFatalError(state, "InitSurfaceGroundHeatExchanger: Program terminated due to previous condition(s)."); } - rho = state.dataPlnt->PlantLoop(this->plantLoc.loopNum).glycol->getDensity(state, 0.0, RoutineName); + rho = this->plantLoc.loop->glycol->getDensity(state, 0.0, RoutineName); this->DesignMassFlowRate = Constant::Pi / 4.0 * pow_2(this->TubeDiameter) * DesignVelocity * rho * this->TubeCircuits; InitComponentNodes(state, 0.0, this->DesignMassFlowRate, this->InletNodeNum, this->OutletNodeNum); RegisterPlantCompDesignFlow(state, this->InletNodeNum, this->DesignMassFlowRate / rho); diff --git a/src/EnergyPlus/UnitVentilator.cc b/src/EnergyPlus/UnitVentilator.cc index 26a7e1b0cd3..6ff051421de 100644 --- a/src/EnergyPlus/UnitVentilator.cc +++ b/src/EnergyPlus/UnitVentilator.cc @@ -1111,8 +1111,7 @@ namespace UnitVentilator { if (unitVent.HCoilType == HeatCoilType::Water) { - Real64 rho = - state.dataPlnt->PlantLoop(unitVent.HWplantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + Real64 rho = unitVent.HWplantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); unitVent.MaxHotWaterFlow = rho * unitVent.MaxVolHotWaterFlow; unitVent.MinHotWaterFlow = rho * unitVent.MinVolHotWaterFlow; @@ -1132,7 +1131,7 @@ namespace UnitVentilator { } //(UnitVent(UnitVentNum)%HCoilPresent) if (unitVent.CCoilPresent) { // Only initialize these if a cooling coil is actually present - Real64 rho = state.dataPlnt->PlantLoop(unitVent.CWPlantLoc.loopNum).glycol->getDensity(state, 5.0, RoutineName); + Real64 rho = unitVent.CWPlantLoc.loop->glycol->getDensity(state, 5.0, RoutineName); unitVent.MaxColdWaterFlow = rho * unitVent.MaxVolColdWaterFlow; unitVent.MinColdWaterFlow = rho * unitVent.MinVolColdWaterFlow; @@ -1846,10 +1845,8 @@ namespace UnitVentilator { sizerHeatingCapacity.initializeWithinEP(state, CompType, CompName, PrintFlag, RoutineName); DesHeatingLoad = sizerHeatingCapacity.size(state, TempSize, errorsFound); } - rho = state.dataPlnt->PlantLoop(unitVent.HWplantLoc.loopNum) - .glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); - Cp = state.dataPlnt->PlantLoop(unitVent.HWplantLoc.loopNum) - .glycol->getSpecificHeat(state, Constant::HWInitConvTemp, RoutineName); + rho = unitVent.HWplantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + Cp = unitVent.HWplantLoc.loop->glycol->getSpecificHeat(state, Constant::HWInitConvTemp, RoutineName); MaxVolHotWaterFlowDes = DesHeatingLoad / (WaterCoilSizDeltaT * Cp * rho); } else { @@ -2121,8 +2118,8 @@ namespace UnitVentilator { sizerCoolingCapacity.initializeWithinEP(state, CompType, CompName, PrintFlag, RoutineName); DesCoolingLoad = sizerCoolingCapacity.size(state, TempSize, ErrorsFound); } - rho = state.dataPlnt->PlantLoop(unitVent.CWPlantLoc.loopNum).glycol->getDensity(state, 5., RoutineName); - Cp = state.dataPlnt->PlantLoop(unitVent.CWPlantLoc.loopNum).glycol->getSpecificHeat(state, 5., RoutineName); + rho = unitVent.CWPlantLoc.loop->glycol->getDensity(state, 5., RoutineName); + Cp = unitVent.CWPlantLoc.loop->glycol->getSpecificHeat(state, 5., RoutineName); MaxVolColdWaterFlowDes = DesCoolingLoad / (WaterCoilSizDeltaT * Cp * rho); if (MaxVolColdWaterFlowDes < 0.0) { diff --git a/src/EnergyPlus/UnitarySystem.cc b/src/EnergyPlus/UnitarySystem.cc index 123b403da79..53eaf86858e 100644 --- a/src/EnergyPlus/UnitarySystem.cc +++ b/src/EnergyPlus/UnitarySystem.cc @@ -608,8 +608,7 @@ namespace UnitarySystems { state, CoolingCoilType, CoolingCoilName, state.dataUnitarySystems->initUnitarySystemsErrorsFound); if (this->MaxCoolCoilFluidFlow > 0.0) { - Real64 rho = - state.dataPlnt->PlantLoop(this->CoolCoilPlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, routineName); + Real64 rho = this->CoolCoilPlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, routineName); this->MaxCoolCoilFluidFlow *= rho; } // fill outlet node for coil @@ -652,8 +651,7 @@ namespace UnitarySystems { state, HeatingCoilType, this->m_HeatingCoilName, state.dataUnitarySystems->initUnitarySystemsErrorsFound); if (this->MaxHeatCoilFluidFlow > 0.0) { - Real64 rho = state.dataPlnt->PlantLoop(this->HeatCoilPlantLoc.loopNum) - .glycol->getDensity(state, Constant::HWInitConvTemp, routineName); + Real64 rho = this->HeatCoilPlantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, routineName); this->MaxHeatCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate( state, HeatingCoilType, this->m_HeatingCoilName, state.dataUnitarySystems->initUnitarySystemsErrorsFound) * @@ -704,8 +702,7 @@ namespace UnitarySystems { state, "Coil:Heating:Water", this->m_SuppHeatCoilName, state.dataUnitarySystems->initUnitarySystemsErrorsFound); if (this->m_MaxSuppCoilFluidFlow > 0.0) { - Real64 rho = - state.dataPlnt->PlantLoop(this->m_SuppCoilPlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, routineName); + Real64 rho = this->m_SuppCoilPlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, routineName); this->m_MaxSuppCoilFluidFlow = WaterCoils::GetCoilMaxWaterFlowRate( state, "Coil:Heating:Water", this->m_SuppHeatCoilName, state.dataUnitarySystems->initUnitarySystemsErrorsFound) * @@ -772,7 +769,7 @@ namespace UnitarySystems { if ((this->m_HeatRecActive) && (!this->m_MyPlantScanFlag)) { - Real64 rho = state.dataPlnt->PlantLoop(this->m_HRPlantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, routineName); + Real64 rho = this->m_HRPlantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, routineName); this->m_DesignHeatRecMassFlowRate = this->m_DesignHRWaterVolumeFlow * rho; @@ -794,8 +791,7 @@ namespace UnitarySystems { Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate( state, CoolingCoilType, this->m_CoolingCoilName, state.dataUnitarySystems->initUnitarySystemsErrorsFound); if (CoilMaxVolFlowRate != DataSizing::AutoSize) { - Real64 rho = state.dataPlnt->PlantLoop(this->CoolCoilPlantLoc.loopNum) - .glycol->getDensity(state, Constant::CWInitConvTemp, routineName); + Real64 rho = this->CoolCoilPlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, routineName); this->MaxCoolCoilFluidFlow = CoilMaxVolFlowRate * rho; } } @@ -812,8 +808,7 @@ namespace UnitarySystems { Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate( state, "Coil:Heating:Water", this->m_HeatingCoilName, state.dataUnitarySystems->initUnitarySystemsErrorsFound); if (CoilMaxVolFlowRate != DataSizing::AutoSize) { - Real64 rho = state.dataPlnt->PlantLoop(this->HeatCoilPlantLoc.loopNum) - .glycol->getDensity(state, Constant::CWInitConvTemp, routineName); + Real64 rho = this->HeatCoilPlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, routineName); this->MaxHeatCoilFluidFlow = CoilMaxVolFlowRate * rho; } } @@ -847,8 +842,7 @@ namespace UnitarySystems { Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate( state, "Coil:Heating:Water", this->m_SuppHeatCoilName, state.dataUnitarySystems->initUnitarySystemsErrorsFound); if (CoilMaxVolFlowRate != DataSizing::AutoSize) { - Real64 rho = state.dataPlnt->PlantLoop(this->m_SuppCoilPlantLoc.loopNum) - .glycol->getDensity(state, Constant::CWInitConvTemp, routineName); + Real64 rho = this->m_SuppCoilPlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, routineName); this->m_MaxSuppCoilFluidFlow = CoilMaxVolFlowRate * rho; } } @@ -10471,8 +10465,7 @@ namespace UnitarySystems { Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", this->m_HeatingCoilName, errorsFound); if (CoilMaxVolFlowRate != DataSizing::AutoSize) { - Real64 rho = state.dataPlnt->PlantLoop(this->HeatCoilPlantLoc.loopNum) - .glycol->getDensity(state, Constant::CWInitConvTemp, routineName); + Real64 rho = this->HeatCoilPlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, routineName); this->MaxHeatCoilFluidFlow = CoilMaxVolFlowRate * rho; } } @@ -10504,8 +10497,7 @@ namespace UnitarySystems { Real64 CoilMaxVolFlowRate = WaterCoils::GetCoilMaxWaterFlowRate(state, "Coil:Heating:Water", this->m_SuppHeatCoilName, errorsFound); if (CoilMaxVolFlowRate != DataSizing::AutoSize) { - Real64 rho = state.dataPlnt->PlantLoop(this->m_SuppCoilPlantLoc.loopNum) - .glycol->getDensity(state, Constant::CWInitConvTemp, routineName); + Real64 rho = this->m_SuppCoilPlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, routineName); this->m_MaxSuppCoilFluidFlow = CoilMaxVolFlowRate * rho; } } @@ -16247,7 +16239,7 @@ namespace UnitarySystems { if (HeatRecMassFlowRate > 0.0) { - Real64 CpHeatRec = state.dataPlnt->PlantLoop(this->m_HRPlantLoc.loopNum).glycol->getSpecificHeat(state, HeatRecInletTemp, routineName); + Real64 CpHeatRec = this->m_HRPlantLoc.loop->glycol->getSpecificHeat(state, HeatRecInletTemp, routineName); HeatRecOutletTemp = QHeatRec / (HeatRecMassFlowRate * CpHeatRec) + HeatRecInletTemp; // coil model should be handling max outlet water temp (via limit to heat transfer) since heat rejection needs to be accounted for by the diff --git a/src/EnergyPlus/VariableSpeedCoils.cc b/src/EnergyPlus/VariableSpeedCoils.cc index e310b024857..04772a1faea 100644 --- a/src/EnergyPlus/VariableSpeedCoils.cc +++ b/src/EnergyPlus/VariableSpeedCoils.cc @@ -3418,8 +3418,8 @@ namespace VariableSpeedCoils { if (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit) { // need to set water info for WSHP varSpeedCoil.WaterMassFlowRate = varSpeedCoil.MSRatedWaterMassFlowRate(varSpeedCoil.NumOfSpeeds); varSpeedCoil.InletWaterTemp = RatedInletWaterTemp; // 85 F cooling mode - Real64 CpSource = state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum) - .glycol->getSpecificHeat(state, state.dataVariableSpeedCoils->SourceSideInletTemp, RoutineName); + Real64 CpSource = + varSpeedCoil.plantLoc.loop->glycol->getSpecificHeat(state, state.dataVariableSpeedCoils->SourceSideInletTemp, RoutineName); varSpeedCoil.InletWaterEnthalpy = varSpeedCoil.InletWaterTemp * CpSource; } @@ -3505,8 +3505,8 @@ namespace VariableSpeedCoils { if (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit) { // need to set water info for WSHP varSpeedCoil.WaterMassFlowRate = varSpeedCoil.MSRatedWaterMassFlowRate(varSpeedCoil.NumOfSpeeds); varSpeedCoil.InletWaterTemp = RatedInletWaterTempHeat; // 21.11C or 70F, heating mode - Real64 CpSource = state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum) - .glycol->getSpecificHeat(state, state.dataVariableSpeedCoils->SourceSideInletTemp, RoutineName); + Real64 CpSource = + varSpeedCoil.plantLoc.loop->glycol->getSpecificHeat(state, state.dataVariableSpeedCoils->SourceSideInletTemp, RoutineName); varSpeedCoil.InletWaterEnthalpy = varSpeedCoil.InletWaterTemp * CpSource; } @@ -3616,10 +3616,8 @@ namespace VariableSpeedCoils { (varSpeedCoil.VSCoilType == HVAC::Coil_CoolingWaterToAirHPVSEquationFit)) { WaterInletNode = varSpeedCoil.WaterInletNodeNum; - rho = state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum) - .glycol->getDensity(state, Constant::CWInitConvTemp, RoutineNameSimpleWatertoAirHP); - Cp = state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum) - .glycol->getSpecificHeat(state, Constant::CWInitConvTemp, RoutineNameSimpleWatertoAirHP); + rho = varSpeedCoil.plantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, RoutineNameSimpleWatertoAirHP); + Cp = varSpeedCoil.plantLoc.loop->glycol->getSpecificHeat(state, Constant::CWInitConvTemp, RoutineNameSimpleWatertoAirHP); // VarSpeedCoil(DXCoilNum)%DesignWaterMassFlowRate= & // rho * VarSpeedCoil(DXCoilNum)%RatedWaterVolFlowRate @@ -4545,10 +4543,8 @@ namespace VariableSpeedCoils { } if (PltSizNum > 0) { - rho = state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum) - .glycol->getDensity(state, state.dataSize->PlantSizData(PltSizNum).ExitTemp, RoutineNameAlt); - cp = state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum) - .glycol->getSpecificHeat(state, state.dataSize->PlantSizData(PltSizNum).ExitTemp, RoutineNameAlt); + rho = varSpeedCoil.plantLoc.loop->glycol->getDensity(state, state.dataSize->PlantSizData(PltSizNum).ExitTemp, RoutineNameAlt); + cp = varSpeedCoil.plantLoc.loop->glycol->getSpecificHeat(state, state.dataSize->PlantSizData(PltSizNum).ExitTemp, RoutineNameAlt); if (varSpeedCoil.VSCoilType == HVAC::Coil_HeatingWaterToAirHPVSEquationFit || varSpeedCoil.VSCoilType == HVAC::Coil_HeatingAirToAirVariableSpeed) { @@ -4680,7 +4676,7 @@ namespace VariableSpeedCoils { if (PltSizNum > 0) { rhoW = rho; } else { - rhoW = state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum).glycol->getDensity(state, RatedSourceTempCool, RoutineName); + rhoW = varSpeedCoil.plantLoc.loop->glycol->getDensity(state, RatedSourceTempCool, RoutineName); } varSpeedCoil.RatedWaterMassFlowRate = varSpeedCoil.RatedWaterVolFlowRate * rhoW; @@ -5291,8 +5287,8 @@ namespace VariableSpeedCoils { state.dataVariableSpeedCoils->SourceSideMassFlowRate = varSpeedCoil.WaterMassFlowRate; state.dataVariableSpeedCoils->SourceSideInletTemp = varSpeedCoil.InletWaterTemp; state.dataVariableSpeedCoils->SourceSideInletEnth = varSpeedCoil.InletWaterEnthalpy; - CpSource = state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum) - .glycol->getSpecificHeat(state, state.dataVariableSpeedCoils->SourceSideInletTemp, RoutineNameSourceSideInletTemp); + CpSource = varSpeedCoil.plantLoc.loop->glycol->getSpecificHeat( + state, state.dataVariableSpeedCoils->SourceSideInletTemp, RoutineNameSourceSideInletTemp); } // Check for flows, do not perform simulation if no flow in load side or source side. @@ -6442,8 +6438,8 @@ namespace VariableSpeedCoils { state.dataVariableSpeedCoils->SourceSideMassFlowRate = varSpeedCoil.WaterMassFlowRate; state.dataVariableSpeedCoils->SourceSideInletTemp = varSpeedCoil.InletWaterTemp; state.dataVariableSpeedCoils->SourceSideInletEnth = varSpeedCoil.InletWaterEnthalpy; - CpSource = state.dataPlnt->PlantLoop(varSpeedCoil.plantLoc.loopNum) - .glycol->getSpecificHeat(state, state.dataVariableSpeedCoils->SourceSideInletTemp, RoutineNameSourceSideInletTemp); + CpSource = varSpeedCoil.plantLoc.loop->glycol->getSpecificHeat( + state, state.dataVariableSpeedCoils->SourceSideInletTemp, RoutineNameSourceSideInletTemp); } // Check for flows, do not perform simulation if no flow in load side or source side. diff --git a/src/EnergyPlus/VentilatedSlab.cc b/src/EnergyPlus/VentilatedSlab.cc index febfde9c299..8ea9f6226fd 100644 --- a/src/EnergyPlus/VentilatedSlab.cc +++ b/src/EnergyPlus/VentilatedSlab.cc @@ -1568,7 +1568,7 @@ namespace VentilatedSlab { if (ventSlab.heatingCoilType == DataPlant::PlantEquipmentType::CoilWaterSimpleHeating && !state.dataVentilatedSlab->MyPlantScanFlag(Item)) { - rho = state.dataPlnt->PlantLoop(ventSlab.HWPlantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + rho = ventSlab.HWPlantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); ventSlab.MaxHotWaterFlow = rho * ventSlab.MaxVolHotWaterFlow; ventSlab.MinHotWaterFlow = rho * ventSlab.MinVolHotWaterFlow; @@ -1592,7 +1592,7 @@ namespace VentilatedSlab { // Only initialize these if a cooling coil is actually present if ((ventSlab.coolingCoilType == DataPlant::PlantEquipmentType::CoilWaterCooling) || (ventSlab.coolingCoilType == DataPlant::PlantEquipmentType::CoilWaterDetailedFlatCooling)) { - rho = state.dataPlnt->PlantLoop(ventSlab.CWPlantLoc.loopNum).glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); + rho = ventSlab.CWPlantLoc.loop->glycol->getDensity(state, Constant::CWInitConvTemp, RoutineName); ventSlab.MaxColdWaterFlow = rho * ventSlab.MaxVolColdWaterFlow; ventSlab.MinColdWaterFlow = rho * ventSlab.MinVolColdWaterFlow; PlantUtilities::InitComponentNodes( @@ -2052,10 +2052,8 @@ namespace VentilatedSlab { sizerHeatingCapacity.initializeWithinEP(state, CompType, CompName, PrintFlag, RoutineName); DesCoilLoad = sizerHeatingCapacity.size(state, TempSize, ErrorsFound); } - rho = state.dataPlnt->PlantLoop(ventSlab.HWPlantLoc.loopNum) - .glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); - Cp = state.dataPlnt->PlantLoop(ventSlab.HWPlantLoc.loopNum) - .glycol->getSpecificHeat(state, Constant::HWInitConvTemp, RoutineName); + rho = ventSlab.HWPlantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + Cp = ventSlab.HWPlantLoc.loop->glycol->getSpecificHeat(state, Constant::HWInitConvTemp, RoutineName); MaxVolHotWaterFlowDes = DesCoilLoad / (WaterCoilSizDeltaT * Cp * rho); } else { MaxVolHotWaterFlowDes = 0.0; @@ -2309,8 +2307,8 @@ namespace VentilatedSlab { sizerCoolingCapacity.initializeWithinEP(state, CompType, CompName, PrintFlag, RoutineName); DesCoilLoad = sizerCoolingCapacity.size(state, TempSize, ErrorsFound); } - rho = state.dataPlnt->PlantLoop(ventSlab.CWPlantLoc.loopNum).glycol->getDensity(state, 5., RoutineName); - Cp = state.dataPlnt->PlantLoop(ventSlab.CWPlantLoc.loopNum).glycol->getSpecificHeat(state, 5., RoutineName); + rho = ventSlab.CWPlantLoc.loop->glycol->getDensity(state, 5., RoutineName); + Cp = ventSlab.CWPlantLoc.loop->glycol->getSpecificHeat(state, 5., RoutineName); MaxVolColdWaterFlowDes = DesCoilLoad / (WaterCoilSizDeltaT * Cp * rho); } else { MaxVolColdWaterFlowDes = 0.0; diff --git a/src/EnergyPlus/WaterCoils.cc b/src/EnergyPlus/WaterCoils.cc index 10f6e4598c9..992525cda57 100644 --- a/src/EnergyPlus/WaterCoils.cc +++ b/src/EnergyPlus/WaterCoils.cc @@ -1086,7 +1086,7 @@ void InitWaterCoil(EnergyPlusData &state, int const CoilNum, bool const FirstHVA // Do the Begin Environment initializations if (state.dataGlobal->BeginEnvrnFlag && state.dataWaterCoils->MyEnvrnFlag(CoilNum)) { - rho = state.dataPlnt->PlantLoop(waterCoil.WaterPlantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, RoutineName); + rho = waterCoil.WaterPlantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, RoutineName); // Initialize all report variables to a known state at beginning of simulation waterCoil.TotWaterHeatingCoilEnergy = 0.0; waterCoil.TotWaterCoolingCoilEnergy = 0.0; @@ -1108,7 +1108,7 @@ void InitWaterCoil(EnergyPlusData &state, int const CoilNum, bool const FirstHVA auto &waterInletNode = state.dataLoopNodes->Node(WaterInletNode); waterInletNode.Temp = 5.0; - Cp = state.dataPlnt->PlantLoop(waterCoil.WaterPlantLoc.loopNum).glycol->getSpecificHeat(state, waterInletNode.Temp, RoutineName); + Cp = waterCoil.WaterPlantLoc.loop->glycol->getSpecificHeat(state, waterInletNode.Temp, RoutineName); waterInletNode.Enthalpy = Cp * waterInletNode.Temp; waterInletNode.Quality = 0.0; @@ -1120,7 +1120,7 @@ void InitWaterCoil(EnergyPlusData &state, int const CoilNum, bool const FirstHVA auto &waterInletNode = state.dataLoopNodes->Node(WaterInletNode); waterInletNode.Temp = 60.0; - Cp = state.dataPlnt->PlantLoop(waterCoil.WaterPlantLoc.loopNum).glycol->getSpecificHeat(state, waterInletNode.Temp, RoutineName); + Cp = waterCoil.WaterPlantLoc.loop->glycol->getSpecificHeat(state, waterInletNode.Temp, RoutineName); waterInletNode.Enthalpy = Cp * waterInletNode.Temp; waterInletNode.Quality = 0.0; @@ -1308,8 +1308,7 @@ void InitWaterCoil(EnergyPlusData &state, int const CoilNum, bool const FirstHVA waterCoil.DesTotWaterCoilLoad = waterCoil.DesAirMassFlowRate * (DesInletAirEnth - DesOutletAirEnth); // Enthalpy of Water at Inlet design conditions - Cp = state.dataPlnt->PlantLoop(waterCoil.WaterPlantLoc.loopNum) - .glycol->getSpecificHeat(state, waterCoil.DesInletWaterTemp, RoutineName); + Cp = waterCoil.WaterPlantLoc.loop->glycol->getSpecificHeat(state, waterCoil.DesInletWaterTemp, RoutineName); DesOutletWaterTemp = waterCoil.DesInletWaterTemp + waterCoil.DesTotWaterCoilLoad / (waterCoil.MaxWaterMassFlowRate * Cp); @@ -1544,7 +1543,7 @@ void InitWaterCoil(EnergyPlusData &state, int const CoilNum, bool const FirstHVA waterCoil.InletAirMassFlowRate = state.dataEnvrn->StdRhoAir * waterCoil.DesAirVolFlowRate; CapacitanceAir = waterCoil.InletAirMassFlowRate * PsyCpAirFnW(waterCoil.InletAirHumRat); - Cp = state.dataPlnt->PlantLoop(waterCoil.WaterPlantLoc.loopNum).glycol->getSpecificHeat(state, waterCoil.InletWaterTemp, RoutineName); + Cp = waterCoil.WaterPlantLoc.loop->glycol->getSpecificHeat(state, waterCoil.InletWaterTemp, RoutineName); state.dataWaterCoils->CapacitanceWater = waterCoil.InletWaterMassFlowRate * Cp; state.dataWaterCoils->CMin = min(CapacitanceAir, state.dataWaterCoils->CapacitanceWater); @@ -1749,8 +1748,7 @@ void InitWaterCoil(EnergyPlusData &state, int const CoilNum, bool const FirstHVA state, waterCoil.DesInletAirTemp, waterCoil.DesInletAirHumRat, DataEnvironment::StdPressureSeaLevel, "InitWaterCoils"); waterCoil.InletWaterMassFlowRate = waterCoil.MaxWaterMassFlowRate; waterCoil.InletWaterTemp = waterCoil.DesInletWaterTemp; - Real64 cp = state.dataPlnt->PlantLoop(waterCoil.WaterPlantLoc.loopNum) - .glycol->getSpecificHeat(state, waterCoil.DesInletWaterTemp, "InitWaterCoil"); + Real64 cp = waterCoil.WaterPlantLoc.loop->glycol->getSpecificHeat(state, waterCoil.DesInletWaterTemp, "InitWaterCoil"); waterCoil.InletWaterEnthalpy = cp * waterCoil.InletWaterTemp; waterCoil.UACoilVariable = waterCoil.UACoil; @@ -2473,7 +2471,7 @@ void SizeWaterCoil(EnergyPlusData &state, int const CoilNum) state.dataSize->DataPltSizHeatNum = PltSizHeatNum; state.dataSize->DataWaterLoopNum = waterCoil.WaterPlantLoc.loopNum; - rho = state.dataPlnt->PlantLoop(waterCoil.WaterPlantLoc.loopNum).glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); + rho = waterCoil.WaterPlantLoc.loop->glycol->getDensity(state, Constant::HWInitConvTemp, RoutineName); Cp = state.dataPlnt->PlantLoop(state.dataSize->DataWaterLoopNum).glycol->getSpecificHeat(state, Constant::HWInitConvTemp, RoutineName); if (waterCoil.DesTotWaterCoilLoad > 0.0) { NomCapUserInp = true; @@ -2851,7 +2849,7 @@ void CalcSimpleHeatingCoil(EnergyPlusData &state, if (WaterMassFlowRate > DataBranchAirLoopPlant::MassFlowTolerance) { // If the coil is operating CapacitanceAir = PsyCpAirFnW(Win) * AirMassFlow; - Cp = state.dataPlnt->PlantLoop(waterCoil.WaterPlantLoc.loopNum).glycol->getSpecificHeat(state, TempWaterIn, RoutineName); + Cp = waterCoil.WaterPlantLoc.loop->glycol->getSpecificHeat(state, TempWaterIn, RoutineName); CapacitanceWater = Cp * WaterMassFlowRate; CapacitanceMin = min(CapacitanceAir, CapacitanceWater); CapacitanceMax = max(CapacitanceAir, CapacitanceWater); @@ -3129,7 +3127,7 @@ void CalcDetailFlatFinCoolingCoil(EnergyPlusData &state, // Ratio of secondary (fin) to total (secondary plus primary) surface areas FinToTotSurfAreaRatio = waterCoil.FinSurfArea / waterCoil.TotCoilOutsideSurfArea; // known water and air flow parameters: - rho = state.dataPlnt->PlantLoop(waterCoil.WaterPlantLoc.loopNum).glycol->getDensity(state, TempWaterIn, RoutineName); + rho = waterCoil.WaterPlantLoc.loop->glycol->getDensity(state, TempWaterIn, RoutineName); // water flow velocity - assuming number of water circuits = NumOfTubesPerRow TubeWaterVel = WaterMassFlowRate * 4.0 / (waterCoil.NumOfTubesPerRow * rho * Constant::Pi * waterCoil.TubeInsideDiam * waterCoil.TubeInsideDiam); @@ -3241,7 +3239,7 @@ void CalcDetailFlatFinCoolingCoil(EnergyPlusData &state, // dry coil outside thermal resistance = [1/UA] (dry coil) CoilToAirThermResistDrySurf = 1.0 / (waterCoil.TotCoilOutsideSurfArea * AirSideDrySurfFilmCoef * DryCoilEfficiency); // definitions made to simplify some of the expressions used below - Cp = state.dataPlnt->PlantLoop(waterCoil.WaterPlantLoc.loopNum).glycol->getSpecificHeat(state, TempWaterIn, RoutineName); + Cp = waterCoil.WaterPlantLoc.loop->glycol->getSpecificHeat(state, TempWaterIn, RoutineName); ScaledWaterSpecHeat = WaterMassFlowRate * Cp * ConvK / AirMassFlow; DryCoilCoeff1 = 1.0 / (AirMassFlow * MoistAirSpecificHeat) - 1.0 / (WaterMassFlowRate * Cp * ConvK); // perform initialisations for all wet solution @@ -3836,7 +3834,7 @@ void CoilCompletelyDry(EnergyPlusData &state, // Calculate air and water capacity rates CapacitanceAir = AirMassFlow * PsyCpAirFnW(waterCoil.InletAirHumRat); // Water Capacity Rate - Cp = state.dataPlnt->PlantLoop(waterCoil.WaterPlantLoc.loopNum).glycol->getSpecificHeat(state, WaterTempIn, RoutineName); + Cp = waterCoil.WaterPlantLoc.loop->glycol->getSpecificHeat(state, WaterTempIn, RoutineName); CapacitanceWater = WaterMassFlowRate * Cp; @@ -3970,7 +3968,7 @@ void CoilCompletelyWet(EnergyPlusData &state, // coil as counterflow enthalpy heat exchanger UACoilTotalEnth = 1.0 / (IntermediateCpSat * WaterSideResist + AirSideResist * PsyCpAirFnW(0.0)); CapacityRateAirWet = AirMassFlow; - Cp = state.dataPlnt->PlantLoop(waterCoil.WaterPlantLoc.loopNum).glycol->getSpecificHeat(state, WaterTempIn, RoutineName); + Cp = waterCoil.WaterPlantLoc.loop->glycol->getSpecificHeat(state, WaterTempIn, RoutineName); CapacityRateWaterWet = WaterMassFlowRate * (Cp / IntermediateCpSat); CoilOutletStreamCondition(state, CoilNum, @@ -6327,7 +6325,7 @@ void EstimateCoilInletWaterTemp(EnergyPlusData &state, } if (WaterMassFlowRate > DataBranchAirLoopPlant::MassFlowTolerance) { // if the coil is operating CapacitanceAir = PsyCpAirFnW(Win) * AirMassFlow; - Cp = state.dataPlnt->PlantLoop(waterCoil.WaterPlantLoc.loopNum).glycol->getSpecificHeat(state, TempWaterIn, RoutineName); + Cp = waterCoil.WaterPlantLoc.loop->glycol->getSpecificHeat(state, TempWaterIn, RoutineName); CapacitanceWater = Cp * WaterMassFlowRate; CapacitanceMin = min(CapacitanceAir, CapacitanceWater); CapacitanceMax = max(CapacitanceAir, CapacitanceWater); diff --git a/src/EnergyPlus/WaterThermalTanks.cc b/src/EnergyPlus/WaterThermalTanks.cc index 9565b4547a2..c98015f3a88 100644 --- a/src/EnergyPlus/WaterThermalTanks.cc +++ b/src/EnergyPlus/WaterThermalTanks.cc @@ -6029,7 +6029,7 @@ void WaterThermalTankData::SetupStratifiedNodes(EnergyPlusData &state) this->Node.allocate(NumNodes); Real64 rho; if ((this->UseSidePlantLoc.loopNum > 0) && allocated(state.dataPlnt->PlantLoop)) { - rho = state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, RoutineName); + rho = this->UseSidePlantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, RoutineName); } else { rho = this->water->getDensity(state, Constant::InitConvTemp, RoutineName); } @@ -6285,11 +6285,10 @@ void WaterThermalTankData::initialize(EnergyPlusData &state, bool const FirstHVA if (this->SetLoopIndexFlag && allocated(state.dataPlnt->PlantLoop)) { if ((this->UseInletNode > 0) && (this->HeatPumpNum == 0)) { - Real64 rho = - state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, GetTankInputString); + Real64 rho = this->UseSidePlantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, GetTankInputString); this->PlantUseMassFlowRateMax = this->UseDesignVolFlowRate * rho; this->Mass = this->Volume * rho; - this->UseSidePlantSizNum = state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).PlantSizNum; + this->UseSidePlantSizNum = this->UseSidePlantLoc.loop->PlantSizNum; if ((this->UseDesignVolFlowRateWasAutoSized) && (this->UseSidePlantSizNum == 0)) { ShowSevereError(state, format("InitWaterThermalTank: Did not find Sizing:Plant object for use side of plant thermal tank = {}", this->Name)); @@ -6297,8 +6296,7 @@ void WaterThermalTankData::initialize(EnergyPlusData &state, bool const FirstHVA } } if ((this->UseInletNode > 0) && (this->HeatPumpNum > 0)) { - Real64 rho = - state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, GetTankInputString); + Real64 rho = this->UseSidePlantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, GetTankInputString); this->PlantUseMassFlowRateMax = this->UseDesignVolFlowRate * rho; this->Mass = this->Volume * rho; this->UseSidePlantSizNum = state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).PlantSizNum; @@ -6309,10 +6307,9 @@ void WaterThermalTankData::initialize(EnergyPlusData &state, bool const FirstHVA } } if ((this->SourceInletNode > 0) && (this->DesuperheaterNum == 0) && (this->HeatPumpNum == 0)) { - Real64 rho = - state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, GetTankInputString); + Real64 rho = this->SrcSidePlantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, GetTankInputString); this->PlantSourceMassFlowRateMax = this->SourceDesignVolFlowRate * rho; - this->SourceSidePlantSizNum = state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).PlantSizNum; + this->SourceSidePlantSizNum = this->SrcSidePlantLoc.loop->PlantSizNum; if ((this->SourceDesignVolFlowRateWasAutoSized) && (this->SourceSidePlantSizNum == 0)) { ShowSevereError( state, format("InitWaterThermalTank: Did not find Sizing:Plant object for source side of plant thermal tank = {}", this->Name)); @@ -6373,8 +6370,7 @@ void WaterThermalTankData::initialize(EnergyPlusData &state, bool const FirstHVA // Clear node initial conditions if (this->UseInletNode > 0 && this->UseOutletNode > 0) { state.dataLoopNodes->Node(this->UseInletNode).Temp = 0.0; - Real64 rho = - state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, GetTankInputString); + Real64 rho = this->UseSidePlantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, GetTankInputString); this->MassFlowRateMin = this->VolFlowRateMin * rho; this->PlantUseMassFlowRateMax = this->UseDesignVolFlowRate * rho; PlantUtilities::InitComponentNodes(state, this->MassFlowRateMin, this->PlantUseMassFlowRateMax, this->UseInletNode, this->UseOutletNode); @@ -6387,8 +6383,7 @@ void WaterThermalTankData::initialize(EnergyPlusData &state, bool const FirstHVA } if ((this->SourceInletNode > 0) && (this->DesuperheaterNum == 0) && (this->HeatPumpNum == 0)) { - Real64 rho = - state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, GetTankInputString); + Real64 rho = this->SrcSidePlantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, GetTankInputString); this->PlantSourceMassFlowRateMax = this->SourceDesignVolFlowRate * rho; PlantUtilities::InitComponentNodes(state, 0.0, this->PlantSourceMassFlowRateMax, this->SourceInletNode, this->SourceOutletNode); @@ -7084,7 +7079,7 @@ void WaterThermalTankData::CalcWaterThermalTankMixed(EnergyPlusData &state) // W Real64 rho; if (this->UseSidePlantLoc.loopNum > 0) { - rho = state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).glycol->getDensity(state, TankTemp_loc, RoutineName); + rho = this->UseSidePlantLoc.loop->glycol->getDensity(state, TankTemp_loc, RoutineName); } else { rho = this->water->getDensity(state, TankTemp_loc, RoutineName); } @@ -7093,7 +7088,7 @@ void WaterThermalTankData::CalcWaterThermalTankMixed(EnergyPlusData &state) // W Real64 Cp; if (this->UseSidePlantLoc.loopNum > 0) { - Cp = state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).glycol->getSpecificHeat(state, TankTemp_loc, RoutineName); + Cp = this->UseSidePlantLoc.loop->glycol->getSpecificHeat(state, TankTemp_loc, RoutineName); } else { Cp = this->water->getSpecificHeat(state, TankTemp_loc, RoutineName); } @@ -7990,7 +7985,7 @@ void WaterThermalTankData::CalcWaterThermalTankStratified(EnergyPlusData &state) // Specific Heat of water (J/kg K) const Real64 Cp = [&] { if (this->UseSidePlantLoc.loopNum > 0) { - return state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).glycol->getSpecificHeat(state, this->TankTemp, RoutineName); + return this->UseSidePlantLoc.loop->glycol->getSpecificHeat(state, this->TankTemp, RoutineName); } return this->water->getSpecificHeat(state, this->TankTemp, RoutineName); }(); @@ -11207,8 +11202,7 @@ void WaterThermalTankData::SizeSupplySidePlantConnections(EnergyPlusData &state, PlantUtilities::RegisterPlantCompDesignFlow(state, this->UseInletNode, tmpUseDesignVolFlowRate); } - Real64 rho = - state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, RoutineName); + Real64 rho = this->UseSidePlantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, RoutineName); if (state.dataPlnt->PlantFirstSizesOkayToFinalize) { this->PlantUseMassFlowRateMax = this->UseDesignVolFlowRate * rho; } else { @@ -11223,7 +11217,7 @@ void WaterThermalTankData::SizeSupplySidePlantConnections(EnergyPlusData &state, PlantUtilities::RegisterPlantCompDesignFlow(state, this->UseInletNode, this->UseDesignVolFlowRate); Real64 rho; if (this->UseSidePlantLoc.loopNum > 0) { - rho = state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, RoutineName); + rho = this->UseSidePlantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, RoutineName); } else { rho = this->water->getDensity(state, Constant::InitConvTemp, RoutineName); } @@ -11264,8 +11258,7 @@ void WaterThermalTankData::SizeSupplySidePlantConnections(EnergyPlusData &state, } else { PlantUtilities::RegisterPlantCompDesignFlow(state, this->SourceInletNode, tmpSourceDesignVolFlowRate); } - Real64 rho = - state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, RoutineName); + Real64 rho = this->SrcSidePlantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, RoutineName); if (state.dataPlnt->PlantFirstSizesOkayToFinalize) { this->PlantSourceMassFlowRateMax = this->SourceDesignVolFlowRate * rho; } else { @@ -11280,7 +11273,7 @@ void WaterThermalTankData::SizeSupplySidePlantConnections(EnergyPlusData &state, PlantUtilities::RegisterPlantCompDesignFlow(state, this->SourceInletNode, this->SourceDesignVolFlowRate); Real64 rho; if (this->SrcSidePlantLoc.loopNum > 0) { - rho = state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, RoutineName); + rho = this->SrcSidePlantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, RoutineName); } else { rho = this->water->getDensity(state, Constant::InitConvTemp, RoutineName); } @@ -11587,8 +11580,8 @@ void WaterThermalTankData::SizeTankForDemandSide(EnergyPlusData &state) Real64 rho; Real64 Cp; if (this->UseSidePlantLoc.loopNum > 0) { - rho = state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).glycol->getDensity(state, ((Tfinish + Tstart) / 2.0), RoutineName); - Cp = state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).glycol->getSpecificHeat(state, ((Tfinish + Tstart) / 2.0), RoutineName); + rho = this->UseSidePlantLoc.loop->glycol->getDensity(state, ((Tfinish + Tstart) / 2.0), RoutineName); + Cp = this->UseSidePlantLoc.loop->glycol->getSpecificHeat(state, ((Tfinish + Tstart) / 2.0), RoutineName); } else { rho = this->water->getDensity(state, ((Tfinish + Tstart) / 2.0), RoutineName); Cp = this->water->getSpecificHeat(state, ((Tfinish + Tstart) / 2.0), RoutineName); @@ -11632,8 +11625,8 @@ void WaterThermalTankData::SizeTankForDemandSide(EnergyPlusData &state) Real64 rho; Real64 Cp; if (this->UseSidePlantLoc.loopNum > 0) { - rho = state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).glycol->getDensity(state, ((Tfinish + Tstart) / 2.0), RoutineName); - Cp = state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).glycol->getSpecificHeat(state, ((Tfinish + Tstart) / 2.0), RoutineName); + rho = this->UseSidePlantLoc.loop->glycol->getDensity(state, ((Tfinish + Tstart) / 2.0), RoutineName); + Cp = this->UseSidePlantLoc.loop->glycol->getSpecificHeat(state, ((Tfinish + Tstart) / 2.0), RoutineName); } else { rho = this->water->getDensity(state, ((Tfinish + Tstart) / 2.0), RoutineName); Cp = this->water->getSpecificHeat(state, ((Tfinish + Tstart) / 2.0), RoutineName); @@ -11671,8 +11664,8 @@ void WaterThermalTankData::SizeTankForDemandSide(EnergyPlusData &state) Real64 rho; Real64 Cp; if (this->UseSidePlantLoc.loopNum > 0) { - rho = state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).glycol->getDensity(state, ((Tfinish + Tstart) / 2.0), RoutineName); - Cp = state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).glycol->getSpecificHeat(state, ((Tfinish + Tstart) / 2.0), RoutineName); + rho = this->UseSidePlantLoc.loop->glycol->getDensity(state, ((Tfinish + Tstart) / 2.0), RoutineName); + Cp = this->UseSidePlantLoc.loop->glycol->getSpecificHeat(state, ((Tfinish + Tstart) / 2.0), RoutineName); } else { rho = this->water->getDensity(state, ((Tfinish + Tstart) / 2.0), RoutineName); Cp = this->water->getSpecificHeat(state, ((Tfinish + Tstart) / 2.0), RoutineName); @@ -11779,9 +11772,8 @@ void WaterThermalTankData::SizeTankForSupplySide(EnergyPlusData &state) constexpr Real64 Tfinish = 57.22; if (this->SrcSidePlantLoc.loopNum > 0) { - rho = state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).glycol->getDensity(state, ((Tfinish + Tstart) / 2.0), RoutineName); - Cp = state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum) - .glycol->getSpecificHeat(state, ((Tfinish + Tstart) / 2.0), RoutineName); + rho = this->SrcSidePlantLoc.loop->glycol->getDensity(state, ((Tfinish + Tstart) / 2.0), RoutineName); + Cp = this->SrcSidePlantLoc.loop->glycol->getSpecificHeat(state, ((Tfinish + Tstart) / 2.0), RoutineName); } else { rho = this->water->getDensity(state, ((Tfinish + Tstart) / 2.0), RoutineName); Cp = this->water->getSpecificHeat(state, ((Tfinish + Tstart) / 2.0), RoutineName); @@ -11970,8 +11962,7 @@ void WaterThermalTankData::SizeDemandSidePlantConnections(EnergyPlusData &state) } else { PlantUtilities::RegisterPlantCompDesignFlow(state, this->UseInletNode, tmpUseDesignVolFlowRate); } - Real64 rho = - state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, RoutineName); + Real64 rho = this->UseSidePlantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, RoutineName); if (state.dataPlnt->PlantFirstSizesOkayToFinalize) { this->PlantUseMassFlowRateMax = this->UseDesignVolFlowRate * rho; } else { @@ -11988,7 +11979,7 @@ void WaterThermalTankData::SizeDemandSidePlantConnections(EnergyPlusData &state) PlantUtilities::RegisterPlantCompDesignFlow(state, this->UseInletNode, this->UseDesignVolFlowRate); Real64 rho; if (this->UseSidePlantLoc.loopNum > 0) { - rho = state.dataPlnt->PlantLoop(this->UseSidePlantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, RoutineName); + rho = this->UseSidePlantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, RoutineName); } else { rho = this->water->getDensity(state, Constant::InitConvTemp, RoutineName); } @@ -12052,8 +12043,7 @@ void WaterThermalTankData::SizeDemandSidePlantConnections(EnergyPlusData &state) } else { PlantUtilities::RegisterPlantCompDesignFlow(state, this->SourceInletNode, tmpSourceDesignVolFlowRate); } - Real64 rho = - state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, RoutineName); + Real64 rho = this->SrcSidePlantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, RoutineName); if (state.dataPlnt->PlantFirstSizesOkayToFinalize) { this->PlantSourceMassFlowRateMax = this->SourceDesignVolFlowRate * rho; } else { @@ -12069,7 +12059,7 @@ void WaterThermalTankData::SizeDemandSidePlantConnections(EnergyPlusData &state) PlantUtilities::RegisterPlantCompDesignFlow(state, this->SourceInletNode, this->SourceDesignVolFlowRate); Real64 rho; if (this->SrcSidePlantLoc.loopNum > 0) { - rho = state.dataPlnt->PlantLoop(this->SrcSidePlantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, RoutineName); + rho = this->SrcSidePlantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, RoutineName); } else { rho = this->water->getDensity(state, Constant::InitConvTemp, RoutineName); } diff --git a/src/EnergyPlus/WaterToAirHeatPump.cc b/src/EnergyPlus/WaterToAirHeatPump.cc index 85d257c55c5..4a8215db457 100644 --- a/src/EnergyPlus/WaterToAirHeatPump.cc +++ b/src/EnergyPlus/WaterToAirHeatPump.cc @@ -1000,8 +1000,8 @@ namespace WaterToAirHeatPump { heatPump.OutletWaterEnthalpy = 0.0; // The rest of the one time initializations - Real64 rho = state.dataPlnt->PlantLoop(heatPump.plantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, RoutineName); - Real64 Cp = state.dataPlnt->PlantLoop(heatPump.plantLoc.loopNum).glycol->getSpecificHeat(state, Constant::InitConvTemp, RoutineName); + Real64 rho = heatPump.plantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, RoutineName); + Real64 Cp = heatPump.plantLoc.loop->glycol->getSpecificHeat(state, Constant::InitConvTemp, RoutineName); heatPump.DesignWaterMassFlowRate = rho * heatPump.DesignWaterVolFlowRate; @@ -1194,9 +1194,8 @@ namespace WaterToAirHeatPump { // Set indoor air conditions to the actual condition CpAir = Psychrometrics::PsyCpAirFnW(heatPump.InletAirHumRat); LoadSideAirInletEnth_Unit = Psychrometrics::PsyHFnTdbW(heatPump.InletAirDBTemp, heatPump.InletAirHumRat); - SourceSideVolFlowRate = - heatPump.InletWaterMassFlowRate / - state.dataPlnt->PlantLoop(heatPump.plantLoc.loopNum).glycol->getDensity(state, heatPump.InletWaterTemp, RoutineNameSourceSideInletTemp); + SourceSideVolFlowRate = heatPump.InletWaterMassFlowRate / + heatPump.plantLoc.loop->glycol->getDensity(state, heatPump.InletWaterTemp, RoutineNameSourceSideInletTemp); StillSimulatingFlag = true; @@ -1309,13 +1308,12 @@ namespace WaterToAirHeatPump { } // Determine Effectiveness of Source Side - CpFluid = state.dataPlnt->PlantLoop(heatPump.plantLoc.loopNum) - .glycol->getSpecificHeat(state, heatPump.InletWaterTemp, RoutineNameSourceSideInletTemp); + CpFluid = heatPump.plantLoc.loop->glycol->getSpecificHeat(state, heatPump.InletWaterTemp, RoutineNameSourceSideInletTemp); - if (state.dataPlnt->PlantLoop(heatPump.plantLoc.loopNum).glycol->Num == Fluid::GlycolNum_Water) { + if (heatPump.plantLoc.loop->glycol->Num == Fluid::GlycolNum_Water) { SourceSideEffect = 1.0 - std::exp(-heatPump.SourceSideUACoeff / (CpFluid * heatPump.InletWaterMassFlowRate)); } else { - DegradFactor = DegradF(state, state.dataPlnt->PlantLoop(heatPump.plantLoc.loopNum).glycol, heatPump.InletWaterTemp); + DegradFactor = DegradF(state, heatPump.plantLoc.loop->glycol, heatPump.InletWaterTemp); SourceSideEffect = 1.0 / ((heatPump.SourceSideHTR1 * std::pow(SourceSideVolFlowRate, -0.8)) / DegradFactor + heatPump.SourceSideHTR2); } @@ -1651,9 +1649,8 @@ namespace WaterToAirHeatPump { // LOAD LOCAL VARIABLES FROM DATA STRUCTURE (for code readability) CpAir = Psychrometrics::PsyCpAirFnW(heatPump.InletAirHumRat); - SourceSideVolFlowRate = - heatPump.InletWaterMassFlowRate / - state.dataPlnt->PlantLoop(heatPump.plantLoc.loopNum).glycol->getDensity(state, heatPump.InletWaterTemp, RoutineNameSourceSideInletTemp); + SourceSideVolFlowRate = heatPump.InletWaterMassFlowRate / + heatPump.plantLoc.loop->glycol->getDensity(state, heatPump.InletWaterTemp, RoutineNameSourceSideInletTemp); // If heat pump is not operating, return if (SensDemand == 0.0 || heatPump.InletAirMassFlowRate <= 0.0 || heatPump.InletWaterMassFlowRate <= 0.0 || @@ -1720,13 +1717,12 @@ namespace WaterToAirHeatPump { } // Determine Effectiveness of Source Side - CpFluid = state.dataPlnt->PlantLoop(heatPump.plantLoc.loopNum) - .glycol->getSpecificHeat(state, heatPump.InletWaterTemp, RoutineNameSourceSideInletTemp); + CpFluid = heatPump.plantLoc.loop->glycol->getSpecificHeat(state, heatPump.InletWaterTemp, RoutineNameSourceSideInletTemp); - if (state.dataPlnt->PlantLoop(heatPump.plantLoc.loopNum).glycol->Num == Fluid::GlycolNum_Water) { + if (heatPump.plantLoc.loop->glycol->Num == Fluid::GlycolNum_Water) { SourceSideEffect = 1.0 - std::exp(-heatPump.SourceSideUACoeff / (CpFluid * heatPump.InletWaterMassFlowRate)); } else { - DegradFactor = DegradF(state, state.dataPlnt->PlantLoop(heatPump.plantLoc.loopNum).glycol, heatPump.InletWaterTemp); + DegradFactor = DegradF(state, heatPump.plantLoc.loop->glycol, heatPump.InletWaterTemp); SourceSideEffect = 1.0 / ((heatPump.SourceSideHTR1 * std::pow(SourceSideVolFlowRate, -0.8)) / DegradFactor + heatPump.SourceSideHTR2); } diff --git a/src/EnergyPlus/WaterToAirHeatPumpSimple.cc b/src/EnergyPlus/WaterToAirHeatPumpSimple.cc index c93b1a95755..4e7cfbe7f53 100644 --- a/src/EnergyPlus/WaterToAirHeatPumpSimple.cc +++ b/src/EnergyPlus/WaterToAirHeatPumpSimple.cc @@ -1051,8 +1051,7 @@ namespace WaterToAirHeatPumpSimple { simpleWatertoAirHP.PartLoadRatio = 0.0; if (simpleWatertoAirHP.RatedWaterVolFlowRate != DataSizing::AutoSize) { - rho = - state.dataPlnt->PlantLoop(simpleWatertoAirHP.plantLoc.loopNum).glycol->getDensity(state, Constant::InitConvTemp, RoutineName); + rho = simpleWatertoAirHP.plantLoc.loop->glycol->getDensity(state, Constant::InitConvTemp, RoutineName); simpleWatertoAirHP.DesignWaterMassFlowRate = rho * simpleWatertoAirHP.RatedWaterVolFlowRate; PlantUtilities::InitComponentNodes(state, @@ -2820,10 +2819,9 @@ namespace WaterToAirHeatPumpSimple { false); if (PltSizNum > 0) { - rho = state.dataPlnt->PlantLoop(simpleWatertoAirHP.plantLoc.loopNum) - .glycol->getDensity(state, state.dataSize->PlantSizData(PltSizNum).ExitTemp, RoutineNameAlt); - Cp = state.dataPlnt->PlantLoop(simpleWatertoAirHP.plantLoc.loopNum) - .glycol->getSpecificHeat(state, state.dataSize->PlantSizData(PltSizNum).ExitTemp, RoutineNameAlt); + rho = simpleWatertoAirHP.plantLoc.loop->glycol->getDensity(state, state.dataSize->PlantSizData(PltSizNum).ExitTemp, RoutineNameAlt); + Cp = simpleWatertoAirHP.plantLoc.loop->glycol->getSpecificHeat( + state, state.dataSize->PlantSizData(PltSizNum).ExitTemp, RoutineNameAlt); if (simpleWatertoAirHP.WAHPType == WatertoAirHP::Heating) { RatedWaterVolFlowRateDes = @@ -3077,8 +3075,8 @@ namespace WaterToAirHeatPumpSimple { state.dataWaterToAirHeatPumpSimple->SourceSideMassFlowRate = simpleWatertoAirHP.WaterMassFlowRate; state.dataWaterToAirHeatPumpSimple->SourceSideInletTemp = simpleWatertoAirHP.InletWaterTemp; state.dataWaterToAirHeatPumpSimple->SourceSideInletEnth = simpleWatertoAirHP.InletWaterEnthalpy; - CpWater = state.dataPlnt->PlantLoop(simpleWatertoAirHP.plantLoc.loopNum) - .glycol->getSpecificHeat(state, state.dataWaterToAirHeatPumpSimple->SourceSideInletTemp, RoutineNameSourceSideInletTemp); + CpWater = simpleWatertoAirHP.plantLoc.loop->glycol->getSpecificHeat( + state, state.dataWaterToAirHeatPumpSimple->SourceSideInletTemp, RoutineNameSourceSideInletTemp); // Check for flows, do not perform simulation if no flow in load side or source side. if (state.dataWaterToAirHeatPumpSimple->SourceSideMassFlowRate <= 0.0 || LoadSideFullMassFlowRate <= 0.0) { @@ -3375,8 +3373,8 @@ namespace WaterToAirHeatPumpSimple { state.dataWaterToAirHeatPumpSimple->SourceSideMassFlowRate = simpleWatertoAirHP.WaterMassFlowRate; state.dataWaterToAirHeatPumpSimple->SourceSideInletTemp = simpleWatertoAirHP.InletWaterTemp; state.dataWaterToAirHeatPumpSimple->SourceSideInletEnth = simpleWatertoAirHP.InletWaterEnthalpy; - CpWater = state.dataPlnt->PlantLoop(simpleWatertoAirHP.plantLoc.loopNum) - .glycol->getSpecificHeat(state, state.dataWaterToAirHeatPumpSimple->SourceSideInletTemp, RoutineNameSourceSideInletTemp); + CpWater = simpleWatertoAirHP.plantLoc.loop->glycol->getSpecificHeat( + state, state.dataWaterToAirHeatPumpSimple->SourceSideInletTemp, RoutineNameSourceSideInletTemp); // Check for flows, do not perform simulation if no flow in load side or source side. if (state.dataWaterToAirHeatPumpSimple->SourceSideMassFlowRate <= 0.0 || LoadSideFullMassFlowRate <= 0.0) { diff --git a/tst/EnergyPlus/unit/Autosizing/WaterHeatingCoilUASizing.unit.cc b/tst/EnergyPlus/unit/Autosizing/WaterHeatingCoilUASizing.unit.cc index 0f45e91bad4..f16c344940e 100644 --- a/tst/EnergyPlus/unit/Autosizing/WaterHeatingCoilUASizing.unit.cc +++ b/tst/EnergyPlus/unit/Autosizing/WaterHeatingCoilUASizing.unit.cc @@ -120,7 +120,6 @@ TEST_F(AutoSizingFixture, WaterHeatingCoilUASizingGauntlet) state->dataWaterCoils->WaterCoil(1).InletWaterTemp = 60.0; state->dataWaterCoils->WaterCoil(1).InletAirMassFlowRate = 0.2; state->dataWaterCoils->WaterCoil(1).InletWaterMassFlowRate = 0.8; - state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loopNum = 1; state->dataWaterCoils->MyUAAndFlowCalcFlag.allocate(1); state->dataWaterCoils->MySizeFlag.allocate(1); state->dataWaterCoils->WaterCoil(1).availSched = Sched::GetScheduleAlwaysOn(*state); @@ -139,6 +138,9 @@ TEST_F(AutoSizingFixture, WaterHeatingCoilUASizingGauntlet) state->dataPlnt->PlantLoop(1).FluidIndex = 1; state->dataPlnt->PlantLoop(1).glycol = Fluid::GetWater(*state); + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loopNum = 1; + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loop = &state->dataPlnt->PlantLoop(1); + state->dataSize->ZoneSizingRunDone = true; // Test 2 - Zone Equipment diff --git a/tst/EnergyPlus/unit/BoilerHotWater.unit.cc b/tst/EnergyPlus/unit/BoilerHotWater.unit.cc index 64285e6b5db..91baa76c773 100644 --- a/tst/EnergyPlus/unit/BoilerHotWater.unit.cc +++ b/tst/EnergyPlus/unit/BoilerHotWater.unit.cc @@ -90,6 +90,9 @@ TEST_F(EnergyPlusFixture, Boiler_HotWaterSizingTest) state->dataPlnt->PlantLoop(1).FluidName = "WATER"; state->dataPlnt->PlantLoop(1).glycol = Fluid::GetWater(*state); + state->dataBoilers->Boiler[0].plantLoc.loopNum = 1; + state->dataBoilers->Boiler[0].plantLoc.loop = &state->dataPlnt->PlantLoop(1); + state->dataSize->PlantSizData(1).DesVolFlowRate = 1.0; state->dataSize->PlantSizData(1).DeltaT = 10.0; state->dataPlnt->PlantFirstSizesOkayToFinalize = true; @@ -123,7 +126,6 @@ TEST_F(EnergyPlusFixture, Boiler_HotWaterAutoSizeTempTest) // boiler nominal capacity in Boiler:HotWater state->dataBoilers->Boiler.emplace_back(); // Autosized Hot Water Boiler - state->dataBoilers->Boiler[0].plantLoc.loopNum = 1; state->dataBoilers->Boiler[0].SizFac = 1.2; state->dataBoilers->Boiler[0].NomCap = DataSizing::AutoSize; state->dataBoilers->Boiler[0].NomCapWasAutoSized = true; @@ -140,11 +142,12 @@ TEST_F(EnergyPlusFixture, Boiler_HotWaterAutoSizeTempTest) state->dataSize->PlantSizData(1).DeltaT = 10.0; state->dataPlnt->PlantFirstSizesOkayToFinalize = true; + state->dataBoilers->Boiler[0].plantLoc.loopNum = 1; + state->dataBoilers->Boiler[0].plantLoc.loop = &state->dataPlnt->PlantLoop(1); + // calculate nominal capacity at 60.0 C hot water temperature - Real64 rho = state->dataPlnt->PlantLoop(state->dataBoilers->Boiler[0].plantLoc.loopNum) - .glycol->getDensity(*state, 60.0, "Boiler_HotWaterAutoSizeTempTest"); - Real64 Cp = state->dataPlnt->PlantLoop(state->dataBoilers->Boiler[0].plantLoc.loopNum) - .glycol->getSpecificHeat(*state, 60.0, "Boiler_HotWaterAutoSizeTempTest"); + Real64 rho = state->dataBoilers->Boiler[0].plantLoc.loop->glycol->getDensity(*state, 60.0, "Boiler_HotWaterAutoSizeTempTest"); + Real64 Cp = state->dataBoilers->Boiler[0].plantLoc.loop->glycol->getSpecificHeat(*state, 60.0, "Boiler_HotWaterAutoSizeTempTest"); Real64 NomCapBoilerExpected = rho * state->dataSize->PlantSizData(1).DesVolFlowRate * Cp * state->dataSize->PlantSizData(1).DeltaT * state->dataBoilers->Boiler[0].SizFac; diff --git a/tst/EnergyPlus/unit/ChillerExhaustAbsorption.unit.cc b/tst/EnergyPlus/unit/ChillerExhaustAbsorption.unit.cc index 9c04765ba59..ee6869e4def 100644 --- a/tst/EnergyPlus/unit/ChillerExhaustAbsorption.unit.cc +++ b/tst/EnergyPlus/unit/ChillerExhaustAbsorption.unit.cc @@ -1451,6 +1451,7 @@ TEST_F(EnergyPlusFixture, ExhAbsorption_calcChiller_Err_Msg_Test) state->dataPlnt->PlantLoop.allocate(state->dataPlnt->TotNumLoops); thisChillerHeater.CWPlantLoc.loopNum = 1; + thisChillerHeater.CWPlantLoc.loop = &state->dataPlnt->PlantLoop(1); thisChillerHeater.CWPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand; state->dataPlnt->PlantLoop(1).FluidName = "WATER"; diff --git a/tst/EnergyPlus/unit/FluidCoolers.unit.cc b/tst/EnergyPlus/unit/FluidCoolers.unit.cc index 1c54eaa18ce..57edd88b950 100644 --- a/tst/EnergyPlus/unit/FluidCoolers.unit.cc +++ b/tst/EnergyPlus/unit/FluidCoolers.unit.cc @@ -370,6 +370,9 @@ TEST_F(EnergyPlusFixture, FluidCooler_SizeWhenPlantSizingIndexIsZero) state->dataFluidCoolers->SimpleFluidCooler(FluidCoolerNum).plantLoc.loopNum = 1; state->dataPlnt->PlantLoop(1).PlantSizNum = 0; + thisFluidCooler.plantLoc.loopNum = 1; + thisFluidCooler.plantLoc.loop = &state->dataPlnt->PlantLoop(1); + EXPECT_EQ("DRY COOLER", thisFluidCooler.Name); EXPECT_FALSE(thisFluidCooler.HighSpeedFanPowerWasAutoSized); EXPECT_FALSE(thisFluidCooler.HighSpeedAirFlowRateWasAutoSized); diff --git a/tst/EnergyPlus/unit/HVACMultiSpeedHeatPump.unit.cc b/tst/EnergyPlus/unit/HVACMultiSpeedHeatPump.unit.cc index 02b19cb20f5..8efce08f0b5 100644 --- a/tst/EnergyPlus/unit/HVACMultiSpeedHeatPump.unit.cc +++ b/tst/EnergyPlus/unit/HVACMultiSpeedHeatPump.unit.cc @@ -1474,6 +1474,9 @@ TEST_F(EnergyPlusFixture, HVACMultiSpeedHeatPump_HeatRecoveryTest) state->dataPlnt->PlantLoop(1).FluidName = "WATER"; state->dataPlnt->PlantLoop(1).glycol = Fluid::GetWater(*state); + state->dataHVACMultiSpdHP->MSHeatPump(1).HRPlantLoc.loopNum = 1; + state->dataHVACMultiSpdHP->MSHeatPump(1).HRPlantLoc.loop = &state->dataPlnt->PlantLoop(1); + state->dataLoopNodes->Node(HeatRecInNode).MassFlowRate = 0.0; // test heat recovery result with 0 water flow rate HVACMultiSpeedHeatPump::MSHPHeatRecovery(*state, 1); diff --git a/tst/EnergyPlus/unit/HWBaseboardRadiator.unit.cc b/tst/EnergyPlus/unit/HWBaseboardRadiator.unit.cc index f854611325a..59a96889292 100644 --- a/tst/EnergyPlus/unit/HWBaseboardRadiator.unit.cc +++ b/tst/EnergyPlus/unit/HWBaseboardRadiator.unit.cc @@ -109,6 +109,9 @@ TEST_F(EnergyPlusFixture, HWBaseboardRadiator_CalcHWBaseboard) state->dataPlnt->PlantLoop(1).FluidType = DataLoopNode::NodeFluidType::Water; state->dataPlnt->PlantLoop(1).glycol = Fluid::GetWater(*state); + HWBaseboard(1).plantLoc.loopNum = 1; + HWBaseboard(1).plantLoc.loop = &state->dataPlnt->PlantLoop(1); + CalcHWBaseboard(*state, BBNum, LoadMet); EXPECT_NEAR(14746.226690452937, HWBaseboard(1).TotPower, 0.000001); diff --git a/tst/EnergyPlus/unit/LowTempRadiantSystem.unit.cc b/tst/EnergyPlus/unit/LowTempRadiantSystem.unit.cc index 624863de5d9..359a0812804 100644 --- a/tst/EnergyPlus/unit/LowTempRadiantSystem.unit.cc +++ b/tst/EnergyPlus/unit/LowTempRadiantSystem.unit.cc @@ -213,12 +213,14 @@ TEST_F(LowTempRadiantSystemTest, SizeLowTempRadiantVariableFlow) state->dataLowTempRadSys->HydrRadSys(RadSysNum).HotWaterInNode = 1; state->dataLowTempRadSys->HydrRadSys(RadSysNum).HotWaterOutNode = 2; state->dataLowTempRadSys->HydrRadSys(RadSysNum).HWPlantLoc.loopNum = 1; + state->dataLowTempRadSys->HydrRadSys(RadSysNum).HWPlantLoc.loop = &state->dataPlnt->PlantLoop(1); state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumIn = state->dataLowTempRadSys->HydrRadSys(RadSysNum).HotWaterInNode; state->dataLowTempRadSys->HydrRadSys(RadSysNum).ColdWaterInNode = 3; state->dataLowTempRadSys->HydrRadSys(RadSysNum).ColdWaterOutNode = 4; state->dataLowTempRadSys->HydrRadSys(RadSysNum).CWPlantLoc.loopNum = 2; + state->dataLowTempRadSys->HydrRadSys(RadSysNum).CWPlantLoc.loop = &state->dataPlnt->PlantLoop(2); state->dataPlnt->PlantLoop(2).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumIn = state->dataLowTempRadSys->HydrRadSys(RadSysNum).ColdWaterInNode; @@ -306,12 +308,14 @@ TEST_F(LowTempRadiantSystemTest, SizeCapacityLowTempRadiantVariableFlow) state->dataLowTempRadSys->HydrRadSys(RadSysNum).HotWaterInNode = 1; state->dataLowTempRadSys->HydrRadSys(RadSysNum).HotWaterOutNode = 2; state->dataLowTempRadSys->HydrRadSys(RadSysNum).HWPlantLoc.loopNum = 1; + state->dataLowTempRadSys->HydrRadSys(RadSysNum).HWPlantLoc.loop = &state->dataPlnt->PlantLoop(1); state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumIn = state->dataLowTempRadSys->HydrRadSys(RadSysNum).HotWaterInNode; state->dataLowTempRadSys->HydrRadSys(RadSysNum).ColdWaterInNode = 3; state->dataLowTempRadSys->HydrRadSys(RadSysNum).ColdWaterOutNode = 4; state->dataLowTempRadSys->HydrRadSys(RadSysNum).CWPlantLoc.loopNum = 2; + state->dataLowTempRadSys->HydrRadSys(RadSysNum).CWPlantLoc.loop = &state->dataPlnt->PlantLoop(2); state->dataPlnt->PlantLoop(2).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumIn = state->dataLowTempRadSys->HydrRadSys(RadSysNum).ColdWaterInNode; @@ -382,12 +386,14 @@ TEST_F(LowTempRadiantSystemTest, SizeLowTempRadiantConstantFlow) state->dataLowTempRadSys->CFloRadSys(RadSysNum).HotWaterInNode = 1; state->dataLowTempRadSys->CFloRadSys(RadSysNum).HotWaterOutNode = 2; state->dataLowTempRadSys->CFloRadSys(RadSysNum).HWPlantLoc.loopNum = 1; + state->dataLowTempRadSys->CFloRadSys(RadSysNum).HWPlantLoc.loop = &state->dataPlnt->PlantLoop(1); state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumIn = state->dataLowTempRadSys->CFloRadSys(RadSysNum).HotWaterInNode; state->dataLowTempRadSys->CFloRadSys(RadSysNum).ColdWaterInNode = 3; state->dataLowTempRadSys->CFloRadSys(RadSysNum).ColdWaterOutNode = 4; state->dataLowTempRadSys->CFloRadSys(RadSysNum).CWPlantLoc.loopNum = 2; + state->dataLowTempRadSys->CFloRadSys(RadSysNum).CWPlantLoc.loop = &state->dataPlnt->PlantLoop(2); state->dataPlnt->PlantLoop(2).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumIn = state->dataLowTempRadSys->CFloRadSys(RadSysNum).ColdWaterInNode; @@ -1197,16 +1203,16 @@ TEST_F(LowTempRadiantSystemTest, AutosizeLowTempRadiantVariableFlowTest) CoolingCapacity = state->dataSize->FinalZoneSizing(state->dataSize->CurZoneEqNum).NonAirSysDesCoolLoad * state->dataLowTempRadSys->HydrRadSys(RadSysNum).ScaledCoolingCapacity; // hot water flow rate sizing calculation - Density = state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).HWPlantLoc.loopNum) - .glycol->getDensity(*state, 60.0, "AutosizeLowTempRadiantVariableFlowTest"); - Cp = state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).HWPlantLoc.loopNum) - .glycol->getSpecificHeat(*state, 60.0, "AutosizeLowTempRadiantVariableFlowTest"); + Density = + state->dataLowTempRadSys->HydrRadSys(RadSysNum).HWPlantLoc.loop->glycol->getDensity(*state, 60.0, "AutosizeLowTempRadiantVariableFlowTest"); + Cp = state->dataLowTempRadSys->HydrRadSys(RadSysNum).HWPlantLoc.loop->glycol->getSpecificHeat( + *state, 60.0, "AutosizeLowTempRadiantVariableFlowTest"); HotWaterFlowRate = HeatingCapacity / (state->dataSize->PlantSizData(1).DeltaT * Cp * Density); // chilled water flow rate sizing calculation - Density = state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).CWPlantLoc.loopNum) - .glycol->getDensity(*state, 5.05, "AutosizeLowTempRadiantVariableFlowTest"); - Cp = state->dataPlnt->PlantLoop(state->dataLowTempRadSys->HydrRadSys(RadSysNum).CWPlantLoc.loopNum) - .glycol->getSpecificHeat(*state, 5.05, "AutosizeLowTempRadiantVariableFlowTest"); + Density = + state->dataLowTempRadSys->HydrRadSys(RadSysNum).CWPlantLoc.loop->glycol->getDensity(*state, 5.05, "AutosizeLowTempRadiantVariableFlowTest"); + Cp = state->dataLowTempRadSys->HydrRadSys(RadSysNum).CWPlantLoc.loop->glycol->getSpecificHeat( + *state, 5.05, "AutosizeLowTempRadiantVariableFlowTest"); ChilledWaterFlowRate = CoolingCapacity / (state->dataSize->PlantSizData(2).DeltaT * Cp * Density); // tuble length sizing calculation state->dataLowTempRadSys->HydrRadSys(RadSysNum).TotalSurfaceArea = @@ -2593,12 +2599,14 @@ TEST_F(LowTempRadiantSystemTest, LowTempRadConFlowSystemAutoSizeTempTest) state->dataLowTempRadSys->CFloRadSys(RadSysNum).HotWaterInNode = 1; state->dataLowTempRadSys->CFloRadSys(RadSysNum).HotWaterOutNode = 2; state->dataLowTempRadSys->CFloRadSys(RadSysNum).HWPlantLoc.loopNum = 1; + state->dataLowTempRadSys->CFloRadSys(RadSysNum).HWPlantLoc.loop = &state->dataPlnt->PlantLoop(1); state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumIn = state->dataLowTempRadSys->CFloRadSys(RadSysNum).HotWaterInNode; state->dataLowTempRadSys->CFloRadSys(RadSysNum).ColdWaterInNode = 3; state->dataLowTempRadSys->CFloRadSys(RadSysNum).ColdWaterOutNode = 4; state->dataLowTempRadSys->CFloRadSys(RadSysNum).CWPlantLoc.loopNum = 2; + state->dataLowTempRadSys->CFloRadSys(RadSysNum).CWPlantLoc.loop = &state->dataPlnt->PlantLoop(2); state->dataPlnt->PlantLoop(2).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumIn = state->dataLowTempRadSys->CFloRadSys(RadSysNum).ColdWaterInNode; @@ -2637,10 +2645,10 @@ TEST_F(LowTempRadiantSystemTest, LowTempRadConFlowSystemAutoSizeTempTest) state->dataLowTempRadSys->CFloRadSys(RadSysNum).WaterVolFlowMax = AutoSize; // chilled water volume flow rate sizing calculation - Density = state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).CWPlantLoc.loopNum) - .glycol->getDensity(*state, 5.05, "LowTempRadConFlowSystemAutoSizeTempTest"); - Cp = state->dataPlnt->PlantLoop(state->dataLowTempRadSys->CFloRadSys(RadSysNum).CWPlantLoc.loopNum) - .glycol->getSpecificHeat(*state, 5.05, "LowTempRadConFlowSystemAutoSizeTempTest"); + Density = + state->dataLowTempRadSys->CFloRadSys(RadSysNum).CWPlantLoc.loop->glycol->getDensity(*state, 5.05, "LowTempRadConFlowSystemAutoSizeTempTest"); + Cp = state->dataLowTempRadSys->CFloRadSys(RadSysNum).CWPlantLoc.loop->glycol->getSpecificHeat( + *state, 5.05, "LowTempRadConFlowSystemAutoSizeTempTest"); Real64 CoolingLoad = state->dataSize->FinalZoneSizing(state->dataSize->CurZoneEqNum).NonAirSysDesCoolLoad; Real64 DesChilledWaterVolFlowRate = CoolingLoad / (state->dataSize->PlantSizData(2).DeltaT * Density * Cp); @@ -2693,6 +2701,7 @@ TEST_F(LowTempRadiantSystemTest, LowTempRadCalcRadSysHXEffectTermTest) RadSysType = SystemType::Hydronic; Temperature = 10.0; state->dataLowTempRadSys->HydrRadSys(RadSysNum).HWPlantLoc.loopNum = 1; + state->dataLowTempRadSys->HydrRadSys(RadSysNum).HWPlantLoc.loop = &state->dataPlnt->PlantLoop(1); HXEffectFuncResult = state->dataLowTempRadSys->HydrRadSys(RadSysNum).calculateHXEffectivenessTerm(*state, SurfNum, @@ -2710,6 +2719,7 @@ TEST_F(LowTempRadiantSystemTest, LowTempRadCalcRadSysHXEffectTermTest) RadSysType = SystemType::Hydronic; Temperature = 10.0; state->dataLowTempRadSys->HydrRadSys(RadSysNum).CWPlantLoc.loopNum = 1; + state->dataLowTempRadSys->HydrRadSys(RadSysNum).CWPlantLoc.loop = &state->dataPlnt->PlantLoop(1); HXEffectFuncResult = state->dataLowTempRadSys->HydrRadSys(RadSysNum).calculateHXEffectivenessTerm(*state, SurfNum, @@ -2727,6 +2737,7 @@ TEST_F(LowTempRadiantSystemTest, LowTempRadCalcRadSysHXEffectTermTest) RadSysType = SystemType::ConstantFlow; Temperature = 10.0; state->dataLowTempRadSys->CFloRadSys(RadSysNum).HWPlantLoc.loopNum = 1; + state->dataLowTempRadSys->CFloRadSys(RadSysNum).HWPlantLoc.loop = &state->dataPlnt->PlantLoop(1); HXEffectFuncResult = state->dataLowTempRadSys->CFloRadSys(RadSysNum).calculateHXEffectivenessTerm(*state, SurfNum, @@ -2744,6 +2755,7 @@ TEST_F(LowTempRadiantSystemTest, LowTempRadCalcRadSysHXEffectTermTest) RadSysType = SystemType::ConstantFlow; Temperature = 10.0; state->dataLowTempRadSys->CFloRadSys(RadSysNum).CWPlantLoc.loopNum = 1; + state->dataLowTempRadSys->CFloRadSys(RadSysNum).CWPlantLoc.loop = &state->dataPlnt->PlantLoop(1); HXEffectFuncResult = state->dataLowTempRadSys->CFloRadSys(RadSysNum).calculateHXEffectivenessTerm(*state, SurfNum, diff --git a/tst/EnergyPlus/unit/SizeWaterHeatingCoil.unit.cc b/tst/EnergyPlus/unit/SizeWaterHeatingCoil.unit.cc index dca3611adb8..6d9229f96b6 100644 --- a/tst/EnergyPlus/unit/SizeWaterHeatingCoil.unit.cc +++ b/tst/EnergyPlus/unit/SizeWaterHeatingCoil.unit.cc @@ -250,10 +250,17 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils1) state->dataWaterCoils->MyUAAndFlowCalcFlag(1) = false; GetSysInput(*state); state->dataSize->TermUnitSingDuct = true; + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loopNum = 1; state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand; state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.branchNum = 1; state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.compNum = 1; + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loop = &state->dataPlnt->PlantLoop(1); + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.side = &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand); + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.branch = &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1); + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.comp = + &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1); + state->dataPlnt->PlantLoop(1).Name = "HotWaterLoop"; state->dataPlnt->PlantLoop(1).FluidName = "WATER"; state->dataPlnt->PlantLoop(1).glycol = Fluid::GetWater(*state); @@ -264,9 +271,15 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils1) state->dataWaterCoils->WaterCoil(1).WaterInletNodeNum; state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumOut = state->dataWaterCoils->WaterCoil(1).WaterOutletNodeNum; + state->dataSingleDuct->sd_airterminal(1).HWplantLoc.loopNum = 1; state->dataSingleDuct->sd_airterminal(1).HWplantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand; state->dataSingleDuct->sd_airterminal(1).HWplantLoc.branchNum = 1; + state->dataSingleDuct->sd_airterminal(1).HWplantLoc.loop = &state->dataPlnt->PlantLoop(1); + state->dataSingleDuct->sd_airterminal(1).HWplantLoc.side = &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand); + state->dataSingleDuct->sd_airterminal(1).HWplantLoc.branch = + &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1); + state->dataSize->PlantSizData(1).DeltaT = 11.0; state->dataSize->PlantSizData(1).ExitTemp = 82; state->dataSize->PlantSizData(1).PlantLoopName = "HotWaterLoop"; @@ -504,6 +517,12 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils2) state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand; state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.branchNum = 1; state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.compNum = 1; + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loop = &state->dataPlnt->PlantLoop(1); + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.side = &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand); + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.branch = &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1); + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.comp = + &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1); + state->dataPlnt->PlantLoop(1).Name = "HotWaterLoop"; state->dataPlnt->PlantLoop(1).FluidName = "WATER"; state->dataPlnt->PlantLoop(1).glycol = Fluid::GetWater(*state); @@ -514,9 +533,15 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils2) state->dataWaterCoils->WaterCoil(1).WaterInletNodeNum; state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumOut = state->dataWaterCoils->WaterCoil(1).WaterOutletNodeNum; + state->dataSingleDuct->sd_airterminal(1).HWplantLoc.loopNum = 1; state->dataSingleDuct->sd_airterminal(1).HWplantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand; state->dataSingleDuct->sd_airterminal(1).HWplantLoc.branchNum = 1; + state->dataSingleDuct->sd_airterminal(1).HWplantLoc.loop = &state->dataPlnt->PlantLoop(1); + state->dataSingleDuct->sd_airterminal(1).HWplantLoc.side = &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand); + state->dataSingleDuct->sd_airterminal(1).HWplantLoc.branch = + &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1); + state->dataSize->PlantSizData(1).DeltaT = 11.0; state->dataSize->PlantSizData(1).ExitTemp = 82; state->dataSize->PlantSizData(1).PlantLoopName = "HotWaterLoop"; @@ -753,6 +778,12 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils3) state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand; state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.branchNum = 1; state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.compNum = 1; + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loop = &state->dataPlnt->PlantLoop(1); + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.side = &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand); + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.branch = &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1); + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.comp = + &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1); + state->dataPlnt->PlantLoop(1).Name = "HotWaterLoop"; state->dataPlnt->PlantLoop(1).FluidName = "WATER"; state->dataPlnt->PlantLoop(1).glycol = Fluid::GetWater(*state); @@ -763,9 +794,15 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils3) state->dataWaterCoils->WaterCoil(1).WaterInletNodeNum; state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumOut = state->dataWaterCoils->WaterCoil(1).WaterOutletNodeNum; + state->dataSingleDuct->sd_airterminal(1).HWplantLoc.loopNum = 1; state->dataSingleDuct->sd_airterminal(1).HWplantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand; state->dataSingleDuct->sd_airterminal(1).HWplantLoc.branchNum = 1; + state->dataSingleDuct->sd_airterminal(1).HWplantLoc.loop = &state->dataPlnt->PlantLoop(1); + state->dataSingleDuct->sd_airterminal(1).HWplantLoc.side = &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand); + state->dataSingleDuct->sd_airterminal(1).HWplantLoc.branch = + &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1); + state->dataSize->PlantSizData(1).DeltaT = 11.0; state->dataSize->PlantSizData(1).ExitTemp = 82; state->dataSize->PlantSizData(1).PlantLoopName = "HotWaterLoop"; @@ -998,10 +1035,17 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils4) state->dataWaterCoils->MyUAAndFlowCalcFlag(1) = false; GetSysInput(*state); state->dataSize->TermUnitSingDuct = true; + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loopNum = 1; state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand; state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.branchNum = 1; state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.compNum = 1; + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loop = &state->dataPlnt->PlantLoop(1); + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.side = &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand); + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.branch = &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1); + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.comp = + &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1); + state->dataPlnt->PlantLoop(1).Name = "HotWaterLoop"; state->dataPlnt->PlantLoop(1).FluidName = "WATER"; state->dataPlnt->PlantLoop(1).glycol = Fluid::GetWater(*state); @@ -1012,9 +1056,15 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils4) state->dataWaterCoils->WaterCoil(1).WaterInletNodeNum; state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumOut = state->dataWaterCoils->WaterCoil(1).WaterOutletNodeNum; + state->dataSingleDuct->sd_airterminal(1).HWplantLoc.loopNum = 1; state->dataSingleDuct->sd_airterminal(1).HWplantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand; state->dataSingleDuct->sd_airterminal(1).HWplantLoc.branchNum = 1; + state->dataSingleDuct->sd_airterminal(1).HWplantLoc.loop = &state->dataPlnt->PlantLoop(1); + state->dataSingleDuct->sd_airterminal(1).HWplantLoc.side = &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand); + state->dataSingleDuct->sd_airterminal(1).HWplantLoc.branch = + &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1); + state->dataSize->PlantSizData(1).DeltaT = 11.0; state->dataSize->PlantSizData(1).ExitTemp = 82; state->dataSize->PlantSizData(1).PlantLoopName = "HotWaterLoop"; @@ -1205,10 +1255,17 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils5) state->dataWaterCoils->MySizeFlag(1) = true; state->dataWaterCoils->MyUAAndFlowCalcFlag(1) = false; state->dataSize->TermUnitSingDuct = true; + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loopNum = 1; state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand; state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.branchNum = 1; state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.compNum = 1; + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loop = &state->dataPlnt->PlantLoop(1); + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.side = &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand); + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.branch = &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1); + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.comp = + &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1); + state->dataPlnt->PlantLoop(1).Name = "HotWaterLoop"; state->dataPlnt->PlantLoop(1).FluidName = "WATER"; state->dataPlnt->PlantLoop(1).glycol = Fluid::GetWater(*state); @@ -1424,6 +1481,12 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils6) state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand; state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.branchNum = 1; state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.compNum = 1; + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loop = &state->dataPlnt->PlantLoop(1); + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.side = &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand); + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.branch = &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1); + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.comp = + &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1); + state->dataPlnt->PlantLoop(1).Name = "HotWaterLoop"; state->dataPlnt->PlantLoop(1).FluidName = "WATER"; state->dataPlnt->PlantLoop(1).glycol = Fluid::GetWater(*state); @@ -1434,9 +1497,15 @@ TEST_F(EnergyPlusFixture, TestSizingRoutineForHotWaterCoils6) state->dataWaterCoils->WaterCoil(1).WaterInletNodeNum; state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumOut = state->dataWaterCoils->WaterCoil(1).WaterOutletNodeNum; + state->dataSingleDuct->sd_airterminal(1).HWplantLoc.loopNum = 1; state->dataSingleDuct->sd_airterminal(1).HWplantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand; state->dataSingleDuct->sd_airterminal(1).HWplantLoc.branchNum = 1; + state->dataSingleDuct->sd_airterminal(1).HWplantLoc.loop = &state->dataPlnt->PlantLoop(1); + state->dataSingleDuct->sd_airterminal(1).HWplantLoc.side = &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand); + state->dataSingleDuct->sd_airterminal(1).HWplantLoc.branch = + &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1); + state->dataSize->CurZoneEqNum = 1; state->dataSize->CurTermUnitSizingNum = 1; state->dataSize->CurSysNum = 0; diff --git a/tst/EnergyPlus/unit/UnitarySystem.unit.cc b/tst/EnergyPlus/unit/UnitarySystem.unit.cc index 47f2a49a16d..24f9fdc1279 100644 --- a/tst/EnergyPlus/unit/UnitarySystem.unit.cc +++ b/tst/EnergyPlus/unit/UnitarySystem.unit.cc @@ -350,10 +350,18 @@ TEST_F(AirloopUnitarySysTest, MultipleWaterCoolingCoilSizing) // set up water coil int CoilNum = 1; state->dataWaterCoils->WaterCoil(CoilNum).Name = "Test Water Cooling Coil"; + state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc.loopNum = 1; state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand; state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc.branchNum = 1; state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc.compNum = 1; + state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc.loop = &state->dataPlnt->PlantLoop(1); + state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc.side = &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand); + state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc.branch = + &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1); + state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc.comp = + &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1); + state->dataWaterCoils->WaterCoil(CoilNum).WaterCoilType = DataPlant::PlantEquipmentType::CoilWaterCooling; state->dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true; state->dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = DataSizing::AutoSize; @@ -419,10 +427,18 @@ TEST_F(AirloopUnitarySysTest, MultipleWaterCoolingCoilSizing) state->dataWaterCoils->WaterCoil(CoilNum).AirInletNodeNum = 7; state->dataWaterCoils->WaterCoil(CoilNum).AirOutletNodeNum = 8; state->dataWaterCoils->WaterCoil(CoilNum).Name = "Test Water Heating Coil"; + state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc.loopNum = 2; state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand; state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc.branchNum = 1; state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc.compNum = 1; + state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc.loop = &state->dataPlnt->PlantLoop(2); + state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc.side = &state->dataPlnt->PlantLoop(2).LoopSide(DataPlant::LoopSideLocation::Demand); + state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc.branch = + &state->dataPlnt->PlantLoop(2).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1); + state->dataWaterCoils->WaterCoil(CoilNum).WaterPlantLoc.comp = + &state->dataPlnt->PlantLoop(2).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1); + state->dataWaterCoils->WaterCoil(CoilNum).WaterCoilType = DataPlant::PlantEquipmentType::CoilWaterSimpleHeating; state->dataWaterCoils->WaterCoil(CoilNum).RequestingAutoSize = true; state->dataWaterCoils->WaterCoil(CoilNum).DesAirVolFlowRate = DataSizing::AutoSize; @@ -8357,10 +8373,6 @@ TEST_F(EnergyPlusFixture, UnitarySystemModel_CalcUnitaryHeatingSystem) state->dataLoopNodes->Node(state->dataWaterCoils->WaterCoil(1).AirInletNodeNum).MassFlowRate = AirMassFlowRate; state->dataLoopNodes->Node(state->dataWaterCoils->WaterCoil(1).AirInletNodeNum).MassFlowRateMax = AirMassFlowRate; - state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loopNum = 1; - state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand; - state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.branchNum = 1; - state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.compNum = 1; state->dataWaterCoils->WaterCoil(1).WaterInletNodeNum = 6; state->dataWaterCoils->WaterCoil(1).WaterOutletNodeNum = 7; state->dataWaterCoils->WaterCoil(1).InletWaterTemp = 60.0; @@ -8390,6 +8402,16 @@ TEST_F(EnergyPlusFixture, UnitarySystemModel_CalcUnitaryHeatingSystem) state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumIn = state->dataWaterCoils->WaterCoil(1).WaterInletNodeNum; + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loopNum = 1; + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand; + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.branchNum = 1; + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.compNum = 1; + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loop = &state->dataPlnt->PlantLoop(1); + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.side = &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand); + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.branch = &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1); + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.comp = + &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1); + thisSys.m_HeatingCoilIndex = 1; thisSys.m_HeatingCoilName = state->dataWaterCoils->WaterCoil(1).Name; thisSys.HeatCoilFluidInletNode = state->dataWaterCoils->WaterCoil(1).WaterInletNodeNum; @@ -8512,10 +8534,6 @@ TEST_F(EnergyPlusFixture, UnitarySystemModel_CalcUnitaryCoolingSystem) state->dataLoopNodes->Node(state->dataWaterCoils->WaterCoil(1).AirInletNodeNum).Temp, state->dataLoopNodes->Node(state->dataWaterCoils->WaterCoil(1).AirInletNodeNum).Enthalpy); - state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loopNum = 1; - state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand; - state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.branchNum = 1; - state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.compNum = 1; state->dataWaterCoils->WaterCoil(1).WaterInletNodeNum = 6; state->dataWaterCoils->WaterCoil(1).WaterOutletNodeNum = 7; state->dataWaterCoils->WaterCoil(1).InletWaterMassFlowRate = ColdWaterMassFlowRate; @@ -8543,6 +8561,16 @@ TEST_F(EnergyPlusFixture, UnitarySystemModel_CalcUnitaryCoolingSystem) state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumIn = state->dataWaterCoils->WaterCoil(1).WaterInletNodeNum; + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loopNum = 1; + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand; + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.branchNum = 1; + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.compNum = 1; + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loop = &state->dataPlnt->PlantLoop(1); + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.side = &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand); + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.branch = &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1); + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.comp = + &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1); + thisSys.m_CoolingCoilIndex = 1; thisSys.m_CoolingCoilName = state->dataWaterCoils->WaterCoil(1).Name; thisSys.CoolCoilFluidInletNode = state->dataWaterCoils->WaterCoil(1).WaterInletNodeNum; @@ -22298,10 +22326,6 @@ TEST_F(EnergyPlusFixture, CoilSystemCoolingWater_ControlStatusTest) state->dataLoopNodes->Node(state->dataWaterCoils->WaterCoil(1).AirInletNodeNum).Temp, state->dataLoopNodes->Node(state->dataWaterCoils->WaterCoil(1).AirInletNodeNum).Enthalpy); - state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loopNum = 1; - state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand; - state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.branchNum = 1; - state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.compNum = 1; state->dataWaterCoils->WaterCoil(1).InletWaterMassFlowRate = ColdWaterMassFlowRate; state->dataWaterCoils->WaterCoil(1).MaxWaterMassFlowRate = ColdWaterMassFlowRate; state->dataLoopNodes->Node(state->dataWaterCoils->WaterCoil(1).WaterInletNodeNum).Temp = state->dataWaterCoils->WaterCoil(1).InletWaterTemp; @@ -22331,6 +22355,16 @@ TEST_F(EnergyPlusFixture, CoilSystemCoolingWater_ControlStatusTest) state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumOut = state->dataWaterCoils->WaterCoil(1).WaterOutletNodeNum; + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loopNum = 1; + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand; + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.branchNum = 1; + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.compNum = 1; + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loop = &state->dataPlnt->PlantLoop(1); + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.side = &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand); + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.branch = &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1); + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.comp = + &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1); + thisSys.CoolCoilFluidInletNode = state->dataWaterCoils->WaterCoil(1).WaterInletNodeNum; thisSys.CoolCoilFluidOutletNodeNum = state->dataWaterCoils->WaterCoil(1).WaterOutletNodeNum; thisSys.CoolCtrlNode = thisSys.AirOutNode; @@ -22551,10 +22585,6 @@ TEST_F(EnergyPlusFixture, CoilSystemCoolingWater_CalcTest) state->dataLoopNodes->Node(state->dataWaterCoils->WaterCoil(1).AirInletNodeNum).Temp, state->dataLoopNodes->Node(state->dataWaterCoils->WaterCoil(1).AirInletNodeNum).Enthalpy); - state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loopNum = 1; - state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand; - state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.branchNum = 1; - state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.compNum = 1; state->dataLoopNodes->Node(state->dataWaterCoils->WaterCoil(1).WaterInletNodeNum).Temp = state->dataWaterCoils->WaterCoil(1).InletWaterTemp; state->dataLoopNodes->Node(state->dataWaterCoils->WaterCoil(1).WaterInletNodeNum).MassFlowRate = ColdWaterMassFlowRate; state->dataLoopNodes->Node(state->dataWaterCoils->WaterCoil(1).WaterInletNodeNum).MassFlowRateMaxAvail = ColdWaterMassFlowRate; @@ -22581,6 +22611,17 @@ TEST_F(EnergyPlusFixture, CoilSystemCoolingWater_CalcTest) state->dataWaterCoils->WaterCoil(1).WaterInletNodeNum; state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumOut = state->dataWaterCoils->WaterCoil(1).WaterOutletNodeNum; + + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loopNum = 1; + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand; + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.branchNum = 1; + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.compNum = 1; + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.loop = &state->dataPlnt->PlantLoop(1); + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.side = &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand); + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.branch = &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1); + state->dataWaterCoils->WaterCoil(1).WaterPlantLoc.comp = + &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1); + thisSys.CoolCoilFluidInletNode = state->dataWaterCoils->WaterCoil(1).WaterInletNodeNum; thisSys.CoolCoilFluidOutletNodeNum = state->dataWaterCoils->WaterCoil(1).WaterOutletNodeNum; thisSys.CoolCtrlNode = thisSys.AirOutNode; @@ -22819,10 +22860,6 @@ TEST_F(EnergyPlusFixture, CoilSystemCoolingWater_HeatRecoveryLoop) state->dataLoopNodes->Node(state->dataWaterCoils->WaterCoil(i).AirInletNodeNum).Temp, state->dataLoopNodes->Node(state->dataWaterCoils->WaterCoil(i).AirInletNodeNum).Enthalpy); - state->dataWaterCoils->WaterCoil(i).WaterPlantLoc.loopNum = 1; - state->dataWaterCoils->WaterCoil(i).WaterPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand; - state->dataWaterCoils->WaterCoil(i).WaterPlantLoc.branchNum = 1; - state->dataWaterCoils->WaterCoil(i).WaterPlantLoc.compNum = i; state->dataLoopNodes->Node(state->dataWaterCoils->WaterCoil(i).WaterInletNodeNum).Temp = state->dataWaterCoils->WaterCoil(i).InletWaterTemp; state->dataLoopNodes->Node(state->dataWaterCoils->WaterCoil(i).WaterInletNodeNum).MassFlowRate = ColdWaterMassFlowRate; state->dataLoopNodes->Node(state->dataWaterCoils->WaterCoil(i).WaterInletNodeNum).MassFlowRateMax = ColdWaterMassFlowRate; @@ -22851,6 +22888,20 @@ TEST_F(EnergyPlusFixture, CoilSystemCoolingWater_HeatRecoveryLoop) state->dataWaterCoils->WaterCoil(1).WaterInletNodeNum; state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumOut = state->dataWaterCoils->WaterCoil(1).WaterOutletNodeNum; + + for (int i = 1; i <= 2; ++i) { + state->dataWaterCoils->WaterCoil(i).WaterPlantLoc.loopNum = 1; + state->dataWaterCoils->WaterCoil(i).WaterPlantLoc.loopSideNum = DataPlant::LoopSideLocation::Demand; + state->dataWaterCoils->WaterCoil(i).WaterPlantLoc.branchNum = 1; + state->dataWaterCoils->WaterCoil(i).WaterPlantLoc.compNum = i; + state->dataWaterCoils->WaterCoil(i).WaterPlantLoc.loop = &state->dataPlnt->PlantLoop(1); + state->dataWaterCoils->WaterCoil(i).WaterPlantLoc.side = &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand); + state->dataWaterCoils->WaterCoil(i).WaterPlantLoc.branch = + &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1); + state->dataWaterCoils->WaterCoil(i).WaterPlantLoc.comp = + &state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(i); + } + thisSys.CoolCoilFluidInletNode = state->dataWaterCoils->WaterCoil(1).WaterInletNodeNum; thisSys.CoolCoilFluidOutletNodeNum = state->dataWaterCoils->WaterCoil(1).WaterOutletNodeNum; thisSys.CoolCtrlNode = thisSys.AirOutNode; diff --git a/tst/EnergyPlus/unit/WaterThermalTanks.unit.cc b/tst/EnergyPlus/unit/WaterThermalTanks.unit.cc index ef8aaebef30..c94ee10876d 100644 --- a/tst/EnergyPlus/unit/WaterThermalTanks.unit.cc +++ b/tst/EnergyPlus/unit/WaterThermalTanks.unit.cc @@ -3955,9 +3955,11 @@ TEST_F(EnergyPlusFixture, Desuperheater_WAHP_VSEQ_Coil_Test) const Real64 Cp = Fluid::GetWater(*state)->getSpecificHeat(*state, 27.0, "WAHP_VSEQ_SOURCE"); state->dataVariableSpeedCoils->VarSpeedCoil(1).InletWaterEnthalpy = 27.0 * Cp; - state->dataVariableSpeedCoils->VarSpeedCoil(1).plantLoc.loopNum = PlantLoopNum; state->dataPlnt->PlantLoop.allocate(PlantLoopNum); + state->dataVariableSpeedCoils->VarSpeedCoil(1).plantLoc.loopNum = PlantLoopNum; + state->dataVariableSpeedCoils->VarSpeedCoil(1).plantLoc.loop = &state->dataPlnt->PlantLoop(PlantLoopNum); + state->dataPlnt->PlantLoop(PlantLoopNum).glycol = Fluid::GetWater(*state); state->dataPlnt->PlantLoop(PlantLoopNum).FluidName = "WATER"; state->dataLoopNodes->Node(5).MassFlowRate = state->dataVariableSpeedCoils->VarSpeedCoil(1).MSRatedAirMassFlowRate(2); diff --git a/tst/EnergyPlus/unit/WaterToAirHeatPumpSimple.unit.cc b/tst/EnergyPlus/unit/WaterToAirHeatPumpSimple.unit.cc index 6d552d709cb..77fb8bd74bc 100644 --- a/tst/EnergyPlus/unit/WaterToAirHeatPumpSimple.unit.cc +++ b/tst/EnergyPlus/unit/WaterToAirHeatPumpSimple.unit.cc @@ -1267,6 +1267,7 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpSimpleTest_SizeHVACWaterToAirRatedCo state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumIn = state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).WaterInletNodeNum; state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).plantLoc.loopNum = 1; + state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).plantLoc.loop = &state->dataPlnt->PlantLoop(1); state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(2).Name = state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).Name; @@ -1275,6 +1276,7 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpSimpleTest_SizeHVACWaterToAirRatedCo state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(2).NodeNumIn = state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).WaterInletNodeNum; state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).plantLoc.loopNum = 1; + state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).plantLoc.loop = &state->dataPlnt->PlantLoop(1); // plant loop design leaving water temperature (design entering water temperature for WAHP coil) state->dataSize->NumPltSizInput = 1; @@ -1503,6 +1505,7 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpSimpleTest_SizeHVACWaterToAirRatedCo state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(1).NodeNumIn = state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).WaterInletNodeNum; state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).plantLoc.loopNum = 1; + state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(1).plantLoc.loop = &state->dataPlnt->PlantLoop(1); state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(2).Name = state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).Name; @@ -1511,6 +1514,7 @@ TEST_F(EnergyPlusFixture, WaterToAirHeatPumpSimpleTest_SizeHVACWaterToAirRatedCo state->dataPlnt->PlantLoop(1).LoopSide(DataPlant::LoopSideLocation::Demand).Branch(1).Comp(2).NodeNumIn = state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).WaterInletNodeNum; state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).plantLoc.loopNum = 1; + state->dataWaterToAirHeatPumpSimple->SimpleWatertoAirHP(2).plantLoc.loop = &state->dataPlnt->PlantLoop(1); // plant loop design leaving water temperature (design entering water temperature for WAHP coil) state->dataSize->NumPltSizInput = 1;