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 : #ifndef DataBSDFWindow_hh_INCLUDED
49 : #define DataBSDFWindow_hh_INCLUDED
50 :
51 : // ObjexxFCL Headers
52 : #include <ObjexxFCL/Array1D.hh>
53 : #include <ObjexxFCL/Array2D.hh>
54 : #include <ObjexxFCL/Array3D.hh>
55 : #include <ObjexxFCL/Vector3.fwd.hh>
56 :
57 : using ObjexxFCL::Vector3;
58 :
59 : // EnergyPlus Headers
60 : #include <EnergyPlus/Data/BaseData.hh>
61 : #include <EnergyPlus/DataVectorTypes.hh>
62 : #include <EnergyPlus/EPVector.hh>
63 : #include <EnergyPlus/EnergyPlus.hh>
64 :
65 : namespace EnergyPlus {
66 :
67 : namespace DataBSDFWindow {
68 :
69 : // Using/Aliasing
70 : using DataVectorTypes::Vector;
71 :
72 : enum class Basis
73 : {
74 : Invalid = -1,
75 : WINDOW,
76 : Custom,
77 : Num
78 : };
79 :
80 : static constexpr std::array<std::string_view, (int)Basis::Num> basisNamesUC = {"LBNLWINDOW", "USERDEFINED"};
81 :
82 : enum class BasisSymmetry
83 : {
84 : Invalid = -1,
85 : Axisymmetric,
86 : None,
87 : Num
88 : };
89 :
90 : static constexpr std::array<std::string_view, (int)BasisSymmetry::Num> basisSymmetryNamesUC = {"AXISSYMMETRIC", "NONE"};
91 :
92 : // Thermal calculations for complex fenestration can be used to generate reports for standard cases
93 : // noCondition is used when performing timestep calculations
94 : // 'Summer' will override certain parameters so that produced results are matching standard summer WINDOW = software results
95 : // 'Winter' will override certain parameters so that produced results are matching standard winter WINDOW = software results
96 : enum class Condition
97 : {
98 : Invalid = -1,
99 : Summer,
100 : Winter,
101 : Num
102 : };
103 :
104 : struct BasisElemDescr
105 : {
106 : // Members
107 : // The following are in the local coordinate system corresponding to the matrix
108 : Real64 Theta = 0.0; // Centroid Theta value
109 : Real64 Phi = 0.0; // Centroid Phi value
110 : Real64 dTheta = 0.0; // Element width, Theta
111 : Real64 dPhi = 0.0; // Element width, Phi
112 : Real64 UpprTheta = 0.0; // Patch upper edge, Theta
113 : Real64 LwrTheta = 0.0; // Patch lower edge, Theta
114 : Real64 UpprPhi = 0.0; // Patch upper edge, Phi
115 : Real64 LwrPhi = 0.0; // Patch lower edge, Phi
116 : // Note: The dimension index of the BasisElementDescription object corresponds to
117 : // the position (index) of this element in the row or column of property matrix
118 : // Note: the following are intended to be used for interpolating directions among basis elements
119 : int INNbInL = 0; // Index of inward (lower Theta) neighbor, lower phi
120 : int INNbInH = 0; // Index of inward (lower Theta) neighbor, higher phi
121 : int INNbOutL = 0; // Index of outward (higher Theta) neighbor, lower phi
122 : int INNbOutH = 0; // Index of outward (higher Theta) neighbor, higher phi
123 : int INNbLft = 0; // Index of leftward (higher Phi) neighbor (same Theta)
124 : int INNbRt = 0; // Index of rightward (lower Phi) neighbor (same Theta)
125 : // These indices are in the BasisElement array, which matches the row/column of the matrix
126 : };
127 :
128 : struct BSDFDaylghtPosition
129 : {
130 : // Members
131 : Real64 Altitude; // Altitude range is from -pi/2 to pi/2. Horizontal vector have altitude of zero
132 : Real64 Azimuth; // Azimuth is measured from positive x counter clockwise. Its range is from -pi to pi
133 :
134 : // Default Constructor
135 580 : BSDFDaylghtPosition() : Altitude(0.0), Azimuth(0.0)
136 : {
137 580 : }
138 :
139 : // Member Constructor
140 2 : BSDFDaylghtPosition(Real64 const Altitude, // Altitude range is from -pi/2 to pi/2. Horizontal vector have altitude of zero
141 : Real64 const Azimuth // Azimuth is measured from positive x counter clockwise. Its range is from -pi to pi
142 : )
143 2 : : Altitude(Altitude), Azimuth(Azimuth)
144 : {
145 2 : }
146 : };
147 :
148 : struct BasisStruct
149 : {
150 : // Members
151 : Basis BasisType = Basis::Invalid; // BasisType_WINDOW or BasisType_Custom (see HeatBalanceManager)
152 : BasisSymmetry BasisSymmetryType = BasisSymmetry::Invalid; // BasisSymmetry_Axisymmetric or BasisSymmetry_None (see HeatBalanceManager)
153 : int BasisMatIndex = 0; // pointer to matrix for basis
154 : int NBasis = 0; // No. elements in basis
155 : Array1D<Real64> Lamda; // Vector of diagonal Lamda matrix elems for grid
156 : Array1D<Real64> SolAng; // Vector of basis element solid angles for grid
157 : int NThetas = 0; // No. Theta values in basis
158 : Array1D<Real64> Thetas; // List of basis theta values
159 : Array1D_int NPhis; // No. basis phi values for each theta
160 : Array2D<Real64> Phis; // List of basis phi values for each theta
161 : Array2D_int BasisIndex; // Index of basis element for theta, phi
162 : Array1D<BasisElemDescr> Grid; // actual basis (to be constructed from matrix)
163 : };
164 :
165 : struct BSDFGeomDescr
166 : {
167 : // Members
168 : BasisStruct Inc; // Basis for incident hemisphere
169 : Array1D<Vector> sInc; // Central direction vectors of incident grid (World coords)
170 : Array1D<BSDFDaylghtPosition> pInc; // azimuth and altitude of incidence vectors
171 : Array1D<Real64> CosInc; // cosine of incident angle
172 : Array1D<Real64> DAInc; // cosine of incident angle times delta theta time delta phi (used in daylighting calculations)
173 : int NSkyUnobs = 0; // Number of Inc basis rays from unobstructed sky
174 : int NGndUnobs = 0; // Number of Inc basis rays from unobstructed ground
175 : int NSky = 0; // Number of Inc basis rays from sky
176 : int NGnd = 0; // Number of Inc basis rays from gnd
177 : int NReflSurf = 0; // Number of Inc basis rays from (potentially reflecting) surfaces
178 : Array1D_int SkyIndex; // list of sky basis indices
179 : Array1D_int GndIndex; // list of gnd basis indices
180 : Array1D<Vector> GndPt; // gnd intersection pt of gnd basis ray (z=0)
181 : Array1D_int RefSurfIndex; // list of basis indices of rays striking exterior surf
182 : Array1D_int RefRayNHits; // for a given ray striking a surface, no. of surfaces pierced
183 : Array2D_int HitSurfNo; // for a given ray striking surface, list of intersected surf nos
184 : Array2D<Real64> HitSurfDSq; // for a given ray striking surface, list of distance^2
185 : // from window
186 : Array2D<Vector> HitPt; // for a given ray striking surface, list of hit pts
187 : Array1D<Real64> SolSkyWt; // Sky intensity weights
188 : Array1D<Real64> SolSkyGndWt; // Wts for sky rad refl from grn
189 : Array3D<Real64> SolBmGndWt; // Wts for beam rad refl from gnd (hour, timestep)
190 : Array2D_int SolBmIndex; // Basis index corresponding to beam dir (hour, timestep)
191 : // Note this is zero if sun is not in incident hemisphere
192 : // otherwise in range 1..NBasis
193 : Array2D<Real64> ThetaBm; // Theta angle corresponging to beam dir (hour, timestep) (rad)
194 : Array2D<Real64> PhiBm; // Theta angle corresponging to beam dir (hour, timestep) (rad)
195 : BasisStruct Trn;
196 : Array1D<Vector> sTrn; // Central direction vectors of Outgoing grid (World coords)
197 : Array1D<BSDFDaylghtPosition> pTrn; // azimuth and altitude of incidence vectors
198 : Array1D_int NSurfInt; // No. of basis rays intersecting back surface (dim from
199 : // NBkSurf in BSDF State Descr)
200 : Array2D_int SurfInt; // Basis index (IBkSurf, j) of the jth ray intersecting IBkSurf
201 : Array2D<Real64> SjdotN; // dot product (IBksurf, j) of the jth ray direction with
202 : // the normal to the back surface
203 : Array2D<Real64> AOverlap; // Overlap areas for each outgoing
204 : // direction (Trn) (no of outgoing dir, NBKSurf)
205 : Array2D<Real64>
206 : ARhoVisOverlap; // Overlap areas multiplied with surface reflectance for each outgoing direction (Trn) (no of outgoing dir, NBKSurf)
207 : Array1D<Real64> AveRhoVisOverlap; // Average visible reflectance from overlap surface which originates from one outgoing direction
208 : bool InitState = true; // Flag for marking that state needs to be initialized
209 : };
210 :
211 : struct BSDFRefPoints
212 : {
213 : // Members
214 : Array1D_int NSky; // number of sky elements for each window element (# window el)
215 : Array1D_int NGnd; // number of ground elements for each window element (# window el)
216 : Array1D_int NReflSurf; // number of Inc basis rays from reflecting surfaces (# window el)
217 : Array2D_int SkyIndex; // list of sky basis indices (# window el, NSky)
218 : Array2D_int GndIndex; // list of gnd basis indices (# window el, NGnd)
219 : Array2D<Vector> GndPt; // gnd intersection pt of gnd basis ray (z=0) (# window el, NGnd)
220 : Array2D<Real64> GndObstrMultiplier; // ground obstruction multiplier used in reflection calculatations (# window el, NGnd)
221 : Array2D_int RefSurfIndex; // list of basis indices of rays striking exterior surf (# window el, NReflSurf)
222 : Array2D_int RefRayNHits; // for a given ray striking a surface, no. of surfaces pierced (# window el, NReflSurf)
223 : Array2D<Real64> TransOutSurf; // total transmittance of exterior obstructions for given incoming basis direction. (# window el, NReflSurf)
224 : Array3D_int HitSurfNo; // for a given ray striking surface, list of intersected surf nos (# window el, NReflSurf, RefRayNHits)
225 : Array3D<Real64> HitSurfDSq; // for a given ray striking surface, list of distance^2 from window (# window el, NReflSurf, RefRayNHits)
226 : Array3D<Vector> HitPt; // for a given ray striking surface, list of hit pts (# window el, NReflSurf, RefRayNHits)
227 : Array1D_int RefPointIndex; // outgoing direction which containts reference point (# window el)
228 : Array1D_bool RefPointIntersection; // determines if reference point is laying in light tube of bsdf outgoing direction (NTrnBasis)
229 : Array1D<Real64> RefPtIntPosFac; // position factors for intersections from reference point to window for each outgoing direction (NTrnBasis)
230 : };
231 :
232 : struct BSDFDaylghtGeomDescr
233 : {
234 : // Members
235 : Array2D<BSDFRefPoints>
236 : IlluminanceMap; // array to keep bsdf coefficients for different illuminance maps (# of illuminance maps, # of reference points)
237 : Array1D<BSDFRefPoints> RefPoint; // keep reference points daylight coefficients (# of reference points)
238 : };
239 :
240 : struct BSDFBkSurfDescr
241 : {
242 : // Members
243 : Array2D<Real64> WinDHBkRefl; // Back directional hemispherical reflectance (hour, timestep)
244 : // of this window for radiation from the back surface window
245 : Array3D<Real64> WinDirBkAbs; // back absorptance (hr, timestep, layer)
246 : // for beam radiation absorbed in this
247 : // window that comes from the back surface window
248 : // Performance May be faster in (layer,hr,timestep) order (loops are not consistent)
249 : // Note: WinDHBkRefl and WinDirBkAbs are the same for all hours & timesteps if the back surface window is a
250 : // Complex Fenestration; they depend on the sun direction if the back surface window is a regular window
251 : };
252 :
253 : struct BSDFStateDescr
254 : {
255 : // Members
256 : int Konst = 0; // pointer to construction for this state; property matrices are in the construction
257 : // INTEGER :: ThermConst =0 ! pointer to thermal construction for this state
258 : Real64 WinDiffTrans = 0.0; // Window hemispherical ave diff trans
259 : // for use in corrections requiring a diffuse trans
260 : // that have not been redone in detail for Compex Fen
261 : Real64 WinDiffVisTrans = 0.0; // Window hemispherical ave diff trans for visible spectrum
262 : Array2D<Real64> WinDirHemiTrans; // Directional-hemispherical transmittance(hr,ts)
263 : Array2D<Real64> WinDirSpecTrans; // Directional specular transmittance(hr,ts)
264 : Real64 WinSkyTrans = 0.0; // Transmittance for sky radiation (weighted average over sky viewed)
265 : Real64 WinSkyGndTrans = 0.0; // Transmittance for sky radiation reflected from ground (average over
266 : // viewed part of ground)
267 : Array2D<Real64> WinBmGndTrans; // Transmittance (hour, timestep) for beam radiation reflected
268 : // from ground (average over unshaded ground viewed)
269 : Real64 WinBkHemRefl = 0.0; // Window back hemispherical reflectance
270 : Real64 WinBkHemVisRefl = 0.0; // Window back hemispherical reflectance (visible spectrum)
271 : //(for reflection of interior diffuse radiation)
272 : int NLayers = 0; // Number of absorbing layers in this window
273 : Array3D<Real64> WinBmFtAbs; // Front directional absorptance (hour, timestep, layer)
274 : Array1D<Real64> WinSkyFtAbs; // Front absorptance (layer) averaged over sky
275 : Array1D<Real64> WinSkyGndAbs; // Front absorptance (layer) averaged over ground
276 : // viewed part of gnd (for ground-reflected sky radiation)
277 : Array3D<Real64> WinBmGndAbs; // Front absorptance (hour, timestep, layer) averaged
278 : // over unshaded ground viewed by beam
279 : Array1D<Real64> WinFtHemAbs; // Front hemispherical absorptance (layers)
280 : Array1D<Real64> WinBkHemAbs; // Back hemispherical absorptance (layers)
281 : Array3D<Real64> WinToSurfBmTrans; // Beam transmittance (hour, timestep, bk surf no)
282 : // to back surface
283 : // Note: the following will be evaluated only if the given back surface is a window
284 : Array1D<BSDFBkSurfDescr> BkSurf; // Structure dimensioned (bk surface no)
285 : // Integrated beam values at front and back sides of window. It is used in calculations of how much of the energy is
286 : // leaving throught the window to other zone or to the outside for certain beam direction
287 : Array1D<Real64> IntegratedFtAbs; // Sum of all back layer absorptances (for each back direction)
288 : Array1D<Real64> IntegratedFtRefl; // Integrated back layer reflectance (for each back direction)
289 : Array1D<Real64> IntegratedFtTrans; // Integrated back layer transmittance (for each back direction)
290 : Array1D<Real64> IntegratedBkAbs; // Sum of all back layer absorptances (for each back direction)
291 : Array1D<Real64> IntegratedBkRefl; // Integrated back layer reflectance (for each back direction)
292 : Array1D<Real64> IntegratedBkTrans; // Integrated back layer transmittance (for each back direction)
293 : };
294 :
295 : struct BSDFRefPointsGeomDescr
296 : {
297 : // Members
298 : Array1D<Real64> SolidAngle; // Solid angle from daylighting reference point to each window element (# window el)
299 : Array1D<Vector> SolidAngleVec; // unit vector from reference point towards center of window element (# window el)
300 : };
301 :
302 : struct BSDFWindowGeomDescr
303 : {
304 : // Members
305 : // This contains all the geometry info that we don't want to carry around in SurfaceWindow
306 : // This is dimensioned like SurfaceWindow, but only surfaces that are complex windows
307 : // will have the structure below allocated
308 : int NumStates = 0; // Number of states for this window
309 : Array1D<BSDFGeomDescr> Geom; // This is dimensioned with number of states
310 : Array1D<BSDFDaylghtGeomDescr> DaylghtGeom; // This is dimensioned with number of states
311 : bool DaylightingInitialized = false; // used for one time initialization only
312 : int NBkSurf = 0; // Number of back (interior) surfaces viewed by this window
313 : Array1D<Vector> sWinSurf; // Unit vector from window center to center of IBkSurf
314 : Array1D<Real64> sdotN; // Dot product of unit vector s with back surface normal
315 : // here s is vector from center of window to center of back surface
316 : // Function of the following subsumed by using an index of 0 if no beam incidence
317 : Array2D<BSDFRefPointsGeomDescr>
318 : IlluminanceMap; // array to keep bsdf coefficients for different illuminance maps (# of illuminance maps, # of reference points)
319 : Array1D<BSDFRefPointsGeomDescr> RefPoint; // keep reference points daylight coefficients (# of reference points)
320 : };
321 :
322 : struct BSDFWindowDescript
323 : {
324 : // Members
325 : int NumStates = 0; // Number of states for this window
326 : int CurrentState = 1; // Current state of this window
327 : Array2D<Real64> ResultAllStates; // Array to hold calculated
328 : // quantities for all states.
329 : // Currently unallocated. To be defined when control
330 : // scheme worked out. This is an array (nvar, nstates)
331 : // to be set up for some number of variables, and calculated
332 : // for all states 1...NumStates each time step. e.g., one variable could be
333 : // total beam transmitted solar, another total transmitted diffuse
334 : // The idea is that for a given time step when one has the
335 : // actual result (total cooling load or whatever), one needs to have
336 : // some information about all the states to decide where to
337 : // set the state variable for the next time step
338 : Array1D<BSDFStateDescr> State; // State description, dimensioned with number of states
339 : };
340 :
341 : struct BSDFLayerAbsorpStruct
342 : {
343 : // Members
344 : int MaterialIndex = 0; // pointer to material layer
345 : int FrtAbsIndex = 0; // pointer to matrix for Front directional absorptance vector
346 : int AbsNcols = 0; // Number of elements (columns) in each of the absorption (row) vectors
347 : Array2D<Real64> FrtAbs; // Front directional absorptance vector
348 : int BkAbsIndex = 0; // pointer to matrix for Back directional absorptance vector
349 : Array2D<Real64> BkAbs; // Back directional absorptance vector
350 : };
351 :
352 : struct BSDFWindowInputStruct
353 : {
354 : // Members
355 : // nested data for Construction
356 : Basis BasisType = Basis::Invalid;
357 : BasisSymmetry BasisSymmetryType = BasisSymmetry::Invalid;
358 : int ThermalModel = 0; // Pointer to thermal model
359 : int BasisMatIndex = 0; // pointer to matrix for basis
360 : int BasisMatNrows = 0; // No. rows in matrix
361 : int BasisMatNcols = 0; // No. columns in matrix
362 : int NBasis = 0; // No. elements in basis
363 : Array2D<Real64> BasisMat; // basis matrix
364 : int SolFrtTransIndex = 0; // pointer to matrix for Front optical transmittance matrix
365 : int SolFrtTransNrows = 0; // No. rows in matrix
366 : int SolFrtTransNcols = 0; // No. columns in matrix
367 : Array2D<Real64> SolFrtTrans; // Front optical transmittance matrix
368 : int SolBkReflIndex = 0; // pointer to matrix for Back optical reflectance matrix
369 : int SolBkReflNrows = 0; // No. rows in matrix
370 : int SolBkReflNcols = 0; // No. columns in matrix
371 : Array2D<Real64> SolBkRefl; // Back optical reflectance matrix
372 : int VisFrtTransIndex = 0; // pointer to matrix for Front visible transmittance matrix
373 : int VisFrtTransNrows = 0; // No. rows in matrix
374 : int VisFrtTransNcols = 0; // No. columns in matrix
375 : Array2D<Real64> VisFrtTrans; // Front visible transmittance matrix
376 : int VisBkReflIndex = 0; // pointer to matrix for Back visible reflectance matrix
377 : int VisBkReflNrows = 0; // No. rows in matrix
378 : int VisBkReflNcols = 0; // No. columns in matrix
379 : Array2D<Real64> VisBkRefl; // Back visible reflectance matrix
380 : int NumLayers = 0;
381 : Array1D<BSDFLayerAbsorpStruct> Layer;
382 : };
383 :
384 : } // namespace DataBSDFWindow
385 :
386 : struct BSDFWindowData : BaseGlobalStruct
387 : {
388 :
389 : int TotComplexFenStates = 0; // Number of complex fenestration construction definitions
390 : int FirstBSDF = 0; // Location of first complex fenestration construction definition in Constr array
391 : int MaxBkSurf = 20; // was 20 Maximum number of back surfaces in solar overlap & interior solar distribution
392 : int TotThermalModels = 0; // Number of thermal models
393 :
394 : // calculation
395 : Array2D<Vector3<Real64>> SUNCOSTS = Array2D<Vector3<Real64>>(60, 24); // Timestep values of solar direction cosines
396 : Array2D<Real64> BSDFTempMtrx; // Temporary matrix for holding axisymmetric input
397 : EPVector<DataBSDFWindow::BSDFWindowGeomDescr> ComplexWind; // Window geometry structure: set in CalcPerSolarBeam/SolarShading
398 :
399 2126 : void init_constant_state([[maybe_unused]] EnergyPlusData &state) override
400 : {
401 2126 : }
402 :
403 1152 : void init_state([[maybe_unused]] EnergyPlusData &state) override
404 : {
405 1152 : }
406 :
407 2100 : void clear_state() override
408 : {
409 2100 : new (this) BSDFWindowData();
410 2100 : }
411 : };
412 :
413 : } // namespace EnergyPlus
414 :
415 : #endif
|
