Line data Source code
1 : // EnergyPlus, Copyright (c) 1996-2024, The Board of Trustees of the University of Illinois,
2 : // The Regents of the University of California, through Lawrence Berkeley National Laboratory
3 : // (subject to receipt of any required approvals from the U.S. Dept. of Energy), Oak Ridge
4 : // National Laboratory, managed by UT-Battelle, Alliance for Sustainable Energy, LLC, and other
5 : // contributors. All rights reserved.
6 : //
7 : // NOTICE: This Software was developed under funding from the U.S. Department of Energy and the
8 : // U.S. Government consequently retains certain rights. As such, the U.S. Government has been
9 : // granted for itself and others acting on its behalf a paid-up, nonexclusive, irrevocable,
10 : // worldwide license in the Software to reproduce, distribute copies to the public, prepare
11 : // derivative works, and perform publicly and display publicly, and to permit others to do so.
12 : //
13 : // Redistribution and use in source and binary forms, with or without modification, are permitted
14 : // provided that the following conditions are met:
15 : //
16 : // (1) Redistributions of source code must retain the above copyright notice, this list of
17 : // conditions and the following disclaimer.
18 : //
19 : // (2) Redistributions in binary form must reproduce the above copyright notice, this list of
20 : // conditions and the following disclaimer in the documentation and/or other materials
21 : // provided with the distribution.
22 : //
23 : // (3) Neither the name of the University of California, Lawrence Berkeley National Laboratory,
24 : // the University of Illinois, U.S. Dept. of Energy nor the names of its contributors may be
25 : // used to endorse or promote products derived from this software without specific prior
26 : // written permission.
27 : //
28 : // (4) Use of EnergyPlus(TM) Name. If Licensee (i) distributes the software in stand-alone form
29 : // without changes from the version obtained under this License, or (ii) Licensee makes a
30 : // reference solely to the software portion of its product, Licensee must refer to the
31 : // software as "EnergyPlus version X" software, where "X" is the version number Licensee
32 : // obtained under this License and may not use a different name for the software. Except as
33 : // specifically required in this Section (4), Licensee shall not use in a company name, a
34 : // product name, in advertising, publicity, or other promotional activities any name, trade
35 : // name, trademark, logo, or other designation of "EnergyPlus", "E+", "e+" or confusingly
36 : // similar designation, without the U.S. Department of Energy's prior written consent.
37 : //
38 : // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
39 : // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
40 : // AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
41 : // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
42 : // CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
43 : // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
44 : // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
45 : // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
46 : // POSSIBILITY OF SUCH DAMAGE.
47 :
48 : // C++ Headers
49 : #include <cmath>
50 :
51 : // ObjexxFCL Headers
52 : #include <ObjexxFCL/Array.functions.hh>
53 :
54 : // EnergyPlus Headers
55 : #include <EnergyPlus/Autosizing/HeatingCapacitySizing.hh>
56 : #include <EnergyPlus/BranchNodeConnections.hh>
57 : #include <EnergyPlus/Data/EnergyPlusData.hh>
58 : #include <EnergyPlus/DataHVACGlobals.hh>
59 : #include <EnergyPlus/DataHeatBalFanSys.hh>
60 : #include <EnergyPlus/DataHeatBalSurface.hh>
61 : #include <EnergyPlus/DataHeatBalance.hh>
62 : #include <EnergyPlus/DataIPShortCuts.hh>
63 : #include <EnergyPlus/DataLoopNode.hh>
64 : #include <EnergyPlus/DataSizing.hh>
65 : #include <EnergyPlus/DataSurfaces.hh>
66 : #include <EnergyPlus/DataZoneEnergyDemands.hh>
67 : #include <EnergyPlus/DataZoneEquipment.hh>
68 : #include <EnergyPlus/FluidProperties.hh>
69 : #include <EnergyPlus/General.hh>
70 : #include <EnergyPlus/GeneralRoutines.hh>
71 : #include <EnergyPlus/GlobalNames.hh>
72 : #include <EnergyPlus/HeatBalanceIntRadExchange.hh>
73 : #include <EnergyPlus/HeatBalanceSurfaceManager.hh>
74 : #include <EnergyPlus/InputProcessing/InputProcessor.hh>
75 : #include <EnergyPlus/NodeInputManager.hh>
76 : #include <EnergyPlus/OutputProcessor.hh>
77 : #include <EnergyPlus/Plant/DataPlant.hh>
78 : #include <EnergyPlus/PlantUtilities.hh>
79 : #include <EnergyPlus/ScheduleManager.hh>
80 : #include <EnergyPlus/SteamBaseboardRadiator.hh>
81 : #include <EnergyPlus/UtilityRoutines.hh>
82 :
83 : namespace EnergyPlus {
84 :
85 : namespace SteamBaseboardRadiator {
86 :
87 : // Module -- (ref: Object: ZoneHVAC:Baseboard:RadiantConvective:Steam)
88 :
89 : // Module containing the routines dealing with the steam baseboard heaters
90 :
91 : // MODULE INFORMATION:
92 : // AUTHOR Daeho Kang
93 : // DATE WRITTEN September 2009
94 : // MODIFIED na
95 : // RE-ENGINEERED na
96 :
97 : // PURPOSE OF THIS MODULE:
98 : // The purpose of this module is to simulate steam baseboard heaters.
99 :
100 : // METHODOLOGY EMPLOYED:
101 :
102 : // REFERENCES:
103 : // 1. HWBaseboardRadiator module (ZoneHVAC:Baseboard:RadiantConvective:Water)
104 : // 2. SteamCoils module (Coil:Heating:Steam)
105 :
106 : using DataLoopNode::ObjectIsNotParent;
107 : using HVAC::SmallLoad;
108 :
109 : using DataZoneEquipment::CheckZoneEquipmentList;
110 :
111 : static constexpr std::string_view fluidNameSteam("STEAM");
112 :
113 7356 : void SimSteamBaseboard(EnergyPlusData &state,
114 : std::string const &EquipName,
115 : int const ControlledZoneNum,
116 : bool const FirstHVACIteration,
117 : Real64 &PowerMet,
118 : int &CompIndex)
119 : {
120 :
121 : // SUBROUTINE INFORMATION:
122 : // AUTHOR Russ Taylor
123 : // DATE WRITTEN Nov 1997
124 : // MODIFIED
125 : // RE-ENGINEERED na
126 :
127 : // PURPOSE OF THIS SUBROUTINE:
128 : // This subroutine simulates the steam baseboards or radiators.
129 :
130 : using PlantUtilities::SetComponentFlowRate;
131 : using ScheduleManager::GetCurrentScheduleValue;
132 :
133 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
134 : int BaseboardNum; // index of unit in baseboard array
135 : Real64 QZnReq; // zone load not yet satisfied
136 : Real64 MaxSteamFlow;
137 : Real64 MinSteamFlow;
138 :
139 7356 : if (state.dataSteamBaseboardRadiator->GetInputFlag) {
140 1 : GetSteamBaseboardInput(state);
141 1 : state.dataSteamBaseboardRadiator->GetInputFlag = false;
142 : }
143 :
144 : // Find the correct Baseboard Equipment
145 7356 : if (CompIndex == 0) {
146 2 : BaseboardNum = Util::FindItemInList(EquipName, state.dataSteamBaseboardRadiator->SteamBaseboard, &SteamBaseboardParams::EquipID);
147 2 : if (BaseboardNum == 0) {
148 0 : ShowFatalError(state, format("SimSteamBaseboard: Unit not found={}", EquipName));
149 : }
150 2 : CompIndex = BaseboardNum;
151 : } else {
152 7354 : BaseboardNum = CompIndex;
153 7354 : if (BaseboardNum > state.dataSteamBaseboardRadiator->NumSteamBaseboards || BaseboardNum < 1) {
154 0 : ShowFatalError(state,
155 0 : format("SimSteamBaseboard: Invalid CompIndex passed={}, Number of Units={}, Entered Unit name={}",
156 : BaseboardNum,
157 0 : state.dataSteamBaseboardRadiator->NumSteamBaseboards,
158 : EquipName));
159 : }
160 7354 : if (state.dataSteamBaseboardRadiator->CheckEquipName(BaseboardNum)) {
161 2 : if (EquipName != state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID) {
162 0 : ShowFatalError(state,
163 0 : format("SimSteamBaseboard: Invalid CompIndex passed={}, Unit name={}, stored Unit Name for that index={}",
164 : BaseboardNum,
165 : EquipName,
166 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID));
167 : }
168 2 : state.dataSteamBaseboardRadiator->CheckEquipName(BaseboardNum) = false;
169 : }
170 : }
171 :
172 7356 : if (CompIndex > 0) {
173 :
174 7356 : InitSteamBaseboard(state, BaseboardNum, ControlledZoneNum, FirstHVACIteration);
175 :
176 7356 : QZnReq = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(ControlledZoneNum).RemainingOutputReqToHeatSP;
177 :
178 7356 : SteamBaseboardDesignData SteamBaseboardDesignDataObject{state.dataSteamBaseboardRadiator->SteamBaseboardDesign(
179 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum)
180 7356 : .DesignObjectPtr)}; // Array that contains the design data for steam baseboard objects
181 :
182 10111 : if (QZnReq > SmallLoad && !state.dataZoneEnergyDemand->CurDeadBandOrSetback(ControlledZoneNum) &&
183 2755 : (GetCurrentScheduleValue(state, state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SchedPtr) > 0.0)) {
184 :
185 : // On the first HVAC iteration the system values are given to the controller, but after that
186 : // the demand limits are in place and there needs to be feedback to the Zone Equipment
187 2755 : if (FirstHVACIteration) {
188 1378 : MaxSteamFlow = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamMassFlowRateMax;
189 1378 : MinSteamFlow = 0.0;
190 : } else {
191 1377 : MaxSteamFlow =
192 1377 : state.dataLoopNodes->Node(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletNode).MassFlowRateMaxAvail;
193 1377 : MinSteamFlow =
194 1377 : state.dataLoopNodes->Node(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletNode).MassFlowRateMinAvail;
195 : }
196 :
197 2755 : switch (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipType) {
198 2755 : case DataPlant::PlantEquipmentType::Baseboard_Rad_Conv_Steam: { // 'ZoneHVAC:Baseboard:RadiantConvective:Steam'
199 8265 : ControlCompOutput(state,
200 2755 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID,
201 2755 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
202 : BaseboardNum,
203 : FirstHVACIteration,
204 : QZnReq,
205 2755 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletNode,
206 : MaxSteamFlow,
207 : MinSteamFlow,
208 : SteamBaseboardDesignDataObject.Offset,
209 2755 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ControlCompTypeNum,
210 2755 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).CompErrIndex,
211 : _,
212 : _,
213 : _,
214 : _,
215 : _,
216 2755 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).plantLoc);
217 2755 : } break;
218 0 : default: {
219 0 : ShowSevereError(
220 : state,
221 0 : format("SimSteamBaseboard: Errors in Baseboard={}", state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID));
222 0 : ShowContinueError(state,
223 0 : format("Invalid or unimplemented equipment type={}",
224 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipType));
225 0 : ShowFatalError(state, "Preceding condition causes termination.");
226 0 : } break;
227 : }
228 :
229 2755 : PowerMet = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotPower;
230 : } else {
231 : // baseboard is off, don't bother going into ControlCompOutput
232 4601 : Real64 mdot = 0.0;
233 9202 : SetComponentFlowRate(state,
234 : mdot,
235 4601 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletNode,
236 4601 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletNode,
237 4601 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).plantLoc);
238 4601 : CalcSteamBaseboard(state, BaseboardNum, PowerMet);
239 : }
240 :
241 7356 : UpdateSteamBaseboard(state, BaseboardNum);
242 :
243 7356 : ReportSteamBaseboard(state, BaseboardNum);
244 :
245 7356 : } else {
246 0 : ShowFatalError(state, format("SimSteamBaseboard: Unit not found={}", EquipName));
247 : }
248 7356 : }
249 :
250 1 : void GetSteamBaseboardInput(EnergyPlusData &state)
251 : {
252 :
253 : // SUBROUTINE INFORMATION:
254 : // AUTHOR Daeho Kang
255 : // DATE WRITTEN September 2009
256 : // MODIFIED na
257 : // RE-ENGINEERED na
258 :
259 : // PURPOSE OF THIS SUBROUTINE:
260 : // This subroutine gets the input for the baseboard units.
261 :
262 : // METHODOLOGY EMPLOYED:
263 : // Standard input processor calls.
264 :
265 : // REFERENCES:
266 : // HWBaseboardRadiator module
267 :
268 : // Using/Aliasing
269 : using BranchNodeConnections::TestCompSet;
270 :
271 : using GlobalNames::VerifyUniqueBaseboardName;
272 : using NodeInputManager::GetOnlySingleNode;
273 : using ScheduleManager::GetCurrentScheduleValue;
274 : using ScheduleManager::GetScheduleIndex;
275 : using namespace DataSizing;
276 :
277 : // SUBROUTINE PARAMETER DEFINITIONS:
278 : static constexpr std::string_view RoutineName("GetSteamBaseboardInput:");
279 1 : Real64 constexpr MaxFraction(1.0); // Maximum limit of fractional values
280 1 : Real64 constexpr MinFraction(0.0); // Minimum limit of fractional values
281 1 : Real64 constexpr MaxSteamFlowRate(10.0); // Maximum limit of steam volume flow rate in m3/s
282 1 : Real64 constexpr MinSteamFlowRate(0.0); // Minimum limit of steam volume flow rate in m3/s
283 : // INTEGER,PARAMETER :: MaxDistribSurfaces = 20 ! Maximum number of surfaces that a baseboard heater can radiate to
284 1 : int constexpr MinDistribSurfaces(1); // Minimum number of surfaces that a baseboard heater can radiate to
285 1 : int constexpr iHeatCAPMAlphaNum(2); // get input index to steam baseboard Radiator system heating capacity sizing method
286 1 : int constexpr iHeatDesignCapacityNumericNum(1); // get input index to steam baseboard Radiator system electric heating capacity
287 1 : int constexpr iHeatCapacityPerFloorAreaNumericNum(
288 : 1); // get input index to steam baseboard Radiator system electric heating capacity per floor area sizing
289 1 : int constexpr iHeatFracOfAutosizedCapacityNumericNum(
290 : 2); // get input index to steam baseboard Radiator system electric heating capacity sizing as fraction of autozized heating capacity
291 :
292 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
293 : int BaseboardNum; // Baseboard number
294 1 : int BaseboardDesignNum(0); // Baseboard number
295 : int NumAlphas; // Number of Alphas for each GetobjectItem call
296 : int NumNumbers; // Number of Numbers for each GetobjectItem call
297 : int SurfNum; // Surface number Do loop counter
298 : int IOStat;
299 1 : bool ErrorsFound(false); // If errors detected in input
300 : bool SteamMessageNeeded;
301 :
302 1 : SteamMessageNeeded = true;
303 2 : state.dataSteamBaseboardRadiator->NumSteamBaseboards =
304 1 : state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam);
305 2 : state.dataSteamBaseboardRadiator->NumSteamBaseboardsDesign =
306 1 : state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam_Design);
307 :
308 : // Count total number of baseboard units
309 :
310 1 : state.dataSteamBaseboardRadiator->SteamBaseboard.allocate(state.dataSteamBaseboardRadiator->NumSteamBaseboards);
311 1 : state.dataSteamBaseboardRadiator->CheckEquipName.dimension(state.dataSteamBaseboardRadiator->NumSteamBaseboards, true);
312 1 : state.dataSteamBaseboardRadiator->SteamBaseboardNumericFields.allocate(state.dataSteamBaseboardRadiator->NumSteamBaseboards);
313 :
314 : // Count total number of baseboard design objects
315 :
316 1 : state.dataSteamBaseboardRadiator->SteamBaseboardDesign.allocate(state.dataSteamBaseboardRadiator->NumSteamBaseboardsDesign);
317 1 : state.dataSteamBaseboardRadiator->CheckDesignObjectName.dimension(state.dataSteamBaseboardRadiator->NumSteamBaseboardsDesign, true);
318 1 : state.dataSteamBaseboardRadiator->SteamBaseboardDesignNumericFields.allocate(state.dataSteamBaseboardRadiator->NumSteamBaseboardsDesign);
319 1 : state.dataSteamBaseboardRadiator->SteamBaseboardDesignNames.allocate(state.dataSteamBaseboardRadiator->NumSteamBaseboardsDesign);
320 :
321 : // Get the data from the user input related to baseboard heater designobjects
322 2 : for (BaseboardDesignNum = 1; BaseboardDesignNum <= state.dataSteamBaseboardRadiator->NumSteamBaseboardsDesign; ++BaseboardDesignNum) {
323 :
324 2 : state.dataInputProcessing->inputProcessor->getObjectItem(state,
325 1 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam_Design,
326 : BaseboardDesignNum,
327 1 : state.dataIPShortCut->cAlphaArgs,
328 : NumAlphas,
329 1 : state.dataIPShortCut->rNumericArgs,
330 : NumNumbers,
331 : IOStat,
332 1 : state.dataIPShortCut->lNumericFieldBlanks,
333 1 : state.dataIPShortCut->lAlphaFieldBlanks,
334 1 : state.dataIPShortCut->cAlphaFieldNames,
335 1 : state.dataIPShortCut->cNumericFieldNames);
336 1 : Util::IsNameEmpty(
337 2 : state, state.dataIPShortCut->cAlphaArgs(1), state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam_Design, ErrorsFound);
338 1 : state.dataSteamBaseboardRadiator->SteamBaseboardDesignNumericFields(BaseboardDesignNum).FieldNames.allocate(NumNumbers);
339 1 : state.dataSteamBaseboardRadiator->SteamBaseboardDesignNumericFields(BaseboardDesignNum).FieldNames = "";
340 1 : state.dataSteamBaseboardRadiator->SteamBaseboardDesignNumericFields(BaseboardDesignNum).FieldNames =
341 2 : state.dataIPShortCut->cNumericFieldNames;
342 :
343 : // ErrorsFound will be set to True if problem was found, left untouched otherwise
344 1 : VerifyUniqueBaseboardName(state,
345 1 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam_Design,
346 1 : state.dataIPShortCut->cAlphaArgs(1),
347 : ErrorsFound,
348 2 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam_Design + " Name");
349 :
350 1 : state.dataSteamBaseboardRadiator->SteamBaseboardDesign(BaseboardDesignNum).designName =
351 2 : state.dataIPShortCut->cAlphaArgs(1); // Name of the design object of baseboard
352 1 : state.dataSteamBaseboardRadiator->SteamBaseboardDesignNames(BaseboardDesignNum) =
353 2 : state.dataIPShortCut->cAlphaArgs(1); // Add to array of design object names
354 :
355 : // Determine steam baseboard radiator system heating design capacity sizing method
356 1 : if (Util::SameString(state.dataIPShortCut->cAlphaArgs(iHeatCAPMAlphaNum), "HeatingDesignCapacity")) {
357 1 : state.dataSteamBaseboardRadiator->SteamBaseboardDesign(BaseboardDesignNum).HeatingCapMethod = HeatingDesignCapacity;
358 0 : } else if (Util::SameString(state.dataIPShortCut->cAlphaArgs(iHeatCAPMAlphaNum), "CapacityPerFloorArea")) {
359 0 : state.dataSteamBaseboardRadiator->SteamBaseboardDesign(BaseboardDesignNum).HeatingCapMethod = CapacityPerFloorArea;
360 0 : if (!state.dataIPShortCut->lNumericFieldBlanks(iHeatCapacityPerFloorAreaNumericNum)) {
361 0 : state.dataSteamBaseboardRadiator->SteamBaseboardDesign(BaseboardDesignNum).DesignScaledHeatingCapacity =
362 0 : state.dataIPShortCut->rNumericArgs(iHeatCapacityPerFloorAreaNumericNum);
363 0 : if (state.dataSteamBaseboardRadiator->SteamBaseboardDesign(BaseboardDesignNum).DesignScaledHeatingCapacity <= 0.0) {
364 0 : ShowSevereError(state,
365 0 : format("{} = {}",
366 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam_Design,
367 0 : state.dataSteamBaseboardRadiator->SteamBaseboardDesign(BaseboardDesignNum).designName));
368 0 : ShowContinueError(state,
369 0 : format("Input for {} = {}",
370 0 : state.dataIPShortCut->cAlphaFieldNames(iHeatCAPMAlphaNum),
371 0 : state.dataIPShortCut->cAlphaArgs(iHeatCAPMAlphaNum)));
372 0 : ShowContinueError(state,
373 0 : format("Illegal {} = {:.7T}",
374 0 : state.dataIPShortCut->cNumericFieldNames(iHeatCapacityPerFloorAreaNumericNum),
375 0 : state.dataIPShortCut->rNumericArgs(iHeatCapacityPerFloorAreaNumericNum)));
376 0 : ErrorsFound = true;
377 0 : } else if (state.dataSteamBaseboardRadiator->SteamBaseboardDesign(BaseboardDesignNum).DesignScaledHeatingCapacity == AutoSize) {
378 0 : ShowSevereError(state,
379 0 : format("{} = {}",
380 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam_Design,
381 0 : state.dataSteamBaseboardRadiator->SteamBaseboardDesign(BaseboardDesignNum).designName));
382 0 : ShowContinueError(state,
383 0 : format("Input for {} = {}",
384 0 : state.dataIPShortCut->cAlphaFieldNames(iHeatCAPMAlphaNum),
385 0 : state.dataIPShortCut->cAlphaArgs(iHeatCAPMAlphaNum)));
386 0 : ShowContinueError(
387 0 : state, format("Illegal {} = Autosize", state.dataIPShortCut->cNumericFieldNames(iHeatCapacityPerFloorAreaNumericNum)));
388 0 : ErrorsFound = true;
389 : }
390 : } else {
391 0 : ShowSevereError(state,
392 0 : format("{} = {}",
393 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam_Design,
394 0 : state.dataSteamBaseboardRadiator->SteamBaseboardDesign(BaseboardDesignNum).designName));
395 0 : ShowContinueError(state,
396 0 : format("Input for {} = {}",
397 0 : state.dataIPShortCut->cAlphaFieldNames(iHeatCAPMAlphaNum),
398 0 : state.dataIPShortCut->cAlphaArgs(iHeatCAPMAlphaNum)));
399 0 : ShowContinueError(
400 : state,
401 0 : format("Blank field not allowed for {}", state.dataIPShortCut->cNumericFieldNames(iHeatCapacityPerFloorAreaNumericNum)));
402 0 : ErrorsFound = true;
403 : }
404 0 : } else if (Util::SameString(state.dataIPShortCut->cAlphaArgs(iHeatCAPMAlphaNum), "FractionOfAutosizedHeatingCapacity")) {
405 0 : state.dataSteamBaseboardRadiator->SteamBaseboardDesign(BaseboardDesignNum).HeatingCapMethod = FractionOfAutosizedHeatingCapacity;
406 0 : if (!state.dataIPShortCut->lNumericFieldBlanks(iHeatFracOfAutosizedCapacityNumericNum)) {
407 0 : state.dataSteamBaseboardRadiator->SteamBaseboardDesign(BaseboardDesignNum).DesignScaledHeatingCapacity =
408 0 : state.dataIPShortCut->rNumericArgs(iHeatFracOfAutosizedCapacityNumericNum);
409 0 : if (state.dataSteamBaseboardRadiator->SteamBaseboardDesign(BaseboardDesignNum).DesignScaledHeatingCapacity < 0.0) {
410 0 : ShowSevereError(state,
411 0 : format("{} = {}",
412 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam_Design,
413 0 : state.dataSteamBaseboardRadiator->SteamBaseboardDesign(BaseboardDesignNum).designName));
414 0 : ShowContinueError(state,
415 0 : format("Illegal {} = {:.7T}",
416 0 : state.dataIPShortCut->cNumericFieldNames(iHeatFracOfAutosizedCapacityNumericNum),
417 0 : state.dataIPShortCut->rNumericArgs(iHeatFracOfAutosizedCapacityNumericNum)));
418 0 : ErrorsFound = true;
419 : }
420 : } else {
421 0 : ShowSevereError(state,
422 0 : format("{} = {}",
423 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam_Design,
424 0 : state.dataSteamBaseboardRadiator->SteamBaseboardDesign(BaseboardDesignNum).designName));
425 0 : ShowContinueError(state,
426 0 : format("Input for {} = {}",
427 0 : state.dataIPShortCut->cAlphaFieldNames(iHeatCAPMAlphaNum),
428 0 : state.dataIPShortCut->cAlphaArgs(iHeatCAPMAlphaNum)));
429 0 : ShowContinueError(
430 : state,
431 0 : format("Blank field not allowed for {}", state.dataIPShortCut->cNumericFieldNames(iHeatFracOfAutosizedCapacityNumericNum)));
432 0 : ErrorsFound = true;
433 : }
434 : } else {
435 0 : ShowSevereError(state,
436 0 : format("{} = {}",
437 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam_Design,
438 0 : state.dataSteamBaseboardRadiator->SteamBaseboardDesign(BaseboardDesignNum).designName));
439 0 : ShowContinueError(state,
440 0 : format("Illegal {} = {}",
441 0 : state.dataIPShortCut->cAlphaFieldNames(iHeatCAPMAlphaNum),
442 0 : state.dataIPShortCut->cAlphaArgs(iHeatCAPMAlphaNum)));
443 0 : ErrorsFound = true;
444 : }
445 :
446 1 : state.dataSteamBaseboardRadiator->SteamBaseboardDesign(BaseboardDesignNum).Offset = state.dataIPShortCut->rNumericArgs(3);
447 : // Set default convergence tolerance
448 1 : if (state.dataSteamBaseboardRadiator->SteamBaseboardDesign(BaseboardDesignNum).Offset <= 0.0) {
449 0 : state.dataSteamBaseboardRadiator->SteamBaseboardDesign(BaseboardDesignNum).Offset = 0.001;
450 0 : ShowWarningError(state,
451 0 : format("{}{}=\"{}\", {} was less than the allowable minimum.",
452 : RoutineName,
453 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam_Design,
454 0 : state.dataIPShortCut->cAlphaArgs(1),
455 0 : state.dataIPShortCut->cNumericFieldNames(3)));
456 0 : ShowContinueError(state, "...reset to default value=[0.001].");
457 : }
458 :
459 : // Fraction of radiant heat out of the total heating rate of the unit
460 1 : state.dataSteamBaseboardRadiator->SteamBaseboardDesign(BaseboardDesignNum).FracRadiant = state.dataIPShortCut->rNumericArgs(4);
461 1 : if (state.dataSteamBaseboardRadiator->SteamBaseboardDesign(BaseboardDesignNum).FracRadiant < MinFraction) {
462 0 : ShowWarningError(state,
463 0 : format("{}{}=\"{}\", {} was lower than the allowable minimum.",
464 : RoutineName,
465 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam_Design,
466 0 : state.dataIPShortCut->cAlphaArgs(1),
467 0 : state.dataIPShortCut->cNumericFieldNames(4)));
468 0 : ShowContinueError(state, format("...reset to minimum value=[{:.3R}].", MinFraction));
469 0 : state.dataSteamBaseboardRadiator->SteamBaseboardDesign(BaseboardDesignNum).FracRadiant = MinFraction;
470 1 : } else if (state.dataSteamBaseboardRadiator->SteamBaseboardDesign(BaseboardDesignNum).FracRadiant > MaxFraction) {
471 0 : ShowWarningError(state,
472 0 : format("{}{}=\"{}\", {} was higher than the allowable maximum.",
473 : RoutineName,
474 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam_Design,
475 0 : state.dataIPShortCut->cAlphaArgs(1),
476 0 : state.dataIPShortCut->cNumericFieldNames(4)));
477 0 : ShowContinueError(state, format("...reset to maximum value=[{:.3R}].", MaxFraction));
478 0 : state.dataSteamBaseboardRadiator->SteamBaseboardDesign(BaseboardDesignNum).FracRadiant = MaxFraction;
479 : }
480 :
481 : // Fraction of radiant heat addition to the people within the radiant heating capacity specified by the user
482 1 : state.dataSteamBaseboardRadiator->SteamBaseboardDesign(BaseboardDesignNum).FracDistribPerson = state.dataIPShortCut->rNumericArgs(5);
483 1 : if (state.dataSteamBaseboardRadiator->SteamBaseboardDesign(BaseboardDesignNum).FracDistribPerson < MinFraction) {
484 0 : ShowWarningError(state,
485 0 : format("{}{}=\"{}\", {} was lower than the allowable minimum.",
486 : RoutineName,
487 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam_Design,
488 0 : state.dataIPShortCut->cAlphaArgs(1),
489 0 : state.dataIPShortCut->cNumericFieldNames(5)));
490 0 : ShowContinueError(state, format("...reset to minimum value=[{:.3R}].", MinFraction));
491 0 : state.dataSteamBaseboardRadiator->SteamBaseboardDesign(BaseboardDesignNum).FracDistribPerson = MinFraction;
492 : }
493 1 : if (state.dataSteamBaseboardRadiator->SteamBaseboardDesign(BaseboardDesignNum).FracDistribPerson > MaxFraction) {
494 0 : ShowWarningError(state,
495 0 : format("{}{}=\"{}\", {} was higher than the allowable maximum.",
496 : RoutineName,
497 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam_Design,
498 0 : state.dataIPShortCut->cAlphaArgs(1),
499 0 : state.dataIPShortCut->cNumericFieldNames(5)));
500 0 : ShowContinueError(state, format("...reset to maximum value=[{:.3R}].", MaxFraction));
501 0 : state.dataSteamBaseboardRadiator->SteamBaseboardDesign(BaseboardDesignNum).FracDistribPerson = MaxFraction;
502 : }
503 : }
504 :
505 : // Get the data from the user input related to baseboard heaters
506 3 : for (BaseboardNum = 1; BaseboardNum <= state.dataSteamBaseboardRadiator->NumSteamBaseboards; ++BaseboardNum) {
507 :
508 4 : state.dataInputProcessing->inputProcessor->getObjectItem(state,
509 2 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
510 : BaseboardNum,
511 2 : state.dataIPShortCut->cAlphaArgs,
512 : NumAlphas,
513 2 : state.dataIPShortCut->rNumericArgs,
514 : NumNumbers,
515 : IOStat,
516 2 : state.dataIPShortCut->lNumericFieldBlanks,
517 2 : state.dataIPShortCut->lAlphaFieldBlanks,
518 2 : state.dataIPShortCut->cAlphaFieldNames,
519 2 : state.dataIPShortCut->cNumericFieldNames);
520 2 : Util::IsNameEmpty(state, state.dataIPShortCut->cAlphaArgs(1), state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam, ErrorsFound);
521 2 : state.dataSteamBaseboardRadiator->SteamBaseboardNumericFields(BaseboardNum).FieldNames.allocate(NumNumbers);
522 2 : state.dataSteamBaseboardRadiator->SteamBaseboardNumericFields(BaseboardNum).FieldNames = "";
523 2 : state.dataSteamBaseboardRadiator->SteamBaseboardNumericFields(BaseboardNum).FieldNames = state.dataIPShortCut->cNumericFieldNames;
524 :
525 : // ErrorsFound will be set to True if problem was found, left untouched otherwise
526 2 : VerifyUniqueBaseboardName(state,
527 2 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
528 2 : state.dataIPShortCut->cAlphaArgs(1),
529 : ErrorsFound,
530 4 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam + " Name");
531 :
532 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID = state.dataIPShortCut->cAlphaArgs(1); // Name of the baseboard
533 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipType =
534 : DataPlant::PlantEquipmentType::Baseboard_Rad_Conv_Steam; //'ZoneHVAC:Baseboard:RadiantConvective:Steam'
535 :
536 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).designObjectName =
537 4 : state.dataIPShortCut->cAlphaArgs(2); // Name of the design object for this baseboard
538 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).DesignObjectPtr =
539 2 : Util::FindItemInList(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).designObjectName,
540 2 : state.dataSteamBaseboardRadiator->SteamBaseboardDesignNames);
541 : SteamBaseboardDesignData SteamBaseboardDesignDataObject{
542 2 : state.dataSteamBaseboardRadiator->SteamBaseboardDesign(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum)
543 2 : .DesignObjectPtr)}; // Contains the design data for steam baseboard object
544 :
545 : // Get schedule
546 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Schedule = state.dataIPShortCut->cAlphaArgs(3);
547 2 : if (state.dataIPShortCut->lAlphaFieldBlanks(3)) {
548 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SchedPtr = ScheduleManager::ScheduleAlwaysOn;
549 : } else {
550 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SchedPtr =
551 2 : GetScheduleIndex(state, state.dataIPShortCut->cAlphaArgs(3));
552 2 : if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SchedPtr == 0) {
553 0 : ShowSevereError(state,
554 0 : format("{}{}=\"{}\", {}=\"{}\" not found.",
555 : RoutineName,
556 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
557 0 : state.dataIPShortCut->cAlphaArgs(1),
558 0 : state.dataIPShortCut->cAlphaFieldNames(3),
559 0 : state.dataIPShortCut->cAlphaArgs(3)));
560 0 : ErrorsFound = true;
561 : }
562 : }
563 :
564 : // Get inlet node number
565 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletNode =
566 4 : GetOnlySingleNode(state,
567 2 : state.dataIPShortCut->cAlphaArgs(4),
568 : ErrorsFound,
569 : DataLoopNode::ConnectionObjectType::ZoneHVACBaseboardRadiantConvectiveSteam,
570 2 : state.dataIPShortCut->cAlphaArgs(1),
571 : DataLoopNode::NodeFluidType::Steam,
572 : DataLoopNode::ConnectionType::Inlet,
573 : NodeInputManager::CompFluidStream::Primary,
574 : ObjectIsNotParent);
575 :
576 : // Get outlet node number
577 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletNode =
578 4 : GetOnlySingleNode(state,
579 2 : state.dataIPShortCut->cAlphaArgs(5),
580 : ErrorsFound,
581 : DataLoopNode::ConnectionObjectType::ZoneHVACBaseboardRadiantConvectiveSteam,
582 2 : state.dataIPShortCut->cAlphaArgs(1),
583 : DataLoopNode::NodeFluidType::Steam,
584 : DataLoopNode::ConnectionType::Outlet,
585 : NodeInputManager::CompFluidStream::Primary,
586 : ObjectIsNotParent);
587 4 : TestCompSet(state,
588 2 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
589 2 : state.dataIPShortCut->cAlphaArgs(1),
590 2 : state.dataIPShortCut->cAlphaArgs(4),
591 2 : state.dataIPShortCut->cAlphaArgs(5),
592 : "Hot Steam Nodes");
593 :
594 : // Determine steam baseboard radiator system heating design capacity sizing method
595 2 : if (SteamBaseboardDesignDataObject.HeatingCapMethod == HeatingDesignCapacity) {
596 2 : if (!state.dataIPShortCut->lNumericFieldBlanks(iHeatDesignCapacityNumericNum)) {
597 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ScaledHeatingCapacity =
598 2 : state.dataIPShortCut->rNumericArgs(iHeatDesignCapacityNumericNum);
599 4 : if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ScaledHeatingCapacity < 0.0 &&
600 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ScaledHeatingCapacity != AutoSize) {
601 0 : ShowSevereError(state,
602 0 : format("{} = {}",
603 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
604 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID));
605 0 : ShowContinueError(state,
606 0 : format("Illegal {} = {:.7T}",
607 0 : state.dataIPShortCut->cNumericFieldNames(iHeatDesignCapacityNumericNum),
608 0 : state.dataIPShortCut->rNumericArgs(iHeatDesignCapacityNumericNum)));
609 0 : ErrorsFound = true;
610 : }
611 : } else {
612 0 : ShowSevereError(state,
613 0 : format("{} = {}",
614 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
615 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID));
616 0 : ShowContinueError(state,
617 0 : format("Input for {} = {}",
618 0 : state.dataIPShortCut->cAlphaFieldNames(iHeatCAPMAlphaNum),
619 0 : state.dataIPShortCut->cAlphaArgs(iHeatCAPMAlphaNum)));
620 0 : ShowContinueError(
621 0 : state, format("Blank field not allowed for {}", state.dataIPShortCut->cNumericFieldNames(iHeatDesignCapacityNumericNum)));
622 0 : ErrorsFound = true;
623 : }
624 0 : } else if (SteamBaseboardDesignDataObject.HeatingCapMethod == CapacityPerFloorArea) {
625 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ScaledHeatingCapacity =
626 0 : SteamBaseboardDesignDataObject.DesignScaledHeatingCapacity;
627 0 : } else if (SteamBaseboardDesignDataObject.HeatingCapMethod == FractionOfAutosizedHeatingCapacity) {
628 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ScaledHeatingCapacity =
629 0 : SteamBaseboardDesignDataObject.DesignScaledHeatingCapacity;
630 : }
631 :
632 : // Desired degree of cooling
633 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).DegOfSubcooling = state.dataIPShortCut->rNumericArgs(2);
634 : // Maximum steam flow rate
635 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax = state.dataIPShortCut->rNumericArgs(3);
636 2 : if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax >= MaxSteamFlowRate) {
637 0 : ShowWarningError(state,
638 0 : format("{}{}=\"{}\", {} was higher than the allowable maximum.",
639 : RoutineName,
640 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
641 0 : state.dataIPShortCut->cAlphaArgs(1),
642 0 : state.dataIPShortCut->cNumericFieldNames(3)));
643 0 : ShowContinueError(state, format("...reset to maximum value=[{:.2R}].", MaxSteamFlowRate));
644 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax = MaxSteamFlowRate;
645 4 : } else if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax <= MinSteamFlowRate &&
646 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax != AutoSize) {
647 0 : ShowWarningError(state,
648 0 : format("{}{}=\"{}\", {} was less than the allowable minimum.",
649 : RoutineName,
650 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
651 0 : state.dataIPShortCut->cAlphaArgs(1),
652 0 : state.dataIPShortCut->cNumericFieldNames(3)));
653 0 : ShowContinueError(state, format("...reset to minimum value=[{:.2R}].", MinSteamFlowRate));
654 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax = MinSteamFlowRate;
655 : }
656 : // Remaining fraction is added to the zone as convective heat transfer
657 2 : if (SteamBaseboardDesignDataObject.FracRadiant > MaxFraction) {
658 0 : ShowWarningError(state,
659 0 : format("{}{}=\"{}\", Fraction Radiant was higher than the allowable maximum.",
660 : RoutineName,
661 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
662 0 : state.dataIPShortCut->cAlphaArgs(1)));
663 0 : SteamBaseboardDesignDataObject.FracRadiant = MaxFraction;
664 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).FracConvect = 0.0;
665 : } else {
666 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).FracConvect = 1.0 - SteamBaseboardDesignDataObject.FracRadiant;
667 : }
668 :
669 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotSurfToDistrib = NumNumbers - 3;
670 : // IF (SteamBaseboard(BaseboardNum)%TotSurfToDistrib > MaxDistribSurfaces) THEN
671 : // CALL ShowWarningError(state, RoutineName//cCMO_BBRadiator_Steam//'="'//TRIM(state.dataIPShortCut->cAlphaArgs(1))// &
672 : // '", the number of surface/radiant fraction groups entered was higher than the allowable maximum.')
673 : // CALL ShowContinueError(state, '...only the maximum value=['//TRIM(RoundSigDigits(MaxDistribSurfaces))// &
674 : // '] will be processed.')
675 : // SteamBaseboard(BaseboardNum)%TotSurfToDistrib = MaxDistribSurfaces
676 : // END IF
677 2 : if ((state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotSurfToDistrib < MinDistribSurfaces) &&
678 0 : (SteamBaseboardDesignDataObject.FracRadiant > MinFraction)) {
679 0 : ShowSevereError(state,
680 0 : format("{}{}=\"{}\", the number of surface/radiant fraction groups entered was less than the allowable minimum.",
681 0 : std::string{RoutineName},
682 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
683 0 : state.dataIPShortCut->cAlphaArgs(1)));
684 0 : ShowContinueError(state, format("...the minimum that must be entered=[{}].", MinDistribSurfaces));
685 0 : ErrorsFound = true;
686 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotSurfToDistrib = 0;
687 : }
688 : // Allocate the surfaces and fractions
689 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum)
690 2 : .SurfaceName.allocate(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotSurfToDistrib);
691 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SurfaceName = "";
692 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum)
693 2 : .SurfacePtr.allocate(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotSurfToDistrib);
694 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SurfacePtr = 0;
695 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum)
696 2 : .FracDistribToSurf.allocate(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotSurfToDistrib);
697 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).FracDistribToSurf = 0.0;
698 :
699 : // search zone equipment list structure for zone index
700 14 : for (int ctrlZone = 1; ctrlZone <= state.dataGlobal->NumOfZones; ++ctrlZone) {
701 26 : for (int zoneEquipTypeNum = 1; zoneEquipTypeNum <= state.dataZoneEquip->ZoneEquipList(ctrlZone).NumOfEquipTypes; ++zoneEquipTypeNum) {
702 14 : if (state.dataZoneEquip->ZoneEquipList(ctrlZone).EquipType(zoneEquipTypeNum) ==
703 18 : DataZoneEquipment::ZoneEquipType::BaseboardSteam &&
704 4 : state.dataZoneEquip->ZoneEquipList(ctrlZone).EquipName(zoneEquipTypeNum) ==
705 4 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID) {
706 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ZonePtr = ctrlZone;
707 : }
708 : }
709 : }
710 2 : if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ZonePtr <= 0) {
711 0 : ShowSevereError(state,
712 0 : format("{}{}=\"{}\" is not on any ZoneHVAC:EquipmentList.",
713 : RoutineName,
714 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
715 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID));
716 0 : ErrorsFound = true;
717 0 : continue;
718 : }
719 :
720 2 : Real64 AllFracsSummed = SteamBaseboardDesignDataObject.FracDistribPerson;
721 8 : for (SurfNum = 1; SurfNum <= state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotSurfToDistrib; ++SurfNum) {
722 6 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SurfaceName(SurfNum) = state.dataIPShortCut->cAlphaArgs(SurfNum + 5);
723 6 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SurfacePtr(SurfNum) =
724 6 : HeatBalanceIntRadExchange::GetRadiantSystemSurface(
725 : state,
726 6 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
727 6 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID,
728 6 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ZonePtr,
729 6 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SurfaceName(SurfNum),
730 : ErrorsFound);
731 6 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).FracDistribToSurf(SurfNum) =
732 6 : state.dataIPShortCut->rNumericArgs(SurfNum + 3);
733 6 : if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).FracDistribToSurf(SurfNum) > MaxFraction) {
734 0 : ShowWarningError(state,
735 0 : format("{}{}=\"{}\", {}was greater than the allowable maximum.",
736 : RoutineName,
737 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
738 0 : state.dataIPShortCut->cAlphaArgs(1),
739 0 : state.dataIPShortCut->cNumericFieldNames(SurfNum + 3)));
740 0 : ShowContinueError(state, format("...reset to maximum value=[{:.1R}].", MaxFraction));
741 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotSurfToDistrib = MaxFraction;
742 : }
743 6 : if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).FracDistribToSurf(SurfNum) < MinFraction) {
744 0 : ShowWarningError(state,
745 0 : format("{}{}=\"{}\", {}was less than the allowable minimum.",
746 : RoutineName,
747 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
748 0 : state.dataIPShortCut->cAlphaArgs(1),
749 0 : state.dataIPShortCut->cNumericFieldNames(SurfNum + 3)));
750 0 : ShowContinueError(state, format("...reset to maximum value=[{:.1R}].", MinFraction));
751 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotSurfToDistrib = MinFraction;
752 : }
753 6 : if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SurfacePtr(SurfNum) != 0) {
754 6 : state.dataSurface->surfIntConv(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SurfacePtr(SurfNum))
755 6 : .getsRadiantHeat = true;
756 12 : state.dataSurface->allGetsRadiantHeatSurfaceList.emplace_back(
757 6 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SurfacePtr(SurfNum));
758 : }
759 :
760 6 : AllFracsSummed += state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).FracDistribToSurf(SurfNum);
761 : } // surfaces
762 :
763 2 : if (AllFracsSummed > (MaxFraction + 0.01)) {
764 0 : ShowSevereError(
765 : state,
766 0 : format("Fraction of radiation distributed to surfaces sums up to greater than 1 for {}", state.dataIPShortCut->cAlphaArgs(1)));
767 0 : ShowContinueError(state, format("Occurs in Baseboard Heater={}", state.dataIPShortCut->cAlphaArgs(1)));
768 0 : ErrorsFound = true;
769 : }
770 2 : if ((AllFracsSummed < (MaxFraction - 0.01)) &&
771 0 : (SteamBaseboardDesignDataObject.FracRadiant >
772 : MinFraction)) { // User didn't distribute all of the | radiation warn that some will be lost
773 0 : ShowWarningError(state,
774 0 : format("{}{}=\"{}\", Summed radiant fractions for people + surface groups < 1.0",
775 : RoutineName,
776 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
777 0 : state.dataIPShortCut->cAlphaArgs(1)));
778 0 : ShowContinueError(state, "The rest of the radiant energy delivered by the baseboard heater will be lost");
779 : }
780 :
781 2 : if (state.dataSteamBaseboardRadiator->SteamIndex == 0 && BaseboardNum == 1) {
782 1 : state.dataSteamBaseboardRadiator->SteamIndex = FluidProperties::GetRefrigNum(state, "STEAM");
783 1 : if (state.dataSteamBaseboardRadiator->SteamIndex == 0) {
784 0 : ShowSevereError(state, format("{}Steam Properties for {} not found.", RoutineName, state.dataIPShortCut->cAlphaArgs(1)));
785 0 : if (SteamMessageNeeded) ShowContinueError(state, "Steam Fluid Properties should have been included in the input file.");
786 0 : ErrorsFound = true;
787 0 : SteamMessageNeeded = false;
788 : }
789 : }
790 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).FluidIndex = state.dataSteamBaseboardRadiator->SteamIndex;
791 2 : }
792 :
793 1 : if (ErrorsFound) {
794 0 : ShowFatalError(
795 : state,
796 0 : format("{}{}Errors found getting input. Program terminates.", RoutineName, state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam));
797 : }
798 :
799 : // Setup Report variables for the Coils
800 3 : for (BaseboardNum = 1; BaseboardNum <= state.dataSteamBaseboardRadiator->NumSteamBaseboards; ++BaseboardNum) {
801 : // CurrentModuleObject='ZoneHVAC:Baseboard:RadiantConvective:Steam'
802 4 : SetupOutputVariable(state,
803 : "Baseboard Total Heating Rate",
804 : Constant::Units::W,
805 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotPower,
806 : OutputProcessor::TimeStepType::System,
807 : OutputProcessor::StoreType::Average,
808 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID);
809 :
810 4 : SetupOutputVariable(state,
811 : "Baseboard Convective Heating Rate",
812 : Constant::Units::W,
813 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ConvPower,
814 : OutputProcessor::TimeStepType::System,
815 : OutputProcessor::StoreType::Average,
816 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID);
817 4 : SetupOutputVariable(state,
818 : "Baseboard Radiant Heating Rate",
819 : Constant::Units::W,
820 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).RadPower,
821 : OutputProcessor::TimeStepType::System,
822 : OutputProcessor::StoreType::Average,
823 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID);
824 4 : SetupOutputVariable(state,
825 : "Baseboard Total Heating Energy",
826 : Constant::Units::J,
827 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotEnergy,
828 : OutputProcessor::TimeStepType::System,
829 : OutputProcessor::StoreType::Sum,
830 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID,
831 : Constant::eResource::EnergyTransfer,
832 : OutputProcessor::Group::HVAC,
833 : OutputProcessor::EndUseCat::Baseboard);
834 4 : SetupOutputVariable(state,
835 : "Baseboard Convective Heating Energy",
836 : Constant::Units::J,
837 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ConvEnergy,
838 : OutputProcessor::TimeStepType::System,
839 : OutputProcessor::StoreType::Sum,
840 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID);
841 4 : SetupOutputVariable(state,
842 : "Baseboard Radiant Heating Energy",
843 : Constant::Units::J,
844 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).RadEnergy,
845 : OutputProcessor::TimeStepType::System,
846 : OutputProcessor::StoreType::Sum,
847 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID);
848 4 : SetupOutputVariable(state,
849 : "Baseboard Steam Energy",
850 : Constant::Units::J,
851 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Energy,
852 : OutputProcessor::TimeStepType::System,
853 : OutputProcessor::StoreType::Sum,
854 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID,
855 : Constant::eResource::PlantLoopHeatingDemand,
856 : OutputProcessor::Group::HVAC,
857 : OutputProcessor::EndUseCat::Baseboard);
858 4 : SetupOutputVariable(state,
859 : "Baseboard Steam Rate",
860 : Constant::Units::W,
861 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Power,
862 : OutputProcessor::TimeStepType::System,
863 : OutputProcessor::StoreType::Average,
864 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID);
865 4 : SetupOutputVariable(state,
866 : "Baseboard Steam Mass Flow Rate",
867 : Constant::Units::kg_s,
868 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamMassFlowRate,
869 : OutputProcessor::TimeStepType::System,
870 : OutputProcessor::StoreType::Average,
871 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID);
872 4 : SetupOutputVariable(state,
873 : "Baseboard Steam Inlet Temperature",
874 : Constant::Units::C,
875 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletTemp,
876 : OutputProcessor::TimeStepType::System,
877 : OutputProcessor::StoreType::Average,
878 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID);
879 4 : SetupOutputVariable(state,
880 : "Baseboard Steam Outlet Temperature",
881 : Constant::Units::C,
882 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletTemp,
883 : OutputProcessor::TimeStepType::System,
884 : OutputProcessor::StoreType::Average,
885 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID);
886 : }
887 1 : }
888 :
889 7356 : void InitSteamBaseboard(EnergyPlusData &state, int const BaseboardNum, int const ControlledZoneNum, bool const FirstHVACIteration)
890 : {
891 :
892 : // SUBROUTINE INFORMATION:
893 : // AUTHOR Russ Taylor
894 : // Rick Strand
895 : // DATE WRITTEN Nov 1997
896 : // Feb 2001
897 : // MODIFIED Sep 2009 Daeho Kang (Add Radiant Component)
898 : // Sept 2010 Chandan Sharma, FSEC (plant interactions)
899 :
900 : // PURPOSE OF THIS SUBROUTINE:
901 : // This subroutine initializes the baseboard units.
902 :
903 : // METHODOLOGY EMPLOYED:
904 : // The initialization subrotines both in high temperature radiant radiator
905 : // and convective only baseboard radiator are combined and modified.
906 : // The heater is assumed to be crossflow with both fluids unmixed.
907 :
908 : // REFERENCES:
909 :
910 : // Using/Aliasing
911 : using FluidProperties::GetSatDensityRefrig;
912 : using FluidProperties::GetSatEnthalpyRefrig;
913 : using PlantUtilities::InitComponentNodes;
914 : using PlantUtilities::ScanPlantLoopsForObject;
915 :
916 : static constexpr std::string_view RoutineName("InitSteamCoil");
917 :
918 : int Loop;
919 : int SteamInletNode;
920 : Real64 StartEnthSteam;
921 : Real64 SteamDensity;
922 : bool errFlag;
923 :
924 : // Do the one time initializations
925 7356 : if (state.dataSteamBaseboardRadiator->MyOneTimeFlag) {
926 :
927 : // initialize the environment and sizing flags
928 1 : state.dataSteamBaseboardRadiator->MyEnvrnFlag.dimension(state.dataSteamBaseboardRadiator->NumSteamBaseboards, true);
929 1 : state.dataSteamBaseboardRadiator->MySizeFlag.dimension(state.dataSteamBaseboardRadiator->NumSteamBaseboards, true);
930 1 : state.dataSteamBaseboardRadiator->SetLoopIndexFlag.dimension(state.dataSteamBaseboardRadiator->NumSteamBaseboards, true);
931 1 : state.dataSteamBaseboardRadiator->MyOneTimeFlag = false;
932 : }
933 :
934 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ZonePtr = ControlledZoneNum;
935 :
936 : // Need to check all units to see if they are on ZoneHVAC:EquipmentList or issue warning
937 7356 : if (!state.dataSteamBaseboardRadiator->ZoneEquipmentListChecked && state.dataZoneEquip->ZoneEquipInputsFilled) {
938 1 : state.dataSteamBaseboardRadiator->ZoneEquipmentListChecked = true;
939 3 : for (Loop = 1; Loop <= state.dataSteamBaseboardRadiator->NumSteamBaseboards; ++Loop) {
940 4 : if (CheckZoneEquipmentList(state,
941 2 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
942 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(Loop).EquipID))
943 2 : continue;
944 0 : ShowSevereError(state,
945 0 : format("InitBaseboard: Unit=[{},{}] is not on any ZoneHVAC:EquipmentList. It will not be simulated.",
946 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
947 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(Loop).EquipID));
948 : }
949 : }
950 :
951 7356 : if (state.dataSteamBaseboardRadiator->SetLoopIndexFlag(BaseboardNum)) {
952 2 : if (allocated(state.dataPlnt->PlantLoop)) {
953 2 : errFlag = false;
954 4 : ScanPlantLoopsForObject(state,
955 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID,
956 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipType,
957 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).plantLoc,
958 : errFlag,
959 : _,
960 : _,
961 : _,
962 : _,
963 : _);
964 2 : state.dataSteamBaseboardRadiator->SetLoopIndexFlag(BaseboardNum) = false;
965 2 : if (errFlag) {
966 0 : ShowFatalError(state, "InitSteamBaseboard: Program terminated for previous conditions.");
967 : }
968 : }
969 : }
970 :
971 7358 : if (!state.dataGlobal->SysSizingCalc && state.dataSteamBaseboardRadiator->MySizeFlag(BaseboardNum) &&
972 2 : (!state.dataSteamBaseboardRadiator->SetLoopIndexFlag(BaseboardNum))) {
973 : // For each coil, do the sizing once
974 2 : SizeSteamBaseboard(state, BaseboardNum);
975 2 : state.dataSteamBaseboardRadiator->MySizeFlag(BaseboardNum) = false;
976 : }
977 :
978 : // Do the Begin Environment initializations
979 7356 : if (state.dataGlobal->BeginEnvrnFlag && state.dataSteamBaseboardRadiator->MyEnvrnFlag(BaseboardNum)) {
980 : // Initialize
981 12 : SteamInletNode = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletNode;
982 12 : state.dataLoopNodes->Node(SteamInletNode).Temp = 100.0;
983 12 : state.dataLoopNodes->Node(SteamInletNode).Press = 101325.0;
984 24 : SteamDensity = GetSatDensityRefrig(state,
985 : fluidNameSteam,
986 12 : state.dataLoopNodes->Node(SteamInletNode).Temp,
987 : 1.0,
988 12 : state.dataLoopNodes->Node(SteamInletNode).FluidIndex,
989 : RoutineName);
990 24 : StartEnthSteam = GetSatEnthalpyRefrig(state,
991 : fluidNameSteam,
992 12 : state.dataLoopNodes->Node(SteamInletNode).Temp,
993 : 1.0,
994 12 : state.dataLoopNodes->Node(SteamInletNode).FluidIndex,
995 : RoutineName);
996 12 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamMassFlowRateMax =
997 12 : SteamDensity * state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax;
998 36 : InitComponentNodes(state,
999 : 0.0,
1000 12 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamMassFlowRateMax,
1001 12 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletNode,
1002 12 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletNode);
1003 12 : state.dataLoopNodes->Node(SteamInletNode).Enthalpy = StartEnthSteam;
1004 12 : state.dataLoopNodes->Node(SteamInletNode).Quality = 1.0;
1005 12 : state.dataLoopNodes->Node(SteamInletNode).HumRat = 0.0;
1006 :
1007 : // Initializes radiant sources
1008 12 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ZeroBBSteamSourceSumHATsurf = 0.0;
1009 12 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSource = 0.0;
1010 12 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSrcAvg = 0.0;
1011 12 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastQBBSteamRadSrc = 0.0;
1012 12 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastSysTimeElapsed = 0.0;
1013 12 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastTimeStepSys = 0.0;
1014 :
1015 12 : state.dataSteamBaseboardRadiator->MyEnvrnFlag(BaseboardNum) = false;
1016 : }
1017 :
1018 7356 : if (!state.dataGlobal->BeginEnvrnFlag) {
1019 7290 : state.dataSteamBaseboardRadiator->MyEnvrnFlag(BaseboardNum) = true;
1020 : }
1021 :
1022 7356 : if (state.dataGlobal->BeginTimeStepFlag && FirstHVACIteration) {
1023 2710 : int ZoneNum = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ZonePtr;
1024 2710 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ZeroBBSteamSourceSumHATsurf =
1025 2710 : state.dataHeatBal->Zone(ZoneNum).sumHATsurf(state);
1026 2710 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSrcAvg = 0.0;
1027 2710 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastQBBSteamRadSrc = 0.0;
1028 2710 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastSysTimeElapsed = 0.0;
1029 2710 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastTimeStepSys = 0.0;
1030 : }
1031 :
1032 : // Do the every time step initializations
1033 7356 : SteamInletNode = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletNode;
1034 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamMassFlowRate = state.dataLoopNodes->Node(SteamInletNode).MassFlowRate;
1035 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletTemp = state.dataLoopNodes->Node(SteamInletNode).Temp;
1036 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletEnthalpy = state.dataLoopNodes->Node(SteamInletNode).Enthalpy;
1037 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletPress = state.dataLoopNodes->Node(SteamInletNode).Press;
1038 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletQuality = state.dataLoopNodes->Node(SteamInletNode).Quality;
1039 :
1040 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotPower = 0.0;
1041 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Power = 0.0;
1042 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ConvPower = 0.0;
1043 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).RadPower = 0.0;
1044 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotEnergy = 0.0;
1045 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Energy = 0.0;
1046 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ConvEnergy = 0.0;
1047 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).RadEnergy = 0.0;
1048 7356 : }
1049 :
1050 2 : void SizeSteamBaseboard(EnergyPlusData &state, int const BaseboardNum)
1051 : {
1052 :
1053 : // SUBROUTINE INFORMATION:
1054 : // AUTHOR Fred Buhl
1055 : // DATE WRITTEN February 2002
1056 : // MODIFIED August 2013 Daeho Kang, add component sizing table entries
1057 : // August 2014 Bereket Nigusse, added scalable sizing
1058 : // RE-ENGINEERED na
1059 :
1060 : // PURPOSE OF THIS SUBROUTINE:
1061 : // This subroutine is for sizing steam baseboard components
1062 :
1063 : // METHODOLOGY EMPLOYED:
1064 : // Obtains flow rates from the zone sizing arrays and plant sizing data.
1065 :
1066 : // REFERENCES:
1067 : // na
1068 :
1069 : // Using/Aliasing
1070 : using namespace DataSizing;
1071 : using FluidProperties::GetSatDensityRefrig;
1072 : using FluidProperties::GetSatEnthalpyRefrig;
1073 : using FluidProperties::GetSatSpecificHeatRefrig;
1074 : using HVAC::HeatingCapacitySizing;
1075 : using PlantUtilities::RegisterPlantCompDesignFlow;
1076 :
1077 : // SUBROUTINE PARAMETER DEFINITIONS:
1078 : static constexpr std::string_view RoutineName("SizeSteamBaseboard");
1079 :
1080 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
1081 2 : int PltSizSteamNum(0); // Index of plant sizing object for 1st steam loop
1082 2 : Real64 DesCoilLoad(0.0); // Design heating load in the zone
1083 : Real64 SteamInletTemp; // Inlet steam temperature in C
1084 : Real64 EnthSteamInDry; // Enthalpy of dry steam
1085 : Real64 EnthSteamOutWet; // Enthalpy of wet steam
1086 : Real64 LatentHeatSteam; // latent heat of steam
1087 : Real64 SteamDensity; // Density of steam
1088 : Real64 Cp; // local fluid specific heat
1089 2 : bool ErrorsFound(false); // If errors detected in input
1090 2 : bool IsAutoSize(false); // Indicator to autosizing steam flow
1091 2 : Real64 SteamVolFlowRateMaxDes(0.0); // Design maximum steam volume flow for reporting
1092 2 : Real64 SteamVolFlowRateMaxUser(0.0); // User hard-sized maximum steam volume flow for reporting
1093 2 : std::string CompName; // component name
1094 2 : std::string CompType; // component type
1095 2 : std::string SizingString; // input field sizing description (e.g., Nominal Capacity)
1096 : Real64 TempSize; // autosized value of coil input field
1097 2 : int FieldNum = 1; // IDD numeric field number where input field description is found
1098 : int SizingMethod; // Integer representation of sizing method name (HeatingCapacitySizing)
1099 : bool PrintFlag; // TRUE when sizing information is reported in the eio file
1100 2 : int CapSizingMethod(0); // capacity sizing methods (HeatingDesignCapacity, CapacityPerFloorArea, and FractionOfAutosizedHeatingCapacity )
1101 :
1102 2 : auto &ZoneEqSizing(state.dataSize->ZoneEqSizing);
1103 2 : auto &CurZoneEqNum(state.dataSize->CurZoneEqNum);
1104 :
1105 2 : SteamBaseboardDesignData SteamBaseboardDesignDataObject{state.dataSteamBaseboardRadiator->SteamBaseboardDesign(
1106 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).DesignObjectPtr)}; // Contains the data for variable flow hydronic systems
1107 :
1108 : // Find the appropriate steam plant sizing object
1109 2 : PltSizSteamNum = state.dataPlnt->PlantLoop(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).plantLoc.loopNum).PlantSizNum;
1110 : // PltSizSteamNum = MyPlantSizingIndex('Coil:Heating:Steam', SteamBaseboard(BaseboardNum)%EquipID, &
1111 : // SteamBaseboard(BaseboardNum)%SteamInletNode, &
1112 : // SteamBaseboard(BaseboardNum)%SteamOutletNode, ErrorsFound)
1113 :
1114 2 : if (PltSizSteamNum > 0) {
1115 :
1116 2 : state.dataSize->DataScalableCapSizingON = false;
1117 :
1118 2 : if (CurZoneEqNum > 0) {
1119 :
1120 2 : if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax == AutoSize) {
1121 2 : IsAutoSize = true;
1122 : }
1123 2 : if (!IsAutoSize && !state.dataSize->ZoneSizingRunDone) {
1124 0 : if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax > 0.0) {
1125 0 : BaseSizer::reportSizerOutput(state,
1126 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
1127 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID,
1128 : "User-Specified Maximum Water Flow Rate [m3/s]",
1129 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax);
1130 : }
1131 : } else {
1132 2 : CheckZoneSizing(state,
1133 2 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
1134 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID);
1135 :
1136 2 : CompType = state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam;
1137 2 : CompName = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID;
1138 2 : state.dataSize->DataFracOfAutosizedHeatingCapacity = 1.0;
1139 2 : state.dataSize->DataZoneNumber = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ZonePtr;
1140 2 : SizingMethod = HeatingCapacitySizing;
1141 2 : FieldNum = 1;
1142 2 : PrintFlag = false;
1143 2 : SizingString = state.dataSteamBaseboardRadiator->SteamBaseboardNumericFields(BaseboardNum).FieldNames(FieldNum) + " [W]";
1144 2 : CapSizingMethod = SteamBaseboardDesignDataObject.HeatingCapMethod;
1145 2 : ZoneEqSizing(CurZoneEqNum).SizingMethod(SizingMethod) = CapSizingMethod;
1146 2 : if (CapSizingMethod == HeatingDesignCapacity || CapSizingMethod == CapacityPerFloorArea ||
1147 : CapSizingMethod == FractionOfAutosizedHeatingCapacity) {
1148 :
1149 2 : if (CapSizingMethod == HeatingDesignCapacity) {
1150 2 : if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ScaledHeatingCapacity == AutoSize) {
1151 2 : CheckZoneSizing(state, CompType, CompName);
1152 2 : ZoneEqSizing(CurZoneEqNum).HeatingCapacity = true;
1153 2 : ZoneEqSizing(CurZoneEqNum).DesHeatingLoad = state.dataSize->FinalZoneSizing(CurZoneEqNum).NonAirSysDesHeatLoad;
1154 : }
1155 2 : TempSize = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ScaledHeatingCapacity;
1156 0 : } else if (CapSizingMethod == CapacityPerFloorArea) {
1157 0 : ZoneEqSizing(CurZoneEqNum).HeatingCapacity = true;
1158 0 : ZoneEqSizing(CurZoneEqNum).DesHeatingLoad =
1159 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ScaledHeatingCapacity *
1160 0 : state.dataHeatBal->Zone(state.dataSize->DataZoneNumber).FloorArea;
1161 0 : TempSize = ZoneEqSizing(CurZoneEqNum).DesHeatingLoad;
1162 0 : state.dataSize->DataScalableCapSizingON = true;
1163 0 : } else if (CapSizingMethod == FractionOfAutosizedHeatingCapacity) {
1164 0 : CheckZoneSizing(state, CompType, CompName);
1165 0 : ZoneEqSizing(CurZoneEqNum).HeatingCapacity = true;
1166 0 : state.dataSize->DataFracOfAutosizedHeatingCapacity =
1167 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ScaledHeatingCapacity;
1168 0 : ZoneEqSizing(CurZoneEqNum).DesHeatingLoad = state.dataSize->FinalZoneSizing(CurZoneEqNum).NonAirSysDesHeatLoad;
1169 0 : TempSize = AutoSize;
1170 0 : state.dataSize->DataScalableCapSizingON = true;
1171 : } else {
1172 0 : TempSize = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ScaledHeatingCapacity;
1173 : }
1174 2 : bool errorsFound = false;
1175 2 : HeatingCapacitySizer sizerHeatingCapacity;
1176 2 : sizerHeatingCapacity.overrideSizingString(SizingString);
1177 2 : sizerHeatingCapacity.initializeWithinEP(state, CompType, CompName, PrintFlag, RoutineName);
1178 2 : DesCoilLoad = sizerHeatingCapacity.size(state, TempSize, errorsFound);
1179 2 : state.dataSize->DataScalableCapSizingON = false;
1180 2 : } else {
1181 0 : DesCoilLoad = 0.0; // FinalZoneSizing(CurZoneEqNum).NonAirSysDesHeatLoad;
1182 : }
1183 :
1184 2 : if (DesCoilLoad >= SmallLoad) {
1185 2 : SteamInletTemp = 100.0;
1186 4 : EnthSteamInDry = GetSatEnthalpyRefrig(state,
1187 : fluidNameSteam,
1188 : SteamInletTemp,
1189 : 1.0,
1190 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).FluidIndex,
1191 : RoutineName);
1192 4 : EnthSteamOutWet = GetSatEnthalpyRefrig(state,
1193 : fluidNameSteam,
1194 : SteamInletTemp,
1195 : 0.0,
1196 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).FluidIndex,
1197 : RoutineName);
1198 2 : LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet;
1199 4 : SteamDensity = GetSatDensityRefrig(state,
1200 : fluidNameSteam,
1201 : SteamInletTemp,
1202 : 1.0,
1203 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).FluidIndex,
1204 : RoutineName);
1205 4 : Cp = GetSatSpecificHeatRefrig(state,
1206 : fluidNameSteam,
1207 : SteamInletTemp,
1208 : 0.0,
1209 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).FluidIndex,
1210 : RoutineName);
1211 :
1212 2 : SteamVolFlowRateMaxDes =
1213 2 : DesCoilLoad /
1214 2 : (SteamDensity * (LatentHeatSteam + state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).DegOfSubcooling * Cp));
1215 : } else {
1216 0 : SteamVolFlowRateMaxDes = 0.0;
1217 : }
1218 :
1219 2 : if (IsAutoSize) {
1220 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax = SteamVolFlowRateMaxDes;
1221 4 : BaseSizer::reportSizerOutput(state,
1222 2 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
1223 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID,
1224 : "Design Size Maximum Steam Flow Rate [m3/s]",
1225 : SteamVolFlowRateMaxDes);
1226 : } else { // Hard size with sizing data
1227 0 : if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax > 0.0 &&
1228 0 : SteamVolFlowRateMaxDes > 0.0) {
1229 0 : SteamVolFlowRateMaxUser = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax;
1230 0 : BaseSizer::reportSizerOutput(state,
1231 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
1232 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID,
1233 : "Design Size Maximum Steam Flow Rate [m3/s]",
1234 : SteamVolFlowRateMaxDes,
1235 : "User-Speicified Maximum Steam Flow Rate [m3/s]",
1236 : SteamVolFlowRateMaxUser);
1237 0 : if (state.dataGlobal->DisplayExtraWarnings) {
1238 : // Report difference between design size and user-specified values
1239 0 : if ((std::abs(SteamVolFlowRateMaxDes - SteamVolFlowRateMaxUser) / SteamVolFlowRateMaxUser) >
1240 0 : state.dataSize->AutoVsHardSizingThreshold) {
1241 0 : ShowMessage(state,
1242 0 : format("SizeSteamBaseboard: Potential issue with equipment sizing for "
1243 : "ZoneHVAC:Baseboard:RadiantConvective:Steam=\"{}\".",
1244 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID));
1245 0 : ShowContinueError(state,
1246 0 : format("User-Specified Maximum Steam Flow Rate of {:.5R} [m3/s]", SteamVolFlowRateMaxUser));
1247 0 : ShowContinueError(
1248 0 : state, format("differs from Design Size Maximum Steam Flow Rate of {:.5R} [m3/s]", SteamVolFlowRateMaxDes));
1249 0 : ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
1250 0 : ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
1251 : }
1252 : }
1253 : }
1254 : }
1255 : }
1256 : }
1257 : } else {
1258 0 : if (IsAutoSize) {
1259 : // if there is no heating Sizing:Plant object and autosizng was requested, issue an error message
1260 : // first error will be issued by MyPlantSizingIndex
1261 0 : ShowSevereError(state, "Autosizing of steam baseboard requires a heating loop Sizing:Plant object");
1262 0 : ShowContinueError(state,
1263 0 : format("Occurs in Baseboard Heater={}", state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID));
1264 0 : ErrorsFound = true;
1265 : }
1266 : }
1267 :
1268 4 : RegisterPlantCompDesignFlow(state,
1269 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletNode,
1270 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax);
1271 :
1272 2 : if (ErrorsFound) {
1273 0 : ShowFatalError(state, "Preceding sizing errors cause program termination");
1274 : }
1275 2 : }
1276 :
1277 32562 : void CalcSteamBaseboard(EnergyPlusData &state, int &BaseboardNum, Real64 &LoadMet)
1278 : {
1279 : // SUBROUTINE INFORMATION:
1280 : // AUTHOR Daeho Kang
1281 : // DATE WRITTEN September 2009
1282 : // MODIFIED Sep 2011 LKL/BG - resimulate only zones needing it for Radiant systems
1283 : // RE-ENGINEERED na
1284 :
1285 : // PURPOSE OF THIS SUBROUTINE:
1286 : // This subroutine calculates both the convective and radiant heat transfer rate
1287 : // of steam baseboard heaters. The heater is assumed to be crossflow with
1288 : // both fluids unmixed. The air flow is buoyancy driven and a constant airflow.
1289 :
1290 : // METHODOLOGY EMPLOYED:
1291 : // Equations that calculates heating capacity of steam coils and outlet air and water temperatures
1292 : // of the zone control steam coil in steam coil module in EnergyPlus are employed.
1293 :
1294 : // REFERENCES:
1295 :
1296 : // Using/Aliasing
1297 : using FluidProperties::GetSatDensityRefrig;
1298 : using FluidProperties::GetSatEnthalpyRefrig;
1299 : using FluidProperties::GetSatSpecificHeatRefrig;
1300 : using HVAC::SmallLoad;
1301 : using ScheduleManager::GetCurrentScheduleValue;
1302 :
1303 : // Locals
1304 : // SUBROUTINE ARGUMENT DEFINITIONS:
1305 :
1306 : // SUBROUTINE PARAMETER DEFINITIONS:
1307 : static constexpr std::string_view RoutineName("CalcSteamBaseboard");
1308 :
1309 : // INTERFACE BLOCK SPECIFICATIONS
1310 : // na
1311 :
1312 : // DERIVED TYPE DEFINITIONS
1313 : // na
1314 :
1315 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
1316 : int ZoneNum;
1317 : Real64 RadHeat;
1318 : Real64 SteamBBHeat;
1319 : Real64 SteamInletTemp;
1320 : Real64 SteamOutletTemp;
1321 : Real64 SteamMassFlowRate;
1322 : Real64 SubcoolDeltaT;
1323 : Real64 QZnReq;
1324 : Real64 EnthSteamInDry;
1325 : Real64 EnthSteamOutWet;
1326 : Real64 LatentHeatSteam;
1327 : Real64 Cp;
1328 :
1329 32562 : SteamBaseboardDesignData SteamBaseboardDesignDataObject{state.dataSteamBaseboardRadiator->SteamBaseboardDesign(
1330 32562 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).DesignObjectPtr)}; // Contains the data for variable flow hydronic systems
1331 :
1332 32562 : ZoneNum = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ZonePtr;
1333 32562 : QZnReq = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(ZoneNum).RemainingOutputReqToHeatSP;
1334 32562 : SteamInletTemp = state.dataLoopNodes->Node(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletNode).Temp;
1335 32562 : SteamOutletTemp = SteamInletTemp;
1336 32562 : SteamMassFlowRate = state.dataLoopNodes->Node(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletNode).MassFlowRate;
1337 32562 : SubcoolDeltaT = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).DegOfSubcooling;
1338 :
1339 57767 : if (QZnReq > SmallLoad && !state.dataZoneEnergyDemand->CurDeadBandOrSetback(ZoneNum) && SteamMassFlowRate > 0.0 &&
1340 25205 : GetCurrentScheduleValue(state, state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SchedPtr) > 0) {
1341 : // Unit is on
1342 50410 : EnthSteamInDry = GetSatEnthalpyRefrig(
1343 25205 : state, fluidNameSteam, SteamInletTemp, 1.0, state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).FluidIndex, RoutineName);
1344 50410 : EnthSteamOutWet = GetSatEnthalpyRefrig(
1345 25205 : state, fluidNameSteam, SteamInletTemp, 0.0, state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).FluidIndex, RoutineName);
1346 25205 : LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet;
1347 50410 : Cp = GetSatSpecificHeatRefrig(
1348 25205 : state, fluidNameSteam, SteamInletTemp, 0.0, state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).FluidIndex, RoutineName);
1349 25205 : SteamBBHeat = SteamMassFlowRate * (LatentHeatSteam + SubcoolDeltaT * Cp); // Baseboard heating rate
1350 25205 : SteamOutletTemp = SteamInletTemp - SubcoolDeltaT; // Outlet temperature of steam
1351 : // Estimate radiant heat addition
1352 25205 : RadHeat = SteamBBHeat * SteamBaseboardDesignDataObject.FracRadiant; // Radiant heating rate
1353 25205 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSource =
1354 : RadHeat; // Radiant heat source which will be distributed to surfaces and people
1355 :
1356 : // Now, distribute the radiant energy of all systems to the appropriate surfaces, to people, and the air
1357 25205 : DistributeBBSteamRadGains(state);
1358 : // Now "simulate" the system by recalculating the heat balances
1359 25205 : HeatBalanceSurfaceManager::CalcHeatBalanceOutsideSurf(state, ZoneNum);
1360 25205 : HeatBalanceSurfaceManager::CalcHeatBalanceInsideSurf(state, ZoneNum);
1361 :
1362 : // Here an assumption is made regarding radiant heat transfer to people.
1363 : // While the radiant heat transfer to people array will be used by the thermal comfort
1364 : // routines, the energy transfer to people would get lost from the perspective
1365 : // of the heat balance. So, to avoid this net loss of energy which clearly
1366 : // gets added to the zones, we must account for it somehow. This assumption
1367 : // that all energy radiated to people is converted to convective energy is
1368 : // not very precise, but at least it conserves energy. The system impact to heat balance
1369 : // should include this.
1370 :
1371 : // Actual system load that the unit should meet
1372 25205 : LoadMet = (state.dataHeatBal->Zone(ZoneNum).sumHATsurf(state) -
1373 25205 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ZeroBBSteamSourceSumHATsurf) +
1374 25205 : (SteamBBHeat * state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).FracConvect) +
1375 25205 : (RadHeat * SteamBaseboardDesignDataObject.FracDistribPerson);
1376 25205 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletEnthalpy =
1377 25205 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletEnthalpy - SteamBBHeat / SteamMassFlowRate;
1378 25205 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletQuality = 0.0;
1379 : } else {
1380 7357 : SteamOutletTemp = SteamInletTemp;
1381 7357 : SteamBBHeat = 0.0;
1382 7357 : LoadMet = 0.0;
1383 7357 : RadHeat = 0.0;
1384 7357 : SteamMassFlowRate = 0.0;
1385 7357 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSource = 0.0;
1386 7357 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletQuality = 0.0;
1387 7357 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletEnthalpy =
1388 7357 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletEnthalpy;
1389 : }
1390 :
1391 32562 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletTemp = SteamOutletTemp;
1392 32562 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamMassFlowRate = SteamMassFlowRate;
1393 32562 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletEnthalpy =
1394 32562 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletEnthalpy;
1395 32562 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletQuality =
1396 32562 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletQuality;
1397 32562 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotPower = LoadMet;
1398 32562 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Power = SteamBBHeat;
1399 32562 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ConvPower = SteamBBHeat - RadHeat;
1400 32562 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).RadPower = RadHeat;
1401 32562 : }
1402 :
1403 7356 : void UpdateSteamBaseboard(EnergyPlusData &state, int const BaseboardNum)
1404 : {
1405 : // SUBROUTINE INFORMATION:
1406 : // AUTHOR Russ Taylor
1407 : // Rick Strand
1408 : // DATE WRITTEN Nov 1997
1409 : // February 2001
1410 : // MODIFIED Sep 2009 Daeho Kang (add radiant component)
1411 : // RE-ENGINEERED na
1412 :
1413 : // PURPOSE OF THIS SUBROUTINE:
1414 :
1415 : // METHODOLOGY EMPLOYED:
1416 : // The update subrotines both in high temperature radiant radiator
1417 : // and convective only baseboard radiator are combined and modified.
1418 :
1419 : using PlantUtilities::SafeCopyPlantNode;
1420 :
1421 : int SteamInletNode;
1422 : int SteamOutletNode;
1423 :
1424 : // First, update the running average if necessary...
1425 7356 : if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastSysTimeElapsed == state.dataHVACGlobal->SysTimeElapsed) {
1426 6776 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSrcAvg -=
1427 6776 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastQBBSteamRadSrc *
1428 6776 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastTimeStepSys / state.dataGlobal->TimeStepZone;
1429 : }
1430 : // Update the running average and the "last" values with the current values of the appropriate variables
1431 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSrcAvg +=
1432 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSource * state.dataHVACGlobal->TimeStepSys /
1433 7356 : state.dataGlobal->TimeStepZone;
1434 :
1435 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastQBBSteamRadSrc =
1436 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSource;
1437 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastSysTimeElapsed = state.dataHVACGlobal->SysTimeElapsed;
1438 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastTimeStepSys = state.dataHVACGlobal->TimeStepSys;
1439 :
1440 7356 : SteamInletNode = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletNode;
1441 7356 : SteamOutletNode = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletNode;
1442 :
1443 : // Set the outlet air nodes of the Baseboard
1444 : // Set the outlet water nodes for the Coil
1445 7356 : SafeCopyPlantNode(state, SteamInletNode, SteamOutletNode);
1446 7356 : state.dataLoopNodes->Node(SteamOutletNode).Temp = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletTemp;
1447 7356 : state.dataLoopNodes->Node(SteamOutletNode).Enthalpy = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletEnthalpy;
1448 7356 : }
1449 :
1450 2804482 : void UpdateBBSteamRadSourceValAvg(EnergyPlusData &state, bool &SteamBaseboardSysOn) // .TRUE. if the radiant system has run this zone time step
1451 : {
1452 :
1453 : // SUBROUTINE INFORMATION:
1454 : // AUTHOR Rick Strand
1455 : // DATE WRITTEN February 2001
1456 : // MODIFIED Aug 2009 Daeho Kang (modify only for baseboard)
1457 : // RE-ENGINEERED na
1458 :
1459 : // PURPOSE OF THIS SUBROUTINE:
1460 : // To transfer the average value of the heat source over the entire
1461 : // zone time step back to the heat balance routines so that the heat
1462 : // balance algorithms can simulate one last time with the average source
1463 : // to maintain some reasonable amount of continuity and energy balance
1464 : // in the temperature and flux histories.
1465 :
1466 : // METHODOLOGY EMPLOYED:
1467 : // All of the record keeping for the average term is done in the Update
1468 : // routine so the only other thing that this subroutine does is check to
1469 : // see if the system was even on. If any average term is non-zero, then
1470 : // one or more of the radiant systems was running.
1471 :
1472 : int BaseboardNum; // DO loop counter for surface index
1473 :
1474 2804482 : SteamBaseboardSysOn = false;
1475 :
1476 : // If this was never allocated, then there are no radiant systems in this input file (just RETURN)
1477 2804482 : if (state.dataSteamBaseboardRadiator->NumSteamBaseboards == 0) return;
1478 :
1479 : // If it was allocated, then we have to check to see if this was running at all...
1480 4068 : for (BaseboardNum = 1; BaseboardNum <= state.dataSteamBaseboardRadiator->NumSteamBaseboards; ++BaseboardNum) {
1481 2712 : if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSrcAvg != 0.0) SteamBaseboardSysOn = true;
1482 2712 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSource =
1483 2712 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSrcAvg;
1484 : }
1485 :
1486 1356 : DistributeBBSteamRadGains(state); // QBBSteamRadSource has been modified so we need to redistribute gains
1487 : }
1488 :
1489 26561 : void DistributeBBSteamRadGains(EnergyPlusData &state)
1490 : {
1491 :
1492 : // SUBROUTINE INFORMATION:
1493 : // AUTHOR Rick Strand
1494 : // DATE WRITTEN February 2001
1495 : // MODIFIED Aug. 2009 Daeho Kang (modify only for steam baseboard)
1496 : // April 2010 Brent Griffith, max limit to protect surface temperature calcs
1497 : // RE-ENGINEERED na
1498 :
1499 : // PURPOSE OF THIS SUBROUTINE:
1500 : // To distribute the gains from the steam basebaord heater
1501 : // as specified in the user input file. This includes distribution
1502 : // of long wavelength radiant gains to surfaces and "people."
1503 :
1504 : // METHODOLOGY EMPLOYED:
1505 : // We must cycle through all of the radiant systems because each
1506 : // surface could feel the effect of more than one radiant system.
1507 : // Note that the energy radiated to people is assumed to affect them
1508 : // but them it is assumed to be convected to the air.
1509 :
1510 : using DataHeatBalFanSys::MaxRadHeatFlux;
1511 :
1512 26561 : Real64 constexpr SmallestArea(0.001); // Smallest area in meters squared (to avoid a divide by zero)
1513 :
1514 : Real64 ThisSurfIntensity; // temporary for W/m2 term for rad on a surface
1515 :
1516 79683 : for (auto &thisSteamBB : state.dataSteamBaseboardRadiator->SteamBaseboard) {
1517 212488 : for (int radSurfNum = 1; radSurfNum <= thisSteamBB.TotSurfToDistrib; ++radSurfNum) {
1518 159366 : int surfNum = thisSteamBB.SurfacePtr(radSurfNum);
1519 159366 : state.dataHeatBalFanSys->surfQRadFromHVAC(surfNum).SteamBaseboard = 0.0;
1520 : }
1521 : }
1522 26561 : state.dataHeatBalFanSys->ZoneQSteamBaseboardToPerson = 0.0;
1523 :
1524 79683 : for (int BaseboardNum = 1; BaseboardNum <= state.dataSteamBaseboardRadiator->NumSteamBaseboards; ++BaseboardNum) {
1525 :
1526 53122 : int ZoneNum = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ZonePtr;
1527 : SteamBaseboardDesignData SteamBaseboardDesignDataObject{
1528 53122 : state.dataSteamBaseboardRadiator->SteamBaseboardDesign(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum)
1529 53122 : .DesignObjectPtr)}; // Contains the data for variable flow hydronic systems
1530 53122 : state.dataHeatBalFanSys->ZoneQSteamBaseboardToPerson(ZoneNum) +=
1531 53122 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSource * SteamBaseboardDesignDataObject.FracDistribPerson;
1532 :
1533 212488 : for (int RadSurfNum = 1; RadSurfNum <= state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotSurfToDistrib; ++RadSurfNum) {
1534 159366 : int SurfNum = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SurfacePtr(RadSurfNum);
1535 159366 : if (state.dataSurface->Surface(SurfNum).Area > SmallestArea) {
1536 159366 : ThisSurfIntensity = (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSource *
1537 159366 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).FracDistribToSurf(RadSurfNum) /
1538 159366 : state.dataSurface->Surface(SurfNum).Area);
1539 159366 : state.dataHeatBalFanSys->surfQRadFromHVAC(SurfNum).SteamBaseboard += ThisSurfIntensity;
1540 :
1541 159366 : if (ThisSurfIntensity > MaxRadHeatFlux) { // CR 8074, trap for excessive intensity (throws off surface balance )
1542 0 : ShowSevereError(state, "DistributeBBSteamRadGains: excessive thermal radiation heat flux intensity detected");
1543 0 : ShowContinueError(state, format("Surface = {}", state.dataSurface->Surface(SurfNum).Name));
1544 0 : ShowContinueError(state, format("Surface area = {:.3R} [m2]", state.dataSurface->Surface(SurfNum).Area));
1545 0 : ShowContinueError(state,
1546 0 : format("Occurs in {} = {}",
1547 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
1548 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID));
1549 0 : ShowContinueError(state, format("Radiation intensity = {:.2R} [W/m2]", ThisSurfIntensity));
1550 0 : ShowContinueError(
1551 : state,
1552 0 : format("Assign a larger surface area or more surfaces in {}", state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam));
1553 0 : ShowFatalError(state, "DistributeBBSteamRadGains: excessive thermal radiation heat flux intensity detected");
1554 : }
1555 : } else { // small surface
1556 0 : ShowSevereError(state, "DistributeBBSteamRadGains: surface not large enough to receive thermal radiation heat flux");
1557 0 : ShowContinueError(state, format("Surface = {}", state.dataSurface->Surface(SurfNum).Name));
1558 0 : ShowContinueError(state, format("Surface area = {:.3R} [m2]", state.dataSurface->Surface(SurfNum).Area));
1559 0 : ShowContinueError(state,
1560 0 : format("Occurs in {} = {}",
1561 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
1562 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID));
1563 0 : ShowContinueError(
1564 : state,
1565 0 : format("Assign a larger surface area or more surfaces in {}", state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam));
1566 0 : ShowFatalError(state, "DistributeBBSteamRadGains: surface not large enough to receive thermal radiation heat flux");
1567 : }
1568 : }
1569 53122 : }
1570 26561 : }
1571 :
1572 7356 : void ReportSteamBaseboard(EnergyPlusData &state, int const BaseboardNum)
1573 : {
1574 :
1575 : // SUBROUTINE INFORMATION:
1576 : // AUTHOR Daeho Kang
1577 : // DATE WRITTEN September 2009
1578 : // MODIFIED na
1579 : // RE-ENGINEERED na
1580 :
1581 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotEnergy =
1582 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotPower * state.dataHVACGlobal->TimeStepSys * Constant::SecInHour;
1583 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Energy =
1584 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Power * state.dataHVACGlobal->TimeStepSysSec;
1585 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ConvEnergy =
1586 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ConvPower * state.dataHVACGlobal->TimeStepSys * Constant::SecInHour;
1587 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).RadEnergy =
1588 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).RadPower * state.dataHVACGlobal->TimeStepSys * Constant::SecInHour;
1589 7356 : }
1590 :
1591 : void
1592 0 : UpdateSteamBaseboardPlantConnection(EnergyPlusData &state,
1593 : DataPlant::PlantEquipmentType BaseboardType, // type index
1594 : std::string const &BaseboardName, // component name
1595 : [[maybe_unused]] int const EquipFlowCtrl, // Flow control mode for the equipment
1596 : [[maybe_unused]] int const LoopNum, // Plant loop index for where called from
1597 : [[maybe_unused]] const DataPlant::LoopSideLocation LoopSide, // Plant loop side index for where called from
1598 : int &CompIndex, // Chiller number pointer
1599 : [[maybe_unused]] bool const FirstHVACIteration,
1600 : bool &InitLoopEquip // If not zero, calculate the max load for operating conditions
1601 : )
1602 : {
1603 :
1604 : // SUBROUTINE INFORMATION:
1605 : // AUTHOR Chandan Sharma
1606 : // DATE WRITTEN Sept. 2010
1607 : // MODIFIED na
1608 : // RE-ENGINEERED na
1609 :
1610 : // PURPOSE OF THIS SUBROUTINE:
1611 : // update sim routine called from plant
1612 :
1613 : // METHODOLOGY EMPLOYED:
1614 : // check input, provide comp index, call utility routines
1615 :
1616 : // REFERENCES:
1617 : // Based on UpdateBaseboardPlantConnection from Brent Griffith, Sept 2010
1618 :
1619 : // Using/Aliasing
1620 : using DataPlant::PlantEquipTypeNames;
1621 :
1622 : using PlantUtilities::PullCompInterconnectTrigger;
1623 :
1624 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
1625 :
1626 : int BaseboardNum;
1627 :
1628 : // Find the correct baseboard
1629 0 : if (CompIndex == 0) {
1630 0 : BaseboardNum = Util::FindItemInList(BaseboardName, state.dataSteamBaseboardRadiator->SteamBaseboard, &SteamBaseboardParams::EquipID);
1631 0 : if (BaseboardNum == 0) {
1632 0 : ShowFatalError(state, format("UpdateSteamBaseboardPlantConnection: Specified baseboard not valid ={}", BaseboardName));
1633 : }
1634 0 : CompIndex = BaseboardNum;
1635 : } else {
1636 0 : BaseboardNum = CompIndex;
1637 0 : if (BaseboardNum > state.dataSteamBaseboardRadiator->NumSteamBaseboards || BaseboardNum < 1) {
1638 0 : ShowFatalError(
1639 : state,
1640 0 : format("UpdateSteamBaseboardPlantConnection: Invalid CompIndex passed={}, Number of baseboards={}, Entered baseboard name={}",
1641 : BaseboardNum,
1642 0 : state.dataSteamBaseboardRadiator->NumSteamBaseboards,
1643 : BaseboardName));
1644 : }
1645 0 : if (state.dataGlobal->KickOffSimulation) {
1646 0 : if (BaseboardName != state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID) {
1647 0 : ShowFatalError(state,
1648 0 : format("UpdateSteamBaseboardPlantConnection: Invalid CompIndex passed={}, baseboard name={}, stored baseboard "
1649 : "Name for that index={}",
1650 : BaseboardNum,
1651 : BaseboardName,
1652 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipID));
1653 : }
1654 0 : if (BaseboardType != DataPlant::PlantEquipmentType::Baseboard_Rad_Conv_Steam) {
1655 0 : ShowFatalError(state,
1656 0 : format("UpdateSteamBaseboardPlantConnection: Invalid CompIndex passed={}, baseboard name={}, stored baseboard "
1657 : "Name for that index={}",
1658 : BaseboardNum,
1659 : BaseboardName,
1660 0 : PlantEquipTypeNames[static_cast<int>(BaseboardType)]));
1661 : }
1662 : }
1663 : }
1664 :
1665 0 : if (InitLoopEquip) {
1666 0 : return;
1667 : }
1668 :
1669 0 : PullCompInterconnectTrigger(state,
1670 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).plantLoc,
1671 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).BBLoadReSimIndex,
1672 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).plantLoc,
1673 : DataPlant::CriteriaType::HeatTransferRate,
1674 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Power);
1675 :
1676 0 : PullCompInterconnectTrigger(state,
1677 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).plantLoc,
1678 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).BBLoadReSimIndex,
1679 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).plantLoc,
1680 : DataPlant::CriteriaType::MassFlowRate,
1681 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamMassFlowRate);
1682 :
1683 0 : PullCompInterconnectTrigger(state,
1684 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).plantLoc,
1685 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).BBLoadReSimIndex,
1686 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).plantLoc,
1687 : DataPlant::CriteriaType::Temperature,
1688 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletTemp);
1689 : }
1690 :
1691 : } // namespace SteamBaseboardRadiator
1692 :
1693 : } // namespace EnergyPlus
|
