libMesh::FEMContext Class Reference

#include <fem_context.h>

Inheritance diagram for libMesh::FEMContext:

[legend]

List of all members.

Public Types
typedef std::map< const NumericVector< Number > *, std::pair< DenseVector < Number >, std::vector < DenseSubVector< Number > * > > >::iterator	localized_vectors_iterator
Public Member Functions
	FEMContext (const System &sys)
virtual	~FEMContext ()
bool	has_side_boundary_id (boundary_id_type id) const
std::vector< boundary_id_type >	side_boundary_ids () const
Number	interior_value (unsigned int var, unsigned int qp) const
Number	side_value (unsigned int var, unsigned int qp) const
Number	point_value (unsigned int var, const Point &p) const
Gradient	interior_gradient (unsigned int var, unsigned int qp) const
Gradient	side_gradient (unsigned int var, unsigned int qp) const
Gradient	point_gradient (unsigned int var, const Point &p) const
Tensor	interior_hessian (unsigned int var, unsigned int qp) const
Tensor	side_hessian (unsigned int var, unsigned int qp) const
Tensor	point_hessian (unsigned int var, const Point &p) const
Number	fixed_interior_value (unsigned int var, unsigned int qp) const
Number	fixed_side_value (unsigned int var, unsigned int qp) const
Number	fixed_point_value (unsigned int var, const Point &p) const
Gradient	fixed_interior_gradient (unsigned int var, unsigned int qp) const
Gradient	fixed_side_gradient (unsigned int var, unsigned int qp) const
Gradient	fixed_point_gradient (unsigned int var, const Point &p) const
Tensor	fixed_interior_hessian (unsigned int var, unsigned int qp) const
Tensor	fixed_side_hessian (unsigned int var, unsigned int qp) const
Tensor	fixed_point_hessian (unsigned int var, const Point &p) const
template<typename OutputShape >
void	get_element_fe (unsigned int var, FEGenericBase< OutputShape > *&fe) const
template<typename OutputShape >
void	get_side_fe (unsigned int var, FEGenericBase< OutputShape > *&fe) const
template<typename OutputShape >
void	get_edge_fe (unsigned int var, FEGenericBase< OutputShape > *&fe) const
template<typename OutputType >
void	interior_value (unsigned int var, unsigned int qp, OutputType &u) const
template<typename OutputType >
void	interior_values (unsigned int var, const NumericVector< Number > &_system_vector, std::vector< OutputType > &interior_values_vector) const
template<typename OutputType >
void	side_value (unsigned int var, unsigned int qp, OutputType &u) const
template<typename OutputType >
void	side_values (unsigned int var, const NumericVector< Number > &_system_vector, std::vector< OutputType > &side_values_vector) const
template<typename OutputType >
void	point_value (unsigned int var, const Point &p, OutputType &u) const
template<typename OutputType >
void	interior_gradient (unsigned int var, unsigned int qp, OutputType &du) const
template<typename OutputType >
void	interior_gradients (unsigned int var, const NumericVector< Number > &_system_vector, std::vector< OutputType > &interior_gradients_vector) const
template<typename OutputType >
void	side_gradient (unsigned int var, unsigned int qp, OutputType &du) const
template<typename OutputType >
void	side_gradients (unsigned int var, const NumericVector< Number > &_system_vector, std::vector< OutputType > &side_gradients_vector) const
template<typename OutputType >
void	point_gradient (unsigned int var, const Point &p, OutputType &grad_u) const
template<typename OutputType >
void	interior_hessian (unsigned int var, unsigned int qp, OutputType &d2u) const
template<typename OutputType >
void	interior_hessians (unsigned int var, const NumericVector< Number > &_system_vector, std::vector< OutputType > &d2u_vals) const
template<typename OutputType >
void	side_hessian (unsigned int var, unsigned int qp, OutputType &d2u) const
template<typename OutputType >
void	side_hessians (unsigned int var, const NumericVector< Number > &_system_vector, std::vector< OutputType > &d2u_vals) const
template<typename OutputType >
void	point_hessian (unsigned int var, const Point &p, OutputType &hess_u) const
template<typename OutputType >
void	fixed_interior_value (unsigned int var, unsigned int qp, OutputType &u) const
template<typename OutputType >
void	fixed_side_value (unsigned int var, unsigned int qp, OutputType &u) const
template<typename OutputType >
void	fixed_point_value (unsigned int var, const Point &p, OutputType &u) const
template<typename OutputType >
void	fixed_interior_gradient (unsigned int var, unsigned int qp, OutputType &grad_u) const
template<typename OutputType >
void	fixed_side_gradient (unsigned int var, unsigned int qp, OutputType &grad_u) const
template<typename OutputType >
void	fixed_point_gradient (unsigned int var, const Point &p, OutputType &grad_u) const
template<typename OutputType >
void	fixed_interior_hessian (unsigned int var, unsigned int qp, OutputType &hess_u) const
template<typename OutputType >
void	fixed_side_hessian (unsigned int var, unsigned int qp, OutputType &hess_u) const
template<typename OutputType >
void	fixed_point_hessian (unsigned int var, const Point &p, OutputType &hess_u) const
template<typename OutputType >
void	interior_curl (unsigned int var, unsigned int qp, OutputType &curl_u) const
template<typename OutputType >
void	interior_div (unsigned int var, unsigned int qp, OutputType &div_u) const
virtual void	elem_reinit (Real theta)
virtual void	elem_side_reinit (Real theta)
virtual void	elem_edge_reinit (Real theta)
virtual void	pre_fe_reinit (const System &, const Elem *e)
void	elem_fe_reinit ()
void	side_fe_reinit ()
void	edge_fe_reinit ()
const QBase *	get_element_qrule () const
const QBase *	get_side_qrule () const
const QBase *	get_edge_qrule () const
virtual void	set_mesh_system (System *sys)
const System *	get_mesh_system () const
System *	get_mesh_system ()
unsigned int	get_mesh_x_var () const
void	set_mesh_x_var (unsigned int x_var)
unsigned int	get_mesh_y_var () const
void	set_mesh_y_var (unsigned int y_var)
unsigned int	get_mesh_z_var () const
void	set_mesh_z_var (unsigned int z_var)
const Elem &	get_elem () const
unsigned char	get_side () const
unsigned char	get_edge () const
unsigned char	get_dim () const
void	elem_position_set (Real theta)
void	elem_position_get ()
unsigned int	n_vars () const
const System &	get_system () const
const DenseVector< Number > &	get_elem_solution () const
const DenseSubVector< Number > &	get_elem_solution (unsigned int var) const
const DenseVector< Number > &	get_elem_fixed_solution () const
const DenseSubVector< Number > &	get_elem_fixed_solution (unsigned int var) const
const DenseVector< Number > &	get_elem_residual () const
DenseVector< Number > &	get_elem_residual ()
const DenseSubVector< Number > &	get_elem_residual (unsigned int var) const
DenseSubVector< Number > &	get_elem_residual (unsigned int var)
const DenseMatrix< Number > &	get_elem_jacobian () const
DenseMatrix< Number > &	get_elem_jacobian ()
const DenseSubMatrix< Number > &	get_elem_jacobian (unsigned int var1, unsigned int var2) const
DenseSubMatrix< Number > &	get_elem_jacobian (unsigned int var1, unsigned int var2)
const std::vector< Number > &	get_qois () const
std::vector< Number > &	get_qois ()
const std::vector< DenseVector < Number > > &	get_qoi_derivatives () const
std::vector< DenseVector < Number > > &	get_qoi_derivatives ()
const DenseSubVector< Number > &	get_qoi_derivatives (unsigned int qoi, unsigned int var) const
DenseSubVector< Number > &	get_qoi_derivatives (unsigned int qoi, unsigned int var)
const std::vector< dof_id_type > &	get_dof_indices () const
const std::vector< dof_id_type > &	get_dof_indices (unsigned int var) const
Real	get_system_time () const
Real	get_time () const
void	set_time (Real time_in)
Real	get_elem_solution_derivative () const
Real	get_fixed_solution_derivative () const
bool	is_adjoint () const
bool &	is_adjoint ()
void	set_deltat_pointer (Real *dt)
Real	get_deltat_value ()
void	add_localized_vector (NumericVector< Number > &_localized_vector, const System &_sys)
DenseVector< Number > &	get_localized_vector (const NumericVector< Number > &_localized_vector)
const DenseVector< Number > &	get_localized_vector (const NumericVector< Number > &_localized_vector) const
DenseSubVector< Number > &	get_localized_subvector (const NumericVector< Number > &_localized_vector, unsigned int _var)
const DenseSubVector< Number > &	get_localized_subvector (const NumericVector< Number > &_localized_vector, unsigned int _var) const
Public Attributes
std::map< FEType, FEBase * >	element_fe
std::map< FEType, FEBase * >	side_fe
std::map< FEType, FEBase * >	edge_fe
std::vector< FEBase * >	element_fe_var
std::vector< FEBase * >	side_fe_var
std::vector< FEBase * >	edge_fe_var
QBase *	element_qrule
QBase *	side_qrule
QBase *	edge_qrule
System *	_mesh_sys
unsigned int	_mesh_x_var
unsigned int	_mesh_y_var
unsigned int	_mesh_z_var
const Elem *	elem
unsigned char	side
unsigned char	edge
unsigned char	dim
Real	time
const Real	system_time
DenseVector< Number >	elem_solution
std::vector< DenseSubVector < Number > * >	elem_subsolutions
DenseVector< Number >	elem_fixed_solution
std::vector< DenseSubVector < Number > * >	elem_fixed_subsolutions
Real	elem_solution_derivative
Real	fixed_solution_derivative
DenseVector< Number >	elem_residual
DenseMatrix< Number >	elem_jacobian
std::vector< Number >	elem_qoi
std::vector< DenseVector < Number > >	elem_qoi_derivative
std::vector< std::vector < DenseSubVector< Number > * > >	elem_qoi_subderivatives
std::vector< DenseSubVector < Number > * >	elem_subresiduals
std::vector< std::vector < DenseSubMatrix< Number > * > >	elem_subjacobians
std::vector< dof_id_type >	dof_indices
std::vector< std::vector < dof_id_type > >	dof_indices_var
Protected Member Functions
template<typename OutputShape >
AutoPtr< FEGenericBase < OutputShape > >	build_new_fe (const FEGenericBase< OutputShape > *fe, const Point &p) const
Protected Attributes
std::map< FEType, FEAbstract * >	_element_fe
std::map< FEType, FEAbstract * >	_side_fe
std::map< FEType, FEAbstract * >	_edge_fe
std::vector< FEAbstract * >	_element_fe_var
std::vector< FEAbstract * >	_side_fe_var
std::vector< FEAbstract * >	_edge_fe_var
BoundaryInfo *	_boundary_info
std::map< const NumericVector < Number > *, std::pair < DenseVector< Number > , std::vector< DenseSubVector < Number > * > > >	localized_vectors
Private Member Functions
void	_do_elem_position_set (Real theta)
void	_update_time_from_system (Real theta)

---

Detailed Description

This class provides all data required for a physics package (e.g. an FEMSystem subclass) to perform local element residual and jacobian integrations.

This class is part of the new DifferentiableSystem framework, which is still experimental. Users of this framework should beware of bugs and future API changes.

Author:

Roy H. Stogner 2009

Definition at line 64 of file fem_context.h.

---

Member Typedef Documentation

typedef std::map<const NumericVector<Number>*, std::pair<DenseVector<Number>, std::vector<DenseSubVector<Number>*> > >::iterator libMesh::DiffContext::localized_vectors_iterator [inherited]

Typedef for the localized_vectors iterator

Definition at line 371 of file diff_context.h.

---

Constructor & Destructor Documentation

libMesh::FEMContext::FEMContext

(

const System &

sys

)

[explicit]

Constructor. Allocates some but fills no data structures.

Definition at line 36 of file fem_context.C.

References _edge_fe, _edge_fe_var, _element_fe, _element_fe_var, _side_fe, _side_fe_var, libMesh::FEAbstract::build(), libMesh::FEGenericBase< Real >::build(), libMesh::FEType::default_quadrature_rule(), dim, edge_fe, edge_fe_var, edge_qrule, element_fe, element_fe_var, element_qrule, libMesh::System::extra_quadrature_order, libMesh::FEInterface::field_type(), libMesh::System::n_vars(), libMesh::FEType::order, libMesh::AutoPtr< Tp >::release(), side_fe, side_fe_var, side_qrule, libMeshEnums::TYPE_SCALAR, and libMesh::System::variable_type().

  : DiffContext(sys),
    element_qrule(NULL), side_qrule(NULL),
    edge_qrule(NULL),
    _mesh_sys(NULL),
    _mesh_x_var(0),
    _mesh_y_var(0),
    _mesh_z_var(0),
    elem(NULL),
    side(0), edge(0), dim(sys.get_mesh().mesh_dimension()),
    _boundary_info(sys.get_mesh().boundary_info.get())
{
  // We need to know which of our variables has the hardest
  // shape functions to numerically integrate.

  unsigned int nv = sys.n_vars();

  libmesh_assert (nv);
  FEType hardest_fe_type = sys.variable_type(0);

  for (unsigned int i=0; i != nv; ++i)
    {
      FEType fe_type = sys.variable_type(i);

      // FIXME - we don't yet handle mixed finite elements from
      // different families which require different quadrature rules
      // libmesh_assert_equal_to (fe_type.family, hardest_fe_type.family);

      if (fe_type.order > hardest_fe_type.order)
        hardest_fe_type = fe_type;
    }

  // Create an adequate quadrature rule
  element_qrule = hardest_fe_type.default_quadrature_rule
    (dim, sys.extra_quadrature_order).release();
  side_qrule = hardest_fe_type.default_quadrature_rule
    (dim-1, sys.extra_quadrature_order).release();
  if (dim == 3)
    edge_qrule = hardest_fe_type.default_quadrature_rule
      (1, sys.extra_quadrature_order).release();

  // Next, create finite element objects
  // Preserving backward compatibility here for now
  // Should move to the protected/FEAbstract interface
  element_fe_var.resize(nv);
  side_fe_var.resize(nv);
  if (dim == 3)
    edge_fe_var.resize(nv);

  _element_fe_var.resize(nv);
  _side_fe_var.resize(nv);
  if (dim == 3)
    _edge_fe_var.resize(nv);

  for (unsigned int i=0; i != nv; ++i)
    {
      FEType fe_type = sys.variable_type(i);

      // Preserving backward compatibility here for now
      // Should move to the protected/FEAbstract interface
      if( FEInterface::field_type( fe_type ) == TYPE_SCALAR )
        {
          if( element_fe[fe_type] == NULL )
            {
              element_fe[fe_type] = FEBase::build(dim, fe_type).release();
              element_fe[fe_type]->attach_quadrature_rule(element_qrule);
              side_fe[fe_type] = FEBase::build(dim, fe_type).release();
              side_fe[fe_type]->attach_quadrature_rule(side_qrule);
              
              if (dim == 3)
                {
                  edge_fe[fe_type] = FEBase::build(dim, fe_type).release();
                  edge_fe[fe_type]->attach_quadrature_rule(edge_qrule);
                }
            }
          element_fe_var[i] = element_fe[fe_type];
          side_fe_var[i] = side_fe[fe_type];
          if (dim == 3)
            edge_fe_var[i] = edge_fe[fe_type];
        }

      if ( _element_fe[fe_type] == NULL )
        {
          _element_fe[fe_type] = FEAbstract::build(dim, fe_type).release();
          _element_fe[fe_type]->attach_quadrature_rule(element_qrule);
          _side_fe[fe_type] = FEAbstract::build(dim, fe_type).release();
          _side_fe[fe_type]->attach_quadrature_rule(side_qrule);

          if (dim == 3)
            {
              _edge_fe[fe_type] = FEAbstract::build(dim, fe_type).release();
              _edge_fe[fe_type]->attach_quadrature_rule(edge_qrule);
            }
        }
      _element_fe_var[i] = _element_fe[fe_type];
      _side_fe_var[i] = _side_fe[fe_type];
      if (dim == 3)
        _edge_fe_var[i] = _edge_fe[fe_type];
      
    }
}

