diff --git a/dev/scripts/generate_Plot_test_data.py b/dev/scripts/generate_Plot_test_data.py index a0b613a6..153653cc 100644 --- a/dev/scripts/generate_Plot_test_data.py +++ b/dev/scripts/generate_Plot_test_data.py @@ -171,7 +171,7 @@ def generate_ts_test(): for i in range(5): value = plot._isolines[py_param][i].value if cpp_name == 'P': - print(f' CHECK_THAT({cpp_name.lower()}_isolines[{i}].value, WithinAbs({value}, 1e-8));') + print(f' CHECK_THAT({cpp_name.lower()}_isolines[{i}].value, WithinAbs({value}, 1e-7));') else: print(f' CHECK_THAT({cpp_name.lower()}_isolines[{i}].value, WithinAbs({value}, 1e-10));') diff --git a/src/CoolPropPlot.cpp b/src/CoolPropPlot.cpp index 7cac1070..ad7b5b3f 100644 --- a/src/CoolPropPlot.cpp +++ b/src/CoolPropPlot.cpp @@ -438,8 +438,8 @@ TEST_CASE("Check value_at for p-h plots", "[Plot]") { CHECK_THAT(plot.value_at(CoolProp::iP, 300000/*Pa*/, 200000/*J/kg*/), WithinAbs(200000, 1e-10)); CHECK_THAT(plot.value_at(CoolProp::iHmass, 300000, 200000), WithinAbs(300000, 1e-10)); - CHECK_THAT(plot.value_at(CoolProp::iT, 300000, 200000), WithinAbs(263.07372753976784, 1e-10)); - CHECK_THAT(plot.value_at(CoolProp::iQ, 300000, 200000), WithinAbs(0.550443478743443, 1e-10)); + CHECK_THAT(plot.value_at(CoolProp::iT, 300000, 200000), WithinAbs(263.0737275397678, 1e-10)); + CHECK_THAT(plot.value_at(CoolProp::iQ, 300000, 200000), WithinAbs(0.5504434787434432, 1e-10)); } TEST_CASE("Check that the isolines are the same as from Python", "[Plot]") { CoolProp::Plot::PropertyPlot plot("HEOS::R134a", CoolProp::iP, CoolProp::iHmass, CoolProp::Plot::TPLimits::Achp); @@ -451,9 +451,9 @@ TEST_CASE("Check that the isolines are the same as from Python", "[Plot]") { CHECK(plot.xaxis.scale == CoolProp::Plot::Scale::Lin); CHECK(plot.yaxis.scale == CoolProp::Plot::Scale::Log); - CHECK_THAT(plot.xaxis.min, WithinAbs(75373.12689908473, 1)); - CHECK_THAT(plot.xaxis.max, WithinAbs(577604.5949752147, 1)); - CHECK_THAT(plot.yaxis.min, WithinAbs(24999.999999924632, 1)); + CHECK_THAT(plot.xaxis.min, WithinAbs(75373.12689908482, 1)); + CHECK_THAT(plot.xaxis.max, WithinAbs(577604.5949752146, 1)); + CHECK_THAT(plot.yaxis.min, WithinAbs(25000.0, 1)); CHECK_THAT(plot.yaxis.max, WithinAbs(9133370.875847604, 1)); std::vector iso_types = plot.supported_isoline_keys(); @@ -508,18 +508,18 @@ TEST_CASE("Check that the isolines are the same as from Python", "[Plot]") { CHECK_THAT(t_isolines[3].value, WithinAbs(384.5375, 1e-10)); CHECK_THAT(t_isolines[4].value, WithinAbs(455.0, 1e-10)); const double expected_x[isoline_count][points_per_isoline] = { - {75373.1268990847, 75410.9911120343, 75576.5817006842, 76301.4918515705, 79487.8877883423}, - {382785.230587562, 161389.442353423, 161516.218619847, 162076.984158624, 164637.062377748}, - {439466.649843278, 438148.172824183, 431912.066238713, 257605.319479605, 257512.839247251}, - {504550.626065609, 503783.529360534, 500331.593280549, 482707.17836027, 366958.520785585}, - {577604.594975215, 577097.065048066, 574850.152315666, 564443.789731478, 507875.800635261}, + {75373.1268990848, 75410.9911120345, 75576.5817006844, 76301.4918515715, 79487.8877883422}, + {382785.230587559, 161389.442353423, 161516.218619848, 162076.984158624, 164637.062377748}, + {439466.649843277, 438148.172824179, 431912.0662387, 257605.319479605, 257512.839247251}, + {504550.626065608, 503783.529360532, 500331.593280543, 482707.178360249, 366958.520785585}, + {577604.594975215, 577097.065048065, 574850.152315662, 564443.789731467, 507875.800635261}, }; const double expected_y[isoline_count][points_per_isoline] = { - {24999.9999999246, 109298.142136014, 477843.354976818, 2089095.63724655, 9133370.87584761}, - {24999.9999999246, 109298.142136014, 477843.354976818, 2089095.63724655, 9133370.87584761}, - {24999.9999999246, 109298.142136014, 477843.354976818, 2089095.63724655, 9133370.87584761}, - {24999.9999999246, 109298.142136014, 477843.354976818, 2089095.63724655, 9133370.87584761}, - {24999.9999999246, 109298.142136014, 477843.354976818, 2089095.63724655, 9133370.87584761}, + {25000, 109298.142136262, 477843.354977538, 2089095.63724813, 9133370.87584761}, + {25000, 109298.142136262, 477843.354977538, 2089095.63724813, 9133370.87584761}, + {25000, 109298.142136262, 477843.354977538, 2089095.63724813, 9133370.87584761}, + {25000, 109298.142136262, 477843.354977538, 2089095.63724813, 9133370.87584761}, + {25000, 109298.142136262, 477843.354977538, 2089095.63724813, 9133370.87584761}, }; for (int i = 0; i < t_isolines.size(); ++i) { REQUIRE(t_isolines[i].size() == points_per_isoline); @@ -535,24 +535,24 @@ TEST_CASE("Check that the isolines are the same as from Python", "[Plot]") { std::vector s_values = CoolProp::Plot::generate_values_in_range(CoolProp::iSmass, s_range, isoline_count); CoolProp::Plot::Isolines s_isolines = plot.calc_isolines(CoolProp::iSmass, s_values, points_per_isoline); REQUIRE(s_isolines.size() == isoline_count); - CHECK_THAT(s_isolines[0].value, WithinAbs(426.0094838603979, 1e-10)); - CHECK_THAT(s_isolines[1].value, WithinAbs(925.275035741351, 1e-10)); + CHECK_THAT(s_isolines[0].value, WithinAbs(426.00948386039755, 1e-10)); + CHECK_THAT(s_isolines[1].value, WithinAbs(925.2750357413507, 1e-10)); CHECK_THAT(s_isolines[2].value, WithinAbs(1424.540587622304, 1e-10)); CHECK_THAT(s_isolines[3].value, WithinAbs(1923.806139503257, 1e-10)); CHECK_THAT(s_isolines[4].value, WithinAbs(2423.07169138421, 1e-10)); const double expected_x[isoline_count][points_per_isoline] = { - {73758.1368335346, 73811.2861613466, 74043.6241898205, 75058.877171595, 79487.8877884639}, - {176257.349845373, 179794.80776157, 180290.319046323, 181487.967471083, 186690.959612256}, - {286286.175818423, 303984.726428754, 321692.362821626, 335551.688987583, 344087.839487745}, - {399372.560529411, 433400.354292331, 471964.896213688, 513835.931064389, 555824.663124966}, - {577604.594975109, 635258.237156208, 698999.445970919, 768745.631252129, std::nan("")}, + {73758.1368335347, 73811.2861613466, 74043.6241898207, 75058.8771715961, 79487.8877884637}, + {176257.349845383, 179794.807761573, 180290.319046323, 181487.967471084, 186690.959612256}, + {286286.175818458, 303984.726428782, 321692.362821643, 335551.688987588, 344087.839487745}, + {399372.560529476, 433400.354292387, 471964.89621373, 513835.931064411, 555824.663124966}, + {577604.594975221, 635258.237156301, 698999.445970987, 768745.631252166, std::nan("")}, }; const double expected_y[isoline_count][points_per_isoline] = { - {24999.9999999246, 109298.142136014, 477843.354976818, 2089095.63724655, 9133370.87584761}, - {24999.9999999246, 109298.142136014, 477843.354976818, 2089095.63724655, 9133370.87584761}, - {24999.9999999246, 109298.142136014, 477843.354976818, 2089095.63724655, 9133370.87584761}, - {24999.9999999246, 109298.142136014, 477843.354976818, 2089095.63724655, 9133370.87584761}, - {24999.9999999246, 109298.142136014, 477843.354976818, 2089095.63724655, 9133370.87584761}, + {25000, 109298.142136262, 477843.354977538, 2089095.63724813, 9133370.87584761}, + {25000, 109298.142136262, 477843.354977538, 2089095.63724813, 9133370.87584761}, + {25000, 109298.142136262, 477843.354977538, 2089095.63724813, 9133370.87584761}, + {25000, 109298.142136262, 477843.354977538, 2089095.63724813, 9133370.87584761}, + {25000, 109298.142136262, 477843.354977538, 2089095.63724813, 9133370.87584761}, }; for (int i = 0; i < s_isolines.size(); ++i) { REQUIRE(s_isolines[i].size() == points_per_isoline); @@ -577,18 +577,18 @@ TEST_CASE("Check that the isolines are the same as from Python", "[Plot]") { CHECK_THAT(d_isolines[3].value, WithinAbs(228.57817793711163, 1e-10)); CHECK_THAT(d_isolines[4].value, WithinAbs(1593.2471569904417, 1e-10)); const double expected_x[isoline_count][points_per_isoline] = { - {577604.594973719, std::nan(""), std::nan(""), std::nan(""), std::nan("")}, - {202365.843978259, 419230.112110974, std::nan(""), std::nan(""), std::nan("")}, - {142114.491283555, 204388.004478621, 351216.809706814, std::nan(""), std::nan("")}, - {133470.418481181, 172415.768780602, 235383.044874108, 357492.457483656, 669493.625997729}, - {70518.3287895171, 70601.2088976222, 70963.5807789925, 72548.3591970125, 79487.8877879114}, + {577604.594975212, std::nan(""), std::nan(""), std::nan(""), std::nan("")}, + {202365.843978511, 419230.112111493, std::nan(""), std::nan(""), std::nan("")}, + {142114.491283644, 204388.004478758, 351216.809707051, std::nan(""), std::nan("")}, + {133470.418481246, 172415.768780675, 235383.044874193, 357492.457483747, 669493.625997729}, + {70518.3287895177, 70601.2088976224, 70963.5807789929, 72548.359197014, 79487.8877879113}, }; const double expected_y[isoline_count][points_per_isoline] = { - {24999.9999999246, 109298.142136014, 477843.354976818, 2089095.63724655, 9133370.87584761}, - {24999.9999999246, 109298.142136014, 477843.354976818, 2089095.63724655, 9133370.87584761}, - {24999.9999999246, 109298.142136014, 477843.354976818, 2089095.63724655, 9133370.87584761}, - {24999.9999999246, 109298.142136014, 477843.354976818, 2089095.63724655, 9133370.87584761}, - {24999.9999999246, 109298.142136014, 477843.354976818, 2089095.63724655, 9133370.87584761}, + {25000, 109298.142136262, 477843.354977538, 2089095.63724813, 9133370.87584761}, + {25000, 109298.142136262, 477843.354977538, 2089095.63724813, 9133370.87584761}, + {25000, 109298.142136262, 477843.354977538, 2089095.63724813, 9133370.87584761}, + {25000, 109298.142136262, 477843.354977538, 2089095.63724813, 9133370.87584761}, + {25000, 109298.142136262, 477843.354977538, 2089095.63724813, 9133370.87584761}, }; for (int i = 0; i < d_isolines.size(); ++i) { REQUIRE(d_isolines[i].size() == points_per_isoline); @@ -613,7 +613,7 @@ TEST_CASE("Basic TS Plot has same output as Python", "[Plot]") { CHECK(plot.xaxis.scale == CoolProp::Plot::Scale::Lin); CHECK(plot.yaxis.scale == CoolProp::Plot::Scale::Lin); - CHECK_THAT(plot.xaxis.min, WithinAbs(426.0094838603979, 1)); + CHECK_THAT(plot.xaxis.min, WithinAbs(426.00948386039755, 1)); CHECK_THAT(plot.xaxis.max, WithinAbs(2423.07169138421, 1)); CHECK_THAT(plot.yaxis.min, WithinAbs(173.15, 1)); CHECK_THAT(plot.yaxis.max, WithinAbs(455.0, 1)); @@ -666,11 +666,11 @@ TEST_CASE("Basic TS Plot has same output as Python", "[Plot]") { std::vector p_values = CoolProp::Plot::generate_values_in_range(CoolProp::iP, p_range, isoline_count); CoolProp::Plot::Isolines p_isolines = plot.calc_isolines(CoolProp::iP, p_values, points_per_isoline); REQUIRE(p_isolines.size() == isoline_count); - CHECK_THAT(p_isolines[0].value, WithinAbs(24999.999999924625, 1e-8)); - CHECK_THAT(p_isolines[1].value, WithinAbs(109298.14213601447, 1e-8)); - CHECK_THAT(p_isolines[2].value, WithinAbs(477843.35497681826, 1e-8)); - CHECK_THAT(p_isolines[3].value, WithinAbs(2089095.6372465533, 1e-8)); - CHECK_THAT(p_isolines[4].value, WithinAbs(9133370.87584761, 1e-8)); + CHECK_THAT(p_isolines[0].value, WithinAbs(25000.000000000007, 1e-7)); + CHECK_THAT(p_isolines[1].value, WithinAbs(109298.14213626183, 1e-7)); + CHECK_THAT(p_isolines[2].value, WithinAbs(477843.3549775384, 1e-7)); + CHECK_THAT(p_isolines[3].value, WithinAbs(2089095.6372481277, 1e-7)); + CHECK_THAT(p_isolines[4].value, WithinAbs(9133370.87584761, 1e-7)); const double expected_x[isoline_count][points_per_isoline] = { {426.009483860398, 925.275035741351, 1424.5405876223, 1923.80613950326, 2423.07169138421}, {426.009483860398, 925.275035741351, 1424.5405876223, 1923.80613950326, 2423.07169138421}, @@ -679,10 +679,10 @@ TEST_CASE("Basic TS Plot has same output as Python", "[Plot]") { {426.009483860398, 925.275035741351, 1424.5405876223, 1923.80613950326, 2423.07169138421}, }; const double expected_y[isoline_count][points_per_isoline] = { - {171.786072659192, 220.381369310426, 220.381369310426, 265.362477224796, 454.999999999903}, - {171.798910666292, 248.745218249699, 248.745218249699, 308.633922577054, 506.387752763774}, - {171.854988815762, 258.195699077866, 287.4730373371, 355.964867192568, 560.293101202113}, - {172.099235421196, 258.742471436003, 342.561817261298, 411.323964493166, 618.036314177075}, + {171.786072659192, 220.381369310476, 220.381369310476, 265.362477224881, 455.000000000006}, + {171.798910666292, 248.745218249749, 248.745218249749, 308.633922577123, 506.387752763855}, + {171.854988815762, 258.195699077866, 287.473037337147, 355.964867192619, 560.29310120217}, + {172.099235421196, 258.742471436004, 342.561817261331, 411.323964493198, 618.036314177106}, {173.15, 261.021061581425, 371.327173900344, 484.427831614361, std::nan("")}, }; for (int i = 0; i < p_isolines.size(); ++i) { @@ -703,11 +703,11 @@ TEST_CASE("Basic TS Plot has same output as Python", "[Plot]") { std::vector h_values = CoolProp::Plot::generate_values_in_range(CoolProp::iHmass, h_range, isoline_count); CoolProp::Plot::Isolines h_isolines = plot.calc_isolines(CoolProp::iHmass, h_values, points_per_isoline); REQUIRE(h_isolines.size() == isoline_count); - CHECK_THAT(h_isolines[0].value, WithinAbs(75373.12689908473, 1e-10)); - CHECK_THAT(h_isolines[1].value, WithinAbs(200930.99391811722, 1e-10)); - CHECK_THAT(h_isolines[2].value, WithinAbs(326488.86093714973, 1e-10)); - CHECK_THAT(h_isolines[3].value, WithinAbs(452046.7279561822, 1e-10)); - CHECK_THAT(h_isolines[4].value, WithinAbs(577604.5949752147, 1e-10)); + CHECK_THAT(h_isolines[0].value, WithinAbs(75373.12689908482, 1e-10)); + CHECK_THAT(h_isolines[1].value, WithinAbs(200930.99391811725, 1e-10)); + CHECK_THAT(h_isolines[2].value, WithinAbs(326488.8609371497, 1e-10)); + CHECK_THAT(h_isolines[3].value, WithinAbs(452046.72795618215, 1e-10)); + CHECK_THAT(h_isolines[4].value, WithinAbs(577604.5949752146, 1e-10)); const double expected_x[isoline_count][points_per_isoline] = { {426.009483860398, 925.275035741351, 1424.5405876223, 1923.80613950326, 2423.07169138421}, {426.009483860398, 925.275035741351, 1424.5405876223, 1923.80613950326, 2423.07169138421}, @@ -717,10 +717,10 @@ TEST_CASE("Basic TS Plot has same output as Python", "[Plot]") { }; const double expected_y[isoline_count][points_per_isoline] = { {172.174575309065, std::nan(""), std::nan(""), std::nan(""), std::nan("")}, - {196.074550633908, 266.631159312275, std::nan(""), std::nan(""), std::nan("")}, + {196.074550634008, 266.631159312075, std::nan(""), std::nan(""), std::nan("")}, {213.664681842583, 299.984652703232, 301.726570477946, std::nan(""), std::nan("")}, - {228.411201679534, 322.843563825012, 426.787882130168, 331.521169967777, 328.042167528595}, - {241.568258023247, 341.661338916035, 458.593848045394, std::nan(""), 455.000000000079}, + {228.411201679534, 322.843563825212, 426.787882130168, 331.521169967777, 328.042167528594}, + {241.568258023047, 341.661338916035, 458.593848045394, std::nan(""), 455.000000000079}, }; for (int i = 0; i < h_isolines.size(); ++i) { REQUIRE(h_isolines[i].size() == points_per_isoline); @@ -746,10 +746,10 @@ TEST_CASE("Basic TS Plot has same output as Python", "[Plot]") { CHECK_THAT(d_isolines[3].value, WithinAbs(228.57817793711163, 1e-10)); CHECK_THAT(d_isolines[4].value, WithinAbs(1593.2471569904417, 1e-10)); const double expected_x[isoline_count][points_per_isoline] = { - {524.173878302997, 1911.09303197673, 2092.95299735844, 2262.71394473455, 2423.07169138421}, - {448.103089615508, 1715.11956249481, 1932.46627813427, 2103.15612327654, 2263.90953791772}, - {437.189451893868, 972.489749676211, 1758.36241052056, 1935.7522861596, 2099.20643194095}, - {435.623706482598, 865.946977105694, 1292.02339683139, 1720.27746043057, 1899.38158004697}, + {524.17387831234, 1911.09303197673, 2092.95299735844, 2262.71394473455, 2423.07169138421}, + {448.103089616845, 1715.11956249481, 1932.46627813427, 2103.15612327654, 2263.90953791772}, + {437.189451894057, 972.489749676211, 1758.36241052056, 1935.7522861596, 2099.20643194095}, + {435.623706482622, 865.946977105694, 1292.02339683139, 1720.27746043057, 1899.38158004697}, {426.009483860398, 710.877062878169, 946.968704707899, 1151.91782375377, 1335.56507098504}, }; const double expected_y[isoline_count][points_per_isoline] = {