void test_step_iter()
{
iMesh_Instance mesh;
int err;
iMesh_newMesh("", &mesh, &err, 0);
CHECK_EQUAL( iBase_SUCCESS, err );
iBase_EntitySetHandle root_set;
iMesh_getRootSet(mesh, &root_set, &err);
CHECK_EQUAL( iBase_SUCCESS, err );
iBase_EntityHandle *verts = 0;
int verts_alloc = 0, verts_size = 0;
double coords[] = { 0,0,0, 1,1,1, 2,2,2, 3,3,3, 4,4,4, 5,5,5 };
iMesh_createVtxArr(mesh,6,iBase_INTERLEAVED,coords,18,&verts,&verts_alloc,
&verts_size,&err);
CHECK_EQUAL( iBase_SUCCESS, err );
/* make a non-array iterator and test stepping over it */
iBase_EntityIterator iter;
int atend;
iMesh_initEntIter( mesh, root_set, iBase_ALL_TYPES, iMesh_ALL_TOPOLOGIES,
0, &iter, &err );
CHECK_EQUAL( iBase_SUCCESS, err );
iMesh_stepEntIter(mesh, iter, 2, &atend, &err);
CHECK_EQUAL( iBase_SUCCESS, err );
/* shouldn't be at end yet */
if (atend) CHECK_EQUAL( iBase_SUCCESS, iBase_FAILURE );
iMesh_stepEntIter(mesh, iter, 4, &atend, &err);
CHECK_EQUAL( iBase_SUCCESS, err );
/* should be at end now */
if (!atend) CHECK_EQUAL( iBase_SUCCESS, iBase_FAILURE );
iMesh_endEntIter(mesh, iter, &err);
CHECK_EQUAL( iBase_SUCCESS, err );
/* make an array iterator and test stepping over it */
iBase_EntityArrIterator arr_iter;
iMesh_initEntArrIter( mesh, root_set, iBase_ALL_TYPES, iMesh_ALL_TOPOLOGIES,
6, 0, &arr_iter, &err );
CHECK_EQUAL( iBase_SUCCESS, err );
iMesh_stepEntArrIter(mesh, arr_iter, 2, &atend, &err);
CHECK_EQUAL( iBase_SUCCESS, err );
/* shouldn't be at end yet */
if (atend) CHECK_EQUAL( iBase_SUCCESS, iBase_FAILURE );
iMesh_stepEntArrIter(mesh, arr_iter, 4, &atend, &err);
CHECK_EQUAL( iBase_SUCCESS, err );
/* should be at end now */
if (!atend) CHECK_EQUAL( iBase_SUCCESS, iBase_FAILURE );
iMesh_endEntArrIter(mesh, arr_iter, &err);
CHECK_EQUAL( iBase_SUCCESS, err );
iMesh_dtor(mesh,&err);
CHECK_EQUAL( iBase_SUCCESS, err );
free(verts);
}
void test_tags_retrieval()
{
iMesh_Instance mesh;
int err;
iMesh_newMesh("", &mesh, &err, 0);
CHECK_EQUAL( iBase_SUCCESS, err );
iBase_EntitySetHandle root_set;
iMesh_getRootSet(mesh, &root_set, &err);
CHECK_EQUAL( iBase_SUCCESS, err );
// open a file with var len tags (sense tags)
// they should be filtered out
std::string filename = STRINGIFY(MESHDIR) "/PB.h5m";
iMesh_load(mesh, root_set, filename.c_str(), NULL, &err, filename.length(), 0);
CHECK_EQUAL( iBase_SUCCESS, err );
iBase_EntitySetHandle* contained_set_handles = NULL;
int contained_set_handles_allocated = 0;
int contained_set_handles_size;
// get all entity sets
iMesh_getEntSets(mesh, root_set, 1,
&contained_set_handles,
&contained_set_handles_allocated,
&contained_set_handles_size,
&err );
CHECK_EQUAL( iBase_SUCCESS, err );
// get tags for all sets
for (int i=0; i< contained_set_handles_size; i++)
{
iBase_TagHandle* tag_handles = NULL;
int tag_handles_allocated=0;
int tag_handles_size;
iMesh_getAllEntSetTags (mesh,
contained_set_handles[i],
&tag_handles,
&tag_handles_allocated,
&tag_handles_size, &err);
CHECK_EQUAL( iBase_SUCCESS, err );
for (int j=0; j<tag_handles_size; j++)
{
int tagSize;
iMesh_getTagSizeValues(mesh, tag_handles[j], &tagSize, &err);
CHECK_EQUAL( iBase_SUCCESS, err );
}
free(tag_handles);
}
free (contained_set_handles);
// Delete the iMesh instance
iMesh_dtor(mesh, &err);
CHECK_EQUAL(iBase_SUCCESS, err);
return;
}
inline
iMesh::iMesh( const char* options )
{
int err, len = options ? strlen(options) : 0;
iMesh_newMesh( options, &mInstance, &err, len );
if (iBase_SUCCESS != err) {
mInstance = 0;
iMeshInstanceOwner = false;
}
else {
iMeshInstanceOwner = true;
cacheAdjTable();
}
}
iMesh_Instance create_mesh()
{
static iMesh_Instance instance = 0;
if (instance)
return instance;
int err;
iMesh_Instance tmp;
iMesh_newMesh( 0, &tmp, &err, 0 );
CHECK_EQUAL( iBase_SUCCESS, err );
for (int i = 0; i < INTERVALS+1; ++i)
for (int j = 0; j < INTERVALS+1; ++j)
for (int k = 0; k < INTERVALS+1; ++k) {
iMesh_createVtx( tmp, i, j, k, &VERTS[i][j][k], &err );
CHECK_EQUAL( iBase_SUCCESS, err );
}
int status;
iBase_EntityHandle conn[8];
for (int i = 0; i < INTERVALS; ++i)
for (int j = 0; j < INTERVALS; ++j)
for (int k = 0; k < INTERVALS; ++k) {
HEX_VERTS(i,j,k,conn);
iMesh_createEnt( tmp, iMesh_HEXAHEDRON, conn, 8, &HEXES[i][j][k], &status, &err );
CHECK_EQUAL( iBase_SUCCESS, err );
CHECK_EQUAL( iBase_NEW, status );
}
for (int f = 0; f < 6; ++f)
for (int i = 0; i < INTERVALS; ++i)
for (int j = 0; j < INTERVALS; ++j) {
QUAD_VERTS(f,i,j,conn);
iMesh_createEnt( tmp, iMesh_QUADRILATERAL, conn, 4, &FACES[f][i][j], &status, &err );
CHECK_EQUAL( iBase_SUCCESS, err );
}
return (instance = tmp);
}
// This consistent interpolation example loads a linear quad mesh
// tagged with a scalar field and interpolates it along with the gradient
// pullback onto a delaunay tri mesh mesh. (Function domain = func_dmn,
// function range = func_rng )
int main(int argc, char* argv[])
{
// Setup communication.
Teuchos::GlobalMPISession mpiSession(&argc,&argv);
Teuchos::RCP<const Teuchos::Comm<int> > comm =
Teuchos::DefaultComm<int>::getComm();
if ( getDefaultComm<int>()->getRank() == 0 ) // Force scalar execution.
{
int error;
// The tensor template can be shared by both the range and
// domain value.
Teuchos::RCP<FOOD::TensorTemplate> tensor_template = Teuchos::rcp(
new FOOD::TensorTemplate(0, 1, FOOD::FOOD_REAL, Teuchos::null) );
// Need another one for the gradient. Here the gradient is a 3-vector.
Teuchos::RCP<FOOD::TensorTemplate> grad_tensor_template = Teuchos::rcp(
new FOOD::TensorTemplate(1, 3, FOOD::FOOD_REAL, Teuchos::null) );
// Set up the func_dmn mesh.
iMesh_Instance func_dmn_mesh;
iMesh_newMesh("", &func_dmn_mesh, &error, 0);
assert( iBase_SUCCESS == error );
iBase_EntitySetHandle func_dmn_root_set;
iMesh_getRootSet( func_dmn_mesh, &func_dmn_root_set, &error );
assert( iBase_SUCCESS == error );
std::string func_dmn_mesh_filename = "tagged_quad_flat_surf.vtk";
iMesh_load( func_dmn_mesh,
func_dmn_root_set,
&func_dmn_mesh_filename[0],
"",
&error,
(int) func_dmn_mesh_filename.size(),
0 );
assert( iBase_SUCCESS == error );
// Set up the func_dmn mesh field.
Teuchos::RCP<FOOD::Domain> func_dmn_domain = Teuchos::rcp(
new FOOD::Domain(func_dmn_mesh, func_dmn_root_set, FOOD::FOOD_MBCN) );
Teuchos::RCP< FOOD::DFuncKernel<double> > func_dmn_dfunckernel =
Teuchos::rcp( new FOOD::DFuncKernel<double>( iBase_FACE,
iMesh_QUADRILATERAL,
iBase_VERTEX,
iMesh_POINT,
FOOD::FOOD_CARTESIAN,
FOOD::FOOD_FEM,
FOOD::FOOD_HGRAD,
FOOD::FOOD_SHARDSCN,
2 ) );
Teuchos::RCP< FOOD::TensorField<double> > func_dmn_field = Teuchos::rcp(
new FOOD::TensorField<double>( getDefaultComm<int>(),
func_dmn_domain,
func_dmn_dfunckernel,
FOOD::FOOD_CARTESIAN,
tensor_template,
Teuchos::null,
"FUNC_DMN_FIELD" ) );
std::string func_dmn_tag_name = "domain";
iBase_TagHandle func_dmn_tag;
iMesh_getTagHandle( func_dmn_domain->getMesh(),
&func_dmn_tag_name[0],
&func_dmn_tag,
&error,
(int) func_dmn_tag_name.size() );
assert( iBase_SUCCESS == error );
func_dmn_field->attachToTagData( func_dmn_tag, error );
assert( iBase_SUCCESS == error );
// Set up the func_rng mesh.
iMesh_Instance func_rng_mesh;
iMesh_newMesh("", &func_rng_mesh, &error, 0);
assert( iBase_SUCCESS == error );
iBase_EntitySetHandle func_rng_root_set;
iMesh_getRootSet( func_rng_mesh, &func_rng_root_set, &error );
assert( iBase_SUCCESS == error );
std::string func_rng_mesh_filename = "tagged_delaunay_flat_surf.vtk";
iMesh_load( func_rng_mesh,
func_rng_root_set,
&func_rng_mesh_filename[0],
"",
&error,
(int) func_rng_mesh_filename.size(),
0 );
assert( iBase_SUCCESS == error );
// Set up the func_rng mesh field for function values.
Teuchos::RCP<FOOD::Domain> func_rng_domain = Teuchos::rcp(
new FOOD::Domain(func_rng_mesh, func_rng_root_set, FOOD::FOOD_MBCN) );
Teuchos::RCP< FOOD::DFuncKernel<double> > func_rng_dfunckernel =
Teuchos::rcp( new FOOD::DFuncKernel<double>( iBase_FACE,
iMesh_TRIANGLE,
iBase_VERTEX,
iMesh_POINT,
FOOD::FOOD_CARTESIAN,
FOOD::FOOD_FEM,
FOOD::FOOD_HGRAD,
FOOD::FOOD_SHARDSCN,
1 ) );
Teuchos::RCP< FOOD::TensorField<double> > func_rng_field = Teuchos::rcp(
new FOOD::TensorField<double>( getDefaultComm<int>(),
func_rng_domain,
func_rng_dfunckernel,
FOOD::FOOD_CARTESIAN,
tensor_template,
Teuchos::null,
"FUNC_RNG_FIELD" ) );
std::string func_rng_tag_name = "range";
iBase_TagHandle func_rng_tag;
iMesh_getTagHandle( func_rng_domain->getMesh(),
&func_rng_tag_name[0],
&func_rng_tag,
&error,
(int) func_rng_tag_name.size() );
assert( iBase_SUCCESS == error );
func_rng_field->attachToTagData( func_rng_tag, error );
assert( iBase_SUCCESS == error );
// Setup the gradient field.
Teuchos::RCP< FOOD::TensorField<double> > func_rng_grad_field = Teuchos::rcp(
new FOOD::TensorField<double>( getDefaultComm<int>(),
func_rng_domain,
func_rng_dfunckernel,
FOOD::FOOD_CARTESIAN,
grad_tensor_template,
Teuchos::null,
"FUNC_RNG_GRAD_FIELD" ) );
std::string func_rng_grad_tag_name = "grad_range";
iBase_TagHandle func_rng_grad_tag;
iMesh_getTagHandle( func_rng_domain->getMesh(),
&func_rng_grad_tag_name[0],
&func_rng_grad_tag,
&error,
(int) func_rng_grad_tag_name.size() );
assert( iBase_SUCCESS == error );
func_rng_grad_field->attachToTagData( func_rng_grad_tag, error );
assert( iBase_SUCCESS == error );
// Do interpolation.
FOOD::ConsistentScheme<double> fem_interp_val( func_dmn_field,
func_rng_field );
fem_interp_val.setup();
fem_interp_val.transferValueDF();
FOOD::ConsistentScheme<double> fem_interp_grad( func_dmn_field,
func_rng_grad_field );
fem_interp_grad.setup();
fem_interp_grad.transferGradDF();
// Write the interpolated mesh to file.
std::string interp_file = "flat_surf_output.vtk";
iMesh_save( func_rng_domain->getMesh(),
func_rng_domain->getMeshSet(),
&interp_file[0],
"",
&error,
(int) interp_file.size(),
0 );
assert( iBase_SUCCESS == error );
} // end rank 0
return 0;
}
void test_tag_iterate()
{
iMesh_Instance mesh;
int err;
iMesh_newMesh("", &mesh, &err, 0);
CHECK_EQUAL( iBase_SUCCESS, err );
iBase_EntitySetHandle root_set, entset;
iMesh_getRootSet(mesh, &root_set, &err);
CHECK_EQUAL( iBase_SUCCESS, err );
iBase_EntityHandle *verts = 0;
int verts_alloc = 0, verts_size = 0;
double coords[] = { 0,0,0, 1,1,1, 2,2,2, 3,3,3, 4,4,4, 5,5,5 };
iMesh_createVtxArr(mesh,6,iBase_INTERLEAVED,coords,18,&verts,&verts_alloc,
&verts_size,&err);
CHECK_EQUAL( iBase_SUCCESS, err );
/* create an entity set with two subranges */
iMesh_createEntSet( mesh, 0, &entset, &err );
CHECK_EQUAL( iBase_SUCCESS, err );
iMesh_addEntArrToSet( mesh, verts, 2, entset, &err );
CHECK_EQUAL( iBase_SUCCESS, err );
iMesh_addEntArrToSet( mesh, &verts[3], 3, entset, &err );
CHECK_EQUAL( iBase_SUCCESS, err );
/* create a dbl tag and set vertices */
iBase_TagHandle tagh;
iMesh_createTagWithOptions(mesh, "dum", "moab:TAG_STORAGE_TYPE=DENSE", 1, iBase_DOUBLE, &tagh, &err, 3, 27);
CHECK_EQUAL( iBase_SUCCESS, err );
iMesh_setDblArrData(mesh, verts, 6, tagh, coords+3, 6, &err);
CHECK_EQUAL( iBase_SUCCESS, err );
/* get an iterator over the root set, and check tag iterator for that */
iBase_EntityArrIterator iter;
int count, atend;
double *data;
iMesh_initEntArrIter( mesh, root_set, iBase_ALL_TYPES, iMesh_ALL_TOPOLOGIES,
6, 0, &iter, &err );
CHECK_EQUAL( iBase_SUCCESS, err );
iMesh_tagIterate(mesh, tagh, iter, &data, &count, &err);
CHECK_EQUAL( iBase_SUCCESS, err );
if (count != 6) CHECK_EQUAL( iBase_SUCCESS, iBase_FAILURE );
for (int i = 0; i < 6; i++) {
if (data[i] != coords[i+3]) CHECK_EQUAL( iBase_SUCCESS, iBase_FAILURE );
}
iMesh_endEntArrIter(mesh, iter, &err);
CHECK_EQUAL( iBase_SUCCESS, err );
/* get an iterator over the set with two subranges, and check tag iterator for that */
iMesh_initEntArrIter( mesh, entset, iBase_ALL_TYPES, iMesh_ALL_TOPOLOGIES, 6,
0, &iter, &err );
CHECK_EQUAL( iBase_SUCCESS, err );
iMesh_tagIterate(mesh, tagh, iter, &data, &count, &err);
CHECK_EQUAL( iBase_SUCCESS, err );
if (count != 2 || data[0] != coords[3] || data[1] != coords[4]) CHECK_EQUAL( iBase_SUCCESS, iBase_FAILURE );
iMesh_stepEntArrIter(mesh, iter, 2, &atend, &err);
CHECK_EQUAL( iBase_SUCCESS, err );
/* shouldn't be at end yet */
if (atend) CHECK_EQUAL( iBase_SUCCESS, iBase_FAILURE );
iMesh_tagIterate(mesh, tagh, iter, &data, &count, &err);
CHECK_EQUAL( iBase_SUCCESS, err );
if (count != 3 || data[0] != coords[6] || data[1] != coords[7]) CHECK_EQUAL( iBase_SUCCESS, iBase_FAILURE );
iMesh_stepEntArrIter(mesh, iter, 3, &atend, &err);
CHECK_EQUAL( iBase_SUCCESS, err );
/* should be at end now */
if (!atend) CHECK_EQUAL( iBase_SUCCESS, iBase_FAILURE );
iMesh_endEntArrIter(mesh, iter, &err);
CHECK_EQUAL( iBase_SUCCESS, err );
iMesh_dtor(mesh,&err);
CHECK_EQUAL( iBase_SUCCESS, err );
free(verts);
}
void create_hex_mesh(iMesh_Instance &mesh)
{
// Create the mesh instance.
int error;
iMesh_newMesh("", &mesh, &error, 0);
assert( iBase_SUCCESS == error );
// Create a tag for the vertex elements.
iBase_TagHandle vertex_tag;
std::string vertex_tag_name = "vertex_tag";
iMesh_createTag( mesh,
&vertex_tag_name[0],
1,
iBase_DOUBLE,
&vertex_tag,
&error,
(int) vertex_tag_name.size());
assert( iBase_SUCCESS == error );
// Generate vertices.
int num_i = 11;
int num_j = 11;
int num_k = 11;
int dx = 1.0;
int dy = 1.0;
int dz = 1.0;
int idx = 0;
std::vector<double> coords(3*num_i*num_j*num_k, 0.0);
for ( int k = 0; k < num_k; ++k )
{
for ( int j = 0; j < num_j; ++j )
{
for ( int i = 0; i < num_i; ++i )
{
idx = i + num_i*j + num_i*num_j*k;
coords[3*idx] = i*dx;
coords[3*idx + 1] = j*dy;
coords[3*idx + 2] = k*dz;
}
}
}
iBase_EntityHandle *vertices;
int vertices_allocated = 0;
int vertices_size = 0;
iMesh_createVtxArr( mesh,
(int) coords.size() / 3,
iBase_INTERLEAVED,
&coords[0],
(int) coords.size(),
&vertices,
&vertices_allocated,
&vertices_size,
&error);
assert( iBase_SUCCESS == error );
assert( vertices_allocated == num_i*num_j*num_k );
assert( vertices_size == num_i*num_j*num_k );
// Tag the vertices.
std::vector<double> vertex_tag_data( (int) coords.size() / 3, 0.0 );
double data = 0.0;
std::vector<double>::iterator vertex_data_iterator;
for (vertex_data_iterator = vertex_tag_data.begin();
vertex_data_iterator != vertex_tag_data.end();
++vertex_data_iterator )
{
*vertex_data_iterator = data;
data += 1.0;
}
iMesh_setDblArrData( mesh,
vertices,
vertices_size,
vertex_tag,
&vertex_tag_data[0],
(int) vertex_tag_data.size(),
&error);
assert( iBase_SUCCESS == error );
// Create a vertex set and add the vertex array.
iBase_EntitySetHandle vertex_set;
iMesh_createEntSet(mesh, 1, &vertex_set, &error);
assert( iBase_SUCCESS == error );
iMesh_addEntArrToSet(mesh, vertices, vertices_size, vertex_set, &error);
assert( iBase_SUCCESS == error );
// Create a hex set.
iBase_EntitySetHandle hex_set;
iMesh_createEntSet(mesh, 1, &hex_set, &error);
assert( iBase_SUCCESS == error );
// Create a tag for the hex elements.
iBase_TagHandle hex_tag;
std::string hex_tag_name = "hex_tag";
iMesh_createTag( mesh,
&hex_tag_name[0],
1,
iBase_DOUBLE,
&hex_tag,
&error,
(int) hex_tag_name.size());
assert( iBase_SUCCESS == error );
// Generate hexahedrons from vertices, tag them, and add them to the hex
// set.
iBase_EntityHandle connectivity[8];
int hex_creation_status = 0;
double hex_data = 0.0;
for (int k = 0; k < num_k - 1; ++k)
{
for (int j = 0; j < num_j - 1; ++j)
{
for (int i = 0; i < num_i - 1; ++i)
{
idx = i + num_i*j + num_i*num_j*k;
connectivity[0] = vertices[ idx ];
connectivity[1] = vertices[ idx + 1 ];
connectivity[2] = vertices[ idx + 1 + num_i ];
connectivity[3] = vertices[ idx + num_i ];
connectivity[4] = vertices[ idx + num_i*num_j ];
connectivity[5] = vertices[ idx + 1 + num_i*num_j ];
connectivity[6] = vertices[ idx + 1 + num_i + num_i*num_j ];
connectivity[7] = vertices[ idx + num_i + num_i*num_j ];
iBase_EntityHandle hexahedron;
iMesh_createEnt( mesh,
iMesh_HEXAHEDRON,
connectivity,
8,
&hexahedron,
&hex_creation_status,
&error);
assert( iBase_SUCCESS == error );
assert( iBase_NEW == hex_creation_status );
iMesh_setDblData( mesh,
hexahedron,
hex_tag,
hex_data,
&error);
assert( iBase_SUCCESS == error );
hex_data += 1.0;
iMesh_addEntToSet(mesh,
hexahedron,
hex_set,
&error);
assert( iBase_SUCCESS == error );
}
}
}
}
void create_tet_mesh( iMesh_Instance &mesh )
{
// Setup iMesh instance
int error;
iMesh_newMesh("", &mesh, &error, 0);
assert( iBase_SUCCESS == error );
// Create a tag for the vertex elements.
iBase_TagHandle vertex_tag;
std::string vertex_tag_name = "vertex_tag";
iMesh_createTag( mesh,
&vertex_tag_name[0],
1,
iBase_DOUBLE,
&vertex_tag,
&error,
(int) vertex_tag_name.size());
assert( iBase_SUCCESS == error );
// Generate vertices.
int num_i = 11;
int num_j = 11;
int num_k = 11;
int dx = 1.0;
int dy = 1.0;
int dz = 1.0;
int idx = 0;
std::vector<double> coords(3*num_i*num_j*num_k, 0.0);
for ( int k = 0; k < num_k; ++k )
{
for ( int j = 0; j < num_j; ++j )
{
for ( int i = 0; i < num_i; ++i )
{
idx = i + num_i*j + num_i*num_j*k;
coords[3*idx] = i*dx;
coords[3*idx + 1] = j*dy;
coords[3*idx + 2] = k*dz;
}
}
}
iBase_EntityHandle *vertices;
int vertices_allocated = 0;
int vertices_size = 0;
iMesh_createVtxArr( mesh,
(int) coords.size() / 3,
iBase_INTERLEAVED,
&coords[0],
(int) coords.size(),
&vertices,
&vertices_allocated,
&vertices_size,
&error);
assert( iBase_SUCCESS == error );
assert( vertices_allocated == num_i*num_j*num_k );
assert( vertices_size == num_i*num_j*num_k );
// Tag the vertices.
std::vector<double> vertex_tag_data( (int) coords.size() / 3, 0.0 );
double data = 0.0;
std::vector<double>::iterator vertex_data_iterator;
for (vertex_data_iterator = vertex_tag_data.begin();
vertex_data_iterator != vertex_tag_data.end();
++vertex_data_iterator )
{
*vertex_data_iterator = data;
data += 1.0;
}
iMesh_setDblArrData( mesh,
vertices,
vertices_size,
vertex_tag,
&vertex_tag_data[0],
(int) vertex_tag_data.size(),
&error);
assert( iBase_SUCCESS == error );
// Create a vertex set and add the vertex array.
iBase_EntitySetHandle vertex_set;
iMesh_createEntSet(mesh, 1, &vertex_set, &error);
assert( iBase_SUCCESS == error );
iMesh_addEntArrToSet(mesh, vertices, vertices_size, vertex_set, &error);
assert( iBase_SUCCESS == error );
// Create a tet set.
iBase_EntitySetHandle tet_set;
iMesh_createEntSet(mesh, 1, &tet_set, &error);
assert( iBase_SUCCESS == error );
// Create a tag for the tet elements.
iBase_TagHandle tet_tag;
std::string tet_tag_name = "tet_tag";
iMesh_createTag(mesh,
&tet_tag_name[0],
3,
iBase_DOUBLE,
&tet_tag,
&error,
(int) tet_tag_name.size());
assert( iBase_SUCCESS == error );
// Generate tetrahedrons from vertices, tag them, and add them to the tet
// set. Decompose each cube into 5 tetrahedrons.
iBase_EntityHandle connectivity[4];
int tet_creation_status = 0;
double tet_data = 0.0;
double data_arr[3] = {tet_data, tet_data, tet_data};
int v0 = 0;
int v1 = 0;
int v2 = 0;
int v3 = 0;
int v4 = 0;
int v5 = 0;
int v6 = 0;
int v7 = 0;
for (int k = 0; k < num_k - 1; ++k)
{
for (int j = 0; j < num_j - 1; ++j)
{
for (int i = 0; i < num_i - 1; ++i)
{
// Starting corner vertex index.
idx = i + num_i*j + num_i*num_j*k;
v0 = idx;
v1 = idx + 1;
v2 = idx + 1 + num_i;
v3 = idx + num_i;
v4 = idx + num_i*num_j;
v5 = idx + 1 + num_i*num_j;
v6 = idx + 1 + num_i + num_i*num_j;
v7 = idx + num_i + num_i*num_j;
// Tetrahedron 1.
connectivity[0] = vertices[ v0 ];
connectivity[1] = vertices[ v1 ];
connectivity[2] = vertices[ v3 ];
connectivity[3] = vertices[ v4 ];
iBase_EntityHandle tetrahedron_1;
iMesh_createEnt( mesh,
iMesh_TETRAHEDRON,
connectivity,
4,
&tetrahedron_1,
&tet_creation_status,
&error);
assert( iBase_SUCCESS == error );
assert( iBase_NEW == tet_creation_status );
data_arr[0] = tet_data;
data_arr[1] = tet_data;
data_arr[2] = tet_data;
iMesh_setDblArrData( mesh,
&tetrahedron_1,
1,
tet_tag,
data_arr,
3,
&error);
assert( iBase_SUCCESS == error );
tet_data += 1.0;
iMesh_addEntToSet( mesh,
tetrahedron_1,
tet_set,
&error);
assert( iBase_SUCCESS == error );
// Tetrahedron 2.
connectivity[0] = vertices[ v1 ];
connectivity[1] = vertices[ v2 ];
connectivity[2] = vertices[ v3 ];
connectivity[3] = vertices[ v6 ];
iBase_EntityHandle tetrahedron_2;
iMesh_createEnt(mesh,
iMesh_TETRAHEDRON,
connectivity,
4,
&tetrahedron_2,
&tet_creation_status,
&error);
assert( iBase_SUCCESS == error );
assert( iBase_NEW == tet_creation_status );
data_arr[0] = tet_data;
data_arr[1] = tet_data;
data_arr[2] = tet_data;
iMesh_setDblArrData( mesh,
&tetrahedron_2,
1,
tet_tag,
data_arr,
3,
&error);
assert( iBase_SUCCESS == error );
tet_data += 1.0;
iMesh_addEntToSet( mesh,
tetrahedron_2,
tet_set,
&error);
assert( iBase_SUCCESS == error );
// Tetrahedron 3.
connectivity[0] = vertices[ v6 ];
connectivity[1] = vertices[ v5 ];
connectivity[2] = vertices[ v4 ];
connectivity[3] = vertices[ v1 ];
iBase_EntityHandle tetrahedron_3;
iMesh_createEnt( mesh,
iMesh_TETRAHEDRON,
connectivity,
4,
&tetrahedron_3,
&tet_creation_status,
&error);
assert( iBase_SUCCESS == error );
assert( iBase_NEW == tet_creation_status );
data_arr[0] = tet_data;
data_arr[1] = tet_data;
data_arr[2] = tet_data;
iMesh_setDblArrData( mesh,
&tetrahedron_3,
1,
tet_tag,
data_arr,
3,
&error);
assert( iBase_SUCCESS == error );
tet_data += 1.0;
iMesh_addEntToSet(mesh,
tetrahedron_3,
tet_set,
&error);
assert( iBase_SUCCESS == error );
// Tetrahedron 4.
connectivity[0] = vertices[ v4 ];
connectivity[1] = vertices[ v7 ];
connectivity[2] = vertices[ v6 ];
connectivity[3] = vertices[ v3 ];
iBase_EntityHandle tetrahedron_4;
iMesh_createEnt( mesh,
iMesh_TETRAHEDRON,
connectivity,
4,
&tetrahedron_4,
&tet_creation_status,
&error);
assert( iBase_SUCCESS == error );
assert( iBase_NEW == tet_creation_status );
data_arr[0] = tet_data;
data_arr[1] = tet_data;
data_arr[2] = tet_data;
iMesh_setDblArrData( mesh,
&tetrahedron_4,
1,
tet_tag,
data_arr,
3,
&error);
assert( iBase_SUCCESS == error );
tet_data += 1.0;
iMesh_addEntToSet( mesh,
tetrahedron_4,
tet_set,
&error);
assert( iBase_SUCCESS == error );
// Tetrahedron 5.
connectivity[0] = vertices[ v3 ];
connectivity[1] = vertices[ v1 ];
connectivity[2] = vertices[ v6 ];
connectivity[3] = vertices[ v4 ];
iBase_EntityHandle tetrahedron_5;
iMesh_createEnt( mesh,
iMesh_TETRAHEDRON,
connectivity,
4,
&tetrahedron_5,
&tet_creation_status,
&error);
assert( iBase_SUCCESS == error );
assert( iBase_NEW == tet_creation_status );
data_arr[0] = tet_data;
data_arr[1] = tet_data;
data_arr[2] = tet_data;
iMesh_setDblArrData( mesh,
&tetrahedron_5,
1,
tet_tag,
data_arr,
3,
&error);
assert( iBase_SUCCESS == error );
tet_data += 1.0;
iMesh_addEntToSet( mesh,
tetrahedron_5,
tet_set,
&error);
assert( iBase_SUCCESS == error );
}
}
}
}
