libMesh::OldSolutionValue< Output, point_output > Class Template Reference

The OldSolutionValue input functor class can be used with GenericProjector to read values from a solution on a just-refined-and-coarsened mesh. More...

#include <generic_projector.h>

Inheritance diagram for libMesh::OldSolutionValue< Output, point_output >:

Public Types
typedef Output	FunctorValue
typedef DofValueType	ValuePushType
typedef TensorTools::MakeReal< Output >::type	RealType

Public Member Functions
	OldSolutionValue (const libMesh::System &sys_in, const NumericVector< Number > &old_sol, const std::vector< unsigned int > *vars)
	OldSolutionValue (const OldSolutionValue &in)
Output	eval_at_node (const FEMContext &c, unsigned int i, unsigned int elem_dim, const Node &n, bool, Real=0.)
Output	eval_at_point (const FEMContext &c, unsigned int i, const Point &p, Real, bool skip_context_check)
template<typename T = Output, typename std::enable_if< std::is_same< T, Number >::value, int >::type = 0>
void	eval_mixed_derivatives (const FEMContext &libmesh_dbg_var(c), unsigned int i, unsigned int dim, const Node &n, std::vector< Output > &derivs)
template<typename T = Output, typename std::enable_if<!std::is_same< T, Number >::value, int >::type = 0>
void	eval_mixed_derivatives (const FEMContext &, unsigned int, unsigned int, const Node &, std::vector< Output > &)
void	eval_old_dofs (const Elem &elem, unsigned int node_num, unsigned int var_num, std::vector< dof_id_type > &indices, std::vector< DofValueType > &values)
void	eval_old_dofs (const Elem &elem, const FEType &fe_type, unsigned int sys_num, unsigned int var_num, std::vector< dof_id_type > &indices, std::vector< DofValueType > &values)
template<>
Number	eval_at_node (const FEMContext &c, unsigned int i, unsigned int, const Node &n, bool extra_hanging_dofs, Real)
template<>
Gradient	eval_at_node (const FEMContext &c, unsigned int i, unsigned int, const Node &n, bool extra_hanging_dofs, Real)
template<>
Gradient	eval_at_node (const FEMContext &c, unsigned int i, unsigned int elem_dim, const Node &n, bool extra_hanging_dofs, Real)
template<>
Tensor	eval_at_node (const FEMContext &, unsigned int, unsigned int, const Node &, bool, Real)
template<>
void	get_shape_outputs (FEAbstract &fe)
template<>
void	get_shape_outputs (FEAbstract &fe)
template<>
void	get_shape_outputs (FEAbstract &fe)
template<>
void	get_shape_outputs (FEAbstract &fe)
template<>
void	get_shape_outputs (FEAbstract &fe)
template<>
void	get_shape_outputs (FEAbstract &fe)
template<>
void	get_shape_outputs (FEAbstract &fe)
template<>
void	get_shape_outputs (FEAbstract &fe)
void	init_context (FEMContext &c)
bool	is_grid_projection ()

Static Public Member Functions
static void	get_shape_outputs (FEAbstract &fe)

Protected Types
typedef TensorTools::MakeBaseNumber< Output >::type	DofValueType

Protected Member Functions
void	check_old_context (const FEMContext &c)
bool	check_old_context (const FEMContext &c, const Point &p)

Protected Attributes
const Elem *	last_elem
const System &	sys
FEMContext	old_context
std::vector< unsigned int >	component_to_var

Static Protected Attributes
static const Real	out_of_elem_tol = 10 * TOLERANCE

Private Attributes
const NumericVector< Number > &	old_solution

Detailed Description

template<typename Output, void(FEMContext::*)(unsigned int, const Point &, Output &, const Real) const point_output>
class libMesh::OldSolutionValue< Output, point_output >

The OldSolutionValue input functor class can be used with GenericProjector to read values from a solution on a just-refined-and-coarsened mesh.

Author

Roy H. Stogner

Date

2016

Definition at line 719 of file generic_projector.h.

Member Typedef Documentation

DofValueType

template<typename Output, void(FEMContext::*)(unsigned int, const Point &, Output &, const Real) const point_output>

