reorder_test.cpp

Go to the documentation of this file.

#include "moab/Core.hpp"
#include "moab/ReorderTool.hpp"
#include "TestUtil.hpp"
 
using namespace moab;
 
// some tag names
const char GLOBAL_ID_NAME[] = "GLOBAL_ID"; /* global ID assigned to each vtx and quad */
const char SET_IDS_NAME[] = "SET_IDS"; /* global IDs of entities in each set */
const char SET_HANDLES_NAME[] = "SET_HANDLES"; /* handles of entities in each set */
const char CONN_IDS_NAME[] = "CONN_IDS"; /* global IDs of vertices in each quad */
const char CONN_NAME[] = "CONN_HANDLES"; /* handles of vertices in each quad */
const char VAR_INTS_NAME[] = "VAR_LEN_INTS"; /* variable length tag on nodes */
const char BIT_NAME[] = "TEST_BIT_TAG";
const int ENTS_PER_SET = 6;
const int BITS_PER_TAG = 2;
 
Core* mbcore = 0;
Interface* mb = 0;
Tag order_tag = 0;
 
const size_t INTERVALS = 6;
 
/* values for variable-length tag data */
void tag_vals_from_gid( int global_id, std::vector< int >& values )
{
 int i = global_id / ( INTERVALS + 1 );
 int j = global_id % ( INTERVALS + 1 );
 int n = global_id % 5 + 1;
 int vals[] = { i, j, n, i + j, j - 2 * i };
 values.resize( n );
 std::copy( vals, vals + n, values.begin() );
}
 
unsigned char bits_from_gid( int global_id )
{
 return global_id % ( 1 << BITS_PER_TAG );
}
 
unsigned char order_from_gid( int global_id )
{
 return global_id % 3;
}
 
void coords_from_gid( int global_id, double coords[3] )
{
 int i = global_id / ( INTERVALS + 1 );
 int j = global_id % ( INTERVALS + 1 );
 coords[0] = i;
 coords[1] = j;
 coords[2] = 0.1 * ( i + j );
}
 
void build_mesh();
void check_order_by_sets_and_adj();
void call_reorder();
void check_order();
void check_node_coords();
void check_quad_conn();
void check_set_meshset();
void check_list_meshset();
void check_big_meshset();
void check_handle_tag();
void check_varlen_tag();
void check_bit_tag();
 
int main()
{
 // Define global MOAB instance for use by all tests
 Core mcore;
 mbcore = &mcore;
 mb = &mcore;
 
 // if this fails, don't bother with anything else
 if( RUN_TEST( build_mesh ) ) return 1;
 
 // this test needs be be run before reordering the mesh
 int errors = 0;
 errors += RUN_TEST( check_order_by_sets_and_adj );
 
 // if reorder returned failure, don't bother doing anything else
 int tmp = RUN_TEST( call_reorder );
 if( tmp ) return tmp + errors;
 
 // test the core stuff
 errors += RUN_TEST( check_order );
 errors += RUN_TEST( check_node_coords );
 errors += RUN_TEST( check_quad_conn );
 errors += RUN_TEST( check_set_meshset );
 errors += RUN_TEST( check_list_meshset );
 errors += RUN_TEST( check_big_meshset );
 errors += RUN_TEST( check_handle_tag );
 errors += RUN_TEST( check_varlen_tag );
 errors += RUN_TEST( check_bit_tag );
 return errors;
}
 
