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

#include <generic_projector.h>

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

Public Member Functions
	ProjectVertices (GenericProjector &p)
	ProjectVertices (ProjectVertices &p_v, Threads::split)
void	operator() (const node_range &range)
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	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 FEBase &fe)
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	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
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 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 FEBase &fe)

Detailed Description

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

Definition at line 262 of file generic_projector.h.

Constructor & Destructor Documentation

ProjectVertices() [1/2]

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

libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectVertices::ProjectVertices

(

GenericProjector &

p

)

Definition at line 263 of file generic_projector.h.

: SubProjector(p) {}

ProjectVertices() [2/2]

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

libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::ProjectVertices::ProjectVertices	(	ProjectVertices &	p_v,
		Threads::split
	)

Definition at line 265 of file generic_projector.h.

: SubProjector(p_v.projector) {}

Member Function Documentation

construct_projection() [1/2]

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 FEBase &  fe  )

protectedinherited

Definition at line 2478 of file generic_projector.h.

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::DofObject::invalid_processor_id, libMesh::DofObject::processor_id(), and libMesh::DenseVector< T >::size().

{
  const std::vector<Real> & JxW = fe.get_JxW();
  const std::vector<std::vector<Real>> & phi = fe.get_phi();
  const std::vector<std::vector<RealGradient>> * dphi = nullptr;
  const std::vector<Point> & xyz_values = fe.get_xyz();
  const FEContinuity cont = fe.get_continuity();
  const std::unordered_map<dof_id_type, FValue> & 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<FValue> Uinvolved(n_involved_dofs);
  std::vector<char> dof_is_fixed(n_involved_dofs, false); // bools

  for (auto i : IntRange<unsigned int>(0, 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<FValue> Fe(free_dofs);
  // The new degree of freedom coefficients to solve for
  DenseVector<FValue> 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);
      // solution grad at the quadrature point
      VectorValue<FValue> finegrad;
      if (cont == C_ONE)
        finegrad = g->eval_at_point(context,
                                    var_component,
                                    xyz_values[qp],
                                    system.time);

      // 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) -= ( (*dphi)[i][qp] *
                                   (*dphi)[j][qp] ) *
                      JxW[qp] * Uinvolved(sidej);
                  else
                    Ke(freei,freej) += ( (*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) += (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);
}

construct_projection() [2/2]

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

void libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubProjector::construct_projection

Definition at line 2478 of file generic_projector.h.

{
  const std::vector<Real> & JxW = fe.get_JxW();
  const std::vector<std::vector<Real>> & phi = fe.get_phi();
  const std::vector<std::vector<RealGradient>> * dphi = nullptr;
  const std::vector<Point> & xyz_values = fe.get_xyz();
  const FEContinuity cont = fe.get_continuity();
  const std::unordered_map<dof_id_type, FValue> & 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<FValue> Uinvolved(n_involved_dofs);
  std::vector<char> dof_is_fixed(n_involved_dofs, false); // bools

  for (auto i : IntRange<unsigned int>(0, 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<FValue> Fe(free_dofs);
  // The new degree of freedom coefficients to solve for
  DenseVector<FValue> 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);
      // solution grad at the quadrature point
      VectorValue<FValue> finegrad;
      if (cont == C_ONE)
        finegrad = g->eval_at_point(context,
                                    var_component,
                                    xyz_values[qp],
                                    system.time);

      // 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) -= ( (*dphi)[i][qp] *
                                   (*dphi)[j][qp] ) *
                      JxW[qp] * Uinvolved(sidej);
                  else
                    Ke(freei,freej) += ( (*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) += (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);
}

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

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::Elem::node_ptr(), libMesh::DofObject::processor_id(), and libMesh::Elem::subdomain_id().

{
  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;
    }
}

insert_id() [1/2]

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

References libMesh::DofObject::invalid_processor_id.

{
  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;
    }
}

insert_id() [2/2]

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

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

Definition at line 1112 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;
    }
}

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

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

{
  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;
        }
    }
}

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

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

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

{
  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());
}

operator()()

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

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

(

const node_range &

range

)

Definition at line 1637 of file generic_projector.h.