typedef TensorTools::MakeBaseNumber<Output>::type libMesh::OldSolutionBase< Output, point_output >::DofValueType

protectedinherited

Definition at line 527 of file generic_projector.h.

FunctorValue

template<typename Output, void(FEMContext::*)(unsigned int, const Point &, Output &, const Real) const point_output>

typedef Output libMesh::OldSolutionValue< Output, point_output >::FunctorValue

Definition at line 724 of file generic_projector.h.

RealType

template<typename Output, void(FEMContext::*)(unsigned int, const Point &, Output &, const Real) const point_output>

typedef TensorTools::MakeReal<Output>::type libMesh::OldSolutionBase< Output, point_output >::RealType

inherited

Definition at line 529 of file generic_projector.h.

ValuePushType

template<typename Output, void(FEMContext::*)(unsigned int, const Point &, Output &, const Real) const point_output>

typedef DofValueType libMesh::OldSolutionValue< Output, point_output >::ValuePushType

Definition at line 725 of file generic_projector.h.

Constructor & Destructor Documentation

OldSolutionValue() [1/2]

template<typename Output, void(FEMContext::*)(unsigned int, const Point &, Output &, const Real) const point_output>

libMesh::OldSolutionValue< Output, point_output >::OldSolutionValue ( const libMesh::System &  sys_in, const NumericVector< Number > &  old_sol, const std::vector< unsigned int > *  vars  )

inline

Definition at line 727 of file generic_projector.h.

References libMesh::FEMContext::OLD.

                                                         :
      OldSolutionBase<Output, point_output>(sys_in, vars),
      old_solution(old_sol)
  {
    this->old_context.set_algebraic_type(FEMContext::OLD);
    this->old_context.set_custom_solution(&old_solution);
  }

OldSolutionValue() [2/2]

template<typename Output, void(FEMContext::*)(unsigned int, const Point &, Output &, const Real) const point_output>

libMesh::OldSolutionValue< Output, point_output >::OldSolutionValue ( const OldSolutionValue< Output, point_output > &  in )

inline

Definition at line 737 of file generic_projector.h.

References libMesh::FEMContext::OLD.

                                                :
      OldSolutionBase<Output, point_output>(in.sys, in.old_context.active_vars()),
      old_solution(in.old_solution)
  {
    this->old_context.set_algebraic_type(FEMContext::OLD);
    this->old_context.set_custom_solution(&old_solution);
  }

Member Function Documentation

check_old_context() [1/2]

template<typename Output, void(FEMContext::*)(unsigned int, const Point &, Output &, const Real) const point_output>

void libMesh::OldSolutionBase< Output, point_output >::check_old_context ( const FEMContext &  c )

inlineprotectedinherited

Definition at line 596 of file generic_projector.h.

References libMesh::FEMContext::get_elem(), libMesh::DofObject::get_old_dof_object(), libMesh::Elem::JUST_COARSENED, libMesh::Elem::JUST_REFINED, libMesh::libmesh_assert(), libMesh::Elem::parent(), and libMesh::Elem::refinement_flag().

  {
    LOG_SCOPE ("check_old_context(c)", "OldSolutionBase");
    const Elem & elem = c.get_elem();
    if (last_elem != &elem)
      {
        if (elem.refinement_flag() == Elem::JUST_REFINED)
          {
            old_context.pre_fe_reinit(sys, elem.parent());
          }
        else if (elem.refinement_flag() == Elem::JUST_COARSENED)
          {
            libmesh_error();
          }
        else
          {
            if (!elem.get_old_dof_object())
              {
                libmesh_error();
              }

            old_context.pre_fe_reinit(sys, &elem);
          }

        last_elem = &elem;
      }
    else
      {
        libmesh_assert(old_context.has_elem());
      }
  }

check_old_context() [2/2]

template<typename Output, void(FEMContext::*)(unsigned int, const Point &, Output &, const Real) const point_output>

bool libMesh::OldSolutionBase< Output, point_output >::check_old_context ( const FEMContext &  c, const Point &  p  )