libMesh::FEMContext::~FEMContext

(

)

[virtual]

Destructor.

Definition at line 139 of file fem_context.C.

References _edge_fe, _element_fe, _side_fe, edge_fe, edge_qrule, element_fe, element_qrule, side_fe, and side_qrule.

{
  // We don't want to store AutoPtrs in STL containers, but we don't
  // want to leak memory either
  // Preserving backward compatibility here for now
  // Should move to the protected/FEAbstract interface
  for (std::map<FEType, FEBase *>::iterator i = element_fe.begin();
       i != element_fe.end(); ++i)
    delete i->second;
  element_fe.clear();

  for (std::map<FEType, FEBase *>::iterator i = side_fe.begin();
       i != side_fe.end(); ++i)
    delete i->second;
  side_fe.clear();

  for (std::map<FEType, FEBase *>::iterator i = edge_fe.begin();
       i != edge_fe.end(); ++i)
    delete i->second;
  edge_fe.clear();


  for (std::map<FEType, FEAbstract *>::iterator i = _element_fe.begin();
       i != _element_fe.end(); ++i)
    delete i->second;
  _element_fe.clear();
  
  for (std::map<FEType, FEAbstract *>::iterator i = _side_fe.begin();
       i != _side_fe.end(); ++i)
    delete i->second;
  _side_fe.clear();

  for (std::map<FEType, FEAbstract *>::iterator i = _edge_fe.begin();
       i != _edge_fe.end(); ++i)
    delete i->second;
  _edge_fe.clear();


  delete element_qrule;
  element_qrule = NULL;

  delete side_qrule;
  side_qrule = NULL;

  if (edge_qrule)
    delete edge_qrule;
  side_qrule = NULL;
}

---

Member Function Documentation

void libMesh::FEMContext::_do_elem_position_set

(

Real

theta

)

[private]

Uses the coordinate data specified by mesh_*_position configuration to set the geometry of elem to the value it would take after a fraction theta of a timestep.

This does the work of elem_position_set, but isn't safe to call without _mesh_sys/etc. defined first.

Definition at line 1548 of file fem_context.C.

References _mesh_sys, _mesh_x_var, _mesh_y_var, _mesh_z_var, elem, libMesh::DiffContext::elem_subsolutions, element_fe_var, libMesh::invalid_uint, libMeshEnums::LAGRANGE, libMesh::libmesh_real(), libMesh::Elem::n_nodes(), n_nodes, and libMesh::n_threads().

Referenced by elem_position_set().

{
  // This is too expensive to call unless we've been asked to move the mesh
  libmesh_assert (_mesh_sys);

  // This will probably break with threading when two contexts are
  // operating on elements which share a node
  libmesh_assert_equal_to (libMesh::n_threads(), 1);

  // If the coordinate data is in our own system, it's already
  // been set up for us, and we can ignore our input parameter theta
//  if (_mesh_sys == this->number())
//    {
      unsigned int n_nodes = elem->n_nodes();
      // For simplicity we demand that mesh coordinates be stored
      // in a format that allows a direct copy
      libmesh_assert(_mesh_x_var == libMesh::invalid_uint ||
                     (element_fe_var[_mesh_x_var]->get_fe_type().family
                      == LAGRANGE &&
                      elem_subsolutions[_mesh_x_var]->size() == n_nodes));
      libmesh_assert(_mesh_y_var == libMesh::invalid_uint ||
                     (element_fe_var[_mesh_y_var]->get_fe_type().family
                      == LAGRANGE &&
                      elem_subsolutions[_mesh_y_var]->size() == n_nodes));
      libmesh_assert(_mesh_z_var == libMesh::invalid_uint ||
                     (element_fe_var[_mesh_z_var]->get_fe_type().family
                      == LAGRANGE &&
                      elem_subsolutions[_mesh_z_var]->size() == n_nodes));

      // Set the new point coordinates
      if (_mesh_x_var != libMesh::invalid_uint)
        for (unsigned int i=0; i != n_nodes; ++i)
          const_cast<Elem*>(elem)->point(i)(0) =
            libmesh_real((*elem_subsolutions[_mesh_x_var])(i));

      if (_mesh_y_var != libMesh::invalid_uint)
        for (unsigned int i=0; i != n_nodes; ++i)
          const_cast<Elem*>(elem)->point(i)(1) =
            libmesh_real((*elem_subsolutions[_mesh_y_var])(i));

      if (_mesh_z_var != libMesh::invalid_uint)
        for (unsigned int i=0; i != n_nodes; ++i)
          const_cast<Elem*>(elem)->point(i)(2) =
            libmesh_real((*elem_subsolutions[_mesh_z_var])(i));
//    }
  // FIXME - If the coordinate data is not in our own system, someone
  // had better get around to implementing that... - RHS
//  else
//    {
//      libmesh_not_implemented();
//    }
}

void libMesh::FEMContext::_update_time_from_system

(

Real

theta

)

[private]

Update the time in the context object for the given value of theta, based on the values of "time" and "deltat" stored in the system which created this context.

Definition at line 1725 of file fem_context.C.

References libMesh::DiffContext::get_deltat_value(), libMesh::Real, libMesh::DiffContext::system_time, and libMesh::DiffContext::time.

Referenced by elem_edge_reinit(), elem_reinit(), and elem_side_reinit().

{
  // Update the "time" variable based on the value of theta.  For this
  // to work, we need to know the value of deltat, a pointer to which is now
  // stored by our parent DiffContext class.  Note: get_deltat_value() will
  // assert in debug mode if the requested pointer is NULL.
  const Real deltat = this->get_deltat_value();

  this->time = theta*(this->system_time + deltat) + (1.-theta)*this->system_time;
}

void libMesh::DiffContext::add_localized_vector	(	NumericVector< Number > &	_localized_vector,
		const System &	_sys
	)			[inherited]

Adds a vector to the map of localized vectors. We can later evaluate interior_values, interior_gradients and side_values for these fields these vectors represent.

Definition at line 125 of file diff_context.C.

References libMesh::DiffContext::localized_vectors, and libMesh::System::n_vars().

{
  // Make an empty pair keyed with a reference to this _localized_vector
  localized_vectors[&_localized_vector] = std::make_pair(DenseVector<Number>(), std::vector<DenseSubVector<Number>*>());

  unsigned int nv = _sys.n_vars();

  localized_vectors[&_localized_vector].second.reserve(nv);
  
  // Fill the DenseSubVector with nv copies of DenseVector
  for(unsigned int i=0; i != nv; ++i)
    localized_vectors[&_localized_vector].second.push_back(new DenseSubVector<Number>(localized_vectors[&_localized_vector].first));
}

template<typename OutputShape >

AutoPtr< FEGenericBase< OutputShape > > libMesh::FEMContext::build_new_fe	(	const FEGenericBase< OutputShape > *	fe,
		const Point &	p
	)			const [inline, protected]

Helper function to reduce some code duplication in the *_point_* methods.

Definition at line 1739 of file fem_context.C.

References dim, libMesh::Elem::dim(), elem, libMesh::FEAbstract::get_fe_type(), and libMesh::FEInterface::inverse_map().

Referenced by fixed_point_gradient(), fixed_point_hessian(), fixed_point_value(), point_gradient(), point_hessian(), and point_value().

{
  FEType fe_type = fe->get_fe_type();
  AutoPtr<FEGenericBase<OutputShape> > fe_new(FEGenericBase<OutputShape>::build(elem->dim(), fe_type));

  // Map the physical co-ordinates to the master co-ordinates using the inverse_map from fe_interface.h
  // Build a vector of point co-ordinates to send to reinit
  std::vector<Point> coor(1, FEInterface::inverse_map(dim, fe_type, elem, p));

  // Reinitialize the element and compute the shape function values at coor
  fe_new->reinit (elem, &coor);

  return fe_new;
}

void libMesh::FEMContext::edge_fe_reinit

(

)

Reinitializes edge FE objects on the current geometric element

Definition at line 1465 of file fem_context.C.

References _edge_fe, dim, edge, edge_fe, and elem.

Referenced by elem_edge_reinit().

{
  libmesh_assert_equal_to (dim, 3);

  // Initialize all the interior FE objects on elem/edge.
  // Logging of FE::reinit is done in the FE functions
  std::map<FEType, FEBase *>::iterator fe_end = edge_fe.end();
  for (std::map<FEType, FEBase *>::iterator i = edge_fe.begin();
       i != fe_end; ++i)
    {
      i->second->edge_reinit(elem, edge);
    }

  std::map<FEType, FEAbstract *>::iterator local_fe_end = _edge_fe.end();
  for (std::map<FEType, FEAbstract *>::iterator i = _edge_fe.begin();
       i != local_fe_end; ++i)
    {
      i->second->edge_reinit(elem, edge);
    }
}

void libMesh::FEMContext::elem_edge_reinit

(

Real

theta

)

[virtual]

Reinitialize Elem and edge FE objects if necessary for integration at a new point in time: specifically, handle moving elements in moving mesh schemes.

Reimplemented from libMesh::DiffContext.

Definition at line 1408 of file fem_context.C.

References _mesh_sys, _update_time_from_system(), edge_fe_reinit(), and elem_position_set().

{
  // Update the "time" variable of this context object
  this->_update_time_from_system(theta);

  // Handle a moving element if necessary
  if (_mesh_sys)
    {
      // FIXME - not threadsafe yet!
      elem_position_set(theta);
      edge_fe_reinit();
    }
}

void libMesh::FEMContext::elem_fe_reinit

(

)

Reinitializes interior FE objects on the current geometric element

Definition at line 1423 of file fem_context.C.

References _element_fe, elem, and element_fe.

Referenced by elem_reinit(), and libMesh::FEMSystem::mesh_position_set().

{
  // Initialize all the interior FE objects on elem.
  // Logging of FE::reinit is done in the FE functions
  std::map<FEType, FEBase *>::iterator fe_end = element_fe.end();
  for (std::map<FEType, FEBase *>::iterator i = element_fe.begin();
       i != fe_end; ++i)
    {
      i->second->reinit(elem);
    }


  std::map<FEType, FEAbstract *>::iterator local_fe_end = _element_fe.end();
  for (std::map<FEType, FEAbstract *>::iterator i = _element_fe.begin();
       i != local_fe_end; ++i)
    {
      i->second->reinit(elem);
    }
}

void libMesh::FEMContext::elem_position_get

(

)

Uses the geometry of elem to set the coordinate data specified by mesh_*_position configuration.

Definition at line 1488 of file fem_context.C.

References _mesh_sys, _mesh_x_var, _mesh_y_var, _mesh_z_var, libMesh::Elem::default_order(), elem, libMesh::DiffContext::elem_subsolutions, element_fe_var, libMesh::invalid_uint, libMeshEnums::LAGRANGE, libMesh::Elem::n_nodes(), n_nodes, libMesh::n_threads(), and libMesh::Elem::point().

Referenced by libMesh::FEMSystem::mesh_position_get().

{
  // This is too expensive to call unless we've been asked to move the mesh
  libmesh_assert (_mesh_sys);

  // This will probably break with threading when two contexts are
  // operating on elements which share a node
  libmesh_assert_equal_to (libMesh::n_threads(), 1);

  // If the coordinate data is in our own system, it's already
  // been set up for us
//  if (_mesh_sys == this->number())
//    {
      unsigned int n_nodes = elem->n_nodes();
      // For simplicity we demand that mesh coordinates be stored
      // in a format that allows a direct copy
      libmesh_assert(_mesh_x_var == libMesh::invalid_uint ||
                     (element_fe_var[_mesh_x_var]->get_fe_type().family
                      == LAGRANGE &&
                      element_fe_var[_mesh_x_var]->get_fe_type().order
                      == elem->default_order()));
      libmesh_assert(_mesh_y_var == libMesh::invalid_uint ||
                     (element_fe_var[_mesh_y_var]->get_fe_type().family
                      == LAGRANGE &&
                      element_fe_var[_mesh_y_var]->get_fe_type().order
                      == elem->default_order()));
      libmesh_assert(_mesh_z_var == libMesh::invalid_uint ||
                     (element_fe_var[_mesh_z_var]->get_fe_type().family
                      == LAGRANGE &&
                      element_fe_var[_mesh_z_var]->get_fe_type().order
                      == elem->default_order()));

      // Get degree of freedom coefficients from point coordinates
      if (_mesh_x_var != libMesh::invalid_uint)
        for (unsigned int i=0; i != n_nodes; ++i)
          (*elem_subsolutions[_mesh_x_var])(i) = elem->point(i)(0);

      if (_mesh_y_var != libMesh::invalid_uint)
        for (unsigned int i=0; i != n_nodes; ++i)
          (*elem_subsolutions[_mesh_y_var])(i) = elem->point(i)(1);

      if (_mesh_z_var != libMesh::invalid_uint)
        for (unsigned int i=0; i != n_nodes; ++i)
          (*elem_subsolutions[_mesh_z_var])(i) = elem->point(i)(2);
//    }
  // FIXME - If the coordinate data is not in our own system, someone
  // had better get around to implementing that... - RHS
//  else
//    {
//      libmesh_not_implemented();
//    }
}