void build_mesh()
{
 const unsigned dense = MB_TAG_CREAT | MB_TAG_DENSE;
 const unsigned sparse = MB_TAG_CREAT | MB_TAG_SPARSE;
 
 ErrorCode rval;
 
 // get/create various tags
 Tag gid;
 rval = mb->tag_get_handle( GLOBAL_ID_NAME, 1, MB_TYPE_INTEGER, gid, dense );CHECK_ERR( rval );
 
 Tag conn_ids;
 rval = mb->tag_get_handle( CONN_IDS_NAME, 4, MB_TYPE_INTEGER, conn_ids, dense );CHECK_ERR( rval );
 
 Tag conn_handles;
 rval = mb->tag_get_handle( CONN_NAME, 4, MB_TYPE_HANDLE, conn_handles, dense );CHECK_ERR( rval );
 
 Tag set_ids;
 rval = mb->tag_get_handle( SET_IDS_NAME, ENTS_PER_SET, MB_TYPE_INTEGER, set_ids, sparse );CHECK_ERR( rval );
 
 Tag set_handles;
 rval = mb->tag_get_handle( SET_HANDLES_NAME, ENTS_PER_SET, MB_TYPE_HANDLE, set_handles, sparse );CHECK_ERR( rval );
 
 Tag var_data;
 rval = mb->tag_get_handle( VAR_INTS_NAME, 0, MB_TYPE_INTEGER, var_data, dense | MB_TAG_VARLEN );CHECK_ERR( rval );
 
 Tag bit_data;
 rval = mb->tag_get_handle( BIT_NAME, BITS_PER_TAG, MB_TYPE_BIT, bit_data, MB_TAG_CREAT );CHECK_ERR( rval );
 
 rval = mb->tag_get_handle( "ORDER", 1, MB_TYPE_INTEGER, order_tag, dense );CHECK_ERR( rval );
 
 // create and tag vertices
 std::vector< int > values;
 EntityHandle nodes[( INTERVALS + 1 ) * ( INTERVALS + 1 )];
 for( size_t i = 0; i <= INTERVALS; ++i )
 {
 for( size_t j = 0; j <= INTERVALS; ++j )
 {
 size_t idx = i * ( INTERVALS + 1 ) + j;
 double coords[3];
 coords_from_gid( idx, coords );
 rval = mb->create_vertex( coords, nodes[idx] );CHECK_ERR( rval );
 
 int tagval = idx;
 rval = mb->tag_set_data( gid, nodes + idx, 1, &tagval );CHECK_ERR( rval );
 
 tag_vals_from_gid( idx, values );
 const void* ptr = &values[0];
 const int size = values.size();
 rval = mb->tag_set_by_ptr( var_data, nodes + idx, 1, &ptr, &size );CHECK_ERR( rval );
 
 unsigned char bits = bits_from_gid( idx );
 rval = mb->tag_set_data( bit_data, nodes + idx, 1, &bits );CHECK_ERR( rval );
 
 int group = order_from_gid( idx );
 rval = mb->tag_set_data( order_tag, nodes + idx, 1, &group );CHECK_ERR( rval );
 }
 }
 
 // create and tag elements
 EntityHandle quads[INTERVALS * INTERVALS];
 for( size_t i = 0; i < INTERVALS; ++i )
 {
 for( size_t j = 0; j < INTERVALS; ++j )
 {
 size_t idx = i * INTERVALS + j;
 size_t n0 = i * ( INTERVALS + 1 ) + j;
 size_t n1 = ( i + 1 ) * ( INTERVALS + 1 ) + j;
 size_t n2 = ( i + 1 ) * ( INTERVALS + 1 ) + j + 1;
 size_t n3 = i * ( INTERVALS + 1 ) + j + 1;
 EntityHandle conn[4] = { nodes[n0], nodes[n1], nodes[n2], nodes[n3] };
 EntityHandle h;
 rval = mb->create_element( MBQUAD, conn, 4, h );CHECK_ERR( rval );
 
 int tagval = idx;
 rval = mb->tag_set_data( gid, &h, 1, &tagval );CHECK_ERR( rval );
 
 int ids[4] = { static_cast< int >( n0 ), static_cast< int >( n1 ), static_cast< int >( n2 ),
 static_cast< int >( n3 ) };
 rval = mb->tag_set_data( conn_ids, &h, 1, ids );CHECK_ERR( rval );
 
 rval = mb->tag_set_data( conn_handles, &h, 1, conn );CHECK_ERR( rval );
 
 int group = order_from_gid( idx );
 rval = mb->tag_set_data( order_tag, &h, 1, &group );CHECK_ERR( rval );
 
 quads[idx] = h;
 }
 }
 
 // create a few sets
 for( int i = 0; i < 2; ++i )
 {
 EntityHandle* from = 0;
 size_t count;
 unsigned flag;
 if( i )
 {
 from = nodes;
 count = ( INTERVALS + 1 ) * ( INTERVALS + 1 );
 flag = MESHSET_SET;
 }
 else
 {
 from = quads;
 count = INTERVALS * INTERVALS;
 flag = MESHSET_ORDERED;
 }
 
 EntityHandle h;
 rval = mb->create_meshset( flag | MESHSET_TRACK_OWNER, h );CHECK_ERR( rval );
 
 EntityHandle ents[ENTS_PER_SET];
 int gids[ENTS_PER_SET];
 for( int j = 0; j < ENTS_PER_SET; ++j )
 {
 int idx = j + 2;
 idx = ( idx * idx ) % count;
 ents[j] = from[idx];
 gids[j] = idx;
 }
 
 rval = mb->add_entities( h, ents, ENTS_PER_SET );CHECK_ERR( rval );
 
 rval = mb->tag_set_data( set_ids, &h, 1, gids );CHECK_ERR( rval );
 
 rval = mb->tag_set_data( set_handles, &h, 1, ents );CHECK_ERR( rval );
 }
 
 // create a set containing all vertices
 EntityHandle allverts;
 rval = mb->create_meshset( MESHSET_SET, allverts );CHECK_ERR( rval );
 rval = mb->add_entities( allverts, nodes, ( INTERVALS + 1 ) * ( INTERVALS + 1 ) );CHECK_ERR( rval );
}
 