inlineprotectedinherited

Definition at line 629 of file generic_projector.h.

References libMesh::Elem::child_ref_range(), libMesh::FEMContext::get_elem(), libMesh::DofObject::get_old_dof_object(), libMesh::Elem::hmax(), libMesh::Elem::JUST_COARSENED, libMesh::Elem::JUST_REFINED, libMesh::libmesh_assert(), libMesh::Elem::parent(), libMesh::Real, and libMesh::Elem::refinement_flag().

  {
    LOG_SCOPE ("check_old_context(c,p)", "OldSolutionBase");
    const Elem & elem = c.get_elem();
    if (last_elem != &elem)
      {
        if (elem.refinement_flag() == Elem::JUST_REFINED)
          {
            old_context.pre_fe_reinit(sys, elem.parent());
          }
        else if (elem.refinement_flag() == Elem::JUST_COARSENED)
          {
            // Find the child with this point.  Use out_of_elem_tol
            // (in physical space, which may correspond to a large
            // tolerance in master space!) to allow for out-of-element
            // finite differencing of mixed gradient terms.  Pray we
            // have no quadrature locations which are within 1e-5 of
            // the element subdivision boundary but are not exactly on
            // that boundary.
            const Real master_tol = out_of_elem_tol / elem.hmax() * 2;

            for (auto & child : elem.child_ref_range())
              if (child.close_to_point(p, master_tol))
                {
                  old_context.pre_fe_reinit(sys, &child);
                  break;
                }

            libmesh_assert
              (old_context.get_elem().close_to_point(p, master_tol));
          }
        else
          {
            if (!elem.get_old_dof_object())
              return false;

            old_context.pre_fe_reinit(sys, &elem);
          }

        last_elem = &elem;
      }
    else
      {
        libmesh_assert(old_context.has_elem());

        const Real master_tol = out_of_elem_tol / elem.hmax() * 2;

        if (!old_context.get_elem().close_to_point(p, master_tol))
          {
            libmesh_assert_equal_to
              (elem.refinement_flag(), Elem::JUST_COARSENED);

            for (auto & child : elem.child_ref_range())
              if (child.close_to_point(p, master_tol))
                {
                  old_context.pre_fe_reinit(sys, &child);
                  break;
                }

            libmesh_assert
              (old_context.get_elem().close_to_point(p, master_tol));
          }
      }

    return true;
  }

eval_at_node() [1/5]

template<typename Output, void(FEMContext::*)(unsigned int, const Point &, Output &, const Real) const point_output>

Output libMesh::OldSolutionValue< Output, point_output >::eval_at_node	(	const FEMContext &	c,
		unsigned int	i,
		unsigned int	elem_dim,
		const Node &	n,
		bool	,
		Real	= 0.
	)

eval_at_node() [2/5]

template<>

Number libMesh::OldSolutionValue< Number, &FEMContext::point_value >::eval_at_node ( const FEMContext &  c, unsigned int  i, unsigned  int, const Node &  n, bool  extra_hanging_dofs, Real    )

inline

Definition at line 1010 of file generic_projector.h.

References libMesh::Elem::DO_NOTHING, libMesh::DofObject::dof_number(), libMesh::FEMContext::get_elem(), libMesh::Elem::get_node_index(), libMesh::DofObject::get_old_dof_object(), libMesh::Elem::JUST_COARSENED, libMesh::DofObject::n_comp(), libMesh::DofObject::n_vars(), libMesh::Elem::n_vertices(), and libMesh::Elem::refinement_flag().