void libMesh::FEMContext::elem_position_set

(

Real

theta

)

[inline]

Uses the coordinate data specified by mesh_*_position configuration to set the geometry of elem to the value it would take after a fraction theta of a timestep.

Definition at line 745 of file fem_context.h.

References _do_elem_position_set(), and _mesh_sys.

Referenced by elem_edge_reinit(), elem_reinit(), elem_side_reinit(), and libMesh::FEMSystem::mesh_position_set().

{
  if (_mesh_sys)
    this->_do_elem_position_set(theta);
}

void libMesh::FEMContext::elem_reinit

(

Real

theta

)

[virtual]

Reinitialize all my FEM context data on a given element for the given system Reinitialize Elem and FE objects if necessary for integration at a new point in time: specifically, handle moving elements in moving mesh schemes.

Reimplemented from libMesh::DiffContext.

Definition at line 1371 of file fem_context.C.

References _mesh_sys, _update_time_from_system(), elem_fe_reinit(), elem_position_set(), and libMesh::n_threads().

{
  // Update the "time" variable of this context object
  this->_update_time_from_system(theta);

  // Handle a moving element if necessary.
  if (_mesh_sys)
    // We assume that the ``default'' state
    // of the mesh is its final, theta=1.0
    // position, so we don't bother with
    // mesh motion in that case.
    if (theta != 1.0)
      {
        // FIXME - ALE is not threadsafe yet!
        libmesh_assert_equal_to (libMesh::n_threads(), 1);

        elem_position_set(theta);
      }
  elem_fe_reinit();
}

void libMesh::FEMContext::elem_side_reinit

(

Real

theta

)

[virtual]

Reinitialize Elem and side FE objects if necessary for integration at a new point in time: specifically, handle moving elements in moving mesh schemes.

Reimplemented from libMesh::DiffContext.

Definition at line 1393 of file fem_context.C.

References _mesh_sys, _update_time_from_system(), elem_position_set(), and side_fe_reinit().

{
  // Update the "time" variable of this context object
  this->_update_time_from_system(theta);

  // Handle a moving element if necessary
  if (_mesh_sys)
    {
      // FIXME - not threadsafe yet!
      elem_position_set(theta);
      side_fe_reinit();
    }
}

template<typename OutputType >

void libMesh::FEMContext::fixed_interior_gradient	(	unsigned int	var,
		unsigned int	qp,
		OutputType &	grad_u
	)			const [inline]

Returns the gradient of the fixed_solution variable var at the quadrature point qp on the current element interior. This is the preferred API.

Gradient libMesh::FEMContext::fixed_interior_gradient	(	unsigned int	var,
		unsigned int	qp
	)			const

Returns the gradient of the fixed_solution variable var at the quadrature point qp on the current element interior. This API currently present for backward compatibility.

Definition at line 986 of file fem_context.C.

{
  Gradient du;

  this->fixed_interior_gradient( var, qp, du );

  return du;
}

template<typename OutputType >

void libMesh::FEMContext::fixed_interior_hessian	(	unsigned int	var,
		unsigned int	qp,
		OutputType &	hess_u
	)			const [inline]

Returns the hessian of the fixed_solution variable var at the quadrature point qp on the current element interior. This is the preferred API.

Definition at line 1044 of file fem_context.C.

References libMesh::DiffContext::dof_indices, libMesh::DiffContext::dof_indices_var, libMesh::DiffContext::elem_fixed_subsolutions, and libMesh::FEGenericBase< OutputType >::get_d2phi().

{
  typedef typename TensorTools::MakeReal<
    typename TensorTools::DecrementRank<
      typename TensorTools::DecrementRank<
        OutputType>::type>::type>::type
    OutputShape;

  // Get local-to-global dof index lookup
  libmesh_assert_greater (dof_indices.size(), var);
  const unsigned int n_dofs = libmesh_cast_int<unsigned int>
    (dof_indices_var[var].size());

  // Get current local coefficients
  libmesh_assert_greater (elem_fixed_subsolutions.size(), var);
  libmesh_assert(elem_fixed_subsolutions[var]);
  DenseSubVector<Number> &coef = *elem_fixed_subsolutions[var];

  // Get finite element object
  FEGenericBase<OutputShape>* fe = NULL;
  this->get_element_fe<OutputShape>( var, fe );

  // Get shape function values at quadrature point
  const std::vector<std::vector<typename FEGenericBase<OutputShape>::OutputTensor> > &d2phi = fe->get_d2phi();

  // Accumulate solution second derivatives
  d2u = 0.0;

  for (unsigned int l=0; l != n_dofs; l++)
    d2u.add_scaled(d2phi[l][qp], coef(l));

  return;
}

Tensor libMesh::FEMContext::fixed_interior_hessian	(	unsigned int	var,
		unsigned int	qp
	)			const

Returns the hessian of the fixed_solution variable var at the quadrature point qp on the current element interior. This API currently present for backward compatibility.

Definition at line 1033 of file fem_context.C.

{
  Tensor d2u;

  this->fixed_interior_hessian( var, qp, d2u );

  return d2u;
}

template<typename OutputType >

void libMesh::FEMContext::fixed_interior_value	(	unsigned int	var,
		unsigned int	qp,
		OutputType &	u
	)			const [inline]

Returns the value of the fixed_solution variable var at the quadrature point qp on the current element interior. This is the preferred API.

Definition at line 953 of file fem_context.C.

References libMesh::DiffContext::dof_indices, libMesh::DiffContext::dof_indices_var, libMesh::DiffContext::elem_fixed_subsolutions, and libMesh::FEGenericBase< OutputType >::get_phi().

{
  typedef typename TensorTools::MakeReal<OutputType>::type OutputShape;

  // Get local-to-global dof index lookup
  libmesh_assert_greater (dof_indices.size(), var);
  const unsigned int n_dofs = libmesh_cast_int<unsigned int>
    (dof_indices_var[var].size());

  // Get current local coefficients
  libmesh_assert_greater (elem_fixed_subsolutions.size(), var);
  libmesh_assert(elem_fixed_subsolutions[var]);
  DenseSubVector<Number> &coef = *elem_fixed_subsolutions[var];

  // Get finite element object
  FEGenericBase<OutputShape>* fe = NULL;
  this->get_element_fe<OutputShape>( var, fe );

  // Get shape function values at quadrature point
  const std::vector<std::vector<OutputShape> > &phi = fe->get_phi();

  // Accumulate solution value
  u = 0.0;

  for (unsigned int l=0; l != n_dofs; l++)
    u += phi[l][qp] * coef(l);

  return;
}

Number libMesh::FEMContext::fixed_interior_value	(	unsigned int	var,
		unsigned int	qp
	)			const

Returns the value of the fixed_solution variable var at the quadrature point qp on the current element interior. This API currently present for backward compatibility.

Definition at line 941 of file fem_context.C.

{
  Number u = 0.;

  this->fixed_interior_value( var, qp, u );

  return u;
}

template<typename OutputType >

void libMesh::FEMContext::fixed_point_gradient	(	unsigned int	var,
		const Point &	p,
		OutputType &	grad_u
	)			const [inline]

Returns the gradient of the fixed_solution variable var at the physical point p on the current element. This is the preferred API.

Definition at line 1278 of file fem_context.C.

References build_new_fe(), libMesh::DiffContext::dof_indices, libMesh::DiffContext::dof_indices_var, and libMesh::DiffContext::elem_fixed_subsolutions.

{
  typedef typename TensorTools::MakeReal
    <typename TensorTools::DecrementRank<OutputType>::type>::type
      OutputShape;

  // Get local-to-global dof index lookup
  libmesh_assert_greater (dof_indices.size(), var);
  const unsigned int n_dofs = libmesh_cast_int<unsigned int>
    (dof_indices_var[var].size());

  // Get current local coefficients
  libmesh_assert_greater (elem_fixed_subsolutions.size(), var);
  libmesh_assert(elem_fixed_subsolutions[var]);
  DenseSubVector<Number> &coef = *elem_fixed_subsolutions[var];

  // Get finite element object
  FEGenericBase<OutputShape>* fe = NULL;
  this->get_element_fe<OutputShape>( var, fe );

  // Build a FE for calculating u(p)
  AutoPtr<FEGenericBase<OutputShape> > fe_new = this->build_new_fe( fe, p );

  // Get the values of the shape function derivatives
  const std::vector<std::vector<typename FEGenericBase<OutputShape>::OutputGradient> >&  dphi = fe_new->get_dphi();

  grad_u = 0.0;

  for (unsigned int l=0; l != n_dofs; l++)
    grad_u.add_scaled(dphi[l][0], coef(l));

  return;
}

Gradient libMesh::FEMContext::fixed_point_gradient	(	unsigned int	var,
		const Point &	p
	)			const

Returns the gradient of the fixed_solution variable var at the physical point p on the current element. This API currently present for backward compatibility.

Definition at line 1266 of file fem_context.C.

{
  Gradient grad_u;

  this->fixed_point_gradient( var, p, grad_u );

  return grad_u;
}

template<typename OutputType >

void libMesh::FEMContext::fixed_point_hessian	(	unsigned int	var,
		const Point &	p,
		OutputType &	hess_u
	)			const [inline]

Returns the hessian of the fixed_solution variable var at the physical point p on the current element. This is the preferred API.

Definition at line 1328 of file fem_context.C.

References build_new_fe(), libMesh::DiffContext::dof_indices, libMesh::DiffContext::dof_indices_var, and libMesh::DiffContext::elem_fixed_subsolutions.

{
  typedef typename TensorTools::MakeReal<
    typename TensorTools::DecrementRank<
      typename TensorTools::DecrementRank<
        OutputType>::type>::type>::type
    OutputShape;

  // Get local-to-global dof index lookup
  libmesh_assert_greater (dof_indices.size(), var);
  const unsigned int n_dofs = libmesh_cast_int<unsigned int>
    (dof_indices_var[var].size());

  // Get current local coefficients
  libmesh_assert_greater (elem_fixed_subsolutions.size(), var);
  libmesh_assert(elem_fixed_subsolutions[var]);
  DenseSubVector<Number> &coef = *elem_fixed_subsolutions[var];

  // Get finite element object
  FEGenericBase<OutputShape>* fe = NULL;
  this->get_element_fe<OutputShape>( var, fe );
  
  // Build a FE for calculating u(p)
  AutoPtr<FEGenericBase<OutputShape> > fe_new = this->build_new_fe( fe, p );

  // Get the values of the shape function derivatives
  const std::vector<std::vector<typename FEGenericBase<OutputShape>::OutputTensor> >&  d2phi = fe_new->get_d2phi();

  hess_u = 0.0;

  for (unsigned int l=0; l != n_dofs; l++)
    hess_u.add_scaled(d2phi[l][0], coef(l));

  return;
}

Tensor libMesh::FEMContext::fixed_point_hessian	(	unsigned int	var,
		const Point &	p
	)			const

Returns the hessian of the fixed_solution variable var at the physical point p on the current element. This API currently present for backward compatibility.

Definition at line 1316 of file fem_context.C.

{
  Tensor hess_u;

  this->fixed_point_hessian( var, p, hess_u );

  return hess_u;
}

template<typename OutputType >

void libMesh::FEMContext::fixed_point_value	(	unsigned int	var,
		const Point &	p,
		OutputType &	u
	)			const [inline]

Returns the value of the fixed_solution variable var at the physical point p on the current element. This is the preferred API.

Definition at line 1231 of file fem_context.C.

References build_new_fe(), libMesh::DiffContext::dof_indices, libMesh::DiffContext::dof_indices_var, and libMesh::DiffContext::elem_fixed_subsolutions.

{
  typedef typename TensorTools::MakeReal<OutputType>::type OutputShape;

  // Get local-to-global dof index lookup
  libmesh_assert_greater (dof_indices.size(), var);
  const unsigned int n_dofs = libmesh_cast_int<unsigned int>
    (dof_indices_var[var].size());

  // Get current local coefficients
  libmesh_assert_greater (elem_fixed_subsolutions.size(), var);
  libmesh_assert(elem_fixed_subsolutions[var]);
  DenseSubVector<Number> &coef = *elem_fixed_subsolutions[var];

  // Get finite element object
  FEGenericBase<OutputShape>* fe = NULL;
  this->get_element_fe<OutputShape>( var, fe );

  // Build a FE for calculating u(p)
  AutoPtr<FEGenericBase<OutputShape> > fe_new = this->build_new_fe( fe, p );

  // Get the values of the shape function derivatives
  const std::vector<std::vector<OutputShape> >&  phi = fe_new->get_phi();
  
  u = 0.;

  for (unsigned int l=0; l != n_dofs; l++)
    u += phi[l][0] * coef(l);

  return;
}

Number libMesh::FEMContext::fixed_point_value	(	unsigned int	var,
		const Point &	p
	)			const

Returns the value of the fixed_solution variable var at the physical point p on the current element. This API currently present for backward compatibility.

Definition at line 1221 of file fem_context.C.

{
  Number u = 0.;

  this->fixed_point_value( var, p, u );

  return u;
}

template<typename OutputType >

void libMesh::FEMContext::fixed_side_gradient	(	unsigned int	var,
		unsigned int	qp,
		OutputType &	grad_u
	)			const [inline]

Returns the gradient of the fixed_solution variable var at the quadrature point qp on the current element side. This is the preferred API.

Definition at line 1137 of file fem_context.C.

References libMesh::DiffContext::dof_indices, libMesh::DiffContext::dof_indices_var, libMesh::DiffContext::elem_fixed_subsolutions, and libMesh::FEGenericBase< OutputType >::get_dphi().

{
  typedef typename TensorTools::MakeReal
    <typename TensorTools::DecrementRank<OutputType>::type>::type
      OutputShape;

  // Get local-to-global dof index lookup
  libmesh_assert_greater (dof_indices.size(), var);
  const unsigned int n_dofs = libmesh_cast_int<unsigned int>
    (dof_indices_var[var].size());

  // Get current local coefficients
  libmesh_assert_greater (elem_fixed_subsolutions.size(), var);
  libmesh_assert(elem_fixed_subsolutions[var]);
  DenseSubVector<Number> &coef = *elem_fixed_subsolutions[var];

  // Get finite element object
  FEGenericBase<OutputShape>* the_side_fe = NULL;
  this->get_side_fe<OutputShape>( var, the_side_fe );

  // Get shape function values at quadrature point
  const std::vector<std::vector<typename FEGenericBase<OutputShape>::OutputGradient> > &dphi = the_side_fe->get_dphi();

  // Accumulate solution derivatives
  du = 0.0;

  for (unsigned int l=0; l != n_dofs; l++)
    du.add_scaled(dphi[l][qp], coef(l));

  return;
}

