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