{
  LOG_SCOPE ("Number eval_at_node()", "OldSolutionValue");

  // This should only be called on vertices
  libmesh_assert_less(c.get_elem().get_node_index(&n),
                      c.get_elem().n_vertices());

  // Handle offset from non-scalar components in previous variables
  libmesh_assert_less(i, this->component_to_var.size());
  unsigned int var = this->component_to_var[i];

  // Optimize for the common case, where this node was part of the
  // old solution.
  //
  // Be sure to handle cases where the variable wasn't defined on
  // this node (due to changing subdomain support) or where the
  // variable has no components on this node (due to Elem order
  // exceeding FE order) or where the old_dof_object dofs might
  // correspond to non-vertex dofs (due to extra_hanging_dofs and
  // refinement)

  const Elem::RefinementState flag = c.get_elem().refinement_flag();

  const DofObject * old_dof_object = n.get_old_dof_object();
  if (old_dof_object &&
      (!extra_hanging_dofs ||
       flag == Elem::JUST_COARSENED ||
       flag == Elem::DO_NOTHING) &&
      old_dof_object->n_vars(sys.number()) &&
      old_dof_object->n_comp(sys.number(), var))
    {
      const dof_id_type old_id =
        old_dof_object->dof_number(sys.number(), var, 0);
      return old_solution(old_id);
    }

  return this->eval_at_point(c, i, n, 0, false);
}

eval_at_node() [3/5]

template<>

Gradient libMesh::OldSolutionValue< Gradient, &FEMContext::point_value >::eval_at_node ( const FEMContext &  c, unsigned int  i, unsigned  int, const Node &  n, bool  extra_hanging_dofs, Real    )

inline

Definition at line 1059 of file generic_projector.h.

References dim, libMesh::Elem::DO_NOTHING, libMesh::DofObject::dof_number(), libMesh::FEMContext::get_elem(), libMesh::Elem::get_node_index(), libMesh::DofObject::get_old_dof_object(), libMesh::Elem::JUST_COARSENED, libMesh::make_range(), libMesh::DofObject::n_comp(), libMesh::DofObject::n_vars(), libMesh::Elem::n_vertices(), and libMesh::Elem::refinement_flag().

{
  LOG_SCOPE ("Number eval_at_node()", "OldSolutionValue");

  // This should only be called on vertices
  libmesh_assert_less(c.get_elem().get_node_index(&n),
                      c.get_elem().n_vertices());

  // Handle offset from non-scalar components in previous variables
  libmesh_assert_less(i, this->component_to_var.size());
  unsigned int var = this->component_to_var[i];

  // Optimize for the common case, where this node was part of the
  // old solution.
  //
  // Be sure to handle cases where the variable wasn't defined on
  // this node (due to changing subdomain support) or where the
  // variable has no components on this node (due to Elem order
  // exceeding FE order) or where the old_dof_object dofs might
  // correspond to non-vertex dofs (due to extra_hanging_dofs and
  // refinement)

  const auto & elem = c.get_elem();

  const Elem::RefinementState flag = elem.refinement_flag();

  const DofObject * old_dof_object = n.get_old_dof_object();
  if (old_dof_object &&
      (!extra_hanging_dofs ||
       flag == Elem::JUST_COARSENED ||
       flag == Elem::DO_NOTHING) &&
      old_dof_object->n_vars(sys.number()) &&
      old_dof_object->n_comp(sys.number(), var))
    {
      Gradient return_val;

      for (auto dim : make_range(elem.dim()))
      {
        const dof_id_type old_id =
          old_dof_object->dof_number(sys.number(), var, dim);
        return_val(dim) = old_solution(old_id);
      }

      return return_val;
    }

  return this->eval_at_point(c, i, n, 0, false);
}

eval_at_node() [4/5]

template<>

Gradient libMesh::OldSolutionValue< Gradient, &FEMContext::point_gradient >::eval_at_node ( const FEMContext &  c, unsigned int  i, unsigned int  elem_dim, const Node &  n, bool  extra_hanging_dofs, Real    )

inline

Definition at line 1119 of file generic_projector.h.

References libMesh::Elem::DO_NOTHING, libMesh::DofObject::dof_number(), libMesh::FEMContext::get_elem(), libMesh::Elem::get_node_index(), libMesh::DofObject::get_old_dof_object(), libMesh::Elem::JUST_COARSENED, libMesh::DofObject::n_comp(), libMesh::DofObject::n_vars(), libMesh::Elem::n_vertices(), and libMesh::Elem::refinement_flag().

