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

#include <generic_projector.h>

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

Public Member Functions
	ProjectSides (GenericProjector &p)
	ProjectSides (ProjectSides &p_s, Threads::split)
void	operator() (const node_range &range)
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)
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)
void	join (const SubFunctor &other)

Public Attributes
ProjectionAction	action
FFunctor	f
std::unique_ptr< GFunctor >	g
const System &	system
FEMContext	context
std::vector< FEContinuity >	conts
std::vector< FEFieldType >	field_types
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 Member Functions
void	construct_projection (const std::vector< dof_id_type > &dof_indices_var, const std::vector< unsigned int > &involved_dofs, unsigned int var_component, const Node *node, const FEGenericBase< typename FFunctor::RealType > &fe)

Detailed Description

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

Definition at line 346 of file generic_projector.h.

Constructor & Destructor Documentation

ProjectSides() [1/2]

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

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

inline

Definition at line 347 of file generic_projector.h.

: SubProjector(p) {}

ProjectSides() [2/2]

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

libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectSides::ProjectSides ( ProjectSides &  p_s, Threads::split    )

inline

Definition at line 349 of file generic_projector.h.

: SubProjector(p_s.projector) {}

Member Function Documentation

construct_projection()

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

void libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubProjector::construct_projection ( const std::vector< dof_id_type > &  dof_indices_var, const std::vector< unsigned int > &  involved_dofs, unsigned int  var_component, const Node *  node, const FEGenericBase< typename FFunctor::RealType > &  fe  )

protectedinherited

Definition at line 3003 of file generic_projector.h.

{
  const auto & JxW = fe.get_JxW();
  const auto & phi = fe.get_phi();
  const std::vector<std::vector<typename FEGenericBase<typename FFunctor::RealType>::OutputGradient>> * dphi = nullptr;
  const std::vector<Point> & xyz_values = fe.get_xyz();
  const FEContinuity cont = fe.get_continuity();
  const std::unordered_map<dof_id_type, typename FFunctor::ValuePushType> & ids_to_save =
    this->projector.ids_to_save;
 
  if (cont == C_ONE)
    dphi = &(fe.get_dphi());
 
  const unsigned int n_involved_dofs =
    cast_int<unsigned int>(involved_dofs.size());
 
  std::vector<dof_id_type> free_dof_ids;
  DenseVector<typename FFunctor::ValuePushType> Uinvolved(n_involved_dofs);
  std::vector<char> dof_is_fixed(n_involved_dofs, false); // bools
 
  for (auto i : make_range(n_involved_dofs))
    {
      const dof_id_type id = dof_indices_var[involved_dofs[i]];
      auto iter = ids_to_save.find(id);
      if (iter == ids_to_save.end())
        free_dof_ids.push_back(id);
      else
        {
          dof_is_fixed[i] = true;
          Uinvolved(i) = iter->second;
        }
    }
 
  const unsigned int free_dofs = free_dof_ids.size();
 
  // There may be nothing to project
  if (!free_dofs)
    return;
 
  // The element matrix and RHS for projections.
  // Note that Ke is always real-valued, whereas
  // Fe may be complex valued if complex number
  // support is enabled
  DenseMatrix<Real> Ke(free_dofs, free_dofs);
  DenseVector<typename FFunctor::ValuePushType> Fe(free_dofs);
  // The new degree of freedom coefficients to solve for
  DenseVector<typename FFunctor::ValuePushType> Ufree(free_dofs);
 
  const unsigned int n_qp =
    cast_int<unsigned int>(xyz_values.size());
 
  // Loop over the quadrature points
  for (unsigned int qp=0; qp<n_qp; qp++)
    {
      // solution at the quadrature point
      FValue fineval = f.eval_at_point(context,
                                       var_component,
                                       xyz_values[qp],
                                       system.time,
                                       false);
      // solution grad at the quadrature point
      typename GFunctor::FunctorValue finegrad;
      if (cont == C_ONE)
        finegrad = g->eval_at_point(context,
                                    var_component,
                                    xyz_values[qp],
                                    system.time,
                                    false);
 
      // Form edge projection matrix
      for (unsigned int sidei=0, freei=0;
           sidei != n_involved_dofs; ++sidei)
        {
          unsigned int i = involved_dofs[sidei];
          // fixed DoFs aren't test functions
          if (dof_is_fixed[sidei])
            continue;
          for (unsigned int sidej=0, freej=0;
               sidej != n_involved_dofs; ++sidej)
            {
              unsigned int j = involved_dofs[sidej];
              if (dof_is_fixed[sidej])
                Fe(freei) -= phi[i][qp] * phi[j][qp] *
                  JxW[qp] * Uinvolved(sidej);
              else
                Ke(freei,freej) += phi[i][qp] *
                  phi[j][qp] * JxW[qp];
              if (cont == C_ONE)
                {
                  if (dof_is_fixed[sidej])
                    Fe(freei) -= ( TensorTools::inner_product((*dphi)[i][qp],
                                                              (*dphi)[j][qp]) ) *
                      JxW[qp] * Uinvolved(sidej);
                  else
                    Ke(freei,freej) += ( TensorTools::inner_product((*dphi)[i][qp],
                                                                    (*dphi)[j][qp]) )
                      * JxW[qp];
                }
              if (!dof_is_fixed[sidej])
                freej++;
            }
          Fe(freei) += phi[i][qp] * fineval * JxW[qp];
          if (cont == C_ONE)
            Fe(freei) += (TensorTools::inner_product(finegrad,
                                                     (*dphi)[i][qp]) ) *
              JxW[qp];
          freei++;
        }
    }
 
  Ke.cholesky_solve(Fe, Ufree);
 
  // Transfer new edge solutions to element
  const processor_id_type pid = node ?
    node->processor_id() : DofObject::invalid_processor_id;
  insert_ids(free_dof_ids, Ufree.get_values(), pid);
}

