ForkMaster/netgen
1
0
Fork 0
mirror of https://github.com/NGSolve/netgen.git synced 2024-12-26 22:00:33 +05:00
Code Issues Packages Projects Releases Wiki Activity
4592123f68
netgen/tests/pytest/results.json

3534 lines
97 KiB
JSON
Raw Normal View History

Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
{
"boundarycondition.geo": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
parallel SplitImprove
2019-10-25 17:57:00 +05:00
27.914,
137.69
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
parallel SplitImprove
2019-10-25 17:57:00 +05:00
29.255,
99.865
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 74,
"ne2d": 54,
parallel SplitImprove
2019-10-25 17:57:00 +05:00
"ne3d": 46,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 5, 6, 15, 3, 7, 5, 0, 0, 0]",
"total_badness": 70.019644222
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
31.383,
127.91
],
"angles_trig": [
28.041,
119.87
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 59,
"ne2d": 37,
"ne3d": 22,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 4, 4, 0, 0, 8, 0, 0, 0, 0]",
"total_badness": 35.161528768
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
32.461,
127.16
],
"angles_trig": [
28.547,
120.05
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 59,
"ne2d": 37,
"ne3d": 22,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 4, 4, 0, 0, 8, 0, 0, 0, 0]",
"total_badness": 35.098288788
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
parallel SplitImprove
2019-10-25 17:57:00 +05:00
27.914,
137.69
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
parallel SplitImprove
2019-10-25 17:57:00 +05:00
29.255,
99.865
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 74,
"ne2d": 54,
parallel SplitImprove
2019-10-25 17:57:00 +05:00
"ne3d": 46,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 5, 6, 15, 3, 7, 5, 0, 0, 0]",
"total_badness": 70.019644216
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
22.611,
132.85
],
"angles_trig": [
23.939,
104.77
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 118,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 140,
"ne3d": 165,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 9, 13, 23, 20, 31, 25, 21, 14, 6, 1]",
parallel SplitImprove
2019-10-25 17:57:00 +05:00
"total_badness": 233.73328915
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
25.801,
134.97
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
24.858,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
111.88
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 181,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 325,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"ne3d": 520,
parallel SplitImprove
2019-10-25 17:57:00 +05:00
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 6, 14, 39, 52, 64, 79, 98, 93, 57, 15]",
"total_badness": 673.37179433
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
"boxcyl.geo": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
22.391,
135.51
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
22.547,
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
121.98
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 190,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 468,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"ne3d": 845,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 1, 29, 90, 89, 74, 95, 96, 93, 98, 99, 60, 21]",
"total_badness": 1218.9142866
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
14.829,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
146.41
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
16.491,
127.01
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 94,
"ne2d": 114,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 122,
"quality_histogram": "[0, 0, 0, 0, 1, 2, 4, 9, 19, 14, 12, 10, 10, 7, 11, 4, 2, 14, 3, 0]",
"total_badness": 231.46662286
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
15.88,
154.64
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
20.0,
140.0
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 136,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 222,
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
"ne3d": 352,
"quality_histogram": "[0, 0, 0, 0, 0, 5, 5, 7, 4, 7, 14, 26, 24, 54, 64, 61, 47, 18, 14, 2]",
"total_badness": 527.329265
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
22.392,
135.93
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
22.547,
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
121.98
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 190,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 468,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"ne3d": 838,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 1, 30, 88, 87, 63, 105, 87, 95, 98, 101, 59, 24]",
"total_badness": 1206.145501
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
26.449,
140.15
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
24.477,
114.57
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 284,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 938,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 3808,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 12, 47, 117, 277, 497, 641, 782, 746, 506, 177]",
"total_badness": 4753.2608558
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
28.839,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
136.82
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
24.852,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
123.06
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 456,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 2496,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 18745,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 27, 92, 267, 746, 1634, 2890, 4017, 4509, 3387, 1173]",
"total_badness": 22615.490176
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
"circle_on_cube.geo": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
21.273,
137.67
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
24.517,
113.53
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 94,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 170,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"ne3d": 631,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 3, 5, 12, 30, 55, 76, 104, 120, 97, 70, 49, 10]",
"total_badness": 851.6214528
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
17.203,
146.18
],
"angles_trig": [
16.937,
127.21
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 40,
"ne2d": 38,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne3d": 46,
"quality_histogram": "[0, 0, 0, 0, 0, 2, 2, 4, 8, 8, 6, 7, 5, 1, 2, 1, 0, 0, 0, 0]",
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"total_badness": 97.323158326
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
26.568,
131.32
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
23.604,
115.75
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 62,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 96,
"ne3d": 196,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 8, 13, 31, 32, 43, 33, 18, 6, 9, 0]",
"total_badness": 281.47956507
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
27.256,
136.88
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
25.056,
112.86
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 94,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 170,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"ne3d": 617,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 8, 24, 45, 83, 93, 110, 109, 75, 54, 12]",
"total_badness": 818.76482812
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
28.642,
131.64
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
27.582,
112.81
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 138,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 384,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"ne3d": 1988,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 11, 49, 142, 225, 336, 439, 417, 280, 85]",
"total_badness": 2458.7297408
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
26.261,
136.67
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
24.333,
115.58
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 224,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 944,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 11884,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 15, 67, 187, 504, 1104, 1766, 2553, 2772, 2223, 688]",
"total_badness": 14368.116024
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
"cone.geo": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
12.946,
151.76
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
17.672,
123.45
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 64,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 722,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 1259,
"quality_histogram": "[0, 0, 0, 0, 0, 1, 8, 17, 41, 54, 101, 121, 139, 140, 171, 144, 127, 124, 55, 16]",
"total_badness": 1909.2743283
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Fix SwapImprove2 Don't allow swaps if an adjacent element was deleted in the current optimization pass. Also update test restults.
2020-11-25 21:55:44 +05:00
16.89,
158.0
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Fix SwapImprove2 Don't allow swaps if an adjacent element was deleted in the current optimization pass. Also update test restults.
2020-11-25 21:55:44 +05:00
16.739,
133.14
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 32,
"ne2d": 220,
Fix SwapImprove2 Don't allow swaps if an adjacent element was deleted in the current optimization pass. Also update test restults.
2020-11-25 21:55:44 +05:00
"ne3d": 551,
"quality_histogram": "[0, 0, 0, 0, 0, 3, 4, 16, 23, 34, 48, 43, 50, 61, 70, 53, 51, 48, 37, 10]",
"total_badness": 860.81905284
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
5.6575,
169.44
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
7.092,
155.41
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 48,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 428,
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
"ne3d": 763,
"quality_histogram": "[0, 1, 12, 30, 35, 44, 39, 49, 82, 100, 68, 81, 55, 44, 49, 23, 22, 19, 8, 2]",
"total_badness": 1832.2349397
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
15.888,
150.08
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
17.326,
121.07
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 64,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 722,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 1237,
"quality_histogram": "[0, 0, 0, 0, 0, 1, 5, 6, 28, 49, 94, 114, 121, 154, 165, 157, 128, 136, 64, 15]",
"total_badness": 1827.4800276
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
parallel SplitImprove
2019-10-25 17:57:00 +05:00
17.405,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
142.43
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
19.91,
123.02
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 96,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 1660,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"ne3d": 4458,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 2, 8, 32, 70, 131, 272, 410, 628, 728, 793, 731, 514, 139]",
parallel SplitImprove
2019-10-25 17:57:00 +05:00
"total_badness": 5796.7552731
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
22.764,
140.56
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
27.263,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
120.46
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 160,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 4748,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 27254,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 1, 4, 16, 71, 235, 659, 1375, 2774, 4392, 5618, 6099, 4470, 1540]",
"total_badness": 33350.665582
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
"cube.geo": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
35.264,
125.26
],
"angles_trig": [
35.264,
90.0
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 24,
"ne2d": 12,
"ne3d": 6,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 4, 0, 1, 0, 0, 0, 0]",
"total_badness": 9.1401272869
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
35.264,
125.26
],
"angles_trig": [
35.264,
90.0
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 24,
"ne2d": 12,
"ne3d": 6,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 4, 0, 1, 0, 0, 0, 0]",
"total_badness": 9.1401272869
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
35.264,
125.26
],
"angles_trig": [
35.264,
90.0
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 24,
"ne2d": 12,
"ne3d": 6,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 4, 0, 1, 0, 0, 0, 0]",
"total_badness": 9.1401272869
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
35.264,
125.26
],
"angles_trig": [
35.264,
90.0
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 24,
"ne2d": 12,
"ne3d": 6,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 4, 0, 1, 0, 0, 0, 0]",
"total_badness": 9.1401272869
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
27.354,
136.27
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
21.671,
126.93
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 48,
"ne2d": 36,
"ne3d": 57,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 4, 1, 10, 12, 9, 12, 4, 1, 2, 0]",
"total_badness": 83.840161698
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
21.865,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
136.72
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
22.37,
121.17
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 72,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 116,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"ne3d": 169,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 1, 3, 3, 4, 8, 13, 12, 20, 28, 33, 27, 11, 6]",
"total_badness": 228.41837612
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
"cubeandring.geo": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
5.2065,
170.27
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
10.96,
154.62
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 262,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 726,
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
"ne3d": 2167,
"quality_histogram": "[0, 4, 17, 35, 75, 117, 114, 112, 77, 51, 58, 86, 115, 177, 248, 293, 239, 204, 118, 27]",
Fix SwapImprove2 Don't allow swaps if an adjacent element was deleted in the current optimization pass. Also update test restults.
2020-11-25 21:55:44 +05:00
"total_badness": 4176.9284057
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
16.741,
140.94
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
19.264,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
120.29
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 134,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 164,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"ne3d": 252,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 1, 4, 2, 3, 11, 30, 31, 34, 40, 38, 33, 17, 7, 1]",
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"total_badness": 369.95189237
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
14.206,
159.84
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
21.077,
131.52
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 190,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 300,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 632,
"quality_histogram": "[0, 0, 0, 0, 2, 0, 0, 4, 8, 26, 45, 62, 80, 96, 90, 84, 65, 46, 22, 2]",
"total_badness": 947.91494351
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
5.9887,
161.33
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
13.133,
parallel SplitImprove
2019-10-25 17:57:00 +05:00
150.46
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 262,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 726,
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
"ne3d": 2060,
"quality_histogram": "[0, 2, 5, 15, 46, 103, 106, 104, 71, 36, 48, 67, 99, 165, 253, 287, 287, 195, 136, 35]",
"total_badness": 3642.1604728
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
24.1,
141.88
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
23.859,
119.8
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 378,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 1412,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 7670,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 2, 7, 36, 112, 284, 477, 845, 1308, 1555, 1517, 1168, 359]",
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"total_badness": 9545.7933664
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
24.428,
143.27
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
24.968,
121.61
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 624,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 3944,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 38337,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 5, 12, 70, 233, 701, 1858, 3746, 6011, 8031, 8828, 6611, 2231]",
"total_badness": 46629.830149
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
"cubeandspheres.geo": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
23.615,
137.71
],
"angles_trig": [
28.816,
110.5
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 144,
"ne2d": 148,
"ne3d": 98,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 3, 6, 3, 4, 18, 19, 13, 20, 2, 9, 1, 0]",
"total_badness": 145.83375079
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
24.423,
137.5
],
"angles_trig": [
28.935,
109.27
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 144,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 150,
"ne3d": 100,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 7, 10, 16, 18, 15, 17, 6, 5, 4, 0]",
"total_badness": 146.6468601
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
23.888,
137.32
],
"angles_trig": [
29.702,
106.44
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 144,
"ne2d": 148,
"ne3d": 98,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 6, 6, 19, 21, 12, 18, 5, 4, 4, 0]",
"total_badness": 145.14580879
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
23.615,
137.71
],
"angles_trig": [
28.816,
110.5
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 144,
"ne2d": 148,
"ne3d": 98,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 3, 6, 3, 4, 18, 19, 13, 20, 2, 9, 1, 0]",
"total_badness": 145.83375079
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
17.481,
142.47
],
"angles_trig": [
23.755,
116.95
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 264,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 390,
"ne3d": 369,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 4, 5, 19, 26, 42, 46, 49, 41, 53, 45, 27, 10, 2]",
"total_badness": 554.2809713
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
13.221,
154.37
],
"angles_trig": [
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
19.317,
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
128.1
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 428,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 926,
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
"ne3d": 1086,
"quality_histogram": "[0, 0, 0, 0, 0, 1, 3, 22, 44, 37, 108, 133, 101, 117, 167, 161, 67, 71, 33, 21]",
"total_badness": 1684.0903817
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
"cubemcyl.geo": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
19.095,
148.41
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
19.819,
130.08
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 142,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 2488,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 20377,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 3, 13, 54, 165, 390, 900, 1554, 2429, 3089, 3513, 3446, 2730, 1633, 458]",
"total_badness": 27224.35447
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
19.437,
141.17
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
17.771,
130.84
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 64,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 642,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 3305,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 1, 11, 21, 62, 135, 236, 368, 452, 577, 512, 439, 311, 151, 29]",
"total_badness": 4674.6678046
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
20.675,
143.54
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
14.769,
129.61
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 102,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 1402,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 8209,
"quality_histogram": "[0, 0, 0, 0, 0, 2, 4, 4, 26, 56, 216, 420, 704, 1026, 1323, 1412, 1302, 954, 587, 173]",
"total_badness": 11118.365255
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
21.997,
146.77
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
23.524,
123.14
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 142,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 2488,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 19366,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 3, 7, 43, 115, 406, 1004, 1806, 2745, 3564, 3751, 3220, 2125, 577]",
"total_badness": 24813.005671
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
22.179,
143.28
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
22.998,
122.28
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 210,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 5508,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"ne3d": 89117,
parallel SplitImprove
2019-10-25 17:57:00 +05:00
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 7, 64, 213, 756, 2149, 5056, 9540, 14533, 18572, 19573, 14246, 4408]",
"total_badness": 109473.41917
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
22.072,
141.68
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
23.818,
123.89
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 362,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 15122,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"ne3d": 525200,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 6, 82, 526, 2296, 7742, 21372, 47326, 79983, 111877, 125226, 97896, 30868]",
parallel SplitImprove
2019-10-25 17:57:00 +05:00
"total_badness": 633738.01761
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
"cubemsphere.geo": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
18.937,
145.89
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
21.407,
128.79
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 90,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 702,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 4814,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 4, 10, 55, 89, 206, 386, 582, 723, 808, 801, 647, 392, 111]",
"total_badness": 6443.9958085
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
17.436,
150.08
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
14.077,
130.7
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 44,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 274,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 769,
"quality_histogram": "[0, 0, 0, 0, 1, 3, 9, 15, 28, 41, 69, 78, 114, 88, 96, 95, 62, 35, 31, 4]",
"total_badness": 1221.5992458
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
20.966,
149.27
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
22.441,
124.17
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 68,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 402,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"ne3d": 1570,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 2, 10, 25, 53, 109, 194, 185, 264, 251, 214, 153, 94, 16]",
"total_badness": 2195.1465077
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
22.975,
142.5
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
21.962,
120.34
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 90,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 702,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 4601,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 4, 21, 45, 92, 246, 466, 682, 801, 899, 738, 477, 130]",
"total_badness": 5937.2722105
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
25.354,
139.69
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
24.508,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
122.25
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 146,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 1492,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 17953,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 1, 15, 49, 186, 416, 1010, 1922, 3086, 3851, 3738, 2822, 857]",
"total_badness": 22102.299848
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
23.515,
140.76
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
24.908,
125.3
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 248,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 4354,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 113864,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 3, 21, 137, 566, 1806, 4993, 10776, 18228, 24232, 26678, 20186, 6238]",
"total_badness": 138017.18455
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
"cylinder.geo": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
19.066,
144.66
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
22.516,
111.49
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 52,
"ne2d": 288,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"ne3d": 403,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 1, 1, 1, 4, 15, 36, 40, 54, 81, 51, 55, 40, 13, 11]",
"total_badness": 567.02829865
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
24.676,
151.98
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
24.811,
126.7
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 24,
"ne2d": 66,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 70,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 1, 0, 6, 5, 5, 2, 6, 5, 3, 5, 14, 17, 1, 0]",
"total_badness": 105.64076027
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Fix SwapImprove2 Don't allow swaps if an adjacent element was deleted in the current optimization pass. Also update test restults.
2020-11-25 21:55:44 +05:00
8.4923,
161.34
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Fix SwapImprove2 Don't allow swaps if an adjacent element was deleted in the current optimization pass. Also update test restults.
2020-11-25 21:55:44 +05:00
20.122,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
127.45
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 36,
"ne2d": 152,
Fix SwapImprove2 Don't allow swaps if an adjacent element was deleted in the current optimization pass. Also update test restults.
2020-11-25 21:55:44 +05:00
"ne3d": 358,
"quality_histogram": "[0, 0, 1, 0, 0, 2, 5, 11, 21, 19, 22, 22, 31, 29, 35, 39, 57, 37, 17, 10]",
"total_badness": 559.67849284
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
19.059,
144.67
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
22.497,
111.48
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 52,
"ne2d": 288,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"ne3d": 403,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 1, 1, 1, 4, 15, 36, 40, 54, 81, 51, 56, 39, 13, 11]",
"total_badness": 567.02256434
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
parallel SplitImprove
2019-10-25 17:57:00 +05:00
21.985,
136.08
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
parallel SplitImprove
2019-10-25 17:57:00 +05:00
24.141,
119.73
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 76,
"ne2d": 636,
parallel SplitImprove
2019-10-25 17:57:00 +05:00
"ne3d": 1183,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 1, 9, 29, 61, 96, 141, 201, 195, 208, 129, 88, 25]",
"total_badness": 1595.7683733
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
parallel SplitImprove
2019-10-25 17:57:00 +05:00
26.542,
136.11
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
parallel SplitImprove
2019-10-25 17:57:00 +05:00
29.438,
113.26
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 124,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 1672,
parallel SplitImprove
2019-10-25 17:57:00 +05:00
"ne3d": 8113,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 7, 46, 139, 415, 799, 1289, 1722, 1833, 1400, 461]",
"total_badness": 9862.4056943
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
"cylsphere.geo": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
16.89,
141.12
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
17.583,
119.1
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 104,
"ne2d": 496,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"ne3d": 707,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 3, 8, 14, 34, 56, 93, 112, 103, 97, 52, 69, 49, 14, 3]",
"total_badness": 1093.5696529
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
10.144,
167.27
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
13.416,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
150.52
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 48,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 142,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 150,
"quality_histogram": "[0, 0, 0, 5, 27, 32, 16, 4, 0, 2, 1, 1, 4, 5, 3, 17, 16, 7, 10, 0]",
"total_badness": 409.78409193
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
16.975,
137.45
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
17.533,
120.6
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 104,
"ne2d": 496,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"ne3d": 706,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 3, 5, 14, 31, 59, 94, 101, 111, 93, 65, 66, 46, 15, 3]",
"total_badness": 1086.526116
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
24.122,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
136.31
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
20.921,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
117.93
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 152,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 1084,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 2876,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 1, 4, 19, 35, 100, 163, 262, 362, 452, 549, 486, 354, 89]",
"total_badness": 3717.0068038
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
21.955,
141.68
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
24.73,
126.1
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 248,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 2820,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 17779,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 1, 4, 33, 102, 305, 737, 1664, 2832, 3742, 4116, 3177, 1066]",
"total_badness": 21539.566965
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
"ellipsoid.geo": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
17.39,
153.23
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
18.41,
123.71
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 0,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 704,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 1282,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 2, 10, 36, 69, 94, 134, 144, 177, 156, 153, 137, 92, 60, 18]",
"total_badness": 1935.37865
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Fix SwapImprove2 Don't allow swaps if an adjacent element was deleted in the current optimization pass. Also update test restults.
2020-11-25 21:55:44 +05:00
5.6074,
169.95
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Fix SwapImprove2 Don't allow swaps if an adjacent element was deleted in the current optimization pass. Also update test restults.
2020-11-25 21:55:44 +05:00
7.5945,
159.99
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 0,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 192,
Fix SwapImprove2 Don't allow swaps if an adjacent element was deleted in the current optimization pass. Also update test restults.
2020-11-25 21:55:44 +05:00
"ne3d": 748,
"quality_histogram": "[0, 0, 30, 62, 87, 77, 80, 61, 72, 38, 54, 43, 34, 27, 27, 20, 18, 10, 7, 1]",
"total_badness": 2287.1659209
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
19.777,
131.46
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
20.139,
112.74
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 0,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 394,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 597,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 2, 6, 29, 41, 61, 90, 98, 81, 81, 55, 29, 17, 7]",
"total_badness": 896.10180497
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
19.843,
146.94
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
19.04,
124.64
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 0,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 704,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 1279,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 5, 24, 63, 82, 136, 148, 154, 170, 159, 151, 92, 69, 26]",
"total_badness": 1888.990628
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
19.838,
144.66
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
24.559,
116.15
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 0,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 1618,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 5582,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 1, 1, 1, 18, 48, 133, 269, 450, 670, 884, 1028, 1098, 753, 228]",
"total_badness": 7078.3419995
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
[testing] update results
2019-10-31 20:38:40 +05:00
23.712,
141.53
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
[testing] update results
2019-10-31 20:38:40 +05:00
27.221,
120.25
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 0,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 4236,
[testing] update results
2019-10-31 20:38:40 +05:00
"ne3d": 37109,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 1, 11, 43, 182, 476, 1429, 3220, 5619, 7718, 8934, 7209, 2267]",
"total_badness": 44660.376357
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
"ellipticcone.geo": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
17.699,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
148.03
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
23.943,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
122.76
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 174,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 1562,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 5212,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 1, 1, 8, 32, 89, 187, 328, 534, 719, 937, 969, 775, 458, 174]",
"total_badness": 6834.3167615
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
16.573,
145.68
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
18.772,
127.9
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 86,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 380,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 533,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 3, 10, 16, 31, 44, 51, 59, 72, 64, 75, 46, 37, 14, 11]",
"total_badness": 822.13701721
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
16.597,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
149.96
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
18.553,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
135.0
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 130,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 864,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 1652,
"quality_histogram": "[0, 0, 0, 0, 0, 2, 12, 28, 40, 57, 56, 113, 146, 183, 206, 245, 268, 166, 103, 27]",
"total_badness": 2393.1339621
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
21.766,
144.03
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
25.696,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
119.99
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 174,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 1562,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 5072,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 4, 11, 54, 93, 228, 440, 641, 935, 1026, 892, 544, 204]",
"total_badness": 6463.5570559
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
20.935,
144.66
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
18.719,
132.57
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 258,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 3468,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 13471,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 8, 18, 67, 132, 305, 570, 999, 1594, 2335, 2604, 2480, 1787, 572]",
[testing] update results
2019-10-31 20:38:40 +05:00
"total_badness": 17093.610502
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
19.932,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
144.83
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
21.622,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
126.14
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 432,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 9544,
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
"ne3d": 69846,
Parallel SplitImprove2, update test results Due to prallelization, the order of splits is changed (sort by improvement of badness, like in other optimization passes)
2020-07-23 23:12:20 +05:00
"quality_histogram": "[0, 0, 0, 0, 0, 0, 1, 7, 30, 71, 221, 652, 1560, 3667, 7028, 11234, 14630, 15524, 11810, 3411]",
"total_badness": 85625.275421
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
"ellipticcyl.geo": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
parallel SplitImprove
2019-10-25 17:57:00 +05:00
16.526,
149.46
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
21.243,
122.35
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 156,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 996,
parallel SplitImprove
2019-10-25 17:57:00 +05:00
"ne3d": 2250,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 1, 3, 10, 54, 75, 108, 223, 245, 334, 397, 328, 264, 157, 51]",
"total_badness": 3092.4590274
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
22.853,
132.4
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
21.921,
108.66
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 76,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 238,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 318,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 16, 20, 33, 38, 67, 54, 49, 20, 11, 1]",
"total_badness": 450.48872379
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
20.733,
143.0
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
23.594,
117.45
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 116,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 596,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 1126,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 1, 2, 9, 28, 29, 73, 131, 178, 186, 196, 165, 107, 21]",
"total_badness": 1489.487043
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
18.67,
144.62
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
parallel SplitImprove
2019-10-25 17:57:00 +05:00
23.115,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
121.16
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 156,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 996,
parallel SplitImprove
2019-10-25 17:57:00 +05:00
"ne3d": 2228,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 2, 7, 26, 55, 99, 185, 230, 332, 401, 349, 286, 208, 48]",
"total_badness": 2986.6628685
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
24.468,
138.03
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
25.275,
115.12
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 232,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 2212,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 8292,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 1, 15, 37, 90, 258, 586, 955, 1411, 1668, 1703, 1209, 359]",
"total_badness": 10319.810588
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
21.266,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
143.66
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
23.958,
119.8
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 388,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 6142,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 54704,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 2, 17, 66, 248, 717, 2138, 4854, 8219, 11632, 13173, 10210, 3428]",
"total_badness": 65897.969985
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
fix csg extrusion
2021-04-13 15:11:10 +05:00
"extrusion.geo": [
{
"angles_tet": [
6.6841,
171.53
],
"angles_trig": [
11.293,
152.07
],
"ne1d": 172,
"ne2d": 286,
"ne3d": 241,
"quality_histogram": "[0, 0, 7, 56, 39, 22, 0, 0, 0, 0, 2, 0, 5, 18, 18, 29, 21, 10, 9, 5]",
"total_badness": 775.80779693
},
{
"angles_tet": [
16.097,
160.17
],
"angles_trig": [
15.327,
149.09
],
"ne1d": 104,
"ne2d": 152,
"ne3d": 124,
"quality_histogram": "[0, 0, 0, 0, 10, 19, 39, 26, 9, 3, 1, 1, 5, 1, 3, 2, 3, 2, 0, 0]",
"total_badness": 353.53219387
},
{
"angles_tet": [
11.505,
165.94
],
"angles_trig": [
15.054,
147.98
],
"ne1d": 134,
"ne2d": 196,
"ne3d": 167,
"quality_histogram": "[0, 0, 0, 1, 3, 35, 33, 8, 5, 21, 11, 9, 10, 11, 7, 3, 5, 3, 1, 1]",
"total_badness": 417.63980201
},
{
"angles_tet": [
6.6841,
171.53
],
"angles_trig": [
11.293,
152.07
],
"ne1d": 172,
"ne2d": 286,
"ne3d": 241,
"quality_histogram": "[0, 0, 7, 56, 39, 22, 0, 0, 0, 0, 2, 0, 5, 18, 18, 29, 21, 10, 9, 5]",
"total_badness": 775.80779693
},
{
"angles_tet": [
17.691,
140.88
],
"angles_trig": [
18.812,
116.06
],
"ne1d": 276,
"ne2d": 570,
"ne3d": 646,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 4, 17, 30, 51, 51, 55, 81, 69, 74, 73, 72, 52, 12, 5]",
"total_badness": 1020.0235117
},
{
"angles_tet": [
14.402,
155.5
],
"angles_trig": [
24.071,
119.03
],
"ne1d": 442,
"ne2d": 1220,
"ne3d": 2802,
"quality_histogram": "[0, 0, 0, 0, 0, 2, 5, 2, 4, 12, 25, 55, 147, 298, 311, 503, 457, 536, 342, 103]",
"total_badness": 3603.431162
}
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"fichera.geo": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
parallel SplitImprove
2019-10-25 17:57:00 +05:00
31.324,
131.07
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
35.264,
96.517
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 50,
"ne2d": 38,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 36,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 5, 4, 7, 6, 8, 1, 1, 0, 1]",
"total_badness": 53.038414986
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
35.264,
125.26
],
"angles_trig": [
35.264,
109.47
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 42,
"ne2d": 24,
"ne3d": 18,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 10, 6, 1, 0, 0, 0, 0]",
"total_badness": 26.546480075
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
35.264,
125.26
],
"angles_trig": [
35.264,
109.47
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 42,
"ne2d": 24,
"ne3d": 18,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 10, 6, 1, 0, 0, 0, 0]",
"total_badness": 26.546480075
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
parallel SplitImprove
2019-10-25 17:57:00 +05:00
31.324,
131.07
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
35.264,
96.517
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 50,
"ne2d": 38,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 36,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 5, 4, 7, 6, 8, 1, 1, 0, 1]",
"total_badness": 53.038414986
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
25.061,
136.16
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
29.251,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
110.29
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 96,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 120,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"ne3d": 205,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 5, 4, 13, 17, 26, 36, 40, 31, 22, 10]",
"total_badness": 264.77766512
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
26.621,
137.76
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
22.737,
128.54
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 144,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 274,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 489,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 20, 29, 59, 75, 95, 77, 74, 43, 13]",
"total_badness": 639.78974791
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
Parallel SplitImprove2, update test results Due to prallelization, the order of splits is changed (sort by improvement of badness, like in other optimization passes)
2020-07-23 23:12:20 +05:00
"frame.step": [
{
"angles_tet": [
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
2.9158,
Parallel SplitImprove2, update test results Due to prallelization, the order of splits is changed (sort by improvement of badness, like in other optimization passes)
2020-07-23 23:12:20 +05:00
171.1
],
"angles_trig": [
2.6092,
172.05
],
"ne1d": 10108,
"ne2d": 30160,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 152932,
"quality_histogram": "[0, 3, 1, 3, 6, 20, 60, 151, 543, 1312, 2940, 5874, 10445, 16338, 21809, 26075, 26405, 22854, 14351, 3742]",
"total_badness": 202658.67088
Parallel SplitImprove2, update test results Due to prallelization, the order of splits is changed (sort by improvement of badness, like in other optimization passes)
2020-07-23 23:12:20 +05:00
},
{
"angles_tet": [
2.296,
175.61
],
"angles_trig": [
1.8443,
175.57
],
"ne1d": 5988,
"ne2d": 11102,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 29140,
"quality_histogram": "[3, 4, 3, 10, 18, 43, 114, 248, 669, 1026, 1563, 2467, 3073, 3886, 4389, 4179, 3406, 2403, 1317, 319]",
"total_badness": 43201.580215
Parallel SplitImprove2, update test results Due to prallelization, the order of splits is changed (sort by improvement of badness, like in other optimization passes)
2020-07-23 23:12:20 +05:00
},
{
"angles_tet": [
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
2.1788,
Parallel SplitImprove2, update test results Due to prallelization, the order of splits is changed (sort by improvement of badness, like in other optimization passes)
2020-07-23 23:12:20 +05:00
174.11
],
"angles_trig": [
2.2053,
174.13
],
"ne1d": 9622,
"ne2d": 23964,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 80884,
"quality_histogram": "[2, 15, 4, 18, 16, 39, 98, 222, 478, 1114, 2389, 4532, 7510, 10291, 12685, 13114, 12137, 9102, 5641, 1477]",
"total_badness": 111769.66842
Parallel SplitImprove2, update test results Due to prallelization, the order of splits is changed (sort by improvement of badness, like in other optimization passes)
2020-07-23 23:12:20 +05:00
}
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"hinge.stl": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
16.835,
148.75
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
18.101,
139.79
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 456,
Update results
2019-10-18 17:09:32 +05:00
"ne2d": 1220,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 1985,
"quality_histogram": "[0, 0, 0, 0, 0, 1, 0, 9, 20, 38, 65, 129, 172, 240, 303, 297, 268, 263, 138, 42]",
"total_badness": 2749.9093553
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
7.7862,
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
161.84
],
"angles_trig": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
9.6143,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
148.89
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
updated results
2019-10-08 15:04:40 +05:00
"ne1d": 298,
Update results
2019-10-18 17:09:32 +05:00
"ne2d": 610,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 789,
"quality_histogram": "[0, 0, 1, 10, 9, 4, 22, 15, 40, 43, 68, 84, 103, 96, 83, 85, 48, 49, 25, 4]",
"total_badness": 1364.9012739
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
10.751,
157.43
],
"angles_trig": [
parallel SplitImprove
2019-10-25 17:57:00 +05:00
12.656,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
152.72
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
updated results
2019-10-08 15:04:40 +05:00
"ne1d": 370,
Update results
2019-10-18 17:09:32 +05:00
"ne2d": 856,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 1134,
"quality_histogram": "[0, 0, 0, 2, 4, 5, 14, 25, 38, 56, 78, 119, 136, 137, 152, 151, 98, 66, 45, 8]",
"total_badness": 1795.6519937
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
13.485,
156.97
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
19.521,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
135.02
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
updated results
2019-10-08 15:04:40 +05:00
"ne1d": 516,
CombineImprove() 2D: optimize all faces at once
2019-10-14 19:19:52 +05:00
"ne2d": 1574,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 2592,
"quality_histogram": "[0, 0, 0, 0, 0, 4, 3, 4, 24, 49, 98, 174, 224, 322, 378, 396, 333, 317, 216, 50]",
"total_badness": 3599.8559259
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
parallel SplitImprove
2019-10-25 17:57:00 +05:00
19.877,
146.81
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
21.493,
131.22
],
updated results
2019-10-08 15:04:40 +05:00
"ne1d": 722,
Update results
2019-10-18 17:09:32 +05:00
"ne2d": 2866,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 6672,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 1, 1, 24, 30, 67, 169, 331, 632, 870, 1040, 1173, 1200, 874, 260]",
"total_badness": 8558.9452401
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
20.701,
Fix SwapImprove2 Don't allow swaps if an adjacent element was deleted in the current optimization pass. Also update test restults.
2020-11-25 21:55:44 +05:00
141.98
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
22.443,
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
122.07
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
updated results
2019-10-08 15:04:40 +05:00
"ne1d": 1862,
Update results
2019-10-18 17:09:32 +05:00
"ne2d": 19474,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 136547,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 1, 8, 60, 274, 868, 2525, 6456, 12982, 21266, 29083, 31162, 24018, 7844]",
"total_badness": 165951.25229
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"lense.in2d": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
0.0,
0.0
],
"angles_trig": [
0.0,
0.0
],
update test results
2020-10-19 18:45:16 +05:00
"ne1d": 81,
"ne2d": 442,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne3d": 0,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]",
"total_badness": 0.0
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
0.0,
0.0
],
"angles_trig": [
0.0,
0.0
],
update test results
2020-10-19 18:45:16 +05:00
"ne1d": 86,
"ne2d": 464,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne3d": 0,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]",
"total_badness": 0.0
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
0.0,
0.0
],
"angles_trig": [
0.0,
0.0
],
update test results
2020-10-19 18:45:16 +05:00
"ne1d": 86,
"ne2d": 466,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne3d": 0,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]",
"total_badness": 0.0
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
0.0,
0.0
],
"angles_trig": [
0.0,
0.0
],
update test results
2020-10-19 18:45:16 +05:00
"ne1d": 81,
"ne2d": 442,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne3d": 0,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]",
"total_badness": 0.0
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
0.0,
0.0
],
"angles_trig": [
0.0,
0.0
],
update test results
2020-10-19 18:45:16 +05:00
"ne1d": 82,
"ne2d": 441,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne3d": 0,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]",
"total_badness": 0.0
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
0.0,
0.0
],
"angles_trig": [
0.0,
0.0
],
update test results
2020-10-19 18:45:16 +05:00
"ne1d": 86,
"ne2d": 472,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne3d": 0,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]",
"total_badness": 0.0
}
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"lshape3d.geo": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
parallel SplitImprove
2019-10-25 17:57:00 +05:00
35.202,
125.39
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
parallel SplitImprove
2019-10-25 17:57:00 +05:00
35.225,
109.34
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 44,
"ne2d": 28,
parallel SplitImprove
2019-10-25 17:57:00 +05:00
"ne3d": 24,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 20, 0, 2, 0, 0, 0, 0]",
"total_badness": 36.197580222
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
30.0,
120.0
],
"angles_trig": [
26.565,
90.0
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 36,
"ne2d": 20,
"ne3d": 12,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 1, 6, 1, 0, 0, 0, 0, 0]",
"total_badness": 18.961481515
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
30.0,
120.0
],
"angles_trig": [
26.565,
90.0
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 36,
"ne2d": 20,
"ne3d": 12,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 1, 6, 1, 0, 0, 0, 0, 0]",
"total_badness": 18.961481515
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
parallel SplitImprove
2019-10-25 17:57:00 +05:00
35.202,
125.39
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
parallel SplitImprove
2019-10-25 17:57:00 +05:00
35.225,
109.34
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 44,
"ne2d": 28,
parallel SplitImprove
2019-10-25 17:57:00 +05:00
"ne3d": 24,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 20, 0, 2, 0, 0, 0, 0]",
"total_badness": 36.197580222
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
31.641,
125.43
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
32.108,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
97.676
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 80,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 76,
"ne3d": 88,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 6, 24, 21, 11, 5, 1, 5]",
"total_badness": 119.51330947
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
25.888,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
130.75
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
26.255,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
106.78
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 122,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 204,
"ne3d": 326,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 12, 19, 39, 41, 73, 58, 41, 29, 11]",
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"total_badness": 425.73873607
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
"manyholes.geo": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
14.551,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
155.18
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
16.38,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
141.4
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 5886,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 48052,
Parallel SplitImprove2, update test results Due to prallelization, the order of splits is changed (sort by improvement of badness, like in other optimization passes)
2020-07-23 23:12:20 +05:00
"ne3d": 178844,
"quality_histogram": "[0, 0, 0, 0, 0, 5, 11, 71, 288, 829, 2312, 6198, 10948, 18856, 27414, 30640, 31333, 26927, 18474, 4538]",
"total_badness": 233920.54177
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
11.536,
149.67
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
15.246,
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
137.87
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 2746,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 13866,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 29391,
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
"quality_histogram": "[0, 0, 0, 0, 13, 14, 37, 136, 380, 846, 1453, 2331, 3276, 4281, 4196, 3749, 3317, 2686, 1967, 709]",
"total_badness": 42208.382479
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
11.183,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
153.89
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
12.194,
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
138.76
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 4106,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 27994,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 70789,
"quality_histogram": "[0, 0, 0, 1, 31, 72, 171, 344, 668, 1440, 2602, 4089, 6675, 9290, 10472, 10751, 9903, 7620, 4876, 1784]",
"total_badness": 99059.754776
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
"manyholes2.geo": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
14.171,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
152.51
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
15.466,
parallel SplitImprove
2019-10-25 17:57:00 +05:00
135.27
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 10202,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 55380,
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
"ne3d": 128239,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"quality_histogram": "[0, 0, 0, 0, 4, 28, 79, 241, 721, 1932, 4433, 7722, 11698, 17421, 18591, 18340, 17271, 15154, 10934, 3670]",
"total_badness": 176223.54068
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
"matrix.geo": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
9.8227,
167.77
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
10.647,
154.14
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 174,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 1198,
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
"ne3d": 5070,
"quality_histogram": "[0, 0, 11, 117, 166, 59, 60, 113, 98, 185, 297, 374, 498, 658, 620, 577, 494, 424, 240, 79]",
"total_badness": 8804.2621534
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Parallel SplitImprove2, update test results Due to prallelization, the order of splits is changed (sort by improvement of badness, like in other optimization passes)
2020-07-23 23:12:20 +05:00
9.3063,
165.3
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
7.9174,
161.29
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 106,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 610,
Parallel SplitImprove2, update test results Due to prallelization, the order of splits is changed (sort by improvement of badness, like in other optimization passes)
2020-07-23 23:12:20 +05:00
"ne3d": 1659,
"quality_histogram": "[0, 1, 13, 49, 81, 155, 190, 149, 159, 132, 135, 145, 137, 107, 66, 37, 33, 40, 26, 4]",
"total_badness": 4094.4605262
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
6.3111,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
169.7
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
parallel SplitImprove
2019-10-25 17:57:00 +05:00
10.116,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
150.34
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 132,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 830,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 2488,
"quality_histogram": "[0, 0, 3, 37, 71, 155, 161, 102, 158, 211, 284, 276, 249, 203, 195, 139, 108, 79, 42, 15]",
Fix SwapImprove2 Don't allow swaps if an adjacent element was deleted in the current optimization pass. Also update test restults.
2020-11-25 21:55:44 +05:00
"total_badness": 5146.3098762
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
9.8227,
167.77
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
10.647,
154.14
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 174,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 1198,
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
"ne3d": 5012,
"quality_histogram": "[0, 0, 7, 101, 161, 60, 53, 107, 93, 172, 281, 320, 519, 570, 616, 653, 509, 445, 260, 85]",
"total_badness": 8527.4907589
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
12.758,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
148.17
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
15.825,
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
143.02
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 248,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 2324,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 16371,
"quality_histogram": "[0, 0, 0, 0, 0, 5, 22, 53, 115, 192, 297, 621, 1022, 1479, 2137, 2601, 2778, 2625, 1890, 534]",
"total_badness": 21627.026306
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
18.203,
Parallel SplitImprove2, update test results Due to prallelization, the order of splits is changed (sort by improvement of badness, like in other optimization passes)
2020-07-23 23:12:20 +05:00
145.38
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
17.821,
parallel SplitImprove
2019-10-25 17:57:00 +05:00
129.69
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 418,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 5968,
Parallel SplitImprove2, update test results Due to prallelization, the order of splits is changed (sort by improvement of badness, like in other optimization passes)
2020-07-23 23:12:20 +05:00
"ne3d": 101113,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 4, 7, 51, 102, 349, 993, 2550, 5563, 10196, 16090, 20698, 22258, 16911, 5341]",
"total_badness": 124155.81178
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
"ortho.geo": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
35.264,
125.26
],
"angles_trig": [
35.264,
90.0
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 24,
"ne2d": 12,
"ne3d": 6,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 4, 0, 1, 0, 0, 0, 0]",
"total_badness": 9.1401272869
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
35.264,
125.26
],
"angles_trig": [
35.264,
90.0
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 24,
"ne2d": 12,
"ne3d": 6,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 4, 0, 1, 0, 0, 0, 0]",
"total_badness": 9.1401272869
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
35.264,
125.26
],
"angles_trig": [
35.264,
90.0
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 24,
"ne2d": 12,
"ne3d": 6,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 4, 0, 1, 0, 0, 0, 0]",
"total_badness": 9.1401272869
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
35.264,
125.26
],
"angles_trig": [
35.264,
90.0
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 24,
"ne2d": 12,
"ne3d": 6,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 4, 0, 1, 0, 0, 0, 0]",
"total_badness": 9.1401272869
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
27.31,
136.31
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
32.958,
102.54
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 48,
"ne2d": 36,
"ne3d": 57,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 5, 2, 9, 11, 10, 12, 4, 1, 2, 0]",
"total_badness": 83.838340747
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
26.39,
132.21
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
26.945,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
100.27
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 72,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 116,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"ne3d": 179,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 5, 9, 9, 26, 31, 39, 31, 13, 12]",
"total_badness": 229.03446012
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
"part1.stl": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
14.209,
147.23
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
19.94,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
127.49
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 170,
CombineImprove() 2D: optimize all faces at once
2019-10-14 19:19:52 +05:00
"ne2d": 448,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 1261,
"quality_histogram": "[0, 0, 0, 0, 0, 1, 3, 8, 15, 25, 35, 78, 97, 157, 211, 199, 161, 144, 100, 27]",
"total_badness": 1752.4668505
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
12.231,
157.41
],
"angles_trig": [
12.077,
146.08
],
updated results
2019-10-08 15:04:40 +05:00
"ne1d": 134,
CombineImprove() 2D: optimize all faces at once
2019-10-14 19:19:52 +05:00
"ne2d": 288,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 524,
"quality_histogram": "[0, 0, 0, 2, 4, 2, 4, 7, 16, 28, 38, 46, 52, 62, 72, 70, 55, 40, 24, 2]",
"total_badness": 820.9371699
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
21.121,
143.15
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
24.417,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
116.27
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
updated results
2019-10-08 15:04:40 +05:00
"ne1d": 194,
CombineImprove() 2D: optimize all faces at once
2019-10-14 19:19:52 +05:00
"ne2d": 594,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 1693,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 1, 5, 3, 28, 53, 113, 172, 250, 278, 293, 284, 173, 40]",
"total_badness": 2213.1235108
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
22.044,
141.38
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
25.297,
120.13
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
updated results
2019-10-08 15:04:40 +05:00
"ne1d": 266,
Build neighbors list in parallel Check in new results (part1.stl does not mesh with very_coarse anymore)
2019-10-08 22:26:43 +05:00
"ne2d": 986,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 4106,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 1, 5, 11, 28, 57, 139, 316, 492, 706, 817, 813, 570, 151]",
"total_badness": 5157.0222907
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
23.336,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
138.08
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
24.552,
127.25
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
updated results
2019-10-08 15:04:40 +05:00
"ne1d": 674,
Update results
2019-10-18 17:09:32 +05:00
"ne2d": 6854,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 82721,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 1, 3, 16, 118, 414, 1347, 3658, 7624, 12768, 17708, 19580, 14908, 4576]",
"total_badness": 100175.28811
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
"period.geo": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
11.121,
150.16
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
18.736,
133.1
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 344,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 1136,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 3269,
"quality_histogram": "[0, 0, 0, 0, 2, 4, 13, 24, 57, 92, 181, 260, 351, 430, 482, 454, 417, 280, 179, 43]",
"total_badness": 4762.4191481
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
12.301,
162.28
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
14.714,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
141.01
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 160,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 286,
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
"ne3d": 598,
"quality_histogram": "[0, 0, 0, 0, 3, 2, 13, 17, 35, 62, 59, 74, 66, 57, 56, 49, 39, 43, 19, 4]",
"total_badness": 1009.5773389
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Fix SwapImprove2 Don't allow swaps if an adjacent element was deleted in the current optimization pass. Also update test restults.
2020-11-25 21:55:44 +05:00
11.356,
162.52
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Fix SwapImprove2 Don't allow swaps if an adjacent element was deleted in the current optimization pass. Also update test restults.
2020-11-25 21:55:44 +05:00
16.741,
141.37
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 232,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 598,
Fix SwapImprove2 Don't allow swaps if an adjacent element was deleted in the current optimization pass. Also update test restults.
2020-11-25 21:55:44 +05:00
"ne3d": 1418,
"quality_histogram": "[0, 0, 0, 2, 9, 14, 27, 47, 66, 97, 109, 150, 161, 159, 147, 133, 119, 96, 66, 16]",
"total_badness": 2344.2576172
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
11.121,
150.16
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
19.085,
134.23
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 344,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 1136,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 3234,
"quality_histogram": "[0, 0, 0, 0, 2, 4, 12, 25, 48, 85, 148, 219, 353, 420, 468, 466, 428, 322, 182, 52]",
"total_badness": 4649.5043488
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
20.737,
141.73
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
23.506,
122.66
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 480,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 2256,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 11548,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 4, 28, 90, 222, 484, 867, 1460, 1999, 2324, 2067, 1547, 456]",
"total_badness": 14596.906314
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
[testing] update results
2019-10-31 20:38:40 +05:00
21.56,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
145.28
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
22.722,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
129.08
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 820,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 6226,
[testing] update results
2019-10-31 20:38:40 +05:00
"ne3d": 68692,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 11, 49, 185, 510, 1531, 3657, 6895, 10997, 14320, 15199, 11644, 3694]",
"total_badness": 84012.009025
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
add plane test
2019-10-07 16:41:15 +05:00
"plane.stl": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Update test results
2019-11-18 18:10:30 +05:00
1.2026,
166.97
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
3.5084,
Update test results
2019-11-18 18:10:30 +05:00
158.16
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Update test results
2019-11-18 18:10:30 +05:00
"ne1d": 886,
"ne2d": 2592,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 8292,
"quality_histogram": "[5, 9, 29, 46, 37, 51, 44, 46, 94, 160, 257, 412, 647, 899, 1265, 1378, 1157, 1002, 611, 143]",
"total_badness": 12343.24347
add plane test
2019-10-07 16:41:15 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
1.0841,
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
174.05
],
"angles_trig": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
3.4703,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
170.0
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Update results
2019-10-18 17:09:32 +05:00
"ne1d": 570,
"ne2d": 1202,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 1795,
"quality_histogram": "[2, 20, 39, 51, 70, 80, 102, 131, 157, 158, 176, 170, 145, 140, 122, 84, 67, 50, 26, 5]",
"total_badness": 4436.3977005
add plane test
2019-10-07 16:41:15 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
parallel SplitImprove
2019-10-25 17:57:00 +05:00
1.1033,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
171.77
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
parallel SplitImprove
2019-10-25 17:57:00 +05:00
3.728,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
165.5
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
updated results
2019-10-08 15:04:40 +05:00
"ne1d": 724,
Update results
2019-10-18 17:09:32 +05:00
"ne2d": 1730,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 3290,
"quality_histogram": "[3, 18, 29, 53, 45, 38, 53, 72, 116, 168, 230, 257, 328, 415, 424, 399, 334, 189, 92, 27]",
"total_badness": 6051.57684
add plane test
2019-10-07 16:41:15 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
1.2134,
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
169.94
],
"angles_trig": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
2.0839,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
163.08
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
updated results
2019-10-08 15:04:40 +05:00
"ne1d": 956,
Update results
2019-10-18 17:09:32 +05:00
"ne2d": 2828,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 8481,
"quality_histogram": "[3, 8, 38, 49, 47, 50, 55, 57, 96, 137, 195, 343, 515, 792, 1200, 1366, 1417, 1181, 742, 190]",
"total_badness": 12456.662988
add plane test
2019-10-07 16:41:15 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
1.1518,
168.3
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
1.7811,
158.38
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
updated results
2019-10-08 15:04:40 +05:00
"ne1d": 1554,
Update results
2019-10-18 17:09:32 +05:00
"ne2d": 6372,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 31605,
"quality_histogram": "[2, 8, 13, 9, 26, 53, 51, 69, 87, 191, 315, 647, 1221, 2378, 3853, 5328, 6181, 5935, 4068, 1170]",
"total_badness": 40844.172563
add plane test
2019-10-07 16:41:15 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
parallel SplitImprove
2019-10-25 17:57:00 +05:00
1.2315,
163.84
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
parallel SplitImprove
2019-10-25 17:57:00 +05:00
1.2724,
158.0
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
updated results
2019-10-08 15:04:40 +05:00
"ne1d": 2992,
Update results
2019-10-18 17:09:32 +05:00
"ne2d": 23322,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 281946,
"quality_histogram": "[4, 10, 12, 10, 9, 21, 29, 60, 99, 245, 724, 2133, 5538, 13549, 27663, 44504, 60069, 63936, 48457, 14874]",
"total_badness": 344547.37835
add plane test
2019-10-07 16:41:15 +05:00
}
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"revolution.geo": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
17.33,
146.89
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
16.848,
130.37
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 320,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 3110,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 8379,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"quality_histogram": "[0, 0, 0, 0, 0, 0, 3, 27, 90, 212, 461, 680, 967, 1096, 1153, 1170, 1080, 802, 520, 118]",
"total_badness": 11967.150699
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
8.7903,
155.06
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
15.518,
131.14
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 160,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 822,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 1234,
"quality_histogram": "[0, 0, 0, 1, 0, 10, 62, 86, 121, 132, 145, 139, 147, 99, 95, 67, 61, 38, 23, 8]",
"total_badness": 2290.4515055
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
optimize CalcPartition() and PartitionBoundary() new test results (2d meshing behaviour is changed with this commit)
2020-10-16 21:40:04 +05:00
16.888,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
145.04
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
optimize CalcPartition() and PartitionBoundary() new test results (2d meshing behaviour is changed with this commit)
2020-10-16 21:40:04 +05:00
17.592,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
134.95
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 240,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 1830,
optimize CalcPartition() and PartitionBoundary() new test results (2d meshing behaviour is changed with this commit)
2020-10-16 21:40:04 +05:00
"ne3d": 3886,
"quality_histogram": "[0, 0, 0, 0, 0, 1, 3, 27, 70, 177, 288, 405, 522, 502, 496, 407, 393, 336, 210, 49]",
"total_badness": 5799.4091506
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
18.416,
144.94
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
18.352,
126.94
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 320,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 3110,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 8258,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 2, 13, 48, 141, 339, 627, 829, 1041, 1149, 1209, 1156, 945, 605, 154]",
"total_badness": 11481.414846
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
19.038,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
140.94
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
22.544,
132.58
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 480,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 6864,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 33174,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 2, 2, 52, 185, 571, 1253, 2563, 4038, 5675, 6688, 6259, 4556, 1330]",
optimize CalcPartition() and PartitionBoundary() new test results (2d meshing behaviour is changed with this commit)
2020-10-16 21:40:04 +05:00
"total_badness": 41696.548838
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
21.902,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
143.83
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
19.492,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
121.07
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 800,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 17934,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 201307,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 4, 11, 83, 359, 1237, 3580, 9039, 19000, 30994, 42542, 46628, 36256, 11574]",
"total_badness": 244220.94708
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
Parallel SplitImprove2, update test results Due to prallelization, the order of splits is changed (sort by improvement of badness, like in other optimization passes)
2020-07-23 23:12:20 +05:00
"screw.step": [
{
"angles_tet": [
15.139,
148.36
],
"angles_trig": [
17.363,
140.59
],
"ne1d": 400,
"ne2d": 1436,
"ne3d": 2342,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 16, 61, 92, 165, 209, 246, 307, 280, 262, 272, 182, 148, 84, 18]",
"total_badness": 3718.1755695
},
{
"angles_tet": [
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
19.077,
Parallel SplitImprove2, update test results Due to prallelization, the order of splits is changed (sort by improvement of badness, like in other optimization passes)
2020-07-23 23:12:20 +05:00
146.38
],
"angles_trig": [
17.221,
126.09
],
"ne1d": 528,
"ne2d": 2792,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 8126,
"quality_histogram": "[0, 0, 0, 0, 0, 1, 4, 11, 33, 98, 190, 299, 553, 796, 1040, 1329, 1446, 1294, 795, 237]",
"total_badness": 10753.750681
Parallel SplitImprove2, update test results Due to prallelization, the order of splits is changed (sort by improvement of badness, like in other optimization passes)
2020-07-23 23:12:20 +05:00
},
{
"angles_tet": [
20.515,
144.03
],
"angles_trig": [
24.891,
120.48
],
"ne1d": 666,
"ne2d": 4922,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 31546,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 1, 5, 29, 94, 294, 701, 1778, 3224, 4988, 6720, 6967, 5142, 1603]",
"total_badness": 38702.936245
Parallel SplitImprove2, update test results Due to prallelization, the order of splits is changed (sort by improvement of badness, like in other optimization passes)
2020-07-23 23:12:20 +05:00
}
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"sculpture.geo": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
17.362,
152.2
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
25.459,
115.78
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 192,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 414,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 476,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 1, 2, 5, 16, 21, 32, 60, 64, 94, 100, 42, 25, 12, 2]",
"total_badness": 693.83910484
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
28.072,
137.6
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
27.015,
109.61
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 102,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 146,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 142,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 1, 6, 11, 19, 18, 35, 29, 17, 2]",
"total_badness": 181.04521663
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
23.253,
139.76
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
28.457,
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
103.35
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 144,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 250,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"ne3d": 264,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 5, 9, 13, 27, 29, 52, 47, 46, 25, 7]",
"total_badness": 345.68732003
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
17.362,
152.2
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
25.459,
115.78
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 192,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 414,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 476,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 1, 2, 5, 16, 21, 32, 60, 64, 94, 100, 42, 25, 12, 2]",
"total_badness": 693.83910484
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
16.484,
145.52
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
21.309,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
127.3
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 288,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 962,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 1325,
"quality_histogram": "[0, 0, 0, 0, 1, 3, 6, 25, 50, 85, 117, 137, 126, 139, 114, 144, 146, 127, 86, 19]",
"total_badness": 2043.076343
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
14.743,
147.57
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
17.184,
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
119.06
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 480,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 2394,
parallel SplitImprove
2019-10-25 17:57:00 +05:00
"ne3d": 6711,
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
"quality_histogram": "[0, 0, 0, 0, 2, 2, 7, 8, 21, 26, 61, 123, 262, 462, 722, 1073, 1348, 1317, 960, 317]",
"total_badness": 8476.8430085
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
"shaft.geo": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
8.3078,
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
162.65
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
9.3916,
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
147.77
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 708,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 1722,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 2734,
"quality_histogram": "[0, 0, 2, 4, 8, 15, 30, 41, 85, 143, 291, 393, 333, 284, 246, 293, 248, 190, 101, 27]",
"total_badness": 4392.4206713
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Fix SwapImprove2 Don't allow swaps if an adjacent element was deleted in the current optimization pass. Also update test restults.
2020-11-25 21:55:44 +05:00
15.154,
159.78
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
17.101,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
134.17
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 410,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 606,
Fix SwapImprove2 Don't allow swaps if an adjacent element was deleted in the current optimization pass. Also update test restults.
2020-11-25 21:55:44 +05:00
"ne3d": 791,
"quality_histogram": "[0, 0, 0, 0, 2, 3, 4, 7, 33, 42, 54, 61, 88, 86, 118, 92, 89, 72, 29, 11]",
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"total_badness": 1208.0644901
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
12.907,
Fix SwapImprove2 Don't allow swaps if an adjacent element was deleted in the current optimization pass. Also update test restults.
2020-11-25 21:55:44 +05:00
158.51
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
11.963,
148.8
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 510,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 1004,
Fix SwapImprove2 Don't allow swaps if an adjacent element was deleted in the current optimization pass. Also update test restults.
2020-11-25 21:55:44 +05:00
"ne3d": 1859,
"quality_histogram": "[0, 0, 0, 3, 7, 29, 43, 74, 68, 95, 115, 158, 153, 213, 250, 232, 206, 107, 81, 25]",
"total_badness": 3021.4076425
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
14.303,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
162.65
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
15.512,
147.17
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 708,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 1722,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 2708,
"quality_histogram": "[0, 0, 0, 1, 3, 1, 11, 22, 50, 108, 258, 412, 344, 299, 275, 311, 271, 203, 108, 31]",
"total_badness": 4149.681437
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
19.192,
146.58
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
19.637,
120.23
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 1138,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 4220,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 11314,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 3, 31, 71, 185, 327, 551, 977, 1446, 1854, 2226, 1947, 1281, 415]",
"total_badness": 14598.782663
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
22.61,
139.73
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
22.297,
118.87
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 1792,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 10600,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 63839,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 4, 22, 130, 424, 1292, 3122, 6208, 9992, 13576, 14305, 11041, 3723]",
"total_badness": 77729.577133
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
"sphere.geo": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
42.957,
93.227
],
"angles_trig": [
20.575,
79.713
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 0,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 126,
"ne3d": 126,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 6, 25, 47, 33, 12, 1, 2, 0, 0, 0, 0, 0]",
"total_badness": 237.42979301
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
46.583,
91.583
],
"angles_trig": [
31.308,
74.346
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 0,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 56,
"ne3d": 56,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 18, 19, 15, 0, 0]",
"total_badness": 68.826138928
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
51.677,
84.991
],
"angles_trig": [
28.501,
75.749
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 0,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 72,
"ne3d": 72,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 14, 27, 22, 7, 0, 0, 0]",
"total_badness": 97.572347502
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
42.957,
93.227
],
"angles_trig": [
20.575,
79.713
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 0,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 126,
"ne3d": 126,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 6, 25, 47, 33, 12, 1, 2, 0, 0, 0, 0, 0]",
"total_badness": 237.42979301
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
23.979,
130.28
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
21.654,
112.69
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 0,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 258,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"ne3d": 365,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 2, 22, 37, 56, 50, 43, 51, 29, 34, 23, 12, 6]",
"total_badness": 556.26115599
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
25.093,
140.27
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
24.971,
118.43
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 0,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 660,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"ne3d": 2290,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 6, 21, 55, 155, 246, 393, 499, 453, 343, 116]",
"total_badness": 2832.4661091
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
"sphereincube.geo": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
10.889,
166.62
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
parallel SplitImprove
2019-10-25 17:57:00 +05:00
11.28,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
151.39
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 46,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 202,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 422,
"quality_histogram": "[0, 0, 2, 60, 42, 39, 29, 25, 44, 40, 28, 14, 16, 8, 9, 12, 12, 25, 12, 5]",
"total_badness": 1241.4610254
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
8.6025,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
158.11
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
10.358,
143.19
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 24,
"ne2d": 60,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 128,
"quality_histogram": "[0, 0, 5, 12, 14, 16, 34, 28, 18, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]",
"total_badness": 451.47087804
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
9.1579,
165.65
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
8.211,
143.3
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 30,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 116,
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
"ne3d": 264,
"quality_histogram": "[0, 0, 7, 21, 33, 55, 37, 14, 20, 15, 10, 6, 13, 10, 6, 7, 5, 3, 2, 0]",
"total_badness": 850.25370446
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
10.889,
166.62
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
11.28,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
151.39
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 46,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 202,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 422,
"quality_histogram": "[0, 0, 2, 60, 42, 39, 29, 25, 44, 40, 28, 14, 16, 8, 9, 12, 12, 25, 12, 5]",
"total_badness": 1241.4610254
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
14.196,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
141.07
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
15.659,
128.46
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 74,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 418,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 1737,
"quality_histogram": "[0, 0, 0, 0, 0, 5, 5, 10, 28, 29, 64, 81, 147, 223, 267, 259, 251, 200, 126, 42]",
"total_badness": 2428.2600478
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
25.662,
141.31
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
22.482,
131.58
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 122,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 1082,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 13915,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 3, 20, 89, 213, 396, 802, 1392, 2185, 2853, 2977, 2228, 757]",
"total_badness": 17194.535821
Test in2d files, update results
2019-10-23 14:27:05 +05:00
}
],
"square.in2d": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
0.0,
0.0
],
"angles_trig": [
0.0,
0.0
],
update test results
2020-10-19 18:45:16 +05:00
"ne1d": 31,
"ne2d": 99,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne3d": 0,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]",
"total_badness": 0.0
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
0.0,
0.0
],
"angles_trig": [
0.0,
0.0
],
update test results
2020-10-19 18:45:16 +05:00
"ne1d": 27,
"ne2d": 75,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne3d": 0,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]",
"total_badness": 0.0
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
0.0,
0.0
],
"angles_trig": [
0.0,
0.0
],
update test results
2020-10-19 18:45:16 +05:00
"ne1d": 25,
"ne2d": 85,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne3d": 0,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]",
"total_badness": 0.0
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
0.0,
0.0
],
"angles_trig": [
0.0,
0.0
],
update test results
2020-10-19 18:45:16 +05:00
"ne1d": 31,
"ne2d": 99,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne3d": 0,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]",
"total_badness": 0.0
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
0.0,
0.0
],
"angles_trig": [
0.0,
0.0
],
update test results
2020-10-19 18:45:16 +05:00
"ne1d": 41,
"ne2d": 177,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne3d": 0,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]",
"total_badness": 0.0
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
0.0,
0.0
],
"angles_trig": [
0.0,
0.0
],
update test results
2020-10-19 18:45:16 +05:00
"ne1d": 30,
"ne2d": 108,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne3d": 0,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]",
"total_badness": 0.0
}
],
"squarecircle.in2d": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
0.0,
0.0
],
"angles_trig": [
0.0,
0.0
],
update test results
2020-10-19 18:45:16 +05:00
"ne1d": 32,
"ne2d": 148,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne3d": 0,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]",
"total_badness": 0.0
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
0.0,
0.0
],
"angles_trig": [
0.0,
0.0
],
update test results
2020-10-19 18:45:16 +05:00
"ne1d": 32,
"ne2d": 140,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne3d": 0,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]",
"total_badness": 0.0
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
0.0,
0.0
],
"angles_trig": [
0.0,
0.0
],
update test results
2020-10-19 18:45:16 +05:00
"ne1d": 32,
"ne2d": 148,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne3d": 0,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]",
"total_badness": 0.0
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
0.0,
0.0
],
"angles_trig": [
0.0,
0.0
],
update test results
2020-10-19 18:45:16 +05:00
"ne1d": 32,
"ne2d": 148,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne3d": 0,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]",
"total_badness": 0.0
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
0.0,
0.0
],
"angles_trig": [
0.0,
0.0
],
update test results
2020-10-19 18:45:16 +05:00
"ne1d": 43,
"ne2d": 300,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne3d": 0,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]",
"total_badness": 0.0
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
0.0,
0.0
],
"angles_trig": [
0.0,
0.0
],
optimize CalcPartition() and PartitionBoundary() new test results (2d meshing behaviour is changed with this commit)
2020-10-16 21:40:04 +05:00
"ne1d": 79,
update test results
2020-10-19 18:45:16 +05:00
"ne2d": 821,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne3d": 0,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]",
"total_badness": 0.0
}
],
"squarehole.in2d": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
0.0,
0.0
],
"angles_trig": [
0.0,
0.0
],
update test results
2020-10-19 18:45:16 +05:00
"ne1d": 32,
"ne2d": 124,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne3d": 0,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]",
"total_badness": 0.0
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
0.0,
0.0
],
"angles_trig": [
0.0,
0.0
],
update test results
2020-10-19 18:45:16 +05:00
"ne1d": 32,
"ne2d": 116,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne3d": 0,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]",
"total_badness": 0.0
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
0.0,
0.0
],
"angles_trig": [
0.0,
0.0
],
update test results
2020-10-19 18:45:16 +05:00
"ne1d": 32,
"ne2d": 124,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne3d": 0,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]",
"total_badness": 0.0
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
0.0,
0.0
],
"angles_trig": [
0.0,
0.0
],
update test results
2020-10-19 18:45:16 +05:00
"ne1d": 32,
"ne2d": 124,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne3d": 0,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]",
"total_badness": 0.0
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
0.0,
0.0
],
"angles_trig": [
0.0,
0.0
],
update test results
2020-10-19 18:45:16 +05:00
"ne1d": 43,
"ne2d": 249,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne3d": 0,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]",
"total_badness": 0.0
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
0.0,
0.0
],
"angles_trig": [
0.0,
0.0
],
optimize CalcPartition() and PartitionBoundary() new test results (2d meshing behaviour is changed with this commit)
2020-10-16 21:40:04 +05:00
"ne1d": 79,
update test results
2020-10-19 18:45:16 +05:00
"ne2d": 687,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne3d": 0,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]",
"total_badness": 0.0
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
"torus.geo": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
[testing] update results
2019-10-31 20:38:40 +05:00
16.805,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
152.81
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
19.689,
parallel SplitImprove
2019-10-25 17:57:00 +05:00
126.12
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 0,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 2534,
[testing] update results
2019-10-31 20:38:40 +05:00
"ne3d": 5726,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 3, 26, 89, 209, 392, 549, 656, 774, 819, 718, 633, 497, 273, 88]",
"total_badness": 8399.0875048
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Fix SwapImprove2 Don't allow swaps if an adjacent element was deleted in the current optimization pass. Also update test restults.
2020-11-25 21:55:44 +05:00
1.9786,
173.68
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Fix SwapImprove2 Don't allow swaps if an adjacent element was deleted in the current optimization pass. Also update test restults.
2020-11-25 21:55:44 +05:00
3.8198,
165.45
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 0,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 692,
Fix SwapImprove2 Don't allow swaps if an adjacent element was deleted in the current optimization pass. Also update test restults.
2020-11-25 21:55:44 +05:00
"ne3d": 2726,
"quality_histogram": "[19, 190, 366, 339, 352, 304, 237, 182, 157, 143, 110, 86, 53, 46, 34, 43, 30, 24, 10, 1]",
"total_badness": 13096.6735
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
18.239,
144.68
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
19.683,
120.56
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 0,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 1446,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 2739,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 2, 2, 15, 48, 132, 221, 357, 421, 424, 382, 318, 204, 161, 52]",
"total_badness": 3899.5318975
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
17.882,
148.83
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
19.93,
parallel SplitImprove
2019-10-25 17:57:00 +05:00
125.43
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 0,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 2534,
[testing] update results
2019-10-31 20:38:40 +05:00
"ne3d": 5613,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 1, 7, 32, 146, 287, 439, 640, 748, 826, 786, 707, 539, 349, 106]",
"total_badness": 7957.8333725
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
22.543,
142.87
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
22.771,
121.22
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 0,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 5894,
[testing] update results
2019-10-31 20:38:40 +05:00
"ne3d": 25261,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 11, 44, 119, 414, 855, 1696, 2860, 4123, 4940, 5200, 3813, 1186]",
"total_badness": 31467.735079
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
23.144,
144.46
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
22.932,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
121.88
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 0,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 16296,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 175488,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 1, 9, 59, 275, 907, 2675, 7276, 15893, 27102, 37072, 41339, 32333, 10547]",
"total_badness": 212080.25891
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
"trafo.geo": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
7.5246,
167.34
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
14.916,
Parallel SplitImprove2, update test results Due to prallelization, the order of splits is changed (sort by improvement of badness, like in other optimization passes)
2020-07-23 23:12:20 +05:00
132.02
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 690,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 1684,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 5178,
"quality_histogram": "[0, 0, 1, 0, 1, 8, 29, 37, 107, 193, 284, 368, 461, 566, 670, 689, 621, 536, 462, 145]",
"total_badness": 7465.8398023
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
8.0938,
167.14
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
7.7605,
156.22
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 390,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 522,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 1347,
"quality_histogram": "[0, 0, 4, 14, 14, 41, 75, 117, 125, 145, 169, 126, 140, 107, 82, 87, 54, 34, 11, 2]",
"total_badness": 2735.6699238
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
7.8932,
164.55
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
14.15,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
148.05
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 512,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 874,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 2395,
"quality_histogram": "[0, 0, 0, 3, 9, 13, 42, 68, 129, 146, 191, 209, 315, 390, 343, 236, 134, 94, 49, 24]",
"total_badness": 3955.4970644
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
7.5246,
167.34
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
14.916,
Parallel SplitImprove2, update test results Due to prallelization, the order of splits is changed (sort by improvement of badness, like in other optimization passes)
2020-07-23 23:12:20 +05:00
132.02
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 690,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 1684,
Parallel SplitImprove2, update test results Due to prallelization, the order of splits is changed (sort by improvement of badness, like in other optimization passes)
2020-07-23 23:12:20 +05:00
"ne3d": 5095,
"quality_histogram": "[0, 0, 1, 0, 0, 4, 19, 34, 101, 181, 263, 354, 439, 548, 689, 696, 611, 547, 467, 141]",
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"total_badness": 7282.7477811
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
16.895,
145.94
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
17.568,
126.69
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 1050,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 3812,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 18028,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 3, 15, 34, 62, 183, 573, 1437, 2190, 2345, 2680, 2713, 2701, 2419, 673]",
"total_badness": 23515.317943
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
15.34,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
149.41
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
19.234,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
129.78
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 1722,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 10042,
Don't swap very bad elements in SwapImprove Changes meshing -> new test results
2021-03-01 13:57:31 +05:00
"ne3d": 84906,
"quality_histogram": "[0, 0, 0, 0, 0, 2, 49, 1422, 720, 370, 704, 1186, 2437, 5535, 8984, 13266, 16409, 16882, 12872, 4068]",
"total_badness": 108652.77514
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
"twobricks.geo": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Parallel SplitImprove2, update test results Due to prallelization, the order of splits is changed (sort by improvement of badness, like in other optimization passes)
2020-07-23 23:12:20 +05:00
29.453,
134.56
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Parallel SplitImprove2, update test results Due to prallelization, the order of splits is changed (sort by improvement of badness, like in other optimization passes)
2020-07-23 23:12:20 +05:00
26.574,
91.538
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 72,
"ne2d": 50,
Parallel SplitImprove2, update test results Due to prallelization, the order of splits is changed (sort by improvement of badness, like in other optimization passes)
2020-07-23 23:12:20 +05:00
"ne3d": 36,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 8, 2, 18, 2, 4, 0, 0, 0, 0]",
"total_badness": 55.618194358
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
34.114,
126.16
],
"angles_trig": [
29.435,
120.21
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 56,
"ne2d": 34,
"ne3d": 22,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 4, 4, 0, 0, 8, 0, 0, 0, 0]",
"total_badness": 35.050418036
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
34.449,
125.92
],
"angles_trig": [
29.606,
120.18
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 56,
"ne2d": 34,
"ne3d": 22,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 2, 4, 0, 0, 8, 0, 0, 0, 0]",
"total_badness": 35.041320265
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Parallel SplitImprove2, update test results Due to prallelization, the order of splits is changed (sort by improvement of badness, like in other optimization passes)
2020-07-23 23:12:20 +05:00
29.453,
134.56
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Parallel SplitImprove2, update test results Due to prallelization, the order of splits is changed (sort by improvement of badness, like in other optimization passes)
2020-07-23 23:12:20 +05:00
26.574,
91.538
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 72,
"ne2d": 50,
Parallel SplitImprove2, update test results Due to prallelization, the order of splits is changed (sort by improvement of badness, like in other optimization passes)
2020-07-23 23:12:20 +05:00
"ne3d": 36,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 8, 2, 18, 2, 4, 0, 0, 0, 0]",
"total_badness": 55.618194358
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
24.085,
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
131.06
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
27.682,
109.51
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 116,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 134,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"ne3d": 176,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 11, 13, 17, 37, 23, 30, 17, 17, 7]",
"total_badness": 234.86129156
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
26.468,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
134.05
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
27.418,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
109.77
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 186,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 346,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"ne3d": 595,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 23, 40, 55, 95, 101, 105, 99, 60, 8]",
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
"total_badness": 777.63275434
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
"twocubes.geo": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Parallel SplitImprove2, update test results Due to prallelization, the order of splits is changed (sort by improvement of badness, like in other optimization passes)
2020-07-23 23:12:20 +05:00
29.453,
134.56
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Parallel SplitImprove2, update test results Due to prallelization, the order of splits is changed (sort by improvement of badness, like in other optimization passes)
2020-07-23 23:12:20 +05:00
26.574,
91.538
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 72,
"ne2d": 50,
Parallel SplitImprove2, update test results Due to prallelization, the order of splits is changed (sort by improvement of badness, like in other optimization passes)
2020-07-23 23:12:20 +05:00
"ne3d": 36,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 8, 2, 18, 2, 4, 0, 0, 0, 0]",
"total_badness": 55.618194358
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
34.114,
126.16
],
"angles_trig": [
29.435,
120.21
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 56,
"ne2d": 34,
"ne3d": 22,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 4, 4, 0, 0, 8, 0, 0, 0, 0]",
"total_badness": 35.050418036
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
34.449,
125.92
],
"angles_trig": [
29.606,
120.18
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 56,
"ne2d": 34,
"ne3d": 22,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 2, 4, 0, 0, 8, 0, 0, 0, 0]",
"total_badness": 35.041320265
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Parallel SplitImprove2, update test results Due to prallelization, the order of splits is changed (sort by improvement of badness, like in other optimization passes)
2020-07-23 23:12:20 +05:00
29.453,
134.56
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Parallel SplitImprove2, update test results Due to prallelization, the order of splits is changed (sort by improvement of badness, like in other optimization passes)
2020-07-23 23:12:20 +05:00
26.574,
91.538
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 72,
"ne2d": 50,
Parallel SplitImprove2, update test results Due to prallelization, the order of splits is changed (sort by improvement of badness, like in other optimization passes)
2020-07-23 23:12:20 +05:00
"ne3d": 36,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 8, 2, 18, 2, 4, 0, 0, 0, 0]",
"total_badness": 55.618194358
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
24.085,
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
131.06
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
27.682,
109.51
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 116,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 134,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"ne3d": 176,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 11, 13, 17, 37, 23, 30, 17, 17, 7]",
"total_badness": 234.86129156
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
26.468,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
134.05
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
27.418,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
109.77
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 186,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 346,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"ne3d": 595,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 23, 40, 55, 95, 101, 105, 99, 60, 8]",
SplitImprove2 - optimize only bad elements, update results
2020-07-23 16:18:14 +05:00
"total_badness": 777.63275434
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
"twocyl.geo": [
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
17.425,
151.3
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
21.178,
117.72
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 144,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 408,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"ne3d": 577,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 1, 6, 9, 16, 24, 56, 67, 84, 115, 83, 63, 36, 11, 6]",
"total_badness": 849.57493713
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Fix SwapImprove2 Don't allow swaps if an adjacent element was deleted in the current optimization pass. Also update test restults.
2020-11-25 21:55:44 +05:00
20.148,
153.82
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
25.599,
Fix SwapImprove2 Don't allow swaps if an adjacent element was deleted in the current optimization pass. Also update test restults.
2020-11-25 21:55:44 +05:00
118.3
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 68,
"ne2d": 100,
Fix SwapImprove2 Don't allow swaps if an adjacent element was deleted in the current optimization pass. Also update test restults.
2020-11-25 21:55:44 +05:00
"ne3d": 135,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 1, 0, 4, 5, 2, 9, 5, 18, 25, 16, 22, 20, 7, 1]",
"total_badness": 190.82756065
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
12.268,
Fix SwapImprove2 Don't allow swaps if an adjacent element was deleted in the current optimization pass. Also update test restults.
2020-11-25 21:55:44 +05:00
164.96
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Fix SwapImprove2 Don't allow swaps if an adjacent element was deleted in the current optimization pass. Also update test restults.
2020-11-25 21:55:44 +05:00
15.698,
145.1
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 102,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 238,
Fix SwapImprove2 Don't allow swaps if an adjacent element was deleted in the current optimization pass. Also update test restults.
2020-11-25 21:55:44 +05:00
"ne3d": 471,
"quality_histogram": "[0, 0, 1, 6, 3, 23, 25, 45, 63, 40, 34, 29, 30, 34, 27, 33, 43, 25, 8, 2]",
"total_badness": 950.55701299
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
17.51,
141.43
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
21.505,
117.52
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 144,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 408,
parallel SplitImprove
2019-10-25 17:57:00 +05:00
"ne3d": 575,
Rework on 3D SplitImprove - Try (expensive) split operation only if badness > 100 (of any adjacent tet) and badness > 0.1 * badness_max - Use FindInnerPoint before BFGS to ensure valid starting point (similar as in ImproveMesh() ) - Skip valid tets if goal==OPT_LEGAL (as in sequential version)
2019-10-29 21:58:37 +05:00
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 4, 7, 10, 20, 57, 65, 76, 116, 90, 74, 40, 14, 2]",
"total_badness": 830.26839459
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
21.286,
140.31
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
22.446,
114.89
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 214,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 910,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 1889,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 1, 2, 13, 31, 69, 126, 193, 280, 351, 341, 277, 168, 37]",
"total_badness": 2489.1406753
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
},
{
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
"angles_tet": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
26.173,
141.08
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
26.564,
123.51
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 350,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 2374,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"ne3d": 13532,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 23, 84, 243, 598, 1273, 2166, 2872, 3118, 2387, 764]",
"total_badness": 16428.083882
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
]
}
Reference in New Issue Copy Permalink