{
  LOG_SCOPE ("Gradient eval_at_node()", "OldSolutionValue");

  // This should only be called on vertices
  libmesh_assert_less(c.get_elem().get_node_index(&n),
                      c.get_elem().n_vertices());

  // Handle offset from non-scalar components in previous variables
  libmesh_assert_less(i, this->component_to_var.size());
  unsigned int var = this->component_to_var[i];

  // Optimize for the common case, where this node was part of the
  // old solution.
  //
  // Be sure to handle cases where the variable wasn't defined on
  // this node (due to changing subdomain support) or where the
  // variable has no components on this node (due to Elem order
  // exceeding FE order) or where the old_dof_object dofs might
  // correspond to non-vertex dofs (due to extra_hanging_dofs and
  // refinement)

  const Elem::RefinementState flag = c.get_elem().refinement_flag();

  const DofObject * old_dof_object = n.get_old_dof_object();
  if (old_dof_object &&
      (!extra_hanging_dofs ||
       flag == Elem::JUST_COARSENED ||
       flag == Elem::DO_NOTHING) &&
      old_dof_object->n_vars(sys.number()) &&
      old_dof_object->n_comp(sys.number(), var))
    {
      Gradient g;
      for (unsigned int d = 0; d != elem_dim; ++d)
        {
          const dof_id_type old_id =
            old_dof_object->dof_number(sys.number(), var, d+1);
          g(d) = old_solution(old_id);
        }
      return g;
    }

  return this->eval_at_point(c, i, n, 0, false);
}

eval_at_node() [5/5]

template<>

Tensor libMesh::OldSolutionValue< Tensor, &FEMContext::point_gradient >::eval_at_node ( const FEMContext &  , unsigned  int, unsigned  int, const Node &  , bool  , Real    )

inline

Definition at line 1173 of file generic_projector.h.

{
  libmesh_error_msg("You shouldn't need to call eval_at_node for the gradient "
                    "functor for a vector-valued finite element type");
  return Tensor();
}

eval_at_point()

template<typename Output, void(FEMContext::*)(unsigned int, const Point &, Output &, const Real) const point_output>

Output libMesh::OldSolutionValue< Output, point_output >::eval_at_point ( const FEMContext &  c, unsigned int  i, const Point &  p, Real  , bool  skip_context_check  )

inline

Definition at line 753 of file generic_projector.h.

  {
    LOG_SCOPE ("eval_at_point()", "OldSolutionValue");

    if (!skip_context_check)
      if (!this->check_old_context(c, p))
        return Output(0);

    // Handle offset from non-scalar components in previous variables
    libmesh_assert_less(i, this->component_to_var.size());
    unsigned int var = this->component_to_var[i];

    Output n;
    (this->old_context.*point_output)(var, p, n, this->out_of_elem_tol);
    return n;
  }

eval_mixed_derivatives() [1/2]

template<typename Output, void(FEMContext::*)(unsigned int, const Point &, Output &, const Real) const point_output>

template<typename T = Output, typename std::enable_if< std::is_same< T, Number >::value, int >::type = 0>

void libMesh::OldSolutionValue< Output, point_output >::eval_mixed_derivatives ( const FEMContext &  libmesh_dbg_varc, unsigned int  i, unsigned int  dim, const Node &  n, std::vector< Output > &  derivs  )

inline

Definition at line 776 of file generic_projector.h.

References dim, libMesh::DofObject::dof_number(), libMesh::DofObject::get_old_dof_object(), libMesh::Utility::iota(), libMesh::DofObject::n_comp(), and libMesh::DofObject::n_vars().

  {
    LOG_SCOPE ("eval_mixed_derivatives", "OldSolutionValue");

    // This should only be called on vertices
    libmesh_assert_less(c.get_elem().get_node_index(&n),
                        c.get_elem().n_vertices());

    // Handle offset from non-scalar components in previous variables
    libmesh_assert_less(i, this->component_to_var.size());
    unsigned int var = this->component_to_var[i];

    // We have 1 mixed derivative in 2D, 4 in 3D
    const unsigned int n_mixed = (dim-1) * (dim-1);
    derivs.resize(n_mixed);

    // Be sure to handle cases where the variable wasn't defined on
    // this node (e.g. due to changing subdomain support)
    const DofObject * old_dof_object = n.get_old_dof_object();
    if (old_dof_object &&
        old_dof_object->n_vars(this->sys.number()) &&
        old_dof_object->n_comp(this->sys.number(), var))
      {
        const dof_id_type first_old_id =
          old_dof_object->dof_number(this->sys.number(), var, dim);
        std::vector<dof_id_type> old_ids(n_mixed);
        std::iota(old_ids.begin(), old_ids.end(), first_old_id);
        old_solution.get(old_ids, derivs);
      }
    else
      {
        std::fill(derivs.begin(), derivs.end(), 0);
      }
  }

