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