ForkMaster/netgen
1
0
Fork 0
mirror of https://github.com/NGSolve/netgen.git synced 2024-11-11 16:49:16 +05:00
Code Issues Packages Projects Releases Wiki Activity
3fae0e029f
netgen/tests/pytest/results.json

3442 lines
95 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": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
16.335,
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
152.61
[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,
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": 348,
"quality_histogram": "[0, 0, 0, 0, 0, 4, 3, 5, 4, 9, 18, 23, 27, 46, 55, 62, 55, 20, 16, 1]",
"total_badness": 514.05343802
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 SwapImprove
2020-07-15 22:26:39 +05:00
13.26,
163.45
[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
11.907,
152.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": 32,
"ne2d": 220,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 556,
"quality_histogram": "[0, 0, 0, 4, 7, 14, 27, 33, 41, 29, 37, 47, 34, 50, 41, 51, 63, 38, 30, 10]",
"total_badness": 997.95710204
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
2.8811,
172.75
[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
9.0948,
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": 48,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 428,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 770,
"quality_histogram": "[2, 11, 24, 35, 27, 40, 36, 49, 76, 95, 61, 81, 68, 31, 52, 32, 17, 19, 12, 2]",
"total_badness": 2061.8554811
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,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 2153,
"quality_histogram": "[0, 5, 20, 35, 79, 117, 112, 108, 75, 47, 53, 85, 111, 177, 250, 290, 240, 204, 118, 27]",
"total_badness": 4183.5255584
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]",
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": 369.95189199
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
20.8,
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
137.89
[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,
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": 631,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"quality_histogram": "[0, 0, 0, 0, 1, 0, 0, 3, 8, 27, 48, 61, 68, 107, 85, 89, 63, 49, 20, 2]",
"total_badness": 943.22430902
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
5.4026,
168.34
[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.552,
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,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 2048,
"quality_histogram": "[0, 2, 10, 18, 56, 101, 108, 97, 63, 36, 41, 60, 100, 164, 255, 284, 287, 195, 135, 36]",
"total_badness": 3675.3946288
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": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
19.374,
[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,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"ne3d": 1071,
"quality_histogram": "[0, 0, 0, 0, 0, 1, 3, 22, 48, 36, 110, 131, 98, 115, 161, 162, 68, 66, 30, 20]",
"total_badness": 1667.9770545
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 SwapImprove
2020-07-15 22:26:39 +05:00
15.925,
157.39
[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.814,
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 SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 381,
"quality_histogram": "[0, 0, 0, 0, 0, 9, 13, 18, 26, 25, 30, 29, 42, 32, 39, 28, 41, 21, 22, 6]",
"total_badness": 648.79536841
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 SwapImprove
2020-07-15 22:26:39 +05:00
5.1577,
170.71
[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
8.073,
161.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": 0,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 192,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 748,
"quality_histogram": "[0, 5, 41, 63, 100, 92, 74, 71, 54, 49, 43, 43, 23, 20, 20, 20, 10, 5, 12, 3]",
"total_badness": 2470.4393077
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": [
parallel SplitImprove
2019-10-25 17:57:00 +05:00
20.184,
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": [
parallel SplitImprove
2019-10-25 17:57:00 +05:00
21.582,
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,
[testing] update results
2019-10-31 20:38:40 +05:00
"ne3d": 69863,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 1, 7, 30, 69, 222, 646, 1562, 3675, 7035, 11242, 14646, 15515, 11810, 3403]",
"total_badness": 85648.446235
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": [
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.427,
143.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
23.929,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
119.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": 388,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 6142,
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": 54709,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 2, 17, 61, 251, 727, 2119, 4819, 8218, 11623, 13209, 10213, 3450]",
"total_badness": 65887.909834
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,
parallel SplitImprove
2019-10-25 17:57:00 +05:00
"ne3d": 35,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 4, 3, 8, 4, 10, 2, 0, 0, 2]",
"total_badness": 50.263302236
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,
parallel SplitImprove
2019-10-25 17:57:00 +05:00
"ne3d": 35,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 4, 3, 8, 4, 10, 2, 0, 0, 2]",
"total_badness": 50.263302236
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
}
],
"frame.step": [
{
[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
2.9095,
Update test results
2019-11-18 18:10:30 +05:00
171.1
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Update test results
2019-11-18 18:10:30 +05:00
2.6092,
172.05
[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": 10108,
"ne2d": 30160,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 152987,
"quality_histogram": "[0, 3, 1, 3, 6, 20, 57, 149, 535, 1257, 2919, 5827, 10443, 16376, 21793, 26060, 26579, 22897, 14346, 3716]",
"total_badness": 202618.94822
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": [
2.296,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
175.61
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
[testing] Add results for OCC 7.4, skip tests on Ubuntu (with OCC 7.3)
2019-10-28 19:11:42 +05:00
1.8443,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
175.57
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
[testing] Add results for OCC 7.4, skip tests on Ubuntu (with OCC 7.3)
2019-10-28 19:11:42 +05:00
"ne1d": 5988,
"ne2d": 11102,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 29317,
"quality_histogram": "[3, 4, 5, 8, 16, 44, 120, 246, 699, 1024, 1561, 2491, 3110, 3894, 4329, 4296, 3374, 2408, 1353, 332]",
"total_badness": 43465.268618
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
2.5792,
parallel SplitImprove
2019-10-25 17:57:00 +05:00
174.11
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
"angles_trig": [
Update test results
2019-11-18 18:10:30 +05:00
2.2053,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
174.13
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
[testing] Add results for OCC 7.4, skip tests on Ubuntu (with OCC 7.3)
2019-10-28 19:11:42 +05:00
"ne1d": 9622,
Update test results
2019-11-18 18:10:30 +05:00
"ne2d": 23964,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 80994,
"quality_histogram": "[2, 14, 4, 20, 18, 40, 94, 224, 488, 1114, 2412, 4540, 7490, 10250, 12758, 13185, 12021, 9204, 5660, 1456]",
"total_badness": 111934.48598
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": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
21.248,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
144.42
[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,
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": 1986,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 8, 20, 39, 66, 127, 177, 243, 307, 299, 259, 259, 141, 41]",
"total_badness": 2751.3290713
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,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 788,
"quality_histogram": "[0, 0, 1, 10, 9, 4, 22, 15, 39, 41, 68, 84, 103, 97, 84, 85, 48, 49, 25, 4]",
"total_badness": 1361.2509309
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,
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": 1135,
"quality_histogram": "[0, 0, 0, 2, 4, 5, 14, 26, 39, 57, 79, 117, 135, 136, 153, 151, 97, 67, 45, 8]",
"total_badness": 1799.6066426
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,
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": 2598,
"quality_histogram": "[0, 0, 0, 0, 0, 4, 3, 4, 26, 48, 95, 172, 225, 326, 383, 383, 339, 325, 216, 49]",
"total_badness": 3605.8538311
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,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 6700,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 1, 2, 22, 29, 52, 170, 325, 637, 877, 1046, 1169, 1237, 870, 263]",
"total_badness": 8579.1803793
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 SwapImprove
2020-07-15 22:26:39 +05:00
140.94
[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,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
122.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": 1862,
Update results
2019-10-18 17:09:32 +05:00
"ne2d": 19474,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 136555,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 1, 12, 59, 278, 860, 2542, 6422, 13021, 21252, 29142, 31120, 24008, 7838]",
"total_badness": 165971.00359
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
],
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne1d": 84,
"ne2d": 436,
"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
],
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne1d": 86,
"ne2d": 476,
"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
],
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne1d": 86,
"ne2d": 490,
"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
],
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne1d": 84,
"ne2d": 436,
"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
],
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne1d": 84,
"ne2d": 460,
"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
],
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne1d": 88,
"ne2d": 496,
"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": [
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.385,
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": [
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
13.429,
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,
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": 178770,
"quality_histogram": "[0, 0, 0, 0, 0, 5, 15, 82, 303, 822, 2352, 6216, 10998, 19000, 27368, 30676, 31225, 26902, 18298, 4508]",
"total_badness": 233986.23978
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,
"quality_histogram": "[0, 0, 0, 0, 13, 14, 37, 138, 377, 848, 1450, 2328, 3278, 4286, 4195, 3745, 3323, 2685, 1964, 710]",
"total_badness": 42208.591965
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,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 70783,
"quality_histogram": "[0, 0, 0, 1, 30, 72, 170, 340, 660, 1449, 2616, 4104, 6681, 9272, 10482, 10764, 9861, 7627, 4870, 1784]",
"total_badness": 99055.647638
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,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 128240,
"quality_histogram": "[0, 0, 0, 0, 4, 29, 79, 237, 725, 1935, 4437, 7722, 11695, 17431, 18582, 18325, 17276, 15158, 10938, 3667]",
"total_badness": 176228.44994
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,
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": 5066,
"quality_histogram": "[0, 0, 11, 118, 169, 57, 61, 111, 95, 184, 293, 368, 508, 651, 617, 577, 496, 429, 246, 75]",
[testing] update results
2019-10-31 20:38:40 +05:00
"total_badness": 8799.2034431
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.9601,
167.83
[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,
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": 1654,
"quality_histogram": "[0, 1, 12, 50, 83, 156, 195, 155, 160, 124, 137, 141, 133, 102, 67, 34, 32, 43, 24, 5]",
"total_badness": 4104.7339693
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]",
[testing] update results
2019-10-31 20:38:40 +05:00
"total_badness": 5146.3098744
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,
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": 5005,
"quality_histogram": "[0, 0, 7, 100, 165, 53, 56, 108, 103, 165, 278, 336, 503, 574, 623, 631, 520, 438, 264, 81]",
"total_badness": 8524.8161998
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 SplitImprove
2019-10-25 17:57:00 +05:00
145.26
[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,
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": 101047,
[testing] update results
2019-10-31 20:38:40 +05:00
"quality_histogram": "[0, 0, 0, 0, 0, 1, 5, 8, 52, 104, 356, 989, 2551, 5548, 10164, 16045, 20725, 22251, 16920, 5328]",
"total_badness": 124081.88321
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": [
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
13.213,
147.22
[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,
128.03
[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,
Update results
2019-10-18 17:09:32 +05:00
"ne3d": 1260,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"quality_histogram": "[0, 0, 0, 0, 0, 2, 2, 9, 17, 21, 37, 69, 106, 152, 209, 198, 165, 149, 98, 26]",
"total_badness": 1750.899754
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,
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": 528,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"quality_histogram": "[0, 0, 0, 2, 4, 2, 4, 3, 16, 24, 36, 42, 54, 69, 66, 74, 61, 46, 24, 1]",
"total_badness": 813.76674756
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
20.704,
143.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
24.375,
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,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 1, 5, 14, 28, 54, 137, 197, 250, 262, 308, 248, 149, 40]",
"total_badness": 2242.4690855
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.052,
141.32
[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.868,
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
119.75
],
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,
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": 4101,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 0, 5, 12, 29, 53, 158, 292, 530, 683, 826, 812, 568, 133]",
"total_badness": 5160.0364225
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.306,
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,
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": 82748,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 1, 3, 17, 121, 417, 1362, 3669, 7623, 12797, 17700, 19603, 14878, 4557]",
"total_badness": 100231.59467
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": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
14.582,
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,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 590,
"quality_histogram": "[0, 0, 0, 0, 6, 10, 15, 24, 40, 62, 65, 67, 64, 47, 50, 45, 38, 42, 12, 3]",
"total_badness": 1045.1530377
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.731,
162.52
[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.335,
148.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": 232,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 598,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 1383,
"quality_histogram": "[0, 0, 0, 1, 13, 17, 35, 53, 69, 92, 121, 143, 146, 153, 154, 121, 115, 84, 52, 14]",
"total_badness": 2341.0219936
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,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 8268,
"quality_histogram": "[4, 9, 33, 42, 41, 54, 43, 47, 100, 142, 258, 402, 641, 938, 1253, 1305, 1193, 1022, 588, 153]",
"total_badness": 12309.108485
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,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 1823,
"quality_histogram": "[2, 22, 36, 57, 66, 78, 105, 136, 163, 183, 187, 160, 150, 143, 114, 76, 69, 47, 25, 4]",
"total_badness": 4525.5906501
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,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
172.29
[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,
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
163.66
],
updated results
2019-10-08 15:04:40 +05:00
"ne1d": 724,
Update results
2019-10-18 17:09:32 +05:00
"ne2d": 1730,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 3267,
"quality_histogram": "[3, 15, 32, 52, 50, 38, 44, 76, 118, 161, 234, 258, 360, 375, 419, 411, 310, 195, 94, 22]",
"total_badness": 6011.5192864
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,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
165.56
[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,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 8577,
"quality_histogram": "[3, 9, 37, 48, 48, 52, 58, 60, 87, 127, 205, 328, 507, 805, 1199, 1394, 1476, 1215, 736, 183]",
"total_badness": 12579.939101
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.3345,
171.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
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,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 31588,
"quality_histogram": "[2, 7, 14, 6, 25, 55, 52, 67, 91, 190, 307, 635, 1249, 2307, 3892, 5308, 6146, 5974, 4098, 1163]",
"total_badness": 40793.027008
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,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 281957,
"quality_histogram": "[4, 9, 10, 11, 11, 21, 33, 65, 96, 260, 755, 2146, 5563, 13605, 27734, 44577, 59933, 63963, 48268, 14893]",
"total_badness": 344644.09939
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,
[testing] update results
2019-10-31 20:38:40 +05:00
"quality_histogram": "[0, 0, 0, 0, 0, 0, 3, 27, 91, 210, 453, 679, 983, 1088, 1150, 1165, 1083, 812, 518, 117]",
"total_badness": 11964.310211
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": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
16.884,
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": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
16.408,
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,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 3859,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 6, 25, 68, 162, 284, 407, 508, 515, 505, 411, 383, 323, 208, 54]",
"total_badness": 5750.8446823
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,
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": 8253,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 2, 13, 47, 138, 333, 624, 839, 1047, 1151, 1187, 1166, 945, 608, 153]",
[testing] update results
2019-10-31 20:38:40 +05:00
"total_badness": 11468.848993
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]",
"total_badness": 41696.548837
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.857,
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": [
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.774,
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,
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": 201342,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 4, 13, 87, 366, 1250, 3570, 9060, 18977, 31022, 42571, 46627, 36250, 11545]",
"total_badness": 244286.77424
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
}
],
"screw.step": [
{
[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
15.139,
148.36
[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.363,
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
140.59
],
Check for number of 1d and 2d elements Store test results in .json
2019-10-07 14:45:08 +05:00
"ne1d": 400,
[testing] Add results for OCC 7.4, skip tests on Ubuntu (with OCC 7.3)
2019-10-28 19:11:42 +05:00
"ne2d": 1436,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"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
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.55,
146.38
[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.221,
126.09
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
[testing] Add results for OCC 7.4, skip tests on Ubuntu (with OCC 7.3)
2019-10-28 19:11:42 +05:00
"ne1d": 528,
"ne2d": 2792,
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": 8129,
"quality_histogram": "[0, 0, 0, 0, 0, 1, 4, 8, 35, 96, 188, 298, 537, 817, 1057, 1323, 1446, 1284, 798, 237]",
"total_badness": 10753.086327
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.515,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
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
24.891,
120.48
[testing] Check for min/max trig/tet angles
2019-10-23 22:05:51 +05:00
],
[testing] Add results for OCC 7.4, skip tests on Ubuntu (with OCC 7.3)
2019-10-28 19:11:42 +05:00
"ne1d": 666,
"ne2d": 4922,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 31540,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 1, 5, 31, 92, 290, 707, 1762, 3221, 4997, 6712, 6966, 5146, 1610]",
"total_badness": 38689.280913
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": [
16.998,
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,
"quality_histogram": "[0, 0, 0, 0, 1, 2, 5, 9, 18, 27, 60, 127, 255, 455, 730, 1074, 1345, 1332, 952, 319]",
"total_badness": 8467.8828851
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": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
9.1003,
164.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
9.2165,
146.85
[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,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 2725,
"quality_histogram": "[0, 0, 3, 6, 15, 19, 28, 47, 87, 138, 286, 386, 316, 291, 250, 298, 242, 178, 104, 31]",
"total_badness": 4420.5345142
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
15.158,
158.0
[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 SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 796,
"quality_histogram": "[0, 0, 0, 0, 1, 3, 5, 6, 28, 40, 56, 62, 82, 83, 128, 96, 88, 75, 29, 14]",
"total_badness": 1204.2331383
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.5703,
165.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
12.063,
152.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": 510,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 1004,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 1832,
"quality_histogram": "[0, 0, 2, 8, 9, 35, 44, 79, 84, 110, 107, 164, 159, 194, 235, 212, 202, 104, 66, 18]",
"total_badness": 3083.8429043
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": [
Fix SwapImprove
2020-07-15 22:26:39 +05:00
14.459,
150.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": 708,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 1722,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 2703,
"quality_histogram": "[0, 0, 0, 0, 2, 3, 11, 17, 48, 118, 246, 396, 350, 292, 274, 307, 281, 221, 102, 35]",
"total_badness": 4122.3827179
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": [
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
8.1657,
165.53
[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
9.2408,
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.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": 30,
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne2d": 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
"ne3d": 262,
"quality_histogram": "[0, 0, 4, 26, 30, 52, 33, 16, 22, 13, 11, 12, 11, 8, 6, 7, 6, 3, 2, 0]",
"total_badness": 832.73325512
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
],
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne1d": 35,
"ne2d": 121,
"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
],
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne1d": 30,
"ne2d": 98,
"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
],
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne1d": 30,
"ne2d": 96,
"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
],
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne1d": 35,
"ne2d": 121,
"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
],
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne1d": 44,
"ne2d": 190,
"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
],
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne1d": 58,
"ne2d": 396,
"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
],
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne1d": 32,
"ne2d": 158,
"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
],
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne1d": 32,
"ne2d": 130,
"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
],
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne1d": 32,
"ne2d": 140,
"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
],
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne1d": 32,
"ne2d": 158,
"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
],
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne1d": 45,
"ne2d": 313,
"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
],
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne1d": 81,
"ne2d": 843,
"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
],
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne1d": 32,
"ne2d": 134,
"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
],
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne1d": 32,
"ne2d": 108,
"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
],
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne1d": 32,
"ne2d": 118,
"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
],
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne1d": 32,
"ne2d": 134,
"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
],
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne1d": 45,
"ne2d": 253,
"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
],
Test in2d files, update results
2019-10-23 14:27:05 +05:00
"ne1d": 81,
"ne2d": 709,
"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 SwapImprove
2020-07-15 22:26:39 +05:00
1.7223,
174.81
[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
4.9314,
166.92
[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 SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 2691,
"quality_histogram": "[26, 258, 398, 331, 349, 264, 205, 192, 123, 145, 87, 67, 74, 48, 30, 33, 29, 20, 11, 1]",
"total_badness": 14056.890733
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,
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,
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": 5193,
"quality_histogram": "[0, 0, 1, 1, 1, 11, 32, 47, 111, 196, 275, 365, 465, 566, 668, 699, 617, 545, 452, 141]",
"total_badness": 7518.4794095
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.1301,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
160.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,
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": 1353,
"quality_histogram": "[0, 0, 3, 13, 12, 38, 80, 115, 128, 149, 170, 126, 139, 107, 87, 85, 54, 34, 11, 2]",
"total_badness": 2731.8393348
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,
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": 2381,
"quality_histogram": "[0, 0, 0, 3, 9, 15, 42, 68, 122, 139, 198, 209, 307, 380, 349, 235, 137, 97, 46, 25]",
"total_badness": 3929.5802554
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,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +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,
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": 5099,
"quality_histogram": "[0, 0, 1, 1, 0, 3, 23, 37, 102, 189, 265, 343, 430, 564, 673, 707, 612, 543, 465, 141]",
"total_badness": 7304.8063731
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
6.8825,
166.88
[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,
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": 17990,
"quality_histogram": "[0, 0, 1, 0, 0, 0, 3, 15, 34, 64, 183, 570, 1424, 2206, 2299, 2682, 2720, 2713, 2367, 709]",
"total_badness": 23464.671179
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.338,
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,
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": 84837,
"quality_histogram": "[0, 0, 0, 0, 0, 3, 55, 1435, 719, 373, 691, 1186, 2492, 5459, 8935, 13171, 16437, 16966, 12825, 4090]",
[testing] update results
2019-10-31 20:38:40 +05:00
"total_badness": 108583.90765
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": [
22.934,
142.89
],
"angles_trig": [
18.806,
142.29
],
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,
"ne3d": 41,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 8, 2, 16, 3, 4, 0, 0, 0, 0]",
"total_badness": 68.897088924
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": [
22.934,
142.89
],
"angles_trig": [
18.806,
142.29
],
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,
"ne3d": 41,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 8, 2, 16, 3, 4, 0, 0, 0, 0]",
"total_badness": 68.897088924
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]",
[testing] update results
2019-10-31 20:38:40 +05:00
"total_badness": 777.63275563
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": [
22.934,
142.89
],
"angles_trig": [
18.806,
142.29
],
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,
"ne3d": 41,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 8, 2, 16, 3, 4, 0, 0, 0, 0]",
"total_badness": 68.897088924
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": [
22.934,
142.89
],
"angles_trig": [
18.806,
142.29
],
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,
"ne3d": 41,
Sort edges by improvement in SwapImprove
2019-10-24 17:09:37 +05:00
"quality_histogram": "[0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 8, 2, 16, 3, 4, 0, 0, 0, 0]",
"total_badness": 68.897088924
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]",
[testing] update results
2019-10-31 20:38:40 +05:00
"total_badness": 777.63275563
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 SwapImprove
2020-07-15 22:26:39 +05:00
19.944,
152.59
[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,
123.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": 68,
"ne2d": 100,
Fix SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 130,
"quality_histogram": "[0, 0, 0, 0, 0, 0, 1, 1, 3, 6, 7, 9, 5, 13, 21, 16, 21, 19, 7, 1]",
"total_badness": 187.02414176
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,
164.21
[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.1,
144.2
[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 SwapImprove
2020-07-15 22:26:39 +05:00
"ne3d": 468,
"quality_histogram": "[0, 0, 1, 10, 5, 27, 33, 42, 51, 36, 38, 28, 35, 40, 29, 26, 37, 24, 4, 2]",
"total_badness": 980.42864262
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