void call_reorder()
{
 // do reorder
 ReorderTool tool( mbcore );
 Tag mapping;
 ErrorCode rval = tool.handle_order_from_int_tag( order_tag, -1, mapping );CHECK_ERR( rval );
 rval = tool.reorder_entities( mapping );CHECK_ERR( rval );
}
 
void check_order( EntityType type )
{
 ErrorCode rval;
 
 Tag gid;
 rval = mb->tag_get_handle( GLOBAL_ID_NAME, 1, MB_TYPE_INTEGER, gid );CHECK_ERR( rval );
 
 Range ents;
 rval = mb->get_entities_by_type( 0, type, ents );CHECK_ERR( rval );
 
 std::vector< int > ids( ents.size() );
 rval = mb->tag_get_data( gid, ents, &ids[0] );CHECK_ERR( rval );
 
 for( size_t i = 1; i < ids.size(); ++i )
 {
 CHECK( order_from_gid( ids[i - 1] ) <= order_from_gid( ids[i] ) );
 }
}
 
void check_order_by_sets_and_adj()
{
 ErrorCode rval;
 
 std::vector< EntityHandle > quads;
 rval = mb->get_entities_by_dimension( 0, 2, quads );CHECK_ERR( rval );
 CHECK( !quads.empty() );
 
 // group quads by the ordering assigned in build_mesh()
 std::map< int, Range > groups;
 std::vector< int > group_ids( quads.size() );
 rval = mb->tag_get_data( order_tag, &quads[0], quads.size(), &group_ids[0] );CHECK_ERR( rval );
 for( size_t i = 0; i < quads.size(); ++i )
 groups[group_ids[i]].insert( quads[i] );
 
 // create sets from groups
 Range sets;
 for( std::map< int, Range >::iterator i = groups.begin(); i != groups.end(); ++i )
 {
 EntityHandle h;
 rval = mb->create_meshset( MESHSET_SET, h );CHECK_ERR( rval );
 rval = mb->add_entities( h, i->second );CHECK_ERR( rval );
 sets.insert( h );
 }
 
 // Get ordering assigned by set containment
 Tag neworder = 0;
 ReorderTool tool( mbcore );
 rval = tool.handle_order_from_sets_and_adj( sets, neworder );CHECK_ERR( rval );
 
 // check that new quad handles are clustered as expected
 std::vector< std::pair< EntityHandle, EntityHandle > > ranges;
 for( std::map< int, Range >::iterator i = groups.begin(); i != groups.end(); ++i )
 {
 std::vector< EntityHandle > newh( i->second.size() );
 rval = mb->tag_get_data( neworder, i->second, &newh[0] );CHECK_ERR( rval );
 std::sort( newh.begin(), newh.end() );
 CHECK( newh[0] > 0 ); // zero implies some quad got left out of the reordering
 std::pair< EntityHandle, EntityHandle > p( newh[0], newh[newh.size() - 1] );
 ranges.push_back( p );
 }
 std::sort( ranges.begin(), ranges.end() );
 for( size_t i = 1; i < ranges.size(); ++i )
 {
 CHECK( ranges[i - 1].second < ranges[i].first );
 }
 
 // group vertices as we expect handles to be grouped
 std::map< std::vector< int >, Range > vtxgroups;
 Range verts;
 rval = mb->get_entities_by_type( 0, MBVERTEX, verts );CHECK_ERR( rval );
 for( Range::iterator i = verts.begin(); i != verts.end(); ++i )
 {
 Range adj;
 rval = mb->get_adjacencies( &*i, 1, 2, false, adj );CHECK_ERR( rval );
 std::vector< int > ids( adj.size() );
 rval = mb->tag_get_data( order_tag, adj, &ids[0] );CHECK_ERR( rval );
 std::sort( ids.begin(), ids.end() );
 ids.erase( std::unique( ids.begin(), ids.end() ), ids.end() );
 vtxgroups[ids].insert( *i );
 }
 
 // check that new vertex handles are clustered as expected
 ranges.clear();
 std::map< std::vector< int >, Range >::iterator j;
 for( j = vtxgroups.begin(); j != vtxgroups.end(); ++j )
 {
 std::vector< EntityHandle > newh( j->second.size() );
 rval = mb->tag_get_data( neworder, j->second, &newh[0] );CHECK_ERR( rval );
 std::sort( newh.begin(), newh.end() );
 CHECK( newh[0] > 0 ); // zero implies some quad got left out of the reordering
 std::pair< EntityHandle, EntityHandle > p( newh[0], newh[newh.size() - 1] );
 ranges.push_back( p );
 }
 std::sort( ranges.begin(), ranges.end() );
 for( size_t i = 1; i < ranges.size(); ++i )
 {
 CHECK( ranges[i - 1].second < ranges[i].first );
 }
}
 