Gradient libMesh::FEMContext::fixed_side_gradient	(	unsigned int	var,
		unsigned int	qp
	)			const

Returns the gradient of the fixed_solution variable var at the quadrature point qp on the current element side. This API currently present for backward compatibility.

Definition at line 1126 of file fem_context.C.

{
  Gradient du;

  this->fixed_side_gradient( var, qp, du );

  return du;
}

template<typename OutputType >

void libMesh::FEMContext::fixed_side_hessian	(	unsigned int	var,
		unsigned int	qp,
		OutputType &	hess_u
	)			const [inline]

Returns the hessian of the fixed_solution variable var at the quadrature point qp on the current element side. This is the preferred API.

Definition at line 1183 of file fem_context.C.

References libMesh::DiffContext::dof_indices, libMesh::DiffContext::dof_indices_var, libMesh::DiffContext::elem_fixed_subsolutions, and libMesh::FEGenericBase< OutputType >::get_d2phi().

{
  typedef typename TensorTools::MakeReal<
    typename TensorTools::DecrementRank<
      typename TensorTools::DecrementRank<
        OutputType>::type>::type>::type
    OutputShape;

  // Get local-to-global dof index lookup
  libmesh_assert_greater (dof_indices.size(), var);
  const unsigned int n_dofs = libmesh_cast_int<unsigned int>
    (dof_indices_var[var].size());

  // Get current local coefficients
  libmesh_assert_greater (elem_fixed_subsolutions.size(), var);
  libmesh_assert(elem_fixed_subsolutions[var]);
  DenseSubVector<Number> &coef = *elem_fixed_subsolutions[var];

  // Get finite element object
  FEGenericBase<OutputShape>* the_side_fe = NULL;
  this->get_side_fe<OutputShape>( var, the_side_fe );

  // Get shape function values at quadrature point
  const std::vector<std::vector<typename FEGenericBase<OutputShape>::OutputTensor> > &d2phi = the_side_fe->get_d2phi();

  // Accumulate solution second derivatives
  d2u = 0.0;

  for (unsigned int l=0; l != n_dofs; l++)
    d2u.add_scaled(d2phi[l][qp], coef(l));

  return;
}

Tensor libMesh::FEMContext::fixed_side_hessian	(	unsigned int	var,
		unsigned int	qp
	)			const

Returns the hessian of the fixed_solution variable var at the quadrature point qp on the current element side. This API currently present for backward compatibility.

Definition at line 1173 of file fem_context.C.

{
  Tensor d2u;

  this->fixed_side_hessian( var, qp, d2u );

  return d2u;
}

template<typename OutputType >

void libMesh::FEMContext::fixed_side_value	(	unsigned int	var,
		unsigned int	qp,
		OutputType &	u
	)			const [inline]

Returns the value of the fixed_solution variable var at the quadrature point qp on the current element side. This is the preferred API.

Definition at line 1093 of file fem_context.C.

References libMesh::DiffContext::dof_indices, libMesh::DiffContext::dof_indices_var, libMesh::DiffContext::elem_fixed_subsolutions, and libMesh::FEGenericBase< OutputType >::get_phi().

{
  typedef typename TensorTools::MakeReal<OutputType>::type OutputShape;

  // Get local-to-global dof index lookup
  libmesh_assert_greater (dof_indices.size(), var);
  const unsigned int n_dofs = libmesh_cast_int<unsigned int>
    (dof_indices_var[var].size());

  // Get current local coefficients
  libmesh_assert_greater (elem_fixed_subsolutions.size(), var);
  libmesh_assert(elem_fixed_subsolutions[var]);
  DenseSubVector<Number> &coef = *elem_fixed_subsolutions[var];

  // Get finite element object
  FEGenericBase<OutputShape>* the_side_fe = NULL;
  this->get_side_fe<OutputShape>( var, the_side_fe );

  // Get shape function values at quadrature point
  const std::vector<std::vector<OutputShape> > &phi = the_side_fe->get_phi();

  // Accumulate solution value
  u = 0.0;

  for (unsigned int l=0; l != n_dofs; l++)
    u += phi[l][qp] * coef(l);

  return;
}

Number libMesh::FEMContext::fixed_side_value	(	unsigned int	var,
		unsigned int	qp
	)			const

Returns the value of the fixed_solution variable var at the quadrature point qp on the current element side. This API currently present for backward compatibility.

Definition at line 1082 of file fem_context.C.

{
  Number u = 0.;

  this->fixed_side_value( var, qp, u );

  return u;
}

Real libMesh::DiffContext::get_deltat_value

(

)

[inherited]

Returns the value currently pointed to by this class's _deltat member

Definition at line 117 of file diff_context.C.

References libMesh::DiffContext::_deltat.

Referenced by _update_time_from_system().

{
  libmesh_assert(_deltat);

  return *_deltat;
}

unsigned char libMesh::FEMContext::get_dim

(

)

const [inline]

Accessor for cached element dimension

Definition at line 607 of file fem_context.h.

References dim.

  { return dim; }

const std::vector<dof_id_type>& libMesh::DiffContext::get_dof_indices

(

unsigned int

var

)

const [inline, inherited]

Accessor for element dof indices of a particular variable corresponding to the index argument.

Definition at line 230 of file diff_context.h.

References libMesh::DiffContext::dof_indices_var.

  { return dof_indices_var[var]; }

const std::vector<dof_id_type>& libMesh::DiffContext::get_dof_indices

(

)

const [inline, inherited]

Accessor for element dof indices

Definition at line 223 of file diff_context.h.

References libMesh::DiffContext::dof_indices.

  { return dof_indices; }

unsigned char libMesh::FEMContext::get_edge

(

)

const [inline]

Accessor for current edge of Elem object

Definition at line 601 of file fem_context.h.

References edge.

  { return edge; }

template<typename OutputShape >

void libMesh::FEMContext::get_edge_fe	(	unsigned int	var,
		FEGenericBase< OutputShape > *&	fe
	)			const [inline]

Accessor for edge (3D only!) finite element object for variable var.

Definition at line 769 of file fem_context.h.

References _edge_fe_var.

{ 
  libmesh_assert_less ( var, _edge_fe_var.size() );
  fe = libmesh_cast_ptr<FEGenericBase<OutputShape>*>( _edge_fe_var[var] );
}

const QBase* libMesh::FEMContext::get_edge_qrule

(

)

const [inline]

Accessor for element edge quadrature rule.

Definition at line 518 of file fem_context.h.

References edge_qrule.

  { return this->edge_qrule; }

const Elem& libMesh::FEMContext::get_elem

(

)

const [inline]

Accessor for current Elem object

Definition at line 589 of file fem_context.h.

References elem.

  { return *elem; }

const DenseSubVector<Number>& libMesh::DiffContext::get_elem_fixed_solution

(

unsigned int

var

)

const [inline, inherited]

Accessor for element fixed solution of a particular variable corresponding to the variable index argument.

Definition at line 127 of file diff_context.h.

References libMesh::DiffContext::elem_fixed_subsolutions.

  { return *(elem_fixed_subsolutions[var]); }

const DenseVector<Number>& libMesh::DiffContext::get_elem_fixed_solution

(

)

const [inline, inherited]

Accessor for element fixed solution.

Definition at line 120 of file diff_context.h.

References libMesh::DiffContext::elem_fixed_solution.

  { return elem_fixed_solution; }

DenseSubMatrix<Number>& libMesh::DiffContext::get_elem_jacobian	(	unsigned int	var1,
		unsigned int	var2
	)			[inline, inherited]

Non-const accessor for element Jacobian of particular variables corresponding to the variable index arguments.

Definition at line 179 of file diff_context.h.

References libMesh::DiffContext::elem_subjacobians.

  { return *(elem_subjacobians[var1][var2]); }

const DenseSubMatrix<Number>& libMesh::DiffContext::get_elem_jacobian	(	unsigned int	var1,
		unsigned int	var2
	)			const [inline, inherited]

Const accessor for element Jacobian of particular variables corresponding to the variable index arguments.

Definition at line 172 of file diff_context.h.

References libMesh::DiffContext::elem_subjacobians.

  { return *(elem_subjacobians[var1][var2]); }

DenseMatrix<Number>& libMesh::DiffContext::get_elem_jacobian

(

)

[inline, inherited]

Non-const accessor for element Jacobian.

Definition at line 165 of file diff_context.h.

References libMesh::DiffContext::elem_jacobian.

  { return elem_jacobian; }

const DenseMatrix<Number>& libMesh::DiffContext::get_elem_jacobian

(

)

const [inline, inherited]

Const accessor for element Jacobian.

Definition at line 159 of file diff_context.h.

References libMesh::DiffContext::elem_jacobian.

  { return elem_jacobian; }

DenseSubVector<Number>& libMesh::DiffContext::get_elem_residual

(

unsigned int

var

)

[inline, inherited]

Non-const accessor for element residual of a particular variable corresponding to the variable index argument.

Definition at line 153 of file diff_context.h.

References libMesh::DiffContext::elem_subresiduals.

  { return *(elem_subresiduals[var]); }

const DenseSubVector<Number>& libMesh::DiffContext::get_elem_residual

(

unsigned int

var

)

const [inline, inherited]

Const accessor for element residual of a particular variable corresponding to the variable index argument.

Definition at line 146 of file diff_context.h.

References libMesh::DiffContext::elem_subresiduals.

  { return *(elem_subresiduals[var]); }

DenseVector<Number>& libMesh::DiffContext::get_elem_residual

(

)

[inline, inherited]

Non-const accessor for element residual.

Definition at line 139 of file diff_context.h.

References libMesh::DiffContext::elem_residual.

  { return elem_residual; }

const DenseVector<Number>& libMesh::DiffContext::get_elem_residual

(

)

const [inline, inherited]

Const accessor for element residual.

Definition at line 133 of file diff_context.h.

References libMesh::DiffContext::elem_residual.

  { return elem_residual; }

const DenseSubVector<Number>& libMesh::DiffContext::get_elem_solution

(

unsigned int

var

)

const [inline, inherited]

Accessor for element solution of a particular variable corresponding to the variable index argument.

Definition at line 114 of file diff_context.h.

References libMesh::DiffContext::elem_subsolutions.

  { return *(elem_subsolutions[var]); }

const DenseVector<Number>& libMesh::DiffContext::get_elem_solution

(

)

const [inline, inherited]

Accessor for element solution.

Definition at line 107 of file diff_context.h.

References libMesh::DiffContext::elem_solution.

  { return elem_solution; }

Real libMesh::DiffContext::get_elem_solution_derivative

(

)

const [inline, inherited]

Definition at line 251 of file diff_context.h.

References libMesh::DiffContext::elem_solution_derivative.

  { return elem_solution_derivative; }

template<typename OutputShape >

void libMesh::FEMContext::get_element_fe	(	unsigned int	var,
		FEGenericBase< OutputShape > *&	fe
	)			const [inline]

Accessor for interior finite element object for variable var.

Definition at line 753 of file fem_context.h.

References _element_fe_var.

{
  libmesh_assert_less ( var, _element_fe_var.size() );
  fe = libmesh_cast_ptr<FEGenericBase<OutputShape>*>( _element_fe_var[var] );
}

const QBase* libMesh::FEMContext::get_element_qrule

(

)

const [inline]

Accessor for element interior quadrature rule.

Definition at line 506 of file fem_context.h.

References element_qrule.

  { return this->element_qrule; }

Real libMesh::DiffContext::get_fixed_solution_derivative

(

)

const [inline, inherited]

Definition at line 254 of file diff_context.h.

References libMesh::DiffContext::fixed_solution_derivative.

  { return fixed_solution_derivative; }

const DenseSubVector< Number > & libMesh::DiffContext::get_localized_subvector	(	const NumericVector< Number > &	_localized_vector,
		unsigned int	_var
	)			const [inherited]

const accessible version of get_localized_subvector function

Definition at line 161 of file diff_context.C.

References libMesh::DiffContext::localized_vectors.

{
  std::map<const NumericVector<Number>*, std::pair<DenseVector<Number>, std::vector<DenseSubVector<Number>*> > >::const_iterator
    localized_vectors_it = localized_vectors.find(&_localized_vector);
  libmesh_assert(localized_vectors_it != localized_vectors.end());
  return *localized_vectors_it->second.second[_var];
}

DenseSubVector< Number > & libMesh::DiffContext::get_localized_subvector	(	const NumericVector< Number > &	_localized_vector,
		unsigned int	_var
	)			[inherited]

Return a reference to DenseSubVector localization of _localized_vector at variable _var contained in the localized_vectors map

Definition at line 155 of file diff_context.C.

References libMesh::DiffContext::localized_vectors.

Referenced by interior_values().

{
  return *localized_vectors[&_localized_vector].second[_var];
}

const DenseVector< Number > & libMesh::DiffContext::get_localized_vector

(

const NumericVector< Number > &

_localized_vector

)

const [inherited]

const accessible version of get_localized_vector function

Definition at line 146 of file diff_context.C.

References libMesh::DiffContext::localized_vectors.

{
  std::map<const NumericVector<Number>*, std::pair<DenseVector<Number>, std::vector<DenseSubVector<Number>*> > >::const_iterator
    localized_vectors_it = localized_vectors.find(&_localized_vector);
  libmesh_assert(localized_vectors_it != localized_vectors.end());
  return localized_vectors_it->second.first;
}

DenseVector< Number > & libMesh::DiffContext::get_localized_vector

(

const NumericVector< Number > &

_localized_vector

)

[inherited]

Return a reference to DenseVector localization of _localized_vector contained in the localized_vectors map

Definition at line 140 of file diff_context.C.

References libMesh::DiffContext::localized_vectors.

{
  return localized_vectors[&_localized_vector].first;
}

System* libMesh::FEMContext::get_mesh_system

(

)

[inline]

Accessor for moving mesh System

Definition at line 541 of file fem_context.h.

References _mesh_sys.

  { return this->_mesh_sys; }

const System* libMesh::FEMContext::get_mesh_system

(

)

const [inline]

Accessor for moving mesh System

Definition at line 535 of file fem_context.h.

References _mesh_sys.

  { return this->_mesh_sys; }

unsigned int libMesh::FEMContext::get_mesh_x_var

(

)

const [inline]

Accessor for x-variable of moving mesh System

Definition at line 547 of file fem_context.h.

References _mesh_x_var.

  { return _mesh_x_var; }

unsigned int libMesh::FEMContext::get_mesh_y_var

(

)

const [inline]

Accessor for y-variable of moving mesh System

Definition at line 561 of file fem_context.h.

References _mesh_y_var.

  { return _mesh_y_var; }

unsigned int libMesh::FEMContext::get_mesh_z_var

