libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SortAndCopy Struct Reference

#include <generic_projector.h>

Inheritance diagram for libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SortAndCopy:

Public Types
typedef std::unordered_multimap< const Node *, std::tuple< const Elem *, unsigned short, var_set > >	ves_multimap

Public Member Functions
	SortAndCopy (GenericProjector &p)
	SortAndCopy (SortAndCopy &other, Threads::split)
void	operator() (const ConstElemRange &range)
void	join (const SortAndCopy &other)
template<typename InsertInput , typename std::enable_if< std::is_same< typename ProjectionAction::InsertInput, InsertInput >::value, int >::type = 0>
void	insert_ids (const std::vector< dof_id_type > &ids, const std::vector< InsertInput > &vals, processor_id_type pid)
template<typename InsertInput , typename std::enable_if< !std::is_same< typename ProjectionAction::InsertInput, InsertInput >::value, int >::type = 0>
void	insert_ids (const std::vector< dof_id_type > &ids, const std::vector< InsertInput > &vals, processor_id_type pid)
void	find_dofs_to_send (const Node &node, const Elem &elem, unsigned short node_num, const var_set &vars)
template<typename InsertInput , typename std::enable_if< std::is_same< typename ProjectionAction::InsertInput, InsertInput >::value, int >::type = 0>
void	insert_id (dof_id_type id, const InsertInput &val, processor_id_type pid)
template<typename InsertInput , typename std::enable_if< !std::is_same< typename ProjectionAction::InsertInput, InsertInput >::value, int >::type = 0>
void	insert_id (dof_id_type id, const InsertInput &val, processor_id_type pid)
void	join (const SubFunctor &other)

Public Attributes
ves_multimap	vertices
ves_multimap	edges
ves_multimap	sides
std::vector< const Elem * >	interiors
ProjectionAction	action
FFunctor	f
const System &	system
FEMContext	context
GenericProjector &	projector
std::unordered_map< dof_id_type, std::pair< typename FFunctor::ValuePushType, processor_id_type > >	new_ids_to_push
std::unordered_map< dof_id_type, typename FFunctor::ValuePushType >	new_ids_to_save

Protected Attributes
std::vector< FEContinuity >	conts
std::vector< FEFieldType >	field_types

Detailed Description

template<typename FFunctor, typename GFunctor, typename FValue, typename ProjectionAction>
struct libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SortAndCopy

Definition at line 280 of file generic_projector.h.

Member Typedef Documentation

ves_multimap

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

typedef std::unordered_multimap<const Node *, std::tuple<const Elem *, unsigned short, var_set> > libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SortAndCopy::ves_multimap

Definition at line 300 of file generic_projector.h.

Constructor & Destructor Documentation

SortAndCopy() [1/2]

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SortAndCopy::SortAndCopy ( GenericProjector &  p )

inline

Definition at line 281 of file generic_projector.h.

: SubFunctor(p) {}

SortAndCopy() [2/2]

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SortAndCopy::SortAndCopy ( SortAndCopy &  other, Threads::split    )

inline

Definition at line 283 of file generic_projector.h.

: SubFunctor(other.projector) {}

Member Function Documentation

find_dofs_to_send()

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

void libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::find_dofs_to_send ( const Node &  node, const Elem &  elem, unsigned short  node_num, const var_set &  vars  )

inherited

Definition at line 2844 of file generic_projector.h.

