Line data Source code
1 : // EnergyPlus, Copyright (c) 1996-2024, 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 : // ObjexxFCL Headers
49 : #include <ObjexxFCL/Array.functions.hh>
50 : #include <ObjexxFCL/Fmath.hh>
51 :
52 : // EnergyPlus Headers
53 : #include <EnergyPlus/Autosizing/Base.hh>
54 : #include <EnergyPlus/BranchNodeConnections.hh>
55 : #include <EnergyPlus/Data/EnergyPlusData.hh>
56 : #include <EnergyPlus/DataEnvironment.hh>
57 : #include <EnergyPlus/DataHVACGlobals.hh>
58 : #include <EnergyPlus/DataLoopNode.hh>
59 : #include <EnergyPlus/DataSizing.hh>
60 : #include <EnergyPlus/DataZoneEnergyDemands.hh>
61 : #include <EnergyPlus/HybridEvapCoolingModel.hh>
62 : #include <EnergyPlus/HybridUnitaryAirConditioners.hh>
63 : #include <EnergyPlus/InputProcessing/InputProcessor.hh>
64 : #include <EnergyPlus/NodeInputManager.hh>
65 : #include <EnergyPlus/OutputProcessor.hh>
66 : #include <EnergyPlus/Psychrometrics.hh>
67 : #include <EnergyPlus/ScheduleManager.hh>
68 : #include <EnergyPlus/UtilityRoutines.hh>
69 :
70 : #define TEMP_CURVE 0
71 : #define W_CURVE 1
72 : #define POWER_CURVE 2
73 :
74 : namespace EnergyPlus::HybridUnitaryAirConditioners {
75 :
76 : // Begin routines for zone HVAC Hybrid Evaporative cooler unit
77 13275 : void SimZoneHybridUnitaryAirConditioners(EnergyPlusData &state,
78 : std::string_view CompName, // name of the packaged terminal heat pump
79 : int const ZoneNum, // number of zone being served
80 : Real64 &SensibleOutputProvided, // sensible capacity delivered to zone cooling is negative
81 : Real64 &LatentOutputProvided, // Latent add/removal (kg/s), dehumid = negative
82 : int &CompIndex // index to zone hvac unit
83 : )
84 : {
85 : // SUBROUTINE INFORMATION:
86 : // AUTHOR Spencer Maxwell Dutton
87 : // DATE WRITTEN October 2017
88 : // MODIFIED
89 : // RE-ENGINEERED na
90 :
91 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
92 : int CompNum;
93 13275 : bool errorsfound = false;
94 13275 : if (state.dataHybridUnitaryAC->GetInputZoneHybridEvap) {
95 1 : GetInputZoneHybridUnitaryAirConditioners(state, errorsfound);
96 1 : state.dataHybridUnitaryAC->GetInputZoneHybridEvap = false;
97 : }
98 :
99 13275 : if (CompIndex == 0) {
100 1 : CompNum = Util::FindItemInList(CompName, state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner);
101 1 : if (CompNum == 0) {
102 0 : ShowFatalError(state, "SimZoneHybridUnitaryAirConditioners: ZoneHVAC:HybridUnitaryHVAC not found.");
103 : }
104 1 : CompIndex = CompNum;
105 : } else {
106 13274 : CompNum = CompIndex;
107 13274 : if (CompNum < 1 || CompNum > state.dataHybridUnitaryAC->NumZoneHybridEvap) {
108 0 : ShowFatalError(state,
109 0 : format("SimZoneHybridUnitaryAirConditioners: Invalid CompIndex passed={}, Number of units ={}, Entered Unit name = {}",
110 : CompNum,
111 0 : state.dataHybridUnitaryAC->NumZoneHybridEvap,
112 : CompName));
113 : }
114 13274 : if (state.dataHybridUnitaryAC->CheckZoneHybridEvapName(CompNum)) {
115 1 : if (CompName != state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(CompNum).Name) {
116 0 : ShowFatalError(
117 : state,
118 0 : format("SimZoneHybridUnitaryAirConditioners: Invalid CompIndex passed={}, Unit name={}, stored unit name for that index={}",
119 : CompNum,
120 : CompName,
121 0 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(CompNum).Name));
122 : }
123 1 : state.dataHybridUnitaryAC->CheckZoneHybridEvapName(CompNum) = false;
124 : }
125 : }
126 : try {
127 13275 : InitZoneHybridUnitaryAirConditioners(state, CompNum, ZoneNum);
128 0 : } catch (int e) {
129 0 : ShowFatalError(state,
130 0 : format("An exception occurred in InitZoneHybridUnitaryAirConditioners{}, Unit name={}, stored unit name for that "
131 : "index={}. Please check idf.",
132 : CompNum,
133 : CompName,
134 0 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(CompNum).Name));
135 0 : return;
136 0 : }
137 : try {
138 13275 : CalcZoneHybridUnitaryAirConditioners(state, CompNum, ZoneNum, SensibleOutputProvided, LatentOutputProvided);
139 0 : } catch (int e) {
140 0 : ShowFatalError(state,
141 0 : format("An exception occurred in CalcZoneHybridUnitaryAirConditioners{}, Unit name={}, stored unit name for that "
142 : "index={}. Please check idf.",
143 : CompNum,
144 : CompName,
145 0 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(CompNum).Name));
146 0 : return;
147 0 : }
148 : try {
149 13275 : ReportZoneHybridUnitaryAirConditioners(state, CompNum);
150 0 : } catch (int e) {
151 0 : ShowFatalError(state,
152 0 : format("An exception occurred in ReportZoneHybridUnitaryAirConditioners{}, Unit name={}, stored unit name for that "
153 : "index={}. Please check idf.",
154 : CompNum,
155 : CompName,
156 0 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(CompNum).Name));
157 0 : return;
158 0 : }
159 : }
160 :
161 13275 : void InitZoneHybridUnitaryAirConditioners(EnergyPlusData &state,
162 : int const UnitNum, // unit number
163 : int const ZoneNum // number of zone being served
164 : )
165 : {
166 : // SUBROUTINE INFORMATION:
167 : // AUTHOR Spencer Maxwell Dutton
168 : // DATE WRITTEN October 2017
169 : // MODIFIED
170 : // RE-ENGINEERED na
171 :
172 : // PURPOSE OF THIS SUBROUTINE:
173 : //
174 :
175 : // METHODOLOGY EMPLOYED:
176 : //
177 :
178 : // REFERENCES:
179 : // na
180 :
181 : // Using/Aliasing
182 : using namespace DataLoopNode;
183 : using namespace Psychrometrics;
184 : using DataZoneEquipment::CheckZoneEquipmentList;
185 :
186 : // Locals
187 : int Loop;
188 : int InletNode;
189 :
190 13275 : if (state.dataHybridUnitaryAC->HybridCoolOneTimeFlag) {
191 : // These three look like they are not used anywhere
192 1 : state.dataHybridUnitaryAC->MySizeFlag.dimension(state.dataHybridUnitaryAC->NumZoneHybridEvap, true);
193 1 : state.dataHybridUnitaryAC->MyEnvrnFlag.dimension(state.dataHybridUnitaryAC->NumZoneHybridEvap, true);
194 1 : state.dataHybridUnitaryAC->MyFanFlag.dimension(state.dataHybridUnitaryAC->NumZoneHybridEvap, true);
195 :
196 1 : state.dataHybridUnitaryAC->MyZoneEqFlag.dimension(state.dataHybridUnitaryAC->NumZoneHybridEvap, true);
197 1 : state.dataHybridUnitaryAC->HybridCoolOneTimeFlag = false;
198 : }
199 13275 : if (!state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).Initialized) {
200 1 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).Initialize(ZoneNum);
201 : }
202 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).RequestedLoadToHeatingSetpoint = 0;
203 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).RequestedLoadToCoolingSetpoint = 0;
204 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).RequestedHumdificationMass = 0;
205 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).RequestedHumdificationLoad = 0;
206 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).RequestedHumdificationEnergy = 0;
207 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).RequestedDeHumdificationMass = 0;
208 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).RequestedDeHumdificationLoad = 0;
209 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).RequestedDeHumdificationEnergy = 0;
210 :
211 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).UnitTotalCoolingRate = 0.0;
212 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).UnitTotalCoolingEnergy = 0.0;
213 :
214 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).UnitSensibleCoolingRate = 0.0;
215 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).UnitSensibleCoolingEnergy = 0.0;
216 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).UnitLatentCoolingRate = 0.0;
217 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).UnitLatentCoolingEnergy = 0.0;
218 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).availStatus = Avail::Status::NoAction;
219 :
220 : // set the availability status based on the availability manager list name
221 13275 : if (allocated(state.dataAvail->ZoneComp)) {
222 13275 : auto &availMgr = state.dataAvail->ZoneComp(DataZoneEquipment::ZoneEquipType::HybridEvaporativeCooler).ZoneCompAvailMgrs(UnitNum);
223 13275 : if (state.dataHybridUnitaryAC->MyZoneEqFlag(UnitNum)) { // initialize the name of each availability manager list and zone number
224 1 : availMgr.AvailManagerListName = state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).AvailManagerListName;
225 1 : availMgr.ZoneNum = ZoneNum;
226 1 : state.dataHybridUnitaryAC->MyZoneEqFlag(UnitNum) = false;
227 : }
228 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).availStatus = availMgr.availStatus;
229 : }
230 :
231 : // need to check all zone outdoor air control units to see if they are on Zone Equipment List or issue warning
232 13275 : if (!state.dataHybridUnitaryAC->ZoneEquipmentListChecked && state.dataZoneEquip->ZoneEquipInputsFilled) {
233 1 : state.dataHybridUnitaryAC->ZoneEquipmentListChecked = true;
234 2 : for (Loop = 1; Loop <= state.dataHybridUnitaryAC->NumZoneHybridEvap; ++Loop) {
235 1 : if (CheckZoneEquipmentList(state, "ZoneHVAC:HybridUnitaryHVAC", state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(Loop).Name)) {
236 1 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(Loop).ZoneNodeNum = state.dataZoneEquip->ZoneEquipConfig(ZoneNum).ZoneNode;
237 : } else {
238 0 : ShowSevereError(state,
239 0 : format("InitZoneHybridUnitaryAirConditioners: ZoneHVAC:HybridUnitaryHVAC = {}, is not on any ZoneHVAC:EquipmentList. "
240 : " It will not be simulated.",
241 0 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(Loop).Name));
242 : }
243 : }
244 : }
245 :
246 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).InitializeModelParams();
247 : // Do the following initializations (every time step): This should be the info from
248 : // the previous components outlets or the node data in this section.
249 :
250 : // Transfer the node data to EvapCond data structure
251 13275 : InletNode = state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).InletNode;
252 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).InletMassFlowRate = state.dataLoopNodes->Node(InletNode).MassFlowRate;
253 :
254 : // Set the inlet volumetric flow rate from the mass flow rate
255 13275 : if (state.dataEnvrn->StdRhoAir > 1) {
256 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).InletVolumetricFlowRate =
257 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).InletMassFlowRate / state.dataEnvrn->StdRhoAir;
258 : } else {
259 0 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).InletVolumetricFlowRate =
260 0 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).InletMassFlowRate / 1.225;
261 : }
262 :
263 : // Set all of the inlet state variables from the inlet nodes
264 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).InletTemp = state.dataLoopNodes->Node(InletNode).Temp;
265 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).InletHumRat = state.dataLoopNodes->Node(InletNode).HumRat;
266 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).InletEnthalpy = state.dataLoopNodes->Node(InletNode).Enthalpy;
267 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).InletPressure = state.dataLoopNodes->Node(InletNode).Press;
268 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).InletRH =
269 26550 : PsyRhFnTdbWPb(state,
270 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).InletTemp,
271 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).InletHumRat,
272 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).InletPressure,
273 : "InitZoneHybridUnitaryAirConditioners");
274 :
275 : // Set default outlet state to inlet states, just to be safe
276 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).OutletTemp =
277 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).InletTemp;
278 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).OutletHumRat =
279 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).InletHumRat;
280 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).OutletEnthalpy =
281 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).InletEnthalpy;
282 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).OutletPressure =
283 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).InletPressure;
284 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).OutletRH =
285 26550 : PsyRhFnTdbWPb(state,
286 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).OutletTemp,
287 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).OutletHumRat,
288 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).OutletPressure,
289 : "InitZoneHybridUnitaryAirConditioners");
290 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).OutletMassFlowRate =
291 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).InletMassFlowRate;
292 :
293 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecInletTemp =
294 13275 : state.dataLoopNodes->Node(state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecondaryInletNode).Temp;
295 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecInletHumRat =
296 13275 : state.dataLoopNodes->Node(state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecondaryInletNode).HumRat;
297 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecInletEnthalpy =
298 13275 : state.dataLoopNodes->Node(state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecondaryInletNode).Enthalpy;
299 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecInletPressure =
300 13275 : state.dataLoopNodes->Node(state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecondaryInletNode).Press;
301 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecInletRH =
302 26550 : PsyRhFnTdbWPb(state,
303 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecInletTemp,
304 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecInletHumRat,
305 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecInletPressure,
306 : "InitZoneHybridUnitaryAirConditioners");
307 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecInletMassFlowRate =
308 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SupplyVentilationAir;
309 :
310 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecOutletTemp =
311 13275 : state.dataLoopNodes->Node(state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecondaryInletNode).Temp;
312 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecOutletHumRat =
313 13275 : state.dataLoopNodes->Node(state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecondaryInletNode).HumRat;
314 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecOutletEnthalpy =
315 13275 : state.dataLoopNodes->Node(state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecondaryInletNode).Enthalpy;
316 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecOutletPressure =
317 13275 : state.dataLoopNodes->Node(state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecondaryInletNode).Press;
318 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecOutletRH =
319 26550 : PsyRhFnTdbWPb(state,
320 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecInletTemp,
321 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecInletHumRat,
322 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecInletPressure,
323 : "InitZoneHybridUnitaryAirConditioners");
324 13275 : }
325 :
326 13275 : void CalcZoneHybridUnitaryAirConditioners(EnergyPlusData &state,
327 : int const UnitNum, // unit number
328 : int const ZoneNum, // number of zone being served
329 : Real64 &SensibleOutputProvided, // sensible capacity delivered to zone cooling negitive
330 : Real64 &LatentOutputProvided // Latent add/removal (kg/s), dehumid = negative
331 : )
332 : {
333 : // SUBROUTINE INFORMATION:
334 : // AUTHOR Spencer Maxwell Dutton
335 : // DATE WRITTEN October 2017
336 : // MODIFIED
337 : // RE-ENGINEERED na
338 :
339 : using namespace DataLoopNode;
340 : using namespace Psychrometrics;
341 :
342 : Real64 EnvDryBulbT, AirTempRoom, EnvRelHumm, RoomRelHum, DesignMinVR;
343 :
344 13275 : Real64 ZoneCoolingLoad = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(ZoneNum)
345 13275 : .RemainingOutputReqToCoolSP; // Remaining load required to meet cooling setpoint (<0 is a cooling load)
346 13275 : Real64 ZoneHeatingLoad = state.dataZoneEnergyDemand->ZoneSysEnergyDemand(ZoneNum)
347 13275 : .RemainingOutputReqToHeatSP; // Remaining load required to meet heating setpoint (>0 is a heating load)
348 : Real64 OutputRequiredToHumidify =
349 13275 : state.dataZoneEnergyDemand->ZoneSysMoistureDemand(ZoneNum)
350 13275 : .OutputRequiredToHumidifyingSP; // Load required to meet humidifying setpoint (>0 = a humidify load) [kgWater/s]
351 :
352 : Real64 OutputRequiredToDehumidify =
353 13275 : state.dataZoneEnergyDemand->ZoneSysMoistureDemand(ZoneNum)
354 13275 : .OutputRequiredToDehumidifyingSP; // Load required to meet dehumidifying setpoint (<0 = a dehumidify load) [kgWater/s]
355 :
356 13275 : SensibleOutputProvided = 0;
357 13275 : LatentOutputProvided = 0;
358 : // taking class members out of the object and then using them in the calcualtion is odd but its for clarity with unit testing.
359 13275 : EnvDryBulbT = state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecInletTemp; // degrees C
360 13275 : AirTempRoom = state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).InletTemp; // degrees C
361 13275 : EnvRelHumm = state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecInletRH; // RH
362 13275 : RoomRelHum = state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).InletRH; // RH
363 :
364 13275 : bool UseOccSchFlag = true;
365 13275 : bool UseMinOASchFlag = true;
366 :
367 39825 : DesignMinVR = DataSizing::calcDesignSpecificationOutdoorAir(state,
368 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).OARequirementsPtr,
369 : ZoneNum,
370 : UseOccSchFlag,
371 : UseMinOASchFlag); //[m3/s]
372 13275 : Real64 DesignMinVRMassFlow = 0;
373 13275 : if (state.dataEnvrn->StdRhoAir > 1) {
374 13275 : DesignMinVRMassFlow = DesignMinVR * state.dataEnvrn->StdRhoAir;
375 : } else {
376 0 : DesignMinVRMassFlow = DesignMinVR * 1.225;
377 : }
378 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).doStep(
379 : state, ZoneCoolingLoad, ZoneHeatingLoad, OutputRequiredToHumidify, OutputRequiredToDehumidify, DesignMinVRMassFlow);
380 13275 : SensibleOutputProvided = -state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).QSensZoneOut; // cooling negative
381 :
382 13275 : LatentOutputProvided = -state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).QLatentZoneOutMass; // dehumidification negative kg/s
383 13275 : }
384 :
385 13275 : void ReportZoneHybridUnitaryAirConditioners(EnergyPlusData &state, int const UnitNum)
386 : {
387 : // SUBROUTINE INFORMATION:
388 : // AUTHOR Spencer Maxwell Dutton
389 : // DATE WRITTEN October 2017
390 : // MODIFIED
391 : // RE-ENGINEERED na
392 :
393 : // Using/Aliasing
394 : using namespace DataLoopNode;
395 : using namespace Psychrometrics;
396 :
397 : // SUBROUTINE LOCAL VARIABLE DECLARATIONS:
398 : int ZoneNodeNum;
399 13275 : ZoneNodeNum = state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).ZoneNodeNum;
400 :
401 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).PrimaryMode =
402 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).PrimaryMode;
403 :
404 13275 : state.dataLoopNodes->Node(state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).InletNode).Temp =
405 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).InletTemp;
406 13275 : state.dataLoopNodes->Node(state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).InletNode).HumRat =
407 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).InletHumRat;
408 13275 : state.dataLoopNodes->Node(state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).InletNode).MassFlowRate =
409 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).InletMassFlowRate;
410 13275 : state.dataLoopNodes->Node(state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).InletNode).Enthalpy =
411 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).InletEnthalpy;
412 :
413 13275 : state.dataLoopNodes->Node(state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).OutletNode).Temp =
414 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).OutletTemp;
415 13275 : state.dataLoopNodes->Node(state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).OutletNode).HumRat =
416 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).OutletHumRat;
417 13275 : state.dataLoopNodes->Node(state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).OutletNode).MassFlowRate =
418 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).OutletMassFlowRate;
419 13275 : state.dataLoopNodes->Node(state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).OutletNode).Enthalpy =
420 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).OutletEnthalpy;
421 :
422 13275 : state.dataLoopNodes->Node(state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecondaryInletNode).Temp =
423 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecInletTemp;
424 13275 : state.dataLoopNodes->Node(state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecondaryInletNode).HumRat =
425 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecInletHumRat;
426 13275 : state.dataLoopNodes->Node(state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecondaryInletNode).Enthalpy =
427 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecInletEnthalpy;
428 13275 : state.dataLoopNodes->Node(state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecondaryInletNode).MassFlowRate =
429 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecInletMassFlowRate;
430 :
431 13275 : state.dataLoopNodes->Node(state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecondaryOutletNode).Temp =
432 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecOutletTemp;
433 13275 : state.dataLoopNodes->Node(state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecondaryOutletNode).HumRat =
434 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecOutletHumRat;
435 13275 : state.dataLoopNodes->Node(state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecondaryOutletNode).Enthalpy =
436 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecOutletEnthalpy;
437 13275 : state.dataLoopNodes->Node(state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecondaryOutletNode).MassFlowRate =
438 13275 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitNum).SecOutletMassFlowRate;
439 13275 : }
440 :
441 1 : void GetInputZoneHybridUnitaryAirConditioners(EnergyPlusData &state, bool &Errors)
442 : {
443 : // SUBROUTINE INFORMATION:
444 : // AUTHOR Spencer Maxwell Dutton
445 : // DATE WRITTEN October 2017
446 : // MODIFIED
447 : // RE-ENGINEERED na
448 :
449 : // Using/Aliasing
450 : using BranchNodeConnections::TestCompSet;
451 : using namespace ScheduleManager;
452 : using BranchNodeConnections::SetUpCompSets;
453 : using NodeInputManager::GetOnlySingleNode;
454 : using namespace DataLoopNode;
455 1 : std::string cCurrentModuleObject; // Object type for getting and error messages
456 1 : Array1D_string Alphas; // Alpha items for object
457 1 : Array1D<Real64> Numbers; // Numeric items for object
458 1 : Array1D_string cAlphaFields; // Alpha field names
459 1 : Array1D_string cNumericFields; // Numeric field names
460 1 : Array1D_bool lAlphaBlanks; // Logical array, alpha field input BLANK = .TRUE.
461 1 : Array1D_bool lNumericBlanks; // Logical array, numeric field input BLANK = .TRUE.
462 : int NumAlphas; // Number of Alphas for each GetObjectItem call
463 : int NumNumbers; // Number of Numbers for each GetObjectItem call
464 : int NumFields; // Total number of fields in object
465 : int IOStatus; // Used in GetObjectItem
466 1 : bool ErrorsFound(false); // Set to true if errors in input, fatal at end of routine
467 : bool IsNotOK; // Flag to verify name
468 : bool IsBlank; // Flag for blank name
469 : int UnitLoop;
470 :
471 : // SUBROUTINE PARAMETER DEFINITIONS:
472 : static constexpr std::string_view routineName = "GetInputZoneHybridUnitaryAirConditioners";
473 :
474 1 : cCurrentModuleObject = "ZoneHVAC:HybridUnitaryHVAC";
475 1 : state.dataHybridUnitaryAC->NumZoneHybridEvap = state.dataInputProcessing->inputProcessor->getNumObjectsFound(state, cCurrentModuleObject);
476 1 : state.dataInputProcessing->inputProcessor->getObjectDefMaxArgs(state, cCurrentModuleObject, NumFields, NumAlphas, NumNumbers);
477 1 : int MaxNumbers = max(0, NumNumbers); // Maximum number of numeric fields in all objects
478 1 : int MaxAlphas = max(0, NumAlphas); // Maximum number of alpha fields in all objects
479 1 : Alphas.allocate(MaxAlphas);
480 1 : Numbers.dimension(MaxNumbers, 0.0);
481 1 : cAlphaFields.allocate(MaxAlphas);
482 1 : cNumericFields.allocate(MaxNumbers);
483 1 : lAlphaBlanks.dimension(MaxAlphas, true);
484 1 : lNumericBlanks.dimension(MaxNumbers, true);
485 1 : std::vector<std::string> test;
486 1 : std::vector<bool> blanks;
487 :
488 1 : if (state.dataHybridUnitaryAC->NumZoneHybridEvap > 0) {
489 1 : state.dataHybridUnitaryAC->CheckZoneHybridEvapName.dimension(state.dataHybridUnitaryAC->NumZoneHybridEvap, true);
490 1 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner.allocate(state.dataHybridUnitaryAC->NumZoneHybridEvap);
491 :
492 2 : for (UnitLoop = 1; UnitLoop <= state.dataHybridUnitaryAC->NumZoneHybridEvap; ++UnitLoop) {
493 1 : state.dataInputProcessing->inputProcessor->getObjectItem(state,
494 : cCurrentModuleObject,
495 : UnitLoop,
496 : Alphas,
497 : NumAlphas,
498 : Numbers,
499 : NumNumbers,
500 : IOStatus,
501 : lNumericBlanks,
502 : lAlphaBlanks,
503 : cAlphaFields,
504 : cNumericFields);
505 :
506 1 : IsNotOK = false;
507 1 : IsBlank = false;
508 2 : Util::VerifyName(state,
509 1 : Alphas(1),
510 1 : state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner,
511 : UnitLoop - 1,
512 : IsNotOK,
513 : IsBlank,
514 2 : cCurrentModuleObject + " Name");
515 :
516 1 : ErrorObjectHeader eoh{routineName, cCurrentModuleObject, Alphas(1)};
517 1 : auto &hybridUnitaryAC = state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitLoop);
518 :
519 : // A1, \field Name
520 1 : hybridUnitaryAC.Name = Alphas(1);
521 : // A2, \field Availability Schedule Name
522 1 : hybridUnitaryAC.Schedule = Alphas(2);
523 1 : if (lAlphaBlanks(2)) {
524 0 : hybridUnitaryAC.SchedPtr = ScheduleManager::ScheduleAlwaysOn;
525 : } else {
526 1 : hybridUnitaryAC.SchedPtr = GetScheduleIndex(state, Alphas(2));
527 1 : if (hybridUnitaryAC.SchedPtr == 0) {
528 0 : ShowSevereError(state, format("Invalid {}={}", cAlphaFields(2), Alphas(2)));
529 0 : ShowContinueError(state, format("Entered in {}={}", cCurrentModuleObject, Alphas(1)));
530 0 : ErrorsFound = true;
531 : }
532 : }
533 : // A3, \field Availability Manager List Name
534 1 : if (!lAlphaBlanks(3)) {
535 0 : hybridUnitaryAC.AvailManagerListName = Alphas(3);
536 : }
537 :
538 : // A4, \field Minimum Supply Air Temperature Schedule Named
539 1 : if (!lAlphaBlanks(4)) {
540 1 : hybridUnitaryAC.TsaMin_schedule_pointer = GetScheduleIndex(state, Alphas(4));
541 1 : if (hybridUnitaryAC.TsaMin_schedule_pointer == 0) {
542 0 : ShowSevereError(state, format("Invalid {}={}", cAlphaFields(4), Alphas(4)));
543 0 : ShowContinueError(state, format("Entered in {}={}", cCurrentModuleObject, Alphas(1)));
544 0 : ErrorsFound = true;
545 : }
546 : }
547 : // A5, \field Maximum Supply Air Temperature Schedule Name
548 1 : if (!lAlphaBlanks(5)) {
549 1 : hybridUnitaryAC.TsaMax_schedule_pointer = GetScheduleIndex(state, Alphas(5));
550 1 : if (hybridUnitaryAC.TsaMax_schedule_pointer == 0) {
551 0 : ShowSevereError(state, format("Invalid {}={}", cAlphaFields(5), Alphas(5)));
552 0 : ShowContinueError(state, format("Entered in {}={}", cCurrentModuleObject, Alphas(1)));
553 0 : ErrorsFound = true;
554 : }
555 : }
556 : // A6, \field Minimum Supply Air Humidity Ratio Schedule Name
557 1 : if (!lAlphaBlanks(6)) {
558 1 : hybridUnitaryAC.RHsaMin_schedule_pointer = GetScheduleIndex(state, Alphas(6));
559 1 : if (hybridUnitaryAC.RHsaMin_schedule_pointer == 0) {
560 0 : ShowSevereError(state, format("Invalid {}={}", cAlphaFields(6), Alphas(6)));
561 0 : ShowContinueError(state, format("Entered in {}={}", cCurrentModuleObject, Alphas(1)));
562 0 : ErrorsFound = true;
563 : }
564 : }
565 : // A7, \field Maximum Supply Air Humidity Ratio Schedule Name
566 1 : if (!lAlphaBlanks(7)) {
567 1 : hybridUnitaryAC.RHsaMax_schedule_pointer = GetScheduleIndex(state, Alphas(7));
568 1 : if (hybridUnitaryAC.RHsaMax_schedule_pointer == 0) {
569 0 : ShowSevereError(state, format("Invalid {}={}", cAlphaFields(7), Alphas(7)));
570 0 : ShowContinueError(state, format("Entered in {}={}", cCurrentModuleObject, Alphas(1)));
571 0 : ErrorsFound = true;
572 : }
573 : }
574 :
575 : // A8, \field Method to Choose Value of Controlled Inputs
576 :
577 : // A9, \field Return Air Node Name
578 : // A10, \field Outdoor Air Node Name
579 : // A11, \field Supply Air Node Name
580 : // A12, \field Relief Node Name
581 1 : hybridUnitaryAC.InletNode = GetOnlySingleNode(state,
582 1 : Alphas(9),
583 : ErrorsFound,
584 : DataLoopNode::ConnectionObjectType::ZoneHVACHybridUnitaryHVAC,
585 1 : Alphas(1),
586 : DataLoopNode::NodeFluidType::Air,
587 : DataLoopNode::ConnectionType::Inlet,
588 : NodeInputManager::CompFluidStream::Primary,
589 : ObjectIsNotParent);
590 1 : hybridUnitaryAC.SecondaryInletNode = GetOnlySingleNode(state,
591 1 : Alphas(10),
592 : ErrorsFound,
593 : DataLoopNode::ConnectionObjectType::ZoneHVACHybridUnitaryHVAC,
594 1 : Alphas(1),
595 : DataLoopNode::NodeFluidType::Air,
596 : DataLoopNode::ConnectionType::OutsideAir,
597 : NodeInputManager::CompFluidStream::Primary,
598 : ObjectIsNotParent);
599 1 : hybridUnitaryAC.OutletNode = GetOnlySingleNode(state,
600 1 : Alphas(11),
601 : ErrorsFound,
602 : DataLoopNode::ConnectionObjectType::ZoneHVACHybridUnitaryHVAC,
603 1 : Alphas(1),
604 : DataLoopNode::NodeFluidType::Air,
605 : DataLoopNode::ConnectionType::Outlet,
606 : NodeInputManager::CompFluidStream::Primary,
607 : ObjectIsNotParent);
608 1 : hybridUnitaryAC.SecondaryOutletNode = GetOnlySingleNode(state,
609 1 : Alphas(12),
610 : ErrorsFound,
611 : DataLoopNode::ConnectionObjectType::ZoneHVACHybridUnitaryHVAC,
612 1 : Alphas(1),
613 : DataLoopNode::NodeFluidType::Air,
614 : DataLoopNode::ConnectionType::ReliefAir,
615 : NodeInputManager::CompFluidStream::Primary,
616 : ObjectIsNotParent);
617 1 : TestCompSet(state, cCurrentModuleObject, Alphas(1), Alphas(9), Alphas(11), "Hybrid Evap Air Zone Nodes");
618 1 : TestCompSet(state, cCurrentModuleObject, Alphas(1), Alphas(10), Alphas(12), "Hybrid Evap Air Zone Secondary Nodes");
619 :
620 : // N1, \field System Maximum Supply AirFlow Rate
621 1 : hybridUnitaryAC.SystemMaximumSupplyAirFlowRate = Numbers(1);
622 :
623 : // N2, \field External Static Pressure at System Maximum Supply Air Flow Rate
624 :
625 : // In each time step, the result for system power, fan power, gas use, water user, or supply airflow rate will be determined as :
626 : // TableValue * SysMaxSupply * ScalingFactor
627 : // A13, \field Fan Heat Included in Lookup Tables
628 1 : hybridUnitaryAC.FanHeatGain = false;
629 1 : if (!lAlphaBlanks(13)) {
630 1 : if (Util::SameString(Alphas(13), "Yes")) {
631 1 : hybridUnitaryAC.FanHeatGain = false;
632 0 : } else if (Util::SameString(Alphas(13), "No")) {
633 0 : hybridUnitaryAC.FanHeatGain = true;
634 : } else {
635 0 : ShowSevereError(state, format("{} = {}", cCurrentModuleObject, hybridUnitaryAC.Name));
636 0 : ShowContinueError(state, format("Illegal {} = {}", cAlphaFields(13), Alphas(13)));
637 0 : ErrorsFound = true;
638 : }
639 : }
640 : // A14, \field Fan Heat Gain Location
641 1 : if (!lAlphaBlanks(14)) {
642 0 : hybridUnitaryAC.FanHeatGainLocation = Alphas(14);
643 : }
644 : // N3, \field Fan Heat in Air Stream Fraction
645 1 : hybridUnitaryAC.FanHeatInAirFrac = Numbers(3);
646 : // N4, \field Scaling Factor
647 1 : hybridUnitaryAC.ScalingFactor = Numbers(4);
648 : // the two numbers above are used to generate a overall scaling factor
649 1 : hybridUnitaryAC.ScaledSystemMaximumSupplyAirVolumeFlowRate = Numbers(1) * Numbers(4);
650 1 : if (state.dataEnvrn->StdRhoAir > 1) {
651 : // SystemMaximumSupplyAirFlowRate*ScalingFactor*AirDensity;
652 1 : hybridUnitaryAC.ScaledSystemMaximumSupplyAirMassFlowRate =
653 1 : hybridUnitaryAC.ScaledSystemMaximumSupplyAirVolumeFlowRate * state.dataEnvrn->StdRhoAir;
654 : } else {
655 0 : hybridUnitaryAC.ScaledSystemMaximumSupplyAirMassFlowRate = hybridUnitaryAC.ScaledSystemMaximumSupplyAirVolumeFlowRate * 1.225;
656 : }
657 :
658 : // N5, \field Minimum Time Between Mode Change
659 : // A15, \field First fuel type
660 1 : if (lAlphaBlanks(15)) {
661 : // The original code never checks if this field is empty, but adding this check leads to a unit test failure.
662 : // ShowSevereEmptyField(state, eoh, cAlphaFields(15));
663 : // ErrorsFound = true;
664 2 : } else if ((hybridUnitaryAC.firstFuel = static_cast<Constant::eFuel>(
665 1 : getEnumValue(Constant::eFuelNamesUC, Util::makeUPPER(Alphas(15))))) == Constant::eFuel::Invalid) {
666 0 : ShowSevereInvalidKey(state, eoh, cAlphaFields(15), Alphas(15));
667 0 : ErrorsFound = true;
668 : }
669 :
670 : // A16, \field Second fuel type
671 2 : if (!lAlphaBlanks(16) && Alphas(16) != "NONE" &&
672 2 : (hybridUnitaryAC.secondFuel = static_cast<Constant::eFuel>(getEnumValue(Constant::eFuelNamesUC, Util::makeUPPER(Alphas(16))))) ==
673 : Constant::eFuel::Invalid) {
674 0 : ShowSevereInvalidKey(state, eoh, cAlphaFields(16), Alphas(16));
675 0 : ErrorsFound = true;
676 : }
677 :
678 : // A17, \field Third fuel type
679 2 : if (!lAlphaBlanks(17) && Alphas(17) != "NONE" &&
680 2 : (hybridUnitaryAC.thirdFuel = static_cast<Constant::eFuel>(getEnumValue(Constant::eFuelNamesUC, Util::makeUPPER(Alphas(17))))) ==
681 : Constant::eFuel::Invalid) {
682 0 : ShowSevereInvalidKey(state, eoh, cAlphaFields(17), Alphas(17));
683 0 : ErrorsFound = true;
684 : }
685 :
686 : // A18, \field Objective Function Minimizes
687 :
688 : // A19, \ OA requirement pointer
689 1 : if (!lAlphaBlanks(19)) {
690 1 : hybridUnitaryAC.OARequirementsPtr = Util::FindItemInList(Alphas(19), state.dataSize->OARequirements);
691 1 : if (hybridUnitaryAC.OARequirementsPtr == 0) {
692 0 : ShowSevereError(state, format("{}: {} = {} invalid data", routineName, cCurrentModuleObject, Alphas(1)));
693 0 : ShowContinueError(state, format("Invalid-not found {}=\"{}\".", cAlphaFields(19), Alphas(19)));
694 0 : ErrorsFound = true;
695 : } else {
696 1 : hybridUnitaryAC.OutdoorAir = true;
697 : }
698 : }
699 :
700 1 : int FirstModeAlphaNumber = 20;
701 1 : int NumberOfAlphasPerMode = 9;
702 1 : int Numberofoperatingmodes = 0;
703 7 : for (int i = FirstModeAlphaNumber; i <= NumAlphas; i = i + NumberOfAlphasPerMode) {
704 6 : if (!lAlphaBlanks(i)) {
705 6 : ++Numberofoperatingmodes;
706 : } else {
707 0 : break;
708 : }
709 : }
710 :
711 7 : for (int modeIter = 0; modeIter <= Numberofoperatingmodes - 1; ++modeIter) {
712 6 : ErrorsFound = hybridUnitaryAC.ParseMode(state, Alphas, cAlphaFields, Numbers, cNumericFields, lAlphaBlanks, cCurrentModuleObject);
713 6 : if (ErrorsFound) {
714 0 : ShowFatalError(state, format("{}: Errors found parsing modes", routineName));
715 0 : ShowContinueError(state, "... Preceding condition causes termination.");
716 0 : break;
717 : }
718 : }
719 : // add the ZoneHVAC:HybridUnitaryHVAC Scaled Maximum Supply Air Volume Flow Rate to the Component Sizing Report Summary
720 1 : BaseSizer::reportSizerOutput(state,
721 : cCurrentModuleObject,
722 : hybridUnitaryAC.Name,
723 : "Scaled Maximum Supply Air Volume Flow Rate [m3/s]",
724 : hybridUnitaryAC.ScaledSystemMaximumSupplyAirVolumeFlowRate);
725 : }
726 : }
727 :
728 : // setup output variables
729 2 : for (UnitLoop = 1; UnitLoop <= state.dataHybridUnitaryAC->NumZoneHybridEvap; ++UnitLoop) {
730 :
731 1 : auto &hybridUnitaryAC = state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitLoop);
732 :
733 2 : SetUpCompSets(state,
734 : cCurrentModuleObject,
735 : hybridUnitaryAC.Name,
736 : cCurrentModuleObject,
737 : hybridUnitaryAC.Name,
738 1 : state.dataLoopNodes->NodeID(hybridUnitaryAC.InletNode),
739 1 : state.dataLoopNodes->NodeID(hybridUnitaryAC.OutletNode));
740 :
741 2 : SetUpCompSets(state,
742 : cCurrentModuleObject,
743 : hybridUnitaryAC.Name,
744 : cCurrentModuleObject,
745 : hybridUnitaryAC.Name,
746 1 : state.dataLoopNodes->NodeID(hybridUnitaryAC.SecondaryInletNode),
747 1 : state.dataLoopNodes->NodeID(hybridUnitaryAC.SecondaryOutletNode));
748 :
749 2 : SetupOutputVariable(state,
750 : "Zone Hybrid Unitary HVAC System Total Cooling Rate",
751 : Constant::Units::W,
752 1 : hybridUnitaryAC.SystemTotalCoolingRate,
753 : OutputProcessor::TimeStepType::System,
754 : OutputProcessor::StoreType::Average,
755 1 : hybridUnitaryAC.Name);
756 2 : SetupOutputVariable(state,
757 : "Zone Hybrid Unitary HVAC System Total Cooling Energy",
758 : Constant::Units::J,
759 1 : hybridUnitaryAC.SystemTotalCoolingEnergy,
760 : OutputProcessor::TimeStepType::System,
761 : OutputProcessor::StoreType::Sum,
762 1 : hybridUnitaryAC.Name,
763 : Constant::eResource::EnergyTransfer,
764 : OutputProcessor::Group::HVAC,
765 : OutputProcessor::EndUseCat::CoolingCoils);
766 2 : SetupOutputVariable(state,
767 : "Zone Hybrid Unitary HVAC System Sensible Cooling Rate",
768 : Constant::Units::W,
769 1 : hybridUnitaryAC.SystemSensibleCoolingRate,
770 : OutputProcessor::TimeStepType::System,
771 : OutputProcessor::StoreType::Average,
772 1 : hybridUnitaryAC.Name);
773 2 : SetupOutputVariable(state,
774 : "Zone Hybrid Unitary HVAC System Sensible Cooling Energy",
775 : Constant::Units::J,
776 1 : hybridUnitaryAC.SystemSensibleCoolingEnergy,
777 : OutputProcessor::TimeStepType::System,
778 : OutputProcessor::StoreType::Sum,
779 1 : hybridUnitaryAC.Name);
780 2 : SetupOutputVariable(state,
781 : "Zone Hybrid Unitary HVAC System Latent Cooling Rate",
782 : Constant::Units::W,
783 1 : hybridUnitaryAC.SystemLatentCoolingRate,
784 : OutputProcessor::TimeStepType::System,
785 : OutputProcessor::StoreType::Average,
786 1 : hybridUnitaryAC.Name);
787 2 : SetupOutputVariable(state,
788 : "Zone Hybrid Unitary HVAC System Latent Cooling Energy",
789 : Constant::Units::J,
790 1 : hybridUnitaryAC.SystemLatentCoolingEnergy,
791 : OutputProcessor::TimeStepType::System,
792 : OutputProcessor::StoreType::Sum,
793 1 : hybridUnitaryAC.Name);
794 :
795 2 : SetupOutputVariable(state,
796 : "Zone Hybrid Unitary HVAC Zone Total Cooling Rate",
797 : Constant::Units::W,
798 1 : hybridUnitaryAC.UnitTotalCoolingRate,
799 : OutputProcessor::TimeStepType::System,
800 : OutputProcessor::StoreType::Average,
801 1 : hybridUnitaryAC.Name);
802 2 : SetupOutputVariable(state,
803 : "Zone Hybrid Unitary HVAC Zone Total Cooling Energy",
804 : Constant::Units::J,
805 1 : hybridUnitaryAC.UnitTotalCoolingEnergy,
806 : OutputProcessor::TimeStepType::System,
807 : OutputProcessor::StoreType::Sum,
808 1 : hybridUnitaryAC.Name);
809 2 : SetupOutputVariable(state,
810 : "Zone Hybrid Unitary HVAC Zone Sensible Cooling Rate",
811 : Constant::Units::W,
812 1 : hybridUnitaryAC.UnitSensibleCoolingRate,
813 : OutputProcessor::TimeStepType::System,
814 : OutputProcessor::StoreType::Average,
815 1 : hybridUnitaryAC.Name);
816 2 : SetupOutputVariable(state,
817 : "Zone Hybrid Unitary HVAC Zone Sensible Cooling Energy",
818 : Constant::Units::J,
819 1 : hybridUnitaryAC.UnitSensibleCoolingEnergy,
820 : OutputProcessor::TimeStepType::System,
821 : OutputProcessor::StoreType::Sum,
822 1 : hybridUnitaryAC.Name);
823 2 : SetupOutputVariable(state,
824 : "Zone Hybrid Unitary HVAC Zone Latent Cooling Rate",
825 : Constant::Units::W,
826 1 : hybridUnitaryAC.UnitLatentCoolingRate,
827 : OutputProcessor::TimeStepType::System,
828 : OutputProcessor::StoreType::Average,
829 1 : hybridUnitaryAC.Name);
830 2 : SetupOutputVariable(state,
831 : "Zone Hybrid Unitary HVAC Zone Latent Cooling Energy",
832 : Constant::Units::J,
833 1 : hybridUnitaryAC.UnitLatentCoolingEnergy,
834 : OutputProcessor::TimeStepType::System,
835 : OutputProcessor::StoreType::Sum,
836 1 : hybridUnitaryAC.Name);
837 :
838 2 : SetupOutputVariable(state,
839 : "Zone Hybrid Unitary HVAC System Total Heating Rate",
840 : Constant::Units::W,
841 1 : hybridUnitaryAC.SystemTotalHeatingRate,
842 : OutputProcessor::TimeStepType::System,
843 : OutputProcessor::StoreType::Average,
844 1 : hybridUnitaryAC.Name);
845 2 : SetupOutputVariable(state,
846 : "Zone Hybrid Unitary HVAC System Total Heating Energy",
847 : Constant::Units::J,
848 1 : hybridUnitaryAC.SystemTotalHeatingEnergy,
849 : OutputProcessor::TimeStepType::System,
850 : OutputProcessor::StoreType::Sum,
851 1 : hybridUnitaryAC.Name,
852 : Constant::eResource::EnergyTransfer,
853 : OutputProcessor::Group::HVAC,
854 : OutputProcessor::EndUseCat::HeatingCoils);
855 2 : SetupOutputVariable(state,
856 : "Zone Hybrid Unitary HVAC System Sensible Heating Rate",
857 : Constant::Units::W,
858 1 : hybridUnitaryAC.SystemSensibleHeatingRate,
859 : OutputProcessor::TimeStepType::System,
860 : OutputProcessor::StoreType::Average,
861 1 : hybridUnitaryAC.Name);
862 2 : SetupOutputVariable(state,
863 : "Zone Hybrid Unitary HVAC System Sensible Heating Energy",
864 : Constant::Units::J,
865 1 : hybridUnitaryAC.SystemSensibleHeatingEnergy,
866 : OutputProcessor::TimeStepType::System,
867 : OutputProcessor::StoreType::Sum,
868 1 : hybridUnitaryAC.Name);
869 2 : SetupOutputVariable(state,
870 : "Zone Hybrid Unitary HVAC System Latent Heating Rate",
871 : Constant::Units::W,
872 1 : hybridUnitaryAC.SystemLatentHeatingRate,
873 : OutputProcessor::TimeStepType::System,
874 : OutputProcessor::StoreType::Average,
875 1 : hybridUnitaryAC.Name);
876 2 : SetupOutputVariable(state,
877 : "Zone Hybrid Unitary HVAC System Latent Heating Energy",
878 : Constant::Units::J,
879 1 : hybridUnitaryAC.SystemLatentHeatingEnergy,
880 : OutputProcessor::TimeStepType::System,
881 : OutputProcessor::StoreType::Sum,
882 1 : hybridUnitaryAC.Name);
883 :
884 2 : SetupOutputVariable(state,
885 : "Zone Hybrid Unitary HVAC Zone Total Heating Rate",
886 : Constant::Units::W,
887 1 : hybridUnitaryAC.UnitTotalHeatingRate,
888 : OutputProcessor::TimeStepType::System,
889 : OutputProcessor::StoreType::Average,
890 1 : hybridUnitaryAC.Name);
891 2 : SetupOutputVariable(state,
892 : "Zone Hybrid Unitary HVAC Zone Total Heating Energy",
893 : Constant::Units::J,
894 1 : hybridUnitaryAC.UnitTotalHeatingEnergy,
895 : OutputProcessor::TimeStepType::System,
896 : OutputProcessor::StoreType::Sum,
897 1 : hybridUnitaryAC.Name);
898 2 : SetupOutputVariable(state,
899 : "Zone Hybrid Unitary HVAC Zone Sensible Heating Rate",
900 : Constant::Units::W,
901 1 : hybridUnitaryAC.UnitSensibleHeatingRate,
902 : OutputProcessor::TimeStepType::System,
903 : OutputProcessor::StoreType::Average,
904 1 : hybridUnitaryAC.Name);
905 2 : SetupOutputVariable(state,
906 : "Zone Hybrid Unitary HVAC Zone Sensible Heating Energy",
907 : Constant::Units::J,
908 1 : hybridUnitaryAC.UnitSensibleHeatingEnergy,
909 : OutputProcessor::TimeStepType::System,
910 : OutputProcessor::StoreType::Sum,
911 1 : hybridUnitaryAC.Name);
912 2 : SetupOutputVariable(state,
913 : "Zone Hybrid Unitary HVAC Zone Latent Heating Rate",
914 : Constant::Units::W,
915 1 : hybridUnitaryAC.UnitLatentHeatingRate,
916 : OutputProcessor::TimeStepType::System,
917 : OutputProcessor::StoreType::Average,
918 1 : hybridUnitaryAC.Name);
919 2 : SetupOutputVariable(state,
920 : "Zone Hybrid Unitary HVAC Zone Latent Heating Energy",
921 : Constant::Units::J,
922 1 : hybridUnitaryAC.UnitLatentHeatingEnergy,
923 : OutputProcessor::TimeStepType::System,
924 : OutputProcessor::StoreType::Sum,
925 1 : hybridUnitaryAC.Name);
926 :
927 2 : SetupOutputVariable(state,
928 : "Zone Hybrid Unitary HVAC Predicted Sensible Load to Setpoint Heat Transfer Rate",
929 : Constant::Units::W,
930 1 : hybridUnitaryAC.RequestedLoadToCoolingSetpoint,
931 : OutputProcessor::TimeStepType::System,
932 : OutputProcessor::StoreType::Average,
933 1 : hybridUnitaryAC.Name);
934 1 : SetupOutputVariable(state,
935 : "Zone Hybrid Unitary HVAC Error Code",
936 : Constant::Units::None,
937 1 : hybridUnitaryAC.ErrorCode,
938 : OutputProcessor::TimeStepType::System,
939 : OutputProcessor::StoreType::Average,
940 1 : hybridUnitaryAC.Name);
941 :
942 2 : SetupOutputVariable(state,
943 : "Zone Hybrid Unitary HVAC Supply Air Temperature",
944 : Constant::Units::C,
945 1 : hybridUnitaryAC.OutletTemp,
946 : OutputProcessor::TimeStepType::System,
947 : OutputProcessor::StoreType::Average,
948 1 : hybridUnitaryAC.Name);
949 2 : SetupOutputVariable(state,
950 : "Zone Hybrid Unitary HVAC Return Air Temperature",
951 : Constant::Units::C,
952 1 : hybridUnitaryAC.InletTemp,
953 : OutputProcessor::TimeStepType::System,
954 : OutputProcessor::StoreType::Average,
955 1 : hybridUnitaryAC.Name);
956 2 : SetupOutputVariable(state,
957 : "Zone Hybrid Unitary HVAC Outdoor Air Temperature",
958 : Constant::Units::C,
959 1 : hybridUnitaryAC.SecInletTemp,
960 : OutputProcessor::TimeStepType::System,
961 : OutputProcessor::StoreType::Average,
962 1 : hybridUnitaryAC.Name);
963 2 : SetupOutputVariable(state,
964 : "Zone Hybrid Unitary HVAC Relief Air Temperature",
965 : Constant::Units::C,
966 1 : hybridUnitaryAC.SecOutletTemp,
967 : OutputProcessor::TimeStepType::System,
968 : OutputProcessor::StoreType::Average,
969 1 : hybridUnitaryAC.Name);
970 :
971 2 : SetupOutputVariable(state,
972 : "Zone Hybrid Unitary HVAC Supply Air Humidity Ratio",
973 : Constant::Units::kgWater_kgDryAir,
974 1 : hybridUnitaryAC.OutletHumRat,
975 : OutputProcessor::TimeStepType::System,
976 : OutputProcessor::StoreType::Average,
977 1 : hybridUnitaryAC.Name);
978 2 : SetupOutputVariable(state,
979 : "Zone Hybrid Unitary HVAC Return Air Humidity Ratio",
980 : Constant::Units::kgWater_kgDryAir,
981 1 : hybridUnitaryAC.InletHumRat,
982 : OutputProcessor::TimeStepType::System,
983 : OutputProcessor::StoreType::Average,
984 1 : hybridUnitaryAC.Name);
985 2 : SetupOutputVariable(state,
986 : "Zone Hybrid Unitary HVAC Outdoor Air Humidity Ratio",
987 : Constant::Units::kgWater_kgDryAir,
988 1 : hybridUnitaryAC.SecInletHumRat,
989 : OutputProcessor::TimeStepType::System,
990 : OutputProcessor::StoreType::Average,
991 1 : hybridUnitaryAC.Name);
992 2 : SetupOutputVariable(state,
993 : "Zone Hybrid Unitary HVAC Relief Air Humidity Ratio",
994 : Constant::Units::kgWater_kgDryAir,
995 1 : hybridUnitaryAC.SecOutletHumRat,
996 : OutputProcessor::TimeStepType::System,
997 : OutputProcessor::StoreType::Average,
998 1 : hybridUnitaryAC.Name);
999 :
1000 2 : SetupOutputVariable(state,
1001 : "Zone Hybrid Unitary HVAC Supply Air Relative Humidity",
1002 : Constant::Units::Perc,
1003 1 : hybridUnitaryAC.OutletRH,
1004 : OutputProcessor::TimeStepType::System,
1005 : OutputProcessor::StoreType::Average,
1006 1 : hybridUnitaryAC.Name);
1007 2 : SetupOutputVariable(state,
1008 : "Zone Hybrid Unitary HVAC Return Air Relative Humidity",
1009 : Constant::Units::Perc,
1010 1 : hybridUnitaryAC.InletRH,
1011 : OutputProcessor::TimeStepType::System,
1012 : OutputProcessor::StoreType::Average,
1013 1 : hybridUnitaryAC.Name);
1014 2 : SetupOutputVariable(state,
1015 : "Zone Hybrid Unitary HVAC Outdoor Air Relative Humidity",
1016 : Constant::Units::Perc,
1017 1 : hybridUnitaryAC.SecInletRH,
1018 : OutputProcessor::TimeStepType::System,
1019 : OutputProcessor::StoreType::Average,
1020 1 : hybridUnitaryAC.Name);
1021 2 : SetupOutputVariable(state,
1022 : "Zone Hybrid Unitary HVAC Relief Air Relative Humidity",
1023 : Constant::Units::Perc,
1024 1 : hybridUnitaryAC.SecOutletRH,
1025 : OutputProcessor::TimeStepType::System,
1026 : OutputProcessor::StoreType::Average,
1027 1 : hybridUnitaryAC.Name);
1028 :
1029 2 : SetupOutputVariable(state,
1030 : "Zone Hybrid Unitary HVAC Supply Air Mass Flow Rate",
1031 : Constant::Units::kg_s,
1032 1 : hybridUnitaryAC.OutletMassFlowRate,
1033 : OutputProcessor::TimeStepType::System,
1034 : OutputProcessor::StoreType::Average,
1035 1 : hybridUnitaryAC.Name);
1036 2 : SetupOutputVariable(state,
1037 : "Zone Hybrid Unitary HVAC Supply Air Standard Density Volume Flow Rate",
1038 : Constant::Units::m3_s,
1039 1 : hybridUnitaryAC.OutletVolumetricFlowRate,
1040 : OutputProcessor::TimeStepType::System,
1041 : OutputProcessor::StoreType::Average,
1042 1 : hybridUnitaryAC.Name);
1043 2 : SetupOutputVariable(state,
1044 : "Zone Hybrid Unitary HVAC Return Air Mass Flow Rate",
1045 : Constant::Units::kg_s,
1046 1 : hybridUnitaryAC.InletMassFlowRate,
1047 : OutputProcessor::TimeStepType::System,
1048 : OutputProcessor::StoreType::Average,
1049 1 : hybridUnitaryAC.Name);
1050 2 : SetupOutputVariable(state,
1051 : "Zone Hybrid Unitary HVAC Return Air Standard Density Volume Flow Rate",
1052 : Constant::Units::m3_s,
1053 1 : hybridUnitaryAC.InletVolumetricFlowRate,
1054 : OutputProcessor::TimeStepType::System,
1055 : OutputProcessor::StoreType::Average,
1056 1 : hybridUnitaryAC.Name);
1057 2 : SetupOutputVariable(state,
1058 : "Zone Hybrid Unitary HVAC Relief Air Mass Flow Rate",
1059 : Constant::Units::kg_s,
1060 1 : hybridUnitaryAC.SecOutletMassFlowRate,
1061 : OutputProcessor::TimeStepType::System,
1062 : OutputProcessor::StoreType::Average,
1063 1 : hybridUnitaryAC.Name);
1064 2 : SetupOutputVariable(state,
1065 : "Zone Hybrid Unitary HVAC Relief Air Standard Density Volume Flow Rate",
1066 : Constant::Units::m3_s,
1067 1 : hybridUnitaryAC.SecOutletVolumetricFlowRate,
1068 : OutputProcessor::TimeStepType::System,
1069 : OutputProcessor::StoreType::Average,
1070 1 : hybridUnitaryAC.Name);
1071 2 : SetupOutputVariable(state,
1072 : "Zone Hybrid Unitary HVAC Ventilation Air Standard Density Volume Flow Rate",
1073 : Constant::Units::m3_s,
1074 1 : hybridUnitaryAC.SupplyVentilationVolume,
1075 : OutputProcessor::TimeStepType::System,
1076 : OutputProcessor::StoreType::Average,
1077 1 : hybridUnitaryAC.Name);
1078 2 : SetupOutputVariable(state,
1079 : "Zone Hybrid Unitary HVAC Electricity Rate",
1080 : Constant::Units::W,
1081 1 : hybridUnitaryAC.FinalElectricalPower,
1082 : OutputProcessor::TimeStepType::System,
1083 : OutputProcessor::StoreType::Average,
1084 1 : hybridUnitaryAC.Name);
1085 2 : SetupOutputVariable(state,
1086 : "Zone Hybrid Unitary HVAC Electricity Energy",
1087 : Constant::Units::J,
1088 1 : hybridUnitaryAC.FinalElectricalEnergy,
1089 : OutputProcessor::TimeStepType::System,
1090 : OutputProcessor::StoreType::Sum,
1091 1 : hybridUnitaryAC.Name,
1092 : Constant::eResource::Electricity,
1093 : OutputProcessor::Group::HVAC,
1094 : OutputProcessor::EndUseCat::Cooling,
1095 : "Hybrid HVAC Cooling");
1096 :
1097 2 : SetupOutputVariable(state,
1098 : "Zone Hybrid Unitary HVAC Requested Outdoor Air Ventilation Mass Flow Rate",
1099 : Constant::Units::kg_s,
1100 1 : hybridUnitaryAC.MinOA_Msa,
1101 : OutputProcessor::TimeStepType::System,
1102 : OutputProcessor::StoreType::Average,
1103 1 : hybridUnitaryAC.Name);
1104 2 : SetupOutputVariable(state,
1105 : "Zone Hybrid Unitary HVAC Ventilation Air Mass Flow Rate",
1106 : Constant::Units::kg_s,
1107 1 : hybridUnitaryAC.SupplyVentilationAir,
1108 : OutputProcessor::TimeStepType::System,
1109 : OutputProcessor::StoreType::Average,
1110 1 : hybridUnitaryAC.Name);
1111 1 : SetupOutputVariable(state,
1112 : "Zone Hybrid Unitary HVAC Availability Status",
1113 : Constant::Units::None,
1114 1 : hybridUnitaryAC.UnitOn,
1115 : OutputProcessor::TimeStepType::System,
1116 : OutputProcessor::StoreType::Average,
1117 1 : hybridUnitaryAC.Name);
1118 2 : SetupOutputVariable(state,
1119 : "Zone Hybrid Unitary HVAC Outdoor Air Fraction",
1120 : Constant::Units::None,
1121 1 : hybridUnitaryAC.averageOSAF,
1122 : OutputProcessor::TimeStepType::System,
1123 : OutputProcessor::StoreType::Average,
1124 1 : hybridUnitaryAC.Name);
1125 :
1126 2 : SetupOutputVariable(state,
1127 : "Zone Hybrid Unitary HVAC Dehumidification Load to Humidistat Setpoint Moisture Transfer Rate",
1128 : Constant::Units::kg_s,
1129 1 : hybridUnitaryAC.RequestedDeHumdificationMass,
1130 : OutputProcessor::TimeStepType::System,
1131 : OutputProcessor::StoreType::Average,
1132 1 : hybridUnitaryAC.Name);
1133 2 : SetupOutputVariable(state,
1134 : "Zone Hybrid Unitary HVAC Dehumidification Load to Humidistat Setpoint Heat Transfer Rate",
1135 : Constant::Units::W,
1136 1 : hybridUnitaryAC.RequestedDeHumdificationLoad,
1137 : OutputProcessor::TimeStepType::System,
1138 : OutputProcessor::StoreType::Average,
1139 1 : hybridUnitaryAC.Name);
1140 2 : SetupOutputVariable(state,
1141 : "Zone Hybrid Unitary HVAC DehumidificationLoad to Humidistat Setpoint Heat Tansfer Energy",
1142 : Constant::Units::J,
1143 1 : hybridUnitaryAC.RequestedDeHumdificationEnergy,
1144 : OutputProcessor::TimeStepType::System,
1145 : OutputProcessor::StoreType::Average,
1146 1 : hybridUnitaryAC.Name);
1147 :
1148 2 : SetupOutputVariable(state,
1149 : "Zone Hybrid Unitary HVAC Humidification Load to Humidistat Setpoint Moisture Transfer Rate",
1150 : Constant::Units::kg_s,
1151 1 : hybridUnitaryAC.RequestedHumdificationMass,
1152 : OutputProcessor::TimeStepType::System,
1153 : OutputProcessor::StoreType::Average,
1154 1 : hybridUnitaryAC.Name);
1155 2 : SetupOutputVariable(state,
1156 : "Zone Hybrid Unitary HVAC Humidification Load to Humidistat Setpoint Heat Transfer Rate",
1157 : Constant::Units::W,
1158 1 : hybridUnitaryAC.RequestedHumdificationLoad,
1159 : OutputProcessor::TimeStepType::System,
1160 : OutputProcessor::StoreType::Average,
1161 1 : hybridUnitaryAC.Name);
1162 2 : SetupOutputVariable(state,
1163 : "Zone Hybrid Unitary HVAC Humidification Load to Humidistat Setpoint Heat Tansfer Energy",
1164 : Constant::Units::J,
1165 1 : hybridUnitaryAC.RequestedHumdificationEnergy,
1166 : OutputProcessor::TimeStepType::System,
1167 : OutputProcessor::StoreType::Average,
1168 1 : hybridUnitaryAC.Name);
1169 :
1170 2 : SetupOutputVariable(state,
1171 : "Zone Hybrid Unitary HVAC Supply Fan Electricity Rate",
1172 : Constant::Units::W,
1173 1 : hybridUnitaryAC.SupplyFanElectricPower,
1174 : OutputProcessor::TimeStepType::System,
1175 : OutputProcessor::StoreType::Average,
1176 1 : hybridUnitaryAC.Name);
1177 2 : SetupOutputVariable(state,
1178 : "Zone Hybrid Unitary HVAC Supply Fan Electricity Energy",
1179 : Constant::Units::J,
1180 1 : hybridUnitaryAC.SupplyFanElectricEnergy,
1181 : OutputProcessor::TimeStepType::System,
1182 : OutputProcessor::StoreType::Sum,
1183 1 : hybridUnitaryAC.Name,
1184 : Constant::eResource::Electricity,
1185 : OutputProcessor::Group::HVAC,
1186 : OutputProcessor::EndUseCat::Fans,
1187 : "Hybrid HVAC Fans");
1188 1 : if (hybridUnitaryAC.secondFuel != Constant::eFuel::Invalid) {
1189 2 : SetupOutputVariable(state,
1190 : "Zone Hybrid Unitary HVAC Secondary Fuel Consumption Rate",
1191 : Constant::Units::W,
1192 1 : hybridUnitaryAC.SecondaryFuelConsumptionRate,
1193 : OutputProcessor::TimeStepType::System,
1194 : OutputProcessor::StoreType::Average,
1195 1 : hybridUnitaryAC.Name);
1196 2 : SetupOutputVariable(state,
1197 : "Zone Hybrid Unitary HVAC Secondary Fuel Consumption",
1198 : Constant::Units::J,
1199 1 : hybridUnitaryAC.SecondaryFuelConsumption,
1200 : OutputProcessor::TimeStepType::System,
1201 : OutputProcessor::StoreType::Sum,
1202 1 : hybridUnitaryAC.Name,
1203 1 : Constant::eFuel2eResource[(int)hybridUnitaryAC.secondFuel],
1204 : OutputProcessor::Group::HVAC,
1205 : OutputProcessor::EndUseCat::Cooling,
1206 : "Hybrid HVAC Cooling");
1207 : }
1208 1 : if (hybridUnitaryAC.thirdFuel != Constant::eFuel::Invalid) {
1209 2 : SetupOutputVariable(state,
1210 : "Zone Hybrid Unitary HVAC Third Fuel Consumption Rate",
1211 : Constant::Units::W,
1212 1 : hybridUnitaryAC.ThirdFuelConsumptionRate,
1213 : OutputProcessor::TimeStepType::System,
1214 : OutputProcessor::StoreType::Average,
1215 1 : hybridUnitaryAC.Name);
1216 2 : SetupOutputVariable(state,
1217 : "Zone Hybrid Unitary HVAC Third Fuel Consumption",
1218 : Constant::Units::J,
1219 1 : hybridUnitaryAC.ThirdFuelConsumption,
1220 : OutputProcessor::TimeStepType::System,
1221 : OutputProcessor::StoreType::Sum,
1222 1 : hybridUnitaryAC.Name,
1223 1 : Constant::eFuel2eResource[(int)hybridUnitaryAC.thirdFuel],
1224 : OutputProcessor::Group::HVAC,
1225 : OutputProcessor::EndUseCat::Cooling,
1226 : "Hybrid HVAC Cooling");
1227 : }
1228 2 : SetupOutputVariable(state,
1229 : "Zone Hybrid Unitary HVAC Water Consumption Rate",
1230 : Constant::Units::kgWater_s,
1231 1 : hybridUnitaryAC.WaterConsumptionRate,
1232 : OutputProcessor::TimeStepType::System,
1233 : OutputProcessor::StoreType::Average,
1234 1 : hybridUnitaryAC.Name);
1235 2 : SetupOutputVariable(state,
1236 : "Zone Hybrid Unitary HVAC Water Consumption",
1237 : Constant::Units::m3,
1238 1 : hybridUnitaryAC.WaterConsumption,
1239 : OutputProcessor::TimeStepType::System,
1240 : OutputProcessor::StoreType::Sum,
1241 1 : hybridUnitaryAC.Name,
1242 : Constant::eResource::Water,
1243 : OutputProcessor::Group::HVAC,
1244 : OutputProcessor::EndUseCat::Cooling,
1245 : "Hybrid HVAC Cooling");
1246 2 : SetupOutputVariable(state,
1247 : "Zone Hybrid Unitary HVAC External Static Pressure",
1248 : Constant::Units::Pa,
1249 1 : hybridUnitaryAC.ExternalStaticPressure,
1250 : OutputProcessor::TimeStepType::System,
1251 : OutputProcessor::StoreType::Average,
1252 1 : hybridUnitaryAC.Name);
1253 :
1254 1 : if (hybridUnitaryAC.FanHeatGain) {
1255 0 : SetupOutputVariable(state,
1256 : "Zone Hybrid Unitary HVAC Fan Rise in Air Temperature",
1257 : Constant::Units::deltaC,
1258 0 : hybridUnitaryAC.FanHeatTemp,
1259 : OutputProcessor::TimeStepType::System,
1260 : OutputProcessor::StoreType::Average,
1261 0 : hybridUnitaryAC.Name);
1262 0 : SetupOutputVariable(state,
1263 : "Zone Hybrid Unitary HVAC Fan Heat Gain to Air",
1264 : Constant::Units::W,
1265 0 : hybridUnitaryAC.PowerLossToAir,
1266 : OutputProcessor::TimeStepType::System,
1267 : OutputProcessor::StoreType::Average,
1268 0 : hybridUnitaryAC.Name);
1269 : }
1270 :
1271 1 : int index = 0;
1272 :
1273 6 : for (auto &thisSetting : hybridUnitaryAC.CurrentOperatingSettings) {
1274 15 : SetupOutputVariable(state,
1275 10 : format("Zone Hybrid Unitary HVAC Runtime Fraction in Setting {}", index),
1276 : Constant::Units::None,
1277 5 : thisSetting.Runtime_Fraction,
1278 : OutputProcessor::TimeStepType::Zone,
1279 : OutputProcessor::StoreType::Average,
1280 5 : hybridUnitaryAC.Name);
1281 15 : SetupOutputVariable(state,
1282 10 : format("Zone Hybrid Unitary HVAC Mode in Setting {}", index),
1283 : Constant::Units::None,
1284 5 : thisSetting.Mode,
1285 : OutputProcessor::TimeStepType::Zone,
1286 : OutputProcessor::StoreType::Average,
1287 5 : hybridUnitaryAC.Name);
1288 15 : SetupOutputVariable(state,
1289 10 : format("Zone Hybrid Unitary HVAC Outdoor Air Fraction in Setting {}", index),
1290 : Constant::Units::kg_s,
1291 5 : thisSetting.Outdoor_Air_Fraction,
1292 : OutputProcessor::TimeStepType::Zone,
1293 : OutputProcessor::StoreType::Average,
1294 5 : hybridUnitaryAC.Name);
1295 15 : SetupOutputVariable(state,
1296 10 : format("Zone Hybrid Unitary HVAC Supply Air Mass Flow Rate in Setting {}", index),
1297 : Constant::Units::kg_s,
1298 5 : thisSetting.Unscaled_Supply_Air_Mass_Flow_Rate,
1299 : OutputProcessor::TimeStepType::Zone,
1300 : OutputProcessor::StoreType::Average,
1301 5 : hybridUnitaryAC.Name);
1302 15 : SetupOutputVariable(state,
1303 10 : format("Zone Hybrid Unitary HVAC Supply Air Mass Flow Rate Ratio in Setting {}", index),
1304 : Constant::Units::None,
1305 5 : thisSetting.Supply_Air_Mass_Flow_Rate_Ratio,
1306 : OutputProcessor::TimeStepType::Zone,
1307 : OutputProcessor::StoreType::Average,
1308 5 : hybridUnitaryAC.Name);
1309 5 : index++;
1310 1 : }
1311 : }
1312 1 : Errors = ErrorsFound;
1313 1 : if (ErrorsFound) {
1314 0 : ShowFatalError(state, format("{}: Errors found in getting input.", routineName));
1315 0 : ShowContinueError(state, "... Preceding condition causes termination.");
1316 : }
1317 1 : }
1318 771 : int GetHybridUnitaryACOutAirNode(EnergyPlusData &state, int const CompNum)
1319 : {
1320 771 : bool errorsfound = false;
1321 771 : if (state.dataHybridUnitaryAC->GetInputZoneHybridEvap) {
1322 0 : GetInputZoneHybridUnitaryAirConditioners(state, errorsfound);
1323 0 : state.dataHybridUnitaryAC->GetInputZoneHybridEvap = false;
1324 : }
1325 :
1326 : int GetHybridUnitaryACOutAirNode;
1327 771 : GetHybridUnitaryACOutAirNode = 0;
1328 771 : if (CompNum > 0 && CompNum <= state.dataHybridUnitaryAC->NumZoneHybridEvap) {
1329 771 : GetHybridUnitaryACOutAirNode = state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(CompNum).SecondaryInletNode;
1330 : }
1331 :
1332 771 : return GetHybridUnitaryACOutAirNode;
1333 : }
1334 :
1335 771 : int GetHybridUnitaryACZoneInletNode(EnergyPlusData &state, int const CompNum)
1336 : {
1337 771 : bool errorsfound = false;
1338 771 : if (state.dataHybridUnitaryAC->GetInputZoneHybridEvap) {
1339 0 : GetInputZoneHybridUnitaryAirConditioners(state, errorsfound);
1340 0 : state.dataHybridUnitaryAC->GetInputZoneHybridEvap = false;
1341 : }
1342 :
1343 : int GetHybridUnitaryACZoneInletNode;
1344 771 : GetHybridUnitaryACZoneInletNode = 0;
1345 771 : if (CompNum > 0 && CompNum <= state.dataHybridUnitaryAC->NumZoneHybridEvap) {
1346 771 : GetHybridUnitaryACZoneInletNode = state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(CompNum).OutletNode;
1347 : }
1348 :
1349 771 : return GetHybridUnitaryACZoneInletNode;
1350 : }
1351 :
1352 771 : int GetHybridUnitaryACReturnAirNode(EnergyPlusData &state, int const CompNum)
1353 : {
1354 771 : bool errorsfound = false;
1355 771 : if (state.dataHybridUnitaryAC->GetInputZoneHybridEvap) {
1356 0 : GetInputZoneHybridUnitaryAirConditioners(state, errorsfound);
1357 0 : state.dataHybridUnitaryAC->GetInputZoneHybridEvap = false;
1358 : }
1359 :
1360 : int GetHybridUnitaryACReturnAirNode;
1361 771 : GetHybridUnitaryACReturnAirNode = 0;
1362 771 : if (CompNum > 0 && CompNum <= state.dataHybridUnitaryAC->NumZoneHybridEvap) {
1363 771 : GetHybridUnitaryACReturnAirNode = state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(CompNum).InletNode;
1364 : }
1365 :
1366 771 : return GetHybridUnitaryACReturnAirNode;
1367 : }
1368 :
1369 0 : int getHybridUnitaryACIndex(EnergyPlusData &state, std::string_view CompName)
1370 : {
1371 0 : bool errFlag = false;
1372 0 : if (state.dataHybridUnitaryAC->GetInputZoneHybridEvap) {
1373 0 : GetInputZoneHybridUnitaryAirConditioners(state, errFlag);
1374 0 : state.dataHybridUnitaryAC->GetInputZoneHybridEvap = false;
1375 : }
1376 :
1377 0 : for (int UnitLoop = 1; UnitLoop <= state.dataHybridUnitaryAC->NumZoneHybridEvap; ++UnitLoop) {
1378 0 : if (Util::SameString(state.dataHybridUnitaryAC->ZoneHybridUnitaryAirConditioner(UnitLoop).Name, CompName)) {
1379 0 : return UnitLoop;
1380 : }
1381 : }
1382 :
1383 0 : return 0;
1384 : }
1385 :
1386 : //*****************************************************************************************
1387 :
1388 : } // namespace EnergyPlus::HybridUnitaryAirConditioners
|
