Line data Source code
1 : // EnergyPlus, Copyright (c) 1996-2023, The Board of Trustees of the University of Illinois,
2 : // The Regents of the University of California, through Lawrence Berkeley National Laboratory
3 : // (subject to receipt of any required approvals from the U.S. Dept. of Energy), Oak Ridge
4 : // National Laboratory, managed by UT-Battelle, Alliance for Sustainable Energy, LLC, and other
5 : // contributors. All rights reserved.
6 : //
7 : // NOTICE: This Software was developed under funding from the U.S. Department of Energy and the
8 : // U.S. Government consequently retains certain rights. As such, the U.S. Government has been
9 : // granted for itself and others acting on its behalf a paid-up, nonexclusive, irrevocable,
10 : // worldwide license in the Software to reproduce, distribute copies to the public, prepare
11 : // derivative works, and perform publicly and display publicly, and to permit others to do so.
12 : //
13 : // Redistribution and use in source and binary forms, with or without modification, are permitted
14 : // provided that the following conditions are met:
15 : //
16 : // (1) Redistributions of source code must retain the above copyright notice, this list of
17 : // conditions and the following disclaimer.
18 : //
19 : // (2) Redistributions in binary form must reproduce the above copyright notice, this list of
20 : // conditions and the following disclaimer in the documentation and/or other materials
21 : // provided with the distribution.
22 : //
23 : // (3) Neither the name of the University of California, Lawrence Berkeley National Laboratory,
24 : // the University of Illinois, U.S. Dept. of Energy nor the names of its contributors may be
25 : // used to endorse or promote products derived from this software without specific prior
26 : // written permission.
27 : //
28 : // (4) Use of EnergyPlus(TM) Name. If Licensee (i) distributes the software in stand-alone form
29 : // without changes from the version obtained under this License, or (ii) Licensee makes a
30 : // reference solely to the software portion of its product, Licensee must refer to the
31 : // software as "EnergyPlus version X" software, where "X" is the version number Licensee
32 : // obtained under this License and may not use a different name for the software. Except as
33 : // specifically required in this Section (4), Licensee shall not use in a company name, a
34 : // product name, in advertising, publicity, or other promotional activities any name, trade
35 : // name, trademark, logo, or other designation of "EnergyPlus", "E+", "e+" or confusingly
36 : // similar designation, without the U.S. Department of Energy's prior written consent.
37 : //
38 : // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
39 : // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
40 : // AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
41 : // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
42 : // CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
43 : // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
44 : // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
45 : // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
46 : // POSSIBILITY OF SUCH DAMAGE.
47 :
48 : #ifndef Construction_hh_INCLUDED
49 : #define Construction_hh_INCLUDED
50 :
51 : // EnergyPlus Headers
52 : #include <EnergyPlus/Data/BaseData.hh>
53 : #include <EnergyPlus/DataBSDFWindow.hh>
54 : #include <EnergyPlus/DataHeatBalance.hh>
55 : #include <EnergyPlus/DataSurfaces.hh>
56 : #include <EnergyPlus/DataWindowEquivalentLayer.hh>
57 : #include <EnergyPlus/EnergyPlus.hh>
58 :
59 : namespace EnergyPlus {
60 :
61 : // Forward declarations
62 : struct EnergyPlusData;
63 :
64 : namespace Construction {
65 :
66 : int constexpr MaxLayersInConstruct(11); // Maximum number of layers allowed in a single construction
67 : int constexpr MaxCTFTerms(19); // Maximum number of CTF terms allowed to still allow stability
68 : // Note Sync with SurfaceGroundHeatExchanger::local::MaxCTFTerms
69 : // ** has to be big enough to hold no matter what window model
70 : // each window model should validate layers individually
71 : int constexpr MaxSpectralDataElements(800); // Maximum number in Spectral Data arrays.
72 :
73 13677 : struct ConstructionProps
74 : {
75 : // Members
76 : std::string Name; // Name of construction
77 : int TotLayers = 0; // Total number of layers for the construction; for windows
78 : // this is the total of the glass, gas and shade layers
79 : int TotSolidLayers = 0; // Total number of solid (glass or shade) layers (windows only)
80 : int TotGlassLayers = 0; // Total number of glass layers (windows only)
81 : Array1D_int LayerPoint; // Pointer array which refers back to
82 : // the Material structure; LayerPoint(i)=j->Material(j)%Name,etc
83 : bool IsUsed = false; // Marked true when the construction is used
84 : bool IsUsedCTF = false; // Mark true when the construction is used for a surface with CTF calculations
85 : Real64 InsideAbsorpVis = 0.0; // Inside Layer visible absorptance of an opaque surface; not used for windows.
86 : Real64 OutsideAbsorpVis = 0.0; // Outside Layer visible absorptance of an opaque surface; not used for windows.
87 : Real64 InsideAbsorpSolar = 0.0; // Inside Layer solar absorptance of an opaque surface; not used for windows.
88 : Real64 OutsideAbsorpSolar = 0.0; // Outside Layer solar absorptance of an opaque surface; not used for windows.
89 : Real64 InsideAbsorpThermal = 0.0; // Inside Layer Thermal absorptance for opaque surfaces or windows;
90 : // for windows, applies to innermost glass layer
91 : Real64 OutsideAbsorpThermal = 0.0; // Outside Layer Thermal absorptance
92 : DataSurfaces::SurfaceRoughness OutsideRoughness = DataSurfaces::SurfaceRoughness::Invalid; // Outside Surface roughness index
93 : int DayltPropPtr = 0; // Pointer to Daylight Construction Properties
94 : int W5FrameDivider = 0; // FrameDivider number for window construction from Window5 data file;
95 : // zero is construction not from Window5 file or Window5 construction has no frame.
96 : // Conductive properties for the construction
97 : Array1D<Real64> CTFCross; // Cross or Y terms of the CTF equation
98 : Array1D<Real64> CTFFlux; // Flux history terms of the CTF equation
99 : Array1D<Real64> CTFInside; // Inside or Z terms of the CTF equation
100 : Array1D<Real64> CTFOutside; // Outside or X terms of the CTF equation
101 : Array1D<Real64> CTFSourceIn; // Heat source/sink inside terms of CTF equation
102 : Array1D<Real64> CTFSourceOut; // Heat source/sink outside terms of CTF equation
103 : Real64 CTFTimeStep; // Time increment for stable simulation of construct (could be greater than TimeStep)
104 : // The next three series of terms are used to calculate the temperature at the location of a source/sink
105 : // in the QTF formulation. This calculation is necessary to allow the proper simulation of a
106 : // radiant system.
107 : Array1D<Real64> CTFTSourceOut; // Outside terms of the CTF equation for interior temp
108 : // calc@source location
109 : Array1D<Real64> CTFTSourceIn; // Inside terms of the CTF equation for interior temp
110 : // calc@source location
111 : Array1D<Real64> CTFTSourceQ; // Source/sink terms of the CTF equation for interior temp
112 : // calc@source location
113 : // The next three series of terms are used to calculate the temperature at a location specified by the user.
114 : // This location must be between two layers and is intended to allow the user to evaluate whether or not
115 : // condensation is a possibility between material layers.
116 : Array1D<Real64> CTFTUserOut; // Outside terms of the CTF equation for interior temp
117 : // calc@user location
118 : Array1D<Real64> CTFTUserIn; // Inside terms of the CTF equation for interior temp
119 : // calc@user location
120 : Array1D<Real64> CTFTUserSource; // Source/sink terms of the CTF equation for interior temp
121 : // calc@user location
122 : int NumHistories = 0; // CTFTimeStep/TimeStepZone or the number of temp/flux history series
123 : // for the construction
124 : int NumCTFTerms = 0; // Number of CTF terms for this construction (not including terms at current time)
125 : Real64 UValue = 0.0; // Overall heat transfer coefficient for the construction
126 : int SolutionDimensions = 0; // Number of dimensions in the solution (1 for normal constructions,
127 : // 1 or 2 for constructions with sources or sinks)-->may allow 3-D later?
128 : int SourceAfterLayer = 0; // Source/sink is present after this layer in the construction
129 : int TempAfterLayer = 0; // User is requesting a temperature calculation after this layer in the construction
130 : // This location is also the position of a temperature on the interior of a slab
131 : // that could be used to control a low temperature radiant system
132 : Real64 ThicknessPerpend = 0.0; // Thickness between planes of symmetry in the direction
133 : // perpendicular to the main direction of heat transfer
134 : // (same as half the distance between tubes)
135 : Real64 userTemperatureLocationPerpendicular = 0.0; // Location of the source perpendicular to the main direction
136 : // of heat transfer. Used in conjunction with the TempAfterLayer
137 : // term to provide specific location of user defined temperature.
138 : // This value is only used when SolutionDimension = 2.
139 : // Moisture Transfer Functions term belong here as well
140 : // BLAST detailed solar model parameters
141 : Real64 AbsDiffIn = 0.0; // Inner absorptance coefficient for diffuse radiation
142 : Real64 AbsDiffOut = 0.0; // Outer absorptance coefficient for diffuse radiation
143 : // Variables for window constructions
144 : Array1D<Real64> AbsDiff; // Diffuse solar absorptance for each glass layer,
145 : // bare glass or shade on
146 : Array2D<Real64> BlAbsDiff; // Diffuse solar absorptance for each glass layer vs.
147 : // slat angle, blind on
148 : Array2D<Real64> BlAbsDiffGnd; // Diffuse ground solar absorptance for each glass layer
149 : // vs. slat angle, blind on
150 : Array2D<Real64> BlAbsDiffSky; // Diffuse sky solar absorptance for each glass layer
151 : // vs. slat angle, blind on
152 : Array1D<Real64> AbsDiffBack; // Diffuse back solar absorptance for each glass layer
153 : Array2D<Real64> BlAbsDiffBack; // Diffuse back solar absorptance for each glass layer,
154 : // vs. slat angle, blind on
155 : Real64 AbsDiffShade = 0.0; // Diffuse solar absorptance for shade
156 : Array1D<Real64> AbsDiffBlind; // Diffuse solar absorptance for blind, vs. slat angle
157 : Array1D<Real64> AbsDiffBlindGnd; // Diffuse ground solar absorptance for blind, vs. slat angle
158 : Array1D<Real64> AbsDiffBlindSky; // Diffuse sky solar absorptance for blind, vs. slat angle
159 : Real64 AbsDiffBackShade = 0.0; // Diffuse back solar absorptance for shade
160 : Array1D<Real64> AbsDiffBackBlind; // Diffuse back solar absorptance for blind, vs. slat angle
161 : Real64 ShadeAbsorpThermal = 0.0; // Diffuse back thermal absorptance of shade
162 : Array1D<Array1D<Real64>> AbsBeamCoef; // Coefficients of incidence-angle polynomial for solar
163 : // absorptance for each solid glazing layer
164 : Array1D<Array1D<Real64>> AbsBeamBackCoef; // As for AbsBeamCoef but for back-incident solar
165 : Array1D<Real64> AbsBeamShadeCoef; // Coefficients of incidence-angle polynomial for solar
166 : // absorptance of shade
167 : Real64 TransDiff = 0.0; // Diffuse solar transmittance, bare glass or shade on
168 : Array1D<Real64> BlTransDiff; // Diffuse solar transmittance, blind present, vs. slat angle
169 : Array1D<Real64> BlTransDiffGnd; // Ground diffuse solar transmittance, blind present, vs. slat angle
170 : Array1D<Real64> BlTransDiffSky; // Sky diffuse solar transmittance, blind present, vs. slat angle
171 : Real64 TransDiffVis; // Diffuse visible transmittance, bare glass or shade on
172 : Array1D<Real64> BlTransDiffVis; // Diffuse visible transmittance, blind present, vs. slat angle
173 : Real64 ReflectSolDiffBack = 0.0; // Diffuse back solar reflectance, bare glass or shade on
174 : Array1D<Real64> BlReflectSolDiffBack; // Diffuse back solar reflectance, blind present, vs. slat angle
175 : Real64 ReflectSolDiffFront = 0.0; // Diffuse front solar reflectance, bare glass or shade on
176 : Array1D<Real64> BlReflectSolDiffFront; // Diffuse front solar reflectance, blind present, vs. slat angle
177 : Real64 ReflectVisDiffBack = 0.0; // Diffuse back visible reflectance, bare glass or shade on
178 : Array1D<Real64> BlReflectVisDiffBack; // Diffuse back visible reflectance, blind present, vs. slat angle
179 : Real64 ReflectVisDiffFront = 0.0; // Diffuse front visible reflectance, bare glass or shade on
180 : Array1D<Real64> BlReflectVisDiffFront; // Diffuse front visible reflectance, blind present, vs. slat angle
181 : Array1D<Real64> TransSolBeamCoef; // Coeffs of incidence-angle polynomial for beam sol trans,
182 : // bare glass or shade on
183 : Array1D<Real64> TransVisBeamCoef; // Coeffs of incidence-angle polynomial for beam vis trans,
184 : // bare glass or shade on
185 : Array1D<Real64> ReflSolBeamFrontCoef; // Coeffs of incidence-angle polynomial for beam sol front refl,
186 : // bare glass or shade on
187 : Array1D<Real64> ReflSolBeamBackCoef; // Like ReflSolBeamFrontCoef, but for back-incident beam solar
188 : Array1D<Array1D<Real64>> tBareSolCoef; // Isolated glass solar transmittance coeffs of inc. angle polynomial
189 : Array1D<Array1D<Real64>> tBareVisCoef; // Isolated glass visible transmittance coeffs of inc. angle polynomial
190 : Array1D<Array1D<Real64>> rfBareSolCoef; // Isolated glass front solar reflectance coeffs of inc. angle polynomial
191 : Array1D<Array1D<Real64>> rfBareVisCoef; // Isolated glass front visible reflectance coeffs of inc. angle polynomial
192 : Array1D<Array1D<Real64>> rbBareSolCoef; // Isolated glass back solar reflectance coeffs of inc. angle polynomial
193 : Array1D<Array1D<Real64>> rbBareVisCoef; // Isolated glass back visible reflectance coeffs of inc. angle polynomial
194 : Array1D<Array1D<Real64>> afBareSolCoef; // Isolated glass front solar absorptance coeffs of inc. angle polynomial
195 : Array1D<Array1D<Real64>> abBareSolCoef; // Isolated glass back solar absorptance coeffs of inc. angle polynomial
196 : Array1D<Real64> tBareSolDiff; // Isolated glass diffuse solar transmittance
197 : Array1D<Real64> tBareVisDiff; // Isolated glass diffuse visible transmittance
198 : Array1D<Real64> rfBareSolDiff; // Isolated glass diffuse solar front reflectance
199 : Array1D<Real64> rfBareVisDiff; // Isolated glass diffuse visible front reflectance
200 : Array1D<Real64> rbBareSolDiff; // Isolated glass diffuse solar back reflectance
201 : Array1D<Real64> rbBareVisDiff; // Isolated glass diffuse visible back reflectance
202 : Array1D<Real64> afBareSolDiff; // Isolated glass diffuse solar front absorptance
203 : Array1D<Real64> abBareSolDiff; // Isolated glass diffuse solar back absorptance
204 : bool FromWindow5DataFile = false; // True if this is a window construction extracted from the Window5 data file
205 : Real64 W5FileMullionWidth = 0.0; // Width of mullion for construction from Window5 data file (m)
206 : DataWindowEquivalentLayer::Orientation W5FileMullionOrientation =
207 : DataWindowEquivalentLayer::Orientation::Invalid; // Orientation of mullion, if present, for Window5 data file construction,
208 : Real64 W5FileGlazingSysWidth = 0.0; // Glass width for construction from Window5 data file (m)
209 : Real64 W5FileGlazingSysHeight = 0.0; // Glass height for construction form Window5 data file (m)
210 : Real64 SummerSHGC = 0.0; // Calculated ASHRAE SHGC for summer conditions
211 : Real64 VisTransNorm = 0.0; // The normal visible transmittance
212 : Real64 SolTransNorm = 0.0; // the normal solar transmittance
213 : bool SourceSinkPresent = false; // .TRUE. if there is a source/sink within this construction
214 : bool TypeIsWindow = false; // True if a window construction, false otherwise
215 : bool WindowTypeBSDF = false; // True for complex window, false otherwise
216 : bool TypeIsEcoRoof = false; // -- true for construction with ecoRoof outside, the flag
217 : //-- is turned on when the outside layer is of type EcoRoof
218 : bool TypeIsIRT = false; // -- true for construction with IRT material
219 : bool TypeIsCfactorWall = false; // -- true for construction with Construction:CfactorUndergroundWall
220 : bool TypeIsFfactorFloor = false; // -- true for construction with Construction:FfactorGroundFloor
221 : // Added TH 12/22/2008 for thermochromic windows
222 : int TCFlag = 0; // 0: this construction is not a thermochromic window construction
223 : // 1: it is a TC window construction
224 : int TCLayer = 0; // Reference to the TC glazing material layer in the Material array
225 : int TCMasterConst = 0; // The master TC construction referenced by its slave constructions
226 : int TCLayerID = 0; // Which material layer is the TC glazing, counting all material layers.
227 : int TCGlassID = 0; // Which glass layer is the TC glazing, counting from glass layers only.
228 : // For CFactor underground walls
229 : Real64 CFactor = 0.0;
230 : Real64 Height = 0.0;
231 : // For FFactor slabs-on-grade or underground floors
232 : Real64 FFactor = 0.0;
233 : Real64 Area = 0.0;
234 : Real64 PerimeterExposed = 0.0;
235 : bool ReverseConstructionNumLayersWarning = false;
236 : bool ReverseConstructionLayersOrderWarning = false;
237 : // Complex Fenestration
238 : DataBSDFWindow::BSDFWindowInputStruct BSDFInput; // nest structure with user input for complex fenestration
239 : // EquivalentLayer Window
240 : bool WindowTypeEQL = false; // True for equivalent layer window, false otherwise
241 : int EQLConsPtr = 0; // Pointer to equivalent Layer window construction
242 : Array1D<Real64> AbsDiffFrontEQL; // Diffuse layer system front absorptance for EQL window
243 : Array1D<Real64> AbsDiffBackEQL; // Diffuse layer system back absorptance for EQL window
244 : Real64 TransDiffFrontEQL = 0.0; // Diffuse system front transmittance for EQL window
245 : Real64 TransDiffBackEQL = 0.0; // Diffuse system back transmittance for EQL window
246 : // Air boundary
247 : bool TypeIsAirBoundary = false; // true for Construction:AirBoundary
248 : bool TypeIsAirBoundaryMixing = false; // true for Construction:AirBoundary with SimpleMixing for air exchange
249 : Real64 AirBoundaryACH = 0.0; // Air boundary simple mixing air changes per hour [1/hr]
250 : int AirBoundaryMixingSched = 0; // Air boundary simple mixing schedule index
251 :
252 : int rcmax = 0; // Total number of nodes in the construct (<= MaxTotNodes)
253 : Array2D<Real64> AExp; // Exponential of AMat
254 : Array2D<Real64> AInv; // Inverse of AMat
255 : Array2D<Real64> AMat; // "A" matrix from Seem's dissertation (constant coefficients of linear system)
256 : Array1D<Real64> BMat; // "B" matrix of state space method (non-zero elements)
257 : Array1D<Real64> CMat; // "C" matrix of state space method (non-zero elements)
258 : Array1D<Real64> DMat; // "D" matrix of state space method (non-zero elements)
259 : Array1D<Real64> e; // Coefficients for the surface flux history term
260 : Array2D<Real64> Gamma1; // Intermediate calculation array corresponding to a term in Seem's dissertation
261 : Array2D<Real64> Gamma2; // Intermediate calculation array corresponding to a term in Seem's dissertation
262 : Array3D<Real64> s; // Coefficients for the surface temperature history terms
263 : Array2D<Real64> s0; // Coefficients for the current surface temperature terms
264 : Array2D<Real64> IdenMatrix; // Identity Matrix
265 : int NumOfPerpendNodes = 7; // Number of nodes in the direction
266 : // perpendicular to the main direction of heat transfer. This is only used
267 : // when a two-dimensional solution has been requested for a construction
268 : // with a heat source/sink.
269 : int NodeSource = 0; // Node at which a source or sink is present
270 : int NodeUserTemp = 0; // Node where user wishes to calculate a temperature (for constructions with sources/sinks only)
271 :
272 : // Default Constructor
273 800 : ConstructionProps()
274 800 : : LayerPoint(MaxLayersInConstruct, 0), CTFCross({0, MaxCTFTerms - 1}, 0.0), CTFFlux(MaxCTFTerms - 1, 0.0),
275 : CTFInside({0, MaxCTFTerms - 1}, 0.0), CTFOutside({0, MaxCTFTerms - 1}, 0.0), CTFSourceIn({0, MaxCTFTerms - 1}, 0.0),
276 : CTFSourceOut({0, MaxCTFTerms - 1}, 0.0), CTFTSourceOut({0, MaxCTFTerms - 1}, 0.0), CTFTSourceIn({0, MaxCTFTerms - 1}, 0.0),
277 : CTFTSourceQ({0, MaxCTFTerms - 1}, 0.0), CTFTUserOut({0, MaxCTFTerms - 1}, 0.0), CTFTUserIn({0, MaxCTFTerms - 1}, 0.0),
278 : CTFTUserSource({0, MaxCTFTerms - 1}, 0.0), AbsDiffBlind(DataSurfaces::MaxSlatAngs, 0.0),
279 : AbsDiffBlindGnd(DataSurfaces::MaxSlatAngs, 0.0), AbsDiffBlindSky(DataSurfaces::MaxSlatAngs, 0.0),
280 : AbsDiffBackBlind(DataSurfaces::MaxSlatAngs, 0.0), AbsBeamShadeCoef(6, 0.0), BlTransDiff(DataSurfaces::MaxSlatAngs, 0.0),
281 : BlTransDiffGnd(DataSurfaces::MaxSlatAngs, 0.0), BlTransDiffSky(DataSurfaces::MaxSlatAngs, 0.0), TransDiffVis(0.0),
282 : BlTransDiffVis(DataSurfaces::MaxSlatAngs, 0.0), BlReflectSolDiffBack(DataSurfaces::MaxSlatAngs, 0.0),
283 : BlReflectSolDiffFront(DataSurfaces::MaxSlatAngs, 0.0), BlReflectVisDiffBack(DataSurfaces::MaxSlatAngs, 0.0),
284 : BlReflectVisDiffFront(DataSurfaces::MaxSlatAngs, 0.0), TransSolBeamCoef(6, 0.0), TransVisBeamCoef(6, 0.0), ReflSolBeamFrontCoef(6, 0.0),
285 : ReflSolBeamBackCoef(6, 0.0), tBareSolDiff(5, 0.0), tBareVisDiff(5, 0.0), rfBareSolDiff(5, 0.0), rfBareVisDiff(5, 0.0),
286 : rbBareSolDiff(5, 0.0), rbBareVisDiff(5, 0.0), afBareSolDiff(5, 0.0), abBareSolDiff(5, 0.0),
287 800 : AbsDiffFrontEQL(DataWindowEquivalentLayer::CFSMAXNL, 0.0), AbsDiffBackEQL(DataWindowEquivalentLayer::CFSMAXNL, 0.0)
288 : {
289 800 : BMat.allocate(3);
290 800 : CMat.allocate(2);
291 800 : DMat.allocate(2);
292 800 : s0.allocate(3, 4);
293 800 : }
294 :
295 : void calculateTransferFunction(EnergyPlusData &state, bool &ErrorsFound, bool &DoCTFErrorReport);
296 :
297 : void calculateExponentialMatrix(); // Time step of the resulting CTFs
298 :
299 : void calculateInverseMatrix();
300 :
301 : void calculateGammas();
302 :
303 : void calculateFinalCoefficients();
304 :
305 : void reportTransferFunction(EnergyPlusData &state, int cCounter);
306 :
307 : bool isGlazingConstruction(EnergyPlusData &state) const;
308 :
309 : Real64 setThicknessPerpendicular(EnergyPlusData &state, Real64 userValue);
310 :
311 : Real64 setUserTemperatureLocationPerpendicular(EnergyPlusData &state, Real64 userValue);
312 :
313 : void setNodeSourceAndUserTemp(Array1D_int &Nodes);
314 :
315 : void setArraysBasedOnMaxSolidWinLayers(EnergyPlusData &state);
316 : };
317 : } // namespace Construction
318 :
319 1542 : struct ConstructionData : BaseGlobalStruct
320 : {
321 : Array1D<Construction::ConstructionProps> Construct;
322 : Array1D_int LayerPoint = Array1D<int>(Construction::MaxLayersInConstruct, 0);
323 :
324 0 : void clear_state() override
325 : {
326 0 : *this = ConstructionData();
327 0 : }
328 : };
329 :
330 : } // namespace EnergyPlus
331 :
332 : #endif
|