{
  libmesh_assert (&node == elem.node_ptr(node_num));
 
  // Any ghosted node in our range might have an owner who needs our
  // data
  const processor_id_type owner = node.processor_id();
  if (owner != system.processor_id())
    {
      const MeshBase & mesh = system.get_mesh();
      const DofMap & dof_map = system.get_dof_map();
 
      // But let's check and see if we can be certain the owner can
      // compute any or all of its own dof coefficients on that node.
      std::vector<dof_id_type> node_dof_ids, patch_dof_ids;
      for (const auto & var : vars)
        {
          const Variable & variable = system.variable(var);
 
          if (!variable.active_on_subdomain(elem.subdomain_id()))
            continue;
 
          dof_map.dof_indices(elem, node_num, node_dof_ids, var);
        }
      libmesh_assert(std::is_sorted(node_dof_ids.begin(),
                                    node_dof_ids.end()));
      const std::vector<dof_id_type> & patch =
        (*this->projector.nodes_to_elem)[node.id()];
      for (const auto & elem_id : patch)
        {
          const Elem & patch_elem = mesh.elem_ref(elem_id);
          if (!patch_elem.active() || owner != patch_elem.processor_id())
            continue;
          dof_map.dof_indices(&patch_elem, patch_dof_ids);
          std::sort(patch_dof_ids.begin(), patch_dof_ids.end());
 
          // Remove any node_dof_ids that we see can be calculated on
          // this element
          std::vector<dof_id_type> diff_ids(node_dof_ids.size());
          auto it = std::set_difference(node_dof_ids.begin(), node_dof_ids.end(),
                                        patch_dof_ids.begin(), patch_dof_ids.end(), diff_ids.begin());
          diff_ids.resize(it-diff_ids.begin());
          node_dof_ids.swap(diff_ids);
          if (node_dof_ids.empty())
            break;
        }
 
      // Give ids_to_push default invalid pid: not yet computed
      for (auto id : node_dof_ids)
        new_ids_to_push[id].second = DofObject::invalid_processor_id;
    }
}

