void Elem::refine (MeshRefinement & mesh_refinement)
{
libmesh_assert_equal_to (this->refinement_flag(), Elem::REFINE);
libmesh_assert (this->active());
// Create my children if necessary
if (!_children)
{
_children = new Elem *[this->n_children()];
unsigned int parent_p_level = this->p_level();
for (unsigned int c=0; c<this->n_children(); c++)
{
_children[c] = Elem::build(this->type(), this).release();
Elem * current_child = this->child(c);
current_child->set_refinement_flag(Elem::JUST_REFINED);
current_child->set_p_level(parent_p_level);
current_child->set_p_refinement_flag(this->p_refinement_flag());
for (unsigned int nc=0; nc<current_child->n_nodes(); nc++)
{
Node * node =
mesh_refinement.add_node(*this, c, nc,
current_child->processor_id());
node->set_n_systems (this->n_systems());
current_child->set_node(nc) = node;
}
mesh_refinement.add_elem (current_child);
current_child->set_n_systems(this->n_systems());
}
}
else
{
unsigned int parent_p_level = this->p_level();
for (unsigned int c=0; c<this->n_children(); c++)
{
Elem * current_child = this->child(c);
libmesh_assert(current_child->subactive());
current_child->set_refinement_flag(Elem::JUST_REFINED);
current_child->set_p_level(parent_p_level);
current_child->set_p_refinement_flag(this->p_refinement_flag());
}
}
// Un-set my refinement flag now
this->set_refinement_flag(Elem::INACTIVE);
this->set_p_refinement_flag(Elem::INACTIVE);
for (unsigned int c=0; c<this->n_children(); c++)
{
libmesh_assert_equal_to (this->child(c)->parent(), this);
libmesh_assert(this->child(c)->active());
}
libmesh_assert (this->ancestor());
}
void Elem::refine (MeshRefinement& mesh_refinement)
{
libmesh_assert (this->refinement_flag() == Elem::REFINE);
libmesh_assert (this->active());
// Create my children if necessary
if (!_children)
{
_children = new Elem*[this->n_children()];
unsigned int parent_p_level = this->p_level();
for (unsigned int c=0; c<this->n_children(); c++)
{
_children[c] = Elem::build(this->type(), this).release();
_children[c]->set_refinement_flag(Elem::JUST_REFINED);
_children[c]->set_p_level(parent_p_level);
_children[c]->set_p_refinement_flag(this->p_refinement_flag());
}
// Compute new nodal locations
// and asssign nodes to children
// Make these static. It is unlikely the
// sizes will change from call to call, so having these
// static should save on reallocations
std::vector<std::vector<Point> > p (this->n_children());
std::vector<std::vector<Node*> > nodes(this->n_children());
// compute new nodal locations
for (unsigned int c=0; c<this->n_children(); c++)
{
Elem *child = this->child(c);
p[c].resize (child->n_nodes());
nodes[c].resize(child->n_nodes());
for (unsigned int nc=0; nc<child->n_nodes(); nc++)
{
// zero entries
p[c][nc].zero();
nodes[c][nc] = NULL;
for (unsigned int n=0; n<this->n_nodes(); n++)
{
// The value from the embedding matrix
const float em_val = this->embedding_matrix(c,nc,n);
if (em_val != 0.)
{
p[c][nc].add_scaled (this->point(n), em_val);
// We may have found the node, in which case we
// won't need to look it up later.
if (em_val == 1.)
nodes[c][nc] = this->get_node(n);
}
}
}
// assign nodes to children & add them to the mesh
const Real pointtol = this->hmin() * TOLERANCE;
for (unsigned int nc=0; nc<child->n_nodes(); nc++)
{
if (nodes[c][nc] != NULL)
{
child->set_node(nc) = nodes[c][nc];
}
else
{
child->set_node(nc) =
mesh_refinement.add_point(p[c][nc],
child->processor_id(),
pointtol);
child->get_node(nc)->set_n_systems
(this->n_systems());
}
}
mesh_refinement.add_elem (child);
child->set_n_systems(this->n_systems());
}
}
else
{
unsigned int parent_p_level = this->p_level();
for (unsigned int c=0; c<this->n_children(); c++)
{
Elem *child = this->child(c);
libmesh_assert(child->subactive());
child->set_refinement_flag(Elem::JUST_REFINED);
child->set_p_level(parent_p_level);
child->set_p_refinement_flag(this->p_refinement_flag());
}
}
// Un-set my refinement flag now
this->set_refinement_flag(Elem::INACTIVE);
this->set_p_refinement_flag(Elem::INACTIVE);
for (unsigned int c=0; c<this->n_children(); c++)
{
libmesh_assert(this->child(c)->parent() == this);
libmesh_assert(this->child(c)->active());
}
libmesh_assert (this->ancestor());
}
void Elem::refine (MeshRefinement & mesh_refinement)
{
libmesh_assert_equal_to (this->refinement_flag(), Elem::REFINE);
libmesh_assert (this->active());
const unsigned int nc = this->n_children();
// Create my children if necessary
if (!_children)
{
_children = new Elem *[nc];
unsigned int parent_p_level = this->p_level();
const unsigned int nei = this->n_extra_integers();
for (unsigned int c = 0; c != nc; c++)
{
_children[c] = Elem::build(this->type(), this).release();
Elem * current_child = this->child_ptr(c);
current_child->set_refinement_flag(Elem::JUST_REFINED);
current_child->set_p_level(parent_p_level);
current_child->set_p_refinement_flag(this->p_refinement_flag());
for (unsigned int cnode=0; cnode != current_child->n_nodes(); ++cnode)
{
Node * node =
mesh_refinement.add_node(*this, c, cnode,
current_child->processor_id());
node->set_n_systems (this->n_systems());
current_child->set_node(cnode) = node;
}
mesh_refinement.add_elem (current_child);
current_child->set_n_systems(this->n_systems());
libmesh_assert_equal_to (current_child->n_extra_integers(),
this->n_extra_integers());
for (unsigned int i=0; i != nei; ++i)
current_child->set_extra_integer(i, this->get_extra_integer(i));
}
}
else
{
unsigned int parent_p_level = this->p_level();
for (unsigned int c = 0; c != nc; c++)
{
Elem * current_child = this->child_ptr(c);
if (current_child != remote_elem)
{
libmesh_assert(current_child->subactive());
current_child->set_refinement_flag(Elem::JUST_REFINED);
current_child->set_p_level(parent_p_level);
current_child->set_p_refinement_flag(this->p_refinement_flag());
}
}
}
// Un-set my refinement flag now
this->set_refinement_flag(Elem::INACTIVE);
// Leave the p refinement flag set - we will need that later to get
// projection operations correct
// this->set_p_refinement_flag(Elem::INACTIVE);
#ifndef NDEBUG
for (unsigned int c = 0; c != nc; c++)
if (this->child_ptr(c) != remote_elem)
{
libmesh_assert_equal_to (this->child_ptr(c)->parent(), this);
libmesh_assert(this->child_ptr(c)->active());
}
#endif
libmesh_assert (this->ancestor());
}