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