References libMesh::Elem::active(), libMesh::Variable::active_on_subdomain(), libMesh::DofMap::dof_indices(), libMesh::System::get_dof_map(), libMesh::System::get_mesh(), libMesh::DofObject::id(), libMesh::DofObject::invalid_processor_id, libMesh::libmesh_assert(), mesh, libMesh::Elem::node_ptr(), libMesh::DofObject::processor_id(), libMesh::ParallelObject::processor_id(), libMesh::Elem::subdomain_id(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::system, and libMesh::System::variable().

insert_id() [1/2]

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

template<typename InsertInput , typename std::enable_if< std::is_same< typename ProjectionAction::InsertInput, InsertInput >::value, int >::type >

void libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::insert_id ( dof_id_type  id, const InsertInput &  val, processor_id_type  pid  )

inherited

Definition at line 1378 of file generic_projector.h.

{
  libmesh_error_msg("ID insertion should only occur when the provided input matches that "
                    "expected by the ProjectionAction");
}

insert_id() [2/2]

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

template<typename InsertInput , typename std::enable_if< !std::is_same< typename ProjectionAction::InsertInput, InsertInput >::value, int >::type = 0>

void libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::insert_id ( dof_id_type  id, const InsertInput &  val, processor_id_type  pid  )

inherited

insert_ids() [1/2]

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

template<typename InsertInput , typename std::enable_if< std::is_same< typename ProjectionAction::InsertInput, InsertInput >::value, int >::type = 0>

void libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::insert_ids	(	const std::vector< dof_id_type > &	ids,
		const std::vector< InsertInput > &	vals,
		processor_id_type	pid
	)

Definition at line 213 of file generic_projector.h.

{
  libmesh_error_msg("ID insertion should only occur when the provided input matches that "
                    "expected by the ProjectionAction");
}

insert_ids() [2/2]

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

template<typename InsertInput , typename std::enable_if< !std::is_same< typename ProjectionAction::InsertInput, InsertInput >::value, int >::type = 0>

void libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::insert_ids	(	const std::vector< dof_id_type > &	ids,
		const std::vector< InsertInput > &	vals,
		processor_id_type	pid
	)

join() [1/2]

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

void libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SortAndCopy::join

(

const SortAndCopy &

other

)

Definition at line 1941 of file generic_projector.h.

{
  auto merge_multimaps = [](ves_multimap & self, const ves_multimap & other_mm)
    {
      for (const auto & pair : other_mm)
        {
          const Node * node = pair.first;
          auto remaining_vars = std::get<2>(pair.second);
 
          auto my_range = self.equal_range(node);
          for (const auto & v_ent : as_range(my_range))
            for (const unsigned int var_covered :
                 std::get<2>(v_ent.second))
              remaining_vars.erase(var_covered);
 
          if (!remaining_vars.empty())
            self.emplace
              (node, std::make_tuple(std::get<0>(pair.second),
                                     std::get<1>(pair.second),
                                     std::move(remaining_vars)));
        }
    };
 
  merge_multimaps(vertices, other.vertices);
  merge_multimaps(edges, other.edges);
  merge_multimaps(sides, other.sides);
 
  std::sort(interiors.begin(), interiors.end());
  std::vector<const Elem *> other_interiors = other.interiors;
  std::sort(other_interiors.begin(), other_interiors.end());
  std::vector<const Elem *> merged_interiors;
  std::set_union(interiors.begin(), interiors.end(),
                 other_interiors.begin(), other_interiors.end(),
                 std::back_inserter(merged_interiors));
  interiors.swap(merged_interiors);
 
  SubFunctor::join(other);
}

References libMesh::as_range(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SortAndCopy::edges, libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SortAndCopy::interiors, libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::join(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SortAndCopy::sides, and libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SortAndCopy::vertices.

join() [2/2]

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

void libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::join ( const SubFunctor &  other )

inherited

Definition at line 1470 of file generic_projector.h.

{
  new_ids_to_push.insert(other.new_ids_to_push.begin(), other.new_ids_to_push.end());
  new_ids_to_save.insert(other.new_ids_to_save.begin(), other.new_ids_to_save.end());
}

References libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::new_ids_to_push, and libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::new_ids_to_save.

Referenced by libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SortAndCopy::join().

operator()()

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

void libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SortAndCopy::operator()

(

const ConstElemRange &

range

)

Definition at line 1480 of file generic_projector.h.

{
  LOG_SCOPE ("SortAndCopy::operator()","GenericProjector");
 
  // Look at all the elements in the range.  Directly copy values from
  // unchanged elements.  For other elements, determine sets of
  // vertices, edge nodes, and side nodes to project.
  //
  // As per our other weird nomenclature, "sides" means faces in 3D
  // and edges in 2D, and "edges" gets skipped in 2D
  //
  // This gets tricky in the case of subdomain-restricted
  // variables, for which we might need to do the same projection
  // from different elements when evaluating different variables.
  // We'll keep track of which variables can be projected from which
  // elements.
 
  // If we copy DoFs on a node, keep track of it so we don't bother
  // with any redundant interpolations or projections later.
  //
  // We still need to keep track of *which* variables get copied,
  // since we may be able to copy elements which lack some
  // subdomain-restricted variables.
  //
  // For extra_hanging_dofs FE types, we'll keep track of which
  // variables were copied from vertices, and which from edges/sides,
  // because those types need copies made from *both* on hanging
  // nodes.
  std::unordered_map<const Node *, std::pair<var_set, var_set>> copied_nodes;
 
  const unsigned int sys_num = system.number();
 
  // At hanging nodes for variables with extra hanging dofs we'll need
  // to do projections *separately* from vertex elements and side/edge
  // elements.
  std::vector<unsigned short> extra_hanging_dofs;
  bool all_extra_hanging_dofs = true;
  for (auto v_num : this->projector.variables)
    {
      if (extra_hanging_dofs.size() <= v_num)
        extra_hanging_dofs.resize(v_num+1, false);
      extra_hanging_dofs[v_num] =
        FEInterface::extra_hanging_dofs(system.variable(v_num).type());
 
      if (!extra_hanging_dofs[v_num])
        all_extra_hanging_dofs = false;
    }
 
  for (const auto & elem : range)
    {
      // If we're doing AMR, we might be able to copy more DoFs than
      // we interpolate or project.
      bool copy_this_elem = false;
 
#ifdef LIBMESH_ENABLE_AMR
      // If we're projecting from an old grid
      if (f.is_grid_projection())
        {
          // If this element doesn't have an old_dof_object, but it
          // wasn't just refined or just coarsened into activity, then
          // it must be newly added, so the user is responsible for
          // setting the new dofs on it during a grid projection.
          const DofObject * old_dof_object = elem->get_old_dof_object();
          const Elem::RefinementState h_flag = elem->refinement_flag();
          const Elem::RefinementState p_flag = elem->p_refinement_flag();
          if (!old_dof_object &&
              h_flag != Elem::JUST_REFINED &&
              h_flag != Elem::JUST_COARSENED)
            continue;
 
          // If this is an unchanged element, just copy everything
          if (h_flag != Elem::JUST_REFINED &&
              h_flag != Elem::JUST_COARSENED &&
              p_flag != Elem::JUST_REFINED &&
              p_flag != Elem::JUST_COARSENED)
            copy_this_elem = true;
          else
            {
              bool reinitted = false;
 
              const unsigned int p_level = elem->p_level();
 
              // If this element has a low order monomial which has
              // merely been h refined, copy it.
              const bool copy_possible =
                p_level == 0 &&
                h_flag != Elem::JUST_COARSENED &&
                p_flag != Elem::JUST_COARSENED;
 
              std::vector<typename FFunctor::ValuePushType> Ue(1);
              std::vector<dof_id_type> elem_dof_ids(1);
 
              for (auto v_num : this->projector.variables)
                {
                  const Variable & var = system.variable(v_num);
                  if (!var.active_on_subdomain(elem->subdomain_id()))
                    continue;
                  const FEType fe_type = var.type();
 
                  if (fe_type.family == MONOMIAL &&
                      fe_type.order == CONSTANT &&
                      copy_possible)
                    {
                      if (!reinitted)
                        {
                          reinitted = true;
                          context.pre_fe_reinit(system, elem);
                        }
 
                      f.eval_old_dofs(*elem, fe_type, sys_num, v_num,
                                      elem_dof_ids, Ue);
 
                      action.insert(elem_dof_ids[0], Ue[0]);
                    }
                }
            }
        }
#endif // LIBMESH_ENABLE_AMR
 
      const int dim = elem->dim();
 
      const unsigned int n_vertices = elem->n_vertices();
      const unsigned int n_edges = elem->n_edges();
      const unsigned int n_nodes = elem->n_nodes();
 
      // In 1-D we already handle our sides as vertices
      const unsigned int n_sides = (dim > 1) * elem->n_sides();
 
      // What variables are supported on each kind of node on this elem?
      var_set vertex_vars, edge_vars, side_vars;
 
      // If we have non-vertex nodes, the first is an edge node, but
      // if we're in 2D we'll call that a side node
      const bool has_poly_midnode = (elem->type() == C0POLYHEDRON) && (n_nodes == n_vertices + 1);
      const bool has_edge_nodes = (n_nodes > n_vertices + has_poly_midnode && dim > 2);
 
      // If we have even more nodes, the next is a side node.
      const bool has_side_nodes =
        (n_nodes > n_vertices + ((dim > 2) * n_edges));
 
      // We may be out of nodes at this point or we have interior
      // nodes which may have DoFs to project too
      const bool has_interior_nodes =
        (n_nodes > n_vertices + ((dim > 2) * n_edges) + n_sides);
 
      for (auto v_num : this->projector.variables)
        {
          const Variable & var = this->projector.system.variable(v_num);
          if (!var.active_on_subdomain(elem->subdomain_id()))
            continue;
          const FEType fe_type = var.type();
          const bool add_p_level = fe_type.p_refinement;
 
          // If we're trying to do projections on an isogeometric
          // analysis mesh, only the finite element nodes constrained
          // by those spline nodes truly have delta function degrees
          // of freedom.  We'll have to back out the spline degrees of
          // freedom indirectly later.
          if (fe_type.family == RATIONAL_BERNSTEIN &&
              elem->type() == NODEELEM)
            continue;
 
          if (FEInterface::n_dofs_at_node(fe_type, elem, 0, add_p_level))
            vertex_vars.insert(vertex_vars.end(), v_num);
 
          // The first non-vertex node is always an edge node if those
          // exist.  All edge nodes have the same number of DoFs
          if (has_edge_nodes)
            if (FEInterface::n_dofs_at_node(fe_type, elem, n_vertices, add_p_level))
              edge_vars.insert(edge_vars.end(), v_num);
 
          if (has_side_nodes)
            {
              if (dim != 3)
                {
                  if (FEInterface::n_dofs_at_node(fe_type, elem, n_vertices, add_p_level))
                    side_vars.insert(side_vars.end(), v_num);
                }
              else
                // In 3D, not all face nodes always have the same number of
                // DoFs!  We'll loop over all sides to be safe.
                for (unsigned int n = 0; n != n_nodes; ++n)
                  if (elem->is_face(n))
                    if (FEInterface::n_dofs_at_node(fe_type, elem, n, add_p_level))
                      {
                        side_vars.insert(side_vars.end(), v_num);
                        break;
                      }
            }
 
          if (FEInterface::n_dofs_per_elem(fe_type, elem, add_p_level) ||
              (has_interior_nodes &&
               FEInterface::n_dofs_at_node(fe_type, elem, n_nodes-1, add_p_level)))
            {
#ifdef LIBMESH_ENABLE_AMR
              // We may have already just copied constant monomials,
              // or we may be about to copy the whole element
              if ((f.is_grid_projection() &&
                   fe_type.family == MONOMIAL &&
                   fe_type.order == CONSTANT &&
                   elem->p_level() == 0 &&
                   elem->refinement_flag() != Elem::JUST_COARSENED &&
                   elem->p_refinement_flag() != Elem::JUST_COARSENED)
                  || copy_this_elem
                  )
                continue;
#endif // LIBMESH_ENABLE_AMR
 
              // We need to project any other variables
              if (interiors.empty() || interiors.back() != elem)
                interiors.push_back(elem);
            }
        }
 
      // We'll use a greedy algorithm in most cases: if another
      // element has already claimed some of our DoFs, we'll let it do
      // the work.
      auto erase_covered_vars = []
        (const Node * node, var_set & remaining, const ves_multimap & covered)
        {
          auto covered_range = covered.equal_range(node);
          for (const auto & v_ent : as_range(covered_range))
            for (const unsigned int var_covered :
                 std::get<2>(v_ent.second))
              remaining.erase(var_covered);
        };
 
      auto erase_nonhanging_vars = [&extra_hanging_dofs]
        (const Node * node, var_set & remaining, const ves_multimap & covered)
        {
          auto covered_range = covered.equal_range(node);
          for (const auto & v_ent : as_range(covered_range))
            for (const unsigned int var_covered :
                 std::get<2>(v_ent.second))
              if (!extra_hanging_dofs[var_covered])
                remaining.erase(var_covered);
        };
 
      auto erase_copied_vars = [&copied_nodes, &extra_hanging_dofs]
        (const Node * node, bool is_vertex, var_set & remaining)
        {
          auto copying_range = copied_nodes.equal_range(node);
          for (const auto & v_ent : as_range(copying_range))
            {
              for (const unsigned int var_covered :
                   v_ent.second.first)
                if (is_vertex || !extra_hanging_dofs[var_covered])
                  remaining.erase(var_covered);
 
              for (const unsigned int var_covered :
                   v_ent.second.second)
                if (!is_vertex || !extra_hanging_dofs[var_covered])
                  remaining.erase(var_covered);
            }
        };
 
      // Treat polyhedron midnode as a vertex
      // NOTE: if we start having edge or side nodes on polyhedra, we need to use that +1 offset
      // in the edge and side nodes code as well!
#ifndef NDEBUG
      for (auto v_num : this->projector.variables)
        {
          const auto & family = this->projector.system.variable(v_num).type().family;
          // Add to the list once known to be correctly functioning with the midnode
          libmesh_assert(!has_poly_midnode || (family == LAGRANGE || family == MONOMIAL || family == XYZ));
        }
#endif
      for (const auto v : make_range(n_vertices + has_poly_midnode))
        {
          const Node * node = elem->node_ptr(v);
 
          auto remaining_vars = vertex_vars;
 
          erase_covered_vars(node, remaining_vars, vertices);
 
          if (remaining_vars.empty())
            continue;
 
          if (!all_extra_hanging_dofs)
            {
              erase_nonhanging_vars(node, remaining_vars, edges);
              if (remaining_vars.empty())
                continue;
 
              erase_nonhanging_vars(node, remaining_vars, sides);
              if (remaining_vars.empty())
                continue;
            }
 
          erase_copied_vars(node, true, remaining_vars);
          if (remaining_vars.empty())
            continue;
 
          if (copy_this_elem)
            {
              std::vector<dof_id_type> node_dof_ids;
              std::vector<typename FFunctor::ValuePushType> values;
 
              for (auto var : remaining_vars)
                {
                  f.eval_old_dofs(*elem, v, var, node_dof_ids, values);
                  insert_ids(node_dof_ids, values, node->processor_id());
                }
              copied_nodes[node].first.insert(remaining_vars.begin(),
                                              remaining_vars.end());
              this->find_dofs_to_send(*node, *elem, v, remaining_vars);
            }
          else
            vertices.emplace
              (node, std::make_tuple(elem, v, std::move(remaining_vars)));
        }
 
      if (has_edge_nodes)
        {
          for (unsigned int e=0; e != n_edges; ++e)
            {
              const Node * node = elem->node_ptr(n_vertices+e);
 
              auto remaining_vars = edge_vars;
 
              erase_covered_vars(node, remaining_vars, edges);
              if (remaining_vars.empty())
                continue;
 
              erase_covered_vars(node, remaining_vars, sides);
              if (remaining_vars.empty())
                continue;
 
              if (!all_extra_hanging_dofs)
                {
                  erase_nonhanging_vars(node, remaining_vars, vertices);
                  if (remaining_vars.empty())
                    continue;
                }
 
              erase_copied_vars(node, false, remaining_vars);
              if (remaining_vars.empty())
                continue;
 
              if (copy_this_elem)
                {
                  std::vector<dof_id_type> edge_dof_ids;
                  std::vector<typename FFunctor::ValuePushType> values;
 
                  for (auto var : remaining_vars)
                    {
                      f.eval_old_dofs(*elem, n_vertices+e, var, edge_dof_ids, values);
                      insert_ids(edge_dof_ids, values, node->processor_id());
                    }
 
                  copied_nodes[node].second.insert(remaining_vars.begin(),
                                                   remaining_vars.end());
                  this->find_dofs_to_send(*node, *elem, n_vertices+e, remaining_vars);
                }
              else
                edges.emplace
                  (node, std::make_tuple(elem, e, std::move(remaining_vars)));
            }
        }
 
      if (has_side_nodes)
        {
          for (unsigned int side=0; side != n_sides; ++side)
            {
              const Node * node = nullptr;
              unsigned short node_num = n_vertices+(dim>2)*n_edges+side;
              if (dim != 3)
                node = elem->node_ptr(node_num);
              else
                {
                  // In 3D only some sides may have nodes
                  for (unsigned int n = 0; n != n_nodes; ++n)
                    {
                      if (!elem->is_face(n))
                        continue;
 
                      if (elem->is_node_on_side(n, side))
                        {
                          node_num = n;
                          node = elem->node_ptr(node_num);
                          break;
                        }
                    }
                }
 
              if (!node)
                continue;
 
              auto remaining_vars = side_vars;
 
              erase_covered_vars(node, remaining_vars, edges);
              if (remaining_vars.empty())
                continue;
 
              erase_covered_vars(node, remaining_vars, sides);
              if (remaining_vars.empty())
                continue;
 
              if (!all_extra_hanging_dofs)
                {
                  erase_nonhanging_vars(node, remaining_vars, vertices);
                  if (remaining_vars.empty())
                    continue;
                }
 
              erase_copied_vars(node, false, remaining_vars);
              if (remaining_vars.empty())
                continue;
 
              if (copy_this_elem)
                {
                  std::vector<dof_id_type> side_dof_ids;
                  std::vector<typename FFunctor::ValuePushType> values;
 
                  for (auto var : remaining_vars)
                    {
                      f.eval_old_dofs(*elem, node_num, var, side_dof_ids, values);
                      insert_ids(side_dof_ids, values, node->processor_id());
                    }
 
                  copied_nodes[node].second.insert(remaining_vars.begin(),
                                                   remaining_vars.end());
                  this->find_dofs_to_send(*node, *elem, node_num, remaining_vars);
                }
              else
                sides.emplace
                  (node, std::make_tuple(elem, side, std::move(remaining_vars)));
            }
        }
 
      // Elements with elemental dofs might need those copied too.
      if (copy_this_elem)
        {
          std::vector<typename FFunctor::ValuePushType> U;
          std::vector<dof_id_type> dof_ids;
 
          for (auto v_num : this->projector.variables)
            {
              const Variable & var = system.variable(v_num);
              if (!var.active_on_subdomain(elem->subdomain_id()))
                continue;
              FEType fe_type = var.type();
 
              f.eval_old_dofs(*elem, fe_type, sys_num, v_num,
                              dof_ids, U);
              action.insert(dof_ids, U);
 
              if (has_interior_nodes)
                {
                  f.eval_old_dofs(*elem, n_nodes-1, v_num, dof_ids, U);
                  action.insert(dof_ids, U);
                }
            }
        }
    }
}

References libMesh::Variable::active_on_subdomain(), libMesh::as_range(), libMesh::C0POLYHEDRON, libMesh::CONSTANT, dim, libMesh::FEInterface::extra_hanging_dofs(), libMesh::FEType::family, libMesh::DofObject::get_old_dof_object(), libMesh::Elem::JUST_COARSENED, libMesh::Elem::JUST_REFINED, libMesh::LAGRANGE, libMesh::libmesh_assert(), libMesh::make_range(), libMesh::MONOMIAL, libMesh::FEInterface::n_dofs_at_node(), libMesh::FEInterface::n_dofs_per_elem(), n_nodes, libMesh::NODEELEM, libMesh::System::number(), libMesh::FEType::order, libMesh::FEType::p_refinement, libMesh::DofObject::processor_id(), libMesh::RATIONAL_BERNSTEIN, libMesh::Variable::system(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::system, libMesh::Variable::type(), libMesh::System::variable(), and libMesh::XYZ.

Member Data Documentation

action

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

ProjectionAction libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::action

Definition at line 231 of file generic_projector.h.

context

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

FEMContext libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::context

Definition at line 236 of file generic_projector.h.

conts

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

std::vector<FEContinuity> libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::conts

protectedinherited

Definition at line 239 of file generic_projector.h.

Referenced by libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::SubFunctor().

edges

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

ves_multimap libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SortAndCopy::edges

Definition at line 302 of file generic_projector.h.

Referenced by libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SortAndCopy::join(), and libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::project().

f

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

FFunctor libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::f

Definition at line 232 of file generic_projector.h.

field_types

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

std::vector<FEFieldType> libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::field_types

protectedinherited

Definition at line 240 of file generic_projector.h.

Referenced by libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::SubFunctor().

interiors

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

std::vector<const Elem *> libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SortAndCopy::interiors

Definition at line 303 of file generic_projector.h.

Referenced by libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SortAndCopy::join(), and libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::project().

new_ids_to_push

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

std::unordered_map<dof_id_type, std::pair<typename FFunctor::ValuePushType, processor_id_type> > libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::new_ids_to_push

inherited

Definition at line 183 of file generic_projector.h.

Referenced by libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::join(), and libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::project().

new_ids_to_save

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

std::unordered_map<dof_id_type, typename FFunctor::ValuePushType> libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::new_ids_to_save

inherited

Definition at line 187 of file generic_projector.h.

Referenced by libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::join(), and libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::project().

projector

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

GenericProjector& libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::projector

inherited

Definition at line 170 of file generic_projector.h.

Referenced by libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::SubFunctor(), and libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubProjector::SubProjector().

sides

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

ves_multimap libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SortAndCopy::sides

Definition at line 302 of file generic_projector.h.

Referenced by libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SortAndCopy::join(), and libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::project().

system

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

const System& libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::system

Definition at line 242 of file generic_projector.h.

vertices

template<typename FFunctor , typename GFunctor , typename FValue , typename ProjectionAction >

ves_multimap libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SortAndCopy::vertices

Definition at line 302 of file generic_projector.h.

Referenced by libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SortAndCopy::join(), and libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::project().

---

The documentation for this struct was generated from the following file:

• include/systems/generic_projector.h