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 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).designObjectName =
538 4 : state.dataIPShortCut->cAlphaArgs(2); // Name of the design object for this baseboard
539 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).DesignObjectPtr =
540 2 : Util::FindItemInList(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).designObjectName,
541 2 : state.dataSteamBaseboardRadiator->SteamBaseboardDesignNames);
542 : SteamBaseboardDesignData SteamBaseboardDesignDataObject{
543 2 : state.dataSteamBaseboardRadiator->SteamBaseboardDesign(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum)
544 2 : .DesignObjectPtr)}; // Contains the design data for steam baseboard object
545 :
546 : // Get schedule
547 2 : if (state.dataIPShortCut->lAlphaFieldBlanks(3)) {
548 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).availSched = Sched::GetScheduleAlwaysOn(state);
549 2 : } else if ((state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).availSched =
550 4 : Sched::GetSchedule(state, state.dataIPShortCut->cAlphaArgs(3))) == nullptr) {
551 0 : ShowSevereItemNotFound(state, eoh, state.dataIPShortCut->cAlphaFieldNames(3), state.dataIPShortCut->cAlphaArgs(3));
552 0 : ErrorsFound = true;
553 : }
554 :
555 : // Get inlet node number
556 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletNode =
557 4 : GetOnlySingleNode(state,
558 2 : state.dataIPShortCut->cAlphaArgs(4),
559 : ErrorsFound,
560 : DataLoopNode::ConnectionObjectType::ZoneHVACBaseboardRadiantConvectiveSteam,
561 2 : state.dataIPShortCut->cAlphaArgs(1),
562 : DataLoopNode::NodeFluidType::Steam,
563 : DataLoopNode::ConnectionType::Inlet,
564 : NodeInputManager::CompFluidStream::Primary,
565 : ObjectIsNotParent);
566 :
567 : // Get outlet node number
568 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletNode =
569 6 : GetOnlySingleNode(state,
570 2 : state.dataIPShortCut->cAlphaArgs(5),
571 : ErrorsFound,
572 : DataLoopNode::ConnectionObjectType::ZoneHVACBaseboardRadiantConvectiveSteam,
573 2 : state.dataIPShortCut->cAlphaArgs(1),
574 : DataLoopNode::NodeFluidType::Steam,
575 : DataLoopNode::ConnectionType::Outlet,
576 : NodeInputManager::CompFluidStream::Primary,
577 : ObjectIsNotParent);
578 4 : TestCompSet(state,
579 2 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
580 2 : state.dataIPShortCut->cAlphaArgs(1),
581 2 : state.dataIPShortCut->cAlphaArgs(4),
582 2 : state.dataIPShortCut->cAlphaArgs(5),
583 : "Hot Steam Nodes");
584 :
585 : // Determine steam baseboard radiator system heating design capacity sizing method
586 2 : if (SteamBaseboardDesignDataObject.HeatingCapMethod == HeatingDesignCapacity) {
587 2 : if (!state.dataIPShortCut->lNumericFieldBlanks(iHeatDesignCapacityNumericNum)) {
588 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ScaledHeatingCapacity =
589 2 : state.dataIPShortCut->rNumericArgs(iHeatDesignCapacityNumericNum);
590 4 : if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ScaledHeatingCapacity < 0.0 &&
591 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ScaledHeatingCapacity != AutoSize) {
592 0 : ShowSevereError(state,
593 0 : format("{} = {}",
594 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
595 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name));
596 0 : ShowContinueError(state,
597 0 : format("Illegal {} = {:.7T}",
598 0 : state.dataIPShortCut->cNumericFieldNames(iHeatDesignCapacityNumericNum),
599 0 : state.dataIPShortCut->rNumericArgs(iHeatDesignCapacityNumericNum)));
600 0 : ErrorsFound = true;
601 : }
602 : } else {
603 0 : ShowSevereError(state,
604 0 : format("{} = {}",
605 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
606 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name));
607 0 : ShowContinueError(state,
608 0 : format("Input for {} = {}",
609 0 : state.dataIPShortCut->cAlphaFieldNames(iHeatCAPMAlphaNum),
610 0 : state.dataIPShortCut->cAlphaArgs(iHeatCAPMAlphaNum)));
611 0 : ShowContinueError(
612 0 : state, format("Blank field not allowed for {}", state.dataIPShortCut->cNumericFieldNames(iHeatDesignCapacityNumericNum)));
613 0 : ErrorsFound = true;
614 : }
615 0 : } else if (SteamBaseboardDesignDataObject.HeatingCapMethod == CapacityPerFloorArea) {
616 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ScaledHeatingCapacity =
617 0 : SteamBaseboardDesignDataObject.DesignScaledHeatingCapacity;
618 0 : } else if (SteamBaseboardDesignDataObject.HeatingCapMethod == FractionOfAutosizedHeatingCapacity) {
619 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ScaledHeatingCapacity =
620 0 : SteamBaseboardDesignDataObject.DesignScaledHeatingCapacity;
621 : }
622 :
623 : // Desired degree of cooling
624 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).DegOfSubcooling = state.dataIPShortCut->rNumericArgs(2);
625 : // Maximum steam flow rate
626 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax = state.dataIPShortCut->rNumericArgs(3);
627 2 : if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax >= MaxSteamFlowRate) {
628 0 : ShowWarningError(state,
629 0 : format("{}{}=\"{}\", {} was higher than the allowable maximum.",
630 : RoutineName,
631 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
632 0 : state.dataIPShortCut->cAlphaArgs(1),
633 0 : state.dataIPShortCut->cNumericFieldNames(3)));
634 0 : ShowContinueError(state, format("...reset to maximum value=[{:.2R}].", MaxSteamFlowRate));
635 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax = MaxSteamFlowRate;
636 4 : } else if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax <= MinSteamFlowRate &&
637 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax != AutoSize) {
638 0 : ShowWarningError(state,
639 0 : format("{}{}=\"{}\", {} was less than the allowable minimum.",
640 : RoutineName,
641 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
642 0 : state.dataIPShortCut->cAlphaArgs(1),
643 0 : state.dataIPShortCut->cNumericFieldNames(3)));
644 0 : ShowContinueError(state, format("...reset to minimum value=[{:.2R}].", MinSteamFlowRate));
645 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax = MinSteamFlowRate;
646 : }
647 : // Remaining fraction is added to the zone as convective heat transfer
648 2 : if (SteamBaseboardDesignDataObject.FracRadiant > MaxFraction) {
649 0 : ShowWarningError(state,
650 0 : format("{}{}=\"{}\", Fraction Radiant was higher than the allowable maximum.",
651 : RoutineName,
652 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
653 0 : state.dataIPShortCut->cAlphaArgs(1)));
654 0 : SteamBaseboardDesignDataObject.FracRadiant = MaxFraction;
655 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).FracConvect = 0.0;
656 : } else {
657 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).FracConvect = 1.0 - SteamBaseboardDesignDataObject.FracRadiant;
658 : }
659 :
660 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotSurfToDistrib = NumNumbers - 3;
661 : // IF (SteamBaseboard(BaseboardNum)%TotSurfToDistrib > MaxDistribSurfaces) THEN
662 : // CALL ShowWarningError(state, RoutineName//cCMO_BBRadiator_Steam//'="'//TRIM(state.dataIPShortCut->cAlphaArgs(1))// &
663 : // '", the number of surface/radiant fraction groups entered was higher than the allowable maximum.')
664 : // CALL ShowContinueError(state, '...only the maximum value=['//TRIM(RoundSigDigits(MaxDistribSurfaces))// &
665 : // '] will be processed.')
666 : // SteamBaseboard(BaseboardNum)%TotSurfToDistrib = MaxDistribSurfaces
667 : // END IF
668 2 : if ((state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotSurfToDistrib < MinDistribSurfaces) &&
669 0 : (SteamBaseboardDesignDataObject.FracRadiant > MinFraction)) {
670 0 : ShowSevereError(state,
671 0 : format("{}{}=\"{}\", the number of surface/radiant fraction groups entered was less than the allowable minimum.",
672 0 : std::string{RoutineName},
673 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
674 0 : state.dataIPShortCut->cAlphaArgs(1)));
675 0 : ShowContinueError(state, format("...the minimum that must be entered=[{}].", MinDistribSurfaces));
676 0 : ErrorsFound = true;
677 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotSurfToDistrib = 0;
678 : }
679 : // Allocate the surfaces and fractions
680 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum)
681 2 : .SurfaceName.allocate(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotSurfToDistrib);
682 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SurfaceName = "";
683 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum)
684 2 : .SurfacePtr.allocate(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotSurfToDistrib);
685 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SurfacePtr = 0;
686 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum)
687 2 : .FracDistribToSurf.allocate(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotSurfToDistrib);
688 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).FracDistribToSurf = 0.0;
689 :
690 : // search zone equipment list structure for zone index
691 14 : for (int ctrlZone = 1; ctrlZone <= state.dataGlobal->NumOfZones; ++ctrlZone) {
692 26 : for (int zoneEquipTypeNum = 1; zoneEquipTypeNum <= state.dataZoneEquip->ZoneEquipList(ctrlZone).NumOfEquipTypes; ++zoneEquipTypeNum) {
693 14 : if (state.dataZoneEquip->ZoneEquipList(ctrlZone).EquipType(zoneEquipTypeNum) ==
694 18 : DataZoneEquipment::ZoneEquipType::BaseboardSteam &&
695 4 : state.dataZoneEquip->ZoneEquipList(ctrlZone).EquipName(zoneEquipTypeNum) ==
696 4 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name) {
697 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ZonePtr = ctrlZone;
698 : }
699 : }
700 : }
701 2 : if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ZonePtr <= 0) {
702 0 : ShowSevereError(state,
703 0 : format("{}{}=\"{}\" is not on any ZoneHVAC:EquipmentList.",
704 : RoutineName,
705 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
706 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name));
707 0 : ErrorsFound = true;
708 0 : continue;
709 : }
710 :
711 2 : Real64 AllFracsSummed = SteamBaseboardDesignDataObject.FracDistribPerson;
712 8 : for (SurfNum = 1; SurfNum <= state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotSurfToDistrib; ++SurfNum) {
713 6 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SurfaceName(SurfNum) = state.dataIPShortCut->cAlphaArgs(SurfNum + 5);
714 6 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SurfacePtr(SurfNum) =
715 6 : HeatBalanceIntRadExchange::GetRadiantSystemSurface(
716 : state,
717 6 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
718 6 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name,
719 6 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ZonePtr,
720 6 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SurfaceName(SurfNum),
721 : ErrorsFound);
722 6 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).FracDistribToSurf(SurfNum) =
723 6 : state.dataIPShortCut->rNumericArgs(SurfNum + 3);
724 6 : if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).FracDistribToSurf(SurfNum) > MaxFraction) {
725 0 : ShowWarningError(state,
726 0 : format("{}{}=\"{}\", {}was greater than the allowable maximum.",
727 : RoutineName,
728 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
729 0 : state.dataIPShortCut->cAlphaArgs(1),
730 0 : state.dataIPShortCut->cNumericFieldNames(SurfNum + 3)));
731 0 : ShowContinueError(state, format("...reset to maximum value=[{:.1R}].", MaxFraction));
732 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotSurfToDistrib = MaxFraction;
733 : }
734 6 : if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).FracDistribToSurf(SurfNum) < MinFraction) {
735 0 : ShowWarningError(state,
736 0 : format("{}{}=\"{}\", {}was less than the allowable minimum.",
737 : RoutineName,
738 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
739 0 : state.dataIPShortCut->cAlphaArgs(1),
740 0 : state.dataIPShortCut->cNumericFieldNames(SurfNum + 3)));
741 0 : ShowContinueError(state, format("...reset to maximum value=[{:.1R}].", MinFraction));
742 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotSurfToDistrib = MinFraction;
743 : }
744 6 : if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SurfacePtr(SurfNum) != 0) {
745 6 : state.dataSurface->surfIntConv(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SurfacePtr(SurfNum))
746 6 : .getsRadiantHeat = true;
747 12 : state.dataSurface->allGetsRadiantHeatSurfaceList.emplace_back(
748 6 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SurfacePtr(SurfNum));
749 : }
750 :
751 6 : AllFracsSummed += state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).FracDistribToSurf(SurfNum);
752 : } // surfaces
753 :
754 2 : if (AllFracsSummed > (MaxFraction + 0.01)) {
755 0 : ShowSevereError(
756 : state,
757 0 : format("Fraction of radiation distributed to surfaces sums up to greater than 1 for {}", state.dataIPShortCut->cAlphaArgs(1)));
758 0 : ShowContinueError(state, format("Occurs in Baseboard Heater={}", state.dataIPShortCut->cAlphaArgs(1)));
759 0 : ErrorsFound = true;
760 : }
761 2 : if ((AllFracsSummed < (MaxFraction - 0.01)) &&
762 0 : (SteamBaseboardDesignDataObject.FracRadiant >
763 : MinFraction)) { // User didn't distribute all of the | radiation warn that some will be lost
764 0 : ShowWarningError(state,
765 0 : format("{}{}=\"{}\", Summed radiant fractions for people + surface groups < 1.0",
766 : RoutineName,
767 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
768 0 : state.dataIPShortCut->cAlphaArgs(1)));
769 0 : ShowContinueError(state, "The rest of the radiant energy delivered by the baseboard heater will be lost");
770 : }
771 :
772 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).steam = Fluid::GetSteam(state);
773 2 : if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).steam == nullptr && BaseboardNum == 1) {
774 0 : ShowSevereError(state, format("{}Steam Properties for {} not found.", RoutineName, state.dataIPShortCut->cAlphaArgs(1)));
775 0 : if (SteamMessageNeeded) {
776 0 : ShowContinueError(state, "Steam Fluid Properties should have been included in the input file.");
777 : }
778 0 : ErrorsFound = true;
779 0 : SteamMessageNeeded = false;
780 : }
781 2 : }
782 :
783 1 : if (ErrorsFound) {
784 0 : ShowFatalError(
785 : state,
786 0 : format("{}{}Errors found getting input. Program terminates.", RoutineName, state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam));
787 : }
788 :
789 : // Setup Report variables for the Coils
790 3 : for (BaseboardNum = 1; BaseboardNum <= state.dataSteamBaseboardRadiator->NumSteamBaseboards; ++BaseboardNum) {
791 : // CurrentModuleObject='ZoneHVAC:Baseboard:RadiantConvective:Steam'
792 4 : SetupOutputVariable(state,
793 : "Baseboard Total Heating Rate",
794 : Constant::Units::W,
795 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotPower,
796 : OutputProcessor::TimeStepType::System,
797 : OutputProcessor::StoreType::Average,
798 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name);
799 :
800 4 : SetupOutputVariable(state,
801 : "Baseboard Convective Heating Rate",
802 : Constant::Units::W,
803 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ConvPower,
804 : OutputProcessor::TimeStepType::System,
805 : OutputProcessor::StoreType::Average,
806 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name);
807 4 : SetupOutputVariable(state,
808 : "Baseboard Radiant Heating Rate",
809 : Constant::Units::W,
810 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).RadPower,
811 : OutputProcessor::TimeStepType::System,
812 : OutputProcessor::StoreType::Average,
813 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name);
814 4 : SetupOutputVariable(state,
815 : "Baseboard Total Heating Energy",
816 : Constant::Units::J,
817 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotEnergy,
818 : OutputProcessor::TimeStepType::System,
819 : OutputProcessor::StoreType::Sum,
820 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name,
821 : Constant::eResource::EnergyTransfer,
822 : OutputProcessor::Group::HVAC,
823 : OutputProcessor::EndUseCat::Baseboard);
824 4 : SetupOutputVariable(state,
825 : "Baseboard Convective Heating Energy",
826 : Constant::Units::J,
827 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ConvEnergy,
828 : OutputProcessor::TimeStepType::System,
829 : OutputProcessor::StoreType::Sum,
830 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name);
831 4 : SetupOutputVariable(state,
832 : "Baseboard Radiant Heating Energy",
833 : Constant::Units::J,
834 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).RadEnergy,
835 : OutputProcessor::TimeStepType::System,
836 : OutputProcessor::StoreType::Sum,
837 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name);
838 4 : SetupOutputVariable(state,
839 : "Baseboard Steam Energy",
840 : Constant::Units::J,
841 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Energy,
842 : OutputProcessor::TimeStepType::System,
843 : OutputProcessor::StoreType::Sum,
844 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name,
845 : Constant::eResource::PlantLoopHeatingDemand,
846 : OutputProcessor::Group::HVAC,
847 : OutputProcessor::EndUseCat::Baseboard);
848 4 : SetupOutputVariable(state,
849 : "Baseboard Steam Rate",
850 : Constant::Units::W,
851 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Power,
852 : OutputProcessor::TimeStepType::System,
853 : OutputProcessor::StoreType::Average,
854 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name);
855 4 : SetupOutputVariable(state,
856 : "Baseboard Steam Mass Flow Rate",
857 : Constant::Units::kg_s,
858 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamMassFlowRate,
859 : OutputProcessor::TimeStepType::System,
860 : OutputProcessor::StoreType::Average,
861 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name);
862 4 : SetupOutputVariable(state,
863 : "Baseboard Steam Inlet Temperature",
864 : Constant::Units::C,
865 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletTemp,
866 : OutputProcessor::TimeStepType::System,
867 : OutputProcessor::StoreType::Average,
868 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name);
869 4 : SetupOutputVariable(state,
870 : "Baseboard Steam Outlet Temperature",
871 : Constant::Units::C,
872 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletTemp,
873 : OutputProcessor::TimeStepType::System,
874 : OutputProcessor::StoreType::Average,
875 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name);
876 : }
877 1 : }
878 :
879 7356 : void InitSteamBaseboard(EnergyPlusData &state, int const BaseboardNum, int const ControlledZoneNum, bool const FirstHVACIteration)
880 : {
881 :
882 : // SUBROUTINE INFORMATION:
883 : // AUTHOR Russ Taylor
884 : // Rick Strand
885 : // DATE WRITTEN Nov 1997
886 : // Feb 2001
887 : // MODIFIED Sep 2009 Daeho Kang (Add Radiant Component)
888 : // Sept 2010 Chandan Sharma, FSEC (plant interactions)
889 :
890 : // PURPOSE OF THIS SUBROUTINE:
891 : // This subroutine initializes the baseboard units.
892 :
893 : // METHODOLOGY EMPLOYED:
894 : // The initialization subroutines both in high temperature radiant radiator
895 : // and convective only baseboard radiator are combined and modified.
896 : // The heater is assumed to be crossflow with both fluids unmixed.
897 :
898 : // REFERENCES:
899 :
900 : // Using/Aliasing
901 : using PlantUtilities::InitComponentNodes;
902 : using PlantUtilities::ScanPlantLoopsForObject;
903 :
904 : static constexpr std::string_view RoutineName("InitSteamCoil");
905 :
906 : int Loop;
907 : int SteamInletNode;
908 : Real64 StartEnthSteam;
909 : Real64 SteamDensity;
910 : bool errFlag;
911 :
912 : // Do the one time initializations
913 7356 : if (state.dataSteamBaseboardRadiator->MyOneTimeFlag) {
914 :
915 : // initialize the environment and sizing flags
916 1 : state.dataSteamBaseboardRadiator->MyEnvrnFlag.dimension(state.dataSteamBaseboardRadiator->NumSteamBaseboards, true);
917 1 : state.dataSteamBaseboardRadiator->MySizeFlag.dimension(state.dataSteamBaseboardRadiator->NumSteamBaseboards, true);
918 1 : state.dataSteamBaseboardRadiator->SetLoopIndexFlag.dimension(state.dataSteamBaseboardRadiator->NumSteamBaseboards, true);
919 1 : state.dataSteamBaseboardRadiator->MyOneTimeFlag = false;
920 : }
921 :
922 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ZonePtr = ControlledZoneNum;
923 :
924 : // Need to check all units to see if they are on ZoneHVAC:EquipmentList or issue warning
925 7356 : if (!state.dataSteamBaseboardRadiator->ZoneEquipmentListChecked && state.dataZoneEquip->ZoneEquipInputsFilled) {
926 1 : state.dataSteamBaseboardRadiator->ZoneEquipmentListChecked = true;
927 3 : for (Loop = 1; Loop <= state.dataSteamBaseboardRadiator->NumSteamBaseboards; ++Loop) {
928 4 : if (CheckZoneEquipmentList(state,
929 2 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
930 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(Loop).Name)) {
931 2 : continue;
932 : }
933 0 : ShowSevereError(state,
934 0 : format("InitBaseboard: Unit=[{},{}] is not on any ZoneHVAC:EquipmentList. It will not be simulated.",
935 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
936 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(Loop).Name));
937 : }
938 : }
939 :
940 7356 : if (state.dataSteamBaseboardRadiator->SetLoopIndexFlag(BaseboardNum)) {
941 2 : if (allocated(state.dataPlnt->PlantLoop)) {
942 2 : errFlag = false;
943 4 : ScanPlantLoopsForObject(state,
944 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name,
945 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipType,
946 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).plantLoc,
947 : errFlag,
948 : _,
949 : _,
950 : _,
951 : _,
952 : _);
953 2 : state.dataSteamBaseboardRadiator->SetLoopIndexFlag(BaseboardNum) = false;
954 2 : if (errFlag) {
955 0 : ShowFatalError(state, "InitSteamBaseboard: Program terminated for previous conditions.");
956 : }
957 : }
958 : }
959 :
960 7358 : if (!state.dataGlobal->SysSizingCalc && state.dataSteamBaseboardRadiator->MySizeFlag(BaseboardNum) &&
961 2 : (!state.dataSteamBaseboardRadiator->SetLoopIndexFlag(BaseboardNum))) {
962 : // For each coil, do the sizing once
963 2 : SizeSteamBaseboard(state, BaseboardNum);
964 2 : state.dataSteamBaseboardRadiator->MySizeFlag(BaseboardNum) = false;
965 : }
966 :
967 : // Do the Begin Environment initializations
968 7356 : if (state.dataGlobal->BeginEnvrnFlag && state.dataSteamBaseboardRadiator->MyEnvrnFlag(BaseboardNum)) {
969 : // Initialize
970 12 : SteamInletNode = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletNode;
971 12 : state.dataLoopNodes->Node(SteamInletNode).Temp = 100.0;
972 12 : state.dataLoopNodes->Node(SteamInletNode).Press = 101325.0;
973 12 : auto *steam = Fluid::GetSteam(state);
974 12 : SteamDensity = steam->getSatDensity(state, state.dataLoopNodes->Node(SteamInletNode).Temp, 1.0, RoutineName);
975 12 : StartEnthSteam = steam->getSatEnthalpy(state, state.dataLoopNodes->Node(SteamInletNode).Temp, 1.0, RoutineName);
976 12 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamMassFlowRateMax =
977 12 : SteamDensity * state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax;
978 36 : InitComponentNodes(state,
979 : 0.0,
980 12 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamMassFlowRateMax,
981 12 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletNode,
982 12 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletNode);
983 12 : state.dataLoopNodes->Node(SteamInletNode).Enthalpy = StartEnthSteam;
984 12 : state.dataLoopNodes->Node(SteamInletNode).Quality = 1.0;
985 12 : state.dataLoopNodes->Node(SteamInletNode).HumRat = 0.0;
986 :
987 : // Initializes radiant sources
988 12 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ZeroBBSteamSourceSumHATsurf = 0.0;
989 12 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSource = 0.0;
990 12 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSrcAvg = 0.0;
991 12 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastQBBSteamRadSrc = 0.0;
992 12 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastSysTimeElapsed = 0.0;
993 12 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastTimeStepSys = 0.0;
994 :
995 12 : state.dataSteamBaseboardRadiator->MyEnvrnFlag(BaseboardNum) = false;
996 : }
997 :
998 7356 : if (!state.dataGlobal->BeginEnvrnFlag) {
999 7290 : state.dataSteamBaseboardRadiator->MyEnvrnFlag(BaseboardNum) = true;
1000 : }
1001 :
1002 7356 : if (state.dataGlobal->BeginTimeStepFlag && FirstHVACIteration) {
1003 2710 : int ZoneNum = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ZonePtr;
1004 2710 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ZeroBBSteamSourceSumHATsurf =
1005 2710 : state.dataHeatBal->Zone(ZoneNum).sumHATsurf(state);
1006 2710 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSrcAvg = 0.0;
1007 2710 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastQBBSteamRadSrc = 0.0;
1008 2710 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastSysTimeElapsed = 0.0;
1009 2710 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastTimeStepSys = 0.0;
1010 : }
1011 :
1012 : // Do the every time step initializations
1013 7356 : SteamInletNode = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletNode;
1014 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamMassFlowRate = state.dataLoopNodes->Node(SteamInletNode).MassFlowRate;
1015 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletTemp = state.dataLoopNodes->Node(SteamInletNode).Temp;
1016 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletEnthalpy = state.dataLoopNodes->Node(SteamInletNode).Enthalpy;
1017 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletPress = state.dataLoopNodes->Node(SteamInletNode).Press;
1018 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletQuality = state.dataLoopNodes->Node(SteamInletNode).Quality;
1019 :
1020 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotPower = 0.0;
1021 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Power = 0.0;
1022 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ConvPower = 0.0;
1023 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).RadPower = 0.0;
1024 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotEnergy = 0.0;
1025 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Energy = 0.0;
1026 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ConvEnergy = 0.0;
1027 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).RadEnergy = 0.0;
1028 7356 : }
1029 :
1030 2 : void SizeSteamBaseboard(EnergyPlusData &state, int const BaseboardNum)
1031 : {
1032 :
1033 : // SUBROUTINE INFORMATION:
1034 : // AUTHOR Fred Buhl
1035 : // DATE WRITTEN February 2002
1036 : // MODIFIED August 2013 Daeho Kang, add component sizing table entries
1037 : // August 2014 Bereket Nigusse, added scalable sizing
1038 : // RE-ENGINEERED na
1039 :
1040 : // PURPOSE OF THIS SUBROUTINE:
1041 : // This subroutine is for sizing steam baseboard components
1042 :
1043 : // METHODOLOGY EMPLOYED:
1044 : // Obtains flow rates from the zone sizing arrays and plant sizing data.
1045 :
1046 : // REFERENCES:
1047 : // na
1048 :
1049 : // Using/Aliasing
1050 : using namespace DataSizing;
1051 : using HVAC::HeatingCapacitySizing;
1052 : using PlantUtilities::RegisterPlantCompDesignFlow;
1053 :
1054 : // SUBROUTINE PARAMETER DEFINITIONS:
1055 : static constexpr std::string_view RoutineName("SizeSteamBaseboard");
1056 :
1057 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
1058 2 : int PltSizSteamNum(0); // Index of plant sizing object for 1st steam loop
1059 2 : Real64 DesCoilLoad(0.0); // Design heating load in the zone
1060 : Real64 SteamInletTemp; // Inlet steam temperature in C
1061 : Real64 EnthSteamInDry; // Enthalpy of dry steam
1062 : Real64 EnthSteamOutWet; // Enthalpy of wet steam
1063 : Real64 LatentHeatSteam; // latent heat of steam
1064 : Real64 SteamDensity; // Density of steam
1065 : Real64 Cp; // local fluid specific heat
1066 2 : bool ErrorsFound(false); // If errors detected in input
1067 2 : bool IsAutoSize(false); // Indicator to autosizing steam flow
1068 2 : Real64 SteamVolFlowRateMaxDes(0.0); // Design maximum steam volume flow for reporting
1069 2 : Real64 SteamVolFlowRateMaxUser(0.0); // User hard-sized maximum steam volume flow for reporting
1070 2 : std::string CompName; // component name
1071 2 : std::string CompType; // component type
1072 2 : std::string SizingString; // input field sizing description (e.g., Nominal Capacity)
1073 : Real64 TempSize; // autosized value of coil input field
1074 2 : int FieldNum = 1; // IDD numeric field number where input field description is found
1075 : int SizingMethod; // Integer representation of sizing method name (HeatingCapacitySizing)
1076 : bool PrintFlag; // TRUE when sizing information is reported in the eio file
1077 2 : int CapSizingMethod(0); // capacity sizing methods (HeatingDesignCapacity, CapacityPerFloorArea, and FractionOfAutosizedHeatingCapacity )
1078 :
1079 2 : int &CurZoneEqNum = state.dataSize->CurZoneEqNum;
1080 :
1081 2 : SteamBaseboardDesignData SteamBaseboardDesignDataObject{state.dataSteamBaseboardRadiator->SteamBaseboardDesign(
1082 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).DesignObjectPtr)}; // Contains the data for variable flow hydronic systems
1083 :
1084 : // Find the appropriate steam plant sizing object
1085 2 : PltSizSteamNum = state.dataPlnt->PlantLoop(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).plantLoc.loopNum).PlantSizNum;
1086 : // PltSizSteamNum = MyPlantSizingIndex('Coil:Heating:Steam', SteamBaseboard(BaseboardNum)%EquipID, &
1087 : // SteamBaseboard(BaseboardNum)%SteamInletNode, &
1088 : // SteamBaseboard(BaseboardNum)%SteamOutletNode, ErrorsFound)
1089 :
1090 2 : if (PltSizSteamNum > 0) {
1091 :
1092 2 : state.dataSize->DataScalableCapSizingON = false;
1093 :
1094 2 : if (CurZoneEqNum > 0) {
1095 :
1096 2 : if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax == AutoSize) {
1097 2 : IsAutoSize = true;
1098 : }
1099 2 : if (!IsAutoSize && !state.dataSize->ZoneSizingRunDone) {
1100 0 : if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax > 0.0) {
1101 0 : BaseSizer::reportSizerOutput(state,
1102 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
1103 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name,
1104 : "User-Specified Maximum Water Flow Rate [m3/s]",
1105 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax);
1106 : }
1107 : } else {
1108 2 : CheckZoneSizing(state,
1109 2 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
1110 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name);
1111 :
1112 2 : auto &zoneEqSizing = state.dataSize->ZoneEqSizing(CurZoneEqNum);
1113 2 : CompType = state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam;
1114 2 : CompName = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name;
1115 2 : state.dataSize->DataFracOfAutosizedHeatingCapacity = 1.0;
1116 2 : state.dataSize->DataZoneNumber = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ZonePtr;
1117 2 : SizingMethod = HeatingCapacitySizing;
1118 2 : FieldNum = 1;
1119 2 : PrintFlag = false;
1120 2 : SizingString = state.dataSteamBaseboardRadiator->SteamBaseboardNumericFields(BaseboardNum).FieldNames(FieldNum) + " [W]";
1121 2 : CapSizingMethod = SteamBaseboardDesignDataObject.HeatingCapMethod;
1122 2 : zoneEqSizing.SizingMethod(SizingMethod) = CapSizingMethod;
1123 2 : if (CapSizingMethod == HeatingDesignCapacity || CapSizingMethod == CapacityPerFloorArea ||
1124 : CapSizingMethod == FractionOfAutosizedHeatingCapacity) {
1125 :
1126 2 : if (CapSizingMethod == HeatingDesignCapacity) {
1127 2 : if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ScaledHeatingCapacity == AutoSize) {
1128 2 : CheckZoneSizing(state, CompType, CompName);
1129 2 : zoneEqSizing.HeatingCapacity = true;
1130 2 : zoneEqSizing.DesHeatingLoad = state.dataSize->FinalZoneSizing(CurZoneEqNum).NonAirSysDesHeatLoad;
1131 : }
1132 2 : TempSize = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ScaledHeatingCapacity;
1133 0 : } else if (CapSizingMethod == CapacityPerFloorArea) {
1134 0 : zoneEqSizing.HeatingCapacity = true;
1135 0 : zoneEqSizing.DesHeatingLoad = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ScaledHeatingCapacity *
1136 0 : state.dataHeatBal->Zone(state.dataSize->DataZoneNumber).FloorArea;
1137 0 : TempSize = zoneEqSizing.DesHeatingLoad;
1138 0 : state.dataSize->DataScalableCapSizingON = true;
1139 0 : } else if (CapSizingMethod == FractionOfAutosizedHeatingCapacity) {
1140 0 : CheckZoneSizing(state, CompType, CompName);
1141 0 : zoneEqSizing.HeatingCapacity = true;
1142 0 : state.dataSize->DataFracOfAutosizedHeatingCapacity =
1143 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ScaledHeatingCapacity;
1144 0 : zoneEqSizing.DesHeatingLoad = state.dataSize->FinalZoneSizing(CurZoneEqNum).NonAirSysDesHeatLoad;
1145 0 : TempSize = AutoSize;
1146 0 : state.dataSize->DataScalableCapSizingON = true;
1147 : } else {
1148 0 : TempSize = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ScaledHeatingCapacity;
1149 : }
1150 2 : bool errorsFound = false;
1151 2 : HeatingCapacitySizer sizerHeatingCapacity;
1152 2 : sizerHeatingCapacity.overrideSizingString(SizingString);
1153 2 : sizerHeatingCapacity.initializeWithinEP(state, CompType, CompName, PrintFlag, RoutineName);
1154 2 : DesCoilLoad = sizerHeatingCapacity.size(state, TempSize, errorsFound);
1155 2 : state.dataSize->DataScalableCapSizingON = false;
1156 2 : } else {
1157 0 : DesCoilLoad = 0.0; // FinalZoneSizing(CurZoneEqNum).NonAirSysDesHeatLoad;
1158 : }
1159 :
1160 2 : if (DesCoilLoad >= SmallLoad) {
1161 2 : SteamInletTemp = 100.0;
1162 2 : auto *steam = Fluid::GetSteam(state);
1163 2 : EnthSteamInDry = steam->getSatEnthalpy(state, SteamInletTemp, 1.0, RoutineName);
1164 2 : EnthSteamOutWet = steam->getSatEnthalpy(state, SteamInletTemp, 0.0, RoutineName);
1165 2 : LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet;
1166 2 : SteamDensity = steam->getSatDensity(state, SteamInletTemp, 1.0, RoutineName);
1167 2 : Cp = steam->getSatSpecificHeat(state, SteamInletTemp, 0.0, RoutineName);
1168 :
1169 2 : SteamVolFlowRateMaxDes =
1170 2 : DesCoilLoad /
1171 2 : (SteamDensity * (LatentHeatSteam + state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).DegOfSubcooling * Cp));
1172 : } else {
1173 0 : SteamVolFlowRateMaxDes = 0.0;
1174 : }
1175 :
1176 2 : if (IsAutoSize) {
1177 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax = SteamVolFlowRateMaxDes;
1178 4 : BaseSizer::reportSizerOutput(state,
1179 2 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
1180 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name,
1181 : "Design Size Maximum Steam Flow Rate [m3/s]",
1182 : SteamVolFlowRateMaxDes);
1183 : } else { // Hard size with sizing data
1184 0 : if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax > 0.0 &&
1185 0 : SteamVolFlowRateMaxDes > 0.0) {
1186 0 : SteamVolFlowRateMaxUser = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax;
1187 0 : BaseSizer::reportSizerOutput(state,
1188 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
1189 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name,
1190 : "Design Size Maximum Steam Flow Rate [m3/s]",
1191 : SteamVolFlowRateMaxDes,
1192 : "User-Specified Maximum Steam Flow Rate [m3/s]",
1193 : SteamVolFlowRateMaxUser);
1194 0 : if (state.dataGlobal->DisplayExtraWarnings) {
1195 : // Report difference between design size and user-specified values
1196 0 : if ((std::abs(SteamVolFlowRateMaxDes - SteamVolFlowRateMaxUser) / SteamVolFlowRateMaxUser) >
1197 0 : state.dataSize->AutoVsHardSizingThreshold) {
1198 0 : ShowMessage(state,
1199 0 : format("SizeSteamBaseboard: Potential issue with equipment sizing for "
1200 : "ZoneHVAC:Baseboard:RadiantConvective:Steam=\"{}\".",
1201 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name));
1202 0 : ShowContinueError(state,
1203 0 : format("User-Specified Maximum Steam Flow Rate of {:.5R} [m3/s]", SteamVolFlowRateMaxUser));
1204 0 : ShowContinueError(
1205 0 : state, format("differs from Design Size Maximum Steam Flow Rate of {:.5R} [m3/s]", SteamVolFlowRateMaxDes));
1206 0 : ShowContinueError(state, "This may, or may not, indicate mismatched component sizes.");
1207 0 : ShowContinueError(state, "Verify that the value entered is intended and is consistent with other components.");
1208 : }
1209 : }
1210 : }
1211 : }
1212 : }
1213 : }
1214 : } else {
1215 0 : if (IsAutoSize) {
1216 : // if there is no heating Sizing:Plant object and autosizing was requested, issue an error message
1217 : // first error will be issued by MyPlantSizingIndex
1218 0 : ShowSevereError(state, "Autosizing of steam baseboard requires a heating loop Sizing:Plant object");
1219 0 : ShowContinueError(state,
1220 0 : format("Occurs in Baseboard Heater={}", state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name));
1221 0 : ErrorsFound = true;
1222 : }
1223 : }
1224 :
1225 4 : RegisterPlantCompDesignFlow(state,
1226 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletNode,
1227 2 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax);
1228 :
1229 2 : if (ErrorsFound) {
1230 0 : ShowFatalError(state, "Preceding sizing errors cause program termination");
1231 : }
1232 2 : }
1233 :
1234 32562 : void CalcSteamBaseboard(EnergyPlusData &state, int &BaseboardNum, Real64 &LoadMet)
1235 : {
1236 : // SUBROUTINE INFORMATION:
1237 : // AUTHOR Daeho Kang
1238 : // DATE WRITTEN September 2009
1239 : // MODIFIED Sep 2011 LKL/BG - resimulate only zones needing it for Radiant systems
1240 : // RE-ENGINEERED na
1241 :
1242 : // PURPOSE OF THIS SUBROUTINE:
1243 : // This subroutine calculates both the convective and radiant heat transfer rate
1244 : // of steam baseboard heaters. The heater is assumed to be crossflow with
1245 : // both fluids unmixed. The air flow is buoyancy driven and a constant airflow.
1246 :
1247 : // METHODOLOGY EMPLOYED:
1248 : // Equations that calculates heating capacity of steam coils and outlet air and water temperatures
1249 : // of the zone control steam coil in steam coil module in EnergyPlus are employed.
1250 :
1251 : // REFERENCES:
1252 :
1253 : // Using/Aliasing
1254 : using HVAC::SmallLoad;
1255 :
1256 : // Locals
1257 : // SUBROUTINE ARGUMENT DEFINITIONS:
1258 :
1259 : // SUBROUTINE PARAMETER DEFINITIONS:
1260 : static constexpr std::string_view RoutineName("CalcSteamBaseboard");
1261 :
1262 : // INTERFACE BLOCK SPECIFICATIONS
1263 : // na
1264 :
1265 : // DERIVED TYPE DEFINITIONS
1266 : // na
1267 :
1268 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
1269 : int ZoneNum;
1270 : Real64 RadHeat;
1271 : Real64 SteamBBHeat;
1272 : Real64 SteamInletTemp;
1273 : Real64 SteamOutletTemp;
1274 : Real64 SteamMassFlowRate;
1275 : Real64 SubcoolDeltaT;
1276 : Real64 QZnReq;
1277 : Real64 EnthSteamInDry;
1278 : Real64 EnthSteamOutWet;
1279 : Real64 LatentHeatSteam;
1280 : Real64 Cp;
1281 :
1282 32562 : SteamBaseboardDesignData SteamBaseboardDesignDataObject{state.dataSteamBaseboardRadiator->SteamBaseboardDesign(
1283 32562 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).DesignObjectPtr)}; // Contains the data for variable flow hydronic systems
1284 :
1285 32562 : ZoneNum = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ZonePtr;
1286 32562 : QZnReq = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(ZoneNum).RemainingOutputReqToHeatSP;
1287 32562 : SteamInletTemp = state.dataLoopNodes->Node(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletNode).Temp;
1288 32562 : SteamOutletTemp = SteamInletTemp;
1289 32562 : SteamMassFlowRate = state.dataLoopNodes->Node(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletNode).MassFlowRate;
1290 32562 : SubcoolDeltaT = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).DegOfSubcooling;
1291 :
1292 57767 : if (QZnReq > SmallLoad && !state.dataZoneEnergyDemand->CurDeadBandOrSetback(ZoneNum) && SteamMassFlowRate > 0.0 &&
1293 25205 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).availSched->getCurrentVal() > 0) {
1294 : // Unit is on
1295 25205 : auto *steam = Fluid::GetSteam(state);
1296 25205 : EnthSteamInDry = steam->getSatEnthalpy(state, SteamInletTemp, 1.0, RoutineName);
1297 25205 : EnthSteamOutWet = steam->getSatEnthalpy(state, SteamInletTemp, 0.0, RoutineName);
1298 25205 : LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet;
1299 25205 : Cp = steam->getSatSpecificHeat(state, SteamInletTemp, 0.0, RoutineName);
1300 25205 : SteamBBHeat = SteamMassFlowRate * (LatentHeatSteam + SubcoolDeltaT * Cp); // Baseboard heating rate
1301 25205 : SteamOutletTemp = SteamInletTemp - SubcoolDeltaT; // Outlet temperature of steam
1302 : // Estimate radiant heat addition
1303 25205 : RadHeat = SteamBBHeat * SteamBaseboardDesignDataObject.FracRadiant; // Radiant heating rate
1304 25205 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSource =
1305 : RadHeat; // Radiant heat source which will be distributed to surfaces and people
1306 :
1307 : // Now, distribute the radiant energy of all systems to the appropriate surfaces, to people, and the air
1308 25205 : DistributeBBSteamRadGains(state);
1309 : // Now "simulate" the system by recalculating the heat balances
1310 25205 : HeatBalanceSurfaceManager::CalcHeatBalanceOutsideSurf(state, ZoneNum);
1311 25205 : HeatBalanceSurfaceManager::CalcHeatBalanceInsideSurf(state, ZoneNum);
1312 :
1313 : // Here an assumption is made regarding radiant heat transfer to people.
1314 : // While the radiant heat transfer to people array will be used by the thermal comfort
1315 : // routines, the energy transfer to people would get lost from the perspective
1316 : // of the heat balance. So, to avoid this net loss of energy which clearly
1317 : // gets added to the zones, we must account for it somehow. This assumption
1318 : // that all energy radiated to people is converted to convective energy is
1319 : // not very precise, but at least it conserves energy. The system impact to heat balance
1320 : // should include this.
1321 :
1322 : // Actual system load that the unit should meet
1323 25205 : LoadMet = (state.dataHeatBal->Zone(ZoneNum).sumHATsurf(state) -
1324 25205 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ZeroBBSteamSourceSumHATsurf) +
1325 25205 : (SteamBBHeat * state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).FracConvect) +
1326 25205 : (RadHeat * SteamBaseboardDesignDataObject.FracDistribPerson);
1327 25205 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletEnthalpy =
1328 25205 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletEnthalpy - SteamBBHeat / SteamMassFlowRate;
1329 25205 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletQuality = 0.0;
1330 : } else {
1331 7357 : SteamOutletTemp = SteamInletTemp;
1332 7357 : SteamBBHeat = 0.0;
1333 7357 : LoadMet = 0.0;
1334 7357 : RadHeat = 0.0;
1335 7357 : SteamMassFlowRate = 0.0;
1336 7357 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSource = 0.0;
1337 7357 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletQuality = 0.0;
1338 7357 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletEnthalpy =
1339 7357 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletEnthalpy;
1340 : }
1341 :
1342 32562 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletTemp = SteamOutletTemp;
1343 32562 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamMassFlowRate = SteamMassFlowRate;
1344 32562 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletEnthalpy =
1345 32562 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletEnthalpy;
1346 32562 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletQuality =
1347 32562 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletQuality;
1348 32562 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotPower = LoadMet;
1349 32562 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Power = SteamBBHeat;
1350 32562 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ConvPower = SteamBBHeat - RadHeat;
1351 32562 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).RadPower = RadHeat;
1352 32562 : }
1353 :
1354 7356 : void UpdateSteamBaseboard(EnergyPlusData &state, int const BaseboardNum)
1355 : {
1356 : // SUBROUTINE INFORMATION:
1357 : // AUTHOR Russ Taylor
1358 : // Rick Strand
1359 : // DATE WRITTEN Nov 1997
1360 : // February 2001
1361 : // MODIFIED Sep 2009 Daeho Kang (add radiant component)
1362 : // RE-ENGINEERED na
1363 :
1364 : // PURPOSE OF THIS SUBROUTINE:
1365 :
1366 : // METHODOLOGY EMPLOYED:
1367 : // The update subroutines both in high temperature radiant radiator
1368 : // and convective only baseboard radiator are combined and modified.
1369 :
1370 : using PlantUtilities::SafeCopyPlantNode;
1371 :
1372 : int SteamInletNode;
1373 : int SteamOutletNode;
1374 :
1375 : // First, update the running average if necessary...
1376 7356 : if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastSysTimeElapsed == state.dataHVACGlobal->SysTimeElapsed) {
1377 6776 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSrcAvg -=
1378 6776 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastQBBSteamRadSrc *
1379 6776 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastTimeStepSys / state.dataGlobal->TimeStepZone;
1380 : }
1381 : // Update the running average and the "last" values with the current values of the appropriate variables
1382 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSrcAvg +=
1383 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSource * state.dataHVACGlobal->TimeStepSys /
1384 7356 : state.dataGlobal->TimeStepZone;
1385 :
1386 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastQBBSteamRadSrc =
1387 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSource;
1388 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastSysTimeElapsed = state.dataHVACGlobal->SysTimeElapsed;
1389 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastTimeStepSys = state.dataHVACGlobal->TimeStepSys;
1390 :
1391 7356 : SteamInletNode = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletNode;
1392 7356 : SteamOutletNode = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletNode;
1393 :
1394 : // Set the outlet air nodes of the Baseboard
1395 : // Set the outlet water nodes for the Coil
1396 7356 : SafeCopyPlantNode(state, SteamInletNode, SteamOutletNode);
1397 7356 : state.dataLoopNodes->Node(SteamOutletNode).Temp = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletTemp;
1398 7356 : state.dataLoopNodes->Node(SteamOutletNode).Enthalpy = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletEnthalpy;
1399 7356 : }
1400 :
1401 2828212 : void UpdateBBSteamRadSourceValAvg(EnergyPlusData &state, bool &SteamBaseboardSysOn) // .TRUE. if the radiant system has run this zone time step
1402 : {
1403 :
1404 : // SUBROUTINE INFORMATION:
1405 : // AUTHOR Rick Strand
1406 : // DATE WRITTEN February 2001
1407 : // MODIFIED Aug 2009 Daeho Kang (modify only for baseboard)
1408 : // RE-ENGINEERED na
1409 :
1410 : // PURPOSE OF THIS SUBROUTINE:
1411 : // To transfer the average value of the heat source over the entire
1412 : // zone time step back to the heat balance routines so that the heat
1413 : // balance algorithms can simulate one last time with the average source
1414 : // to maintain some reasonable amount of continuity and energy balance
1415 : // in the temperature and flux histories.
1416 :
1417 : // METHODOLOGY EMPLOYED:
1418 : // All of the record keeping for the average term is done in the Update
1419 : // routine so the only other thing that this subroutine does is check to
1420 : // see if the system was even on. If any average term is non-zero, then
1421 : // one or more of the radiant systems was running.
1422 :
1423 : int BaseboardNum; // DO loop counter for surface index
1424 :
1425 2828212 : SteamBaseboardSysOn = false;
1426 :
1427 : // If this was never allocated, then there are no radiant systems in this input file (just RETURN)
1428 2828212 : if (state.dataSteamBaseboardRadiator->NumSteamBaseboards == 0) {
1429 2826856 : return;
1430 : }
1431 :
1432 : // If it was allocated, then we have to check to see if this was running at all...
1433 4068 : for (BaseboardNum = 1; BaseboardNum <= state.dataSteamBaseboardRadiator->NumSteamBaseboards; ++BaseboardNum) {
1434 2712 : if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSrcAvg != 0.0) {
1435 1344 : SteamBaseboardSysOn = true;
1436 : }
1437 2712 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSource =
1438 2712 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSrcAvg;
1439 : }
1440 :
1441 1356 : DistributeBBSteamRadGains(state); // QBBSteamRadSource has been modified so we need to redistribute gains
1442 : }
1443 :
1444 26561 : void DistributeBBSteamRadGains(EnergyPlusData &state)
1445 : {
1446 :
1447 : // SUBROUTINE INFORMATION:
1448 : // AUTHOR Rick Strand
1449 : // DATE WRITTEN February 2001
1450 : // MODIFIED Aug. 2009 Daeho Kang (modify only for steam baseboard)
1451 : // April 2010 Brent Griffith, max limit to protect surface temperature calcs
1452 : // RE-ENGINEERED na
1453 :
1454 : // PURPOSE OF THIS SUBROUTINE:
1455 : // To distribute the gains from the steam baseboard heater
1456 : // as specified in the user input file. This includes distribution
1457 : // of long wavelength radiant gains to surfaces and "people."
1458 :
1459 : // METHODOLOGY EMPLOYED:
1460 : // We must cycle through all of the radiant systems because each
1461 : // surface could feel the effect of more than one radiant system.
1462 : // Note that the energy radiated to people is assumed to affect them
1463 : // but them it is assumed to be convected to the air.
1464 :
1465 : using DataHeatBalFanSys::MaxRadHeatFlux;
1466 :
1467 26561 : Real64 constexpr SmallestArea(0.001); // Smallest area in meters squared (to avoid a divide by zero)
1468 :
1469 : Real64 ThisSurfIntensity; // temporary for W/m2 term for rad on a surface
1470 :
1471 79683 : for (auto &thisSteamBB : state.dataSteamBaseboardRadiator->SteamBaseboard) {
1472 212488 : for (int radSurfNum = 1; radSurfNum <= thisSteamBB.TotSurfToDistrib; ++radSurfNum) {
1473 159366 : int surfNum = thisSteamBB.SurfacePtr(radSurfNum);
1474 159366 : state.dataHeatBalFanSys->surfQRadFromHVAC(surfNum).SteamBaseboard = 0.0;
1475 : }
1476 : }
1477 26561 : state.dataHeatBalFanSys->ZoneQSteamBaseboardToPerson = 0.0;
1478 :
1479 79683 : for (int BaseboardNum = 1; BaseboardNum <= state.dataSteamBaseboardRadiator->NumSteamBaseboards; ++BaseboardNum) {
1480 :
1481 53122 : int ZoneNum = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ZonePtr;
1482 : SteamBaseboardDesignData SteamBaseboardDesignDataObject{
1483 53122 : state.dataSteamBaseboardRadiator->SteamBaseboardDesign(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum)
1484 53122 : .DesignObjectPtr)}; // Contains the data for variable flow hydronic systems
1485 53122 : state.dataHeatBalFanSys->ZoneQSteamBaseboardToPerson(ZoneNum) +=
1486 53122 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSource * SteamBaseboardDesignDataObject.FracDistribPerson;
1487 :
1488 212488 : for (int RadSurfNum = 1; RadSurfNum <= state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotSurfToDistrib; ++RadSurfNum) {
1489 159366 : int SurfNum = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SurfacePtr(RadSurfNum);
1490 159366 : if (state.dataSurface->Surface(SurfNum).Area > SmallestArea) {
1491 159366 : ThisSurfIntensity = (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSource *
1492 159366 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).FracDistribToSurf(RadSurfNum) /
1493 159366 : state.dataSurface->Surface(SurfNum).Area);
1494 159366 : state.dataHeatBalFanSys->surfQRadFromHVAC(SurfNum).SteamBaseboard += ThisSurfIntensity;
1495 :
1496 159366 : if (ThisSurfIntensity > MaxRadHeatFlux) { // CR 8074, trap for excessive intensity (throws off surface balance )
1497 0 : ShowSevereError(state, "DistributeBBSteamRadGains: excessive thermal radiation heat flux intensity detected");
1498 0 : ShowContinueError(state, format("Surface = {}", state.dataSurface->Surface(SurfNum).Name));
1499 0 : ShowContinueError(state, format("Surface area = {:.3R} [m2]", state.dataSurface->Surface(SurfNum).Area));
1500 0 : ShowContinueError(state,
1501 0 : format("Occurs in {} = {}",
1502 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
1503 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name));
1504 0 : ShowContinueError(state, format("Radiation intensity = {:.2R} [W/m2]", ThisSurfIntensity));
1505 0 : ShowContinueError(
1506 : state,
1507 0 : format("Assign a larger surface area or more surfaces in {}", state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam));
1508 0 : ShowFatalError(state, "DistributeBBSteamRadGains: excessive thermal radiation heat flux intensity detected");
1509 : }
1510 : } else { // small surface
1511 0 : ShowSevereError(state, "DistributeBBSteamRadGains: surface not large enough to receive thermal radiation heat flux");
1512 0 : ShowContinueError(state, format("Surface = {}", state.dataSurface->Surface(SurfNum).Name));
1513 0 : ShowContinueError(state, format("Surface area = {:.3R} [m2]", state.dataSurface->Surface(SurfNum).Area));
1514 0 : ShowContinueError(state,
1515 0 : format("Occurs in {} = {}",
1516 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
1517 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name));
1518 0 : ShowContinueError(
1519 : state,
1520 0 : format("Assign a larger surface area or more surfaces in {}", state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam));
1521 0 : ShowFatalError(state, "DistributeBBSteamRadGains: surface not large enough to receive thermal radiation heat flux");
1522 : }
1523 : }
1524 53122 : }
1525 26561 : }
1526 :
1527 7356 : void ReportSteamBaseboard(EnergyPlusData &state, int const BaseboardNum)
1528 : {
1529 :
1530 : // SUBROUTINE INFORMATION:
1531 : // AUTHOR Daeho Kang
1532 : // DATE WRITTEN September 2009
1533 : // MODIFIED na
1534 : // RE-ENGINEERED na
1535 :
1536 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotEnergy =
1537 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotPower * state.dataHVACGlobal->TimeStepSysSec;
1538 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Energy =
1539 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Power * state.dataHVACGlobal->TimeStepSysSec;
1540 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ConvEnergy =
1541 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ConvPower * state.dataHVACGlobal->TimeStepSysSec;
1542 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).RadEnergy =
1543 7356 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).RadPower * state.dataHVACGlobal->TimeStepSysSec;
1544 7356 : }
1545 :
1546 : void
1547 0 : UpdateSteamBaseboardPlantConnection(EnergyPlusData &state,
1548 : DataPlant::PlantEquipmentType BaseboardType, // type index
1549 : std::string const &BaseboardName, // component name
1550 : [[maybe_unused]] int const EquipFlowCtrl, // Flow control mode for the equipment
1551 : [[maybe_unused]] int const LoopNum, // Plant loop index for where called from
1552 : [[maybe_unused]] const DataPlant::LoopSideLocation LoopSide, // Plant loop side index for where called from
1553 : int &CompIndex, // Chiller number pointer
1554 : [[maybe_unused]] bool const FirstHVACIteration,
1555 : bool const InitLoopEquip // If not zero, calculate the max load for operating conditions
1556 : )
1557 : {
1558 :
1559 : // SUBROUTINE INFORMATION:
1560 : // AUTHOR Chandan Sharma
1561 : // DATE WRITTEN Sept. 2010
1562 : // MODIFIED na
1563 : // RE-ENGINEERED na
1564 :
1565 : // PURPOSE OF THIS SUBROUTINE:
1566 : // update sim routine called from plant
1567 :
1568 : // METHODOLOGY EMPLOYED:
1569 : // check input, provide comp index, call utility routines
1570 :
1571 : // REFERENCES:
1572 : // Based on UpdateBaseboardPlantConnection from Brent Griffith, Sept 2010
1573 :
1574 : // Using/Aliasing
1575 : using DataPlant::PlantEquipTypeNames;
1576 :
1577 : using PlantUtilities::PullCompInterconnectTrigger;
1578 :
1579 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
1580 :
1581 : int BaseboardNum;
1582 :
1583 : // Find the correct baseboard
1584 0 : if (CompIndex == 0) {
1585 0 : BaseboardNum = Util::FindItemInList(BaseboardName, state.dataSteamBaseboardRadiator->SteamBaseboard, &SteamBaseboardParams::Name);
1586 0 : if (BaseboardNum == 0) {
1587 0 : ShowFatalError(state, format("UpdateSteamBaseboardPlantConnection: Specified baseboard not valid ={}", BaseboardName));
1588 : }
1589 0 : CompIndex = BaseboardNum;
1590 : } else {
1591 0 : BaseboardNum = CompIndex;
1592 0 : if (BaseboardNum > state.dataSteamBaseboardRadiator->NumSteamBaseboards || BaseboardNum < 1) {
1593 0 : ShowFatalError(
1594 : state,
1595 0 : format("UpdateSteamBaseboardPlantConnection: Invalid CompIndex passed={}, Number of baseboards={}, Entered baseboard name={}",
1596 : BaseboardNum,
1597 0 : state.dataSteamBaseboardRadiator->NumSteamBaseboards,
1598 : BaseboardName));
1599 : }
1600 0 : if (state.dataGlobal->KickOffSimulation) {
1601 0 : if (BaseboardName != state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name) {
1602 0 : ShowFatalError(state,
1603 0 : format("UpdateSteamBaseboardPlantConnection: Invalid CompIndex passed={}, baseboard name={}, stored baseboard "
1604 : "Name for that index={}",
1605 : BaseboardNum,
1606 : BaseboardName,
1607 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name));
1608 : }
1609 0 : if (BaseboardType != DataPlant::PlantEquipmentType::Baseboard_Rad_Conv_Steam) {
1610 0 : ShowFatalError(state,
1611 0 : format("UpdateSteamBaseboardPlantConnection: Invalid CompIndex passed={}, baseboard name={}, stored baseboard "
1612 : "Name for that index={}",
1613 : BaseboardNum,
1614 : BaseboardName,
1615 0 : PlantEquipTypeNames[static_cast<int>(BaseboardType)]));
1616 : }
1617 : }
1618 : }
1619 :
1620 0 : if (InitLoopEquip) {
1621 0 : return;
1622 : }
1623 :
1624 0 : PullCompInterconnectTrigger(state,
1625 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).plantLoc,
1626 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).BBLoadReSimIndex,
1627 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).plantLoc,
1628 : DataPlant::CriteriaType::HeatTransferRate,
1629 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Power);
1630 :
1631 0 : PullCompInterconnectTrigger(state,
1632 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).plantLoc,
1633 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).BBLoadReSimIndex,
1634 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).plantLoc,
1635 : DataPlant::CriteriaType::MassFlowRate,
1636 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamMassFlowRate);
1637 :
1638 0 : PullCompInterconnectTrigger(state,
1639 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).plantLoc,
1640 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).BBLoadReSimIndex,
1641 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).plantLoc,
1642 : DataPlant::CriteriaType::Temperature,
1643 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletTemp);
1644 : }
1645 :
1646 : } // namespace SteamBaseboardRadiator
1647 :
1648 : } // namespace EnergyPlus
|
