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