References libMesh::C_ONE, libMesh::C_ZERO, libMesh::Elem::dim(), libMesh::DISCONTINUOUS, libMesh::DofObject::dof_number(), libMesh::FEInterface::extra_hanging_dofs(), libMesh::FEType::family, libMesh::Elem::get_node_index(), libMesh::HERMITE, libMesh::Elem::hmin(), libMesh::DofObject::id(), libMesh::Elem::is_vertex_on_parent(), libMesh::DofObject::n_comp(), libMesh::FEInterface::n_dofs_at_node(), libMesh::Elem::parent(), libMesh::Elem::point(), libMesh::DofObject::processor_id(), libMesh::Real, libMesh::SCALAR, libMesh::TOLERANCE, libMesh::Variable::type(), libMesh::Elem::type(), and libMesh::Elem::which_child_am_i().

{
  LOG_SCOPE ("project_vertices","GenericProjector");

  const unsigned int sys_num = system.number();

  // Variables with extra hanging dofs can't safely use eval_at_node
  // in as many places as variables without can.
  std::vector<unsigned short> extra_hanging_dofs;
  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());
    }

  for (const auto & v_pair : range)
    {
      const Node & vertex = *v_pair.first;
      const Elem & elem = *std::get<0>(v_pair.second);
      const unsigned int n = std::get<1>(v_pair.second);
      const var_set & vertex_vars = std::get<2>(v_pair.second);

      context.pre_fe_reinit(system, &elem);

      this->find_dofs_to_send(vertex, elem, n, vertex_vars);

      // Look at all the variables we're supposed to interpolate from
      // this element on this vertex
      for (const auto & var : vertex_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;

          const FEContinuity & cont = this->conts[var];
          if (cont == DISCONTINUOUS)
            {
              libmesh_assert_equal_to(vertex.n_comp(sys_num, var), 0);
            }
          else if (cont == C_ZERO)
            {
              libmesh_assert(vertex.n_comp(sys_num, var));
              const dof_id_type id = vertex.dof_number(sys_num, var, 0);
              // C_ZERO elements have a single nodal value DoF at vertices
              const FValue val = f.eval_at_node
                (context, var_component, /*dim=*/ 0, // Don't care w/C0
                 vertex, extra_hanging_dofs[var], system.time);
              insert_id(id, val, vertex.processor_id());
            }
          else if (cont == C_ONE)
            {
              libmesh_assert(vertex.n_comp(sys_num, var));
              const dof_id_type first_id = vertex.dof_number(sys_num, var, 0);

              // C_ONE elements have a single nodal value and dim
              // gradient values at vertices, as well as cross
              // gradients for HERMITE.  We need to have an element in
              // hand to figure out dim and to have in case this
              // vertex is a new vertex.
              const int dim = elem.dim();
#ifndef NDEBUG
              // For now all C1 elements at a vertex had better have
              // the same dimension.  If anyone hits these asserts let
              // me know; we could probably support a mixed-dimension
              // mesh IFF the 2D elements were all parallel to xy and
              // the 1D elements all parallel to x.
              for (const auto e_id : (*this->projector.nodes_to_elem)[vertex.id()])
                {
                  const Elem & e = system.get_mesh().elem_ref(e_id);
                  libmesh_assert_equal_to(dim, e.dim());
                }
#endif
#ifdef LIBMESH_ENABLE_AMR
              bool is_parent_vertex = false;
              if (elem.parent())
                {
                  const int i_am_child =
                    elem.parent()->which_child_am_i(&elem);
                  is_parent_vertex =
                    elem.parent()->is_vertex_on_parent(i_am_child, n);
                }
#else
              const bool is_parent_vertex = false;
#endif

              // The hermite element vertex shape functions are weird
              if (base_fe_type.family == HERMITE)
                {
                  const FValue val =
                    f.eval_at_node(context,
                                   var_component,
                                   dim,
                                   vertex,
                                   extra_hanging_dofs[var],
                                   system.time);
                  insert_id(first_id, val, vertex.processor_id());

                  VectorValue<FValue> grad =
                    is_parent_vertex ?
                    g->eval_at_node(context,
                                    var_component,
                                    dim,
                                    vertex,
                                    extra_hanging_dofs[var],
                                    system.time) :
                    g->eval_at_point(context,
                                     var_component,
                                     vertex,
                                     system.time);
                  // x derivative
                  insert_id(first_id+1, grad(0),
                            vertex.processor_id());
                  if (dim > 1)
                    {
                      // We'll finite difference mixed derivatives
                      Real delta_x = TOLERANCE * elem.hmin();

                      Point nxminus = elem.point(n),
                            nxplus = elem.point(n);
                      nxminus(0) -= delta_x;
                      nxplus(0) += delta_x;
                      VectorValue<FValue> gxminus =
                        g->eval_at_point(context,
                                         var_component,
                                         nxminus,
                                         system.time);
                      VectorValue<FValue> gxplus =
                        g->eval_at_point(context,
                                         var_component,
                                         nxplus,
                                         system.time);
                      // y derivative
                      insert_id(first_id+2, grad(1),
                                vertex.processor_id());
                      // xy derivative
                      insert_id(first_id+3,
                        (gxplus(1) - gxminus(1)) / 2. / delta_x,
                        vertex.processor_id());

                      if (dim > 2)
                        {
                          // z derivative
                          insert_id(first_id+4, grad(2),
                                    vertex.processor_id());
                          // xz derivative
                          insert_id(first_id+5,
                            (gxplus(2) - gxminus(2)) / 2. / delta_x,
                            vertex.processor_id());

                          // We need new points for yz
                          Point nyminus = elem.point(n),
                            nyplus = elem.point(n);
                          nyminus(1) -= delta_x;
                          nyplus(1) += delta_x;
                          VectorValue<FValue> gyminus =
                            g->eval_at_point(context,
                                             var_component,
                                             nyminus,
                                             system.time);
                          VectorValue<FValue> gyplus =
                            g->eval_at_point(context,
                                             var_component,
                                             nyplus,
                                             system.time);
                          // yz derivative
                          insert_id(first_id+6,
                            (gyplus(2) - gyminus(2)) / 2. / delta_x,
                            vertex.processor_id());
                          // Getting a 2nd order xyz is more tedious
                          Point nxmym = elem.point(n),
                            nxmyp = elem.point(n),
                            nxpym = elem.point(n),
                            nxpyp = elem.point(n);
                          nxmym(0) -= delta_x;
                          nxmym(1) -= delta_x;
                          nxmyp(0) -= delta_x;
                          nxmyp(1) += delta_x;
                          nxpym(0) += delta_x;
                          nxpym(1) -= delta_x;
                          nxpyp(0) += delta_x;
                          nxpyp(1) += delta_x;
                          VectorValue<FValue> gxmym =
                            g->eval_at_point(context,
                                             var_component,
                                             nxmym,
                                             system.time);
                          VectorValue<FValue> gxmyp =
                            g->eval_at_point(context,
                                             var_component,
                                             nxmyp,
                                             system.time);
                          VectorValue<FValue> gxpym =
                            g->eval_at_point(context,
                                             var_component,
                                             nxpym,
                                             system.time);
                          VectorValue<FValue> gxpyp =
                            g->eval_at_point(context,
                                             var_component,
                                             nxpyp,
                                             system.time);
                          FValue gxzplus = (gxpyp(2) - gxmyp(2))
                            / 2. / delta_x;
                          FValue gxzminus = (gxpym(2) - gxmym(2))
                            / 2. / delta_x;
                          // xyz derivative
                          insert_id(first_id+7,
                            (gxzplus - gxzminus) / 2. / delta_x,
                            vertex.processor_id());
                        }
                    }
                }
              else
                {
                  // Currently other C_ONE elements have a single nodal
                  // value shape function and nodal gradient component
                  // shape functions
                  libmesh_assert_equal_to
                    (FEInterface::n_dofs_at_node
                      (dim, base_fe_type, elem.type(),
                       elem.get_node_index(&vertex)),
                    (unsigned int)(1 + dim));
                  const FValue val =
                    f.eval_at_node(context, var_component, dim,
                                   vertex, extra_hanging_dofs[var],
                                   system.time);
                  insert_id(first_id, val, vertex.processor_id());
                  VectorValue<FValue> grad =
                    is_parent_vertex ?
                    g->eval_at_node(context, var_component, dim,
                                    vertex, extra_hanging_dofs[var],
                                    system.time) :
                    g->eval_at_point(context, var_component, vertex,
                                     system.time);
                  for (int i=0; i!= dim; ++i)
                    insert_id(first_id + i + 1, grad(i),
                              vertex.processor_id());
                }
            }
          else
            libmesh_error_msg("Unknown continuity " << cont);
        }
    }
}

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 188 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 193 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 196 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 189 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 222 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<FValue, processor_id_type> > libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::SubFunctor::new_ids_to_push

inherited

Definition at line 160 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 164 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 149 of file generic_projector.h.

system

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

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

Definition at line 198 of file generic_projector.h.

---

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

• include/systems/generic_projector.h