void MeshBase::detect_interior_parents()
{
// This requires an inspection on every processor
parallel_object_only();
// Check if the mesh contains mixed dimensions. If so, then set interior parents, otherwise return.
if (this->elem_dimensions().size() == 1)
return;
//This map will be used to set interior parents
LIBMESH_BEST_UNORDERED_MAP<dof_id_type, std::vector<dof_id_type> > node_to_elem;
const_element_iterator el = this->active_elements_begin();
const_element_iterator end = this->active_elements_end();
for (; el!=end; ++el)
{
const Elem * elem = *el;
// Populating the node_to_elem map, same as MeshTools::build_nodes_to_elem_map
for (unsigned int n=0; n<elem->n_vertices(); n++)
{
libmesh_assert_less (elem->id(), this->max_elem_id());
node_to_elem[elem->node_id(n)].push_back(elem->id());
}
}
// Automatically set interior parents
el = this->elements_begin();
for (; el!=end; ++el)
{
Elem * element = *el;
// Ignore an 3D element or an element that already has an interior parent
if (element->dim()>=LIBMESH_DIM || element->interior_parent())
continue;
// Start by generating a SET of elements that are dim+1 to the current
// element at each vertex of the current element, thus ignoring interior nodes.
// If one of the SET of elements is empty, then we will not have an interior parent
// since an interior parent must be connected to all vertices of the current element
std::vector< std::set<dof_id_type> > neighbors( element->n_vertices() );
bool found_interior_parents = false;
for (dof_id_type n=0; n < element->n_vertices(); n++)
{
std::vector<dof_id_type> & element_ids = node_to_elem[element->node_id(n)];
for (std::vector<dof_id_type>::iterator e_it = element_ids.begin();
e_it != element_ids.end(); e_it++)
{
dof_id_type eid = *e_it;
if (this->elem_ref(eid).dim() == element->dim()+1)
neighbors[n].insert(eid);
}
if (neighbors[n].size()>0)
{
found_interior_parents = true;
}
else
{
// We have found an empty set, no reason to continue
// Ensure we set this flag to false before the break since it could have
// been set to true for previous vertex
found_interior_parents = false;
break;
}
}
// If we have successfully generated a set of elements for each vertex, we will compare
// the set for vertex 0 will the sets for the vertices until we find a id that exists in
// all sets. If found, this is our an interior parent id. The interior parent id found
// will be the lowest element id if there is potential for multiple interior parents.
if (found_interior_parents)
{
std::set<dof_id_type> & neighbors_0 = neighbors[0];
for (std::set<dof_id_type>::iterator e_it = neighbors_0.begin();
e_it != neighbors_0.end(); e_it++)
{
found_interior_parents=false;
dof_id_type interior_parent_id = *e_it;
for (dof_id_type n=1; n < element->n_vertices(); n++)
{
if (neighbors[n].find(interior_parent_id)!=neighbors[n].end())
{
found_interior_parents=true;
}
else
{
found_interior_parents=false;
break;
}
}
if (found_interior_parents)
{
element->set_interior_parent(this->elem_ptr(interior_parent_id));
break;
}
}
}
}
}
void TetGenMeshInterface::triangulate_conformingDelaunayMesh_carvehole (const std::vector<Point> & holes,
double quality_constraint,
double volume_constraint)
{
// Before calling this function, the Mesh must contain a convex hull
// of TRI3 elements which define the boundary.
unsigned hull_integrity_check = check_hull_integrity();
// Possibly die if hull integrity check failed
this->process_hull_integrity_result(hull_integrity_check);
// class tetgen_wrapper allows library access on a basic level
TetGenWrapper tetgen_wrapper;
// Copy Mesh's node points into TetGen data structure
this->fill_pointlist(tetgen_wrapper);
// >>> fill input structure "tetgenio" with facet data:
int facet_num = this->_mesh.n_elem();
// allocate memory in "tetgenio" structure:
tetgen_wrapper.allocate_facetlist
(facet_num, cast_int<int>(holes.size()));
// Set up tetgen data structures with existing facet information
// from the convex hull.
{
int insertnum = 0;
MeshBase::element_iterator it = this->_mesh.elements_begin();
const MeshBase::element_iterator end = this->_mesh.elements_end();
for (; it != end ; ++it)
{
tetgen_wrapper.allocate_facet_polygonlist(insertnum, 1);
tetgen_wrapper.allocate_polygon_vertexlist(insertnum, 0, 3);
Elem * elem = *it;
for (unsigned int j=0; j<elem->n_nodes(); ++j)
{
// We need to get the sequential index of elem->node_ptr(j), but
// it should already be stored in _sequential_to_libmesh_node_map...
unsigned libmesh_node_id = elem->node_id(j);
// The libmesh node IDs may not be sequential, but can we assume
// they are at least in order??? We will do so here.
std::vector<unsigned>::iterator node_iter =
Utility::binary_find(_sequential_to_libmesh_node_map.begin(),
_sequential_to_libmesh_node_map.end(),
libmesh_node_id);
// Check to see if not found: this could also indicate the sequential
// node map is not sorted...
if (node_iter == _sequential_to_libmesh_node_map.end())
libmesh_error_msg("Global node " << libmesh_node_id << " not found in sequential node map!");
int sequential_index = cast_int<int>
(std::distance(_sequential_to_libmesh_node_map.begin(),
node_iter));
// Debugging:
// libMesh::out << "libmesh_node_id=" << libmesh_node_id
// << ", sequential_index=" << sequential_index
// << std::endl;
tetgen_wrapper.set_vertex(insertnum, // facet number
0, // polygon (always 0)
j, // local vertex index in tetgen input
sequential_index);
}
// Go to next facet in polygonlist
insertnum++;
}
}
// fill hole list (if there are holes):
if (holes.size() > 0)
{
std::vector<Point>::const_iterator ihole;
unsigned hole_index = 0;
for (ihole=holes.begin(); ihole!=holes.end(); ++ihole)
tetgen_wrapper.set_hole(hole_index++, (*ihole)(0), (*ihole)(1), (*ihole)(2));
}
// Run TetGen triangulation method:
// p = tetrahedralizes a piecewise linear complex (see definition in user manual)
// Q = quiet, no terminal output
// q = specify a minimum radius/edge ratio
// a = tetrahedron volume constraint
// assemble switches:
std::ostringstream oss; // string holding switches
oss << "pQ";
if (quality_constraint != 0)
oss << "q" << std::fixed << quality_constraint;
if (volume_constraint != 0)
oss << "a" << std::fixed << volume_constraint;
std::string params = oss.str();
tetgen_wrapper.set_switches(params); // TetGen switches: Piecewise linear complex, Quiet mode
tetgen_wrapper.run_tetgen();
// => nodes:
unsigned int old_nodesnum = this->_mesh.n_nodes();
REAL x=0., y=0., z=0.;
const unsigned int num_nodes = tetgen_wrapper.get_numberofpoints();
// Debugging:
// libMesh::out << "Original mesh had " << old_nodesnum << " nodes." << std::endl;
// libMesh::out << "Reserving space for " << num_nodes << " total nodes." << std::endl;
// Reserve space for additional nodes in the node map
_sequential_to_libmesh_node_map.reserve(num_nodes);
// Add additional nodes to the Mesh.
// Original code had i<=num_nodes here (Note: the indexing is:
// foo[3*i], [3*i+1], [3*i+2]) But according to the TetGen docs, "In
// all cases, the first item in any array is stored starting at
// index [0]."
for (unsigned int i=old_nodesnum; i<num_nodes; i++)
{
// Fill in x, y, z values
tetgen_wrapper.get_output_node(i, x,y,z);
// Catch the node returned by add_point()... this will tell us the ID
// assigned by the Mesh.
Node * new_node = this->_mesh.add_point ( Point(x,y,z) );
// Store this new ID in our sequential-to-libmesh node mapping array
_sequential_to_libmesh_node_map.push_back( new_node->id() );
}
// Debugging:
// std::copy(_sequential_to_libmesh_node_map.begin(),
// _sequential_to_libmesh_node_map.end(),
// std::ostream_iterator<unsigned>(std::cout, " "));
// std::cout << std::endl;
// => tetrahedra:
const unsigned int num_elements = tetgen_wrapper.get_numberoftetrahedra();
// Vector that temporarily holds the node labels defining element connectivity.
unsigned int node_labels[4];
for (unsigned int i=0; i<num_elements; i++)
{
// TetGen only supports Tet4 elements.
Elem * elem = new Tet4;
// Fill up the the node_labels vector
for (unsigned int j=0; j<elem->n_nodes(); j++)
node_labels[j] = tetgen_wrapper.get_element_node(i,j);
// Associate nodes with this element
this->assign_nodes_to_elem(node_labels, elem);
// Finally, add this element to the mesh
this->_mesh.add_elem(elem);
}
// Delete original convex hull elements. Is there ever a case where
// we should not do this?
this->delete_2D_hull_elements();
}
Elem *
Packing<Elem *>::unpack (std::vector<largest_id_type>::const_iterator in,
MeshBase * mesh)
{
#ifndef NDEBUG
const std::vector<largest_id_type>::const_iterator original_in = in;
const largest_id_type incoming_header = *in++;
libmesh_assert_equal_to (incoming_header, elem_magic_header);
#endif
// int 0: level
const unsigned int level =
cast_int<unsigned int>(*in++);
#ifdef LIBMESH_ENABLE_AMR
// int 1: p level
const unsigned int p_level =
cast_int<unsigned int>(*in++);
// int 2: refinement flag and encoded has_children
const int rflag = cast_int<int>(*in++);
const int invalid_rflag =
cast_int<int>(Elem::INVALID_REFINEMENTSTATE);
libmesh_assert_greater_equal (rflag, 0);
libmesh_assert_less (rflag, invalid_rflag*2+1);
const bool has_children = (rflag > invalid_rflag);
const Elem::RefinementState refinement_flag = has_children ?
cast_int<Elem::RefinementState>(rflag - invalid_rflag - 1) :
cast_int<Elem::RefinementState>(rflag);
// int 3: p refinement flag
const int pflag = cast_int<int>(*in++);
libmesh_assert_greater_equal (pflag, 0);
libmesh_assert_less (pflag, Elem::INVALID_REFINEMENTSTATE);
const Elem::RefinementState p_refinement_flag =
cast_int<Elem::RefinementState>(pflag);
#else
in += 3;
#endif // LIBMESH_ENABLE_AMR
// int 4: element type
const int typeint = cast_int<int>(*in++);
libmesh_assert_greater_equal (typeint, 0);
libmesh_assert_less (typeint, INVALID_ELEM);
const ElemType type =
cast_int<ElemType>(typeint);
const unsigned int n_nodes =
Elem::type_to_n_nodes_map[type];
// int 5: processor id
const processor_id_type processor_id =
cast_int<processor_id_type>(*in++);
libmesh_assert (processor_id < mesh->n_processors() ||
processor_id == DofObject::invalid_processor_id);
// int 6: subdomain id
const subdomain_id_type subdomain_id =
cast_int<subdomain_id_type>(*in++);
// int 7: dof object id
const dof_id_type id =
cast_int<dof_id_type>(*in++);
libmesh_assert_not_equal_to (id, DofObject::invalid_id);
#ifdef LIBMESH_ENABLE_UNIQUE_ID
// int 8: dof object unique id
const unique_id_type unique_id =
cast_int<unique_id_type>(*in++);
#endif
#ifdef LIBMESH_ENABLE_AMR
// int 9: parent dof object id.
// Note: If level==0, then (*in) == invalid_id. In
// this case, the equality check in cast_int<unsigned>(*in) will
// never succeed. Therefore, we should only attempt the more
// rigorous cast verification in cases where level != 0.
const dof_id_type parent_id =
(level == 0)
? static_cast<dof_id_type>(*in++)
: cast_int<dof_id_type>(*in++);
libmesh_assert (level == 0 || parent_id != DofObject::invalid_id);
libmesh_assert (level != 0 || parent_id == DofObject::invalid_id);
// int 10: local child id
// Note: If level==0, then which_child_am_i is not valid, so don't
// do the more rigorous cast verification.
const unsigned int which_child_am_i =
(level == 0)
? static_cast<unsigned int>(*in++)
: cast_int<unsigned int>(*in++);
#else
in += 2;
#endif // LIBMESH_ENABLE_AMR
const dof_id_type interior_parent_id =
static_cast<dof_id_type>(*in++);
// Make sure we don't miscount above when adding the "magic" header
// plus the real data header
libmesh_assert_equal_to (in - original_in, header_size + 1);
Elem * elem = mesh->query_elem_ptr(id);
// if we already have this element, make sure its
// properties match, and update any missing neighbor
// links, but then go on
if (elem)
{
libmesh_assert_equal_to (elem->level(), level);
libmesh_assert_equal_to (elem->id(), id);
//#ifdef LIBMESH_ENABLE_UNIQUE_ID
// No check for unique id sanity
//#endif
libmesh_assert_equal_to (elem->processor_id(), processor_id);
libmesh_assert_equal_to (elem->subdomain_id(), subdomain_id);
libmesh_assert_equal_to (elem->type(), type);
libmesh_assert_equal_to (elem->n_nodes(), n_nodes);
#ifndef NDEBUG
// All our nodes should be correct
for (unsigned int i=0; i != n_nodes; ++i)
libmesh_assert(elem->node_id(i) ==
cast_int<dof_id_type>(*in++));
#else
in += n_nodes;
#endif
#ifdef LIBMESH_ENABLE_AMR
libmesh_assert_equal_to (elem->refinement_flag(), refinement_flag);
libmesh_assert_equal_to (elem->has_children(), has_children);
#ifdef DEBUG
if (elem->active())
{
libmesh_assert_equal_to (elem->p_level(), p_level);
libmesh_assert_equal_to (elem->p_refinement_flag(), p_refinement_flag);
}
#endif
libmesh_assert (!level || elem->parent() != libmesh_nullptr);
libmesh_assert (!level || elem->parent()->id() == parent_id);
libmesh_assert (!level || elem->parent()->child_ptr(which_child_am_i) == elem);
#endif
// Our interior_parent link should be "close to" correct - we
// may have to update it, but we can check for some
// inconsistencies.
{
// If the sending processor sees no interior_parent here, we'd
// better agree.
if (interior_parent_id == DofObject::invalid_id)
{
if (elem->dim() < LIBMESH_DIM)
libmesh_assert (!(elem->interior_parent()));
}
// If the sending processor has a remote_elem interior_parent,
// then all we know is that we'd better have *some*
// interior_parent
else if (interior_parent_id == remote_elem->id())
{
libmesh_assert(elem->interior_parent());
}
else
{
Elem * ip = mesh->query_elem_ptr(interior_parent_id);
// The sending processor sees an interior parent here, so
// if we don't have that interior element, then we'd
// better have a remote_elem signifying that fact.
if (!ip)
libmesh_assert_equal_to (elem->interior_parent(), remote_elem);
else
{
// The sending processor has an interior_parent here,
// and we have that element, but that does *NOT* mean
// we're already linking to it. Perhaps we initially
// received elem from a processor on which the
// interior_parent link was remote?
libmesh_assert(elem->interior_parent() == ip ||
elem->interior_parent() == remote_elem);
// If the link was originally remote, update it
if (elem->interior_parent() == remote_elem)
{
elem->set_interior_parent(ip);
}
}
}
}
// Our neighbor links should be "close to" correct - we may have
// to update a remote_elem link, and we can check for possible
// inconsistencies along the way.
//
// For subactive elements, we don't bother keeping neighbor
// links in good shape, so there's nothing we need to set or can
// safely assert here.
if (!elem->subactive())
for (auto n : elem->side_index_range())
{
const dof_id_type neighbor_id =
cast_int<dof_id_type>(*in++);
// If the sending processor sees a domain boundary here,
// we'd better agree.
if (neighbor_id == DofObject::invalid_id)
{
libmesh_assert (!(elem->neighbor_ptr(n)));
continue;
}
// If the sending processor has a remote_elem neighbor here,
// then all we know is that we'd better *not* have a domain
// boundary.
if (neighbor_id == remote_elem->id())
{
libmesh_assert(elem->neighbor_ptr(n));
continue;
}
Elem * neigh = mesh->query_elem_ptr(neighbor_id);
// The sending processor sees a neighbor here, so if we
// don't have that neighboring element, then we'd better
// have a remote_elem signifying that fact.
if (!neigh)
{
libmesh_assert_equal_to (elem->neighbor_ptr(n), remote_elem);
continue;
}
// The sending processor has a neighbor here, and we have
// that element, but that does *NOT* mean we're already
// linking to it. Perhaps we initially received both elem
// and neigh from processors on which their mutual link was
// remote?
libmesh_assert(elem->neighbor_ptr(n) == neigh ||
elem->neighbor_ptr(n) == remote_elem);
// If the link was originally remote, we should update it,
// and make sure the appropriate parts of its family link
// back to us.
if (elem->neighbor_ptr(n) == remote_elem)
{
elem->set_neighbor(n, neigh);
elem->make_links_to_me_local(n);
}
}
// Our p level and refinement flags should be "close to" correct
// if we're not an active element - we might have a p level
// increased or decreased by changes in remote_elem children.
//
// But if we have remote_elem children, then we shouldn't be
// doing a projection on this inactive element on this
// processor, so we won't need correct p settings. Couldn't
// hurt to update, though.
#ifdef LIBMESH_ENABLE_AMR
if (elem->processor_id() != mesh->processor_id())
{
elem->hack_p_level(p_level);
elem->set_p_refinement_flag(p_refinement_flag);
}
#endif // LIBMESH_ENABLE_AMR
// FIXME: We should add some debug mode tests to ensure that the
// encoded indexing and boundary conditions are consistent.
}
else
{
// We don't already have the element, so we need to create it.
// Find the parent if necessary
Elem * parent = libmesh_nullptr;
#ifdef LIBMESH_ENABLE_AMR
// Find a child element's parent
if (level > 0)
{
// Note that we must be very careful to construct the send
// connectivity so that parents are encountered before
// children. If we get here and can't find the parent that
// is a fatal error.
parent = mesh->elem_ptr(parent_id);
}
// Or assert that the sending processor sees no parent
else
libmesh_assert_equal_to (parent_id, DofObject::invalid_id);
#else
// No non-level-0 elements without AMR
libmesh_assert_equal_to (level, 0);
#endif
elem = Elem::build(type,parent).release();
libmesh_assert (elem);
#ifdef LIBMESH_ENABLE_AMR
if (level != 0)
{
// Since this is a newly created element, the parent must
// have previously thought of this child as a remote element.
libmesh_assert_equal_to (parent->child_ptr(which_child_am_i), remote_elem);
parent->add_child(elem, which_child_am_i);
}
// Assign the refinement flags and levels
elem->set_p_level(p_level);
elem->set_refinement_flag(refinement_flag);
elem->set_p_refinement_flag(p_refinement_flag);
libmesh_assert_equal_to (elem->level(), level);
// If this element should have children, assign remote_elem to
// all of them for now, for consistency. Later unpacked
// elements may overwrite that.
if (has_children)
{
const unsigned int nc = elem->n_children();
for (unsigned int c=0; c != nc; ++c)
elem->add_child(const_cast<RemoteElem *>(remote_elem), c);
}
#endif // LIBMESH_ENABLE_AMR
// Assign the IDs
elem->subdomain_id() = subdomain_id;
elem->processor_id() = processor_id;
elem->set_id() = id;
#ifdef LIBMESH_ENABLE_UNIQUE_ID
elem->set_unique_id() = unique_id;
#endif
// Assign the connectivity
libmesh_assert_equal_to (elem->n_nodes(), n_nodes);
for (unsigned int n=0; n != n_nodes; n++)
elem->set_node(n) =
mesh->node_ptr
(cast_int<dof_id_type>(*in++));
// Set interior_parent if found
{
// We may be unpacking an element that was a ghost element on the
// sender, in which case the element's interior_parent may not be
// known by the packed element. We'll have to set such
// interior_parents to remote_elem ourselves and wait for a
// later packed element to give us better information.
if (interior_parent_id == remote_elem->id())
{
elem->set_interior_parent
(const_cast<RemoteElem *>(remote_elem));
}
else if (interior_parent_id != DofObject::invalid_id)
{
// If we don't have the interior parent element, then it's
// a remote_elem until we get it.
Elem * ip = mesh->query_elem_ptr(interior_parent_id);
if (!ip )
elem->set_interior_parent
(const_cast<RemoteElem *>(remote_elem));
else
elem->set_interior_parent(ip);
}
}
for (auto n : elem->side_index_range())
{
const dof_id_type neighbor_id =
cast_int<dof_id_type>(*in++);
if (neighbor_id == DofObject::invalid_id)
continue;
// We may be unpacking an element that was a ghost element on the
// sender, in which case the element's neighbors may not all be
// known by the packed element. We'll have to set such
// neighbors to remote_elem ourselves and wait for a later
// packed element to give us better information.
if (neighbor_id == remote_elem->id())
{
elem->set_neighbor(n, const_cast<RemoteElem *>(remote_elem));
continue;
}
// If we don't have the neighbor element, then it's a
// remote_elem until we get it.
Elem * neigh = mesh->query_elem_ptr(neighbor_id);
if (!neigh)
{
elem->set_neighbor(n, const_cast<RemoteElem *>(remote_elem));
continue;
}
// If we have the neighbor element, then link to it, and
// make sure the appropriate parts of its family link back
// to us.
elem->set_neighbor(n, neigh);
elem->make_links_to_me_local(n);
}
elem->unpack_indexing(in);
}
in += elem->packed_indexing_size();
// If this is a coarse element,
// add any element side or edge boundary condition ids
if (level == 0)
{
for (auto s : elem->side_index_range())
{
const boundary_id_type num_bcs =
cast_int<boundary_id_type>(*in++);
for (boundary_id_type bc_it=0; bc_it < num_bcs; bc_it++)
mesh->get_boundary_info().add_side
(elem, s, cast_int<boundary_id_type>(*in++));
}
for (auto e : elem->edge_index_range())
{
const boundary_id_type num_bcs =
cast_int<boundary_id_type>(*in++);
for (boundary_id_type bc_it=0; bc_it < num_bcs; bc_it++)
mesh->get_boundary_info().add_edge
(elem, e, cast_int<boundary_id_type>(*in++));
}
for (unsigned short sf=0; sf != 2; ++sf)
{
const boundary_id_type num_bcs =
cast_int<boundary_id_type>(*in++);
for (boundary_id_type bc_it=0; bc_it < num_bcs; bc_it++)
mesh->get_boundary_info().add_shellface
(elem, sf, cast_int<boundary_id_type>(*in++));
}
}
// Return the new element
return elem;
}