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