//---------------------------------------------------------------------------//
// Create the function space.
void STKMeshManager::createFunctionSpace(
const BasisType basis_type,
const PredicateFunction& select_function )
{
Teuchos::RCP<EntitySet> entity_set =
Teuchos::rcp( new STKMeshEntitySet(d_bulk_data) );
Teuchos::RCP<EntityLocalMap> local_map =
Teuchos::rcp( new STKMeshEntityLocalMap(d_bulk_data) );
Teuchos::RCP<EntityShapeFunction> shape_function;
switch( basis_type )
{
case BASIS_TYPE_GRADIENT:
shape_function =
Teuchos::rcp( new STKMeshNodalShapeFunction(d_bulk_data) );
break;
default:
bool bad_basis_type = true;
DTK_INSIST( !bad_basis_type );
break;
}
DTK_CHECK( Teuchos::nonnull(shape_function) );
Teuchos::RCP<EntityIntegrationRule> integration_rule =
Teuchos::rcp( new STKMeshEntityIntegrationRule(d_bulk_data) );
d_function_space = Teuchos::rcp(
new FunctionSpace(entity_set,local_map,shape_function,
integration_rule,select_function) );
DTK_ENSURE( Teuchos::nonnull(d_function_space) );
}
//---------------------------------------------------------------------------//
// Determine if a reference point is in the parameterized space of an entity.
bool STKMeshEntityLocalMap::checkPointInclusion(
const Entity& entity,
const Teuchos::ArrayView<const double>& reference_point ) const
{
// Get the test tolerance.
double tolerance = 1.0e-6;
if ( Teuchos::nonnull(this->b_parameters) )
{
if ( this->b_parameters->isParameter("Point Inclusion Tolerance") )
{
tolerance =
this->b_parameters->get<double>("Point Inclusion Tolerance");
}
}
// Get the STK entity and its topology.
const stk::mesh::Entity& stk_entity = STKMeshHelpers::extractEntity(entity);
stk::mesh::EntityRank rank = d_bulk_data->entity_rank(stk_entity);
shards::CellTopology entity_topo =
stk::mesh::get_cell_topology(
d_bulk_data->bucket(stk_entity).topology() );
// Check point inclusion in the element.
if ( rank == stk::topology::ELEM_RANK )
{
return IntrepidCellLocalMap::checkPointInclusion(
entity_topo, reference_point, tolerance );
}
// Check point inclusion in the face.
else if ( rank == stk::topology::FACE_RANK )
{
bool not_implemented = true;
DTK_INSIST( !not_implemented );
return false;
}
// Check for unsupported ranks.
else
{
bool bad_rank = true;
DTK_INSIST( !bad_rank );
return false;
}
return false;
}
//---------------------------------------------------------------------------//
// Given an entity and a reference point, evaluate the shape function of the
// entity at that point.
void EntityShapeFunction::evaluateValue(
const Entity& entity,
const Teuchos::ArrayView<const double>& reference_point,
Teuchos::Array<double>& values ) const
{
bool not_implemented = true;
DTK_INSIST( !not_implemented );
}
//---------------------------------------------------------------------------//
// Given an entity, get the entities of the given type that are adjacent to
// it.
void POD_PointCloudEntitySet::getAdjacentEntities(
const Entity& entity,
const int adjacent_dimension,
Teuchos::Array<Entity>& adjacent_entities ) const
{
// There is no adjacency information in a point cloud.
DTK_INSIST( false );
}
//---------------------------------------------------------------------------//
// Compute the normal on a face (3D) or edge (2D) at a given reference point.
void MoabEntityLocalMap::normalAtReferencePoint(
const Entity& entity,
const Entity& parent_entity,
const Teuchos::ArrayView<const double>& reference_point,
const Teuchos::ArrayView<double>& normal ) const
{
bool not_implemented = true;
DTK_INSIST( !not_implemented );
}
//---------------------------------------------------------------------------//
// Return the centroid of the entity.
void STKMeshEntityLocalMap::centroid(
const Entity& entity, const Teuchos::ArrayView<double>& centroid ) const
{
// Get the STK entity.
const stk::mesh::Entity& stk_entity = STKMeshHelpers::extractEntity(entity);
stk::mesh::EntityRank rank = d_bulk_data->entity_rank(stk_entity);
// Extract the centroid of the element.
if ( rank == stk::topology::ELEM_RANK )
{
shards::CellTopology entity_topo =
stk::mesh::get_cell_topology(
d_bulk_data->bucket(stk_entity).topology() );
Intrepid::FieldContainer<double> entity_coords =
STKMeshHelpers::getEntityNodeCoordinates(
Teuchos::Array<stk::mesh::Entity>(1,stk_entity), *d_bulk_data );
IntrepidCellLocalMap::centroid(
entity_topo, entity_coords, centroid );
}
// Extract the centroid of the face.
else if ( rank == stk::topology::FACE_RANK )
{
bool not_implemented = true;
DTK_INSIST( !not_implemented );
}
// The centroid of a node is the node coordinates.
else if ( rank == stk::topology::NODE_RANK )
{
Intrepid::FieldContainer<double> entity_coords =
STKMeshHelpers::getEntityNodeCoordinates(
Teuchos::Array<stk::mesh::Entity>(1,stk_entity), *d_bulk_data );
centroid.assign( entity_coords.getData()() );
}
// Check for unsupported ranks.
else
{
bool bad_rank = true;
DTK_INSIST( !bad_rank );
}
}
//---------------------------------------------------------------------------//
// Map a point to the reference space of an entity. Return the parameterized
// point.
bool STKMeshEntityLocalMap::mapToReferenceFrame(
const Entity& entity,
const Teuchos::ArrayView<const double>& point,
const Teuchos::ArrayView<double>& reference_point,
const Teuchos::RCP<MappingStatus>& status ) const
{
// Get the STK entity.
const stk::mesh::Entity& stk_entity = STKMeshHelpers::extractEntity(entity);
stk::mesh::EntityRank rank = d_bulk_data->entity_rank(stk_entity);
// Use the cell to perform the element mapping.
if ( rank == stk::topology::ELEM_RANK )
{
shards::CellTopology entity_topo =
stk::mesh::get_cell_topology(
d_bulk_data->bucket(stk_entity).topology() );
Intrepid::FieldContainer<double> entity_coords =
STKMeshHelpers::getEntityNodeCoordinates(
Teuchos::Array<stk::mesh::Entity>(1,stk_entity), *d_bulk_data );
IntrepidCellLocalMap::mapToReferenceFrame(
entity_topo, entity_coords, point, reference_point );
}
// Use the side cell to perform the face mapping.
else if ( rank == stk::topology::FACE_RANK )
{
bool not_implemented = true;
DTK_INSIST( !not_implemented );
return false;
}
// Check for unsupported ranks.
else
{
bool bad_rank = true;
DTK_INSIST( !bad_rank );
}
// Return true to indicate successful mapping. Catching Intrepid errors
// and returning false is a possibility here.
return true;
}
//---------------------------------------------------------------------------//
// Compute the normal on a face (3D) or edge (2D) at a given reference point.
void STKMeshEntityLocalMap::normalAtReferencePoint(
const Entity& entity,
const Teuchos::ArrayView<double>& reference_point,
const Teuchos::ArrayView<double>& normal ) const
{
// Get the STK entity.
const stk::mesh::Entity& stk_entity = STKMeshHelpers::extractEntity(entity);
stk::mesh::EntityRank rank = d_bulk_data->entity_rank(stk_entity);
// We can only compute normals for faces.
if ( rank == stk::topology::FACE_RANK )
{
bool not_implemented = true;
DTK_INSIST( !not_implemented );
}
// Check for unsupported ranks.
else
{
bool bad_rank = true;
DTK_INSIST( !bad_rank );
}
}
//---------------------------------------------------------------------------//
// Return the entity measure with respect to the parameteric dimension (volume
// for a 3D entity, area for 2D, and length for 1D).
double STKMeshEntityLocalMap::measure( const Entity& entity ) const
{
// Get the STK entity and its topology.
const stk::mesh::Entity& stk_entity = STKMeshHelpers::extractEntity(entity);
stk::mesh::EntityRank rank = d_bulk_data->entity_rank(stk_entity);
shards::CellTopology entity_topo =
stk::mesh::get_cell_topology(
d_bulk_data->bucket(stk_entity).topology() );
// Get the STK entity coordinates.
Intrepid::FieldContainer<double> entity_coords =
STKMeshHelpers::getEntityNodeCoordinates(
Teuchos::Array<stk::mesh::Entity>(1,stk_entity), *d_bulk_data );
// Compute the measure of the element.
if ( rank == stk::topology::ELEM_RANK )
{
return IntrepidCellLocalMap::measure( entity_topo, entity_coords );
}
// Compute the measure of the face.
else if ( rank == stk::topology::FACE_RANK )
{
bool not_implemented = true;
DTK_INSIST( !not_implemented );
return -1.0;
}
// Check for unsupported ranks.
else
{
bool bad_rank = true;
DTK_INSIST( !bad_rank );
return - 1.0;
}
return -1.0;
}
//---------------------------------------------------------------------------//
// Map a reference point to the physical space of an entity.
void STKMeshEntityLocalMap::mapToPhysicalFrame(
const Entity& entity,
const Teuchos::ArrayView<const double>& reference_point,
const Teuchos::ArrayView<double>& point ) const
{
// Get the STK entity.
const stk::mesh::Entity& stk_entity = STKMeshHelpers::extractEntity(entity);
stk::mesh::EntityRank rank = d_bulk_data->entity_rank(stk_entity);
// Map from the element.
if ( rank == stk::topology::ELEM_RANK )
{
shards::CellTopology entity_topo =
stk::mesh::get_cell_topology(
d_bulk_data->bucket(stk_entity).topology() );
Intrepid::FieldContainer<double> entity_coords =
STKMeshHelpers::getEntityNodeCoordinates(
Teuchos::Array<stk::mesh::Entity>(1,stk_entity), *d_bulk_data );
IntrepidCellLocalMap::mapToPhysicalFrame(
entity_topo, entity_coords, reference_point, point );
}
// Map from the face.
else if ( rank == stk::topology::FACE_RANK )
{
bool not_implemented = true;
DTK_INSIST( !not_implemented );
}
// Check for unsupported ranks.
else
{
bool bad_rank = true;
DTK_INSIST( !bad_rank );
}
}
//---------------------------------------------------------------------------//
// Perform a safeguard check for mapping a point to the reference space
// of an entity using the given tolerance.
bool STKMeshEntityLocalMap::isSafeToMapToReferenceFrame(
const Entity& entity,
const Teuchos::ArrayView<const double>& point,
const Teuchos::RCP<MappingStatus>& status ) const
{
// Get the STK entity.
const stk::mesh::Entity& stk_entity = STKMeshHelpers::extractEntity(entity);
stk::mesh::EntityRank rank = d_bulk_data->entity_rank(stk_entity);
// If we have an element, use the default implementation.
if ( rank == stk::topology::ELEM_RANK )
{
return
EntityLocalMap::isSafeToMapToReferenceFrame( entity, point, status );
}
// If we have a face, perform the projection safeguard.
else if ( rank == stk::topology::FACE_RANK )
{
bool not_implemented = true;
DTK_INSIST( !not_implemented );
return false;
}
// Check for unsupported ranks.
else
{
bool bad_rank = true;
DTK_INSIST( !bad_rank );
return false;
}
// Return true to indicate successful mapping. Catching Intrepid errors
// and returning false is a possibility here.
return true;
}
//---------------------------------------------------------------------------//
// Perform a safeguard check for mapping a point to the reference space
// of an entity using the given tolerance.
bool MoabEntityLocalMap::isSafeToMapToReferenceFrame(
const Entity& entity,
const Teuchos::ArrayView<const double>& physical_point ) const
{
int space_dim = entity.physicalDimension();
int param_dim = d_moab_mesh->get_moab()->dimension_from_handle(
MoabHelpers::extractEntity(entity) );
if ( space_dim == param_dim )
{
return EntityLocalMap::isSafeToMapToReferenceFrame(
entity, physical_point );
}
else
{
bool not_implemented = true;
DTK_INSIST( !not_implemented );
}
return false;
}
void IntrepidSideCell<MDArray>::updateCellState()
{
unsigned space_dim = d_parent_topology.getDimension();
// Compute the Jacobian.
Intrepid::CellTools<Scalar>::setJacobian(
this->d_jacobian, this->d_cub_points,
this->d_cell_node_coords, d_parent_topology );
// Compute the cell side measures.
switch ( space_dim )
{
case 3:
{
// Face case.
Intrepid::FunctionSpaceTools::computeFaceMeasure<Scalar>(
this->d_weighted_measures, this->d_jacobian,
this->d_cub_weights, d_side_id, d_parent_topology );
}
break;
case 2:
{
// Edge case.
Intrepid::FunctionSpaceTools::computeEdgeMeasure<Scalar>(
this->d_weighted_measures, this->d_jacobian,
this->d_cub_weights, d_side_id, d_parent_topology );
}
break;
default:
DTK_INSIST( 3 == space_dim || 2 == space_dim,
"Subcell cell not supported for dimension" );
break;
}
// Compute physical frame integration point coordinates.
Intrepid::CellTools<Scalar>::mapToPhysicalFrame(
this->d_physical_ip_coordinates, this->d_cub_points,
this->d_cell_node_coords, d_parent_topology );
}
//---------------------------------------------------------------------------//
// Test the assertion check for DBC.
TEUCHOS_UNIT_TEST( DataTransferKitException, assertion_test )
{
try
{
DTK_INSIST( 0 );
throw std::runtime_error( "this shouldn't be thrown" );
}
catch( const DataTransferKit::DataTransferKitException& assertion )
{
std::string message( assertion.what() );
std::string true_message( "DataTransferKit DataTransferKitException: 0, failed in" );
std::string::size_type idx = message.find( true_message );
if ( idx == std::string::npos )
{
TEST_ASSERT( 0 );
}
}
catch( ... )
{
TEST_ASSERT( 0 );
}
}
//---------------------------------------------------------------------------//
// Given an entity, get the ids of the degrees of freedom in the vector space
// supporting its shape function.
void EntityShapeFunction::entityDOFIds(
const Entity& entity, Teuchos::Array<std::size_t>& dof_ids ) const
{
bool not_implemented = true;
DTK_INSIST( !not_implemented );
}
//---------------------------------------------------------------------------//
Teuchos::RCP<Intrepid::Basis<double,Intrepid::FieldContainer<double> > >
IntrepidBasisFactory::create( const shards::CellTopology& cell_topo )
{
Teuchos::RCP<Intrepid::Basis<double,Intrepid::FieldContainer<double> > > basis;
switch( cell_topo.getKey() ){
case shards::Line<2>::key:
basis = Teuchos::rcp(
new Intrepid::Basis_HGRAD_LINE_C1_FEM<
double,Intrepid::FieldContainer<double> >() );
break;
case shards::Triangle<3>::key:
basis = Teuchos::rcp(
new Intrepid::Basis_HGRAD_TRI_C1_FEM<
double,Intrepid::FieldContainer<double> >() );
break;
case shards::Triangle<6>::key:
basis = Teuchos::rcp(
new Intrepid::Basis_HGRAD_TRI_C2_FEM<
double,Intrepid::FieldContainer<double> >() );
break;
case shards::Quadrilateral<4>::key:
basis = Teuchos::rcp(
new Intrepid::Basis_HGRAD_QUAD_C1_FEM<
double,Intrepid::FieldContainer<double> >() );
break;
case shards::Quadrilateral<9>::key:
basis = Teuchos::rcp(
new Intrepid::Basis_HGRAD_QUAD_C2_FEM<
double,Intrepid::FieldContainer<double> >() );
break;
case shards::Tetrahedron<4>::key:
basis = Teuchos::rcp(
new Intrepid::Basis_HGRAD_TET_C1_FEM<
double,Intrepid::FieldContainer<double> >() );
break;
case shards::Tetrahedron<10>::key:
basis = Teuchos::rcp(
new Intrepid::Basis_HGRAD_TET_C2_FEM<
double,Intrepid::FieldContainer<double> >() );
break;
case shards::Hexahedron<8>::key:
basis = Teuchos::rcp(
new Intrepid::Basis_HGRAD_HEX_C1_FEM<
double,Intrepid::FieldContainer<double> >() );
break;
case shards::Hexahedron<27>::key:
basis = Teuchos::rcp(
new Intrepid::Basis_HGRAD_HEX_C2_FEM<
double,Intrepid::FieldContainer<double> >() );
break;
case shards::Wedge<6>::key:
basis = Teuchos::rcp(
new Intrepid::Basis_HGRAD_WEDGE_C1_FEM<
double,Intrepid::FieldContainer<double> >() );
break;
case shards::Wedge<18>::key:
basis = Teuchos::rcp(
new Intrepid::Basis_HGRAD_WEDGE_C2_FEM<
double,Intrepid::FieldContainer<double> >() );
break;
case shards::Pyramid<5>::key:
case shards::Pyramid<13>::key:
case shards::Pyramid<14>::key:
basis = Teuchos::rcp(
new Intrepid::Basis_HGRAD_PYR_C1_FEM<
double,Intrepid::FieldContainer<double> >() );
break;
default:
bool topology_supported = false;
DTK_INSIST( topology_supported );
break;
}
return basis;
}