References libMesh::C_ONE, libMesh::DenseMatrix< T >::cholesky_solve(), libMesh::FEAbstract::get_continuity(), libMesh::FEGenericBase< OutputType >::get_dphi(), libMesh::FEAbstract::get_JxW(), libMesh::FEGenericBase< OutputType >::get_phi(), libMesh::DenseVector< T >::get_values(), libMesh::FEAbstract::get_xyz(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ids_to_save, libMesh::TensorTools::inner_product(), libMesh::DofObject::invalid_processor_id, libMesh::make_range(), libMesh::DofObject::processor_id(), libMesh::DenseVector< T >::size(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::system, and libMesh::System::time.

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 = 0>

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

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

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 263 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()

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 >::ProjectSides::operator()

(

const node_range &

range

)

Definition at line 2513 of file generic_projector.h.

{
  LOG_SCOPE ("project_sides","GenericProjector");
 
  const unsigned int sys_num = system.number();
 
  for (const auto & s_pair : range)
    {
      const Elem & elem = *std::get<0>(s_pair.second);
 
      // If this is an unchanged element then we already copied all
      // its dofs
#ifdef LIBMESH_ENABLE_AMR
      if (f.is_grid_projection() &&
          (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))
        continue;
#endif // LIBMESH_ENABLE_AMR
 
      const Node & side_node = *s_pair.first;
      const int dim = elem.dim();
      const var_set & side_vars = std::get<2>(s_pair.second);
 
      const unsigned int side_num = std::get<1>(s_pair.second);
      unsigned short node_num = elem.n_vertices()+side_num;
      // In 3D only some sides may have nodes
      if (dim == 3)
        for (auto n : make_range(elem.n_nodes()))
          {
            if (!elem.is_face(n))
              continue;
 
            if (elem.is_node_on_side(n, side_num))
              {
                node_num = n;
                break;
              }
          }
 
      context.side = side_num;
      context.pre_fe_reinit(system, &elem);
 
      this->find_dofs_to_send(side_node, elem, node_num, side_vars);
 
      // Look at all the variables we're supposed to interpolate from
      // this element on this side
      for (const auto & var : side_vars)
        {
          const Variable & variable = system.variable(var);
          const FEType & base_fe_type = variable.type();
          const unsigned int var_component =
            system.variable_scalar_number(var, 0);
 
          if (base_fe_type.family == SCALAR)
            continue;
 
          FEType fe_type = base_fe_type;
          const bool add_p_level = base_fe_type.p_refinement;
 
          // This may be a p refined element
          fe_type.order = fe_type.order + add_p_level*elem.p_level();
 
          // If this is a Lagrange element with DoFs on sides then by
          // convention we interpolate at the node rather than project
          // along the side.
          if (fe_type.family == LAGRANGE || fe_type.family == LAGRANGE_VEC)
            {
              // If order==1 then we only have DoFs on vertices, so
              // skip all this.
              // If order>1 ... we might still have something tricky
              // like order==2 PRISM20, where some side nodes have
              // DoFs but others don't.  Gotta check.
              if (fe_type.order > 1 &&
                  side_node.n_comp(sys_num, var))
                {
                  const processor_id_type pid =
                    side_node.processor_id();
                  FValue fval = f.eval_at_point
                    (context, var_component, side_node, system.time,
                     false);
 
                  if (fe_type.family == LAGRANGE_VEC)
                  {
                    // We will have a number of nodal value DoFs equal to the elem dim
                    for (auto i : make_range(elem.dim()))
                    {
                      const dof_id_type dof_id = side_node.dof_number(sys_num, var, i);
 
                      // Need this conversion so that this method
                      // will compile for TYPE_SCALAR instantiations
                      const auto insert_val =
                        raw_value<typename ProjectionAction::InsertInput>(fval, i);
 
                      insert_id(dof_id, insert_val, pid);
                    }
                  }
                  else // We are LAGRANGE
                  {
                    const dof_id_type dof_id =
                      side_node.dof_number(sys_num, var, 0);
                    insert_id(dof_id, fval, pid);
                  }
                }
              continue;
            }
 
#ifdef LIBMESH_ENABLE_AMR
          // If this is a low order monomial element which has merely
          // been h refined then we already copied all its dofs
          if (fe_type.family == MONOMIAL &&
              fe_type.order == CONSTANT &&
              elem.refinement_flag() != Elem::JUST_COARSENED &&
              elem.p_refinement_flag() != Elem::JUST_COARSENED)
            continue;
#endif // LIBMESH_ENABLE_AMR
 
          // FIXME: Need to generalize this to vector-valued elements. [PB]
          FEGenericBase<typename FFunctor::RealType> * fe = nullptr;
          context.get_element_fe( var, fe, dim );
          FEGenericBase<typename FFunctor::RealType> * side_fe = nullptr;
          context.get_side_fe( var, side_fe );
 
          // If we're JUST_COARSENED we'll need a custom
          // evaluation, not just the standard side FE
          const FEGenericBase<typename FFunctor::RealType> & proj_fe =
#ifdef LIBMESH_ENABLE_AMR
            (elem.refinement_flag() == Elem::JUST_COARSENED) ?
            *fe :
#endif
            *side_fe;
 
#ifdef LIBMESH_ENABLE_AMR
          if (elem.refinement_flag() == Elem::JUST_COARSENED)
            {
              std::vector<Point> fine_points;
 
              std::unique_ptr<FEGenericBase<typename FFunctor::RealType>> fine_fe
                (FEGenericBase<typename FFunctor::RealType>::build (dim, base_fe_type));
 
              std::unique_ptr<QBase> qrule
                (base_fe_type.default_quadrature_rule(1));
              fine_fe->attach_quadrature_rule(qrule.get());
 
              const std::vector<Point> & child_xyz =
                        fine_fe->get_xyz();
 
              for (unsigned int c = 0, nc = elem.n_children();
                   c != nc; ++c)
                {
                  if (!elem.is_child_on_side(c, context.side))
                    continue;
 
                  fine_fe->reinit(elem.child_ptr(c), context.side);
                  fine_points.insert(fine_points.end(),
                                     child_xyz.begin(),
                                     child_xyz.end());
                }
 
              std::vector<Point> fine_qp;
              FEMap::inverse_map (dim, &elem, fine_points, fine_qp);
 
              context.elem_fe_reinit(&fine_qp);
            }
          else
#endif // LIBMESH_ENABLE_AMR
            context.side_fe_reinit();
 
          const std::vector<dof_id_type> & dof_indices =
            context.get_dof_indices(var);
 
          std::vector<unsigned int> side_dofs;
          FEInterface::dofs_on_side(&elem, dim, base_fe_type,
                                    context.side, side_dofs, add_p_level);
 
          this->construct_projection
            (dof_indices, side_dofs, var_component,
             &side_node, proj_fe);
        }
    }
}

References libMesh::Elem::child_ptr(), libMesh::CONSTANT, libMesh::FEType::default_quadrature_rule(), dim, libMesh::Elem::dim(), libMesh::DofObject::dof_number(), libMesh::FEInterface::dofs_on_side(), libMesh::FEType::family, libMesh::FEMap::inverse_map(), libMesh::Elem::is_child_on_side(), libMesh::Elem::is_face(), libMesh::Elem::is_node_on_side(), libMesh::Elem::JUST_COARSENED, libMesh::Elem::JUST_REFINED, libMesh::LAGRANGE, libMesh::LAGRANGE_VEC, libMesh::make_range(), libMesh::MONOMIAL, libMesh::Elem::n_children(), libMesh::DofObject::n_comp(), libMesh::Elem::n_nodes(), libMesh::Elem::n_vertices(), libMesh::System::number(), libMesh::FEType::order, libMesh::Elem::p_level(), libMesh::FEType::p_refinement, libMesh::Elem::p_refinement_flag(), libMesh::DofObject::processor_id(), libMesh::Elem::refinement_flag(), libMesh::SCALAR, libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::system, libMesh::System::time, libMesh::Variable::type(), libMesh::System::variable(), and libMesh::System::variable_scalar_number().

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 256 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 259 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

Definition at line 260 of file generic_projector.h.

f

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

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

Definition at line 257 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

Definition at line 240 of file generic_projector.h.

g

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

std::unique_ptr<GFunctor> libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubProjector::g

Definition at line 267 of file generic_projector.h.

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().

system

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

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

Definition at line 258 of file generic_projector.h.

---

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

• include/systems/generic_projector.h