void check_order()
{
 check_order( MBVERTEX );
 check_order( MBQUAD );
}
 
void check_node_coords()
{
 ErrorCode rval;
 
 Tag gid;
 rval = mb->tag_get_handle( GLOBAL_ID_NAME, 1, MB_TYPE_INTEGER, gid );CHECK_ERR( rval );
 
 Range verts;
 rval = mb->get_entities_by_type( 0, MBVERTEX, verts );CHECK_ERR( rval );
 
 std::vector< int > ids( verts.size() );
 rval = mb->tag_get_data( gid, verts, &ids[0] );CHECK_ERR( rval );
 
 std::vector< double > coords( 3 * verts.size() );
 rval = mb->get_coords( verts, &coords[0] );CHECK_ERR( rval );
 
 std::vector< double > expected( 3 * verts.size() );
 for( size_t i = 0; i < ids.size(); ++i )
 coords_from_gid( ids[i], &expected[3 * i] );
 
 CHECK_EQUAL( expected, coords );
}
 
void check_quad_conn()
{
 ErrorCode rval;
 
 Tag gid;
 rval = mb->tag_get_handle( GLOBAL_ID_NAME, 1, MB_TYPE_INTEGER, gid );CHECK_ERR( rval );
 
 Tag conn_ids;
 rval = mb->tag_get_handle( CONN_IDS_NAME, 4, MB_TYPE_INTEGER, conn_ids );CHECK_ERR( rval );
 
 std::vector< EntityHandle > quads;
 rval = mb->get_entities_by_type( 0, MBQUAD, quads );CHECK_ERR( rval );
 
 std::vector< EntityHandle > conn;
 rval = mb->get_connectivity( &quads[0], quads.size(), conn, true );CHECK_ERR( rval );
 
 CHECK_EQUAL( 4 * quads.size(), conn.size() );
 std::vector< int > exp_ids( 4 * quads.size() ), act_ids( 4 * quads.size() );
 rval = mb->tag_get_data( conn_ids, &quads[0], quads.size(), &exp_ids[0] );CHECK_ERR( rval );
 rval = mb->tag_get_data( gid, &conn[0], conn.size(), &act_ids[0] );CHECK_ERR( rval );
 
 CHECK_EQUAL( exp_ids, act_ids );
}
 