eval_mixed_derivatives() [2/2]

template<typename Output, void(FEMContext::*)(unsigned int, const Point &, Output &, const Real) const point_output>

template<typename T = Output, typename std::enable_if<!std::is_same< T, Number >::value, int >::type = 0>

void libMesh::OldSolutionValue< Output, point_output >::eval_mixed_derivatives ( const FEMContext &  , unsigned  int, unsigned  int, const Node &  , std::vector< Output > &    )

inline

Definition at line 817 of file generic_projector.h.

  {
    libmesh_error_msg("eval_mixed_derivatives should only be applicable for Hermite finite element "
                      "types. I don't know how you got here");
  }

eval_old_dofs() [1/2]

template<typename Output, void(FEMContext::*)(unsigned int, const Point &, Output &, const Real) const point_output>

void libMesh::OldSolutionValue< Output, point_output >::eval_old_dofs ( const Elem &  elem, unsigned int  node_num, unsigned int  var_num, std::vector< dof_id_type > &  indices, std::vector< DofValueType > &  values  )

inline

Definition at line 824 of file generic_projector.h.

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

  {
    LOG_SCOPE ("eval_old_dofs(node)", "OldSolutionValue");

    // We may be reusing a std::vector here, but the following
    // dof_indices call appends without first clearing.
    indices.clear();

    this->sys.get_dof_map().dof_indices(elem, node_num, indices, var_num);

    std::vector<dof_id_type> old_indices;

    this->sys.get_dof_map().old_dof_indices(elem, node_num, old_indices, var_num);

    libmesh_assert_equal_to (old_indices.size(), indices.size());

    // We may have invalid_id in cases where no old DoF existed, e.g.
    // due to expansion of a subdomain-restricted variable's subdomain
    bool invalid_old_index = false;
    for (const auto & di : old_indices)
      if (di == DofObject::invalid_id)
        invalid_old_index = true;

    values.resize(old_indices.size());
    if (invalid_old_index)
      {
        for (auto i : index_range(old_indices))
          {
            const dof_id_type di = old_indices[i];
            if (di == DofObject::invalid_id)
              values[i] = 0;
            else
              values[i] = old_solution(di);
          }
      }
    else
      old_solution.get(old_indices, values);
  }

eval_old_dofs() [2/2]

template<typename Output, void(FEMContext::*)(unsigned int, const Point &, Output &, const Real) const point_output>

void libMesh::OldSolutionValue< Output, point_output >::eval_old_dofs ( const Elem &  elem, const FEType &  fe_type, unsigned int  sys_num, unsigned int  var_num, std::vector< dof_id_type > &  indices, std::vector< DofValueType > &  values  )

inline

Definition at line 868 of file generic_projector.h.