(

)

const [inline]

Accessor for z-variable of moving mesh System

Definition at line 575 of file fem_context.h.

References _mesh_z_var.

  { return _mesh_z_var; }

DenseSubVector<Number>& libMesh::DiffContext::get_qoi_derivatives	(	unsigned int	qoi,
		unsigned int	var
	)			[inline, inherited]

Non-const accessor for QoI derivative of a particular qoi and variable corresponding to the index arguments.

Definition at line 217 of file diff_context.h.

References libMesh::DiffContext::elem_qoi_subderivatives.

  { return *(elem_qoi_subderivatives[qoi][var]); }

const DenseSubVector<Number>& libMesh::DiffContext::get_qoi_derivatives	(	unsigned int	qoi,
		unsigned int	var
	)			const [inline, inherited]

Const accessor for QoI derivative of a particular qoi and variable corresponding to the index arguments.

Definition at line 210 of file diff_context.h.

References libMesh::DiffContext::elem_qoi_subderivatives.

  { return *(elem_qoi_subderivatives[qoi][var]); }

std::vector<DenseVector<Number> >& libMesh::DiffContext::get_qoi_derivatives

(

)

[inline, inherited]

Non-const accessor for QoI derivatives.

Definition at line 203 of file diff_context.h.

References libMesh::DiffContext::elem_qoi_derivative.

  { return elem_qoi_derivative; }

const std::vector<DenseVector<Number> >& libMesh::DiffContext::get_qoi_derivatives

(

)

const [inline, inherited]

Const accessor for QoI derivatives.

Definition at line 197 of file diff_context.h.

References libMesh::DiffContext::elem_qoi_derivative.

  { return elem_qoi_derivative; }

std::vector<Number>& libMesh::DiffContext::get_qois

(

)

[inline, inherited]

Non-const accessor for QoI vector.

Definition at line 191 of file diff_context.h.

References libMesh::DiffContext::elem_qoi.

  { return elem_qoi; }

const std::vector<Number>& libMesh::DiffContext::get_qois

(

)

const [inline, inherited]

Const accessor for QoI vector.

Definition at line 185 of file diff_context.h.

References libMesh::DiffContext::elem_qoi.

  { return elem_qoi; }

unsigned char libMesh::FEMContext::get_side

(

)

const [inline]

Accessor for current side of Elem object

Definition at line 595 of file fem_context.h.

References side.

  { return side; }

template<typename OutputShape >

void libMesh::FEMContext::get_side_fe	(	unsigned int	var,
		FEGenericBase< OutputShape > *&	fe
	)			const [inline]

Accessor for edge/face (2D/3D) finite element object for variable var.

Definition at line 761 of file fem_context.h.

References _side_fe_var.

{
  libmesh_assert_less ( var, _side_fe_var.size() );
  fe = libmesh_cast_ptr<FEGenericBase<OutputShape>*>( _side_fe_var[var] );
}

const QBase* libMesh::FEMContext::get_side_qrule

(

)

const [inline]

Accessor for element side quadrature rule.

Definition at line 512 of file fem_context.h.

References side_qrule.

  { return this->side_qrule; }

const System& libMesh::DiffContext::get_system

(

)

const [inline, inherited]

Accessor for associated system.

Definition at line 101 of file diff_context.h.

References libMesh::DiffContext::_system.

  { return _system; }

Real libMesh::DiffContext::get_system_time

(

)

const [inline, inherited]

Accessor for the time variable stored in the system class.

Definition at line 236 of file diff_context.h.

References libMesh::DiffContext::system_time.

  { return system_time; }

Real libMesh::DiffContext::get_time

(

)

const [inline, inherited]

Accessor for the time for which the current nonlinear_solution is defined.

Definition at line 242 of file diff_context.h.

References libMesh::DiffContext::time.

  { return time; }

bool libMesh::FEMContext::has_side_boundary_id

(

boundary_id_type

id

)

const

Reports if the boundary id is found on the current side

Definition at line 190 of file fem_context.C.

References _boundary_info, elem, libMesh::BoundaryInfo::has_boundary_id(), and side.

{
  return _boundary_info->has_boundary_id(elem, side, id);
}

template<typename OutputType >

void libMesh::FEMContext::interior_curl	(	unsigned int	var,
		unsigned int	qp,
		OutputType &	curl_u
	)			const [inline]

Returns the curl of the solution variable var at the physical point p on the current element.

Definition at line 463 of file fem_context.C.

References libMesh::DiffContext::dof_indices, libMesh::DiffContext::dof_indices_var, libMesh::DiffContext::elem_subsolutions, and libMesh::FEGenericBase< OutputType >::get_curl_phi().

{
  typedef typename TensorTools::MakeReal<OutputType>::type OutputShape;

  // Get local-to-global dof index lookup
  libmesh_assert_greater (dof_indices.size(), var);
  const unsigned int n_dofs = libmesh_cast_int<unsigned int>
    (dof_indices_var[var].size());

  // Get current local coefficients
  libmesh_assert_greater (elem_subsolutions.size(), var);
  libmesh_assert(elem_subsolutions[var]);
  DenseSubVector<Number> &coef = *elem_subsolutions[var];

  // Get finite element object
  FEGenericBase<OutputShape>* fe = NULL;
  this->get_element_fe<OutputShape>( var, fe );

  // Get shape function values at quadrature point
  const std::vector<std::vector<typename FEGenericBase<OutputShape>::OutputShape> > &curl_phi = fe->get_curl_phi();

  // Accumulate solution curl
  curl_u = 0.;

  for (unsigned int l=0; l != n_dofs; l++)
    curl_u.add_scaled(curl_phi[l][qp], coef(l));

  return;
}

template<typename OutputType >

void libMesh::FEMContext::interior_div	(	unsigned int	var,
		unsigned int	qp,
		OutputType &	div_u
	)			const [inline]

Returns the divergence of the solution variable var at the physical point p on the current element.

Definition at line 496 of file fem_context.C.

References libMesh::DiffContext::dof_indices, libMesh::DiffContext::dof_indices_var, libMesh::DiffContext::elem_subsolutions, and libMesh::FEGenericBase< OutputType >::get_div_phi().

{
  typedef typename 
    TensorTools::IncrementRank
      <typename TensorTools::MakeReal<OutputType>::type>::type OutputShape;

  // Get local-to-global dof index lookup
  libmesh_assert_greater (dof_indices.size(), var);
  const unsigned int n_dofs = libmesh_cast_int<unsigned int>
    (dof_indices_var[var].size());

  // Get current local coefficients
  libmesh_assert_greater (elem_subsolutions.size(), var);
  libmesh_assert(elem_subsolutions[var]);
  DenseSubVector<Number> &coef = *elem_subsolutions[var];

  // Get finite element object
  FEGenericBase<OutputShape>* fe = NULL;
  this->get_element_fe<OutputShape>( var, fe );

  // Get shape function values at quadrature point
  const std::vector<std::vector<typename FEGenericBase<OutputShape>::OutputDivergence> > &div_phi = fe->get_div_phi();

  // Accumulate solution curl
  div_u = 0.;

  for (unsigned int l=0; l != n_dofs; l++)
    div_u += div_phi[l][qp] * coef(l);

  return;
}

template<typename OutputType >

void libMesh::FEMContext::interior_gradient	(	unsigned int	var,
		unsigned int	qp,
		OutputType &	du
	)			const [inline]

Returns the gradient of the solution variable var at the quadrature point qp on the current element interior. This is the preferred API.

Definition at line 294 of file fem_context.C.

References libMesh::DiffContext::dof_indices, libMesh::DiffContext::dof_indices_var, libMesh::DiffContext::elem_subsolutions, and libMesh::FEGenericBase< OutputType >::get_dphi().

{
  typedef typename TensorTools::MakeReal
    <typename TensorTools::DecrementRank<OutputType>::type>::type
      OutputShape;

  // Get local-to-global dof index lookup
  libmesh_assert_greater (dof_indices.size(), var);
  const unsigned int n_dofs = libmesh_cast_int<unsigned int>
    (dof_indices_var[var].size());

  // Get current local coefficients
  libmesh_assert_greater (elem_subsolutions.size(), var);
  libmesh_assert(elem_subsolutions[var]);
  DenseSubVector<Number> &coef = *elem_subsolutions[var];

  // Get finite element object
  FEGenericBase<OutputShape>* fe = NULL;
  this->get_element_fe<OutputShape>( var, fe );

  // Get shape function values at quadrature point
  const std::vector<std::vector<typename FEGenericBase<OutputShape>::OutputGradient> > &dphi = fe->get_dphi();

  // Accumulate solution derivatives
  du = 0;

  for (unsigned int l=0; l != n_dofs; l++)
    du.add_scaled(dphi[l][qp], coef(l));

  return;
}

Gradient libMesh::FEMContext::interior_gradient	(	unsigned int	var,
		unsigned int	qp
	)			const

Returns the gradient of the solution variable var at the quadrature point qp on the current element interior. This API currently present for backward compatibility.

Definition at line 282 of file fem_context.C.

{
  Gradient du;

  this->interior_gradient( var, qp, du );

  return du;
}

template<typename OutputType >

void libMesh::FEMContext::interior_gradients	(	unsigned int	var,
		const NumericVector< Number > &	_system_vector,
		std::vector< OutputType > &	interior_gradients_vector
	)			const [inline]

Fills a vector with the gradient of the solution variable var at all the quadrature points in the current element interior. This is the preferred API.

Definition at line 331 of file fem_context.C.

References libMesh::FEGenericBase< OutputType >::get_dphi().

{
  typedef typename TensorTools::MakeReal
    <typename TensorTools::DecrementRank<OutputType>::type>::type
      OutputShape;

  // Get local-to-global dof index lookup
  libmesh_assert_greater (dof_indices.size(), var);
  const unsigned int n_dofs = libmesh_cast_int<unsigned int>
    (dof_indices_var[var].size());

  // Get current local coefficients  
  const DenseSubVector<Number> &coef = get_localized_subvector(_system_vector, var);

  // Get finite element object
  FEGenericBase<OutputShape>* fe = NULL;
  this->get_element_fe<OutputShape>( var, fe );

  // Get shape function values at quadrature point
  const std::vector<std::vector<typename FEGenericBase<OutputShape>::OutputGradient> > &dphi = fe->get_dphi();
  
  // Loop over all the q_points in this finite element
  for (unsigned int qp=0; qp != du_vals.size(); qp++)
    {      
      OutputType &du = du_vals[qp];

      // Compute the gradient at this q_point
      du = 0;

      for (unsigned int l=0; l != n_dofs; l++)
        du.add_scaled(dphi[l][qp], coef(l));
    }

  return;
}

template<typename OutputType >

void libMesh::FEMContext::interior_hessian	(	unsigned int	var,
		unsigned int	qp,
		OutputType &	d2u
	)			const [inline]

Returns the hessian of the solution variable var at the quadrature point qp on the current element interior. This is the preferred API.

Definition at line 380 of file fem_context.C.

References libMesh::DiffContext::dof_indices, libMesh::DiffContext::dof_indices_var, libMesh::DiffContext::elem_subsolutions, and libMesh::FEGenericBase< OutputType >::get_d2phi().

{
  typedef typename TensorTools::MakeReal<
    typename TensorTools::DecrementRank<
      typename TensorTools::DecrementRank<
        OutputType>::type>::type>::type
    OutputShape;

  // Get local-to-global dof index lookup
  libmesh_assert_greater (dof_indices.size(), var);
  const unsigned int n_dofs = libmesh_cast_int<unsigned int>
    (dof_indices_var[var].size());

  // Get current local coefficients
  libmesh_assert_greater (elem_subsolutions.size(), var);
  libmesh_assert(elem_subsolutions[var]);
  DenseSubVector<Number> &coef = *elem_subsolutions[var];

  // Get finite element object
  FEGenericBase<OutputShape>* fe = NULL;
  this->get_element_fe<OutputShape>( var, fe );

  // Get shape function values at quadrature point
  const std::vector<std::vector<typename FEGenericBase<OutputShape>::OutputTensor> > &d2phi = fe->get_d2phi();

  // Accumulate solution second derivatives
  d2u = 0.0;

  for (unsigned int l=0; l != n_dofs; l++)
    d2u.add_scaled(d2phi[l][qp], coef(l));

  return;
}

Tensor libMesh::FEMContext::interior_hessian	(	unsigned int	var,
		unsigned int	qp
	)			const

Returns the hessian of the solution variable var at the quadrature point qp on the current element interior. This API currently present for backward compatibility.

Definition at line 370 of file fem_context.C.

{
  Tensor d2u;

  this->interior_hessian( var, qp, d2u );

  return d2u;
}

template<typename OutputType >

void libMesh::FEMContext::interior_hessians	(	unsigned int	var,
		const NumericVector< Number > &	_system_vector,
		std::vector< OutputType > &	d2u_vals
	)			const [inline]

Fills a vector of hessians of the _system_vector at the all the quadrature points in the current element interior. This is the preferred API.

Definition at line 418 of file fem_context.C.

References libMesh::FEGenericBase< OutputType >::get_d2phi().

{
  typedef typename TensorTools::MakeReal<
    typename TensorTools::DecrementRank<
      typename TensorTools::DecrementRank<
        OutputType>::type>::type>::type
    OutputShape;

  // Get local-to-global dof index lookup
  libmesh_assert_greater (dof_indices.size(), var);
  const unsigned int n_dofs = libmesh_cast_int<unsigned int>
    (dof_indices_var[var].size());

  // Get current local coefficients  
  const DenseSubVector<Number> &coef = get_localized_subvector(_system_vector, var);

  // Get finite element object
  FEGenericBase<OutputShape>* fe = NULL;
  this->get_element_fe<OutputShape>( var, fe );

  // Get shape function values at quadrature point
  const std::vector<std::vector<typename FEGenericBase<OutputShape>::OutputTensor> > &d2phi = fe->get_d2phi();
  
  // Loop over all the q_points in this finite element
  for (unsigned int qp=0; qp != d2u_vals.size(); qp++)
    {      
      OutputType &d2u = d2u_vals[qp];

      // Compute the gradient at this q_point
      d2u = 0;

      for (unsigned int l=0; l != n_dofs; l++)
        d2u.add_scaled(d2phi[l][qp], coef(l));
    }

  return;
}

template<typename OutputType >

void libMesh::FEMContext::interior_value	(	unsigned int	var,
		unsigned int	qp,
		OutputType &	u
	)			const [inline]

Returns the value of the solution variable var at the quadrature point qp on the current element interior. This is the preferred API.

Definition at line 213 of file fem_context.C.

