Refactoring of interpolation functions for blinds Prof and Slat Angle

src/EnergyPlus/DataSurfaces.cc

@@ -629,7 +629,6 @@ namespace EnergyPlus::DataSurfaces {
     }
 
     // Functions
-
     void SetSurfaceOutBulbTempAt(EnergyPlusData &state)
     {
         for (auto &surface : state.dataSurface->Surface) {

src/EnergyPlus/DataSurfaces.hh

@@ -110,6 +110,7 @@ namespace DataSurfaces {
 
     // MODULE PARAMETER DEFINITIONS:
     constexpr int MaxSlatAngs(19);
+    constexpr int MaxProfAngs(37);
 
     // Parameters to indicate surface shape for use with the Surface
     // derived type (see below):
@@ -1485,6 +1486,11 @@ struct SurfacesData : BaseGlobalStruct
     Array1D<bool> SurfWinSlatAngThisTSDegEMSon;      // flag that indicate EMS system is actuating SlatAngThisTSDeg
     Array1D<Real64> SurfWinSlatAngThisTSDegEMSValue; // value that EMS sets for slat angle in degrees
     Array1D<bool> SurfWinSlatsBlockBeam;             // True if blind slats block incident beam solar
+    Array1D<int> SurfWinSlatsAngIndex;
+    Array1D<Real64> SurfWinSlatsAngInterpFac;
+    Array1D<Real64> SurfWinProfileAng;
+    Array1D<int> SurfWinProfAngIndex;
+    Array1D<Real64> SurfWinProfAngInterpFac;
     Array1D<Real64> SurfWinBlindAirFlowPermeability; // Blind air-flow permeability for calculation of convective flow in gap between blind and glass
     Array1D<Real64> SurfWinTotGlazingThickness;      // Total glazing thickness from outside of outer glass to inside of inner glass (m)
     Array1D<Real64> SurfWinTanProfileAngHor;         // Tangent of horizontal profile angle
@@ -1750,6 +1756,11 @@ struct SurfacesData : BaseGlobalStruct
         this->SurfWinSlatAngThisTSDegEMSon.deallocate();
         this->SurfWinSlatAngThisTSDegEMSValue.deallocate();
         this->SurfWinSlatsBlockBeam.deallocate();
+        this->SurfWinSlatsAngIndex.deallocate();
+        this->SurfWinSlatsAngInterpFac.deallocate();
+        this->SurfWinProfileAng.deallocate();
+        this->SurfWinProfAngIndex.deallocate();
+        this->SurfWinProfAngInterpFac.deallocate();
         this->SurfWinBlindAirFlowPermeability.deallocate();
         this->SurfWinTotGlazingThickness.deallocate();
         this->SurfWinTanProfileAngHor.deallocate();

src/EnergyPlus/General.cc

@@ -969,6 +969,7 @@ namespace General {
         XX_1 = X1;
     }
 
+
     Real64 InterpSw(Real64 const SwitchFac, // Switching factor: 0.0 if glazing is unswitched, = 1.0 if fully switched
                     Real64 const A,         // Glazing property in unswitched state
                     Real64 const B          // Glazing property in fully switched state
@@ -1305,6 +1306,21 @@ namespace General {
         IAlpha = int((ProfAng1 + DataGlobalConstants::PiOvr2) / DeltaProfAng) + 1;
         ProfAngRatio = (ProfAng1 + DataGlobalConstants::PiOvr2 - (IAlpha - 1) * DeltaProfAng) / DeltaProfAng;
 
+//        Real64 const DeltaAngRad(DataGlobalConstants::Pi / 36.0); // Profile angle increment (rad)
+//
+//        // FUNCTION LOCAL VARIABLE DECLARATIONS:
+//        Real64 InterpFac; // Interpolation factor
+//        int IAlpha;       // Profile angle index
+//
+//        // DeltaAng = Pi/36
+//        if (ProfAng > DataGlobalConstants::PiOvr2 || ProfAng < -DataGlobalConstants::PiOvr2) {
+//            InterpProfAng = 0.0;
+//        } else {
+//            IAlpha = 1 + int((ProfAng + DataGlobalConstants::PiOvr2) / DeltaAngRad);
+//            InterpFac = (ProfAng - (-DataGlobalConstants::PiOvr2 + DeltaAngRad * (IAlpha - 1))) / DeltaAngRad;
+//            InterpProfAng = (1.0 - InterpFac) * PropArray(IAlpha) + InterpFac * PropArray(IAlpha + 1);
+//        }
+
         if (VarSlats) { // Variable-angle slats: interpolate in profile angle and slat angle
             IBeta = int(SlatAng1 / DeltaSlatAng) + 1;
             SlatAngRatio = (SlatAng1 - (IBeta - 1) * DeltaSlatAng) / DeltaSlatAng;

src/EnergyPlus/General.hh

@@ -157,6 +157,27 @@ namespace General {
                    Real64 &XX_1                // Hign bound obtained with maximum number of allowed iterations
     );
 
+    constexpr Real64 InterpGeneral(Real64 const Lower,
+                                Real64 const Upper,
+                                Real64 const InterpFac
+    )
+    {
+        return Lower + InterpFac * (Upper - Lower);
+    };
+
+    constexpr Real64 InterpProfSlat(Real64 const SlatLower,
+                                    Real64 const SlatUpper,
+                                    Real64 const ProfLower,
+                                    Real64 const ProfUpper,
+                                    Real64 const SlatInterpFac,
+                                    Real64 const ProfInterpFac
+    )
+    {
+        Real64 ValA = SlatLower + SlatInterpFac * (SlatUpper - SlatLower);
+        Real64 ValB = ProfLower + SlatInterpFac * (ProfUpper - ProfLower);
+        return ValA + ProfInterpFac * (ValB - ValA);
+    };
+
     Real64 InterpSw(Real64 const SwitchFac, // Switching factor: 0.0 if glazing is unswitched, = 1.0 if fully switched
                     Real64 const A,         // Glazing property in unswitched state
                     Real64 const B          // Glazing property in fully switched state

src/EnergyPlus/HeatBalanceIntRadExchange.cc

@@ -163,7 +163,6 @@ namespace HeatBalanceIntRadExchange {
         typedef Array1D<Real64>::size_type size_type;
 
         // Using/Aliasing
-        using General::InterpSlatAng; // Function for slat angle interpolation
         using HeatBalanceMovableInsulation::EvalInsideMovableInsulation;
         using WindowEquivalentLayer::EQLWindowInsideEffectiveEmiss;
 
@@ -288,11 +287,8 @@ namespace HeatBalanceIntRadExchange {
                         int const SurfNum = zone_SurfacePtr(ZoneSurfNum);
                         int const ConstrNum = state.dataSurface->Surface(SurfNum).Construction;
                         zone_info.Emissivity(ZoneSurfNum) = state.dataConstruction->Construct(ConstrNum).InsideAbsorpThermal;
-                        auto const &surface_window(state.dataSurface->SurfaceWindow(SurfNum));
                         if (state.dataConstruction->Construct(ConstrNum).TypeIsWindow && ANY_INTERIOR_SHADE_BLIND(state.dataSurface->SurfWinShadingFlag(SurfNum))) {
-                            zone_info.Emissivity(ZoneSurfNum) =
-                                InterpSlatAng(state.dataSurface->SurfWinSlatAngThisTS(SurfNum), state.dataSurface->SurfWinMovableSlats(SurfNum), surface_window.EffShBlindEmiss) +
-                                InterpSlatAng(state.dataSurface->SurfWinSlatAngThisTS(SurfNum), state.dataSurface->SurfWinMovableSlats(SurfNum), surface_window.EffGlassEmiss);
+                            zone_info.Emissivity(ZoneSurfNum) = state.dataHeatBal->ITABSF(SurfNum);
                         }
                         if (state.dataSurface->Surface(SurfNum).MovInsulIntPresent) {
                             HeatBalanceMovableInsulation::EvalInsideMovableInsulation(state, SurfNum, HMovInsul, AbsInt);
@@ -345,8 +341,7 @@ namespace HeatBalanceIntRadExchange {
                         // and emiss is used here that is a weighted combination of shade/blind and glass temp and emiss.
                     } else if (ANY_INTERIOR_SHADE_BLIND(state.dataSurface->SurfWinShadingFlag(SurfNum))) {
                         SurfaceTempRad[ZoneSurfNum] = state.dataSurface->SurfWinEffInsSurfTemp(SurfNum);
-                        SurfaceEmiss[ZoneSurfNum] = InterpSlatAng(state.dataSurface->SurfWinSlatAngThisTS(SurfNum), state.dataSurface->SurfWinMovableSlats(SurfNum), surface_window.EffShBlindEmiss) +
-                            InterpSlatAng(state.dataSurface->SurfWinSlatAngThisTS(SurfNum), state.dataSurface->SurfWinMovableSlats(SurfNum), surface_window.EffGlassEmiss);
+                        SurfaceEmiss[ZoneSurfNum] = state.dataHeatBal->ITABSF(SurfNum);
                     } else {
                         SurfaceTempRad[ZoneSurfNum] = SurfaceTemp(SurfNum);
                         SurfaceEmiss[ZoneSurfNum] = construct.InsideAbsorpThermal;