void check_meshset_common( bool ordered )
{
 ErrorCode rval;
 
 Tag set_ids;
 rval = mb->tag_get_handle( SET_IDS_NAME, ENTS_PER_SET, MB_TYPE_INTEGER, set_ids );CHECK_ERR( rval );
 
 Tag gid;
 rval = mb->tag_get_handle( GLOBAL_ID_NAME, 1, MB_TYPE_INTEGER, gid );CHECK_ERR( rval );
 
 Range sets;
 rval = mb->get_entities_by_type_and_tag( 0, MBENTITYSET, &set_ids, 0, 1, sets );CHECK_ERR( rval );
 CHECK( !sets.empty() );
 
 EntityHandle set = 0;
 unsigned flags;
 for( Range::iterator it = sets.begin(); it != sets.end(); ++it )
 {
 rval = mb->get_meshset_options( *it, flags );CHECK_ERR( rval );
 if( ( ordered && ( flags & MESHSET_ORDERED ) ) || ( !ordered && !( flags & MESHSET_ORDERED ) ) )
 {
 set = *it;
 break;
 }
 }
 CHECK( 0 != set );
 
 std::vector< EntityHandle > ents;
 rval = mb->get_entities_by_handle( set, ents );CHECK_ERR( rval );
 CHECK_EQUAL( ENTS_PER_SET, (int)ents.size() );
 
 int exp[ENTS_PER_SET], act[ENTS_PER_SET];
 rval = mb->tag_get_data( set_ids, &set, 1, exp );CHECK_ERR( rval );
 rval = mb->tag_get_data( gid, &ents[0], ENTS_PER_SET, act );CHECK_ERR( rval );
 
 if( !ordered )
 {
 std::sort( exp, exp + ENTS_PER_SET );
 std::sort( act, act + ENTS_PER_SET );
 }
 
 CHECK_ARRAYS_EQUAL( exp, ENTS_PER_SET, act, ENTS_PER_SET );
 
 if( !( flags & MESHSET_TRACK_OWNER ) ) return;
 
 for( int i = 0; i < ENTS_PER_SET; ++i )
 {
 std::vector< EntityHandle > adj;
 rval = mb->get_adjacencies( &ents[i], 1, 4, false, adj );CHECK_ERR( rval );
 CHECK( std::find( adj.begin(), adj.end(), set ) != adj.end() );
 }
}
 
void check_set_meshset()
{
 check_meshset_common( false );
}
 
void check_list_meshset()
{
 check_meshset_common( true );
}
 
void check_big_meshset()
{
 // Mesh should have a single set that contains all the vertices.
 // Find it.
 Range sets;
 ErrorCode rval = mb->get_entities_by_type( 0, MBENTITYSET, sets );CHECK_ERR( rval );
 
 Range verts;
 rval = mb->get_entities_by_type( 0, MBVERTEX, verts );CHECK_ERR( rval );
 
 bool found = false;
 for( Range::iterator it = sets.begin(); it != sets.end(); ++it )
 {
 Range ents;
 rval = mb->get_entities_by_handle( *it, ents );CHECK_ERR( rval );
 if( ents == verts )
 {
 found = true;
 break;
 }
 }
 CHECK( found );
}
 