References libMesh::DiffContext::dof_indices, libMesh::DiffContext::dof_indices_var, libMesh::DiffContext::elem_subsolutions, and libMesh::FEGenericBase< OutputType >::get_phi().

{
  typedef typename TensorTools::MakeReal<OutputType>::type OutputShape;

  // Get local-to-global dof index lookup
  libmesh_assert_greater (dof_indices.size(), var);
  const unsigned int n_dofs = libmesh_cast_int<unsigned int>
    (dof_indices_var[var].size());

  // Get current local coefficients
  libmesh_assert_greater (elem_subsolutions.size(), var);
  libmesh_assert(elem_subsolutions[var]);
  DenseSubVector<Number> &coef = *elem_subsolutions[var];

  // Get finite element object
  FEGenericBase<OutputShape>* fe = NULL;
  this->get_element_fe<OutputShape>( var, fe );

  // Get shape function values at quadrature point
  const std::vector<std::vector<OutputShape> > &phi = fe->get_phi();

  // Accumulate solution value
  u = 0.;

  for (unsigned int l=0; l != n_dofs; l++)
    u += phi[l][qp] * coef(l);

  return;
}

Number libMesh::FEMContext::interior_value	(	unsigned int	var,
		unsigned int	qp
	)			const

Returns the value of the solution variable var at the quadrature point qp on the current element interior. This API currently present for backward compatibility.

Definition at line 203 of file fem_context.C.

{
  Number u = 0.;

  this->interior_value( var, qp, u );

  return u;
}

template<typename OutputType >

void libMesh::FEMContext::interior_values	(	unsigned int	var,
		const NumericVector< Number > &	_system_vector,
		std::vector< OutputType > &	interior_values_vector
	)			const [inline]

Fills a vector of values of the _system_vector at the all the quadrature points in the current element interior.

Definition at line 246 of file fem_context.C.

References libMesh::DiffContext::dof_indices, libMesh::DiffContext::dof_indices_var, libMesh::DiffContext::get_localized_subvector(), and libMesh::FEGenericBase< OutputType >::get_phi().

{
  typedef typename TensorTools::MakeReal<OutputType>::type OutputShape;

  // Get local-to-global dof index lookup
  libmesh_assert_greater (dof_indices.size(), var);
  const unsigned int n_dofs = libmesh_cast_int<unsigned int>
    (dof_indices_var[var].size());
  
  // Get current local coefficients  
  const DenseSubVector<Number> &coef = get_localized_subvector(_system_vector, var);
      
  // Get the finite element object
  FEGenericBase<OutputShape>* fe = NULL;
  this->get_element_fe<OutputShape>( var, fe );

  // Get shape function values at quadrature point
  const std::vector<std::vector<OutputShape> > &phi = fe->get_phi();
    
  // Loop over all the q_points on this element
  for (unsigned int qp=0; qp != u_vals.size(); qp++)
    {            
      OutputType &u = u_vals[qp];
      
      // Compute the value at this q_point
      u = 0.;

      for (unsigned int l=0; l != n_dofs; l++)
        u += phi[l][qp] * coef(l);
    }
  
  return;
}

bool& libMesh::DiffContext::is_adjoint

(

)

[inline, inherited]

Accessor for setting whether we need to do a primal or adjoint solve

Definition at line 268 of file diff_context.h.

References libMesh::DiffContext::_is_adjoint.

  { return _is_adjoint; }

bool libMesh::DiffContext::is_adjoint

(

)

const [inline, inherited]

Accessor for querying whether we need to do a primal or adjoint solve

Definition at line 261 of file diff_context.h.

References libMesh::DiffContext::_is_adjoint.

  { return _is_adjoint; }

unsigned int libMesh::DiffContext::n_vars

(

)

const [inline, inherited]

Number of variables in solution.

Definition at line 95 of file diff_context.h.

References libMesh::DiffContext::dof_indices_var.

  { return libmesh_cast_int<unsigned int>(dof_indices_var.size()); }

template<typename OutputType >

void libMesh::FEMContext::point_gradient	(	unsigned int	var,
		const Point &	p,
		OutputType &	grad_u
	)			const [inline]

Returns the gradient of the solution variable var at the physical point p on the current element. This is the preferred API.

Definition at line 849 of file fem_context.C.

References build_new_fe(), libMesh::DiffContext::dof_indices, libMesh::DiffContext::dof_indices_var, and libMesh::DiffContext::elem_subsolutions.

{
  typedef typename TensorTools::MakeReal
    <typename TensorTools::DecrementRank<OutputType>::type>::type
      OutputShape;

  // Get local-to-global dof index lookup
  libmesh_assert_greater (dof_indices.size(), var);
  const unsigned int n_dofs = libmesh_cast_int<unsigned int>
    (dof_indices_var[var].size());

  // Get current local coefficients
  libmesh_assert_greater (elem_subsolutions.size(), var);
  libmesh_assert(elem_subsolutions[var]);
  DenseSubVector<Number> &coef = *elem_subsolutions[var];

  // Get finite element object
  FEGenericBase<OutputShape>* fe = NULL;
  this->get_element_fe<OutputShape>( var, fe );

  // Build a FE for calculating u(p)
  AutoPtr<FEGenericBase<OutputShape> > fe_new = this->build_new_fe( fe, p );

  // Get the values of the shape function derivatives
  const std::vector<std::vector<typename FEGenericBase<OutputShape>::OutputGradient> >&  dphi = fe_new->get_dphi();

  grad_u = 0.0;

  for (unsigned int l=0; l != n_dofs; l++)
    grad_u.add_scaled(dphi[l][0], coef(l));

  return;
}

Gradient libMesh::FEMContext::point_gradient	(	unsigned int	var,
		const Point &	p
	)			const

Returns the gradient of the solution variable var at the physical point p on the current element. This API currently present for backward compatibility.

Definition at line 837 of file fem_context.C.

{
  Gradient grad_u;

  this->point_gradient( var, p, grad_u );

  return grad_u;
}

template<typename OutputType >

void libMesh::FEMContext::point_hessian	(	unsigned int	var,
		const Point &	p,
		OutputType &	hess_u
	)			const [inline]

Returns the hessian of the solution variable var at the physical point p on the current element. This is the preferred API.

Definition at line 899 of file fem_context.C.

References build_new_fe(), libMesh::DiffContext::dof_indices, libMesh::DiffContext::dof_indices_var, and libMesh::DiffContext::elem_subsolutions.

{
  typedef typename TensorTools::MakeReal<
    typename TensorTools::DecrementRank<
      typename TensorTools::DecrementRank<
        OutputType>::type>::type>::type
    OutputShape;

  // Get local-to-global dof index lookup
  libmesh_assert_greater (dof_indices.size(), var);
  const unsigned int n_dofs = libmesh_cast_int<unsigned int>
    (dof_indices_var[var].size());

  // Get current local coefficients
  libmesh_assert_greater (elem_subsolutions.size(), var);
  libmesh_assert(elem_subsolutions[var]);
  DenseSubVector<Number> &coef = *elem_subsolutions[var];

  // Get finite element object
  FEGenericBase<OutputShape>* fe = NULL;
  this->get_element_fe<OutputShape>( var, fe );
  
  // Build a FE for calculating u(p)
  AutoPtr<FEGenericBase<OutputShape> > fe_new = this->build_new_fe( fe, p );

  // Get the values of the shape function derivatives
  const std::vector<std::vector<typename FEGenericBase<OutputShape>::OutputTensor> >&  d2phi = fe_new->get_d2phi();

  hess_u = 0.0;

  for (unsigned int l=0; l != n_dofs; l++)
    hess_u.add_scaled(d2phi[l][0], coef(l));

  return;
}

Tensor libMesh::FEMContext::point_hessian	(	unsigned int	var,
		const Point &	p
	)			const

Returns the hessian of the solution variable var at the physical point p on the current element. This API currently present for backward compatibility.

Definition at line 888 of file fem_context.C.

{
  Tensor hess_u;

  this->point_hessian( var, p, hess_u );

  return hess_u;
}

template<typename OutputType >

void libMesh::FEMContext::point_value	(	unsigned int	var,
		const Point &	p,
		OutputType &	u
	)			const [inline]

Returns the value of the solution variable var at the physical point p on the current element. This is the preferred API.

Definition at line 802 of file fem_context.C.

References build_new_fe(), libMesh::DiffContext::dof_indices, libMesh::DiffContext::dof_indices_var, and libMesh::DiffContext::elem_subsolutions.

{
  typedef typename TensorTools::MakeReal<OutputType>::type OutputShape;

  // Get local-to-global dof index lookup
  libmesh_assert_greater (dof_indices.size(), var);
  const unsigned int n_dofs = libmesh_cast_int<unsigned int>
    (dof_indices_var[var].size());

  // Get current local coefficients
  libmesh_assert_greater (elem_subsolutions.size(), var);
  libmesh_assert(elem_subsolutions[var]);
  DenseSubVector<Number> &coef = *elem_subsolutions[var];

  // Get finite element object
  FEGenericBase<OutputShape>* fe = NULL;
  this->get_element_fe<OutputShape>( var, fe );

  // Build a FE for calculating u(p)
  AutoPtr<FEGenericBase<OutputShape> > fe_new = this->build_new_fe( fe, p );

  // Get the values of the shape function derivatives
  const std::vector<std::vector<OutputShape> >&  phi = fe_new->get_phi();
  
  u = 0.;

  for (unsigned int l=0; l != n_dofs; l++)
    u += phi[l][0] * coef(l);

  return;
}

Number libMesh::FEMContext::point_value	(	unsigned int	var,
		const Point &	p
	)			const

Returns the value of the solution variable var at the physical point p on the current element. This API currently present for backward compatibility.

Definition at line 792 of file fem_context.C.

{
  Number u = 0.;

  this->point_value( var, p, u );

  return u;
}

void libMesh::FEMContext::pre_fe_reinit	(	const System &	sys,
		const Elem *	e
	)			[virtual]

Reinitializes local data vectors/matrices on the current geometric element

Definition at line 1619 of file fem_context.C.

References libMesh::System::current_solution(), libMesh::DiffContext::dof_indices, libMesh::DofMap::dof_indices(), libMesh::DiffContext::dof_indices_var, elem, libMesh::DiffContext::elem_fixed_solution, libMesh::DiffContext::elem_fixed_subsolutions, libMesh::DiffContext::elem_jacobian, libMesh::DiffContext::elem_qoi_derivative, libMesh::DiffContext::elem_qoi_subderivatives, libMesh::DiffContext::elem_residual, libMesh::DiffContext::elem_solution, libMesh::DiffContext::elem_subjacobians, libMesh::DiffContext::elem_subresiduals, libMesh::DiffContext::elem_subsolutions, libMesh::System::get_dof_map(), libMesh::DiffContext::localized_vectors, libMesh::System::n_vars(), libMesh::System::qoi, libMesh::DenseMatrix< T >::resize(), libMesh::DenseVector< T >::resize(), and libMesh::System::use_fixed_solution.

Referenced by libMesh::FEMSystem::mesh_position_get(), libMesh::FEMSystem::mesh_position_set(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), and libMesh::System::project_vector().

{
  elem = e;

  // Initialize the per-element data for elem.
  sys.get_dof_map().dof_indices (elem, dof_indices);
  const unsigned int n_dofs = libmesh_cast_int<unsigned int>
    (dof_indices.size());
  const std::size_t n_qoi = sys.qoi.size();

  elem_solution.resize(n_dofs);
  if (sys.use_fixed_solution)
    elem_fixed_solution.resize(n_dofs);

  for (unsigned int i=0; i != n_dofs; ++i)
    elem_solution(i) = sys.current_solution(dof_indices[i]);

  // These resize calls also zero out the residual and jacobian
  elem_residual.resize(n_dofs);
  elem_jacobian.resize(n_dofs, n_dofs);

  elem_qoi_derivative.resize(n_qoi);
  elem_qoi_subderivatives.resize(n_qoi);
  for (std::size_t q=0; q != n_qoi; ++q)
    elem_qoi_derivative[q].resize(n_dofs);

  // Initialize the per-variable data for elem.
  {
    unsigned int sub_dofs = 0;
    for (unsigned int i=0; i != sys.n_vars(); ++i)
      {
        sys.get_dof_map().dof_indices (elem, dof_indices_var[i], i);

        const unsigned int n_dofs_var = libmesh_cast_int<unsigned int>
          (dof_indices_var[i].size());

        elem_subsolutions[i]->reposition
          (sub_dofs, n_dofs_var);

        if (sys.use_fixed_solution)
          elem_fixed_subsolutions[i]->reposition
            (sub_dofs, n_dofs_var);

        elem_subresiduals[i]->reposition
          (sub_dofs, n_dofs_var);

        for (std::size_t q=0; q != n_qoi; ++q)
          elem_qoi_subderivatives[q][i]->reposition
            (sub_dofs, n_dofs_var);

        for (unsigned int j=0; j != i; ++j)
          {
            const unsigned int n_dofs_var_j =
              libmesh_cast_int<unsigned int>
                (dof_indices_var[j].size());

            elem_subjacobians[i][j]->reposition
              (sub_dofs, elem_subresiduals[j]->i_off(),
               n_dofs_var, n_dofs_var_j);
            elem_subjacobians[j][i]->reposition
              (elem_subresiduals[j]->i_off(), sub_dofs,
               n_dofs_var_j, n_dofs_var);
          }
        elem_subjacobians[i][i]->reposition
          (sub_dofs, sub_dofs,
           n_dofs_var,
           n_dofs_var);
        sub_dofs += n_dofs_var;
      }
    libmesh_assert_equal_to (sub_dofs, n_dofs);
  }

  // Now do the localization for the user requested vectors
  DiffContext::localized_vectors_iterator localized_vec_it = localized_vectors.begin();
  const DiffContext::localized_vectors_iterator localized_vec_end = localized_vectors.end();
  
  for(; localized_vec_it != localized_vec_end; ++localized_vec_it)
    {
      const NumericVector<Number> * current_localized_vector = localized_vec_it->first;

      DenseVector<Number>& target_vector = localized_vec_it->second.first;
      
      target_vector.resize(n_dofs);
          
      for (unsigned int i=0; i != n_dofs; ++i)
        target_vector(i) = (*current_localized_vector)(dof_indices[i]);
                          
      // Initialize the per-variable data for elem.
      unsigned int sub_dofs = 0;
      for (unsigned int i=0; i != sys.n_vars(); ++i)
        {
          const unsigned int n_dofs_var = libmesh_cast_int<unsigned int>
            (dof_indices_var[i].size());
          sys.get_dof_map().dof_indices (elem, dof_indices_var[i], i);

          localized_vec_it->second.second[i]->reposition
            (sub_dofs, n_dofs_var);

          sub_dofs += n_dofs_var;                     
        }
      libmesh_assert_equal_to (sub_dofs, n_dofs);         
    }
}