References libMesh::DofObject::dof_number(), libMesh::DofObject::get_old_dof_object_ref(), libMesh::DofObject::invalid_id, libMesh::Elem::JUST_REFINED, libMesh::DofObject::n_comp_group(), libMesh::FEInterface::n_dofs_per_elem(), libMesh::DofObject::n_systems(), libMesh::Elem::parent(), libMesh::Elem::refinement_flag(), and libMesh::DofObject::var_to_vg_and_offset().

  {
    LOG_SCOPE ("eval_old_dofs(elem)", "OldSolutionValue");

    // We're only to be asked for old dofs on elements that can copy
    // them through DO_NOTHING or through refinement.
    const Elem & old_elem =
      (elem.refinement_flag() == Elem::JUST_REFINED) ?
      *elem.parent() : elem;

    // If there are any element-based DOF numbers, get them
    const unsigned int nc = FEInterface::n_dofs_per_elem(fe_type, &elem);

    indices.resize(nc);

    // We should never have fewer dofs than necessary on an
    // element unless we're getting indices on a parent element,
    // which we should never need, or getting indices on a newly
    // expanded subdomain, in which case we initialize new values to
    // zero.
    if (nc != 0)
      {
        const DofObject & old_dof_object = old_elem.get_old_dof_object_ref();
        libmesh_assert_greater(elem.n_systems(), sys_num);

        const std::pair<unsigned int, unsigned int>
          vg_and_offset = elem.var_to_vg_and_offset(sys_num,var_num);
        const unsigned int vg = vg_and_offset.first;
        const unsigned int vig = vg_and_offset.second;

        unsigned int n_comp = old_dof_object.n_comp_group(sys_num,vg);
        n_comp = std::min(n_comp, nc);

        std::vector<dof_id_type> old_dof_indices(n_comp);

        for (unsigned int i=0; i != n_comp; ++i)
          {
            const dof_id_type d_old =
              old_dof_object.dof_number(sys_num, vg, vig, i, n_comp);
            const dof_id_type d_new =
              elem.dof_number(sys_num, vg, vig, i, n_comp);
            libmesh_assert_not_equal_to (d_old, DofObject::invalid_id);
            libmesh_assert_not_equal_to (d_new, DofObject::invalid_id);

            old_dof_indices[i] = d_old;
            indices[i] = d_new;
          }

        values.resize(n_comp);
        old_solution.get(old_dof_indices, values);

        for (unsigned int i=n_comp; i != nc; ++i)
          {
            const dof_id_type d_new =
              elem.dof_number(sys_num, vg, vig, i, n_comp);
            libmesh_assert_not_equal_to (d_new, DofObject::invalid_id);
            indices[i] = d_new;
          }

        values.resize(nc, 0);
      }
    else
      values.clear();
  }

get_shape_outputs() [1/9]

template<typename Output, void(FEMContext::*)(unsigned int, const Point &, Output &, const Real) const point_output>

static void libMesh::OldSolutionBase< Output, point_output >::get_shape_outputs ( FEAbstract &  fe )

staticinherited

get_shape_outputs() [2/9]

template<>

void libMesh::OldSolutionBase< Number, &FEMContext::point_value >::get_shape_outputs ( FEAbstract &  fe )

inlineinherited

Definition at line 944 of file generic_projector.h.

References libMesh::FEAbstract::request_phi().

{
  fe.request_phi();
}

get_shape_outputs() [3/9]

template<>

void libMesh::OldSolutionBase< Gradient, &FEMContext::point_gradient >::get_shape_outputs ( FEAbstract &  fe )

inlineinherited

Definition at line 952 of file generic_projector.h.

References libMesh::FEAbstract::request_dphi().

{
  fe.request_dphi();
}

get_shape_outputs() [4/9]

template<>

void libMesh::OldSolutionBase< Gradient, &FEMContext::point_value >::get_shape_outputs ( FEAbstract &  fe )

inlineinherited

Definition at line 959 of file generic_projector.h.

References libMesh::FEAbstract::request_phi().

{
  fe.request_phi();
}

get_shape_outputs() [5/9]

template<>

void libMesh::OldSolutionBase< Tensor, &FEMContext::point_gradient >::get_shape_outputs ( FEAbstract &  fe )

inlineinherited

Definition at line 967 of file generic_projector.h.

References libMesh::FEAbstract::request_dphi().

{
  fe.request_dphi();
}

get_shape_outputs() [6/9]

template<>

void libMesh::OldSolutionBase< Real, &FEMContext::point_value >::get_shape_outputs ( FEAbstract &  fe )

inlineinherited

Definition at line 976 of file generic_projector.h.

References libMesh::FEAbstract::request_phi().

{
  fe.request_phi();
}

get_shape_outputs() [7/9]

template<>

