From 5e7e921fb4f4c5218d403f639a6b12a8f47ab02f Mon Sep 17 00:00:00 2001 From: Yujie Xu Date: Sat, 20 Jul 2024 23:38:24 -0700 Subject: [PATCH] simplify find_eqvar, find_T, adjust precision of unit tests --- src/EnergyPlus/ExtendedHI.cc | 235 ++++++++++++--- src/EnergyPlus/ExtendedHI.hh | 17 +- tst/EnergyPlus/unit/ExtendedHI.unit.cc | 392 +++++++++---------------- 3 files changed, 360 insertions(+), 284 deletions(-) diff --git a/src/EnergyPlus/ExtendedHI.cc b/src/EnergyPlus/ExtendedHI.cc index 589ba28d49a..787b7625d04 100644 --- a/src/EnergyPlus/ExtendedHI.cc +++ b/src/EnergyPlus/ExtendedHI.cc @@ -58,10 +58,6 @@ // Year = {2022}, // } // -// This headindex function returns the Heat Index in Kelvin. The inputs are: -// - T, the temperature in Kelvin -// - RH, the relative humidity, which is a value from 0 to 1 -// - show_info is an optional logical flag. If true, the function returns the physiological state. #include @@ -168,10 +164,190 @@ namespace ExtendedHI { constexpr Real64 Za_un = 60.6 / 12.3; // Pa m^2/W, mass transfer resistance through air, when being naked constexpr Real64 tol = 1e-8; - constexpr Real64 tolT = 1e-8; constexpr Real64 maxIter = 100; + Real64 find_eqvar_phi(EnergyPlusData &state, Real64 Ta, Real64 RH) + { + + Real64 phi = 0.84; + Real64 Pa = RH * pvstar(Ta); + Real64 Rs = 0.0387; + Real64 m = (Pc - Pa) / (Zs(Rs) + Za); + Real64 Ts; + int SolFla; + General::SolveRoot( + state, + tol, + maxIter, + SolFla, + Ts, + [&](Real64 Ts) { return (Ts - Ta) / Ra(Ts, Ta) + (Pc - Pa) / (Zs(Rs) + Za) - (Tc - Ts) / Rs; }, + std::max(0.0, std::min(Tc, Ta) - Rs * std::abs(m)), + std::max(Tc, Ta) + Rs * std::abs(m)); + Real64 flux1 = Q - Qv(Ta, Pa) - (1.0 - phi) * (Tc - Ts) / Rs; + if (flux1 <= 0.0) { + phi = 1.0 - (Q - Qv(Ta, Pa)) * Rs / (Tc - Ts); + } + return phi; + } + + Real64 find_eqvar_Rf(EnergyPlusData &state, Real64 Ta, Real64 RH) + { + Real64 Pa = RH * pvstar(Ta); + Real64 Rs = 0.0387; + Real64 phi = 0.84; + Real64 m_bar = (Pc - Pa) / (Zs(Rs) + Za_bar); + Real64 m = (Pc - Pa) / (Zs(Rs) + Za); + Real64 Ts; + int SolFla; + General::SolveRoot( + state, + tol, + maxIter, + SolFla, + Ts, + [&](Real64 Ts) { return (Ts - Ta) / Ra(Ts, Ta) + (Pc - Pa) / (Zs(Rs) + Za) - (Tc - Ts) / Rs; }, + std::max(0.0, std::min(Tc, Ta) - Rs * std::abs(m)), + std::max(Tc, Ta) + Rs * std::abs(m)); + Real64 Tf; + General::SolveRoot( + state, + tol, + maxIter, + SolFla, + Tf, + [&](Real64 Tf) { return (Tf - Ta) / Ra_bar(Tf, Ta) + (Pc - Pa) / (Zs(Rs) + Za_bar) - (Tc - Tf) / Rs; }, + std::max(0.0, std::min(Tc, Ta) - Rs * std::abs(m_bar)), + std::max(Tc, Ta) + Rs * std::abs(m_bar)); + Real64 flux1 = Q - Qv(Ta, Pa) - (1.0 - phi) * (Tc - Ts) / Rs; + Real64 flux2 = Q - Qv(Ta, Pa) - (1.0 - phi) * (Tc - Ts) / Rs - phi * (Tc - Tf) / Rs; + Real64 Rf; + if (flux1 <= 0.0) { + Rf = std::numeric_limits::infinity(); + } else if (flux2 <= 0.0) { + Real64 Ts_bar = Tc - (Q - Qv(Ta, Pa)) * Rs / phi + (1.0 / phi - 1.0) * (Tc - Ts); + General::SolveRoot( + state, + tol, + maxIter, + SolFla, + Tf, + [&](Real64 Tf) { + return (Tf - Ta) / Ra_bar(Tf, Ta) + (Pc - Pa) * (Tf - Ta) / ((Zs(Rs) + Za_bar) * (Tf - Ta) + r * Ra_bar(Tf, Ta) * (Ts_bar - Tf)) - + (Tc - Ts_bar) / Rs; + }, + Ta, + Ts_bar); + Rf = Ra_bar(Tf, Ta) * (Ts_bar - Tf) / (Tf - Ta); + } else { + Rf = 0.0; + } + return Rf; + } + + Real64 find_eqvar_rs(EnergyPlusData &state, Real64 Ta, Real64 RH) + { + + Real64 Pa = RH * pvstar(Ta); + Real64 phi = 0.84; + Real64 Rs = 0.0387; + Real64 m = (Pc - Pa) / (Zs(Rs) + Za); + Real64 m_bar = (Pc - Pa) / (Zs(Rs) + Za_bar); + Real64 Ts; + int SolFla; + General::SolveRoot( + state, + tol, + maxIter, + SolFla, + Ts, + [&](Real64 Ts) { return (Ts - Ta) / Ra(Ts, Ta) + (Pc - Pa) / (Zs(Rs) + Za) - (Tc - Ts) / Rs; }, + std::max(0.0, std::min(Tc, Ta) - Rs * std::abs(m)), + std::max(Tc, Ta) + Rs * std::abs(m)); + Real64 Tf; + General::SolveRoot( + state, + tol, + maxIter, + SolFla, + Tf, + [&](Real64 Tf) { return (Tf - Ta) / Ra_bar(Tf, Ta) + (Pc - Pa) / (Zs(Rs) + Za_bar) - (Tc - Tf) / Rs; }, + std::max(0.0, std::min(Tc, Ta) - Rs * std::abs(m_bar)), + std::max(Tc, Ta) + Rs * std::abs(m_bar)); + Real64 flux1 = Q - Qv(Ta, Pa) - (1.0 - phi) * (Tc - Ts) / Rs; + Real64 flux2 = Q - Qv(Ta, Pa) - (1.0 - phi) * (Tc - Ts) / Rs - phi * (Tc - Tf) / Rs; + Real64 flux3 = Q - Qv(Ta, Pa) - (Tc - Ta) / Ra_un(Tc, Ta) - (phi_salt * pvstar(Tc) - Pa) / Za_un; + if (flux1 > 0 && flux2 > 0) { + if (flux3 < 0.0) { + General::SolveRoot( + state, + tol, + maxIter, + SolFla, + Ts, + [&](Real64 Ts) { return (Ts - Ta) / Ra_un(Ts, Ta) + (Pc - Pa) / (Zs((Tc - Ts) / (Q - Qv(Ta, Pa))) + Za_un) - (Q - Qv(Ta, Pa)); }, + 0.0, + Tc); + Rs = (Tc - Ts) / (Q - Qv(Ta, Pa)); + Real64 Ps = Pc - (Pc - Pa) * Zs(Rs) / (Zs(Rs) + Za_un); + if (Ps > phi_salt * pvstar(Ts)) { + General::SolveRoot( + state, + tol, + maxIter, + SolFla, + Ts, + [&](Real64 Ts) { return (Ts - Ta) / Ra_un(Ts, Ta) + (phi_salt * pvstar(Ts) - Pa) / Za_un - (Q - Qv(Ta, Pa)); }, + 0.0, + Tc); + Rs = (Tc - Ts) / (Q - Qv(Ta, Pa)); + } + } else { + Rs = 0.0; + } + } + return Rs; + } + + Real64 find_eqvar_dTcdt(EnergyPlusData &state, Real64 Ta, Real64 RH) + { + Real64 dTcdt = 0.0; + Real64 Pa = RH * pvstar(Ta); + Real64 Rs = 0.0387; + Real64 phi = 0.84; + Real64 m = (Pc - Pa) / (Zs(Rs) + Za); + Real64 m_bar = (Pc - Pa) / (Zs(Rs) + Za_bar); + Real64 Ts; + int SolFla; + General::SolveRoot( + state, + tol, + maxIter, + SolFla, + Ts, + [&](Real64 Ts) { return (Ts - Ta) / Ra(Ts, Ta) + (Pc - Pa) / (Zs(Rs) + Za) - (Tc - Ts) / Rs; }, + std::max(0.0, std::min(Tc, Ta) - Rs * std::abs(m)), + std::max(Tc, Ta) + Rs * std::abs(m)); + Real64 Tf; + General::SolveRoot( + state, + tol, + maxIter, + SolFla, + Tf, + [&](Real64 Tf) { return (Tf - Ta) / Ra_bar(Tf, Ta) + (Pc - Pa) / (Zs(Rs) + Za_bar) - (Tc - Tf) / Rs; }, + std::max(0.0, std::min(Tc, Ta) - Rs * std::abs(m_bar)), + std::max(Tc, Ta) + Rs * std::abs(m_bar)); + Real64 flux1 = Q - Qv(Ta, Pa) - (1.0 - phi) * (Tc - Ts) / Rs; + Real64 flux2 = Q - Qv(Ta, Pa) - (1.0 - phi) * (Tc - Ts) / Rs - phi * (Tc - Tf) / Rs; + Real64 flux3 = Q - Qv(Ta, Pa) - (Tc - Ta) / Ra_un(Tc, Ta) - (phi_salt * pvstar(Tc) - Pa) / Za_un; + if (flux1 > 0.0 && flux2 > 0.0 && flux3 >= 0.0) { + dTcdt = (1.0 / C) * flux3; + } + return dTcdt; + } - std::tuple find_eqvar(EnergyPlusData &state, Real64 Ta, Real64 RH) + // given T and RH, returns a key and value pair + std::tuple find_eqvar(EnergyPlusData &state, Real64 Ta, Real64 RH) { Real64 Pa = RH * pvstar(Ta); Real64 Rs = 0.0387; @@ -204,15 +380,16 @@ namespace ExtendedHI { std::max(Tc, Ta) + Rs * std::abs(m_bar)); Real64 flux1 = Q - Qv(Ta, Pa) - (1.0 - phi) * (Tc - Ts) / Rs; Real64 flux2 = Q - Qv(Ta, Pa) - (1.0 - phi) * (Tc - Ts) / Rs - phi * (Tc - Tf) / Rs; - std::string eqvar_name; + int eqvar_name; Real64 Rf; if (flux1 <= 0.0) { - eqvar_name = "phi"; + eqvar_name = static_cast(eqvarName::phi); phi = 1.0 - (Q - Qv(Ta, Pa)) * Rs / (Tc - Ts); Rf = std::numeric_limits::infinity(); + return {eqvar_name, phi}; } else if (flux2 <= 0.0) { - eqvar_name = "Rf"; + eqvar_name = static_cast(eqvarName::Rf); Real64 Ts_bar = Tc - (Q - Qv(Ta, Pa)) * Rs / phi + (1.0 / phi - 1.0) * (Tc - Ts); General::SolveRoot( state, @@ -227,6 +404,7 @@ namespace ExtendedHI { Ta, Ts_bar); Rf = Ra_bar(Tf, Ta) * (Ts_bar - Tf) / (Tf - Ta); + return {eqvar_name, Rf}; } else { Rf = 0.0; Real64 flux3 = Q - Qv(Ta, Pa) - (Tc - Ta) / Ra_un(Tc, Ta) - (phi_salt * pvstar(Tc) - Pa) / Za_un; @@ -241,7 +419,7 @@ namespace ExtendedHI { 0.0, Tc); Rs = (Tc - Ts) / (Q - Qv(Ta, Pa)); - eqvar_name = "Rs"; + eqvar_name = static_cast(eqvarName::Rs); Real64 Ps = Pc - (Pc - Pa) * Zs(Rs) / (Zs(Rs) + Za_un); if (Ps > phi_salt * pvstar(Ts)) { General::SolveRoot( @@ -254,42 +432,42 @@ namespace ExtendedHI { 0.0, Tc); Rs = (Tc - Ts) / (Q - Qv(Ta, Pa)); - eqvar_name = "Rs*"; } + return {eqvar_name, Rs}; } else { Rs = 0.0; - eqvar_name = "dTcdt"; + eqvar_name = static_cast(eqvarName::dTcdt); dTcdt = (1.0 / C) * flux3; + return {eqvar_name, dTcdt}; } } - return {eqvar_name, phi, Rf, Rs, dTcdt}; } // Convert the find_T function - Real64 find_T(EnergyPlusData &state, std::string eqvar_name, Real64 eqvar) + Real64 find_T(EnergyPlusData &state, int eqvar_name, Real64 eqvar) { Real64 T; int SolFla; - if (eqvar_name == "phi") { + if (eqvar_name == static_cast(eqvarName::phi)) { General::SolveRoot( - state, tol, maxIter, SolFla, T, [&](Real64 T) { return std::get<1>(find_eqvar(state, T, 1.0)) - eqvar; }, 0.0, 240.0); - } else if (eqvar_name == "Rf") { + state, tol, maxIter, SolFla, T, [&](Real64 T) { return find_eqvar_phi(state, T, 1.0) - eqvar; }, 0.0, 240.0); + } else if (eqvar_name == static_cast(eqvarName::Rf)) { General::SolveRoot( state, tol, maxIter, SolFla, T, - [&](Real64 T) { return std::get<2>(find_eqvar(state, T, std::min(1.0, Pa0 / pvstar(T)))) - eqvar; }, + [&](Real64 T) { return (find_eqvar_Rf(state, T, std::min(1.0, Pa0 / pvstar(T)))) - eqvar; }, 230.0, 300.0); - } else if (eqvar_name == "Rs" || eqvar_name == "Rs*") { + } else if (eqvar_name == static_cast(eqvarName::Rs)) { General::SolveRoot( - state, tol, maxIter, SolFla, T, [&](Real64 T) { return std::get<3>(find_eqvar(state, T, Pa0 / pvstar(T))) - eqvar; }, 295.0, 350.0); + state, tol, maxIter, SolFla, T, [&](Real64 T) { return find_eqvar_rs(state, T, Pa0 / pvstar(T)) - eqvar; }, 295.0, 350.0); } else { General::SolveRoot( - state, tol, maxIter, SolFla, T, [&](Real64 T) { return std::get<4>(find_eqvar(state, T, Pa0 / pvstar(T))) - eqvar; }, 340.0, 1000.0); + state, tol, maxIter, SolFla, T, [&](Real64 T) { return find_eqvar_dTcdt(state, T, Pa0 / pvstar(T)) - eqvar; }, 340.0, 1000.0); } return T; @@ -304,20 +482,9 @@ namespace ExtendedHI { auto const HVACSystemRootSolverBackup = state.dataRootFinder->HVACSystemRootFinding.HVACSystemRootSolver; state.dataRootFinder->HVACSystemRootFinding.HVACSystemRootSolver = HVACSystemRootSolverAlgorithm::Bisection; - // Dictionary to map eqvar_name to tuple index - std::map dic = {{"phi", 1}, {"Rf", 2}, {"Rs", 3}, {"Rs*", 3}, {"dTcdt", 4}}; auto eqvars = find_eqvar(state, Ta, RH); - std::string eqvar_name = std::get<0>(eqvars); - Real64 eqvar_value; - if (eqvar_name == "phi") { - eqvar_value = std::get<1>(eqvars); - } else if (eqvar_name == "Rf") { - eqvar_value = std::get<2>(eqvars); - } else if (eqvar_name == "Rs" || eqvar_name == "Rs*") { - eqvar_value = std::get<3>(eqvars); - } else if (eqvar_name == "dTcdt") { - eqvar_value = std::get<4>(eqvars); - } + int eqvar_name = std::get<0>(eqvars); + Real64 eqvar_value = std::get<1>(eqvars); Real64 T = find_T(state, eqvar_name, eqvar_value); diff --git a/src/EnergyPlus/ExtendedHI.hh b/src/EnergyPlus/ExtendedHI.hh index 78d6ea8fa3b..69e46ba7f70 100644 --- a/src/EnergyPlus/ExtendedHI.hh +++ b/src/EnergyPlus/ExtendedHI.hh @@ -60,6 +60,16 @@ struct EnergyPlusData; namespace ExtendedHI { + enum class eqvarName + { + Invalid = -1, + phi = 1, + Rf = 2, + Rs = 3, + dTcdt = 4, + Num + }; + Real64 pvstar(Real64 T); Real64 Le(Real64 T); Real64 Qv(Real64 Ta, Real64 Pa); @@ -67,8 +77,11 @@ namespace ExtendedHI { Real64 Ra(Real64 Ts, Real64 Ta); Real64 Ra_bar(Real64 Tf, Real64 Ta); Real64 Ra_un(Real64 Ts, Real64 Ta); - std::tuple find_eqvar(EnergyPlusData &state, double Ta, double RH); - Real64 find_T(EnergyPlusData &state, std::string eqvar_name, Real64 eqvar); + Real64 find_eqvar_phi(EnergyPlusData &state, Real64 Ta, Real64 RH); + Real64 find_eqvar_Rf(EnergyPlusData &state, Real64 Ta, Real64 RH); + Real64 find_eqvar_rs(EnergyPlusData &state, Real64 Ta, Real64 RH); + std::tuple find_eqvar(EnergyPlusData &state, double Ta, double RH); + Real64 find_T(EnergyPlusData &state, int eqvar_name, Real64 eqvar); Real64 heatindex(EnergyPlusData &state, Real64 Ta, Real64 RH); } // namespace ExtendedHI diff --git a/tst/EnergyPlus/unit/ExtendedHI.unit.cc b/tst/EnergyPlus/unit/ExtendedHI.unit.cc index 96fa5386fd7..95662f584f2 100644 --- a/tst/EnergyPlus/unit/ExtendedHI.unit.cc +++ b/tst/EnergyPlus/unit/ExtendedHI.unit.cc @@ -60,29 +60,31 @@ #include using namespace EnergyPlus; +using namespace ExtendedHI; TEST_F(EnergyPlusFixture, extendedHI_pvstar) { Real64 tol = 1e-8; std::vector T_values = {200, 210, 220, 230, 240, 250, 260, 270, 280, 290, 300, 310, 320, 330, 340, 350, 360, 370}; - std::vector result = {0.16315953136381425, - 0.7045737646159884, - 2.6639212639290717, - 8.972721335550697, - 27.315394188834492, - 76.0747215114313, - 195.83100375810935, - 470.0335224802147, - 991.9254222637857, - 1920.6801555359402, - 3538.9408236895683, - 6235.887915937109, - 10554.04916628072, - 17222.314773780665, - 27187.715714871047, - 41643.766112228834, - 62053.2640569111, - 90163.72448626769}; + std::vector result = {0.16315953, + 0.70457376, + 2.66392126, + 8.97272134, + 27.31539419, + 76.07472151, + 195.83100376, + 470.03352248, + 991.92542226, + 1920.68015554, + 3538.94082369, + 6235.88791594, + 10554.04916628, + 17222.31477378, + 27187.71571487, + 41643.76611223, + 62053.26405691, + 90163.72448627}; + for (size_t i = 0; i < T_values.size(); ++i) { EXPECT_NEAR(ExtendedHI::pvstar(T_values[i]), result[i], tol); } @@ -90,7 +92,7 @@ TEST_F(EnergyPlusFixture, extendedHI_pvstar) TEST_F(EnergyPlusFixture, extendedHI_Le) { - Real64 tol = 1e-8; + Real64 tol = 1e-2; std::vector T_values = {200, 210, 220, 230, 240, 250, 260, 270, 280, 290, 300, 310, 320, 330, 340, 350, 360, 370}; std::vector result = {2663805.16, 2641405.16, @@ -120,24 +122,24 @@ TEST_F(EnergyPlusFixture, extendedHI_Qv) Real64 tol = 1e-8; std::vector T_values = {200, 210, 220, 230, 240, 250, 260, 270, 280, 290, 300, 310, 320, 330, 340, 350, 360, 370}; std::vector P_values = {1, 10, 100, 1000, 10000}; - std::vector> result = {{49.94618970804489, 49.91176798964203, 49.56755080561335, 46.125378965326625, 11.703660562459378}, - {47.3566427480449, 47.32222102964202, 46.97800384561336, 43.53583200532663, 9.114113602459378}, - {44.76709578804489, 44.73267406964202, 44.38845688561335, 40.94628504532663, 6.5245666424593765}, - {42.17754882804489, 42.14312710964202, 41.79890992561335, 38.356738085326626, 3.9350196824593775}, - {39.58800186804489, 39.55358014964203, 39.20936296561336, 35.76719112532663, 1.3454727224593785}, - {36.998454908044884, 36.96403318964203, 36.61981600561335, 33.177644165326626, -1.2440742375406237}, - {34.4089079480449, 34.374486229642024, 34.03026904561336, 30.58809720532663, -3.8336211975406225}, - {31.819360988044888, 31.784939269642024, 31.440722085613352, 27.99855024532663, -6.423168157540623}, - {29.229814028044892, 29.195392309642024, 28.851175125613352, 25.409003285326627, -9.012715117540624}, - {26.640267068044892, 26.605845349642024, 26.261628165613356, 22.819456325326627, -11.602262077540622}, - {24.05072010804489, 24.016298389642024, 23.672081205613352, 20.229909365326627, -14.191809037540622}, - {21.461173148044892, 21.426751429642025, 21.082534245613353, 17.640362405326627, -16.781355997540622}, - {18.871626188044893, 18.837204469642025, 18.492987285613356, 15.050815445326627, -19.370902957540622}, - {16.28207922804489, 16.247657509642025, 15.903440325613353, 12.461268485326626, -21.960449917540625}, - {13.692532268044891, 13.658110549642025, 13.313893365613353, 9.871721525326627, -24.549996877540625}, - {11.102985308044891, 11.068563589642023, 10.724346405613353, 7.282174565326627, -27.139543837540625}, - {8.51343834804489, 8.479016629642024, 8.134799445613353, 4.692627605326626, -29.729090797540625}, - {5.923891388044891, 5.889469669642025, 5.545252485613354, 2.1030806453266275, -32.31863775754062}}; + std::vector> result = {{49.94618971, 49.91176799, 49.56755081, 46.12537897, 11.70366056}, + {47.35664275, 47.32222103, 46.97800385, 43.53583201, 9.1141136}, + {44.76709579, 44.73267407, 44.38845689, 40.94628505, 6.52456664}, + {42.17754883, 42.14312711, 41.79890993, 38.35673809, 3.93501968}, + {39.58800187, 39.55358015, 39.20936297, 35.76719113, 1.34547272}, + {36.99845491, 36.96403319, 36.61981601, 33.17764417, -1.24407424}, + {34.40890795, 34.37448623, 34.03026905, 30.58809721, -3.8336212}, + {31.81936099, 31.78493927, 31.44072209, 27.99855025, -6.42316816}, + {29.22981403, 29.19539231, 28.85117513, 25.40900329, -9.01271512}, + {26.64026707, 26.60584535, 26.26162817, 22.81945633, -11.60226208}, + {24.05072011, 24.01629839, 23.67208121, 20.22990937, -14.19180904}, + {21.46117315, 21.42675143, 21.08253425, 17.64036241, -16.781356}, + {18.87162619, 18.83720447, 18.49298729, 15.05081545, -19.37090296}, + {16.28207923, 16.24765751, 15.90344033, 12.46126849, -21.96044992}, + {13.69253227, 13.65811055, 13.31389337, 9.87172153, -24.54999688}, + {11.10298531, 11.06856359, 10.72434641, 7.28217457, -27.13954384}, + {8.51343835, 8.47901663, 8.13479945, 4.69262761, -29.7290908}, + {5.92389139, 5.88946967, 5.54525249, 2.10308065, -32.31863776}}; for (size_t i = 0; i < T_values.size(); ++i) { for (size_t j = 0; j < P_values.size(); ++j) { EXPECT_NEAR(ExtendedHI::Qv(T_values[i], P_values[j]), result[i][j], tol); @@ -160,55 +162,13 @@ TEST_F(EnergyPlusFixture, extendedHI_Ra) Real64 tol = 1e-8; std::vector Ts_values = {240, 260, 280, 300, 320, 340, 360}; std::vector Ta_values = {240, 260, 280, 300, 320, 340, 360}; - std::vector> result = {{0.05003742549640303, - 0.04919686900951711, - 0.0482949471609349, - 0.04733482621494337, - 0.046320477644314524, - 0.04525658366932734, - 0.04414842527373929}, - {0.04919686900951711, - 0.04834034953171599, - 0.04742549966979792, - 0.04645568018096253, - 0.04543499562267212, - 0.044368197070707924, - 0.04326056977845574}, - {0.0482949471609349, - 0.04742549966979792, - 0.04650092325775173, - 0.04552473014716025, - 0.04450111356275697, - 0.04343484913155035, - 0.04233118361901477}, - {0.04733482621494337, - 0.04645568018096253, - 0.04552473014716025, - 0.04454559620854969, - 0.04352251644673171, - 0.04246024843823163, - 0.041363960371290795}, - {0.046320477644314524, - 0.04543499562267212, - 0.04450111356275697, - 0.04352251644673171, - 0.04250344511572377, - 0.04144859919286657, - 0.040363031720372144}, - {0.04525658366932734, - 0.044368197070707924, - 0.04343484913155035, - 0.04246024843823163, - 0.04144859919286657, - 0.04040450670241235, - 0.03933287648842351}, - {0.04414842527373929, - 0.04326056977845574, - 0.04233118361901477, - 0.041363960371290795, - 0.040363031720372144, - 0.03933287648842351, - 0.03827822497025564}}; + std::vector> result = {{0.05003743, 0.04919687, 0.04829495, 0.04733483, 0.04632048, 0.04525658, 0.04414843}, + {0.04919687, 0.04834035, 0.0474255, 0.04645568, 0.045435, 0.0443682, 0.04326057}, + {0.04829495, 0.0474255, 0.04650092, 0.04552473, 0.04450111, 0.04343485, 0.04233118}, + {0.04733483, 0.04645568, 0.04552473, 0.0445456, 0.04352252, 0.04246025, 0.04136396}, + {0.04632048, 0.045435, 0.04450111, 0.04352252, 0.04250345, 0.0414486, 0.04036303}, + {0.04525658, 0.0443682, 0.04343485, 0.04246025, 0.0414486, 0.04040451, 0.03933288}, + {0.04414843, 0.04326057, 0.04233118, 0.04136396, 0.04036303, 0.03933288, 0.03827822}}; for (size_t i = 0; i < Ts_values.size(); ++i) { for (size_t j = 0; j < Ta_values.size(); ++j) { EXPECT_NEAR(ExtendedHI::Ra(Ts_values[i], Ta_values[j]), result[i][j], tol); @@ -221,55 +181,14 @@ TEST_F(EnergyPlusFixture, extendedHI_Ra_bar) Real64 tol = 1e-8; std::vector Tf_values = {240, 260, 280, 300, 320, 340, 360}; std::vector Ta_values = {240, 260, 280, 300, 320, 340, 360}; - std::vector> result = {{0.07141547425826913, - 0.0698327896993347, - 0.06815365152671275, - 0.06638750352391155, - 0.0645450734750961, - 0.06263806274737325, - 0.060678819043721195}, - {0.0698327896993347, - 0.06823771141282657, - 0.06655336747218435, - 0.06478927443631394, - 0.06295606908639516, - 0.06106520744639883, - 0.0591286533968074}, - {0.06815365152671275, - 0.06655336747218435, - 0.06487108590376367, - 0.06311628619901372, - 0.061299411560035544, - 0.0594315809828658, - 0.05752429636310142}, - {0.06638750352391155, - 0.06478927443631394, - 0.06311628619901372, - 0.06137787932930683, - 0.0595842117328534, - 0.057745986422442296, - 0.05587417899074831}, - {0.0645450734750961, - 0.06295606908639516, - 0.061299411560035544, - 0.0595842117328534, - 0.05782026331305135, - 0.05601778840676245, - 0.05418718649514485}, - {0.06263806274737325, - 0.06106520744639883, - 0.0594315809828658, - 0.057745986422442296, - 0.05601778840676245, - 0.054256677818840554, - 0.05247244272030079}, - {0.060678819043721195, - 0.0591286533968074, - 0.05752429636310142, - 0.05587417899074831, - 0.05418718649514485, - 0.05247244272030079, - 0.0507391028959455}}; + std::vector> result = {{0.07141547, 0.06983279, 0.06815365, 0.0663875, 0.06454507, 0.06263806, 0.06067882}, + {0.06983279, 0.06823771, 0.06655337, 0.06478927, 0.06295607, 0.06106521, 0.05912865}, + {0.06815365, 0.06655337, 0.06487109, 0.06311629, 0.06129941, 0.05943158, 0.0575243}, + {0.0663875, 0.06478927, 0.06311629, 0.06137788, 0.05958421, 0.05774599, 0.05587418}, + {0.06454507, 0.06295607, 0.06129941, 0.05958421, 0.05782026, 0.05601779, 0.05418719}, + {0.06263806, 0.06106521, 0.05943158, 0.05774599, 0.05601779, 0.05425668, 0.05247244}, + {0.06067882, 0.05912865, 0.0575243, 0.05587418, 0.05418719, 0.05247244, 0.0507391}}; + for (size_t i = 0; i < Tf_values.size(); ++i) { for (size_t j = 0; j < Ta_values.size(); ++j) { EXPECT_NEAR(ExtendedHI::Ra_bar(Tf_values[i], Ta_values[j]), result[i][j], tol); @@ -282,55 +201,13 @@ TEST_F(EnergyPlusFixture, extendedHI_Ra_un) Real64 tol = 1e-8; std::vector Tf_values = {240, 260, 280, 300, 320, 340, 360}; std::vector Ta_values = {240, 260, 280, 300, 320, 340, 360}; - std::vector> result = {{0.06787493202819687, - 0.06642598354057656, - 0.06488609100341329, - 0.06326346252950685, - 0.06156752777670731, - 0.05980867097828581, - 0.05799794522838118}, - {0.06642598354057656, - 0.06496324482301812, - 0.06341597668917175, - 0.0617925013672891, - 0.06010221781318763, - 0.05835534085968962, - 0.056562627404263835}, - {0.06488609100341329, - 0.06341597668917175, - 0.06186785837632265, - 0.06025007445646361, - 0.0585719003382978, - 0.056843296943746194, - 0.05507465133709833}, - {0.06326346252950685, - 0.0617925013672891, - 0.06025007445646361, - 0.05864444445695526, - 0.056984678844683855, - 0.055280410417843366, - 0.05354159428335702}, - {0.06156752777670731, - 0.06010221781318763, - 0.0585719003382978, - 0.056984678844683855, - 0.05534933885591997, - 0.05367512249775102, - 0.05197150313175455}, - {0.05980867097828581, - 0.05835534085968962, - 0.056843296943746194, - 0.055280410417843366, - 0.05367512249775102, - 0.05203623450490319, - 0.0503727008434497}, - {0.05799794522838118, - 0.056562627404263835, - 0.05507465133709833, - 0.05354159428335702, - 0.05197150313175455, - 0.0503727008434497, - 0.04875359793440157}}; + std::vector> result = {{0.06787493, 0.06642598, 0.06488609, 0.06326346, 0.06156753, 0.05980867, 0.05799795}, + {0.06642598, 0.06496324, 0.06341598, 0.0617925, 0.06010222, 0.05835534, 0.05656263}, + {0.06488609, 0.06341598, 0.06186786, 0.06025007, 0.0585719, 0.0568433, 0.05507465}, + {0.06326346, 0.0617925, 0.06025007, 0.05864444, 0.05698468, 0.05528041, 0.05354159}, + {0.06156753, 0.06010222, 0.0585719, 0.05698468, 0.05534934, 0.05367512, 0.0519715}, + {0.05980867, 0.05835534, 0.0568433, 0.05528041, 0.05367512, 0.05203623, 0.0503727}, + {0.05799795, 0.05656263, 0.05507465, 0.05354159, 0.0519715, 0.0503727, 0.0487536}}; for (size_t i = 0; i < Tf_values.size(); ++i) { for (size_t j = 0; j < Ta_values.size(); ++j) { EXPECT_NEAR(ExtendedHI::Ra_un(Tf_values[i], Ta_values[j]), result[i][j], tol); @@ -343,47 +220,62 @@ TEST_F(EnergyPlusFixture, extendedHI_find_eqvar) Real64 tol = 1e-5; std::vector Ta_values = {240, 260, 280, 300, 320, 340, 360}; std::vector RH_values = {0, 0.2, 0.4, 0.6, 0.8, 1.0}; - std::vector> result_0 = {{"Rf", "Rf", "Rf", "Rf", "Rf", "Rf"}, - {"Rf", "Rf", "Rf", "Rf", "Rf", "Rf"}, - {"Rf", "Rf", "Rf", "Rf", "Rf", "Rf"}, - {"Rf", "Rs", "Rs", "Rs", "Rs", "Rs"}, - {"Rs", "Rs", "dTcdt", "dTcdt", "dTcdt", "dTcdt"}, - {"Rs", "dTcdt", "dTcdt", "dTcdt", "dTcdt", "dTcdt"}, - {"Rs*", "dTcdt", "dTcdt", "dTcdt", "dTcdt", "dTcdt"}}; - Real64 result_1 = 0.84; - std::vector> result_2 = { - {33.04275493601435, 32.695633042229204, 32.355420488419746, 32.02191338684983, 31.694909211003484, 31.374226422935042}, - {1.5604330579759274, 1.546333295029165, 1.5323814066211647, 1.518575393945302, 1.504913229554858, 1.491392978806081}, - {0.4424813164108615, 0.42287513206662247, 0.40403359558586455, 0.3859354349292241, 0.3685598262740109, 0.35188630624297995}, - {0.011072874985460073, 0.0, 0.0, 0.0, 0.0, 0.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0}}; - std::vector> result_3 = { - {0.0387, 0.0387, 0.0387, 0.0387, 0.0387, 0.0387}, - {0.0387, 0.0387, 0.0387, 0.0387, 0.0387, 0.0387}, - {0.0387, 0.0387, 0.0387, 0.0387, 0.0387, 0.0387}, - {0.0387, 0.038212662537193985, 0.03685000138053738, 0.03532725311254958, 0.033563489978529426, 0.031401997100220014}, - {0.026992716499180645, 0.02259372764887033, 0.0, 0.0, 0.0, 0.0}, - {0.02072684837877413, 0.0, 0.0, 0.0, 0.0, 0.0}, - {0.0014681498999064508, 0.0, 0.0, 0.0, 0.0, 0.0}}; - std::vector> result_4 = { - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0}, - {0.0, 0.0, 0.0, 0.0, 0.0, 0.0}, - {0.0, 0.0, 0.00048496625767469157, 0.003383747126335647, 0.006282527994996603, 0.00918130886365756}, - {0.0, 0.004663667586060751, 0.012131060331269492, 0.019598453076478232, 0.02706584582168697, 0.034533238566895705}, - {0.0, 0.016910954386734945, 0.03395453755108459, 0.05099812071543423, 0.06804170387978387, 0.0850852870441335}}; + std::vector> result_0 = {{static_cast(eqvarName::Rf), + static_cast(eqvarName::Rf), + static_cast(eqvarName::Rf), + static_cast(eqvarName::Rf), + static_cast(eqvarName::Rf), + static_cast(eqvarName::Rf)}, + {static_cast(eqvarName::Rf), + static_cast(eqvarName::Rf), + static_cast(eqvarName::Rf), + static_cast(eqvarName::Rf), + static_cast(eqvarName::Rf), + static_cast(eqvarName::Rf)}, + {static_cast(eqvarName::Rf), + static_cast(eqvarName::Rf), + static_cast(eqvarName::Rf), + static_cast(eqvarName::Rf), + static_cast(eqvarName::Rf), + static_cast(eqvarName::Rf)}, + {static_cast(eqvarName::Rf), + static_cast(eqvarName::Rs), + static_cast(eqvarName::Rs), + static_cast(eqvarName::Rs), + static_cast(eqvarName::Rs), + static_cast(eqvarName::Rs)}, + {static_cast(eqvarName::Rs), + static_cast(eqvarName::Rs), + static_cast(eqvarName::dTcdt), + static_cast(eqvarName::dTcdt), + static_cast(eqvarName::dTcdt), + static_cast(eqvarName::dTcdt)}, + {static_cast(eqvarName::Rs), + static_cast(eqvarName::dTcdt), + static_cast(eqvarName::dTcdt), + static_cast(eqvarName::dTcdt), + static_cast(eqvarName::dTcdt), + static_cast(eqvarName::dTcdt)}, + {static_cast(eqvarName::Rs), + static_cast(eqvarName::dTcdt), + static_cast(eqvarName::dTcdt), + static_cast(eqvarName::dTcdt), + static_cast(eqvarName::dTcdt), + static_cast(eqvarName::dTcdt)}}; + + std::vector> result_1 = {{33.04275, 32.69563, 32.35542, 32.02191, 31.69491, 31.37423}, + {1.56043, 1.54633, 1.53238, 1.51858, 1.50491, 1.49139}, + {0.44248, 0.42288, 0.40403, 0.38594, 0.36856, 0.35189}, + {0.01107, 0.03821, 0.03685, 0.03533, 0.03356, 0.0314}, + {0.02699, 0.02259, 0.00048, 0.00338, 0.00628, 0.00918}, + {0.02073, 0.00466, 0.01213, 0.0196, 0.02707, 0.03453}, + {0.00147, 0.01691, 0.03395, 0.051, 0.06804, 0.08509}}; for (size_t i = 0; i < Ta_values.size(); ++i) { for (size_t j = 0; j < RH_values.size(); ++j) { auto const output = ExtendedHI::find_eqvar(*state, Ta_values[i], RH_values[j]); EXPECT_EQ(std::get<0>(output), result_0[i][j]); - EXPECT_EQ(std::get<1>(output), result_1); - EXPECT_NEAR(std::get<2>(output), result_2[i][j], tol); - EXPECT_NEAR(std::get<3>(output), result_3[i][j], tol); - EXPECT_NEAR(std::get<4>(output), result_4[i][j], tol); + EXPECT_NEAR(std::get<1>(output), result_1[i][j], tol); } } } @@ -393,52 +285,56 @@ TEST_F(EnergyPlusFixture, extendedHI_find_T) Real64 tol = 1e-7; state->dataRootFinder->HVACSystemRootFinding.HVACSystemRootSolver = HVACSystemRootSolverAlgorithm::Bisection; std::vector Rf_values = {30, 32, 34, 36, 38}; - std::vector result_0_rf = {240.06754042464308, 239.971123727737, 239.88581076147966, 239.8097881616559, 239.7416166716721}; + std::vector result_0_rf = {240.0675404, 239.9711237, 239.8858108, 239.8097882, 239.7416167}; for (size_t i = 0; i < Rf_values.size(); ++i) { - EXPECT_NEAR(ExtendedHI::find_T(*state, "Rf", Rf_values[i]), result_0_rf[i], tol); + EXPECT_NEAR(ExtendedHI::find_T(*state, static_cast(EnergyPlus::ExtendedHI::eqvarName::Rf), Rf_values[i]), result_0_rf[i], tol); } std::vector Rs_values = {0.01, 0.02, 0.03}; - std::vector result_0_rs = {337.8696502133971, 329.7586998442421, 307.4815719091566}; + std::vector result_0_rs = {337.8697, 329.7587, 307.4816}; tol = 1e-4; for (size_t i = 0; i < Rs_values.size(); ++i) { - EXPECT_NEAR(ExtendedHI::find_T(*state, "Rs", Rs_values[i]), result_0_rs[i], tol); + EXPECT_NEAR(ExtendedHI::find_T(*state, static_cast(EnergyPlus::ExtendedHI::eqvarName::Rs), Rs_values[i]), result_0_rs[i], tol); + } + std::vector phi_values = {0.86, 0.88, 0.90, 0.92, 0.94, 0.96}; + std::vector result_0_phi = {228.6900, 215.9994, 199.0012, 175.1865, 139.7124, 82.0478}; + for (size_t i = 0; i < phi_values.size(); ++i) { + EXPECT_NEAR(ExtendedHI::find_T(*state, static_cast(EnergyPlus::ExtendedHI::eqvarName::phi), phi_values[i]), result_0_phi[i], tol); + } + std::vector dTcdt_values = {0.01, 0.03, 0.05, 0.07, 0.09}; + std::vector result_0_dTcdt = {412.5272, 512.3596, 584.547, 641.1988, 688.0423}; + for (size_t i = 0; i < dTcdt_values.size(); ++i) { + EXPECT_NEAR(ExtendedHI::find_T(*state, static_cast(EnergyPlus::ExtendedHI::eqvarName::dTcdt), dTcdt_values[i]), result_0_dTcdt[i], tol); } - // fixme: this one has large diff, 347 vs 350, because of the difference in the root solvers between EnergyPlus and the heatindex.py code by Lu - // and Romps. - // auto const output = ExtendedHI::find_T(*state, "Rs", 349.99999999359716); EXPECT_NEAR(std::get<0>(ExtendedHI::find_T(*state, "Rs", - // 0.0), result_0_rs[i], tol); } TEST_F(EnergyPlusFixture, extendedHI_heatindex) { - // fixme: not finished state->dataRootFinder->HVACSystemRootFinding.HVACSystemRootSolver = HVACSystemRootSolverAlgorithm::Bisection; - std::vector> HI_values = {{199.9994020652, 199.9997010342, 200.0000000021}, - {209.9975943902, 209.9987971085, 209.9999998068}, - {219.9915822029, 219.9957912306, 219.9999999912}, - {229.9739691979, 229.9869861009, 230.0000001850}, - {239.9253828022, 239.9626700074, 240.0000000003}, - {249.7676757244, 249.8837049107, 250.0000000037}, - {259.3735990024, 259.6864068902, 259.9999999944}, - {268.5453870455, 269.2745889562, 270.0000002224}, - {277.2234200026, 278.6369451963, 280.0000000091}, - {285.7510545370, 288.2813660100, 290.7860610129}, - {297.5737503539, 300.2922595865, 305.3947127590}, - {305.5549530893, 318.6225524695, 359.9063248191}, - {313.0298872791, 359.0538750602, 407.5345212438}, - {320.5088548469, 398.5759733823, 464.9949352940}, - {328.0358006469, 445.8599463105, 530.5524786708}, - {333.2806160592, 500.0421800191, 601.9518435268}, - {343.6312984164, 559.6640227151, 677.2462089759}, - {354.1825692377, 623.1960299857, 755.0832658147}}; + std::vector> HI_values = {{199.9994, 199.9997, 200.0}, + {209.9976, 209.9988, 210.0}, + {219.9916, 219.9958, 220.0}, + {229.974, 229.987, 230.0}, + {239.9254, 239.9627, 240.0}, + {249.7677, 249.8837, 250.0}, + {259.3736, 259.6864, 260.0}, + {268.5454, 269.2746, 270.0}, + {277.2234, 278.6369, 280.0}, + {285.7511, 288.2814, 290.7861}, + {297.5738, 300.2923, 305.3947}, + {305.555, 318.6226, 359.9063}, + {313.0299, 359.0539, 407.5345}, + {320.5089, 398.576, 464.9949}, + {328.0358, 445.8599, 530.5525}, + {333.2806, 500.0422, 601.9518}, + {343.6313, 559.664, 677.2462}, + {354.1826, 623.196, 755.0833}}; std::vector T_values = {200, 210, 220, 230, 240, 250, 260, 270, 280, 290, 300, 310, 320, 330, 340, 350, 360, 370}; std::vector RH_values = {0, 0.5, 1}; Real64 tol = 1e-4; - // fixme, this one has issue: ExtendedHI::heatindex(*state, 310, 0.5); for (size_t i = 0; i < T_values.size(); ++i) { for (size_t j = 0; j < RH_values.size(); ++j) { Real64 HI = HI_values[i][j];