void libMesh::DiffContext::set_deltat_pointer

(

Real *

dt

)

[inherited]

Points the _deltat member of this class at a timestep value stored in the creating System, for example DiffSystem::deltat

Definition at line 109 of file diff_context.C.

References libMesh::DiffContext::_deltat.

Referenced by libMesh::FEMSystem::init_context().

{
  // We may actually want to be able to set this pointer to NULL, so
  // don't report an error for that.
  _deltat = dt;
}

virtual void libMesh::FEMContext::set_mesh_system

(

System *

sys

)

[inline, virtual]

Tells the FEMContext that system sys contains the isoparametric Lagrangian variables which correspond to the coordinates of mesh nodes, in problems where the mesh itself is expected to move in time.

This should be set automatically if the FEMPhysics requires it.

Definition at line 529 of file fem_context.h.

References _mesh_sys.

Referenced by libMesh::FEMSystem::build_context().

  { this->_mesh_sys = sys; }

void libMesh::FEMContext::set_mesh_x_var

(

unsigned int

x_var

)

[inline]

Accessor for x-variable of moving mesh System

This should be set automatically if the FEMPhysics requires it.

Definition at line 555 of file fem_context.h.

References _mesh_x_var.

Referenced by libMesh::FEMSystem::build_context().

  { _mesh_x_var = x_var; }

void libMesh::FEMContext::set_mesh_y_var

(

unsigned int

y_var

)

[inline]

Accessor for y-variable of moving mesh System

This should be set automatically if the FEMPhysics requires it.

Definition at line 569 of file fem_context.h.

References _mesh_y_var.

Referenced by libMesh::FEMSystem::build_context().

  { _mesh_y_var = y_var; }

void libMesh::FEMContext::set_mesh_z_var

(

unsigned int

z_var

)

[inline]

Accessor for z-variable of moving mesh System

This should be set automatically if the FEMPhysics requires it.

Definition at line 583 of file fem_context.h.

References _mesh_z_var.

Referenced by libMesh::FEMSystem::build_context().

  { _mesh_z_var = z_var; }

void libMesh::DiffContext::set_time

(

Real

time_in

)

[inline, inherited]

Set the time for which the current nonlinear_solution is defined.

Definition at line 248 of file diff_context.h.

References libMesh::DiffContext::time.

  { time = time_in; }

std::vector< boundary_id_type > libMesh::FEMContext::side_boundary_ids

(

)

const

Lists the boundary ids found on the current side

Definition at line 196 of file fem_context.C.

References _boundary_info, libMesh::BoundaryInfo::boundary_ids(), elem, and side.

{
  return _boundary_info->boundary_ids(elem, side);
}

void libMesh::FEMContext::side_fe_reinit

(

)

Reinitializes side FE objects on the current geometric element

Definition at line 1444 of file fem_context.C.

References _side_fe, elem, side, and side_fe.

Referenced by elem_side_reinit().

{
  // Initialize all the side FE objects on elem/side.
  // Logging of FE::reinit is done in the FE functions
  std::map<FEType, FEBase *>::iterator fe_end = side_fe.end();
  for (std::map<FEType, FEBase *>::iterator i = side_fe.begin();
       i != fe_end; ++i)
    {
      i->second->reinit(elem, side);
    }

  std::map<FEType, FEAbstract *>::iterator local_fe_end = _side_fe.end();
  for (std::map<FEType, FEAbstract *>::iterator i = _side_fe.begin();
       i != local_fe_end; ++i)
    {
      i->second->reinit(elem, side);
    }
}

template<typename OutputType >

void libMesh::FEMContext::side_gradient	(	unsigned int	var,
		unsigned int	qp,
		OutputType &	du
	)			const [inline]

Returns the gradient of the solution variable var at the quadrature point qp on the current element side. This is the preferred API.

Definition at line 622 of file fem_context.C.

References libMesh::DiffContext::dof_indices, libMesh::DiffContext::dof_indices_var, libMesh::DiffContext::elem_subsolutions, and libMesh::FEGenericBase< OutputType >::get_dphi().

{
  typedef typename TensorTools::MakeReal
    <typename TensorTools::DecrementRank<OutputType>::type>::type
      OutputShape;

  // Get local-to-global dof index lookup
  libmesh_assert_greater (dof_indices.size(), var);
  const unsigned int n_dofs = libmesh_cast_int<unsigned int>
    (dof_indices_var[var].size());

  // Get current local coefficients
  libmesh_assert_greater (elem_subsolutions.size(), var);
  libmesh_assert(elem_subsolutions[var]);
  DenseSubVector<Number> &coef = *elem_subsolutions[var];

  // Get finite element object
  FEGenericBase<OutputShape>* the_side_fe = NULL;
  this->get_side_fe<OutputShape>( var, the_side_fe );

  // Get shape function values at quadrature point
  const std::vector<std::vector< typename FEGenericBase<OutputShape>::OutputGradient> > &dphi = the_side_fe->get_dphi();

  // Accumulate solution derivatives
  du = 0.;

  for (unsigned int l=0; l != n_dofs; l++)
    du.add_scaled(dphi[l][qp], coef(l));

  return;
}

Gradient libMesh::FEMContext::side_gradient	(	unsigned int	var,
		unsigned int	qp
	)			const

Returns the gradient of the solution variable var at the quadrature point qp on the current element side. This API currently present for backward compatibility.

Definition at line 611 of file fem_context.C.

{
  Gradient du;

  this->side_gradient( var, qp, du );

  return du;
}

template<typename OutputType >

void libMesh::FEMContext::side_gradients	(	unsigned int	var,
		const NumericVector< Number > &	_system_vector,
		std::vector< OutputType > &	side_gradients_vector
	)			const [inline]

Fills a vector with the gradient of the solution variable var at all the quadrature points on the current element side. This is the preferred API.

Definition at line 659 of file fem_context.C.

References libMesh::FEGenericBase< OutputType >::get_dphi().

{
  typedef typename TensorTools::MakeReal
    <typename TensorTools::DecrementRank<OutputType>::type>::type
      OutputShape;

  // Get local-to-global dof index lookup
  libmesh_assert_greater (dof_indices.size(), var);
  const unsigned int n_dofs = libmesh_cast_int<unsigned int>
    (dof_indices_var[var].size());

  // Get current local coefficients  
  const DenseSubVector<Number> &coef = get_localized_subvector(_system_vector, var);

  // Get finite element object
  FEGenericBase<OutputShape>* the_side_fe = NULL;
  this->get_side_fe<OutputShape>( var, the_side_fe );

  // Get shape function values at quadrature point
  const std::vector<std::vector<typename FEGenericBase<OutputShape>::OutputGradient> > &dphi = the_side_fe->get_dphi();
  
  // Loop over all the q_points in this finite element
  for (unsigned int qp=0; qp != du_vals.size(); qp++)
    {      
      OutputType &du = du_vals[qp];

      du = 0;

      // Compute the gradient at this q_point
      for (unsigned int l=0; l != n_dofs; l++)
        du.add_scaled(dphi[l][qp], coef(l));
    }

  return;
}

template<typename OutputType >

void libMesh::FEMContext::side_hessian	(	unsigned int	var,
		unsigned int	qp,
		OutputType &	d2u
	)			const [inline]

Returns the hessian of the solution variable var at the quadrature point qp on the current element side. This is the preferred API.

Definition at line 708 of file fem_context.C.

References libMesh::DiffContext::dof_indices, libMesh::DiffContext::dof_indices_var, libMesh::DiffContext::elem_subsolutions, and libMesh::FEGenericBase< OutputType >::get_d2phi().

{
  typedef typename TensorTools::MakeReal<
    typename TensorTools::DecrementRank<
      typename TensorTools::DecrementRank<
        OutputType>::type>::type>::type
    OutputShape;

  // Get local-to-global dof index lookup
  libmesh_assert_greater (dof_indices.size(), var);
  const unsigned int n_dofs = libmesh_cast_int<unsigned int>
    (dof_indices_var[var].size());

  // Get current local coefficients
  libmesh_assert_greater (elem_subsolutions.size(), var);
  libmesh_assert(elem_subsolutions[var]);
  DenseSubVector<Number> &coef = *elem_subsolutions[var];

  // Get finite element object
  FEGenericBase<OutputShape>* the_side_fe = NULL;
  this->get_side_fe<OutputShape>( var, the_side_fe );

  // Get shape function values at quadrature point
  const std::vector<std::vector<typename FEGenericBase<OutputShape>::OutputTensor> > &d2phi = the_side_fe->get_d2phi();

  // Accumulate solution second derivatives
  d2u = 0.0;

  for (unsigned int l=0; l != n_dofs; l++)
    d2u.add_scaled(d2phi[l][qp], coef(l));

  return;
}

Tensor libMesh::FEMContext::side_hessian	(	unsigned int	var,
		unsigned int	qp
	)			const

Returns the hessian of the solution variable var at the quadrature point qp on the current element side. This API currently present for backward compatibility.

Definition at line 698 of file fem_context.C.

{
  Tensor d2u;

  this->side_hessian( var, qp, d2u );

  return d2u;
}

template<typename OutputType >

void libMesh::FEMContext::side_hessians	(	unsigned int	var,
		const NumericVector< Number > &	_system_vector,
		std::vector< OutputType > &	d2u_vals
	)			const [inline]

Fills a vector of hessians of the _system_vector at the all the quadrature points on the current element side. This is the preferred API.

Definition at line 746 of file fem_context.C.

References libMesh::FEGenericBase< OutputType >::get_d2phi().

{
  typedef typename TensorTools::MakeReal<
    typename TensorTools::DecrementRank<
      typename TensorTools::DecrementRank<
        OutputType>::type>::type>::type
    OutputShape;

  // Get local-to-global dof index lookup
  libmesh_assert_greater (dof_indices.size(), var);
  const unsigned int n_dofs = libmesh_cast_int<unsigned int>
    (dof_indices_var[var].size());

  // Get current local coefficients  
  const DenseSubVector<Number> &coef = get_localized_subvector(_system_vector, var);

  // Get finite element object
  FEGenericBase<OutputShape>* the_side_fe = NULL;
  this->get_side_fe<OutputShape>( var, the_side_fe );

  // Get shape function values at quadrature point
  const std::vector<std::vector<typename FEGenericBase<OutputShape>::OutputTensor> > &d2phi = the_side_fe->get_d2phi();
  
  // Loop over all the q_points in this finite element
  for (unsigned int qp=0; qp != d2u_vals.size(); qp++)
    {      
      OutputType &d2u = d2u_vals[qp];

      // Compute the gradient at this q_point
      d2u = 0;

      for (unsigned int l=0; l != n_dofs; l++)
        d2u.add_scaled(d2phi[l][qp], coef(l));
    }

  return;
}

template<typename OutputType >

void libMesh::FEMContext::side_value	(	unsigned int	var,
		unsigned int	qp,
		OutputType &	u
	)			const [inline]

Returns the value of the solution variable var at the quadrature point qp on the current element side. This is the preferred API.

Definition at line 541 of file fem_context.C.

References libMesh::DiffContext::dof_indices, libMesh::DiffContext::dof_indices_var, libMesh::DiffContext::elem_subsolutions, and libMesh::FEGenericBase< OutputType >::get_phi().

{
  typedef typename TensorTools::MakeReal<OutputType>::type OutputShape;

  // Get local-to-global dof index lookup
  libmesh_assert_greater (dof_indices.size(), var);
  const unsigned int n_dofs = libmesh_cast_int<unsigned int>
    (dof_indices_var[var].size());

  // Get current local coefficients
  libmesh_assert_greater (elem_subsolutions.size(), var);
  libmesh_assert(elem_subsolutions[var]);
  DenseSubVector<Number> &coef = *elem_subsolutions[var];

  // Get finite element object
  FEGenericBase<OutputShape>* the_side_fe = NULL;
  this->get_side_fe<OutputShape>( var, the_side_fe );

  // Get shape function values at quadrature point
  const std::vector<std::vector<OutputShape> > &phi = the_side_fe->get_phi();

  // Accumulate solution value
  u = 0.;

  for (unsigned int l=0; l != n_dofs; l++)
    u += phi[l][qp] * coef(l);

  return;
}

Number libMesh::FEMContext::side_value	(	unsigned int	var,
		unsigned int	qp
	)			const

Returns the value of the solution variable var at the quadrature point qp on the current element side. This API currently present for backward compatibility.

Definition at line 530 of file fem_context.C.

{
  Number u = 0.;

  this->side_value( var, qp, u );

  return u;
}

template<typename OutputType >

void libMesh::FEMContext::side_values	(	unsigned int	var,
		const NumericVector< Number > &	_system_vector,
		std::vector< OutputType > &	side_values_vector
	)			const [inline]

Fills a vector of values of the _system_vector at the all the quadrature points on the current element side.

Definition at line 575 of file fem_context.C.

References libMesh::FEGenericBase< OutputType >::get_phi().

{    
  typedef typename TensorTools::MakeReal<OutputType>::type OutputShape;

  // Get local-to-global dof index lookup
  libmesh_assert_greater (dof_indices.size(), var);
  const unsigned int n_dofs = libmesh_cast_int<unsigned int>
    (dof_indices_var[var].size());
  
  // Get current local coefficients  
  const DenseSubVector<Number> &coef = get_localized_subvector(_system_vector, var);
      
  // Get the finite element object
  FEGenericBase<OutputShape>* the_side_fe = NULL;
  this->get_side_fe<OutputShape>( var, the_side_fe );

  // Get shape function values at quadrature point
  const std::vector<std::vector<OutputShape> > &phi = the_side_fe->get_phi();
    
  // Loop over all the q_points on this element
  for (unsigned int qp=0; qp != u_vals.size(); qp++)
    {            
      OutputType &u = u_vals[qp];

      // Compute the value at this q_point
      u = 0.;
      
      for (unsigned int l=0; l != n_dofs; l++)
        u += phi[l][qp] * coef(l);
    }
  
  return;
}

---

Member Data Documentation

BoundaryInfo* libMesh::FEMContext::_boundary_info [protected]

Saved pointer to BoundaryInfo on the mesh for this System. Used to answer boundary id requests.

Definition at line 718 of file fem_context.h.

Referenced by has_side_boundary_id(), and side_boundary_ids().

std::map<FEType, FEAbstract*> libMesh::FEMContext::_edge_fe [protected]

Definition at line 703 of file fem_context.h.

Referenced by edge_fe_reinit(), FEMContext(), and ~FEMContext().

