Line data Source code
1 : // EnergyPlus, Copyright (c) 1996-2025, The Board of Trustees of the University of Illinois,
2 : // The Regents of the University of California, through Lawrence Berkeley National Laboratory
3 : // (subject to receipt of any required approvals from the U.S. Dept. of Energy), Oak Ridge
4 : // National Laboratory, managed by UT-Battelle, Alliance for Sustainable Energy, LLC, and other
5 : // contributors. All rights reserved.
6 : //
7 : // NOTICE: This Software was developed under funding from the U.S. Department of Energy and the
8 : // U.S. Government consequently retains certain rights. As such, the U.S. Government has been
9 : // granted for itself and others acting on its behalf a paid-up, nonexclusive, irrevocable,
10 : // worldwide license in the Software to reproduce, distribute copies to the public, prepare
11 : // derivative works, and perform publicly and display publicly, and to permit others to do so.
12 : //
13 : // Redistribution and use in source and binary forms, with or without modification, are permitted
14 : // provided that the following conditions are met:
15 : //
16 : // (1) Redistributions of source code must retain the above copyright notice, this list of
17 : // conditions and the following disclaimer.
18 : //
19 : // (2) Redistributions in binary form must reproduce the above copyright notice, this list of
20 : // conditions and the following disclaimer in the documentation and/or other materials
21 : // provided with the distribution.
22 : //
23 : // (3) Neither the name of the University of California, Lawrence Berkeley National Laboratory,
24 : // the University of Illinois, U.S. Dept. of Energy nor the names of its contributors may be
25 : // used to endorse or promote products derived from this software without specific prior
26 : // written permission.
27 : //
28 : // (4) Use of EnergyPlus(TM) Name. If Licensee (i) distributes the software in stand-alone form
29 : // without changes from the version obtained under this License, or (ii) Licensee makes a
30 : // reference solely to the software portion of its product, Licensee must refer to the
31 : // software as "EnergyPlus version X" software, where "X" is the version number Licensee
32 : // obtained under this License and may not use a different name for the software. Except as
33 : // specifically required in this Section (4), Licensee shall not use in a company name, a
34 : // product name, in advertising, publicity, or other promotional activities any name, trade
35 : // name, trademark, logo, or other designation of "EnergyPlus", "E+", "e+" or confusingly
36 : // similar designation, without the U.S. Department of Energy's prior written consent.
37 : //
38 : // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
39 : // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
40 : // AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
41 : // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
42 : // CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
43 : // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
44 : // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
45 : // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
46 : // POSSIBILITY OF SUCH DAMAGE.
47 :
48 : #include <EnergyPlus/Autosizing/All_Simple_Sizing.hh>
49 : #include <EnergyPlus/Autosizing/Base.hh>
50 : #include <EnergyPlus/Data/EnergyPlusData.hh>
51 : #include <EnergyPlus/DataEnvironment.hh>
52 : #include <EnergyPlus/DataHVACGlobals.hh>
53 : #include <EnergyPlus/General.hh>
54 : #include <EnergyPlus/OutputReportPredefined.hh>
55 : #include <EnergyPlus/Psychrometrics.hh>
56 : #include <EnergyPlus/SQLiteProcedures.hh>
57 : #include <EnergyPlus/UtilityRoutines.hh>
58 :
59 : namespace EnergyPlus {
60 :
61 2935 : void BaseSizer::initializeWithinEP(EnergyPlusData &state,
62 : std::string_view const _compType,
63 : std::string_view const _compName,
64 : bool _printWarningFlag,
65 : std::string_view const _callingRoutine)
66 : {
67 2935 : this->initialized = true;
68 2935 : this->compType = _compType;
69 2935 : this->compName = _compName;
70 2935 : this->isEpJSON = state.dataGlobal->isEpJSON;
71 2935 : this->printWarningFlag = _printWarningFlag;
72 2935 : this->callingRoutine = _callingRoutine;
73 2935 : this->stdRhoAir = state.dataEnvrn->StdRhoAir;
74 2935 : this->sysSizingRunDone = state.dataSize->SysSizingRunDone;
75 2935 : this->zoneSizingRunDone = state.dataSize->ZoneSizingRunDone;
76 2935 : this->curSysNum = state.dataSize->CurSysNum;
77 2935 : this->curOASysNum = state.dataSize->CurOASysNum;
78 2935 : this->curZoneEqNum = state.dataSize->CurZoneEqNum;
79 2935 : this->curDuctType = state.dataSize->CurDuctType;
80 2935 : this->numPrimaryAirSys = state.dataHVACGlobal->NumPrimaryAirSys;
81 2935 : this->numSysSizInput = state.dataSize->NumSysSizInput;
82 2935 : this->doSystemSizing = state.dataGlobal->DoSystemSizing;
83 2935 : this->numZoneSizingInput = state.dataSize->NumZoneSizingInput;
84 2935 : this->doZoneSizing = state.dataGlobal->DoZoneSizing;
85 2935 : this->curTermUnitSizingNum = state.dataSize->CurTermUnitSizingNum;
86 2935 : this->termUnitSingDuct = state.dataSize->TermUnitSingDuct;
87 2935 : this->termUnitPIU = state.dataSize->TermUnitPIU;
88 2935 : this->termUnitIU = state.dataSize->TermUnitIU;
89 2935 : this->zoneEqFanCoil = state.dataSize->ZoneEqFanCoil;
90 2935 : this->otherEqType = !(this->termUnitSingDuct || this->termUnitPIU || this->termUnitIU || this->zoneEqFanCoil);
91 2935 : this->zoneEqUnitHeater = state.dataSize->ZoneEqUnitHeater;
92 2935 : this->zoneEqUnitVent = state.dataSize->ZoneEqUnitVent;
93 2935 : this->zoneEqVentedSlab = state.dataSize->ZoneEqVentedSlab;
94 2935 : this->zoneSizingInput = state.dataSize->ZoneSizingInput;
95 2935 : this->unitarySysEqSizing = state.dataSize->UnitarySysEqSizing;
96 2935 : this->oaSysEqSizing = state.dataSize->OASysEqSizing;
97 2935 : this->outsideAirSys = state.dataAirLoop->OutsideAirSys;
98 2935 : this->termUnitSizing = state.dataSize->TermUnitSizing;
99 2935 : this->finalZoneSizing = state.dataSize->FinalZoneSizing;
100 2935 : this->termUnitFinalZoneSizing = state.dataSize->TermUnitFinalZoneSizing;
101 2935 : this->zoneEqSizing = state.dataSize->ZoneEqSizing;
102 2935 : this->sysSizingInputData = state.dataSize->SysSizInput;
103 2935 : this->finalSysSizing = state.dataSize->FinalSysSizing;
104 2935 : this->plantSizData = state.dataSize->PlantSizData;
105 2935 : this->primaryAirSystem = state.dataAirSystemsData->PrimaryAirSystems;
106 2935 : this->airLoopControlInfo = state.dataAirLoop->AirLoopControlInfo;
107 2935 : this->airloopDOAS = state.dataAirLoopHVACDOAS->airloopDOAS;
108 2935 : if (EnergyPlus::BaseSizer::isValidCoilType(this->compType)) { // coil reports fail if compType is not one of HVAC::cAllCoilTypes
109 1788 : this->isCoilReportObject = true;
110 : }
111 2935 : if (EnergyPlus::BaseSizer::isValidFanType(this->compType)) { // fan reports fail if compType is not a valid fan type
112 158 : this->isFanReportObject = true;
113 : }
114 :
115 : // global sizing data
116 2935 : dataEMSOverrideON = state.dataSize->DataEMSOverrideON;
117 2935 : dataEMSOverride = state.dataSize->DataEMSOverride;
118 2935 : this->dataAutosizable = state.dataSize->DataAutosizable;
119 2935 : this->minOA = DataSizing::OAControl::MinOA;
120 2935 : this->dataConstantUsedForSizing = state.dataSize->DataConstantUsedForSizing;
121 2935 : this->dataFractionUsedForSizing = state.dataSize->DataFractionUsedForSizing;
122 2935 : state.dataSize->DataConstantUsedForSizing = 0.0; // reset here instead of in component model?
123 2935 : state.dataSize->DataFractionUsedForSizing = 0.0;
124 :
125 2935 : this->dataFanIndex = state.dataSize->DataFanIndex;
126 2935 : this->dataFanType = state.dataSize->DataFanType;
127 :
128 : // global Data* sizing constants
129 2935 : this->dataPltSizHeatNum = state.dataSize->DataPltSizHeatNum;
130 2935 : this->dataWaterLoopNum = state.dataSize->DataWaterLoopNum;
131 2935 : this->dataPltSizCoolNum = state.dataSize->DataPltSizCoolNum;
132 2935 : this->dataWaterCoilSizHeatDeltaT = state.dataSize->DataWaterCoilSizHeatDeltaT;
133 2935 : this->dataWaterCoilSizCoolDeltaT = state.dataSize->DataWaterCoilSizCoolDeltaT;
134 2935 : this->dataCapacityUsedForSizing = state.dataSize->DataCapacityUsedForSizing;
135 2935 : this->dataHeatSizeRatio = state.dataSize->DataHeatSizeRatio;
136 :
137 2935 : this->dataAirFlowUsedForSizing = state.dataSize->DataAirFlowUsedForSizing;
138 2935 : this->dataDesInletAirTemp = state.dataSize->DataDesInletAirTemp;
139 2935 : this->dataDesAccountForFanHeat = state.dataSize->DataDesAccountForFanHeat;
140 2935 : this->dataFanPlacement = state.dataSize->DataFanPlacement;
141 2935 : this->dataDesInletAirHumRat = state.dataSize->DataDesInletAirHumRat;
142 2935 : this->dataDesOutletAirHumRat = state.dataSize->DataDesOutletAirHumRat;
143 2935 : this->dataDesOutletAirTemp = state.dataSize->DataDesOutletAirTemp;
144 2935 : this->dataDesInletWaterTemp = state.dataSize->DataDesInletWaterTemp;
145 2935 : this->dataFlowUsedForSizing = state.dataSize->DataFlowUsedForSizing;
146 2935 : this->dataWaterFlowUsedForSizing = state.dataSize->DataWaterFlowUsedForSizing;
147 :
148 2935 : this->dataSizingFraction = state.dataSize->DataSizingFraction;
149 2935 : this->dataDXSpeedNum = state.dataSize->DataDXSpeedNum;
150 2935 : this->dataDesicRegCoil = state.dataSize->DataDesicRegCoil;
151 2935 : this->dataZoneUsedForSizing = state.dataSize->DataZoneUsedForSizing;
152 2935 : this->dataDesicDehumNum = state.dataSize->DataDesicDehumNum;
153 :
154 2935 : this->dataNomCapInpMeth = state.dataSize->DataNomCapInpMeth;
155 2935 : this->dataCoilNum = state.dataSize->DataCoilNum;
156 2935 : this->dataFanOp = state.dataSize->DataFanOp;
157 2935 : this->dataDesignCoilCapacity = state.dataSize->DataDesignCoilCapacity;
158 2935 : this->dataErrorsFound = state.dataSize->DataErrorsFound;
159 2935 : this->dataBypassFrac = state.dataSize->DataBypassFrac;
160 2935 : this->dataIsDXCoil = state.dataSize->DataIsDXCoil;
161 2935 : this->dataNonZoneNonAirloopValue = state.dataSize->DataNonZoneNonAirloopValue;
162 2935 : this->dataDXCoolsLowSpeedsAutozize = state.dataSize->DataDXCoolsLowSpeedsAutozize;
163 2935 : }
164 :
165 2 : void BaseSizer::initializeFromAPI(EnergyPlusData &state, Real64 const elevation)
166 : {
167 2 : this->clearState();
168 2 : this->initialized = true;
169 2 : this->compType = "API_component_type";
170 2 : this->compName = "API_component_name";
171 2 : this->printWarningFlag = false;
172 2 : this->callingRoutine = "called_from_API";
173 2 : Real64 barometricPressure = DataEnvironment::StdPressureSeaLevel * std::pow(1.0 - 2.25577e-05 * elevation, 5.2559);
174 2 : this->stdRhoAir = Psychrometrics::PsyRhoAirFnPbTdbW(state, barometricPressure, 20.0, 0.0);
175 2 : this->isCoilReportObject = false;
176 2 : }
177 :
178 172 : void BaseSizer::addErrorMessage(std::string const &s)
179 : {
180 172 : this->lastErrorMessages.append(s).append("\n");
181 172 : }
182 :
183 5 : std::string BaseSizer::getLastErrorMessages()
184 : {
185 5 : std::string s(this->lastErrorMessages);
186 5 : this->lastErrorMessages = "";
187 5 : return s;
188 0 : }
189 :
190 2933 : void BaseSizer::preSize(EnergyPlusData &state, Real64 const _originalValue)
191 : {
192 2933 : if (this->sizingType == AutoSizingType::Invalid) {
193 0 : std::string msg = "Sizing Library Base Class: preSize, SizingType not defined.";
194 0 : this->addErrorMessage(msg);
195 0 : ShowSevereError(state, msg);
196 0 : ShowFatalError(state, "Sizing type causes fatal error.");
197 0 : }
198 2933 : this->originalValue = _originalValue;
199 2933 : this->autoCalculate = false;
200 2933 : this->errorType = EnergyPlus::AutoSizingResultType::NoError;
201 2933 : this->initialized = false; // force use of Init then Size in subsequent calls
202 2933 : this->hardSizeNoDesignRun = !(this->sysSizingRunDone || this->zoneSizingRunDone);
203 2933 : this->sizingDesRunThisZone = false;
204 2933 : this->sizingDesRunThisAirSys = false;
205 :
206 2933 : if (this->dataFractionUsedForSizing == 0.0 && this->dataConstantUsedForSizing > 0.0) {
207 1 : this->errorType = AutoSizingResultType::ErrorType1;
208 1 : this->autoCalculate = true;
209 1 : this->hardSizeNoDesignRun = false;
210 1 : if (this->wasAutoSized) {
211 0 : this->autoSizedValue = 0.0;
212 0 : std::string msg = "Sizing Library: DataConstantUsedForSizing and DataFractionUsedForSizing used for autocalculating " +
213 0 : this->sizingString + " must both be greater than 0.";
214 0 : this->addErrorMessage(msg);
215 0 : ShowSevereError(state, msg);
216 0 : }
217 2933 : } else if (this->dataFractionUsedForSizing > 0.0) {
218 318 : this->autoCalculate = true;
219 318 : this->hardSizeNoDesignRun = false;
220 2614 : } else if (this->sizingType == AutoSizingType::AutoCalculateSizing) {
221 4 : this->autoCalculate = true;
222 4 : if (this->originalValue == DataSizing::AutoSize && !this->dataEMSOverrideON) {
223 1 : this->errorType = AutoSizingResultType::ErrorType1;
224 1 : std::string msg = "Sizing Library: DataConstantUsedForSizing and DataFractionUsedForSizing used for autocalculating " +
225 1 : this->sizingString + " must both be greater than 0.";
226 1 : this->addErrorMessage(msg);
227 1 : ShowSevereError(state, msg);
228 1 : }
229 : }
230 :
231 2933 : if (this->curSysNum > 0 && this->curSysNum <= this->numPrimaryAirSys) {
232 714 : if (this->sysSizingRunDone) {
233 614 : int sysNum = this->curSysNum;
234 614 : this->sizingDesRunThisAirSys = std::any_of(
235 610 : this->sysSizingInputData.begin(), this->sysSizingInputData.end(), [sysNum](auto const &ssid) { return ssid.AirLoopNum == sysNum; });
236 : }
237 714 : if (allocated(this->unitarySysEqSizing))
238 543 : this->airLoopSysFlag =
239 543 : this->unitarySysEqSizing(this->curSysNum).CoolingCapacity || this->unitarySysEqSizing(this->curSysNum).HeatingCapacity;
240 714 : if (this->curOASysNum > 0) {
241 106 : this->oaSysFlag = this->oaSysEqSizing(this->curOASysNum).CoolingCapacity || this->oaSysEqSizing(this->curOASysNum).HeatingCapacity;
242 : }
243 : }
244 :
245 2933 : if (this->curZoneEqNum > 0) {
246 1680 : if (allocated(this->zoneEqSizing)) {
247 1643 : this->sizingDesValueFromParent = this->zoneEqSizing(this->curZoneEqNum).DesignSizeFromParent;
248 : }
249 1680 : if (this->zoneSizingRunDone) {
250 1446 : int zoneNum = this->curZoneEqNum;
251 1446 : this->sizingDesRunThisZone = std::any_of(
252 940 : this->zoneSizingInput.begin(), this->zoneSizingInput.end(), [zoneNum](auto const &zsi) { return zsi.ZoneNum == zoneNum; });
253 : }
254 1680 : this->hardSizeNoDesignRun = false;
255 : }
256 :
257 2933 : if (this->originalValue == DataSizing::AutoSize) {
258 1973 : this->wasAutoSized = true;
259 1973 : this->hardSizeNoDesignRun = false;
260 1973 : if (!this->sizingDesRunThisAirSys && this->curSysNum > 0 && !this->autoCalculate) {
261 292 : if (!this->sysSizingRunDone) {
262 0 : std::string msg = "For autosizing of " + this->compType + ' ' + this->compName + ", a system sizing run must be done.";
263 0 : this->addErrorMessage(msg);
264 0 : ShowSevereError(state, msg);
265 0 : if (this->numSysSizInput == 0) {
266 0 : std::string msg2 = "No \"Sizing:System\" objects were entered.";
267 0 : this->addErrorMessage(msg2);
268 0 : ShowContinueError(state, msg2);
269 0 : }
270 0 : if (!this->doSystemSizing) {
271 0 : std::string msg2 = R"(The "SimulationControl" object did not have the field "Do System Sizing Calculation" set to Yes.)";
272 0 : this->addErrorMessage(msg2);
273 0 : ShowContinueError(state, msg2);
274 0 : }
275 0 : ShowFatalError(state, "Program terminates due to previously shown condition(s).");
276 0 : }
277 : }
278 1973 : if (!this->sizingDesRunThisZone && this->curZoneEqNum > 0 && !this->sizingDesValueFromParent && !this->autoCalculate) {
279 537 : if (!this->zoneSizingRunDone) {
280 0 : std::string msg = "For autosizing of " + this->compType + ' ' + this->compName + ", a zone sizing run must be done.";
281 0 : this->addErrorMessage(msg);
282 0 : ShowSevereError(state, msg);
283 0 : if (this->numZoneSizingInput == 0) {
284 0 : std::string msg2 = "No \"Sizing:Zone\" objects were entered.";
285 0 : this->addErrorMessage(msg2);
286 0 : ShowContinueError(state, msg2);
287 0 : }
288 0 : if (!this->doZoneSizing) {
289 0 : std::string msg2 = R"(The "SimulationControl" object did not have the field "Do Zone Sizing Calculation" set to Yes.)";
290 0 : this->addErrorMessage(msg2);
291 0 : ShowContinueError(state, msg2);
292 0 : }
293 0 : ShowFatalError(state, "Program terminates due to previously shown condition(s).");
294 0 : }
295 : }
296 : } else {
297 960 : this->wasAutoSized = false;
298 : }
299 2933 : }
300 :
301 3278 : void BaseSizer::reportSizerOutput(EnergyPlusData &state,
302 : std::string_view CompType,
303 : std::string_view CompName,
304 : std::string_view VarDesc,
305 : Real64 const VarValue,
306 : ObjexxFCL::Optional_string_const UsrDesc,
307 : ObjexxFCL::Optional<Real64 const> UsrValue)
308 : {
309 :
310 : static constexpr std::string_view Format_990(
311 : "! <Component Sizing Information>, Component Type, Component Name, Input Field Description, Value\n");
312 : static constexpr std::string_view Format_991(" Component Sizing Information, {}, {}, {}, {:.5R}\n");
313 :
314 : // to do, make this a parameter. Unfortunately this function is used in MANY
315 : // places so it involves touching most of E+
316 3278 : if (state.dataEnvrn->oneTimeCompRptHeaderFlag) {
317 344 : print(state.files.eio, Format_990);
318 344 : state.dataEnvrn->oneTimeCompRptHeaderFlag = false;
319 : }
320 :
321 3278 : print(state.files.eio, Format_991, CompType, CompName, VarDesc, VarValue);
322 : // add to tabular output reports
323 3278 : OutputReportPredefined::AddCompSizeTableEntry(state, CompType, CompName, VarDesc, VarValue);
324 :
325 3278 : if (present(UsrDesc) && present(UsrValue)) {
326 210 : print(state.files.eio, Format_991, CompType, CompName, UsrDesc(), UsrValue());
327 210 : OutputReportPredefined::AddCompSizeTableEntry(state, CompType, CompName, UsrDesc(), UsrValue);
328 3068 : } else if (present(UsrDesc) || present(UsrValue)) {
329 0 : ShowFatalError(state, "ReportSizingOutput: (Developer Error) - called with user-specified description or value but not both.");
330 : }
331 :
332 : // add to SQL output
333 3278 : if (state.dataSQLiteProcedures->sqlite) state.dataSQLiteProcedures->sqlite->addSQLiteComponentSizingRecord(CompType, CompName, VarDesc, VarValue);
334 3278 : if (present(UsrDesc) && present(UsrValue)) {
335 210 : if (state.dataSQLiteProcedures->sqlite)
336 30 : state.dataSQLiteProcedures->sqlite->addSQLiteComponentSizingRecord(CompType, CompName, UsrDesc(), UsrValue);
337 : }
338 3278 : }
339 :
340 2512 : void BaseSizer::selectSizerOutput(EnergyPlusData &state, bool &errorsFound)
341 : {
342 2512 : if (this->printWarningFlag) {
343 1590 : if (this->dataEMSOverrideON) { // EMS overrides value
344 8 : this->autoSizedValue = this->dataEMSOverride;
345 24 : this->reportSizerOutput(
346 16 : state, this->compType, this->compName, "User-Specified " + this->sizingStringScalable + this->sizingString, this->autoSizedValue);
347 1582 : } else if (this->hardSizeNoDesignRun && !this->wasAutoSized && Util::SameString(this->compType, "Fan:ZoneExhaust")) {
348 0 : this->autoSizedValue = this->originalValue;
349 1582 : } else if (this->wasAutoSized && this->dataFractionUsedForSizing > 0.0 && this->dataConstantUsedForSizing > 0.0) {
350 96 : this->autoSizedValue = this->dataFractionUsedForSizing * this->dataConstantUsedForSizing;
351 288 : this->reportSizerOutput(
352 192 : state, this->compType, this->compName, "Design Size " + this->sizingStringScalable + this->sizingString, this->autoSizedValue);
353 1486 : } else if (!this->wasAutoSized &&
354 608 : (this->autoSizedValue == this->originalValue || this->autoSizedValue == 0.0)) { // no sizing run done or autosizes to 0
355 444 : this->autoSizedValue = this->originalValue;
356 887 : if (this->dataAutosizable || (!this->sizingDesRunThisZone && Util::SameString(this->compType, "Fan:ZoneExhaust"))) {
357 1329 : this->reportSizerOutput(
358 886 : state, this->compType, this->compName, "User-Specified " + this->sizingStringScalable + this->sizingString, this->autoSizedValue);
359 : }
360 1042 : } else if (!this->wasAutoSized && this->autoSizedValue >= 0.0 && this->originalValue == 0.0) { // input was blank or zero
361 23 : this->autoSizedValue = this->originalValue;
362 69 : this->reportSizerOutput(
363 46 : state, this->compType, this->compName, "User-Specified " + this->sizingStringScalable + this->sizingString, this->autoSizedValue);
364 1019 : } else if (this->wasAutoSized && this->autoSizedValue >= 0.0 &&
365 877 : this->originalValue <= 0.0) { // autosized to 0 or greater and input is 0 or autosize
366 : // might need more logic here to catch everything correctly
367 877 : if (this->dataScalableSizingON && int(this->zoneAirFlowSizMethod) > 0) {
368 0 : this->reportSizerOutput(
369 0 : state, this->compType, this->compName, "User-Specified " + this->sizingStringScalable + this->sizingString, this->autoSizedValue);
370 : } else {
371 877 : this->reportSizerOutput(state, this->compType, this->compName, "Design Size " + this->sizingString, this->autoSizedValue);
372 : }
373 142 : } else if (this->autoSizedValue >= 0.0 && this->originalValue > 0.0) {
374 141 : if ((std::abs(this->autoSizedValue - this->originalValue) / this->originalValue) > state.dataSize->AutoVsHardSizingThreshold) {
375 95 : if (this->dataAutosizable)
376 282 : this->reportSizerOutput(state,
377 : this->compType,
378 : this->compName,
379 188 : "Design Size " + this->sizingString,
380 : this->autoSizedValue,
381 188 : "User-Specified " + this->sizingStringScalable + this->sizingString,
382 94 : this->originalValue);
383 : } else {
384 46 : if (this->dataAutosizable)
385 138 : this->reportSizerOutput(state,
386 : this->compType,
387 : this->compName,
388 92 : "User-Specified " + this->sizingStringScalable + this->sizingString,
389 : this->originalValue);
390 : }
391 141 : if (state.dataGlobal->DisplayExtraWarnings && this->dataAutosizable) {
392 0 : if ((std::abs(this->autoSizedValue - this->originalValue) / this->originalValue) > state.dataSize->AutoVsHardSizingThreshold) {
393 0 : std::string msg = this->callingRoutine + ": Potential issue with equipment sizing for " + this->compType + ' ' + this->compName;
394 0 : this->addErrorMessage(msg);
395 0 : ShowMessage(state, msg);
396 0 : msg = format("User-Specified {}{} = {:.5R}", this->sizingStringScalable, this->sizingString, this->originalValue);
397 0 : this->addErrorMessage(msg);
398 0 : ShowContinueError(state, msg);
399 0 : msg = format("differs from Design Size {} = {:.5R}", this->sizingString, this->autoSizedValue);
400 0 : this->addErrorMessage(msg);
401 0 : ShowContinueError(state, msg);
402 0 : msg = "This may, or may not, indicate mismatched component sizes.";
403 0 : this->addErrorMessage(msg);
404 0 : ShowContinueError(state, msg);
405 0 : msg = "Verify that the value entered is intended and is consistent with other components.";
406 0 : this->addErrorMessage(msg);
407 0 : ShowContinueError(state, msg);
408 0 : }
409 : }
410 141 : if (!this->wasAutoSized) this->autoSizedValue = this->originalValue;
411 142 : } else if (this->wasAutoSized && this->autoSizedValue != DataSizing::AutoSize) {
412 3 : this->reportSizerOutput(
413 2 : state, this->compType, this->compName, "Design Size " + this->sizingStringScalable + this->sizingString, this->autoSizedValue);
414 : } else {
415 0 : std::string msg = this->callingRoutine + ' ' + this->compType + ' ' + this->compName + ", Developer Error: Component sizing incomplete.";
416 0 : this->addErrorMessage(msg);
417 0 : ShowSevereError(state, msg);
418 0 : msg = format("SizingString = {}, SizingResult = {:.1T}", this->sizingString, this->originalValue);
419 0 : this->addErrorMessage(msg);
420 0 : ShowContinueError(state, msg);
421 0 : this->errorType = AutoSizingResultType::ErrorType1;
422 0 : }
423 922 : } else if (!this->wasAutoSized && !this->autoCalculate) {
424 179 : this->autoSizedValue = this->originalValue;
425 : }
426 2512 : this->overrideSizeString = true; // reset for next sizer
427 2512 : if (this->errorType != AutoSizingResultType::NoError) {
428 13 : std::string msg = "Developer Error: sizing of " + this->sizingString + " failed.";
429 13 : this->addErrorMessage(msg);
430 13 : ShowSevereError(state, msg);
431 13 : msg = "Occurs in " + this->compType + " " + this->compName;
432 13 : this->addErrorMessage(msg);
433 13 : ShowContinueError(state, msg);
434 13 : errorsFound = true;
435 13 : }
436 2512 : }
437 :
438 421 : void BaseSizer::select2StgDXHumCtrlSizerOutput(EnergyPlusData &state, bool &errorsFound)
439 : {
440 421 : if (this->printWarningFlag) {
441 263 : if (this->dataEMSOverrideON) { // EMS overrides value
442 6 : this->reportSizerOutput(
443 4 : state, this->compType, this->compName, "User-Specified " + this->sizingStringScalable + this->sizingString, this->autoSizedValue);
444 2 : if (Util::SameString(this->compType, "COIL:COOLING:DX:TWOSTAGEWITHHUMIDITYCONTROLMODE")) {
445 0 : this->autoSizedValue *= (1 - this->dataBypassFrac); // now reapply for second message and remianing simulation calcs
446 0 : this->reportSizerOutput(state,
447 : this->compType,
448 : this->compName,
449 0 : "User-Specified " + this->sizingStringScalable + this->sizingString + " ( non-bypassed )",
450 : this->autoSizedValue);
451 : }
452 261 : } else if (!this->wasAutoSized && (this->autoSizedValue == this->originalValue || this->autoSizedValue == 0.0)) { // no sizing run done
453 78 : this->autoSizedValue = this->originalValue;
454 234 : this->reportSizerOutput(
455 156 : state, this->compType, this->compName, "User-Specified " + this->sizingStringScalable + this->sizingString, this->autoSizedValue);
456 78 : if (Util::SameString(this->compType, "COIL:COOLING:DX:TWOSTAGEWITHHUMIDITYCONTROLMODE")) {
457 0 : this->autoSizedValue *= (1 - this->dataBypassFrac); // now reapply for second message and remianing simulation calcs
458 0 : this->reportSizerOutput(state,
459 : this->compType,
460 : this->compName,
461 0 : "User-Specified " + this->sizingStringScalable + this->sizingString + " ( non-bypassed )",
462 : this->autoSizedValue);
463 : }
464 183 : } else if (!this->wasAutoSized && this->autoSizedValue >= 0.0 && this->originalValue == 0.0) { // input was blank or zero
465 0 : this->autoSizedValue = this->originalValue;
466 0 : this->reportSizerOutput(
467 0 : state, this->compType, this->compName, "User-Specified " + this->sizingStringScalable + this->sizingString, this->autoSizedValue);
468 0 : if (Util::SameString(this->compType, "COIL:COOLING:DX:TWOSTAGEWITHHUMIDITYCONTROLMODE")) {
469 0 : this->autoSizedValue *= (1 - this->dataBypassFrac); // now reapply for second message and remianing simulation calcs
470 0 : this->reportSizerOutput(state,
471 : this->compType,
472 : this->compName,
473 0 : "User-Specified " + this->sizingStringScalable + this->sizingString + " ( non-bypassed )",
474 : this->autoSizedValue);
475 : }
476 183 : } else if (this->wasAutoSized && this->autoSizedValue >= 0.0 &&
477 153 : this->originalValue <= 0.0) { // autosized to 0 or greater and input is 0 or autosize
478 : // might need more logic here to catch everything correctly
479 153 : if (this->dataScalableSizingON && int(this->zoneAirFlowSizMethod) > 0) {
480 3 : this->reportSizerOutput(
481 2 : state, this->compType, this->compName, "User-Specified " + this->sizingStringScalable + this->sizingString, this->autoSizedValue);
482 : } else {
483 152 : this->reportSizerOutput(state, this->compType, this->compName, "Design Size " + this->sizingString, this->autoSizedValue);
484 : }
485 153 : if (Util::SameString(this->compType, "COIL:COOLING:DX:TWOSTAGEWITHHUMIDITYCONTROLMODE")) {
486 0 : this->autoSizedValue *= (1 - this->dataBypassFrac); // now reapply for second message and remianing simulation calcs
487 0 : this->reportSizerOutput(
488 0 : state, this->compType, this->compName, "Design Size " + this->sizingString + " ( non-bypassed )", this->autoSizedValue);
489 : }
490 30 : } else if (this->autoSizedValue >= 0.0 && this->originalValue > 0.0) {
491 30 : if ((std::abs(this->autoSizedValue - this->originalValue) / this->originalValue) > state.dataSize->AutoVsHardSizingThreshold) {
492 58 : this->reportSizerOutput(state,
493 : this->compType,
494 : this->compName,
495 58 : "Design Size " + this->sizingString,
496 : this->autoSizedValue,
497 58 : "User-Specified " + this->sizingStringScalable + this->sizingString,
498 29 : this->originalValue);
499 29 : if (Util::SameString(this->compType, "COIL:COOLING:DX:TWOSTAGEWITHHUMIDITYCONTROLMODE")) {
500 0 : this->autoSizedValue *= (1 - this->dataBypassFrac); // now reapply for second message and remianing simulation calcs
501 0 : this->originalValue *= (1 - this->dataBypassFrac); // now reapply for second message and remianing simulation calcs
502 0 : this->reportSizerOutput(state,
503 : this->compType,
504 : this->compName,
505 0 : "Design Size " + this->sizingString + " ( non-bypassed )",
506 : this->autoSizedValue,
507 0 : "User-Specified " + this->sizingStringScalable + this->sizingString + " ( non-bypassed )",
508 0 : this->originalValue);
509 : }
510 : } else {
511 1 : if (Util::SameString(this->compType, "COIL:COOLING:DX:TWOSTAGEWITHHUMIDITYCONTROLMODE")) {
512 0 : this->autoSizedValue /= (1 - this->dataBypassFrac); // back out bypass fraction applied in GetInput
513 : }
514 3 : this->reportSizerOutput(
515 2 : state, this->compType, this->compName, "User-Specified " + this->sizingStringScalable + this->sizingString, this->originalValue);
516 1 : if (Util::SameString(this->compType, "COIL:COOLING:DX:TWOSTAGEWITHHUMIDITYCONTROLMODE")) {
517 0 : this->autoSizedValue *= (1 - this->dataBypassFrac); // now reapply for second message and remianing simulation calcs
518 0 : this->reportSizerOutput(state,
519 : this->compType,
520 : this->compName,
521 0 : "User-Specified " + this->sizingStringScalable + this->sizingString + " ( non-bypassed )",
522 : this->autoSizedValue);
523 : }
524 : }
525 30 : if (state.dataGlobal->DisplayExtraWarnings) {
526 0 : if ((std::abs(this->autoSizedValue - this->originalValue) / this->originalValue) > state.dataSize->AutoVsHardSizingThreshold) {
527 0 : std::string msg = this->callingRoutine + ": Potential issue with equipment sizing for " + this->compType + ' ' + this->compName;
528 0 : this->addErrorMessage(msg);
529 0 : ShowMessage(state, msg);
530 0 : msg = format("User-Specified {}{} = {:.5R}", this->sizingStringScalable, this->sizingString, this->originalValue);
531 0 : this->addErrorMessage(msg);
532 0 : ShowContinueError(state, msg);
533 0 : msg = format("differs from Design Size {} = {:.5R}", this->sizingString, this->autoSizedValue);
534 0 : this->addErrorMessage(msg);
535 0 : ShowContinueError(state, msg);
536 0 : msg = "This may, or may not, indicate mismatched component sizes.";
537 0 : this->addErrorMessage(msg);
538 0 : ShowContinueError(state, msg);
539 0 : msg = "Verify that the value entered is intended and is consistent with other components.";
540 0 : this->addErrorMessage(msg);
541 0 : ShowContinueError(state, msg);
542 0 : }
543 : }
544 30 : if (!this->wasAutoSized) this->autoSizedValue = this->originalValue;
545 30 : } else if (this->wasAutoSized && this->autoSizedValue != DataSizing::AutoSize) {
546 0 : this->reportSizerOutput(
547 0 : state, this->compType, this->compName, "Design Size " + this->sizingStringScalable + this->sizingString, this->autoSizedValue);
548 : } else {
549 0 : std::string msg = this->callingRoutine + ' ' + this->compType + ' ' + this->compName + ", Developer Error: Component sizing incomplete.";
550 0 : this->addErrorMessage(msg);
551 0 : ShowSevereError(state, msg);
552 0 : msg = format("SizingString = {}, SizingResult = {:.1T}", this->sizingString, this->originalValue);
553 0 : this->addErrorMessage(msg);
554 0 : ShowContinueError(state, msg);
555 0 : this->errorType = AutoSizingResultType::ErrorType1;
556 0 : }
557 158 : } else if (!this->wasAutoSized && !this->autoCalculate) {
558 35 : this->autoSizedValue = this->originalValue;
559 : }
560 421 : this->overrideSizeString = true; // reset for next sizer
561 421 : if (this->errorType != AutoSizingResultType::NoError) {
562 0 : std::string msg = "Developer Error: sizing of " + this->sizingString + " failed.";
563 0 : this->addErrorMessage(msg);
564 0 : ShowSevereError(state, msg);
565 0 : msg = "Occurs in " + this->compType + " " + this->compName;
566 0 : this->addErrorMessage(msg);
567 0 : ShowContinueError(state, msg);
568 0 : errorsFound = true;
569 0 : }
570 421 : }
571 :
572 2935 : bool BaseSizer::isValidCoilType(std::string const &_compType)
573 : {
574 2935 : int coilNum = 0;
575 71522 : for (auto const &coilType : HVAC::cAllCoilTypes) {
576 70375 : coilNum += 1;
577 70375 : if (Util::SameString(_compType, coilType)) {
578 1788 : this->coilType_Num = coilNum;
579 1788 : return true;
580 : }
581 : }
582 1147 : this->coilType_Num = 0;
583 1147 : return false;
584 : }
585 :
586 2935 : bool BaseSizer::isValidFanType(std::string const &_compType)
587 : {
588 : // if compType name is one of the fan objects, then return true
589 2935 : if (Util::SameString(_compType, "Fan:SystemModel")) {
590 50 : return true;
591 2885 : } else if (Util::SameString(_compType, "Fan:ComponentModel")) {
592 0 : return true;
593 2885 : } else if (Util::SameString(_compType, "Fan:OnOff")) {
594 71 : return true;
595 2814 : } else if (Util::SameString(_compType, "Fan:ConstantVolume")) {
596 17 : return true;
597 2797 : } else if (Util::SameString(_compType, "Fan:VariableVolume")) {
598 20 : return true;
599 : } else {
600 2777 : return false;
601 : }
602 : }
603 :
604 2964 : bool BaseSizer::checkInitialized(EnergyPlusData &state, bool &errorsFound)
605 : {
606 2964 : if (!this->initialized) {
607 31 : errorsFound = true;
608 31 : this->errorType = AutoSizingResultType::ErrorType2;
609 31 : this->autoSizedValue = 0.0;
610 31 : std::string msg = "Developer Error: uninitialized sizing of " + this->sizingString + ".";
611 31 : this->addErrorMessage(msg);
612 31 : ShowSevereError(state, msg);
613 31 : msg = "Occurs in " + this->compType + " " + this->compName;
614 31 : this->addErrorMessage(msg);
615 31 : ShowContinueError(state, msg);
616 31 : return false;
617 31 : }
618 2933 : return true;
619 : }
620 :
621 1590 : void BaseSizer::overrideSizingString(std::string_view const string)
622 : {
623 1590 : this->sizingString = string;
624 1590 : this->overrideSizeString = false;
625 1590 : }
626 :
627 199 : Real64 BaseSizer::setOAFracForZoneEqSizing(const EnergyPlusData &state, Real64 const desMassFlow, DataSizing::ZoneEqSizingData const &zoneEqSizing)
628 : {
629 199 : Real64 outAirFrac = 0.0;
630 199 : if (desMassFlow <= 0.0) {
631 7 : return outAirFrac;
632 : }
633 :
634 192 : if (zoneEqSizing.ATMixerVolFlow > 0.0) {
635 : // set central DOAS AT mixer OA fraction
636 22 : outAirFrac = min(state.dataEnvrn->StdRhoAir * zoneEqSizing.ATMixerVolFlow / desMassFlow, 1.0);
637 170 : } else if (zoneEqSizing.OAVolFlow > 0.0) { // set zone equipment OA fraction
638 20 : outAirFrac = min(state.dataEnvrn->StdRhoAir * zoneEqSizing.OAVolFlow / desMassFlow, 1.0);
639 : }
640 192 : return outAirFrac;
641 : }
642 :
643 91 : Real64 BaseSizer::setHeatCoilInletTempForZoneEqSizing(Real64 const outAirFrac,
644 : DataSizing::ZoneEqSizingData const &zoneEqSizing,
645 : DataSizing::ZoneSizingData const &finalZoneSizing)
646 : {
647 91 : Real64 coilInTemp = 0.0;
648 91 : if (zoneEqSizing.ATMixerVolFlow > 0.0) {
649 : // adjust for central DOAS AT mixer mixed inlet temp
650 9 : coilInTemp = (1.0 - outAirFrac) * finalZoneSizing.ZoneRetTempAtHeatPeak + outAirFrac * zoneEqSizing.ATMixerHeatPriDryBulb;
651 82 : } else if (zoneEqSizing.OAVolFlow > 0.0) {
652 : // adjust for raw OA mixed inlet temp
653 11 : coilInTemp = (1.0 - outAirFrac) * finalZoneSizing.ZoneTempAtHeatPeak + outAirFrac * finalZoneSizing.OutTempAtHeatPeak;
654 : } else {
655 : // use zone condition for sizing zone equipment
656 71 : coilInTemp = finalZoneSizing.ZoneTempAtHeatPeak;
657 : }
658 91 : return coilInTemp;
659 : }
660 :
661 68 : Real64 BaseSizer::setHeatCoilInletHumRatForZoneEqSizing(Real64 const outAirFrac,
662 : DataSizing::ZoneEqSizingData const &zoneEqSizing,
663 : DataSizing::ZoneSizingData const &finalZoneSizing)
664 : {
665 68 : Real64 coilInHumRat = 0.0;
666 68 : if (zoneEqSizing.ATMixerVolFlow > 0.0) {
667 : // adjust for central DOAS AT mixer mixed inlet humrat
668 8 : coilInHumRat = (1.0 - outAirFrac) * finalZoneSizing.ZoneHumRatAtHeatPeak + outAirFrac * zoneEqSizing.ATMixerHeatPriHumRat;
669 60 : } else if (zoneEqSizing.OAVolFlow > 0.0) { // adjust for raw OA mixed inlet humrat
670 10 : coilInHumRat = (1.0 - outAirFrac) * finalZoneSizing.ZoneHumRatAtHeatPeak + outAirFrac * finalZoneSizing.OutHumRatAtHeatPeak;
671 : } else {
672 50 : coilInHumRat = finalZoneSizing.ZoneHumRatAtHeatPeak;
673 : }
674 68 : return coilInHumRat;
675 : }
676 :
677 27 : Real64 BaseSizer::setCoolCoilInletTempForZoneEqSizing(Real64 const outAirFrac,
678 : DataSizing::ZoneEqSizingData const &zoneEqSizing,
679 : DataSizing::ZoneSizingData const &finalZoneSizing)
680 : {
681 27 : Real64 coilInTemp = 0.0;
682 27 : if (zoneEqSizing.ATMixerVolFlow > 0.0) {
683 : // adjust for central DOAS AT mixer mixed inlet temp
684 6 : coilInTemp = (1.0 - outAirFrac) * finalZoneSizing.ZoneRetTempAtCoolPeak + outAirFrac * zoneEqSizing.ATMixerCoolPriDryBulb;
685 21 : } else if (zoneEqSizing.OAVolFlow > 0.0) {
686 : // adjust for raw OA mixed inlet temp
687 3 : coilInTemp = (1.0 - outAirFrac) * finalZoneSizing.ZoneTempAtCoolPeak + outAirFrac * finalZoneSizing.OutTempAtCoolPeak;
688 : } else {
689 : // use zone condition for sizing zone equipment
690 18 : coilInTemp = finalZoneSizing.ZoneTempAtCoolPeak;
691 : }
692 27 : return coilInTemp;
693 : }
694 :
695 34 : Real64 BaseSizer::setCoolCoilInletHumRatForZoneEqSizing(Real64 const outAirFrac,
696 : DataSizing::ZoneEqSizingData const &zoneEqSizing,
697 : DataSizing::ZoneSizingData const &finalZoneSizing)
698 : {
699 34 : Real64 coilInHumRat = 0.0;
700 34 : if (zoneEqSizing.ATMixerVolFlow > 0.0) {
701 : // adjust for central DOAS AT mixer mixed inlet humrat
702 6 : coilInHumRat = (1.0 - outAirFrac) * finalZoneSizing.ZoneHumRatAtCoolPeak + outAirFrac * zoneEqSizing.ATMixerCoolPriHumRat;
703 28 : } else if (zoneEqSizing.OAVolFlow > 0.0) { // adjust for raw OA mixed inlet humrat
704 3 : coilInHumRat = (1.0 - outAirFrac) * finalZoneSizing.ZoneHumRatAtCoolPeak + outAirFrac * finalZoneSizing.OutHumRatAtCoolPeak;
705 : } else {
706 25 : coilInHumRat = finalZoneSizing.ZoneHumRatAtCoolPeak;
707 : }
708 34 : return coilInHumRat;
709 : }
710 :
711 5 : void BaseSizer::clearState()
712 : {
713 5 : stdRhoAir = 0.0;
714 :
715 5 : zoneAirFlowSizMethod = 0;
716 5 : dataScalableSizingON = false;
717 5 : dataScalableCapSizingON = false;
718 5 : isCoilReportObject = false; // provides access to coil reporting
719 5 : isFanReportObject = false; // provides access to fan reporting
720 5 : initialized = false; // indicates initializeWithinEP was called
721 5 : errorType = AutoSizingResultType::NoError;
722 5 : sizingString = "";
723 5 : sizingStringScalable = "";
724 5 : overrideSizeString = true;
725 5 : originalValue = 0.0;
726 5 : autoSizedValue = 0.0;
727 5 : wasAutoSized = false;
728 5 : hardSizeNoDesignRun = false;
729 5 : sizingDesRunThisAirSys = false;
730 5 : sizingDesRunThisZone = false;
731 5 : sizingDesValueFromParent = false;
732 5 : airLoopSysFlag = false;
733 5 : oaSysFlag = false;
734 5 : coilType_Num = 0;
735 5 : compType = "";
736 5 : compName = "";
737 5 : isEpJSON = false;
738 :
739 5 : sysSizingRunDone = false;
740 5 : zoneSizingRunDone = false;
741 5 : curSysNum = 0;
742 5 : curOASysNum = 0;
743 5 : curZoneEqNum = 0;
744 5 : curDuctType = HVAC::AirDuctType::Invalid;
745 5 : curTermUnitSizingNum = 0; // index in zone equipment vector - for single duct, IU, and PIU
746 5 : numPrimaryAirSys = 0;
747 5 : numSysSizInput = 0;
748 5 : doSystemSizing = false;
749 5 : numZoneSizingInput = 0;
750 5 : doZoneSizing = false;
751 5 : autoCalculate = false; // indicator that AutoCalculate is used
752 :
753 : // terminal units
754 5 : termUnitSingDuct = false; // single duct terminal unit
755 5 : termUnitPIU = false; // powered induction unit
756 5 : termUnitIU = false; // induction terminal unit
757 5 : zoneEqFanCoil = false; // fan coil zone equipment
758 5 : otherEqType = false; // this covers the ELSE type switch
759 5 : zoneEqUnitHeater = false; // unit heater zone equipment
760 5 : zoneEqUnitVent = false; // unit ventilator zone equipment
761 5 : zoneEqVentedSlab = false; // ventilated slab zone equipment
762 :
763 : // error message handling
764 5 : getLastErrorMessages();
765 :
766 : // global sizing data
767 5 : minOA = DataSizing::OAControl::Invalid;
768 :
769 : // global Data* sizing constants
770 5 : dataEMSOverrideON = false;
771 5 : dataEMSOverride = 0.0;
772 5 : dataAutosizable = false;
773 5 : dataConstantUsedForSizing = 0.0;
774 5 : dataFractionUsedForSizing = 0.0;
775 5 : dataDXCoolsLowSpeedsAutozize = false;
776 5 : dataPltSizHeatNum = 0;
777 5 : dataWaterLoopNum = 0;
778 5 : dataFanIndex = -1;
779 5 : dataFanType = HVAC::FanType::Invalid;
780 5 : dataWaterCoilSizCoolDeltaT = 0.0;
781 5 : dataWaterCoilSizHeatDeltaT = 0.0;
782 5 : dataCapacityUsedForSizing = 0.0;
783 5 : dataPltSizCoolNum = 0;
784 5 : dataDesInletAirHumRat = 0.0;
785 5 : dataFlowUsedForSizing = 0.0;
786 5 : dataDesOutletAirHumRat = 0.0;
787 5 : dataDesInletWaterTemp = 0.0;
788 5 : dataDesOutletAirTemp = 0.0;
789 5 : dataWaterFlowUsedForSizing = 0.0;
790 5 : dataSizingFraction = 1.0;
791 5 : dataDXSpeedNum = 0.0;
792 5 : dataAirFlowUsedForSizing = 0.0;
793 5 : dataDesInletAirTemp = 0.0;
794 5 : dataDesAccountForFanHeat = false;
795 5 : dataFanPlacement = HVAC::FanPlace::Invalid;
796 5 : dataDesicRegCoil = false;
797 5 : dataHeatSizeRatio = 0.0;
798 5 : dataZoneUsedForSizing = 0;
799 5 : dataDesicDehumNum = 0;
800 5 : dataNomCapInpMeth = false;
801 5 : dataCoilNum = 0;
802 5 : dataFanOp = HVAC::FanOp::Invalid;
803 5 : dataDesignCoilCapacity = 0.0;
804 5 : dataErrorsFound = false;
805 5 : dataBypassFrac = 0.0;
806 5 : dataIsDXCoil = false;
807 :
808 5 : dataNonZoneNonAirloopValue = 0.0;
809 :
810 5 : printWarningFlag = false;
811 5 : callingRoutine = "";
812 5 : sysSizingInputData.clear();
813 5 : zoneSizingInput.clear();
814 5 : unitarySysEqSizing.clear();
815 5 : oaSysEqSizing.clear();
816 5 : zoneEqSizing.clear();
817 5 : outsideAirSys.clear();
818 5 : termUnitSizing.clear();
819 5 : termUnitFinalZoneSizing.clear();
820 5 : finalZoneSizing.clear();
821 5 : finalSysSizing.clear();
822 5 : plantSizData.clear();
823 5 : primaryAirSystem.clear();
824 5 : airloopDOAS.clear();
825 5 : }
826 :
827 : } // namespace EnergyPlus
|