void check_handle_tag()
{
 Range::iterator it;
 ErrorCode rval;
 
 // first check tag on sets, for which the values should have been
 // updated according to the reordering
 
 Tag set_handles;
 rval = mb->tag_get_handle( SET_HANDLES_NAME, ENTS_PER_SET, MB_TYPE_HANDLE, set_handles );CHECK_ERR( rval );
 
 Range sets;
 rval = mb->get_entities_by_type_and_tag( 0, MBENTITYSET, &set_handles, 0, 1, sets );CHECK_ERR( rval );
 CHECK( !sets.empty() );
 
 for( it = sets.begin(); it != sets.end(); ++it )
 {
 std::vector< EntityHandle > ents;
 rval = mb->get_entities_by_handle( *it, ents );CHECK_ERR( rval );
 
 std::vector< EntityHandle > handles( ENTS_PER_SET );
 rval = mb->tag_get_data( set_handles, &*it, 1, &handles[0] );CHECK_ERR( rval );
 
 unsigned flags;
 rval = mb->get_meshset_options( *it, flags );CHECK_ERR( rval );
 if( !( flags & MESHSET_ORDERED ) ) std::sort( handles.begin(), handles.end() );
 
 CHECK_EQUAL( ents, handles );
 }
 
 // Now check handle tag on quads. This tag need to both be re-ordered
 // and have the contained handles updated.
 
 Tag conn_handles;
 rval = mb->tag_get_handle( CONN_NAME, 4, MB_TYPE_HANDLE, conn_handles );CHECK_ERR( rval );
 
 std::vector< EntityHandle > quads;
 rval = mb->get_entities_by_type( 0, MBQUAD, quads );CHECK_ERR( rval );
 
 std::vector< EntityHandle > conn;
 rval = mb->get_connectivity( &quads[0], quads.size(), conn, true );CHECK_ERR( rval );
 
 std::vector< EntityHandle > tagvals( 4 * quads.size() );
 rval = mb->tag_get_data( conn_handles, &quads[0], quads.size(), &tagvals[0] );CHECK_ERR( rval );
 
 CHECK_EQUAL( conn, tagvals );
}
 
void check_varlen_tag()
{
 ErrorCode rval;
 
 Tag gid;
 rval = mb->tag_get_handle( GLOBAL_ID_NAME, 1, MB_TYPE_INTEGER, gid );CHECK_ERR( rval );
 
 Tag var_data;
 rval = mb->tag_get_handle( VAR_INTS_NAME, 0, MB_TYPE_INTEGER, var_data );CHECK_ERR( rval );
 
 Range verts;
 rval = mb->get_entities_by_type( 0, MBVERTEX, verts );CHECK_ERR( rval );
 
 std::vector< int > gids( verts.size() );
 rval = mb->tag_get_data( gid, verts, &gids[0] );CHECK_ERR( rval );
 
 std::vector< const void* > ptrs( verts.size() );
 std::vector< int > sizes( verts.size() );
 rval = mb->tag_get_by_ptr( var_data, verts, &ptrs[0], &sizes[0] );CHECK_ERR( rval );
 
 for( size_t i = 0; i < gids.size(); ++i )
 {
 std::vector< int > exp;
 tag_vals_from_gid( gids[i], exp );
 CHECK_ARRAYS_EQUAL( &exp[0], exp.size(), (const int*)ptrs[i], sizes[i] );
 }
}
 
void check_bit_tag()
{
 ErrorCode rval;
 
 Tag gid;
 rval = mb->tag_get_handle( GLOBAL_ID_NAME, 1, MB_TYPE_INTEGER, gid );CHECK_ERR( rval );
 
 Tag bit_data;
 rval = mb->tag_get_handle( BIT_NAME, BITS_PER_TAG, MB_TYPE_BIT, bit_data );CHECK_ERR( rval );
 
 Range verts;
 rval = mb->get_entities_by_type( 0, MBVERTEX, verts );CHECK_ERR( rval );
 
 std::vector< int > gids( verts.size() );
 rval = mb->tag_get_data( gid, verts, &gids[0] );CHECK_ERR( rval );
 
 std::vector< unsigned char > exp( gids.size() ), act( gids.size() );
 for( size_t i = 0; i < exp.size(); ++i )
 exp[i] = bits_from_gid( gids[i] );
 
 rval = mb->tag_get_data( bit_data, verts, &act[0] );CHECK_ERR( rval );
 
 CHECK_EQUAL( exp, act );
}