/*!
* \brief Determine if an entity is inside a bounding box. The entire element
* must be in the box.
*/
bool Octree::isEntInBox( const Box &box,
iBase_EntityHandle entity )
{
int error = 0;
bool return_val = true;
iBase_EntityHandle *element_nodes = 0;
int element_nodes_allocated = 0;
int element_nodes_size = 0;
iMesh_getEntAdj( d_mesh,
entity,
iBase_VERTEX,
&element_nodes,
&element_nodes_allocated,
&element_nodes_size,
&error );
assert( iBase_SUCCESS == error );
int coords_allocated = element_nodes_size*3;
int coords_size = 0;
double *coord_array = 0;
iMesh_getVtxArrCoords( d_mesh,
element_nodes,
element_nodes_size,
iBase_INTERLEAVED,
&coord_array,
&coords_allocated,
&coords_size,
&error );
assert( iBase_SUCCESS == error );
int n = 0;
while ( n < element_nodes_size && return_val )
{
if ( !( coord_array[3*n] >= box[0] &&
coord_array[3*n] <= box[1] &&
coord_array[3*n+1] >= box[2] &&
coord_array[3*n+1] <= box[3] &&
coord_array[3*n+2] >= box[4] &&
coord_array[3*n+2] <= box[5] ) )
{
return_val = false;
}
++n;
}
free( element_nodes );
free( coord_array );
return return_val;
}
static dErr doMaterial(iMesh_Instance mesh,iBase_EntitySetHandle root)
{
static const char matSetName[] = "MAT_SET",matNumName[] = "MAT_NUM";
dMeshTag matSetTag,matNumTag;
dMeshESH mat[2];
dMeshEH *ents;
MeshListEH r=MLZ,v=MLZ;
MeshListInt rvo=MLZ;
MeshListReal x=MLZ;
dReal fx,center[3],*matnum;
dInt nents;
dErr err;
dFunctionBegin;
iMesh_createTag(mesh,matSetName,1,iBase_INTEGER,&matSetTag,&err,sizeof(matSetName));dICHK(mesh,err);
iMesh_createTag(mesh,matNumName,1,iBase_DOUBLE,&matNumTag,&err,sizeof(matNumName));dICHK(mesh,err);
iMesh_getEntities(mesh,root,iBase_REGION,iMesh_ALL_TOPOLOGIES,MLREF(r),&err);dICHK(mesh,err);
iMesh_getEntArrAdj(mesh,r.v,r.s,iBase_VERTEX,MLREF(v),MLREF(rvo),&err);dICHK(mesh,err);
iMesh_getVtxArrCoords(mesh,v.v,v.s,iBase_INTERLEAVED,MLREF(x),&err);dICHK(mesh,err);
err = dMalloc(r.s*sizeof(ents[0]),&ents);dCHK(err);
err = dMalloc(r.s*sizeof(matnum[0]),&matnum);dCHK(err);
for (dInt i=0; i<2; i++) {
iMesh_createEntSet(mesh,0,&mat[i],&err);dICHK(mesh,err);
iMesh_setEntSetData(mesh,mat[i],matSetTag,(char*)&i,sizeof(i),&err);dICHK(mesh,err);
nents = 0;
for (dInt j=0; j<r.s; j++) {
dGeomVecMeanI(8,x.v+3*rvo.v[j],center);
fx = sqrt(dGeomDotProd(center,center)); /* material 0 if inside the unit ball, else material 1 */
if (i == (fx < 1.0) ? 0 : 1) {
ents[nents] = r.v[j];
matnum[nents] = 1.0 * i;
nents++;
}
}
iMesh_addEntArrToSet(mesh,ents,nents,mat[i],&err);dICHK(mesh,err);
iMesh_setArrData(mesh,ents,nents,matNumTag,(char*)matnum,nents*(int)sizeof(matnum[0]),&err);dICHK(mesh,err);
}
err = dFree(ents);dCHK(err);
err = dFree(matnum);dCHK(err);
MeshListFree(r); MeshListFree(v); MeshListFree(rvo); MeshListFree(x);
dFunctionReturn(0);
}
void IntrepidKernel<Scalar>::jacobianDet(
Scalar &determinant,
const double param_coords[3],
const iMesh_Instance mesh,
const iBase_EntityHandle physical_cell )
{
int error = 0;
iBase_EntityHandle *element_nodes = 0;
int element_nodes_allocated = 0;
int element_nodes_size = 0;
iMesh_getEntAdj( mesh,
physical_cell,
iBase_VERTEX,
&element_nodes,
&element_nodes_allocated,
&element_nodes_size,
&error );
assert( iBase_SUCCESS == error );
TopologyTools::MBCN2Shards( element_nodes,
element_nodes_size,
this->b_topology );
int coords_allocated = 0;
int coords_size = 0;
double *coord_array = 0;
iMesh_getVtxArrCoords( mesh,
element_nodes,
element_nodes_size,
iBase_INTERLEAVED,
&coord_array,
&coords_allocated,
&coords_size,
&error );
assert( iBase_SUCCESS == error );
Teuchos::Tuple<int,3> cell_node_dimensions;
cell_node_dimensions[0] = 1;
cell_node_dimensions[1] = element_nodes_size;
cell_node_dimensions[2] = 3;
MDArray cell_nodes( Teuchos::Array<int>(cell_node_dimensions),
coord_array );
MDArray reference_coords( 1, 3 );
reference_coords(0,0) = param_coords[0];
reference_coords(0,1) = param_coords[1];
reference_coords(0,2) = param_coords[2];
MDArray jacobian( 1, 1, 3, 3 );
Intrepid::CellTools<double>::setJacobian(
jacobian,
reference_coords,
cell_nodes,
d_intrepid_basis->getBaseCellTopology() );
MDArray jacobian_det( 1, 1 );
Intrepid::CellTools<double>::setJacobianDet( jacobian_det, jacobian );
determinant = jacobian_det(0,0);
free( element_nodes );
free( coord_array );
}
void IntrepidKernel<Scalar>::transformOperator(
Teuchos::ArrayRCP<Scalar> &transformed_values,
const Teuchos::ArrayRCP<Scalar> &values,
const double param_coords[3],
const iMesh_Instance mesh,
const iBase_EntityHandle physical_cell )
{
int error = 0;
iBase_EntityHandle *element_nodes = 0;
int element_nodes_allocated = 0;
int element_nodes_size = 0;
iMesh_getEntAdj( mesh,
physical_cell,
iBase_VERTEX,
&element_nodes,
&element_nodes_allocated,
&element_nodes_size,
&error );
assert( iBase_SUCCESS == error );
TopologyTools::MBCN2Shards( element_nodes,
element_nodes_size,
this->b_topology );
int coords_allocated = 0;
int coords_size = 0;
double *coord_array = 0;
iMesh_getVtxArrCoords( mesh,
element_nodes,
element_nodes_size,
iBase_INTERLEAVED,
&coord_array,
&coords_allocated,
&coords_size,
&error );
assert( iBase_SUCCESS == error );
Teuchos::Tuple<int,3> cell_node_dimensions;
cell_node_dimensions[0] = 1;
cell_node_dimensions[1] = element_nodes_size;
cell_node_dimensions[2] = 3;
MDArray cell_nodes( Teuchos::Array<int>(cell_node_dimensions),
coord_array );
MDArray jacobian( 1, 1, 3, 3 );
MDArray jacobian_det( 1, 1 );
MDArray jacobian_inv( 1, 1, 3, 3 );
MDArray reference_point( 1, 3 );
reference_point(0,0) = param_coords[0];
reference_point(0,1) = param_coords[1];
reference_point(0,2) = param_coords[2];
if ( this->b_function_space_type == FOOD_HGRAD )
{
Intrepid::CellTools<double>::setJacobian(
jacobian,
reference_point,
cell_nodes,
d_intrepid_basis->getBaseCellTopology() );
Intrepid::CellTools<double>::setJacobianInv( jacobian_inv,
jacobian );
MDArray transformed_grad( 1, this->b_cardinality, 1, 3 );
Teuchos::Tuple<int,3> grad_dimensions;
grad_dimensions[0] = this->b_cardinality;
grad_dimensions[1] = 1;
grad_dimensions[2] = 3;
MDArray basis_grad( grad_dimensions, values );
Intrepid::FunctionSpaceTools::HGRADtransformGRAD<double>(
transformed_grad, jacobian_inv, basis_grad );
transformed_values = transformed_grad.getData();
}
else if ( this->b_function_space_type == FOOD_HDIV )
{
}
else if ( this->b_function_space_type == FOOD_HCURL )
{
}
else
{
testPrecondition( this->b_function_space_type == FOOD_HGRAD ||
this->b_function_space_type == FOOD_HDIV ||
this->b_function_space_type == FOOD_HCURL,
"Invalid function space type" );
}
free( coord_array );
free( element_nodes );
}
void IntrepidKernel<Scalar>::transformPoint(
double param_coords[3],
const double physical_coords[3],
const iMesh_Instance mesh,
const iBase_EntityHandle physical_cell )
{
int error = 0;
iBase_EntityHandle *element_nodes = 0;
int element_nodes_allocated = 0;
int element_nodes_size = 0;
iMesh_getEntAdj( mesh,
physical_cell,
iBase_VERTEX,
&element_nodes,
&element_nodes_allocated,
&element_nodes_size,
&error );
assert( iBase_SUCCESS == error );
TopologyTools::MBCN2Shards( element_nodes,
element_nodes_size,
this->b_topology );
int coords_allocated = 0;
int coords_size = 0;
double *coord_array = 0;
iMesh_getVtxArrCoords( mesh,
element_nodes,
element_nodes_size,
iBase_INTERLEAVED,
&coord_array,
&coords_allocated,
&coords_size,
&error );
assert( iBase_SUCCESS == error );
Teuchos::Tuple<int,3> cell_node_dimensions;
cell_node_dimensions[0] = 1;
cell_node_dimensions[1] = element_nodes_size;
cell_node_dimensions[2] = 3;
MDArray cell_nodes( Teuchos::Array<int>(cell_node_dimensions),
coord_array );
MDArray reference_point( 1, 3 );
MDArray coords( 1, 3 );
coords(0,0) = physical_coords[0];
coords(0,1) = physical_coords[1];
coords(0,2) = physical_coords[2];
Intrepid::CellTools<double>::mapToReferenceFrame(
reference_point,
coords,
cell_nodes,
d_intrepid_basis->getBaseCellTopology(),
0 );
param_coords[0] = reference_point(0,0);
param_coords[1] = reference_point(0,1);
param_coords[2] = reference_point(0,2);
free( element_nodes );
free( coord_array );
}
/*!
* \brief Get the bounding box of a set of entities.
*/
void Octree::getEntSetBox( iBase_EntitySetHandle entity_set,
Box &bounding_box )
{
int error = 0;
int num_set_vertices = 0;
iMesh_getNumOfTopo( d_mesh,
entity_set,
iMesh_POINT,
&num_set_vertices,
&error );
assert( iBase_SUCCESS == error );
iBase_EntityHandle *set_vertices = 0;
int set_vertices_allocated = 0;
int set_vertices_size = 0;
iMesh_getEntities( d_mesh,
entity_set,
iBase_VERTEX,
iMesh_POINT,
&set_vertices,
&set_vertices_allocated,
&set_vertices_size,
&error );
assert( iBase_SUCCESS == error );
int set_coords_allocated = 3*set_vertices_size;
int set_coords_size = 0;
double *coords = 0;
iMesh_getVtxArrCoords( d_mesh,
set_vertices,
set_vertices_size,
iBase_BLOCKED,
&coords,
&set_coords_allocated,
&set_coords_size,
&error );
assert( iBase_SUCCESS == error );
Teuchos::ArrayView<double> set_coords( coords, set_coords_size );
Teuchos::ArrayView<double>::const_iterator set_x_it_begin
= set_coords.begin();
Teuchos::ArrayView<double>::const_iterator set_x_it_end
= set_x_it_begin + set_vertices_size;
Teuchos::ArrayView<double>::const_iterator set_y_it_begin
= set_x_it_end;
Teuchos::ArrayView<double>::const_iterator set_y_it_end
= set_y_it_begin + set_vertices_size;
Teuchos::ArrayView<double>::const_iterator set_z_it_begin
= set_y_it_end;
Teuchos::ArrayView<double>::const_iterator set_z_it_end
= set_z_it_begin + set_vertices_size;
bounding_box[0] = *(std::min_element( set_x_it_begin, set_x_it_end ));
bounding_box[1] = *(std::max_element( set_x_it_begin, set_x_it_end ));
bounding_box[2] = *(std::min_element( set_y_it_begin, set_y_it_end ));
bounding_box[3] = *(std::max_element( set_y_it_begin, set_y_it_end ));
bounding_box[4] = *(std::min_element( set_z_it_begin, set_z_it_end ));
bounding_box[5] = *(std::max_element( set_z_it_begin, set_z_it_end ));
free( set_vertices );
free( coords );
}
int ProjectShell::getMeshData()
{
// get original coordinates of mesh
iBase_EntityHandle *verts = NULL;
int verts_alloc = 0;
int vert_coords_alloc = 0;
int vertex_coord_size;
/* check storage order */
int result;
int this_order;
iMesh_getDfltStorage(m_mesh, &this_order, &result);
if (iBase_SUCCESS != result) {
printf("failed to get preferred storage order in getMesh.\n");
return 1;
}
/* now get the vertex coordinates from a vertex array */
/* need to get the vertices in the model */
verts = NULL;
verts_alloc = 0;
iMesh_getEntities(m_mesh, m_hRootSet, iBase_VERTEX,
iMesh_POINT, &verts, &verts_alloc, &m_numNodes, &result);
if (iBase_SUCCESS != result) {
printf("failed to get vertices.\n");
return 1;
}
/*
iMesh_getNumOfType ( iMesh_Instance instance,
const iBase_EntitySetHandle entity_set_handle,
const int entity_type,
int * num_type,
int * err
) */
int numEdges=0;
iMesh_getNumOfType (m_mesh, m_hRootSet, iBase_EDGE,
&numEdges, &result);
// get the triangles and the vertices in one shot
iBase_EntityHandle *triangles = NULL;
int triangles_alloc = 0;
iBase_EntityHandle *vert_adj = NULL;
int vert_adj_alloc = 0, vert_adj_size;
int * offsets = NULL, offsets_alloc = 0, indices_size;
int * indices = NULL, indices_alloc = 0, offsets_size;
iMesh_getAdjEntIndices( m_mesh, m_hRootSet,
iBase_FACE, iMesh_TRIANGLE, iBase_VERTEX,
&triangles, &triangles_alloc, &m_numTriangles,
&vert_adj, &vert_adj_alloc, &vert_adj_size,
&indices, &indices_alloc, &indices_size,
&offsets, &offsets_alloc, &offsets_size,
&result );
if (iBase_SUCCESS != result) {
printf("failed to get triangles and vertices.\n");
return 1;
}
/* get the coordinates in one array */
vert_coords_alloc = 0;
iMesh_getVtxArrCoords(m_mesh, vert_adj, vert_adj_size, iBase_INTERLEAVED,
&m_xyz, &vert_coords_alloc, &vertex_coord_size, &result);
if (iBase_SUCCESS != result || 3*m_numNodes!=vertex_coord_size) {
printf("failed to get vertex coordinates of entities in getMeshData.\n");
return 1;
}
// build list of edges; we cannot rely on iMesh to give them to us
// can we force imesh to give the edges? It does not seem like that
// the vertices are identified as the index in vert_adj
// indices are the triangles
// i is index in triangles
// offsets[i], offsets[i+1] are offsets in indices
// vertices of triangle [i] have indices indices[offsets[i]+j], j=0:(offsets[i+1]-offsets[i])-1
// first, determine the edges of triangle i
if (offsets_size - 1 != m_numTriangles)
{
std::cerr<<"bad indexing\n";
return 1;
}
int i=0;// index used everywhere
for (i=0; i<m_numTriangles; i++)
{
if (offsets[i+1]-offsets[i] !=3)
{
std::cerr<< "not a triangle\n";
return 1;
}
}
// build edges from triangle information
ps_edges = new PSEdge [m_numTriangles*3];// overestimate; probably only half will be created
ps_nodes = new PSNode [m_numNodes];
ps_triangles = new PS3DTriangle [m_numTriangles];
//
for (i=0; i<m_numNodes; i++)
{
PSNode & psn = ps_nodes[i];
psn.id = i;// this can be found by address in the array, but why bother
for (int j=0; j<3; j++)
{
psn.xyz[j] = m_xyz[3*i+j];
}
}
// index in edge:
int edgeIndex = 0;
int j=0;
for (j=0; j<m_numTriangles; j++)
{
PS3DTriangle & curTria = ps_triangles[j];
int ii=0;
for (ii=0; ii<3; ii++)
curTria.v[ii]=indices[offsets[j]+ii];
for (ii=0; ii<3; ii++)
{
PSNode & v1= ps_nodes[curTria.v[ii]];
int nextii = ii+1;
if (ii==2)
nextii=0;
PSNode & v2= ps_nodes[curTria.v[nextii]];
// is there an edge from v1 to v2, or from v2 to v1
int edgeId;
int exi = getEdge(v1, v2, edgeId, ps_edges, edgeIndex);// will be created if not existing already
if (exi)
{
curTria.e[ii] = edgeId;
PSEdge & foundEdge = ps_edges[abs(edgeId)-1];
foundEdge.used++;
if(foundEdge.used>2)
{
std::cerr<< " bad indexing in ps_edge; exit\n";
exit(1);
}
foundEdge.t[1]=j; // mark the triangle it belongs to
}
else
{
int cId = curTria.e[ii]=edgeIndex+1;
PSEdge & newEdge = ps_edges[edgeIndex];
newEdge.v[0] = curTria.v[ii];
newEdge.v[1]=curTria.v[nextii];
v1.edges.push_back(cId); // positive means starts at vertex
v2.edges.push_back(-cId);// negative means incident to the vertex
edgeIndex++;
newEdge.used=1;
newEdge.t[0] = j; // index for triangles
}
}
}
m_numEdges = edgeIndex;
// fill up now the triangle neighbor information
for (j=0; j<m_numTriangles; j++)
{
PS3DTriangle & tri = ps_triangles[j];
for (int k=0; k<3; k++)
{
int edgeId = tri.e[k];
int ae = abs(edgeId);
PSEdge & edge = ps_edges[ae-1];
int t0 = edge.t[0], t1 = edge.t[1];
if (t0==j)
tri.t[k] = t1;
else if (t1==j)
tri.t[k] = t0;
}
}
free(verts);
free(triangles);
free(vert_adj);
free (indices);
free (offsets);
//free(vert_coords);
return 0;
}
