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)
void	insert_ids (const std::vector< dof_id_type > &ids, const std::vector< FValue > &vals, processor_id_type pid)
void	find_dofs_to_send (const Node &node, const Elem &elem, unsigned short node_num, const var_set &vars)
void	insert_id (dof_id_type id, const FValue &val, processor_id_type pid)
void	insert_ids (const std::vector< dof_id_type > &ids, const std::vector< FValue > &vals, 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< FValue, processor_id_type > >	new_ids_to_push
std::unordered_map< dof_id_type, FValue >	new_ids_to_save

Protected Attributes
std::vector< FEContinuity >	conts

Detailed Description

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

Definition at line 240 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 260 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 241 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 243 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 2345 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::MeshBase::elem_ref(), libMesh::DofObject::id(), libMesh::DofObject::invalid_processor_id, libMesh::Parallel::Utils::is_sorted(), libMesh::libmesh_assert(), mesh, libMesh::Elem::node_ptr(), libMesh::DofObject::processor_id(), and libMesh::Elem::subdomain_id().

insert_id()

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

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

inherited

Definition at line 1117 of file generic_projector.h.

{
  auto iter = new_ids_to_push.find(id);
  if (iter == new_ids_to_push.end())
    action.insert(id, val);
  else
    {
      libmesh_assert(pid != DofObject::invalid_processor_id);
      iter->second = std::make_pair(val, pid);
    }
  if (!this->projector.done_saving_ids)
    {
      libmesh_assert(!new_ids_to_save.count(id));
      new_ids_to_save[id] = val;
    }
}

References libMesh::DofObject::invalid_processor_id, and libMesh::libmesh_assert().

insert_ids() [1/2]

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

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

inherited

Definition at line 1138 of file generic_projector.h.

{
  libmesh_assert_equal_to(ids.size(), vals.size());
  for (auto i : index_range(ids))
    {
      const dof_id_type id = ids[i];
      const FValue & val = vals[i];
 
      auto iter = new_ids_to_push.find(id);
      if (iter == new_ids_to_push.end())
        action.insert(id, val);
      else
        {
          libmesh_assert(pid != DofObject::invalid_processor_id);
          iter->second = std::make_pair(val, pid);
        }
      if (!this->projector.done_saving_ids)
        {
          libmesh_assert(!new_ids_to_save.count(id));
          new_ids_to_save[id] = val;
        }
    }
}

References libMesh::index_range(), libMesh::DofObject::invalid_processor_id, and libMesh::libmesh_assert().

insert_ids() [2/2]

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

void libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::insert_ids

Definition at line 1138 of file generic_projector.h.

{
  libmesh_assert_equal_to(ids.size(), vals.size());
  for (auto i : index_range(ids))
    {
      const dof_id_type id = ids[i];
      const FValue & val = vals[i];
 
      auto iter = new_ids_to_push.find(id);
      if (iter == new_ids_to_push.end())
        action.insert(id, val);
      else
        {
          libmesh_assert(pid != DofObject::invalid_processor_id);
          iter->second = std::make_pair(val, pid);
        }
      if (!this->projector.done_saving_ids)
        {
          libmesh_assert(!new_ids_to_save.count(id));
          new_ids_to_save[id] = val;
        }
    }
}

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 1612 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 >::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 1166 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.

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 1176 of file generic_projector.h.

{
  // 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.
          if (!elem->old_dof_object &&
              elem->refinement_flag() != Elem::JUST_REFINED &&
              elem->refinement_flag() != Elem::JUST_COARSENED)
            continue;
 
          // If this is an unchanged element, just copy everything
          if ((elem->refinement_flag() != Elem::JUST_REFINED &&
              elem->refinement_flag() != Elem::JUST_COARSENED &&
              elem->p_refinement_flag() != Elem::JUST_REFINED &&
              elem->p_refinement_flag() != Elem::JUST_COARSENED))
            copy_this_elem = true;
          else
            {
              bool reinitted = false;
 
              // If this element has a low order monomial which has
              // merely been h refined, copy it.
              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();
 
                  if (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)
                    {
                      if (!reinitted)
                        {
                          reinitted = true;
                          context.pre_fe_reinit(system, elem);
                        }
 
                      std::vector<FValue> Ue(1);
                      std::vector<dof_id_type> elem_dof_ids(1);
 
                      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_edge_nodes = (n_nodes > n_vertices && 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;
          FEType fe_type = var.type();
          fe_type.order =
            libMesh::Order (fe_type.order + elem->p_level());
          const ElemType elem_type = elem->type();
 
          if (FEInterface::n_dofs_at_node(dim, fe_type, elem_type, 0))
            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(dim, fe_type, elem_type, n_vertices))
              edge_vars.insert(edge_vars.end(), v_num);
 
          if (has_side_nodes)
            {
              if (dim != 3)
                {
                  if (FEInterface::n_dofs_at_node(dim, fe_type, elem_type, n_vertices))
                    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(dim, fe_type,
                                                    elem_type, n))
                      {
                        side_vars.insert(side_vars.end(), v_num);
                        break;
                      }
            }
 
          if (FEInterface::n_dofs_per_elem(dim, fe_type, elem_type) ||
              (has_interior_nodes &&
               FEInterface::n_dofs_at_node(dim, fe_type, elem_type, n_nodes-1)))
            {
#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);
            }
        };
 
      for (unsigned int v=0; v != n_vertices; ++v)
        {
          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)
            {
              for (auto var : remaining_vars)
                {
                  std::vector<dof_id_type> node_dof_ids;
                  std::vector<FValue> values;
 
                  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)
                {
                  for (auto var : remaining_vars)
                    {
                      std::vector<dof_id_type> edge_dof_ids;
                      std::vector<FValue> values;
 
                      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)
                {
                  for (auto var : remaining_vars)
                    {
                      std::vector<dof_id_type> side_dof_ids;
                      std::vector<FValue> values;
 
                      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)
        {
          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();
 
              std::vector<FValue> Ue;
              std::vector<dof_id_type> elem_dof_ids;
              f.eval_old_dofs(*elem, fe_type, sys_num, v_num,
                              elem_dof_ids, Ue);
              action.insert(elem_dof_ids, Ue);
 
              if (has_interior_nodes)
                {
                  std::vector<FValue> Un;
                  std::vector<dof_id_type> node_dof_ids;
 
                  f.eval_old_dofs(*elem, n_nodes-1, v_num, node_dof_ids, Un);
                  action.insert(node_dof_ids, Un);
                }
            }
        }
    }
}

References libMesh::Variable::active_on_subdomain(), libMesh::as_range(), libMesh::CONSTANT, dim, libMesh::FEInterface::extra_hanging_dofs(), libMesh::FEType::family, libMesh::Elem::JUST_COARSENED, libMesh::Elem::JUST_REFINED, libMesh::MONOMIAL, libMesh::FEInterface::n_dofs_at_node(), libMesh::FEInterface::n_dofs_per_elem(), n_nodes, libMesh::FEType::order, libMesh::DofObject::processor_id(), libMesh::Variable::system(), libMesh::Variable::type(), and libMesh::System::variable().

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 193 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 198 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 201 of file generic_projector.h.

edges

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

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

Definition at line 262 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 194 of file generic_projector.h.

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 263 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<FValue, processor_id_type> > libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::new_ids_to_push

inherited

Definition at line 165 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, FValue> libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::new_ids_to_save

inherited

Definition at line 169 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 154 of file generic_projector.h.

sides

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

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

Definition at line 262 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 203 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 262 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