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 0 : 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 0 : if (state.dataSteamBaseboardRadiator->GetInputFlag) {
137 0 : GetSteamBaseboardInput(state);
138 0 : state.dataSteamBaseboardRadiator->GetInputFlag = false;
139 : }
140 :
141 : // Find the correct Baseboard Equipment
142 0 : if (CompIndex == 0) {
143 0 : BaseboardNum = Util::FindItemInList(EquipName, state.dataSteamBaseboardRadiator->SteamBaseboard, &SteamBaseboardParams::Name);
144 0 : if (BaseboardNum == 0) {
145 0 : ShowFatalError(state, format("SimSteamBaseboard: Unit not found={}", EquipName));
146 : }
147 0 : CompIndex = BaseboardNum;
148 : } else {
149 0 : BaseboardNum = CompIndex;
150 0 : 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 0 : if (state.dataSteamBaseboardRadiator->CheckEquipName(BaseboardNum)) {
158 0 : 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 0 : state.dataSteamBaseboardRadiator->CheckEquipName(BaseboardNum) = false;
166 : }
167 : }
168 :
169 0 : if (CompIndex > 0) {
170 :
171 0 : InitSteamBaseboard(state, BaseboardNum, ControlledZoneNum, FirstHVACIteration);
172 :
173 0 : QZnReq = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(ControlledZoneNum).RemainingOutputReqToHeatSP;
174 :
175 0 : SteamBaseboardDesignData SteamBaseboardDesignDataObject{state.dataSteamBaseboardRadiator->SteamBaseboardDesign(
176 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum)
177 0 : .DesignObjectPtr)}; // Array that contains the design data for steam baseboard objects
178 :
179 0 : if (QZnReq > SmallLoad && !state.dataZoneEnergyDemand->CurDeadBandOrSetback(ControlledZoneNum) &&
180 0 : (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 0 : if (FirstHVACIteration) {
185 0 : MaxSteamFlow = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamMassFlowRateMax;
186 0 : MinSteamFlow = 0.0;
187 : } else {
188 0 : MaxSteamFlow =
189 0 : state.dataLoopNodes->Node(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletNode).MassFlowRateMaxAvail;
190 0 : MinSteamFlow =
191 0 : state.dataLoopNodes->Node(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletNode).MassFlowRateMinAvail;
192 : }
193 :
194 0 : switch (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipType) {
195 0 : case DataPlant::PlantEquipmentType::Baseboard_Rad_Conv_Steam: { // 'ZoneHVAC:Baseboard:RadiantConvective:Steam'
196 0 : ControlCompOutput(state,
197 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name,
198 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
199 : BaseboardNum,
200 : FirstHVACIteration,
201 : QZnReq,
202 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletNode,
203 : MaxSteamFlow,
204 : MinSteamFlow,
205 : SteamBaseboardDesignDataObject.Offset,
206 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ControlCompTypeNum,
207 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).CompErrIndex,
208 : _,
209 : _,
210 : _,
211 : _,
212 : _,
213 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).plantLoc);
214 0 : } 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 0 : PowerMet = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotPower;
227 : } else {
228 : // baseboard is off, don't bother going into ControlCompOutput
229 0 : Real64 mdot = 0.0;
230 0 : SetComponentFlowRate(state,
231 : mdot,
232 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletNode,
233 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletNode,
234 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).plantLoc);
235 0 : CalcSteamBaseboard(state, BaseboardNum, PowerMet);
236 : }
237 :
238 0 : UpdateSteamBaseboard(state, BaseboardNum);
239 :
240 0 : ReportSteamBaseboard(state, BaseboardNum);
241 :
242 0 : } else {
243 0 : ShowFatalError(state, format("SimSteamBaseboard: Unit not found={}", EquipName));
244 : }
245 0 : }
246 :
247 0 : 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 0 : Real64 constexpr MaxFraction(1.0); // Maximum limit of fractional values
277 0 : Real64 constexpr MinFraction(0.0); // Minimum limit of fractional values
278 0 : Real64 constexpr MaxSteamFlowRate(10.0); // Maximum limit of steam volume flow rate in m3/s
279 0 : 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 0 : int constexpr MinDistribSurfaces(1); // Minimum number of surfaces that a baseboard heater can radiate to
282 0 : int constexpr iHeatCAPMAlphaNum(2); // get input index to steam baseboard Radiator system heating capacity sizing method
283 0 : int constexpr iHeatDesignCapacityNumericNum(1); // get input index to steam baseboard Radiator system electric heating capacity
284 0 : int constexpr iHeatCapacityPerFloorAreaNumericNum(
285 : 1); // get input index to steam baseboard Radiator system electric heating capacity per floor area sizing
286 0 : 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 0 : 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 0 : bool ErrorsFound(false); // If errors detected in input
297 : bool SteamMessageNeeded;
298 :
299 0 : SteamMessageNeeded = true;
300 0 : state.dataSteamBaseboardRadiator->NumSteamBaseboards =
301 0 : state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam);
302 0 : state.dataSteamBaseboardRadiator->NumSteamBaseboardsDesign =
303 0 : state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam_Design);
304 :
305 : // Count total number of baseboard units
306 :
307 0 : state.dataSteamBaseboardRadiator->SteamBaseboard.allocate(state.dataSteamBaseboardRadiator->NumSteamBaseboards);
308 0 : state.dataSteamBaseboardRadiator->CheckEquipName.dimension(state.dataSteamBaseboardRadiator->NumSteamBaseboards, true);
309 0 : state.dataSteamBaseboardRadiator->SteamBaseboardNumericFields.allocate(state.dataSteamBaseboardRadiator->NumSteamBaseboards);
310 :
311 : // Count total number of baseboard design objects
312 :
313 0 : state.dataSteamBaseboardRadiator->SteamBaseboardDesign.allocate(state.dataSteamBaseboardRadiator->NumSteamBaseboardsDesign);
314 0 : state.dataSteamBaseboardRadiator->CheckDesignObjectName.dimension(state.dataSteamBaseboardRadiator->NumSteamBaseboardsDesign, true);
315 0 : state.dataSteamBaseboardRadiator->SteamBaseboardDesignNumericFields.allocate(state.dataSteamBaseboardRadiator->NumSteamBaseboardsDesign);
316 0 : state.dataSteamBaseboardRadiator->SteamBaseboardDesignNames.allocate(state.dataSteamBaseboardRadiator->NumSteamBaseboardsDesign);
317 :
318 : // Get the data from the user input related to baseboard heater design objects
319 0 : for (BaseboardDesignNum = 1; BaseboardDesignNum <= state.dataSteamBaseboardRadiator->NumSteamBaseboardsDesign; ++BaseboardDesignNum) {
320 :
321 0 : state.dataInputProcessing->inputProcessor->getObjectItem(state,
322 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam_Design,
323 : BaseboardDesignNum,
324 0 : state.dataIPShortCut->cAlphaArgs,
325 : NumAlphas,
326 0 : state.dataIPShortCut->rNumericArgs,
327 : NumNumbers,
328 : IOStat,
329 0 : state.dataIPShortCut->lNumericFieldBlanks,
330 0 : state.dataIPShortCut->lAlphaFieldBlanks,
331 0 : state.dataIPShortCut->cAlphaFieldNames,
332 0 : state.dataIPShortCut->cNumericFieldNames);
333 :
334 0 : Util::IsNameEmpty(
335 0 : state, state.dataIPShortCut->cAlphaArgs(1), state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam_Design, ErrorsFound);
336 0 : state.dataSteamBaseboardRadiator->SteamBaseboardDesignNumericFields(BaseboardDesignNum).FieldNames.allocate(NumNumbers);
337 0 : state.dataSteamBaseboardRadiator->SteamBaseboardDesignNumericFields(BaseboardDesignNum).FieldNames = "";
338 0 : state.dataSteamBaseboardRadiator->SteamBaseboardDesignNumericFields(BaseboardDesignNum).FieldNames =
339 0 : state.dataIPShortCut->cNumericFieldNames;
340 :
341 : // ErrorsFound will be set to True if problem was found, left untouched otherwise
342 0 : VerifyUniqueBaseboardName(state,
343 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam_Design,
344 0 : state.dataIPShortCut->cAlphaArgs(1),
345 : ErrorsFound,
346 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam_Design + " Name");
347 :
348 0 : state.dataSteamBaseboardRadiator->SteamBaseboardDesign(BaseboardDesignNum).designName =
349 0 : state.dataIPShortCut->cAlphaArgs(1); // Name of the design object of baseboard
350 0 : state.dataSteamBaseboardRadiator->SteamBaseboardDesignNames(BaseboardDesignNum) =
351 0 : state.dataIPShortCut->cAlphaArgs(1); // Add to array of design object names
352 :
353 : // Determine steam baseboard radiator system heating design capacity sizing method
354 0 : if (Util::SameString(state.dataIPShortCut->cAlphaArgs(iHeatCAPMAlphaNum), "HeatingDesignCapacity")) {
355 0 : 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 0 : state.dataSteamBaseboardRadiator->SteamBaseboardDesign(BaseboardDesignNum).Offset = state.dataIPShortCut->rNumericArgs(3);
445 : // Set default convergence tolerance
446 0 : 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 0 : state.dataSteamBaseboardRadiator->SteamBaseboardDesign(BaseboardDesignNum).FracRadiant = state.dataIPShortCut->rNumericArgs(4);
459 0 : 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 0 : } 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 0 : state.dataSteamBaseboardRadiator->SteamBaseboardDesign(BaseboardDesignNum).FracDistribPerson = state.dataIPShortCut->rNumericArgs(5);
481 0 : 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 0 : 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 0 : for (BaseboardNum = 1; BaseboardNum <= state.dataSteamBaseboardRadiator->NumSteamBaseboards; ++BaseboardNum) {
505 :
506 0 : state.dataInputProcessing->inputProcessor->getObjectItem(state,
507 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
508 : BaseboardNum,
509 0 : state.dataIPShortCut->cAlphaArgs,
510 : NumAlphas,
511 0 : state.dataIPShortCut->rNumericArgs,
512 : NumNumbers,
513 : IOStat,
514 0 : state.dataIPShortCut->lNumericFieldBlanks,
515 0 : state.dataIPShortCut->lAlphaFieldBlanks,
516 0 : state.dataIPShortCut->cAlphaFieldNames,
517 0 : state.dataIPShortCut->cNumericFieldNames);
518 :
519 0 : ErrorObjectHeader eoh{routineName, state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam, state.dataIPShortCut->cAlphaArgs(1)};
520 :
521 0 : Util::IsNameEmpty(state, state.dataIPShortCut->cAlphaArgs(1), state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam, ErrorsFound);
522 0 : state.dataSteamBaseboardRadiator->SteamBaseboardNumericFields(BaseboardNum).FieldNames.allocate(NumNumbers);
523 0 : state.dataSteamBaseboardRadiator->SteamBaseboardNumericFields(BaseboardNum).FieldNames = "";
524 0 : state.dataSteamBaseboardRadiator->SteamBaseboardNumericFields(BaseboardNum).FieldNames = state.dataIPShortCut->cNumericFieldNames;
525 :
526 : // ErrorsFound will be set to True if problem was found, left untouched otherwise
527 0 : VerifyUniqueBaseboardName(state,
528 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
529 0 : state.dataIPShortCut->cAlphaArgs(1),
530 : ErrorsFound,
531 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam + " Name");
532 :
533 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name = state.dataIPShortCut->cAlphaArgs(1); // Name of the baseboard
534 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipType =
535 : DataPlant::PlantEquipmentType::Baseboard_Rad_Conv_Steam; //'ZoneHVAC:Baseboard:RadiantConvective:Steam'
536 :
537 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).designObjectName =
538 0 : state.dataIPShortCut->cAlphaArgs(2); // Name of the design object for this baseboard
539 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).DesignObjectPtr =
540 0 : Util::FindItemInList(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).designObjectName,
541 0 : state.dataSteamBaseboardRadiator->SteamBaseboardDesignNames);
542 : SteamBaseboardDesignData SteamBaseboardDesignDataObject{
543 0 : state.dataSteamBaseboardRadiator->SteamBaseboardDesign(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum)
544 0 : .DesignObjectPtr)}; // Contains the design data for steam baseboard object
545 :
546 : // Get schedule
547 0 : if (state.dataIPShortCut->lAlphaFieldBlanks(3)) {
548 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).availSched = Sched::GetScheduleAlwaysOn(state);
549 0 : } else if ((state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).availSched =
550 0 : 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 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletNode =
557 0 : GetOnlySingleNode(state,
558 0 : state.dataIPShortCut->cAlphaArgs(4),
559 : ErrorsFound,
560 : DataLoopNode::ConnectionObjectType::ZoneHVACBaseboardRadiantConvectiveSteam,
561 0 : 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 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletNode =
569 0 : GetOnlySingleNode(state,
570 0 : state.dataIPShortCut->cAlphaArgs(5),
571 : ErrorsFound,
572 : DataLoopNode::ConnectionObjectType::ZoneHVACBaseboardRadiantConvectiveSteam,
573 0 : state.dataIPShortCut->cAlphaArgs(1),
574 : DataLoopNode::NodeFluidType::Steam,
575 : DataLoopNode::ConnectionType::Outlet,
576 : NodeInputManager::CompFluidStream::Primary,
577 : ObjectIsNotParent);
578 0 : TestCompSet(state,
579 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
580 0 : state.dataIPShortCut->cAlphaArgs(1),
581 0 : state.dataIPShortCut->cAlphaArgs(4),
582 0 : state.dataIPShortCut->cAlphaArgs(5),
583 : "Hot Steam Nodes");
584 :
585 : // Determine steam baseboard radiator system heating design capacity sizing method
586 0 : if (SteamBaseboardDesignDataObject.HeatingCapMethod == HeatingDesignCapacity) {
587 0 : if (!state.dataIPShortCut->lNumericFieldBlanks(iHeatDesignCapacityNumericNum)) {
588 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ScaledHeatingCapacity =
589 0 : state.dataIPShortCut->rNumericArgs(iHeatDesignCapacityNumericNum);
590 0 : if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ScaledHeatingCapacity < 0.0 &&
591 0 : 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 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).DegOfSubcooling = state.dataIPShortCut->rNumericArgs(2);
625 : // Maximum steam flow rate
626 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax = state.dataIPShortCut->rNumericArgs(3);
627 0 : 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 0 : } else if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax <= MinSteamFlowRate &&
637 0 : 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 0 : 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 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).FracConvect = 1.0 - SteamBaseboardDesignDataObject.FracRadiant;
658 : }
659 :
660 0 : 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 0 : 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 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum)
681 0 : .SurfaceName.allocate(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotSurfToDistrib);
682 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SurfaceName = "";
683 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum)
684 0 : .SurfacePtr.allocate(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotSurfToDistrib);
685 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SurfacePtr = 0;
686 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum)
687 0 : .FracDistribToSurf.allocate(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotSurfToDistrib);
688 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).FracDistribToSurf = 0.0;
689 :
690 : // search zone equipment list structure for zone index
691 0 : for (int ctrlZone = 1; ctrlZone <= state.dataGlobal->NumOfZones; ++ctrlZone) {
692 0 : for (int zoneEquipTypeNum = 1; zoneEquipTypeNum <= state.dataZoneEquip->ZoneEquipList(ctrlZone).NumOfEquipTypes; ++zoneEquipTypeNum) {
693 0 : if (state.dataZoneEquip->ZoneEquipList(ctrlZone).EquipType(zoneEquipTypeNum) ==
694 0 : DataZoneEquipment::ZoneEquipType::BaseboardSteam &&
695 0 : state.dataZoneEquip->ZoneEquipList(ctrlZone).EquipName(zoneEquipTypeNum) ==
696 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name) {
697 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ZonePtr = ctrlZone;
698 : }
699 : }
700 : }
701 0 : 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 0 : Real64 AllFracsSummed = SteamBaseboardDesignDataObject.FracDistribPerson;
712 0 : for (SurfNum = 1; SurfNum <= state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotSurfToDistrib; ++SurfNum) {
713 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SurfaceName(SurfNum) = state.dataIPShortCut->cAlphaArgs(SurfNum + 5);
714 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SurfacePtr(SurfNum) =
715 0 : HeatBalanceIntRadExchange::GetRadiantSystemSurface(
716 : state,
717 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
718 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name,
719 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ZonePtr,
720 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SurfaceName(SurfNum),
721 : ErrorsFound);
722 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).FracDistribToSurf(SurfNum) =
723 0 : state.dataIPShortCut->rNumericArgs(SurfNum + 3);
724 0 : 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 0 : 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 0 : if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SurfacePtr(SurfNum) != 0) {
745 0 : state.dataSurface->surfIntConv(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SurfacePtr(SurfNum))
746 0 : .getsRadiantHeat = true;
747 0 : state.dataSurface->allGetsRadiantHeatSurfaceList.emplace_back(
748 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SurfacePtr(SurfNum));
749 : }
750 :
751 0 : AllFracsSummed += state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).FracDistribToSurf(SurfNum);
752 : } // surfaces
753 :
754 0 : 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 0 : 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 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).steam = Fluid::GetSteam(state);
773 0 : 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 0 : }
782 :
783 0 : 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 0 : for (BaseboardNum = 1; BaseboardNum <= state.dataSteamBaseboardRadiator->NumSteamBaseboards; ++BaseboardNum) {
791 : // CurrentModuleObject='ZoneHVAC:Baseboard:RadiantConvective:Steam'
792 0 : SetupOutputVariable(state,
793 : "Baseboard Total Heating Rate",
794 : Constant::Units::W,
795 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotPower,
796 : OutputProcessor::TimeStepType::System,
797 : OutputProcessor::StoreType::Average,
798 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name);
799 :
800 0 : SetupOutputVariable(state,
801 : "Baseboard Convective Heating Rate",
802 : Constant::Units::W,
803 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ConvPower,
804 : OutputProcessor::TimeStepType::System,
805 : OutputProcessor::StoreType::Average,
806 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name);
807 0 : SetupOutputVariable(state,
808 : "Baseboard Radiant Heating Rate",
809 : Constant::Units::W,
810 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).RadPower,
811 : OutputProcessor::TimeStepType::System,
812 : OutputProcessor::StoreType::Average,
813 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name);
814 0 : SetupOutputVariable(state,
815 : "Baseboard Total Heating Energy",
816 : Constant::Units::J,
817 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotEnergy,
818 : OutputProcessor::TimeStepType::System,
819 : OutputProcessor::StoreType::Sum,
820 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name,
821 : Constant::eResource::EnergyTransfer,
822 : OutputProcessor::Group::HVAC,
823 : OutputProcessor::EndUseCat::Baseboard);
824 0 : SetupOutputVariable(state,
825 : "Baseboard Convective Heating Energy",
826 : Constant::Units::J,
827 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ConvEnergy,
828 : OutputProcessor::TimeStepType::System,
829 : OutputProcessor::StoreType::Sum,
830 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name);
831 0 : SetupOutputVariable(state,
832 : "Baseboard Radiant Heating Energy",
833 : Constant::Units::J,
834 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).RadEnergy,
835 : OutputProcessor::TimeStepType::System,
836 : OutputProcessor::StoreType::Sum,
837 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name);
838 0 : SetupOutputVariable(state,
839 : "Baseboard Steam Energy",
840 : Constant::Units::J,
841 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Energy,
842 : OutputProcessor::TimeStepType::System,
843 : OutputProcessor::StoreType::Sum,
844 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name,
845 : Constant::eResource::PlantLoopHeatingDemand,
846 : OutputProcessor::Group::HVAC,
847 : OutputProcessor::EndUseCat::Baseboard);
848 0 : SetupOutputVariable(state,
849 : "Baseboard Steam Rate",
850 : Constant::Units::W,
851 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Power,
852 : OutputProcessor::TimeStepType::System,
853 : OutputProcessor::StoreType::Average,
854 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name);
855 0 : SetupOutputVariable(state,
856 : "Baseboard Steam Mass Flow Rate",
857 : Constant::Units::kg_s,
858 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamMassFlowRate,
859 : OutputProcessor::TimeStepType::System,
860 : OutputProcessor::StoreType::Average,
861 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name);
862 0 : SetupOutputVariable(state,
863 : "Baseboard Steam Inlet Temperature",
864 : Constant::Units::C,
865 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletTemp,
866 : OutputProcessor::TimeStepType::System,
867 : OutputProcessor::StoreType::Average,
868 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name);
869 0 : SetupOutputVariable(state,
870 : "Baseboard Steam Outlet Temperature",
871 : Constant::Units::C,
872 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletTemp,
873 : OutputProcessor::TimeStepType::System,
874 : OutputProcessor::StoreType::Average,
875 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name);
876 : }
877 0 : }
878 :
879 0 : 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 0 : if (state.dataSteamBaseboardRadiator->MyOneTimeFlag) {
914 :
915 : // initialize the environment and sizing flags
916 0 : state.dataSteamBaseboardRadiator->MyEnvrnFlag.dimension(state.dataSteamBaseboardRadiator->NumSteamBaseboards, true);
917 0 : state.dataSteamBaseboardRadiator->MySizeFlag.dimension(state.dataSteamBaseboardRadiator->NumSteamBaseboards, true);
918 0 : state.dataSteamBaseboardRadiator->SetLoopIndexFlag.dimension(state.dataSteamBaseboardRadiator->NumSteamBaseboards, true);
919 0 : state.dataSteamBaseboardRadiator->MyOneTimeFlag = false;
920 : }
921 :
922 0 : 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 0 : if (!state.dataSteamBaseboardRadiator->ZoneEquipmentListChecked && state.dataZoneEquip->ZoneEquipInputsFilled) {
926 0 : state.dataSteamBaseboardRadiator->ZoneEquipmentListChecked = true;
927 0 : for (Loop = 1; Loop <= state.dataSteamBaseboardRadiator->NumSteamBaseboards; ++Loop) {
928 0 : if (CheckZoneEquipmentList(state,
929 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
930 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(Loop).Name)) {
931 0 : 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 0 : if (state.dataSteamBaseboardRadiator->SetLoopIndexFlag(BaseboardNum)) {
941 0 : if (allocated(state.dataPlnt->PlantLoop)) {
942 0 : errFlag = false;
943 0 : ScanPlantLoopsForObject(state,
944 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name,
945 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).EquipType,
946 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).plantLoc,
947 : errFlag,
948 : _,
949 : _,
950 : _,
951 : _,
952 : _);
953 0 : state.dataSteamBaseboardRadiator->SetLoopIndexFlag(BaseboardNum) = false;
954 0 : if (errFlag) {
955 0 : ShowFatalError(state, "InitSteamBaseboard: Program terminated for previous conditions.");
956 : }
957 : }
958 : }
959 :
960 0 : if (!state.dataGlobal->SysSizingCalc && state.dataSteamBaseboardRadiator->MySizeFlag(BaseboardNum) &&
961 0 : (!state.dataSteamBaseboardRadiator->SetLoopIndexFlag(BaseboardNum))) {
962 : // For each coil, do the sizing once
963 0 : SizeSteamBaseboard(state, BaseboardNum);
964 0 : state.dataSteamBaseboardRadiator->MySizeFlag(BaseboardNum) = false;
965 : }
966 :
967 : // Do the Begin Environment initializations
968 0 : if (state.dataGlobal->BeginEnvrnFlag && state.dataSteamBaseboardRadiator->MyEnvrnFlag(BaseboardNum)) {
969 : // Initialize
970 0 : SteamInletNode = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletNode;
971 0 : state.dataLoopNodes->Node(SteamInletNode).Temp = 100.0;
972 0 : state.dataLoopNodes->Node(SteamInletNode).Press = 101325.0;
973 0 : auto *steam = Fluid::GetSteam(state);
974 0 : SteamDensity = steam->getSatDensity(state, state.dataLoopNodes->Node(SteamInletNode).Temp, 1.0, RoutineName);
975 0 : StartEnthSteam = steam->getSatEnthalpy(state, state.dataLoopNodes->Node(SteamInletNode).Temp, 1.0, RoutineName);
976 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamMassFlowRateMax =
977 0 : SteamDensity * state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax;
978 0 : InitComponentNodes(state,
979 : 0.0,
980 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamMassFlowRateMax,
981 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletNode,
982 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletNode);
983 0 : state.dataLoopNodes->Node(SteamInletNode).Enthalpy = StartEnthSteam;
984 0 : state.dataLoopNodes->Node(SteamInletNode).Quality = 1.0;
985 0 : state.dataLoopNodes->Node(SteamInletNode).HumRat = 0.0;
986 :
987 : // Initializes radiant sources
988 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ZeroBBSteamSourceSumHATsurf = 0.0;
989 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSource = 0.0;
990 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSrcAvg = 0.0;
991 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastQBBSteamRadSrc = 0.0;
992 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastSysTimeElapsed = 0.0;
993 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastTimeStepSys = 0.0;
994 :
995 0 : state.dataSteamBaseboardRadiator->MyEnvrnFlag(BaseboardNum) = false;
996 : }
997 :
998 0 : if (!state.dataGlobal->BeginEnvrnFlag) {
999 0 : state.dataSteamBaseboardRadiator->MyEnvrnFlag(BaseboardNum) = true;
1000 : }
1001 :
1002 0 : if (state.dataGlobal->BeginTimeStepFlag && FirstHVACIteration) {
1003 0 : int ZoneNum = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ZonePtr;
1004 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ZeroBBSteamSourceSumHATsurf =
1005 0 : state.dataHeatBal->Zone(ZoneNum).sumHATsurf(state);
1006 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSrcAvg = 0.0;
1007 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastQBBSteamRadSrc = 0.0;
1008 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastSysTimeElapsed = 0.0;
1009 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastTimeStepSys = 0.0;
1010 : }
1011 :
1012 : // Do the every time step initializations
1013 0 : SteamInletNode = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletNode;
1014 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamMassFlowRate = state.dataLoopNodes->Node(SteamInletNode).MassFlowRate;
1015 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletTemp = state.dataLoopNodes->Node(SteamInletNode).Temp;
1016 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletEnthalpy = state.dataLoopNodes->Node(SteamInletNode).Enthalpy;
1017 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletPress = state.dataLoopNodes->Node(SteamInletNode).Press;
1018 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletQuality = state.dataLoopNodes->Node(SteamInletNode).Quality;
1019 :
1020 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotPower = 0.0;
1021 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Power = 0.0;
1022 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ConvPower = 0.0;
1023 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).RadPower = 0.0;
1024 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotEnergy = 0.0;
1025 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Energy = 0.0;
1026 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ConvEnergy = 0.0;
1027 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).RadEnergy = 0.0;
1028 0 : }
1029 :
1030 0 : 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 0 : int PltSizSteamNum(0); // Index of plant sizing object for 1st steam loop
1059 0 : 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 0 : bool ErrorsFound(false); // If errors detected in input
1067 0 : bool IsAutoSize(false); // Indicator to autosizing steam flow
1068 0 : Real64 SteamVolFlowRateMaxDes(0.0); // Design maximum steam volume flow for reporting
1069 0 : Real64 SteamVolFlowRateMaxUser(0.0); // User hard-sized maximum steam volume flow for reporting
1070 0 : std::string CompName; // component name
1071 0 : std::string CompType; // component type
1072 0 : std::string SizingString; // input field sizing description (e.g., Nominal Capacity)
1073 : Real64 TempSize; // autosized value of coil input field
1074 0 : 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 0 : int CapSizingMethod(0); // capacity sizing methods (HeatingDesignCapacity, CapacityPerFloorArea, and FractionOfAutosizedHeatingCapacity )
1078 :
1079 0 : int &CurZoneEqNum = state.dataSize->CurZoneEqNum;
1080 :
1081 0 : SteamBaseboardDesignData SteamBaseboardDesignDataObject{state.dataSteamBaseboardRadiator->SteamBaseboardDesign(
1082 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).DesignObjectPtr)}; // Contains the data for variable flow hydronic systems
1083 :
1084 : // Find the appropriate steam plant sizing object
1085 0 : 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 0 : if (PltSizSteamNum > 0) {
1091 :
1092 0 : state.dataSize->DataScalableCapSizingON = false;
1093 :
1094 0 : if (CurZoneEqNum > 0) {
1095 :
1096 0 : if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax == AutoSize) {
1097 0 : IsAutoSize = true;
1098 : }
1099 0 : 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 0 : CheckZoneSizing(state,
1109 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
1110 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name);
1111 :
1112 0 : auto &zoneEqSizing = state.dataSize->ZoneEqSizing(CurZoneEqNum);
1113 0 : CompType = state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam;
1114 0 : CompName = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Name;
1115 0 : state.dataSize->DataFracOfAutosizedHeatingCapacity = 1.0;
1116 0 : state.dataSize->DataZoneNumber = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ZonePtr;
1117 0 : SizingMethod = HeatingCapacitySizing;
1118 0 : FieldNum = 1;
1119 0 : PrintFlag = false;
1120 0 : SizingString = state.dataSteamBaseboardRadiator->SteamBaseboardNumericFields(BaseboardNum).FieldNames(FieldNum) + " [W]";
1121 0 : CapSizingMethod = SteamBaseboardDesignDataObject.HeatingCapMethod;
1122 0 : zoneEqSizing.SizingMethod(SizingMethod) = CapSizingMethod;
1123 0 : if (CapSizingMethod == HeatingDesignCapacity || CapSizingMethod == CapacityPerFloorArea ||
1124 : CapSizingMethod == FractionOfAutosizedHeatingCapacity) {
1125 :
1126 0 : if (CapSizingMethod == HeatingDesignCapacity) {
1127 0 : if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ScaledHeatingCapacity == AutoSize) {
1128 0 : CheckZoneSizing(state, CompType, CompName);
1129 0 : zoneEqSizing.HeatingCapacity = true;
1130 0 : zoneEqSizing.DesHeatingLoad = state.dataSize->FinalZoneSizing(CurZoneEqNum).NonAirSysDesHeatLoad;
1131 : }
1132 0 : 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 0 : bool errorsFound = false;
1151 0 : HeatingCapacitySizer sizerHeatingCapacity;
1152 0 : sizerHeatingCapacity.overrideSizingString(SizingString);
1153 0 : sizerHeatingCapacity.initializeWithinEP(state, CompType, CompName, PrintFlag, RoutineName);
1154 0 : DesCoilLoad = sizerHeatingCapacity.size(state, TempSize, errorsFound);
1155 0 : state.dataSize->DataScalableCapSizingON = false;
1156 0 : } else {
1157 0 : DesCoilLoad = 0.0; // FinalZoneSizing(CurZoneEqNum).NonAirSysDesHeatLoad;
1158 : }
1159 :
1160 0 : if (DesCoilLoad >= SmallLoad) {
1161 0 : SteamInletTemp = 100.0;
1162 0 : auto *steam = Fluid::GetSteam(state);
1163 0 : EnthSteamInDry = steam->getSatEnthalpy(state, SteamInletTemp, 1.0, RoutineName);
1164 0 : EnthSteamOutWet = steam->getSatEnthalpy(state, SteamInletTemp, 0.0, RoutineName);
1165 0 : LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet;
1166 0 : SteamDensity = steam->getSatDensity(state, SteamInletTemp, 1.0, RoutineName);
1167 0 : Cp = steam->getSatSpecificHeat(state, SteamInletTemp, 0.0, RoutineName);
1168 :
1169 0 : SteamVolFlowRateMaxDes =
1170 0 : DesCoilLoad /
1171 0 : (SteamDensity * (LatentHeatSteam + state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).DegOfSubcooling * Cp));
1172 : } else {
1173 0 : SteamVolFlowRateMaxDes = 0.0;
1174 : }
1175 :
1176 0 : if (IsAutoSize) {
1177 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax = SteamVolFlowRateMaxDes;
1178 0 : BaseSizer::reportSizerOutput(state,
1179 0 : state.dataSteamBaseboardRadiator->cCMO_BBRadiator_Steam,
1180 0 : 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 0 : RegisterPlantCompDesignFlow(state,
1226 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletNode,
1227 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamVolFlowRateMax);
1228 :
1229 0 : if (ErrorsFound) {
1230 0 : ShowFatalError(state, "Preceding sizing errors cause program termination");
1231 : }
1232 0 : }
1233 :
1234 0 : 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 0 : SteamBaseboardDesignData SteamBaseboardDesignDataObject{state.dataSteamBaseboardRadiator->SteamBaseboardDesign(
1283 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).DesignObjectPtr)}; // Contains the data for variable flow hydronic systems
1284 :
1285 0 : ZoneNum = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ZonePtr;
1286 0 : QZnReq = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(ZoneNum).RemainingOutputReqToHeatSP;
1287 0 : SteamInletTemp = state.dataLoopNodes->Node(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletNode).Temp;
1288 0 : SteamOutletTemp = SteamInletTemp;
1289 0 : SteamMassFlowRate = state.dataLoopNodes->Node(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletNode).MassFlowRate;
1290 0 : SubcoolDeltaT = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).DegOfSubcooling;
1291 :
1292 0 : if (QZnReq > SmallLoad && !state.dataZoneEnergyDemand->CurDeadBandOrSetback(ZoneNum) && SteamMassFlowRate > 0.0 &&
1293 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).availSched->getCurrentVal() > 0) {
1294 : // Unit is on
1295 0 : auto *steam = Fluid::GetSteam(state);
1296 0 : EnthSteamInDry = steam->getSatEnthalpy(state, SteamInletTemp, 1.0, RoutineName);
1297 0 : EnthSteamOutWet = steam->getSatEnthalpy(state, SteamInletTemp, 0.0, RoutineName);
1298 0 : LatentHeatSteam = EnthSteamInDry - EnthSteamOutWet;
1299 0 : Cp = steam->getSatSpecificHeat(state, SteamInletTemp, 0.0, RoutineName);
1300 0 : SteamBBHeat = SteamMassFlowRate * (LatentHeatSteam + SubcoolDeltaT * Cp); // Baseboard heating rate
1301 0 : SteamOutletTemp = SteamInletTemp - SubcoolDeltaT; // Outlet temperature of steam
1302 : // Estimate radiant heat addition
1303 0 : RadHeat = SteamBBHeat * SteamBaseboardDesignDataObject.FracRadiant; // Radiant heating rate
1304 0 : 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 0 : DistributeBBSteamRadGains(state);
1309 : // Now "simulate" the system by recalculating the heat balances
1310 0 : HeatBalanceSurfaceManager::CalcHeatBalanceOutsideSurf(state, ZoneNum);
1311 0 : 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 0 : LoadMet = (state.dataHeatBal->Zone(ZoneNum).sumHATsurf(state) -
1324 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ZeroBBSteamSourceSumHATsurf) +
1325 0 : (SteamBBHeat * state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).FracConvect) +
1326 0 : (RadHeat * SteamBaseboardDesignDataObject.FracDistribPerson);
1327 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletEnthalpy =
1328 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletEnthalpy - SteamBBHeat / SteamMassFlowRate;
1329 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletQuality = 0.0;
1330 : } else {
1331 0 : SteamOutletTemp = SteamInletTemp;
1332 0 : SteamBBHeat = 0.0;
1333 0 : LoadMet = 0.0;
1334 0 : RadHeat = 0.0;
1335 0 : SteamMassFlowRate = 0.0;
1336 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSource = 0.0;
1337 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletQuality = 0.0;
1338 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletEnthalpy =
1339 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletEnthalpy;
1340 : }
1341 :
1342 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletTemp = SteamOutletTemp;
1343 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamMassFlowRate = SteamMassFlowRate;
1344 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletEnthalpy =
1345 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletEnthalpy;
1346 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletQuality =
1347 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletQuality;
1348 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotPower = LoadMet;
1349 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Power = SteamBBHeat;
1350 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ConvPower = SteamBBHeat - RadHeat;
1351 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).RadPower = RadHeat;
1352 0 : }
1353 :
1354 0 : 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 0 : if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastSysTimeElapsed == state.dataHVACGlobal->SysTimeElapsed) {
1377 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSrcAvg -=
1378 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastQBBSteamRadSrc *
1379 0 : 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 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSrcAvg +=
1383 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSource * state.dataHVACGlobal->TimeStepSys /
1384 0 : state.dataGlobal->TimeStepZone;
1385 :
1386 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastQBBSteamRadSrc =
1387 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSource;
1388 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastSysTimeElapsed = state.dataHVACGlobal->SysTimeElapsed;
1389 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).LastTimeStepSys = state.dataHVACGlobal->TimeStepSys;
1390 :
1391 0 : SteamInletNode = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamInletNode;
1392 0 : 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 0 : SafeCopyPlantNode(state, SteamInletNode, SteamOutletNode);
1397 0 : state.dataLoopNodes->Node(SteamOutletNode).Temp = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletTemp;
1398 0 : state.dataLoopNodes->Node(SteamOutletNode).Enthalpy = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SteamOutletEnthalpy;
1399 0 : }
1400 :
1401 249945 : 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 249945 : SteamBaseboardSysOn = false;
1426 :
1427 : // If this was never allocated, then there are no radiant systems in this input file (just RETURN)
1428 249945 : if (state.dataSteamBaseboardRadiator->NumSteamBaseboards == 0) {
1429 249945 : return;
1430 : }
1431 :
1432 : // If it was allocated, then we have to check to see if this was running at all...
1433 0 : for (BaseboardNum = 1; BaseboardNum <= state.dataSteamBaseboardRadiator->NumSteamBaseboards; ++BaseboardNum) {
1434 0 : if (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSrcAvg != 0.0) {
1435 0 : SteamBaseboardSysOn = true;
1436 : }
1437 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSource =
1438 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSrcAvg;
1439 : }
1440 :
1441 0 : DistributeBBSteamRadGains(state); // QBBSteamRadSource has been modified so we need to redistribute gains
1442 : }
1443 :
1444 0 : 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 0 : 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 0 : for (auto &thisSteamBB : state.dataSteamBaseboardRadiator->SteamBaseboard) {
1472 0 : for (int radSurfNum = 1; radSurfNum <= thisSteamBB.TotSurfToDistrib; ++radSurfNum) {
1473 0 : int surfNum = thisSteamBB.SurfacePtr(radSurfNum);
1474 0 : state.dataHeatBalFanSys->surfQRadFromHVAC(surfNum).SteamBaseboard = 0.0;
1475 : }
1476 : }
1477 0 : state.dataHeatBalFanSys->ZoneQSteamBaseboardToPerson = 0.0;
1478 :
1479 0 : for (int BaseboardNum = 1; BaseboardNum <= state.dataSteamBaseboardRadiator->NumSteamBaseboards; ++BaseboardNum) {
1480 :
1481 0 : int ZoneNum = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ZonePtr;
1482 : SteamBaseboardDesignData SteamBaseboardDesignDataObject{
1483 0 : state.dataSteamBaseboardRadiator->SteamBaseboardDesign(state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum)
1484 0 : .DesignObjectPtr)}; // Contains the data for variable flow hydronic systems
1485 0 : state.dataHeatBalFanSys->ZoneQSteamBaseboardToPerson(ZoneNum) +=
1486 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSource * SteamBaseboardDesignDataObject.FracDistribPerson;
1487 :
1488 0 : for (int RadSurfNum = 1; RadSurfNum <= state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotSurfToDistrib; ++RadSurfNum) {
1489 0 : int SurfNum = state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).SurfacePtr(RadSurfNum);
1490 0 : if (state.dataSurface->Surface(SurfNum).Area > SmallestArea) {
1491 0 : ThisSurfIntensity = (state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).QBBSteamRadSource *
1492 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).FracDistribToSurf(RadSurfNum) /
1493 0 : state.dataSurface->Surface(SurfNum).Area);
1494 0 : state.dataHeatBalFanSys->surfQRadFromHVAC(SurfNum).SteamBaseboard += ThisSurfIntensity;
1495 :
1496 0 : 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 0 : }
1525 0 : }
1526 :
1527 0 : 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 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotEnergy =
1537 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).TotPower * state.dataHVACGlobal->TimeStepSysSec;
1538 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Energy =
1539 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).Power * state.dataHVACGlobal->TimeStepSysSec;
1540 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ConvEnergy =
1541 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).ConvPower * state.dataHVACGlobal->TimeStepSysSec;
1542 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).RadEnergy =
1543 0 : state.dataSteamBaseboardRadiator->SteamBaseboard(BaseboardNum).RadPower * state.dataHVACGlobal->TimeStepSysSec;
1544 0 : }
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
|