void libMesh::OldSolutionBase< RealGradient, &FEMContext::point_gradient >::get_shape_outputs ( FEAbstract &  fe )

inlineinherited

Definition at line 984 of file generic_projector.h.

References libMesh::FEAbstract::request_dphi().

{
  fe.request_dphi();
}

get_shape_outputs() [8/9]

template<>

void libMesh::OldSolutionBase< RealGradient, &FEMContext::point_value >::get_shape_outputs ( FEAbstract &  fe )

inlineinherited

Definition at line 991 of file generic_projector.h.

References libMesh::FEAbstract::request_phi().

{
  fe.request_phi();
}

get_shape_outputs() [9/9]

template<>

void libMesh::OldSolutionBase< RealTensor, &FEMContext::point_gradient >::get_shape_outputs ( FEAbstract &  fe )

inlineinherited

Definition at line 999 of file generic_projector.h.

References libMesh::FEAbstract::request_dphi().

{
  fe.request_dphi();
}

init_context()

template<typename Output, void(FEMContext::*)(unsigned int, const Point &, Output &, const Real) const point_output>

void libMesh::OldSolutionBase< Output, point_output >::init_context ( FEMContext &  c )

inlineinherited

Definition at line 567 of file generic_projector.h.

References dim, libMesh::FEMContext::DOFS_ONLY, libMesh::make_range(), and libMesh::FEMContext::set_algebraic_type().

  {
    c.set_algebraic_type(FEMContext::DOFS_ONLY);

    const std::set<unsigned char> & elem_dims =
      old_context.elem_dimensions();

    // Loop over variables and dimensions, to prerequest
    for (const auto & dim : elem_dims)
      {
        FEAbstract * fe = nullptr;
        if (old_context.active_vars())
          for (auto var : *old_context.active_vars())
            {
              old_context.get_element_fe(var, fe, dim);
              get_shape_outputs(*fe);
            }
        else
          for (auto var : make_range(sys.n_vars()))
            {
              old_context.get_element_fe(var, fe, dim);
              get_shape_outputs(*fe);
            }
      }
  }

is_grid_projection()

template<typename Output, void(FEMContext::*)(unsigned int, const Point &, Output &, const Real) const point_output>

bool libMesh::OldSolutionBase< Output, point_output >::is_grid_projection ( )

inlineinherited

Definition at line 593 of file generic_projector.h.

{ return true; }

Member Data Documentation

component_to_var

template<typename Output, void(FEMContext::*)(unsigned int, const Point &, Output &, const Real) const point_output>

std::vector<unsigned int> libMesh::OldSolutionBase< Output, point_output >::component_to_var

protectedinherited

Definition at line 700 of file generic_projector.h.

last_elem

template<typename Output, void(FEMContext::*)(unsigned int, const Point &, Output &, const Real) const point_output>

const Elem* libMesh::OldSolutionBase< Output, point_output >::last_elem

protectedinherited

Definition at line 697 of file generic_projector.h.

old_context

template<typename Output, void(FEMContext::*)(unsigned int, const Point &, Output &, const Real) const point_output>

FEMContext libMesh::OldSolutionBase< Output, point_output >::old_context

protectedinherited

Definition at line 699 of file generic_projector.h.

old_solution

template<typename Output, void(FEMContext::*)(unsigned int, const Point &, Output &, const Real) const point_output>

const NumericVector<Number>& libMesh::OldSolutionValue< Output, point_output >::old_solution

private

Definition at line 939 of file generic_projector.h.

out_of_elem_tol

template<typename Output, void(FEMContext::*)(unsigned int, const Point &, Output &, const Real) const point_output>

const Real libMesh::OldSolutionBase< Output, point_output >::out_of_elem_tol = 10 * TOLERANCE

staticprotectedinherited

Definition at line 702 of file generic_projector.h.

sys

template<typename Output, void(FEMContext::*)(unsigned int, const Point &, Output &, const Real) const point_output>

const System& libMesh::OldSolutionBase< Output, point_output >::sys

protectedinherited

Definition at line 698 of file generic_projector.h.

---

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

• include/systems/generic_projector.h