void MeshRefinement::flag_elements_by_error_tolerance (const ErrorVector & error_per_cell_in)
{
parallel_object_only();
libmesh_assert_greater (_coarsen_threshold, 0);
// Check for valid fractions..
// The fraction values must be in [0,1]
libmesh_assert_greater_equal (_refine_fraction, 0);
libmesh_assert_less_equal (_refine_fraction, 1);
libmesh_assert_greater_equal (_coarsen_fraction, 0);
libmesh_assert_less_equal (_coarsen_fraction, 1);
// How much error per cell will we tolerate?
const Real local_refinement_tolerance =
_absolute_global_tolerance / std::sqrt(static_cast<Real>(_mesh.n_active_elem()));
const Real local_coarsening_tolerance =
local_refinement_tolerance * _coarsen_threshold;
// Prepare another error vector if we need to sum parent errors
ErrorVector error_per_parent;
if (_coarsen_by_parents)
{
Real parent_error_min, parent_error_max;
create_parent_error_vector(error_per_cell_in,
error_per_parent,
parent_error_min,
parent_error_max);
}
for (auto & elem : _mesh.active_element_ptr_range())
{
Elem * parent = elem->parent();
const dof_id_type elem_number = elem->id();
const ErrorVectorReal elem_error = error_per_cell_in[elem_number];
if (elem_error > local_refinement_tolerance &&
elem->level() < _max_h_level)
elem->set_refinement_flag(Elem::REFINE);
if (!_coarsen_by_parents && elem_error <
local_coarsening_tolerance)
elem->set_refinement_flag(Elem::COARSEN);
if (_coarsen_by_parents && parent)
{
ErrorVectorReal parent_error = error_per_parent[parent->id()];
if (parent_error >= 0.)
{
const Real parent_coarsening_tolerance =
std::sqrt(parent->n_children() *
local_coarsening_tolerance *
local_coarsening_tolerance);
if (parent_error < parent_coarsening_tolerance)
elem->set_refinement_flag(Elem::COARSEN);
}
}
}
}
void Partitioner::set_parent_processor_ids(MeshBase & mesh)
{
// Ignore the parameter when !LIBMESH_ENABLE_AMR
libmesh_ignore(mesh);
LOG_SCOPE("set_parent_processor_ids()", "Partitioner");
#ifdef LIBMESH_ENABLE_AMR
// If the mesh is serial we have access to all the elements,
// in particular all the active ones. We can therefore set
// the parent processor ids indirecly through their children, and
// set the subactive processor ids while examining their active
// ancestors.
// By convention a parent is assigned to the minimum processor
// of all its children, and a subactive is assigned to the processor
// of its active ancestor.
if (mesh.is_serial())
{
// Loop over all the active elements in the mesh
MeshBase::element_iterator it = mesh.active_elements_begin();
const MeshBase::element_iterator end = mesh.active_elements_end();
for ( ; it!=end; ++it)
{
Elem * child = *it;
// First set descendents
std::vector<const Elem *> subactive_family;
child->total_family_tree(subactive_family);
for (unsigned int i = 0; i != subactive_family.size(); ++i)
const_cast<Elem *>(subactive_family[i])->processor_id() = child->processor_id();
// Then set ancestors
Elem * parent = child->parent();
while (parent)
{
// invalidate the parent id, otherwise the min below
// will not work if the current parent id is less
// than all the children!
parent->invalidate_processor_id();
for (unsigned int c=0; c<parent->n_children(); c++)
{
child = parent->child_ptr(c);
libmesh_assert(child);
libmesh_assert(!child->is_remote());
libmesh_assert_not_equal_to (child->processor_id(), DofObject::invalid_processor_id);
parent->processor_id() = std::min(parent->processor_id(),
child->processor_id());
}
parent = parent->parent();
}
}
}
// When the mesh is parallel we cannot guarantee that parents have access to
// all their children.
else
{
// Setting subactive processor ids is easy: we can guarantee
// that children have access to all their parents.
// Loop over all the active elements in the mesh
MeshBase::element_iterator it = mesh.active_elements_begin();
const MeshBase::element_iterator end = mesh.active_elements_end();
for ( ; it!=end; ++it)
{
Elem * child = *it;
std::vector<const Elem *> subactive_family;
child->total_family_tree(subactive_family);
for (unsigned int i = 0; i != subactive_family.size(); ++i)
const_cast<Elem *>(subactive_family[i])->processor_id() = child->processor_id();
}
// When the mesh is parallel we cannot guarantee that parents have access to
// all their children.
// We will use a brute-force approach here. Each processor finds its parent
// elements and sets the parent pid to the minimum of its
// semilocal descendants.
// A global reduction is then performed to make sure the true minimum is found.
// As noted, this is required because we cannot guarantee that a parent has
// access to all its children on any single processor.
libmesh_parallel_only(mesh.comm());
libmesh_assert(MeshTools::n_elem(mesh.unpartitioned_elements_begin(),
mesh.unpartitioned_elements_end()) == 0);
const dof_id_type max_elem_id = mesh.max_elem_id();
std::vector<processor_id_type>
parent_processor_ids (std::min(communication_blocksize,
max_elem_id));
for (dof_id_type blk=0, last_elem_id=0; last_elem_id<max_elem_id; blk++)
{
last_elem_id =
std::min(static_cast<dof_id_type>((blk+1)*communication_blocksize),
max_elem_id);
const dof_id_type first_elem_id = blk*communication_blocksize;
std::fill (parent_processor_ids.begin(),
parent_processor_ids.end(),
DofObject::invalid_processor_id);
// first build up local contributions to parent_processor_ids
MeshBase::element_iterator not_it = mesh.ancestor_elements_begin();
const MeshBase::element_iterator not_end = mesh.ancestor_elements_end();
bool have_parent_in_block = false;
for ( ; not_it != not_end; ++not_it)
{
Elem * parent = *not_it;
const dof_id_type parent_idx = parent->id();
libmesh_assert_less (parent_idx, max_elem_id);
if ((parent_idx >= first_elem_id) &&
(parent_idx < last_elem_id))
{
have_parent_in_block = true;
processor_id_type parent_pid = DofObject::invalid_processor_id;
std::vector<const Elem *> active_family;
parent->active_family_tree(active_family);
for (unsigned int i = 0; i != active_family.size(); ++i)
parent_pid = std::min (parent_pid, active_family[i]->processor_id());
const dof_id_type packed_idx = parent_idx - first_elem_id;
libmesh_assert_less (packed_idx, parent_processor_ids.size());
parent_processor_ids[packed_idx] = parent_pid;
}
}
// then find the global minimum
mesh.comm().min (parent_processor_ids);
// and assign the ids, if we have a parent in this block.
if (have_parent_in_block)
for (not_it = mesh.ancestor_elements_begin();
not_it != not_end; ++not_it)
{
Elem * parent = *not_it;
const dof_id_type parent_idx = parent->id();
if ((parent_idx >= first_elem_id) &&
(parent_idx < last_elem_id))
{
const dof_id_type packed_idx = parent_idx - first_elem_id;
libmesh_assert_less (packed_idx, parent_processor_ids.size());
const processor_id_type parent_pid =
parent_processor_ids[packed_idx];
libmesh_assert_not_equal_to (parent_pid, DofObject::invalid_processor_id);
parent->processor_id() = parent_pid;
}
}
}
}
#endif // LIBMESH_ENABLE_AMR
}
bool MeshRefinement::flag_elements_by_nelem_target (const ErrorVector& error_per_cell)
{
parallel_only();
// Check for valid fractions..
// The fraction values must be in [0,1]
libmesh_assert_greater_equal (_refine_fraction, 0);
libmesh_assert_less_equal (_refine_fraction, 1);
libmesh_assert_greater_equal (_coarsen_fraction, 0);
libmesh_assert_less_equal (_coarsen_fraction, 1);
// This function is currently only coded to work when coarsening by
// parents - it's too hard to guess how many coarsenings will be
// performed otherwise.
libmesh_assert (_coarsen_by_parents);
// The number of active elements in the mesh - hopefully less than
// 2 billion on 32 bit machines
const unsigned int n_active_elem = _mesh.n_active_elem();
// The maximum number of active elements to flag for coarsening
const unsigned int max_elem_coarsen =
static_cast<unsigned int>(_coarsen_fraction * n_active_elem) + 1;
// The maximum number of elements to flag for refinement
const unsigned int max_elem_refine =
static_cast<unsigned int>(_refine_fraction * n_active_elem) + 1;
// Clean up the refinement flags. These could be left
// over from previous refinement steps.
this->clean_refinement_flags();
// The target number of elements to add or remove
const int n_elem_new = _nelem_target - n_active_elem;
// Create an vector with active element errors and ids,
// sorted by highest errors first
const unsigned int max_elem_id = _mesh.max_elem_id();
std::vector<std::pair<float, unsigned int> > sorted_error;
sorted_error.reserve (n_active_elem);
// On a ParallelMesh, we need to communicate to know which remote ids
// correspond to active elements.
{
std::vector<bool> is_active(max_elem_id, false);
MeshBase::element_iterator elem_it = _mesh.active_local_elements_begin();
const MeshBase::element_iterator elem_end = _mesh.active_local_elements_end();
for (; elem_it != elem_end; ++elem_it)
{
const unsigned int eid = (*elem_it)->id();
is_active[eid] = true;
libmesh_assert_less (eid, error_per_cell.size());
sorted_error.push_back
(std::make_pair(error_per_cell[eid], eid));
}
CommWorld.max(is_active);
CommWorld.allgather(sorted_error);
}
// Default sort works since pairs are sorted lexicographically
std::sort (sorted_error.begin(), sorted_error.end());
std::reverse (sorted_error.begin(), sorted_error.end());
// Create a sorted error vector with coarsenable parent elements
// only, sorted by lowest errors first
ErrorVector error_per_parent;
std::vector<std::pair<float, unsigned int> > sorted_parent_error;
Real parent_error_min, parent_error_max;
create_parent_error_vector(error_per_cell,
error_per_parent,
parent_error_min,
parent_error_max);
// create_parent_error_vector sets values for non-parents and
// non-coarsenable parents to -1. Get rid of them.
for (unsigned int i=0; i != error_per_parent.size(); ++i)
if (error_per_parent[i] != -1)
sorted_parent_error.push_back(std::make_pair(error_per_parent[i], i));
std::sort (sorted_parent_error.begin(), sorted_parent_error.end());
// Keep track of how many elements we plan to coarsen & refine
unsigned int coarsen_count = 0;
unsigned int refine_count = 0;
const unsigned int dim = _mesh.mesh_dimension();
unsigned int twotodim = 1;
for (unsigned int i=0; i!=dim; ++i)
twotodim *= 2;
// First, let's try to get our element count to target_nelem
if (n_elem_new >= 0)
{
// Every element refinement creates at least
// 2^dim-1 new elements
refine_count =
std::min(static_cast<unsigned int>(n_elem_new / (twotodim-1)),
max_elem_refine);
}
else
{
// Every successful element coarsening is likely to destroy
// 2^dim-1 net elements.
coarsen_count =
std::min(static_cast<unsigned int>(-n_elem_new / (twotodim-1)),
max_elem_coarsen);
}
// Next, let's see if we can trade any refinement for coarsening
while (coarsen_count < max_elem_coarsen &&
refine_count < max_elem_refine &&
coarsen_count < sorted_parent_error.size() &&
refine_count < sorted_error.size() &&
sorted_error[refine_count].first >
sorted_parent_error[coarsen_count].first * _coarsen_threshold)
{
coarsen_count++;
refine_count++;
}
// On a ParallelMesh, we need to communicate to know which remote ids
// correspond to refinable elements
unsigned int successful_refine_count = 0;
{
std::vector<bool> is_refinable(max_elem_id, false);
for (unsigned int i=0; i != sorted_error.size(); ++i)
{
unsigned int eid = sorted_error[i].second;
Elem *elem = _mesh.query_elem(eid);
if (elem && elem->level() < _max_h_level)
is_refinable[eid] = true;
}
CommWorld.max(is_refinable);
if (refine_count > max_elem_refine)
refine_count = max_elem_refine;
for (unsigned int i=0; i != sorted_error.size(); ++i)
{
if (successful_refine_count >= refine_count)
break;
unsigned int eid = sorted_error[i].second;
Elem *elem = _mesh.query_elem(eid);
if (is_refinable[eid])
{
if (elem)
elem->set_refinement_flag(Elem::REFINE);
successful_refine_count++;
}
}
}
// If we couldn't refine enough elements, don't coarsen too many
// either
if (coarsen_count < (refine_count - successful_refine_count))
coarsen_count = 0;
else
coarsen_count -= (refine_count - successful_refine_count);
if (coarsen_count > max_elem_coarsen)
coarsen_count = max_elem_coarsen;
unsigned int successful_coarsen_count = 0;
if (coarsen_count)
{
for (unsigned int i=0; i != sorted_parent_error.size(); ++i)
{
if (successful_coarsen_count >= coarsen_count * twotodim)
break;
unsigned int parent_id = sorted_parent_error[i].second;
Elem *parent = _mesh.query_elem(parent_id);
// On a ParallelMesh we skip remote elements
if (!parent)
continue;
libmesh_assert(parent->has_children());
for (unsigned int c=0; c != parent->n_children(); ++c)
{
Elem *elem = parent->child(c);
if (elem && elem != remote_elem)
{
libmesh_assert(elem->active());
elem->set_refinement_flag(Elem::COARSEN);
successful_coarsen_count++;
}
}
}
}
// Return true if we've done all the AMR/C we can
if (!successful_coarsen_count &&
!successful_refine_count)
return true;
// And false if there may still be more to do.
return false;
}
void UnstructuredMesh::find_neighbors (const bool reset_remote_elements,
const bool reset_current_list)
{
// We might actually want to run this on an empty mesh
// (e.g. the boundary mesh for a nonexistant bcid!)
// libmesh_assert_not_equal_to (this->n_nodes(), 0);
// libmesh_assert_not_equal_to (this->n_elem(), 0);
// This function must be run on all processors at once
parallel_object_only();
LOG_SCOPE("find_neighbors()", "Mesh");
const element_iterator el_end = this->elements_end();
//TODO:[BSK] This should be removed later?!
if (reset_current_list)
for (element_iterator el = this->elements_begin(); el != el_end; ++el)
{
Elem * e = *el;
for (unsigned int s=0; s<e->n_neighbors(); s++)
if (e->neighbor_ptr(s) != remote_elem ||
reset_remote_elements)
e->set_neighbor(s, libmesh_nullptr);
}
// Find neighboring elements by first finding elements
// with identical side keys and then check to see if they
// are neighbors
{
// data structures -- Use the hash_multimap if available
typedef unsigned int key_type;
typedef std::pair<Elem *, unsigned char> val_type;
typedef std::pair<key_type, val_type> key_val_pair;
typedef LIBMESH_BEST_UNORDERED_MULTIMAP<key_type, val_type> map_type;
// A map from side keys to corresponding elements & side numbers
map_type side_to_elem_map;
for (element_iterator el = this->elements_begin(); el != el_end; ++el)
{
Elem * element = *el;
for (unsigned char ms=0; ms<element->n_neighbors(); ms++)
{
next_side:
// If we haven't yet found a neighbor on this side, try.
// Even if we think our neighbor is remote, that
// information may be out of date.
if (element->neighbor_ptr(ms) == libmesh_nullptr ||
element->neighbor_ptr(ms) == remote_elem)
{
// Get the key for the side of this element
const unsigned int key = element->key(ms);
// Look for elements that have an identical side key
std::pair <map_type::iterator, map_type::iterator>
bounds = side_to_elem_map.equal_range(key);
// May be multiple keys, check all the possible
// elements which _might_ be neighbors.
if (bounds.first != bounds.second)
{
// Get the side for this element
const UniquePtr<Elem> my_side(element->side_ptr(ms));
// Look at all the entries with an equivalent key
while (bounds.first != bounds.second)
{
// Get the potential element
Elem * neighbor = bounds.first->second.first;
// Get the side for the neighboring element
const unsigned int ns = bounds.first->second.second;
const UniquePtr<Elem> their_side(neighbor->side_ptr(ns));
//libmesh_assert(my_side.get());
//libmesh_assert(their_side.get());
// If found a match with my side
//
// We need special tests here for 1D:
// since parents and children have an equal
// side (i.e. a node), we need to check
// ns != ms, and we also check level() to
// avoid setting our neighbor pointer to
// any of our neighbor's descendants
if( (*my_side == *their_side) &&
(element->level() == neighbor->level()) &&
((element->dim() != 1) || (ns != ms)) )
{
// So share a side. Is this a mixed pair
// of subactive and active/ancestor
// elements?
// If not, then we're neighbors.
// If so, then the subactive's neighbor is
if (element->subactive() ==
neighbor->subactive())
{
// an element is only subactive if it has
// been coarsened but not deleted
element->set_neighbor (ms,neighbor);
neighbor->set_neighbor(ns,element);
}
else if (element->subactive())
{
element->set_neighbor(ms,neighbor);
}
else if (neighbor->subactive())
{
neighbor->set_neighbor(ns,element);
}
side_to_elem_map.erase (bounds.first);
// get out of this nested crap
goto next_side;
}
++bounds.first;
}
}
// didn't find a match...
// Build the map entry for this element
key_val_pair kvp;
kvp.first = key;
kvp.second.first = element;
kvp.second.second = ms;
// use the lower bound as a hint for
// where to put it.
#if defined(LIBMESH_HAVE_UNORDERED_MAP) || defined(LIBMESH_HAVE_TR1_UNORDERED_MAP) || defined(LIBMESH_HAVE_HASH_MAP) || defined(LIBMESH_HAVE_EXT_HASH_MAP)
side_to_elem_map.insert (kvp);
#else
side_to_elem_map.insert (bounds.first,kvp);
#endif
}
}
}
}
#ifdef LIBMESH_ENABLE_AMR
/**
* Here we look at all of the child elements which
* don't already have valid neighbors.
*
* If a child element has a NULL neighbor it is
* either because it is on the boundary or because
* its neighbor is at a different level. In the
* latter case we must get the neighbor from the
* parent.
*
* If a child element has a remote_elem neighbor
* on a boundary it shares with its parent, that
* info may have become out-dated through coarsening
* of the neighbor's parent. In this case, if the
* parent's neighbor is active then the child should
* share it.
*
* Furthermore, that neighbor better be active,
* otherwise we missed a child somewhere.
*
*
* We also need to look through children ordered by increasing
* refinement level in order to add new interior_parent() links in
* boundary elements which have just been generated by refinement,
* and fix links in boundary elements whose previous
* interior_parent() has just been coarsened away.
*/
const unsigned int n_levels = MeshTools::n_levels(*this);
for (unsigned int level = 1; level < n_levels; ++level)
{
element_iterator end = this->level_elements_end(level);
for (element_iterator el = this->level_elements_begin(level);
el != end; ++el)
{
Elem * current_elem = *el;
libmesh_assert(current_elem);
Elem * parent = current_elem->parent();
libmesh_assert(parent);
const unsigned int my_child_num = parent->which_child_am_i(current_elem);
for (unsigned int s=0; s < current_elem->n_neighbors(); s++)
{
if (current_elem->neighbor_ptr(s) == libmesh_nullptr ||
(current_elem->neighbor_ptr(s) == remote_elem &&
parent->is_child_on_side(my_child_num, s)))
{
Elem * neigh = parent->neighbor_ptr(s);
// If neigh was refined and had non-subactive children
// made remote earlier, then a non-subactive elem should
// actually have one of those remote children as a
// neighbor
if (neigh && (neigh->ancestor()) && (!current_elem->subactive()))
{
#ifdef DEBUG
// Let's make sure that "had children made remote"
// situation is actually the case
libmesh_assert(neigh->has_children());
bool neigh_has_remote_children = false;
for (unsigned int c = 0; c != neigh->n_children(); ++c)
{
if (neigh->child_ptr(c) == remote_elem)
neigh_has_remote_children = true;
}
libmesh_assert(neigh_has_remote_children);
// And let's double-check that we don't have
// a remote_elem neighboring a local element
libmesh_assert_not_equal_to (current_elem->processor_id(),
this->processor_id());
#endif // DEBUG
neigh = const_cast<RemoteElem *>(remote_elem);
}
if (!current_elem->subactive())
current_elem->set_neighbor(s, neigh);
#ifdef DEBUG
if (neigh != libmesh_nullptr && neigh != remote_elem)
// We ignore subactive elements here because
// we don't care about neighbors of subactive element.
if ((!neigh->active()) && (!current_elem->subactive()))
{
libMesh::err << "On processor " << this->processor_id()
<< std::endl;
libMesh::err << "Bad element ID = " << current_elem->id()
<< ", Side " << s << ", Bad neighbor ID = " << neigh->id() << std::endl;
libMesh::err << "Bad element proc_ID = " << current_elem->processor_id()
<< ", Bad neighbor proc_ID = " << neigh->processor_id() << std::endl;
libMesh::err << "Bad element size = " << current_elem->hmin()
<< ", Bad neighbor size = " << neigh->hmin() << std::endl;
libMesh::err << "Bad element center = " << current_elem->centroid()
<< ", Bad neighbor center = " << neigh->centroid() << std::endl;
libMesh::err << "ERROR: "
<< (current_elem->active()?"Active":"Ancestor")
<< " Element at level "
<< current_elem->level() << std::endl;
libMesh::err << "with "
<< (parent->active()?"active":
(parent->subactive()?"subactive":"ancestor"))
<< " parent share "
<< (neigh->subactive()?"subactive":"ancestor")
<< " neighbor at level " << neigh->level()
<< std::endl;
NameBasedIO(*this).write ("bad_mesh.gmv");
libmesh_error_msg("Problematic mesh written to bad_mesh.gmv.");
}
#endif // DEBUG
}
}
// We can skip to the next element if we're full-dimension
// and therefore don't have any interior parents
if (current_elem->dim() >= LIBMESH_DIM)
continue;
// We have no interior parents unless we can find one later
current_elem->set_interior_parent(libmesh_nullptr);
Elem * pip = parent->interior_parent();
if (!pip)
continue;
// If there's no interior_parent children, whether due to a
// remote element or a non-conformity, then there's no
// children to search.
if (pip == remote_elem || pip->active())
{
current_elem->set_interior_parent(pip);
continue;
}
// For node comparisons we'll need a sensible tolerance
Real node_tolerance = current_elem->hmin() * TOLERANCE;
// Otherwise our interior_parent should be a child of our
// parent's interior_parent.
for (unsigned int c=0; c != pip->n_children(); ++c)
{
Elem * child = pip->child_ptr(c);
// If we have a remote_elem, that might be our
// interior_parent. We'll set it provisionally now and
// keep trying to find something better.
if (child == remote_elem)
{
current_elem->set_interior_parent
(const_cast<RemoteElem *>(remote_elem));
continue;
}
bool child_contains_our_nodes = true;
for (unsigned int n=0; n != current_elem->n_nodes();
++n)
{
bool child_contains_this_node = false;
for (unsigned int cn=0; cn != child->n_nodes();
++cn)
if (child->point(cn).absolute_fuzzy_equals
(current_elem->point(n), node_tolerance))
{
child_contains_this_node = true;
break;
}
if (!child_contains_this_node)
{
child_contains_our_nodes = false;
break;
}
}
if (child_contains_our_nodes)
{
current_elem->set_interior_parent(child);
break;
}
}
// We should have found *some* interior_parent at this
// point, whether semilocal or remote.
libmesh_assert(current_elem->interior_parent());
}
}
#endif // AMR
#ifdef DEBUG
MeshTools::libmesh_assert_valid_neighbors(*this,
!reset_remote_elements);
MeshTools::libmesh_assert_valid_amr_interior_parents(*this);
#endif
}
void unpack(std::vector<largest_id_type>::const_iterator in,
Elem** out,
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 =
static_cast<unsigned int>(*in++);
#ifdef LIBMESH_ENABLE_AMR
// int 1: p level
const unsigned int p_level =
static_cast<unsigned int>(*in++);
// int 2: refinement flag
const int rflag = *in++;
libmesh_assert_greater_equal (rflag, 0);
libmesh_assert_less (rflag, Elem::INVALID_REFINEMENTSTATE);
const Elem::RefinementState refinement_flag =
static_cast<Elem::RefinementState>(rflag);
// int 3: p refinement flag
const int pflag = *in++;
libmesh_assert_greater_equal (pflag, 0);
libmesh_assert_less (pflag, Elem::INVALID_REFINEMENTSTATE);
const Elem::RefinementState p_refinement_flag =
static_cast<Elem::RefinementState>(pflag);
#else
in += 3;
#endif // LIBMESH_ENABLE_AMR
// int 4: element type
const int typeint = *in++;
libmesh_assert_greater_equal (typeint, 0);
libmesh_assert_less (typeint, INVALID_ELEM);
const ElemType type =
static_cast<ElemType>(typeint);
const unsigned int n_nodes =
Elem::type_to_n_nodes_map[type];
// int 5: processor id
const processor_id_type processor_id =
static_cast<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 =
static_cast<subdomain_id_type>(*in++);
// int 7: dof object id
const dof_id_type id =
static_cast<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 =
static_cast<unique_id_type>(*in++);
#endif
#ifdef LIBMESH_ENABLE_AMR
// int 9: parent dof object id
const dof_id_type parent_id =
static_cast<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
const unsigned int which_child_am_i =
static_cast<unsigned int>(*in++);
#else
in += 2;
#endif // LIBMESH_ENABLE_AMR
// 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(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 unqiue 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(i) ==
static_cast<dof_id_type>(*in++));
#else
in += n_nodes;
#endif
#ifdef LIBMESH_ENABLE_AMR
libmesh_assert_equal_to (elem->p_level(), p_level);
libmesh_assert_equal_to (elem->refinement_flag(), refinement_flag);
libmesh_assert_equal_to (elem->p_refinement_flag(), p_refinement_flag);
libmesh_assert (!level || elem->parent() != NULL);
libmesh_assert (!level || elem->parent()->id() == parent_id);
libmesh_assert (!level || elem->parent()->child(which_child_am_i) == elem);
#endif
// Our neighbor links should be "close to" correct - we may have
// to update them, but we can check for some inconsistencies.
for (unsigned int n=0; n != elem->n_neighbors(); ++n)
{
const dof_id_type neighbor_id =
static_cast<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(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(n));
continue;
}
Elem *neigh = mesh->query_elem(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(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(n) == neigh ||
elem->neighbor(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(n) == remote_elem)
{
elem->set_neighbor(n, neigh);
elem->make_links_to_me_local(n);
}
}
// 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 = NULL;
#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(parent_id);
}
// Or assert that the sending processor sees no parent
else
libmesh_assert_equal_to (parent_id, static_cast<dof_id_type>(-1));
#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(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 definitely should have children, assign
// remote_elem to all of them for now, for consistency. Later
// unpacked elements may overwrite that.
if (!elem->active())
for (unsigned int c=0; c != elem->n_children(); ++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
(static_cast<dof_id_type>(*in++));
for (unsigned int n=0; n<elem->n_neighbors(); n++)
{
const dof_id_type neighbor_id =
static_cast<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(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 boundary condition ids
if (level == 0)
for (unsigned int s = 0; s != elem->n_sides(); ++s)
{
const int num_bcs = *in++;
libmesh_assert_greater_equal (num_bcs, 0);
for(int bc_it=0; bc_it < num_bcs; bc_it++)
mesh->boundary_info->add_side (elem, s, *in++);
}
// Return the new element
*out = elem;
}
void
MaterialPropertyStorage::prolongStatefulProps(const std::vector<std::vector<QpMap> > & refinement_map,
QBase & qrule,
QBase & qrule_face,
MaterialPropertyStorage & parent_material_props,
MaterialData & child_material_data,
const Elem & elem,
const int input_parent_side,
const int input_child,
const int input_child_side)
{
mooseAssert(input_child != -1 || input_parent_side == input_child_side, "Invalid inputs!");
unsigned int n_qpoints = 0;
// If we passed in -1 for these then we really need to store properties at 0
unsigned int parent_side = input_parent_side == -1 ? 0 : input_parent_side;
unsigned int child_side = input_child_side == -1 ? 0 : input_child_side;
if (input_child_side == -1) // Not doing side projection (ie, doing volume projection)
n_qpoints = qrule.n_points();
else
n_qpoints = qrule_face.n_points();
child_material_data.size(n_qpoints);
unsigned int n_children = elem.n_children();
std::vector<unsigned int> children;
if (input_child != -1) // Passed in a child explicitly
children.push_back(input_child);
else
{
children.resize(n_children);
for (unsigned int child=0; child < n_children; child++)
children[child] = child;
}
for (const auto & child : children)
{
// If we're not projecting an internal child side, but we are projecting sides, see if this child is on that side
if (input_child == -1 && input_child_side != -1 && !elem.is_child_on_side(child, parent_side))
continue;
const Elem * child_elem = elem.child(child);
mooseAssert(child < refinement_map.size(), "Refinement_map vector not initialized");
const std::vector<QpMap> & child_map = refinement_map[child];
if (props()[child_elem][child_side].size() == 0) props()[child_elem][child_side].resize(_stateful_prop_id_to_prop_id.size());
if (propsOld()[child_elem][child_side].size() == 0) propsOld()[child_elem][child_side].resize(_stateful_prop_id_to_prop_id.size());
if (propsOlder()[child_elem][child_side].size() == 0) propsOlder()[child_elem][child_side].resize(_stateful_prop_id_to_prop_id.size());
// init properties (allocate memory. etc)
for (unsigned int i=0; i < _stateful_prop_id_to_prop_id.size(); ++i)
{
// duplicate the stateful property in property storage (all three states - we will reuse the allocated memory there)
// also allocating the right amount of memory, so we do not have to resize, etc.
if (props()[child_elem][child_side][i] == NULL) props()[child_elem][child_side][i] = child_material_data.props()[ _stateful_prop_id_to_prop_id[i] ]->init(n_qpoints);
if (propsOld()[child_elem][child_side][i] == NULL) propsOld()[child_elem][child_side][i] = child_material_data.propsOld()[ _stateful_prop_id_to_prop_id[i] ]->init(n_qpoints);
if (hasOlderProperties())
if (propsOlder()[child_elem][child_side][i] == NULL) propsOlder()[child_elem][child_side][i] = child_material_data.propsOlder()[ _stateful_prop_id_to_prop_id[i] ]->init(n_qpoints);
// Copy from the parent stateful properties
for (unsigned int qp=0; qp<refinement_map[child].size(); qp++)
{
PropertyValue * child_property = props()[child_elem][child_side][i];
mooseAssert(props().contains(&elem), "Parent pointer is not in the MaterialProps data structure");
PropertyValue * parent_property = parent_material_props.props()[&elem][parent_side][i];
child_property->qpCopy(qp, parent_property, child_map[qp]._to);
propsOld()[child_elem][child_side][i]->qpCopy(qp, parent_material_props.propsOld()[&elem][parent_side][i], child_map[qp]._to);
if (hasOlderProperties())
propsOlder()[child_elem][child_side][i]->qpCopy(qp, parent_material_props.propsOlder()[&elem][parent_side][i], child_map[qp]._to);
}
}
}
}
bool MeshRefinement::eliminate_unrefined_patches ()
{
// This function must be run on all processors at once
parallel_only();
bool flags_changed = false;
MeshBase::element_iterator elem_it = _mesh.active_elements_begin();
const MeshBase::element_iterator elem_end = _mesh.active_elements_end();
for (; elem_it != elem_end; ++elem_it)
{
Elem* elem = *elem_it;
// First assume that we'll have to flag this element for both h
// and p refinement, then change our minds if we see any
// neighbors that are as coarse or coarser than us.
bool h_flag_me = true,
p_flag_me = true;
// Skip the element if it is already fully flagged for refinement
if (elem->p_refinement_flag() == Elem::REFINE)
p_flag_me = false;
if (elem->refinement_flag() == Elem::REFINE)
{
h_flag_me = false;
if (!p_flag_me)
continue;
}
// Test the parent if that is already flagged for coarsening
else if (elem->refinement_flag() == Elem::COARSEN)
{
libmesh_assert(elem->parent());
elem = elem->parent();
// FIXME - this doesn't seem right - RHS
if (elem->refinement_flag() != Elem::COARSEN_INACTIVE)
continue;
p_flag_me = false;
}
const unsigned int my_level = elem->level();
int my_p_adjustment = 0;
if (elem->p_refinement_flag() == Elem::REFINE)
my_p_adjustment = 1;
else if (elem->p_refinement_flag() == Elem::COARSEN)
{
libmesh_assert_greater (elem->p_level(), 0);
my_p_adjustment = -1;
}
const unsigned int my_new_p_level = elem->p_level() +
my_p_adjustment;
// Check all the element neighbors
for (unsigned int n=0; n<elem->n_neighbors(); n++)
{
const Elem *neighbor = elem->neighbor(n);
// Quit if the element is on a local boundary
if (neighbor == NULL || neighbor == remote_elem)
{
h_flag_me = false;
p_flag_me = false;
break;
}
// if the neighbor will be equally or less refined than
// we are, then we will not become an unrefined island.
// So if we are still considering h refinement:
if (h_flag_me &&
// If our neighbor is already at a lower level,
// it can't end up at a higher level even if it
// is flagged for refinement once
((neighbor->level() < my_level) ||
// If our neighbor is at the same level but isn't
// flagged for refinement, it won't end up at a
// higher level
((neighbor->active()) &&
(neighbor->refinement_flag() != Elem::REFINE)) ||
// If our neighbor is currently more refined but is
// a parent flagged for coarsening, it will end up
// at the same level.
(neighbor->refinement_flag() == Elem::COARSEN_INACTIVE)))
{
// We've proven we won't become an unrefined island,
// so don't h refine to avoid that.
h_flag_me = false;
// If we've also proven we don't need to p refine,
// we don't need to check more neighbors
if (!p_flag_me)
break;
}
if (p_flag_me)
{
// if active neighbors will have a p level
// equal to or lower than ours, then we do not need to p
// refine ourselves.
if (neighbor->active())
{
int p_adjustment = 0;
if (neighbor->p_refinement_flag() == Elem::REFINE)
p_adjustment = 1;
else if (neighbor->p_refinement_flag() == Elem::COARSEN)
{
libmesh_assert_greater (neighbor->p_level(), 0);
p_adjustment = -1;
}
if (my_new_p_level >= neighbor->p_level() + p_adjustment)
{
p_flag_me = false;
if (!h_flag_me)
break;
}
}
// If we have inactive neighbors, we need to
// test all their active descendants which neighbor us
else if (neighbor->ancestor())
{
if (neighbor->min_new_p_level_by_neighbor(elem,
my_new_p_level + 2) <= my_new_p_level)
{
p_flag_me = false;
if (!h_flag_me)
break;
}
}
}
}
if (h_flag_me)
{
// Parents that would create islands should no longer
// coarsen
if (elem->refinement_flag() == Elem::COARSEN_INACTIVE)
{
for (unsigned int c=0; c<elem->n_children(); c++)
{
libmesh_assert_equal_to (elem->child(c)->refinement_flag(),
Elem::COARSEN);
elem->child(c)->set_refinement_flag(Elem::DO_NOTHING);
}
elem->set_refinement_flag(Elem::INACTIVE);
}
else
elem->set_refinement_flag(Elem::REFINE);
flags_changed = true;
}
if (p_flag_me)
{
if (elem->p_refinement_flag() == Elem::COARSEN)
elem->set_p_refinement_flag(Elem::DO_NOTHING);
else
elem->set_p_refinement_flag(Elem::REFINE);
flags_changed = true;
}
}
// If flags changed on any processor then they changed globally
CommWorld.max(flags_changed);
return flags_changed;
}
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;
}
void HPCoarsenTest::select_refinement (System & system)
{
START_LOG("select_refinement()", "HPCoarsenTest");
// The current mesh
MeshBase & mesh = system.get_mesh();
// The dimensionality of the mesh
const unsigned int dim = mesh.mesh_dimension();
// The number of variables in the system
const unsigned int n_vars = system.n_vars();
// The DofMap for this system
const DofMap & dof_map = system.get_dof_map();
// The system number (for doing bad hackery)
const unsigned int sys_num = system.number();
// Check for a valid component_scale
if (!component_scale.empty())
{
if (component_scale.size() != n_vars)
libmesh_error_msg("ERROR: component_scale is the wrong size:\n" \
<< " component_scale.size()=" \
<< component_scale.size() \
<< "\n n_vars=" \
<< n_vars);
}
else
{
// No specified scaling. Scale all variables by one.
component_scale.resize (n_vars, 1.0);
}
// Resize the error_per_cell vectors to handle
// the number of elements, initialize them to 0.
std::vector<ErrorVectorReal> h_error_per_cell(mesh.max_elem_id(), 0.);
std::vector<ErrorVectorReal> p_error_per_cell(mesh.max_elem_id(), 0.);
// Loop over all the variables in the system
for (unsigned int var=0; var<n_vars; var++)
{
// Possibly skip this variable
if (!component_scale.empty())
if (component_scale[var] == 0.0) continue;
// The type of finite element to use for this variable
const FEType & fe_type = dof_map.variable_type (var);
// Finite element objects for a fine (and probably a coarse)
// element will be needed
fe = FEBase::build (dim, fe_type);
fe_coarse = FEBase::build (dim, fe_type);
// Any cached coarse element results have expired
coarse = libmesh_nullptr;
unsigned int cached_coarse_p_level = 0;
const FEContinuity cont = fe->get_continuity();
libmesh_assert (cont == DISCONTINUOUS || cont == C_ZERO ||
cont == C_ONE);
// Build an appropriate quadrature rule
qrule = fe_type.default_quadrature_rule(dim);
// Tell the refined finite element about the quadrature
// rule. The coarse finite element need not know about it
fe->attach_quadrature_rule (qrule.get());
// We will always do the integration
// on the fine elements. Get their Jacobian values, etc..
JxW = &(fe->get_JxW());
xyz_values = &(fe->get_xyz());
// The shape functions
phi = &(fe->get_phi());
phi_coarse = &(fe_coarse->get_phi());
// The shape function derivatives
if (cont == C_ZERO || cont == C_ONE)
{
dphi = &(fe->get_dphi());
dphi_coarse = &(fe_coarse->get_dphi());
}
#ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
// The shape function second derivatives
if (cont == C_ONE)
{
d2phi = &(fe->get_d2phi());
d2phi_coarse = &(fe_coarse->get_d2phi());
}
#endif // defined (LIBMESH_ENABLE_SECOND_DERIVATIVES)
// Iterate over all the active elements in the mesh
// that live on this processor.
MeshBase::const_element_iterator elem_it =
mesh.active_local_elements_begin();
const MeshBase::const_element_iterator elem_end =
mesh.active_local_elements_end();
for (; elem_it != elem_end; ++elem_it)
{
const Elem * elem = *elem_it;
// We're only checking elements that are already flagged for h
// refinement
if (elem->refinement_flag() != Elem::REFINE)
continue;
const dof_id_type e_id = elem->id();
// Find the projection onto the parent element,
// if necessary
if (elem->parent() &&
(coarse != elem->parent() ||
cached_coarse_p_level != elem->p_level()))
{
Uc.resize(0);
coarse = elem->parent();
cached_coarse_p_level = elem->p_level();
unsigned int old_parent_level = coarse->p_level();
(const_cast<Elem *>(coarse))->hack_p_level(elem->p_level());
this->add_projection(system, coarse, var);
(const_cast<Elem *>(coarse))->hack_p_level(old_parent_level);
// Solve the h-coarsening projection problem
Ke.cholesky_solve(Fe, Uc);
}
fe->reinit(elem);
// Get the DOF indices for the fine element
dof_map.dof_indices (elem, dof_indices, var);
// The number of quadrature points
const unsigned int n_qp = qrule->n_points();
// The number of DOFS on the fine element
const unsigned int n_dofs =
cast_int<unsigned int>(dof_indices.size());
// The number of nodes on the fine element
const unsigned int n_nodes = elem->n_nodes();
// The average element value (used as an ugly hack
// when we have nothing p-coarsened to compare to)
// Real average_val = 0.;
Number average_val = 0.;
// Calculate this variable's contribution to the p
// refinement error
if (elem->p_level() == 0)
{
unsigned int n_vertices = 0;
for (unsigned int n = 0; n != n_nodes; ++n)
if (elem->is_vertex(n))
{
n_vertices++;
const Node * const node = elem->get_node(n);
average_val += system.current_solution
(node->dof_number(sys_num,var,0));
}
average_val /= n_vertices;
}
else
{
unsigned int old_elem_level = elem->p_level();
(const_cast<Elem *>(elem))->hack_p_level(old_elem_level - 1);
fe_coarse->reinit(elem, &(qrule->get_points()));
const unsigned int n_coarse_dofs =
cast_int<unsigned int>(phi_coarse->size());
(const_cast<Elem *>(elem))->hack_p_level(old_elem_level);
Ke.resize(n_coarse_dofs, n_coarse_dofs);
Ke.zero();
Fe.resize(n_coarse_dofs);
Fe.zero();
// Loop over the quadrature points
for (unsigned int qp=0; qp<qrule->n_points(); qp++)
{
// The solution value at the quadrature point
Number val = libMesh::zero;
Gradient grad;
Tensor hess;
for (unsigned int i=0; i != n_dofs; i++)
{
dof_id_type dof_num = dof_indices[i];
val += (*phi)[i][qp] *
system.current_solution(dof_num);
if (cont == C_ZERO || cont == C_ONE)
grad.add_scaled((*dphi)[i][qp], system.current_solution(dof_num));
// grad += (*dphi)[i][qp] *
// system.current_solution(dof_num);
if (cont == C_ONE)
hess.add_scaled((*d2phi)[i][qp], system.current_solution(dof_num));
// hess += (*d2phi)[i][qp] *
// system.current_solution(dof_num);
}
// The projection matrix and vector
for (unsigned int i=0; i != Fe.size(); ++i)
{
Fe(i) += (*JxW)[qp] *
(*phi_coarse)[i][qp]*val;
if (cont == C_ZERO || cont == C_ONE)
Fe(i) += (*JxW)[qp] *
grad * (*dphi_coarse)[i][qp];
if (cont == C_ONE)
Fe(i) += (*JxW)[qp] *
hess.contract((*d2phi_coarse)[i][qp]);
for (unsigned int j=0; j != Fe.size(); ++j)
{
Ke(i,j) += (*JxW)[qp] *
(*phi_coarse)[i][qp]*(*phi_coarse)[j][qp];
if (cont == C_ZERO || cont == C_ONE)
Ke(i,j) += (*JxW)[qp] *
(*dphi_coarse)[i][qp]*(*dphi_coarse)[j][qp];
if (cont == C_ONE)
Ke(i,j) += (*JxW)[qp] *
((*d2phi_coarse)[i][qp].contract((*d2phi_coarse)[j][qp]));
}
}
}
// Solve the p-coarsening projection problem
Ke.cholesky_solve(Fe, Up);
}
// loop over the integration points on the fine element
for (unsigned int qp=0; qp<n_qp; qp++)
{
Number value_error = 0.;
Gradient grad_error;
Tensor hessian_error;
for (unsigned int i=0; i<n_dofs; i++)
{
const dof_id_type dof_num = dof_indices[i];
value_error += (*phi)[i][qp] *
system.current_solution(dof_num);
if (cont == C_ZERO || cont == C_ONE)
grad_error.add_scaled((*dphi)[i][qp], system.current_solution(dof_num));
// grad_error += (*dphi)[i][qp] *
// system.current_solution(dof_num);
if (cont == C_ONE)
hessian_error.add_scaled((*d2phi)[i][qp], system.current_solution(dof_num));
// hessian_error += (*d2phi)[i][qp] *
// system.current_solution(dof_num);
}
if (elem->p_level() == 0)
{
value_error -= average_val;
}
else
{
for (unsigned int i=0; i<Up.size(); i++)
{
value_error -= (*phi_coarse)[i][qp] * Up(i);
if (cont == C_ZERO || cont == C_ONE)
grad_error.subtract_scaled((*dphi_coarse)[i][qp], Up(i));
// grad_error -= (*dphi_coarse)[i][qp] * Up(i);
if (cont == C_ONE)
hessian_error.subtract_scaled((*d2phi_coarse)[i][qp], Up(i));
// hessian_error -= (*d2phi_coarse)[i][qp] * Up(i);
}
}
p_error_per_cell[e_id] += static_cast<ErrorVectorReal>
(component_scale[var] *
(*JxW)[qp] * TensorTools::norm_sq(value_error));
if (cont == C_ZERO || cont == C_ONE)
p_error_per_cell[e_id] += static_cast<ErrorVectorReal>
(component_scale[var] *
(*JxW)[qp] * grad_error.norm_sq());
if (cont == C_ONE)
p_error_per_cell[e_id] += static_cast<ErrorVectorReal>
(component_scale[var] *
(*JxW)[qp] * hessian_error.norm_sq());
}
// Calculate this variable's contribution to the h
// refinement error
if (!elem->parent())
{
// For now, we'll always start with an h refinement
h_error_per_cell[e_id] =
std::numeric_limits<ErrorVectorReal>::max() / 2;
}
else
{
FEInterface::inverse_map (dim, fe_type, coarse,
*xyz_values, coarse_qpoints);
unsigned int old_parent_level = coarse->p_level();
(const_cast<Elem *>(coarse))->hack_p_level(elem->p_level());
fe_coarse->reinit(coarse, &coarse_qpoints);
(const_cast<Elem *>(coarse))->hack_p_level(old_parent_level);
// The number of DOFS on the coarse element
unsigned int n_coarse_dofs =
cast_int<unsigned int>(phi_coarse->size());
// Loop over the quadrature points
for (unsigned int qp=0; qp<n_qp; qp++)
{
// The solution difference at the quadrature point
Number value_error = libMesh::zero;
Gradient grad_error;
Tensor hessian_error;
for (unsigned int i=0; i != n_dofs; ++i)
{
const dof_id_type dof_num = dof_indices[i];
value_error += (*phi)[i][qp] *
system.current_solution(dof_num);
if (cont == C_ZERO || cont == C_ONE)
grad_error.add_scaled((*dphi)[i][qp], system.current_solution(dof_num));
// grad_error += (*dphi)[i][qp] *
// system.current_solution(dof_num);
if (cont == C_ONE)
hessian_error.add_scaled((*d2phi)[i][qp], system.current_solution(dof_num));
// hessian_error += (*d2phi)[i][qp] *
// system.current_solution(dof_num);
}
for (unsigned int i=0; i != n_coarse_dofs; ++i)
{
value_error -= (*phi_coarse)[i][qp] * Uc(i);
if (cont == C_ZERO || cont == C_ONE)
// grad_error -= (*dphi_coarse)[i][qp] * Uc(i);
grad_error.subtract_scaled((*dphi_coarse)[i][qp], Uc(i));
if (cont == C_ONE)
hessian_error.subtract_scaled((*d2phi_coarse)[i][qp], Uc(i));
// hessian_error -= (*d2phi_coarse)[i][qp] * Uc(i);
}
h_error_per_cell[e_id] += static_cast<ErrorVectorReal>
(component_scale[var] *
(*JxW)[qp] * TensorTools::norm_sq(value_error));
if (cont == C_ZERO || cont == C_ONE)
h_error_per_cell[e_id] += static_cast<ErrorVectorReal>
(component_scale[var] *
(*JxW)[qp] * grad_error.norm_sq());
if (cont == C_ONE)
h_error_per_cell[e_id] += static_cast<ErrorVectorReal>
(component_scale[var] *
(*JxW)[qp] * hessian_error.norm_sq());
}
}
}
}
// Now that we've got our approximations for p_error and h_error, let's see
// if we want to switch any h refinement flags to p refinement
// Iterate over all the active elements in the mesh
// that live on this processor.
MeshBase::element_iterator elem_it =
mesh.active_local_elements_begin();
const MeshBase::element_iterator elem_end =
mesh.active_local_elements_end();
for (; elem_it != elem_end; ++elem_it)
{
Elem * elem = *elem_it;
// We're only checking elements that are already flagged for h
// refinement
if (elem->refinement_flag() != Elem::REFINE)
continue;
const dof_id_type e_id = elem->id();
unsigned int dofs_per_elem = 0, dofs_per_p_elem = 0;
// Loop over all the variables in the system
for (unsigned int var=0; var<n_vars; var++)
{
// The type of finite element to use for this variable
const FEType & fe_type = dof_map.variable_type (var);
// FIXME: we're overestimating the number of DOFs added by h
// refinement
FEType elem_fe_type = fe_type;
elem_fe_type.order =
static_cast<Order>(fe_type.order + elem->p_level());
dofs_per_elem +=
FEInterface::n_dofs(dim, elem_fe_type, elem->type());
elem_fe_type.order =
static_cast<Order>(fe_type.order + elem->p_level() + 1);
dofs_per_p_elem +=
FEInterface::n_dofs(dim, elem_fe_type, elem->type());
}
const unsigned int new_h_dofs = dofs_per_elem *
(elem->n_children() - 1);
const unsigned int new_p_dofs = dofs_per_p_elem -
dofs_per_elem;
/*
libMesh::err << "Cell " << e_id << ": h = " << elem->hmax()
<< ", p = " << elem->p_level() + 1 << "," << std::endl
<< " h_error = " << h_error_per_cell[e_id]
<< ", p_error = " << p_error_per_cell[e_id] << std::endl
<< " new_h_dofs = " << new_h_dofs
<< ", new_p_dofs = " << new_p_dofs << std::endl;
*/
const Real p_value =
std::sqrt(p_error_per_cell[e_id]) * p_weight / new_p_dofs;
const Real h_value =
std::sqrt(h_error_per_cell[e_id]) /
static_cast<Real>(new_h_dofs);
if (p_value > h_value)
{
elem->set_p_refinement_flag(Elem::REFINE);
elem->set_refinement_flag(Elem::DO_NOTHING);
}
}
STOP_LOG("select_refinement()", "HPCoarsenTest");
}