std::vector<FEAbstract*> libMesh::FEMContext::_edge_fe_var [protected]

Definition at line 712 of file fem_context.h.

Referenced by FEMContext(), and get_edge_fe().

std::map<FEType, FEAbstract*> libMesh::FEMContext::_element_fe [protected]

Finite element objects for each variable's interior, sides and edges.

Definition at line 701 of file fem_context.h.

Referenced by elem_fe_reinit(), FEMContext(), and ~FEMContext().

std::vector<FEAbstract*> libMesh::FEMContext::_element_fe_var [protected]

Pointers to the same finite element objects, but indexed by variable number

Definition at line 710 of file fem_context.h.

Referenced by FEMContext(), and get_element_fe().

System* libMesh::FEMContext::_mesh_sys

System from which to acquire moving mesh information

Definition at line 663 of file fem_context.h.

Referenced by _do_elem_position_set(), elem_edge_reinit(), elem_position_get(), elem_position_set(), elem_reinit(), elem_side_reinit(), get_mesh_system(), and set_mesh_system().

unsigned int libMesh::FEMContext::_mesh_x_var

Variables from which to acquire moving mesh information

Definition at line 668 of file fem_context.h.

Referenced by _do_elem_position_set(), elem_position_get(), get_mesh_x_var(), and set_mesh_x_var().

unsigned int libMesh::FEMContext::_mesh_y_var

Definition at line 668 of file fem_context.h.

Referenced by _do_elem_position_set(), elem_position_get(), get_mesh_y_var(), and set_mesh_y_var().

unsigned int libMesh::FEMContext::_mesh_z_var

Definition at line 668 of file fem_context.h.

Referenced by _do_elem_position_set(), elem_position_get(), get_mesh_z_var(), and set_mesh_z_var().

std::map<FEType, FEAbstract*> libMesh::FEMContext::_side_fe [protected]

Definition at line 702 of file fem_context.h.

Referenced by FEMContext(), side_fe_reinit(), and ~FEMContext().

std::vector<FEAbstract*> libMesh::FEMContext::_side_fe_var [protected]

Definition at line 711 of file fem_context.h.

Referenced by FEMContext(), and get_side_fe().

unsigned char libMesh::FEMContext::dim

Cached dimension of elements in this mesh

Definition at line 688 of file fem_context.h.

Referenced by build_new_fe(), edge_fe_reinit(), FEMContext(), and get_dim().

std::vector<dof_id_type> libMesh::DiffContext::dof_indices [inherited]

Global Degree of freedom index lists

Definition at line 347 of file diff_context.h.

Referenced by libMesh::EulerSolver::element_residual(), libMesh::Euler2Solver::element_residual(), fixed_interior_hessian(), fixed_interior_value(), fixed_point_gradient(), fixed_point_hessian(), fixed_point_value(), fixed_side_gradient(), fixed_side_hessian(), fixed_side_value(), libMesh::DiffContext::get_dof_indices(), interior_curl(), interior_div(), interior_gradient(), interior_hessian(), interior_value(), interior_values(), libMesh::FEMSystem::numerical_jacobian(), point_gradient(), point_hessian(), point_value(), pre_fe_reinit(), side_gradient(), side_hessian(), libMesh::EulerSolver::side_residual(), libMesh::Euler2Solver::side_residual(), and side_value().

std::vector<std::vector<dof_id_type> > libMesh::DiffContext::dof_indices_var [inherited]

Definition at line 348 of file diff_context.h.

Referenced by fixed_interior_hessian(), fixed_interior_value(), fixed_point_gradient(), fixed_point_hessian(), fixed_point_value(), fixed_side_gradient(), fixed_side_hessian(), fixed_side_value(), libMesh::DiffContext::get_dof_indices(), interior_curl(), interior_div(), interior_gradient(), interior_hessian(), interior_value(), interior_values(), libMesh::FEMSystem::mesh_position_get(), libMesh::DiffContext::n_vars(), libMesh::FEMSystem::numerical_jacobian(), point_gradient(), point_hessian(), point_value(), pre_fe_reinit(), side_gradient(), side_hessian(), and side_value().

unsigned char libMesh::FEMContext::edge

Current edge for edge_* to examine

Definition at line 683 of file fem_context.h.

Referenced by edge_fe_reinit(), and get_edge().

std::map<FEType, FEBase *> libMesh::FEMContext::edge_fe

Definition at line 616 of file fem_context.h.

Referenced by edge_fe_reinit(), FEMContext(), and ~FEMContext().

std::vector<FEBase *> libMesh::FEMContext::edge_fe_var

Definition at line 624 of file fem_context.h.

Referenced by FEMContext().

QBase* libMesh::FEMContext::edge_qrule

Quadrature rules for element edges. If the FEM context is told to prepare for edge integration on 3D elements, it will try to find a quadrature rule that correctly integrates all variables

Definition at line 645 of file fem_context.h.

Referenced by FEMContext(), get_edge_qrule(), and ~FEMContext().

const Elem* libMesh::FEMContext::elem

Current element for element_* to examine

Definition at line 673 of file fem_context.h.

Referenced by _do_elem_position_set(), build_new_fe(), edge_fe_reinit(), elem_fe_reinit(), elem_position_get(), get_elem(), has_side_boundary_id(), libMesh::FEMSystem::mesh_position_set(), libMesh::FEMSystem::numerical_jacobian(), pre_fe_reinit(), side_boundary_ids(), and side_fe_reinit().

DenseVector<Number> libMesh::DiffContext::elem_fixed_solution [inherited]

Element by element components of nonlinear_solution at a fixed point in a timestep, for optional use by e.g. stabilized methods

Definition at line 299 of file diff_context.h.

Referenced by libMesh::DiffContext::DiffContext(), libMesh::SteadySolver::element_residual(), libMesh::EulerSolver::element_residual(), libMesh::Euler2Solver::element_residual(), libMesh::DiffContext::get_elem_fixed_solution(), pre_fe_reinit(), libMesh::SteadySolver::side_residual(), libMesh::EulerSolver::side_residual(), and libMesh::Euler2Solver::side_residual().

std::vector<DenseSubVector<Number> *> libMesh::DiffContext::elem_fixed_subsolutions [inherited]

Definition at line 300 of file diff_context.h.

Referenced by libMesh::DiffContext::DiffContext(), fixed_interior_hessian(), fixed_interior_value(), fixed_point_gradient(), fixed_point_hessian(), fixed_point_value(), fixed_side_gradient(), fixed_side_hessian(), fixed_side_value(), libMesh::DiffContext::get_elem_fixed_solution(), pre_fe_reinit(), and libMesh::DiffContext::~DiffContext().

DenseMatrix<Number> libMesh::DiffContext::elem_jacobian [inherited]

Element jacobian: derivatives of elem_residual with respect to elem_solution

Definition at line 325 of file diff_context.h.

Referenced by libMesh::DiffContext::DiffContext(), libMesh::EulerSolver::element_residual(), libMesh::Euler2Solver::element_residual(), libMesh::DiffContext::get_elem_jacobian(), libMesh::FEMSystem::numerical_jacobian(), pre_fe_reinit(), libMesh::EulerSolver::side_residual(), and libMesh::Euler2Solver::side_residual().

std::vector<Number> libMesh::DiffContext::elem_qoi [inherited]

Element quantity of interest contributions

Definition at line 330 of file diff_context.h.

Referenced by libMesh::DiffContext::DiffContext(), and libMesh::DiffContext::get_qois().

std::vector<DenseVector<Number> > libMesh::DiffContext::elem_qoi_derivative [inherited]

Element quantity of interest derivative contributions

Definition at line 335 of file diff_context.h.

Referenced by libMesh::DiffContext::DiffContext(), libMesh::DiffContext::get_qoi_derivatives(), and pre_fe_reinit().

std::vector<std::vector<DenseSubVector<Number> *> > libMesh::DiffContext::elem_qoi_subderivatives [inherited]

Definition at line 336 of file diff_context.h.

Referenced by libMesh::DiffContext::DiffContext(), libMesh::DiffContext::get_qoi_derivatives(), pre_fe_reinit(), and libMesh::DiffContext::~DiffContext().

DenseVector<Number> libMesh::DiffContext::elem_residual [inherited]

Element residual vector

Definition at line 319 of file diff_context.h.

Referenced by libMesh::DiffContext::DiffContext(), libMesh::EulerSolver::element_residual(), libMesh::Euler2Solver::element_residual(), libMesh::DiffContext::get_elem_residual(), libMesh::FEMSystem::numerical_jacobian(), pre_fe_reinit(), libMesh::EulerSolver::side_residual(), and libMesh::Euler2Solver::side_residual().

DenseVector<Number> libMesh::DiffContext::elem_solution [inherited]

Element by element components of nonlinear_solution as adjusted by a time_solver

Definition at line 291 of file diff_context.h.

Referenced by libMesh::DiffContext::DiffContext(), libMesh::SteadySolver::element_residual(), libMesh::EulerSolver::element_residual(), libMesh::Euler2Solver::element_residual(), libMesh::DiffContext::get_elem_solution(), libMesh::FEMSystem::numerical_jacobian(), pre_fe_reinit(), libMesh::SteadySolver::side_residual(), libMesh::EulerSolver::side_residual(), and libMesh::Euler2Solver::side_residual().

Real libMesh::DiffContext::elem_solution_derivative [inherited]

The derivative of elem_solution with respect to the nonlinear solution, for use by systems constructing jacobians with elem_fixed_solution based methods

Definition at line 307 of file diff_context.h.

Referenced by libMesh::EulerSolver::element_residual(), libMesh::Euler2Solver::element_residual(), libMesh::DiffContext::get_elem_solution_derivative(), libMesh::EulerSolver::side_residual(), and libMesh::Euler2Solver::side_residual().

std::vector<std::vector<DenseSubMatrix<Number> *> > libMesh::DiffContext::elem_subjacobians [inherited]

Definition at line 342 of file diff_context.h.

Referenced by libMesh::DiffContext::DiffContext(), libMesh::DiffContext::get_elem_jacobian(), pre_fe_reinit(), and libMesh::DiffContext::~DiffContext().

std::vector<DenseSubVector<Number> *> libMesh::DiffContext::elem_subresiduals [inherited]

Element residual subvectors and Jacobian submatrices

Definition at line 341 of file diff_context.h.

Referenced by libMesh::DiffContext::DiffContext(), libMesh::DiffContext::get_elem_residual(), pre_fe_reinit(), and libMesh::DiffContext::~DiffContext().

std::vector<DenseSubVector<Number> *> libMesh::DiffContext::elem_subsolutions [inherited]

Definition at line 292 of file diff_context.h.

Referenced by _do_elem_position_set(), libMesh::DiffContext::DiffContext(), elem_position_get(), libMesh::DiffContext::get_elem_solution(), interior_curl(), interior_div(), interior_gradient(), interior_hessian(), interior_value(), libMesh::FEMSystem::mesh_position_get(), point_gradient(), point_hessian(), point_value(), pre_fe_reinit(), side_gradient(), side_hessian(), side_value(), and libMesh::DiffContext::~DiffContext().

std::map<FEType, FEBase *> libMesh::FEMContext::element_fe

Finite element objects for each variable's interior, sides and edges.

Definition at line 614 of file fem_context.h.

Referenced by elem_fe_reinit(), FEMContext(), and ~FEMContext().

std::vector<FEBase *> libMesh::FEMContext::element_fe_var

Pointers to the same finite element objects, but indexed by variable number

Definition at line 622 of file fem_context.h.

Referenced by _do_elem_position_set(), elem_position_get(), FEMContext(), and libMesh::FEMSystem::init_context().

QBase* libMesh::FEMContext::element_qrule

Quadrature rule for element interior. The FEM context will try to find a quadrature rule that correctly integrates all variables

Definition at line 631 of file fem_context.h.

Referenced by FEMContext(), get_element_qrule(), and ~FEMContext().

Real libMesh::DiffContext::fixed_solution_derivative [inherited]

The derivative of elem_fixed_solution with respect to the nonlinear solution, for use by systems constructing jacobians with elem_fixed_solution based methods

Definition at line 314 of file diff_context.h.

Referenced by libMesh::SteadySolver::element_residual(), libMesh::EulerSolver::element_residual(), libMesh::Euler2Solver::element_residual(), libMesh::DiffContext::get_fixed_solution_derivative(), libMesh::SteadySolver::side_residual(), libMesh::EulerSolver::side_residual(), and libMesh::Euler2Solver::side_residual().

std::map<const NumericVector<Number>*, std::pair<DenseVector<Number>, std::vector<DenseSubVector<Number>*> > > libMesh::DiffContext::localized_vectors [protected, inherited]

Contains pointers to vectors the user has asked to be localized, keyed with pairs of element localized versions of that vector and per variable views

Definition at line 427 of file diff_context.h.

Referenced by libMesh::DiffContext::add_localized_vector(), libMesh::DiffContext::get_localized_subvector(), libMesh::DiffContext::get_localized_vector(), pre_fe_reinit(), and libMesh::DiffContext::~DiffContext().

unsigned char libMesh::FEMContext::side

Current side for side_* to examine

Definition at line 678 of file fem_context.h.

Referenced by get_side(), has_side_boundary_id(), side_boundary_ids(), and side_fe_reinit().

std::map<FEType, FEBase *> libMesh::FEMContext::side_fe

Definition at line 615 of file fem_context.h.

Referenced by FEMContext(), side_fe_reinit(), and ~FEMContext().

std::vector<FEBase *> libMesh::FEMContext::side_fe_var

Definition at line 623 of file fem_context.h.

Referenced by FEMContext().

QBase* libMesh::FEMContext::side_qrule

Quadrature rules for element sides The FEM context will try to find a quadrature rule that correctly integrates all variables

Definition at line 638 of file fem_context.h.

Referenced by FEMContext(), get_side_qrule(), and ~FEMContext().

const Real libMesh::DiffContext::system_time [inherited]

This is the time stored in the System class at the time this context was created, i.e. the time at the beginning of the current timestep. This value gets set in the constructor and unlike DiffContext::time, is not tweaked mid-timestep by transient solvers: it remains equal to the value it was assigned at construction.

Definition at line 285 of file diff_context.h.

Referenced by _update_time_from_system(), and libMesh::DiffContext::get_system_time().

Real libMesh::DiffContext::time [inherited]

For time-dependent problems, this is the time t for which the current nonlinear_solution is defined. FIXME - this needs to be tweaked mid-timestep by all transient solvers!

Definition at line 276 of file diff_context.h.

Referenced by _update_time_from_system(), libMesh::DiffContext::get_time(), and libMesh::DiffContext::set_time().

---

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

• fem_context.h
• fem_context.C