Branch data Line data Source code
1 : : /*
2 : : * VerdictWrapper.cpp
3 : : *
4 : : * Created on: Nov 18, 2014
5 : : *
6 : : */
7 : :
8 : : #include "moab/Interface.hpp"
9 : : #include "moab/verdict/VerdictWrapper.hpp"
10 : : #include "Internals.hpp"
11 : : #include "moab/verdict.h"
12 : :
13 : : namespace moab
14 : : {
15 : 2 : VerdictWrapper::VerdictWrapper( Interface* mb ) : mbImpl( mb )
16 : : {
17 : : // TODO Auto-generated constructor stub
18 : 2 : }
19 : :
20 : 5 : VerdictWrapper::~VerdictWrapper()
21 : : {
22 : : // TODO Auto-generated destructor stub
23 [ - + ]: 3 : }
24 : :
25 : : static int possibleQuality[MBMAXTYPE][MB_QUALITY_COUNT] = {
26 : : /*
27 : : MB_EDGE_RATIO = 0, // 0
28 : : | MB_MAX_EDGE_RATIO , // 1
29 : : | | MB_SKEW, // 2
30 : : | | | MB_TAPER, // 3
31 : : | | | | MB_VOLUME, // 4
32 : : | | | | | MB_STRETCH, // 5
33 : : | | | | | | MB_DIAGONAL, // 6
34 : : | | | | | | | MB_DIMENSION, // 7
35 : : | | | | | | | | MB_ODDY, // 8
36 : : | | | | | | | | | MB_MED_ASPECT_FROBENIUS,// 9
37 : : | | | | | | | | | | MB_MAX_ASPECT_FROBENIUS, // 10
38 : : | | | | | | | | | | | MB_CONDITION, // 11
39 : : | | | | | | | | | | | | MB_JACOBIAN, // 12
40 : : | | | | | | | | | | | | | MB_SCALED_JACOBIAN, // 13
41 : : | | | | | | | | | | | | | | MB_SHEAR, // 14
42 : : | | | | | | | | | | | | | | | MB_SHAPE, // 15
43 : : | | | | | | | | | | | | | | | | MB_RELATIVE_SIZE_SQUARED, // 16
44 : : | | | | | | | | | | | | | | | | | MB_SHAPE_AND_SIZE, // 17
45 : : | | | | | | | | | | | | | | | | | | MB_SHEAR_AND_SIZE, // 18
46 : : | | | | | | | | | | | | | | | | | | | MB_DISTORTION, // 19
47 : : | | | | | | | | | | | | | | | | | | | | MB_LENGTH, // 20
48 : : only for edge | | | | | | | | | | | | | | | | | | | | | MB_RADIUS_RATIO
49 : : // 21 tet | | | | | | | | | | | | | | | | | | | | | | MB_ASPECT_BETA //
50 : : 22 tet (very similar to 21) | | | | | | | | | | | | | | | | | | | | | |
51 : : | MB_ASPECT_RATIO // 23 tet | | | | | | | | | | | | | | | | | | | | |
52 : : | | | MB_ASPECT_GAMMA // 24 tet | | | | | | | | | | | | | | | | | | | |
53 : : | | | | | MB_MINIMUM_ANGLE // 25 tet | | | | | | | | | | | | | | | | | |
54 : : | | | | | | | | MB_COLLAPSE_RATIO // 26 tet | | | | | | | | | | | | | |
55 : : | | | | | | | | | | | | | MB_WARPAGE // 27 quad | | | | | | | | | |
56 : : | | | | | | | | | | | | | | | | | | MB_AREA // 28 quad | | | | | |
57 : : | | | | | | | | | | | | | | | | | | | | | | | MB_MAXIMUM_ANGLE // 29
58 : : quad | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |
59 : : | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |
60 : : */
61 : : /*0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29*/
62 : : { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // MBVERTEX
63 : : { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // MBEDGE
64 : : { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1 }, // MBTRI
65 : : { 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1 }, // MBQUAD
66 : : { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // MBPOLYGON
67 : : { 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0 }, // MBTET
68 : : { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // MBPYRAMID
69 : : { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // MBPRISM
70 : : { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // MBKNIFE
71 : : { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // MBHEX
72 : : { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // MBPOLYHEDRON
73 : : { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } // MBENTITYSET
74 : : };
75 : :
76 : : static int numQualities[MBMAXTYPE] = {
77 : : 0, // "MBVERTEX"
78 : : 1, // "MBEDGE", /**< Mesh Edge */
79 : : 13, // "MBTRI", /**< Triangular element (including shells) */
80 : : 22, // "MBQUAD", /**< Quadrilateral element (including shells) */
81 : : 0, // "MBPOLYGON", /**< Polygon */
82 : : 14, // "MBTET", /**< Tetrahedral element */
83 : : 0, //"MBPYRAMID", /**< Pyramid element (where are the face ids for this defined?) */
84 : : 1, // "MBPRISM", /**< Wedge element (Exodus has one, Cubit doesn't. Does Mesh need it?) */
85 : : 1, // "MBKNIFE", /**< Knife element */
86 : : 20, // "MBHEX", /**< Hexahedral element */
87 : : 0, //"MBPOLYHEDRON", /**< Polyhedron */
88 : : 0, // "MBENTITYSET", /**< MeshSet */
89 : : };
90 : : static char const* nameQuality[MB_QUALITY_COUNT] = {
91 : : " edge ratio", // MB_EDGE_RATIO = 0, // 0
92 : : " maximum edge ratio", // MB_MAX_EDGE_RATIO , // 1
93 : : " skew", // MB_SKEW, // 2
94 : : " taper", // MB_TAPER, // 3
95 : : " volume", // MB_VOLUME, // 4
96 : : " stretch", // MB_STRETCH, // 5
97 : : " diagonal", // MB_DIAGONAL, // 6
98 : : " characteristic length", // MB_DIMENSION, // 7
99 : : " oddy", // MB_ODDY, // 8
100 : : " average Frobenius aspect", // MB_MED_ASPECT_FROBENIUS,// 9
101 : : " maximum Frobenius aspect", // MB_MAX_ASPECT_FROBENIUS, // 10
102 : : " condition number", // MB_CONDITION, // 11
103 : : " jacobian", // MB_JACOBIAN, // 12
104 : : " scaled jacobian", // MB_SCALED_JACOBIAN, // 13
105 : : " shear", // MB_SHEAR, // 14
106 : : " shape", // MB_SHAPE, // 15
107 : : " relative size squared", // MB_RELATIVE_SIZE_SQUARED, // 16
108 : : " shape and size", // MB_SHAPE_AND_SIZE, // 17
109 : : " shear and size", // MB_SHEAR_AND_SIZE, // 18
110 : : " distortion", // MB_DISTORTION, // 19
111 : : // next are QuadMetricVals that are not in hex metrics
112 : : // length for edge:
113 : : " length", // MB_LENGTH, // 20 only for edge
114 : : " radius ratio", // MB_RADIUS_RATIO // 21 tet
115 : : " aspect beta", // MB_ASPECT_BETA // 22 tet
116 : : " aspect ratio", // MB_ASPECT_RATIO, // 23 MBTET
117 : : " aspect gamma", // MB_ASPECT_GAMMA // 24 tet
118 : : " minimum angle", // MB_MINIMUM_ANGLE, // 25 MBTET
119 : : " collapse ratio", // MB_COLLAPSE_RATIO, // 26 MBTET
120 : : " warpage", // MB_WARPAGE // 27 MBQUAD
121 : : " area", // MB_AREA // 28 MBQAD
122 : : " maximum angle" // MB_MAXIMUM_ANGLE // 29 MBQUAD
123 : : };
124 : :
125 : : static const char* nameType[MBMAXTYPE] = {
126 : : "MBVERTEX", /**< Mesh Vertex AKA node */
127 : : "MBEDGE", /**< Mesh Edge */
128 : : "MBTRI", /**< Triangular element (including shells) */
129 : : "MBQUAD", /**< Quadrilateral element (including shells) */
130 : : "MBPOLYGON", /**< Polygon */
131 : : "MBTET", /**< Tetrahedral element */
132 : : "MBPYRAMID", /**< Pyramid element (where are the face ids for this defined?) */
133 : : "MBPRISM", /**< Wedge element (Exodus has one, Cubit doesn't. Does Mesh need it?) */
134 : : "MBKNIFE", /**< Knife element */
135 : : "MBHEX", /**< Hexahedral element */
136 : : "MBPOLYHEDRON", /**< Polyhedron */
137 : : "MBENTITYSET", /**< MeshSet */
138 : : };
139 : :
140 : 2093 : ErrorCode VerdictWrapper::quality_measure( EntityHandle eh, QualityType q, double& quality, int num_nodes,
141 : : EntityType etype, double* coords )
142 : : {
143 : : double coordinates[27][3]; // at most 27 nodes per element
144 : :
145 [ + + ][ + - ]: 2093 : if( 0 == num_nodes && NULL == coords )
146 : : {
147 [ + - ]: 2040 : etype = TYPE_FROM_HANDLE( eh );
148 [ + + ]: 2040 : if( possibleQuality[etype][q] == 0 ) return MB_NOT_IMPLEMENTED;
149 : :
150 : : // get coordinates of points, if not passed already
151 : 890 : const EntityHandle* conn = NULL;
152 : : // int num_nodes;
153 [ + - ]: 890 : ErrorCode rval = mbImpl->get_connectivity( eh, conn, num_nodes );
154 [ - + ]: 890 : if( rval != MB_SUCCESS ) return rval;
155 [ + - ]: 890 : if( etype != MBPOLYHEDRON )
156 : : {
157 [ + - ]: 890 : rval = mbImpl->get_coords( conn, num_nodes, &( coordinates[0][0] ) );
158 [ - + ]: 890 : if( rval != MB_SUCCESS ) return rval;
159 : 890 : }
160 : : }
161 : : else
162 : : {
163 [ - + ]: 53 : if( num_nodes > 27 ) return MB_FAILURE;
164 [ + + ]: 314 : for( int i = 0; i < num_nodes; i++ )
165 : : {
166 [ + + ]: 1044 : for( int j = 0; j < 3; j++ )
167 : 783 : coordinates[i][j] = coords[3 * i + j];
168 : : }
169 : : }
170 : 943 : VerdictFunction func = 0;
171 : :
172 [ + + + + : 943 : switch( etype )
- + + - ]
173 : : {
174 : : case MBHEX: {
175 : 175 : num_nodes = 8;
176 [ + + + + : 175 : switch( q )
+ + + + +
+ + + + +
+ + + + +
+ - ]
177 : : {
178 : : case MB_EDGE_RATIO:
179 : 8 : func = v_hex_edge_ratio;
180 : 8 : break; // 0
181 : : case MB_MAX_EDGE_RATIO:
182 : 8 : func = v_hex_max_edge_ratio;
183 : 8 : break; // 1
184 : : case MB_SKEW:
185 : 9 : func = v_hex_skew;
186 : 9 : break; // 2
187 : : case MB_TAPER:
188 : 9 : func = v_hex_taper;
189 : 9 : break; // 3
190 : : case MB_VOLUME:
191 : 9 : func = v_hex_volume;
192 : 9 : break; // 4
193 : : case MB_STRETCH:
194 : 9 : func = v_hex_stretch;
195 : 9 : break; // 5
196 : : case MB_DIAGONAL:
197 : 9 : func = v_hex_diagonal;
198 : 9 : break; // 6
199 : : case MB_DIMENSION:
200 : 9 : func = v_hex_dimension;
201 : 9 : break; // 7
202 : : case MB_ODDY:
203 : 8 : func = v_hex_oddy;
204 : 8 : break; // 8
205 : : case MB_MED_ASPECT_FROBENIUS:
206 : 8 : func = v_hex_med_aspect_frobenius;
207 : 8 : break; // 9
208 : : case MB_MAX_ASPECT_FROBENIUS:
209 : 8 : func = v_hex_max_aspect_frobenius;
210 : 8 : break; // 10
211 : : case MB_CONDITION:
212 : 9 : func = v_hex_condition;
213 : 9 : break; // 11
214 : : case MB_JACOBIAN:
215 : 9 : func = v_hex_jacobian;
216 : 9 : break; // 12
217 : : case MB_SCALED_JACOBIAN:
218 : 9 : func = v_hex_scaled_jacobian;
219 : 9 : break; // 13
220 : : case MB_SHEAR:
221 : 9 : func = v_hex_shear;
222 : 9 : break; // 14
223 : : case MB_SHAPE:
224 : 9 : func = v_hex_shape;
225 : 9 : break; // 15
226 : : case MB_RELATIVE_SIZE_SQUARED:
227 : 9 : func = v_hex_relative_size_squared;
228 : 9 : break; // 16
229 : : case MB_SHAPE_AND_SIZE:
230 : 9 : func = v_hex_shape_and_size;
231 : 9 : break; // 17
232 : : case MB_SHEAR_AND_SIZE:
233 : 9 : func = v_hex_shear_and_size;
234 : 9 : break; // 18
235 : : case MB_DISTORTION:
236 : 9 : func = v_hex_distortion;
237 : 9 : break; // 19
238 : : default:
239 : 0 : return MB_FAILURE;
240 : : }
241 : 175 : break;
242 : : }
243 : : case MBEDGE: {
244 : 15 : num_nodes = 2;
245 [ + - ]: 15 : switch( q )
246 : : {
247 : : case MB_LENGTH:
248 : 15 : func = v_edge_length;
249 : 15 : break; // 20
250 : : default:
251 : 0 : return MB_FAILURE;
252 : : }
253 : 15 : break;
254 : : }
255 : : case MBTET: {
256 : 315 : num_nodes = 4;
257 [ + + + + : 315 : switch( q )
+ + + + +
+ + + + +
+ + - ]
258 : : {
259 : : case MB_EDGE_RATIO:
260 : 22 : func = v_tet_edge_ratio;
261 : 22 : break; // 0 //! Calculates tet edge ratio metric.
262 : : case MB_RADIUS_RATIO:
263 : 22 : func = v_tet_radius_ratio;
264 : 22 : break; // 21
265 : : case MB_ASPECT_BETA:
266 : 22 : func = v_tet_aspect_beta;
267 : 22 : break; // 22
268 : : case MB_ASPECT_RATIO:
269 : 22 : func = v_tet_aspect_ratio;
270 : 22 : break; // 23
271 : : case MB_ASPECT_GAMMA:
272 : 22 : func = v_tet_aspect_gamma;
273 : 22 : break; // 24
274 : : case MB_MAX_ASPECT_FROBENIUS:
275 : 22 : func = v_tet_aspect_frobenius;
276 : 22 : break; // 10
277 : : case MB_MINIMUM_ANGLE:
278 : 22 : func = v_tet_minimum_angle;
279 : 22 : break; // 25
280 : : case MB_COLLAPSE_RATIO:
281 : 22 : func = v_tet_collapse_ratio;
282 : 22 : break; // 26
283 : : case MB_VOLUME:
284 : 23 : func = v_tet_volume;
285 : 23 : break; // 4
286 : : case MB_CONDITION:
287 : 23 : func = v_tet_condition;
288 : 23 : break; // 11
289 : : case MB_JACOBIAN:
290 : 23 : func = v_tet_jacobian;
291 : 23 : break; // 12
292 : : case MB_SCALED_JACOBIAN:
293 : 22 : func = v_tet_scaled_jacobian;
294 : 22 : break; // 13
295 : : case MB_SHAPE:
296 : 23 : func = v_tet_shape;
297 : 23 : break; // 15
298 : : case MB_RELATIVE_SIZE_SQUARED:
299 : 23 : func = v_tet_relative_size_squared;
300 : 23 : break; // 16
301 : : case MB_SHAPE_AND_SIZE:
302 : 1 : func = v_tet_shape_and_size;
303 : 1 : break; // 17
304 : : case MB_DISTORTION:
305 : 1 : func = v_tet_distortion;
306 : 1 : break; // 19
307 : : default:
308 : 0 : return MB_FAILURE;
309 : : }
310 : 315 : break;
311 : : }
312 : : case MBPRISM: {
313 : 2 : num_nodes = 6;
314 [ + - ]: 2 : switch( q )
315 : : {
316 : : case MB_VOLUME:
317 : 2 : func = v_wedge_volume;
318 : 2 : break; // 4
319 : : default:
320 : 0 : return MB_FAILURE;
321 : : }
322 : 2 : break;
323 : : }
324 : : case MBKNIFE: {
325 : 0 : num_nodes = 7;
326 [ # # ]: 0 : switch( q )
327 : : {
328 : : case MB_VOLUME:
329 : 0 : func = v_knife_volume;
330 : 0 : break; // 4
331 : : default:
332 : 0 : return MB_FAILURE;
333 : : }
334 : 0 : break;
335 : : }
336 : : case MBQUAD: {
337 : 193 : num_nodes = 4;
338 [ + + + + : 193 : switch( q )
+ + + + +
+ + + + +
+ + + + +
+ + + +
- ]
339 : : {
340 : : case MB_EDGE_RATIO:
341 : 8 : func = v_quad_edge_ratio;
342 : 8 : break; // 0
343 : : case MB_MAX_EDGE_RATIO:
344 : 8 : func = v_quad_max_edge_ratio;
345 : 8 : break; // 1
346 : : case MB_ASPECT_RATIO:
347 : 9 : func = v_quad_aspect_ratio;
348 : 9 : break; // 23
349 : : case MB_RADIUS_RATIO:
350 : 8 : func = v_quad_radius_ratio;
351 : 8 : break; // 21
352 : : case MB_MED_ASPECT_FROBENIUS:
353 : 8 : func = v_quad_med_aspect_frobenius;
354 : 8 : break; // 9
355 : : case MB_MAX_ASPECT_FROBENIUS:
356 : 8 : func = v_quad_max_aspect_frobenius;
357 : 8 : break; // 10
358 : : case MB_SKEW:
359 : 9 : func = v_quad_skew;
360 : 9 : break; // 2
361 : : case MB_TAPER:
362 : 9 : func = v_quad_taper;
363 : 9 : break; // 3
364 : : case MB_WARPAGE:
365 : 9 : func = v_quad_warpage;
366 : 9 : break; // 27
367 : : case MB_AREA:
368 : 9 : func = v_quad_area;
369 : 9 : break; // 28
370 : : case MB_STRETCH:
371 : 9 : func = v_quad_stretch;
372 : 9 : break; // 5
373 : : case MB_MINIMUM_ANGLE:
374 : 1 : func = v_quad_minimum_angle;
375 : 1 : break; // 25
376 : : case MB_MAXIMUM_ANGLE:
377 : 9 : func = v_quad_maximum_angle;
378 : 9 : break; // 29
379 : : case MB_ODDY:
380 : 8 : func = v_quad_oddy;
381 : 8 : break; // 8
382 : : case MB_CONDITION:
383 : 9 : func = v_quad_condition;
384 : 9 : break; // 11
385 : : case MB_JACOBIAN:
386 : 9 : func = v_quad_jacobian;
387 : 9 : break; // 12
388 : : case MB_SCALED_JACOBIAN:
389 : 9 : func = v_quad_scaled_jacobian;
390 : 9 : break; // 13
391 : : case MB_SHEAR:
392 : 9 : func = v_quad_shear;
393 : 9 : break; // 14
394 : : case MB_SHAPE:
395 : 9 : func = v_quad_shape;
396 : 9 : break; // 15
397 : : case MB_RELATIVE_SIZE_SQUARED:
398 : 9 : func = v_quad_relative_size_squared;
399 : 9 : break; // 16
400 : : case MB_SHAPE_AND_SIZE:
401 : 9 : func = v_quad_shape_and_size;
402 : 9 : break; // 17
403 : : case MB_SHEAR_AND_SIZE:
404 : 9 : func = v_quad_shear_and_size;
405 : 9 : break; // 18
406 : : case MB_DISTORTION:
407 : 9 : func = v_quad_distortion;
408 : 9 : break; // 19
409 : : default:
410 : 0 : return MB_FAILURE;
411 : : }
412 : 193 : break;
413 : : }
414 : :
415 : : case MBTRI: {
416 : 243 : num_nodes = 3;
417 [ + + + + : 243 : switch( q )
+ + + + +
+ + + +
- ]
418 : : {
419 : : case MB_EDGE_RATIO:
420 : 18 : func = v_tri_edge_ratio;
421 : 18 : break; // 0
422 : : case MB_ASPECT_RATIO:
423 : 18 : func = v_tri_aspect_ratio;
424 : 18 : break; // 23
425 : : case MB_RADIUS_RATIO:
426 : 18 : func = v_tri_radius_ratio;
427 : 18 : break; // 21
428 : : case MB_MAX_ASPECT_FROBENIUS:
429 : 18 : func = v_tri_aspect_frobenius;
430 : 18 : break; // 10
431 : : case MB_AREA:
432 : 19 : func = v_tri_area;
433 : 19 : break; // 28
434 : : case MB_MINIMUM_ANGLE:
435 : 19 : func = v_tri_minimum_angle;
436 : 19 : break; // 25
437 : : case MB_MAXIMUM_ANGLE:
438 : 19 : func = v_tri_maximum_angle;
439 : 19 : break; // 29
440 : : case MB_CONDITION:
441 : 19 : func = v_tri_condition;
442 : 19 : break; // 11
443 : : case MB_SCALED_JACOBIAN:
444 : 19 : func = v_tri_scaled_jacobian;
445 : 19 : break; // 13
446 : : // does not exist, even though it was defined in verdict.h; remove it from there too
447 : : // case MB_SHEAR: func = v_tri_shear; break; // 14
448 : : case MB_RELATIVE_SIZE_SQUARED:
449 : 19 : func = v_tri_relative_size_squared;
450 : 19 : break; // 16
451 : : case MB_SHAPE:
452 : 19 : func = v_tri_shape;
453 : 19 : break; // 15
454 : : case MB_SHAPE_AND_SIZE:
455 : 19 : func = v_tri_shape_and_size;
456 : 19 : break; // 17
457 : : case MB_DISTORTION:
458 : 19 : func = v_tri_distortion;
459 : 19 : break; // 19
460 : : default:
461 : 0 : return MB_FAILURE;
462 : : }
463 : 243 : break;
464 : : }
465 : : default:
466 : 0 : break; // some have no measures
467 : : }
468 : :
469 [ - + ]: 943 : if( !func ) return MB_NOT_IMPLEMENTED;
470 : : // actual computation happens here
471 [ + - ]: 943 : quality = ( *func )( num_nodes, coordinates );
472 : :
473 : 2093 : return MB_SUCCESS;
474 : : }
475 : 1832 : const char* VerdictWrapper::quality_name( QualityType q )
476 : : {
477 : 1832 : return nameQuality[q];
478 : : }
479 : 0 : const char* VerdictWrapper::entity_type_name( EntityType etype )
480 : : {
481 : 0 : return nameType[etype];
482 : : }
483 : 0 : int VerdictWrapper::num_qualities( EntityType etype )
484 : : {
485 : 0 : return numQualities[etype];
486 : : }
487 : 0 : int VerdictWrapper::possible_quality( EntityType et, QualityType q )
488 : : {
489 : 0 : return possibleQuality[et][q];
490 : : }
491 : : // relative size needs a base size, that is set at global level, one for each major type (hex, tet,
492 : : // quad, tri)
493 : 1 : ErrorCode VerdictWrapper::set_size( double size )
494 : : {
495 : : // set the sizes for all of them; maybe we can set by type, this should be enough for simplicity
496 : 1 : v_set_hex_size( size );
497 : 1 : v_set_tet_size( size );
498 : 1 : v_set_quad_size( size );
499 : 1 : v_set_tri_size( size );
500 : 1 : return MB_SUCCESS;
501 : : }
502 : :
503 : 68 : ErrorCode VerdictWrapper::all_quality_measures( EntityHandle eh, std::map< QualityType, double >& qualities )
504 : : {
505 [ + - ]: 68 : EntityType etype = TYPE_FROM_HANDLE( eh );
506 [ + - ][ + - ]: 68 : if( etype == MBPOLYHEDRON || etype == MBVERTEX || etype == MBENTITYSET )
[ - + ]
507 : 0 : return MB_SUCCESS; // no quality for polyhedron or vertex or set
508 : :
509 : : double coordinates[27][3]; // at most 27 nodes per element
510 : : // get coordinates of points, if not passed already
511 : 68 : const EntityHandle* conn = NULL;
512 : : int num_nodes;
513 [ + - ]: 68 : ErrorCode rval = mbImpl->get_connectivity( eh, conn, num_nodes );
514 [ - + ]: 68 : if( rval != MB_SUCCESS ) return rval;
515 [ + - ]: 68 : rval = mbImpl->get_coords( conn, num_nodes, &( coordinates[0][0] ) );
516 [ - + ]: 68 : if( rval != MB_SUCCESS ) return rval;
517 : :
518 [ + + + - : 68 : switch( etype )
- + + - ]
519 : : {
520 : : case MBEDGE: {
521 [ + - ]: 12 : double leng = v_edge_length( 2, coordinates );
522 [ + - ]: 12 : qualities[MB_LENGTH] = leng;
523 : 12 : break;
524 : : }
525 : : case MBHEX: {
526 : 8 : num_nodes = 8;
527 : : HexMetricVals hexMetric;
528 [ + - ]: 8 : v_hex_quality( num_nodes, coordinates, V_HEX_ALL, &hexMetric );
529 [ + - ]: 8 : qualities[MB_EDGE_RATIO] = hexMetric.edge_ratio;
530 [ + - ]: 8 : qualities[MB_MAX_EDGE_RATIO] = hexMetric.max_edge_ratio;
531 [ + - ]: 8 : qualities[MB_SKEW] = hexMetric.skew;
532 [ + - ]: 8 : qualities[MB_TAPER] = hexMetric.taper;
533 [ + - ]: 8 : qualities[MB_VOLUME] = hexMetric.volume;
534 [ + - ]: 8 : qualities[MB_STRETCH] = hexMetric.stretch;
535 [ + - ]: 8 : qualities[MB_DIAGONAL] = hexMetric.diagonal;
536 [ + - ]: 8 : qualities[MB_DIMENSION] = hexMetric.dimension;
537 [ + - ]: 8 : qualities[MB_ODDY] = hexMetric.oddy;
538 [ + - ]: 8 : qualities[MB_MED_ASPECT_FROBENIUS] = hexMetric.med_aspect_frobenius;
539 : : // MB_CONDITION is the same as MB_MAX_ASPECT_FROBENIUS
540 [ + - ]: 8 : qualities[MB_MAX_ASPECT_FROBENIUS] = hexMetric.condition;
541 [ + - ]: 8 : qualities[MB_CONDITION] = hexMetric.condition;
542 [ + - ]: 8 : qualities[MB_JACOBIAN] = hexMetric.jacobian;
543 [ + - ]: 8 : qualities[MB_SCALED_JACOBIAN] = hexMetric.scaled_jacobian;
544 [ + - ]: 8 : qualities[MB_SHEAR] = hexMetric.shear;
545 [ + - ]: 8 : qualities[MB_SHAPE] = hexMetric.shape;
546 [ + - ]: 8 : qualities[MB_RELATIVE_SIZE_SQUARED] = hexMetric.relative_size_squared;
547 [ + - ]: 8 : qualities[MB_SHAPE_AND_SIZE] = hexMetric.shape_and_size;
548 [ + - ]: 8 : qualities[MB_SHEAR_AND_SIZE] = hexMetric.shear_and_size;
549 [ + - ]: 8 : qualities[MB_DISTORTION] = hexMetric.distortion;
550 : 8 : break;
551 : : }
552 : :
553 : : case MBTET: {
554 : 22 : num_nodes = 4;
555 : : TetMetricVals tetMetrics;
556 [ + - ]: 22 : v_tet_quality( num_nodes, coordinates, V_TET_ALL, &tetMetrics );
557 [ + - ]: 22 : qualities[MB_EDGE_RATIO] = tetMetrics.edge_ratio;
558 [ + - ]: 22 : qualities[MB_RADIUS_RATIO] = tetMetrics.radius_ratio;
559 [ + - ]: 22 : qualities[MB_ASPECT_BETA] = tetMetrics.aspect_beta;
560 [ + - ]: 22 : qualities[MB_ASPECT_RATIO] = tetMetrics.aspect_ratio;
561 [ + - ]: 22 : qualities[MB_ASPECT_GAMMA] = tetMetrics.aspect_gamma;
562 [ + - ]: 22 : qualities[MB_MAX_ASPECT_FROBENIUS] = tetMetrics.aspect_frobenius;
563 [ + - ]: 22 : qualities[MB_MINIMUM_ANGLE] = tetMetrics.minimum_angle;
564 [ + - ]: 22 : qualities[MB_COLLAPSE_RATIO] = tetMetrics.collapse_ratio;
565 [ + - ]: 22 : qualities[MB_VOLUME] = tetMetrics.volume;
566 [ + - ]: 22 : qualities[MB_CONDITION] = tetMetrics.condition;
567 [ + - ]: 22 : qualities[MB_JACOBIAN] = tetMetrics.jacobian;
568 [ + - ]: 22 : qualities[MB_SCALED_JACOBIAN] = tetMetrics.scaled_jacobian;
569 [ + - ]: 22 : qualities[MB_SHAPE] = tetMetrics.shape;
570 [ + - ]: 22 : qualities[MB_RELATIVE_SIZE_SQUARED] = tetMetrics.relative_size_squared;
571 [ + - ]: 22 : qualities[MB_SHAPE_AND_SIZE] = tetMetrics.shape_and_size;
572 [ + - ]: 22 : qualities[MB_DISTORTION] = tetMetrics.distortion;
573 : 22 : break;
574 : : }
575 : : case MBPRISM: {
576 : 0 : num_nodes = 6;
577 [ # # ]: 0 : double volu = v_wedge_volume( num_nodes, coordinates );
578 [ # # ]: 0 : qualities[MB_VOLUME] = volu;
579 : 0 : break;
580 : : }
581 : : case MBKNIFE: {
582 : 0 : num_nodes = 7;
583 [ # # ]: 0 : double volu = v_knife_volume( num_nodes, coordinates );
584 [ # # ]: 0 : qualities[MB_VOLUME] = volu;
585 : 0 : break;
586 : : }
587 : : case MBQUAD: {
588 : 8 : num_nodes = 4;
589 : : QuadMetricVals quadMetrics;
590 [ + - ]: 8 : v_quad_quality( num_nodes, coordinates, V_QUAD_ALL, &quadMetrics );
591 [ + - ]: 8 : qualities[MB_EDGE_RATIO] = quadMetrics.edge_ratio;
592 [ + - ]: 8 : qualities[MB_MAX_EDGE_RATIO] = quadMetrics.max_edge_ratio;
593 [ + - ]: 8 : qualities[MB_ASPECT_RATIO] = quadMetrics.aspect_ratio; // 23
594 [ + - ]: 8 : qualities[MB_RADIUS_RATIO] = quadMetrics.radius_ratio; // 21
595 [ + - ]: 8 : qualities[MB_MED_ASPECT_FROBENIUS] = quadMetrics.med_aspect_frobenius; // 9
596 [ + - ]: 8 : qualities[MB_MAX_ASPECT_FROBENIUS] = quadMetrics.max_aspect_frobenius; // 10
597 [ + - ]: 8 : qualities[MB_SKEW] = quadMetrics.skew; // 2
598 [ + - ]: 8 : qualities[MB_TAPER] = quadMetrics.taper; // 3
599 [ + - ]: 8 : qualities[MB_WARPAGE] = quadMetrics.warpage; // 27
600 [ + - ]: 8 : qualities[MB_AREA] = quadMetrics.area; // 28
601 [ + - ]: 8 : qualities[MB_STRETCH] = quadMetrics.stretch; // 5
602 [ + - ]: 8 : qualities[MB_MINIMUM_ANGLE] = quadMetrics.minimum_angle; // 25
603 [ + - ]: 8 : qualities[MB_MAXIMUM_ANGLE] = quadMetrics.maximum_angle; // 29
604 [ + - ]: 8 : qualities[MB_ODDY] = quadMetrics.oddy; // 8
605 [ + - ]: 8 : qualities[MB_CONDITION] = quadMetrics.condition; // 11
606 [ + - ]: 8 : qualities[MB_JACOBIAN] = quadMetrics.jacobian; // 12
607 [ + - ]: 8 : qualities[MB_SCALED_JACOBIAN] = quadMetrics.scaled_jacobian; // 13
608 [ + - ]: 8 : qualities[MB_SHEAR] = quadMetrics.shear; // 14
609 [ + - ]: 8 : qualities[MB_SHAPE] = quadMetrics.shape; // 15
610 [ + - ]: 8 : qualities[MB_RELATIVE_SIZE_SQUARED] = quadMetrics.relative_size_squared; // 16
611 [ + - ]: 8 : qualities[MB_SHAPE_AND_SIZE] = quadMetrics.shape_and_size; // 17
612 [ + - ]: 8 : qualities[MB_SHEAR_AND_SIZE] = quadMetrics.shear_and_size; // 18
613 [ + - ]: 8 : qualities[MB_DISTORTION] = quadMetrics.distortion; // 19
614 : 8 : break;
615 : : }
616 : :
617 : : case MBTRI: {
618 : 18 : num_nodes = 3;
619 : : TriMetricVals triMetrics;
620 [ + - ]: 18 : v_tri_quality( num_nodes, coordinates, V_TRI_ALL, &triMetrics );
621 [ + - ]: 18 : qualities[MB_EDGE_RATIO] = triMetrics.edge_ratio; // 0
622 [ + - ]: 18 : qualities[MB_ASPECT_RATIO] = triMetrics.aspect_ratio; // 23
623 [ + - ]: 18 : qualities[MB_RADIUS_RATIO] = triMetrics.radius_ratio; // 21
624 [ + - ]: 18 : qualities[MB_MAX_ASPECT_FROBENIUS] = triMetrics.aspect_frobenius; // 10
625 [ + - ]: 18 : qualities[MB_AREA] = triMetrics.area; // 28
626 [ + - ]: 18 : qualities[MB_MINIMUM_ANGLE] = triMetrics.minimum_angle; // 25
627 [ + - ]: 18 : qualities[MB_MAXIMUM_ANGLE] = triMetrics.maximum_angle; // 29
628 [ + - ]: 18 : qualities[MB_CONDITION] = triMetrics.condition; // 11
629 [ + - ]: 18 : qualities[MB_SCALED_JACOBIAN] = triMetrics.scaled_jacobian; // 13
630 : : // does not exist, even though it was defined in verdict.h; remove it from there too
631 : : // case MB_SHEAR: func = v_tri_shear; break; // 14
632 [ + - ]: 18 : qualities[MB_RELATIVE_SIZE_SQUARED] = triMetrics.relative_size_squared; // 16
633 [ + - ]: 18 : qualities[MB_SHAPE] = triMetrics.shape; // 15
634 [ + - ]: 18 : qualities[MB_SHAPE_AND_SIZE] = triMetrics.shape_and_size; // 17
635 [ + - ]: 18 : qualities[MB_DISTORTION] = triMetrics.distortion; // 19
636 : 18 : break;
637 : : }
638 : : default:
639 : 0 : return MB_NOT_IMPLEMENTED;
640 : : }
641 : 68 : return MB_SUCCESS;
642 : : }
643 : :
644 [ + - ][ + - ]: 4 : } // namespace moab
|
