libMesh::FEL2Lagrange< Dim > Class Template Reference

#include <fe.h>

Inheritance diagram for libMesh::FEL2Lagrange< Dim >:

Public Types
typedef FEGenericBase < typename FEOutputType< T > ::type >::OutputShape	OutputShape
typedef TensorTools::IncrementRank < OutputShape >::type	OutputGradient
typedef TensorTools::IncrementRank < OutputGradient >::type	OutputTensor
typedef TensorTools::DecrementRank < OutputShape >::type	OutputDivergence
typedef TensorTools::MakeNumber < OutputShape >::type	OutputNumber
typedef TensorTools::IncrementRank < OutputNumber >::type	OutputNumberGradient
typedef TensorTools::IncrementRank < OutputNumberGradient >::type	OutputNumberTensor
typedef TensorTools::DecrementRank < OutputNumber >::type	OutputNumberDivergence
Public Member Functions
	FEL2Lagrange (const FEType &fet)
virtual unsigned int	n_shape_functions () const
virtual FEContinuity	get_continuity () const
virtual bool	is_hierarchic () const
virtual void	reinit (const Elem elem, const std::vector< Point > const pts=NULL, const std::vector< Real > *const weights=NULL)
virtual void	reinit (const Elem elem, const unsigned int side, const Real tolerance=TOLERANCE, const std::vector< Point > const pts=NULL, const std::vector< Real > *const weights=NULL)
virtual void	edge_reinit (const Elem elem, const unsigned int edge, const Real tolerance=TOLERANCE, const std::vector< Point > const pts=NULL, const std::vector< Real > *const weights=NULL)
virtual void	side_map (const Elem elem, const Elem side, const unsigned int s, const std::vector< Point > &reference_side_points, std::vector< Point > &reference_points)
virtual void	attach_quadrature_rule (QBase *q)
virtual unsigned int	n_quadrature_points () const
virtual bool	shapes_need_reinit () const
const std::vector< std::vector < OutputShape > > &	get_phi () const
const std::vector< std::vector < OutputGradient > > &	get_dphi () const
const std::vector< std::vector < OutputShape > > &	get_curl_phi () const
const std::vector< std::vector < OutputDivergence > > &	get_div_phi () const
const std::vector< std::vector < OutputShape > > &	get_dphidx () const
const std::vector< std::vector < OutputShape > > &	get_dphidy () const
const std::vector< std::vector < OutputShape > > &	get_dphidz () const
const std::vector< std::vector < OutputShape > > &	get_dphidxi () const
const std::vector< std::vector < OutputShape > > &	get_dphideta () const
const std::vector< std::vector < OutputShape > > &	get_dphidzeta () const
const std::vector< std::vector < OutputTensor > > &	get_d2phi () const
const std::vector< std::vector < OutputShape > > &	get_d2phidx2 () const
const std::vector< std::vector < OutputShape > > &	get_d2phidxdy () const
const std::vector< std::vector < OutputShape > > &	get_d2phidxdz () const
const std::vector< std::vector < OutputShape > > &	get_d2phidy2 () const
const std::vector< std::vector < OutputShape > > &	get_d2phidydz () const
const std::vector< std::vector < OutputShape > > &	get_d2phidz2 () const
const std::vector< std::vector < OutputShape > > &	get_d2phidxi2 () const
const std::vector< std::vector < OutputShape > > &	get_d2phidxideta () const
const std::vector< std::vector < OutputShape > > &	get_d2phidxidzeta () const
const std::vector< std::vector < OutputShape > > &	get_d2phideta2 () const
const std::vector< std::vector < OutputShape > > &	get_d2phidetadzeta () const
const std::vector< std::vector < OutputShape > > &	get_d2phidzeta2 () const
const std::vector < OutputGradient > &	get_dphase () const
const std::vector< Real > &	get_Sobolev_weight () const
const std::vector< RealGradient > &	get_Sobolev_dweight () const
void	print_phi (std::ostream &os) const
void	print_dphi (std::ostream &os) const
void	print_d2phi (std::ostream &os) const
const std::vector< Point > &	get_xyz () const
const std::vector< Real > &	get_JxW () const
const std::vector< RealGradient > &	get_dxyzdxi () const
const std::vector< RealGradient > &	get_dxyzdeta () const
const std::vector< RealGradient > &	get_dxyzdzeta () const
const std::vector< RealGradient > &	get_d2xyzdxi2 () const
const std::vector< RealGradient > &	get_d2xyzdeta2 () const
const std::vector< RealGradient > &	get_d2xyzdzeta2 () const
const std::vector< RealGradient > &	get_d2xyzdxideta () const
const std::vector< RealGradient > &	get_d2xyzdxidzeta () const
const std::vector< RealGradient > &	get_d2xyzdetadzeta () const
const std::vector< Real > &	get_dxidx () const
const std::vector< Real > &	get_dxidy () const
const std::vector< Real > &	get_dxidz () const
const std::vector< Real > &	get_detadx () const
const std::vector< Real > &	get_detady () const
const std::vector< Real > &	get_detadz () const
const std::vector< Real > &	get_dzetadx () const
const std::vector< Real > &	get_dzetady () const
const std::vector< Real > &	get_dzetadz () const
const std::vector< std::vector < Point > > &	get_tangents () const
const std::vector< Point > &	get_normals () const
const std::vector< Real > &	get_curvatures () const
ElemType	get_type () const
unsigned int	get_p_level () const
FEType	get_fe_type () const
Order	get_order () const
FEFamily	get_family () const
const FEMap &	get_fe_map () const
void	print_JxW (std::ostream &os) const
void	print_xyz (std::ostream &os) const
void	print_info (std::ostream &os) const
Static Public Member Functions
static OutputShape	shape (const ElemType t, const Order o, const unsigned int i, const Point &p)
static OutputShape	shape (const Elem *elem, const Order o, const unsigned int i, const Point &p)
static OutputShape	shape_deriv (const ElemType t, const Order o, const unsigned int i, const unsigned int j, const Point &p)
static OutputShape	shape_deriv (const Elem *elem, const Order o, const unsigned int i, const unsigned int j, const Point &p)
static OutputShape	shape_second_deriv (const ElemType t, const Order o, const unsigned int i, const unsigned int j, const Point &p)
static OutputShape	shape_second_deriv (const Elem *elem, const Order o, const unsigned int i, const unsigned int j, const Point &p)
static void	nodal_soln (const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)
static unsigned int	n_shape_functions (const ElemType t, const Order o)
static unsigned int	n_dofs (const ElemType t, const Order o)
static unsigned int	n_dofs_at_node (const ElemType t, const Order o, const unsigned int n)
static unsigned int	n_dofs_per_elem (const ElemType t, const Order o)
static void	dofs_on_side (const Elem *const elem, const Order o, unsigned int s, std::vector< unsigned int > &di)
static void	dofs_on_edge (const Elem *const elem, const Order o, unsigned int e, std::vector< unsigned int > &di)
static Point	inverse_map (const Elem *elem, const Point &p, const Real tolerance=TOLERANCE, const bool secure=true)
static void	inverse_map (const Elem *elem, const std::vector< Point > &physical_points, std::vector< Point > &reference_points, const Real tolerance=TOLERANCE, const bool secure=true)
static void	compute_constraints (DofConstraints &constraints, DofMap &dof_map, const unsigned int variable_number, const Elem *elem)
static Point	map (const Elem *elem, const Point &reference_point)
static Point	map_xi (const Elem *elem, const Point &reference_point)
static Point	map_eta (const Elem *elem, const Point &reference_point)
static Point	map_zeta (const Elem *elem, const Point &reference_point)
static AutoPtr< FEGenericBase >	build (const unsigned int dim, const FEType &type)
static AutoPtr< FEGenericBase >	build_InfFE (const unsigned int dim, const FEType &type)
static void	compute_proj_constraints (DofConstraints &constraints, DofMap &dof_map, const unsigned int variable_number, const Elem *elem)
static void	coarsened_dof_values (const NumericVector< Number > &global_vector, const DofMap &dof_map, const Elem *coarse_elem, DenseVector< Number > &coarse_dofs, const unsigned int var, const bool use_old_dof_indices=false)
static void	compute_periodic_constraints (DofConstraints &constraints, DofMap &dof_map, const PeriodicBoundaries &boundaries, const MeshBase &mesh, const PointLocatorBase point_locator, const unsigned int variable_number, const Elem elem)
static bool	on_reference_element (const Point &p, const ElemType t, const Real eps=TOLERANCE)
static void	get_refspace_nodes (const ElemType t, std::vector< Point > &nodes)
static void	compute_node_constraints (NodeConstraints &constraints, const Elem *elem)
static void	compute_periodic_node_constraints (NodeConstraints &constraints, const PeriodicBoundaries &boundaries, const MeshBase &mesh, const PointLocatorBase point_locator, const Elem elem)
static void	print_info (std::ostream &out=libMesh::out)
static std::string	get_info ()
static unsigned int	n_objects ()
static void	enable_print_counter_info ()
static void	disable_print_counter_info ()
Protected Types
typedef std::map< std::string, std::pair< unsigned int, unsigned int > >	Counts
Protected Member Functions
virtual void	init_shape_functions (const std::vector< Point > &qp, const Elem *e)
virtual void	init_base_shape_functions (const std::vector< Point > &qp, const Elem *e)
virtual void	compute_shape_functions (const Elem *elem, const std::vector< Point > &qp)
void	increment_constructor_count (const std::string &name)
void	increment_destructor_count (const std::string &name)
Protected Attributes
std::vector< Point >	cached_nodes
ElemType	last_side
unsigned int	last_edge
AutoPtr< FETransformationBase < FEOutputType< T >::type > >	_fe_trans
std::vector< std::vector < OutputShape > >	phi
std::vector< std::vector < OutputGradient > >	dphi
std::vector< std::vector < OutputShape > >	curl_phi
std::vector< std::vector < OutputDivergence > >	div_phi
std::vector< std::vector < OutputShape > >	dphidxi
std::vector< std::vector < OutputShape > >	dphideta
std::vector< std::vector < OutputShape > >	dphidzeta
std::vector< std::vector < OutputShape > >	dphidx
std::vector< std::vector < OutputShape > >	dphidy
std::vector< std::vector < OutputShape > >	dphidz
std::vector< std::vector < OutputTensor > >	d2phi
std::vector< std::vector < OutputShape > >	d2phidxi2
std::vector< std::vector < OutputShape > >	d2phidxideta
std::vector< std::vector < OutputShape > >	d2phidxidzeta
std::vector< std::vector < OutputShape > >	d2phideta2
std::vector< std::vector < OutputShape > >	d2phidetadzeta
std::vector< std::vector < OutputShape > >	d2phidzeta2
std::vector< std::vector < OutputShape > >	d2phidx2
std::vector< std::vector < OutputShape > >	d2phidxdy
std::vector< std::vector < OutputShape > >	d2phidxdz
std::vector< std::vector < OutputShape > >	d2phidy2
std::vector< std::vector < OutputShape > >	d2phidydz
std::vector< std::vector < OutputShape > >	d2phidz2
std::vector< OutputGradient >	dphase
std::vector< RealGradient >	dweight
std::vector< Real >	weight
AutoPtr< FEMap >	_fe_map
const unsigned int	dim
bool	calculations_started
bool	calculate_phi
bool	calculate_dphi
bool	calculate_d2phi
bool	calculate_curl_phi
bool	calculate_div_phi
bool	calculate_dphiref
const FEType	fe_type
ElemType	elem_type
unsigned int	_p_level
QBase *	qrule
bool	shapes_on_quadrature
Static Protected Attributes
static Counts	_counts
static Threads::atomic < unsigned int >	_n_objects
static Threads::spin_mutex	_mutex
static bool	_enable_print_counter = true
Friends
class	InfFE
std::ostream &	operator<< (std::ostream &os, const FEAbstract &fe)

Detailed Description

template<unsigned int Dim>
class libMesh::FEL2Lagrange< Dim >

Discontinuous Lagrange finite elements.

Definition at line 625 of file fe.h.

Member Typedef Documentation

typedef std::map<std::string, std::pair<unsigned int, unsigned int> > libMesh::ReferenceCounter::Counts [protected, inherited]

Data structure to log the information. The log is identified by the class name.

Definition at line 113 of file reference_counter.h.

typedef TensorTools::DecrementRank<OutputShape>::type libMesh::FEGenericBase< FEOutputType< T >::type >::OutputDivergence [inherited]

Definition at line 151 of file fe_base.h.

typedef TensorTools::IncrementRank<OutputShape>::type libMesh::FEGenericBase< FEOutputType< T >::type >::OutputGradient [inherited]

Definition at line 149 of file fe_base.h.

typedef TensorTools::MakeNumber<OutputShape>::type libMesh::FEGenericBase< FEOutputType< T >::type >::OutputNumber [inherited]

Definition at line 152 of file fe_base.h.

typedef TensorTools::DecrementRank<OutputNumber>::type libMesh::FEGenericBase< FEOutputType< T >::type >::OutputNumberDivergence [inherited]

Definition at line 155 of file fe_base.h.

typedef TensorTools::IncrementRank<OutputNumber>::type libMesh::FEGenericBase< FEOutputType< T >::type >::OutputNumberGradient [inherited]

Definition at line 153 of file fe_base.h.

typedef TensorTools::IncrementRank<OutputNumberGradient>::type libMesh::FEGenericBase< FEOutputType< T >::type >::OutputNumberTensor [inherited]

Definition at line 154 of file fe_base.h.

typedef FEGenericBase<typename FEOutputType<T>::type>::OutputShape libMesh::FE< Dim, T >::OutputShape [inherited]

Convenient typedefs for gradients of output, hessians of output, and potentially-complex-valued versions of same.

Reimplemented from libMesh::FEGenericBase< FEOutputType< T >::type >.

Definition at line 103 of file fe.h.

typedef TensorTools::IncrementRank<OutputGradient>::type libMesh::FEGenericBase< FEOutputType< T >::type >::OutputTensor [inherited]

Definition at line 150 of file fe_base.h.

Constructor & Destructor Documentation

template<unsigned int Dim>

libMesh::FEL2Lagrange< Dim >::FEL2Lagrange ( const FEType & fet ) [inline, explicit]

Constructor. Creates a discontinuous Lagrange finite element to be used in dimension Dim.

Definition at line 983 of file fe.h.

00983                                                   :
00984   FE<Dim,L2_LAGRANGE> (fet)
00985 {
00986 }

Member Function Documentation

virtual void libMesh::FE< Dim, T >::attach_quadrature_rule ( QBase * q ) [virtual, inherited]

Provides the class with the quadrature rule, which provides the locations (on a reference element) where the shape functions are to be calculated.

Implements libMesh::FEAbstract.

static AutoPtr<FEGenericBase> libMesh::FEGenericBase< FEOutputType< T >::type >::build	(	const unsigned int	dim,
		const FEType &	type
	)			`[static, inherited]`

Builds a specific finite element type. A AutoPtr<FEGenericBase> is returned to prevent a memory leak. This way the user need not remember to delete the object.

The build call will fail if the OutputType of this class is not compatible with the output required for the requested type

Reimplemented from libMesh::FEAbstract.

static AutoPtr<FEGenericBase> libMesh::FEGenericBase< FEOutputType< T >::type >::build_InfFE	(	const unsigned int	dim,
		const FEType &	type
	)			`[static, inherited]`

Builds a specific infinite element type. A AutoPtr<FEGenericBase> is returned to prevent a memory leak. This way the user need not remember to delete the object.

The build call will fail if the OutputShape of this class is not compatible with the output required for the requested type

static void libMesh::FEGenericBase< FEOutputType< T >::type >::coarsened_dof_values	(	const NumericVector< Number > &	global_vector,
		const DofMap &	dof_map,
		const Elem *	coarse_elem,
		DenseVector< Number > &	coarse_dofs,
		const unsigned int	var,
		const bool	use_old_dof_indices = `false`
	)			`[static, inherited]`

Creates a local projection on coarse_elem, based on the DoF values in global_vector for it's children.

static void libMesh::FE< Dim, T >::compute_constraints	(	DofConstraints &	constraints,
		DofMap &	dof_map,
		const unsigned int	variable_number,
		const Elem *	elem
	)			`[static, inherited]`

Computes the constraint matrix contributions (for non-conforming adapted meshes) corresponding to variable number var_number, using element-specific optimizations if possible.

void libMesh::FEAbstract::compute_node_constraints	(	NodeConstraints &	constraints,
		const Elem *	elem
	)			`[static, inherited]`

Computes the nodal constraint contributions (for non-conforming adapted meshes), using Lagrange geometry

Definition at line 878 of file fe_abstract.C.

References std::abs(), libMesh::Elem::build_side(), libMesh::Elem::default_order(), libMesh::Elem::dim(), libMesh::FEAbstract::fe_type, libMesh::FEInterface::inverse_map(), libMeshEnums::LAGRANGE, libMesh::Elem::level(), libMesh::FEInterface::n_dofs(), libMesh::Elem::n_sides(), libMesh::Elem::neighbor(), libMesh::Elem::parent(), libMesh::Real, libMesh::remote_elem, libMesh::FEInterface::shape(), libMesh::Threads::spin_mtx, and libMesh::Elem::subactive().

00881 00882 00883 00884 00885 00886 00887 00888 00889 00890 00891 00892 00893 00894 00895 00896 00897 00898 00899 00900 00901 00902 00903 00904 00905 00906 00907 00908 00909 00910 00911 00912 00913 00914 00915 00916 00917 00918 00919 00920 00921 00922 00923 00924 00925 00926 00927 00928 00929 00930 00931 00932 00933 00934 00935 00936 00937 00938 00939 00940 00941 00942 00943 00944 00945 00946 00947 00948 00949 00950 00951 00952 00953 00954 00955 00956 00957 00958 00959 00960 00961 00962 00963 00964 00965 00966 00967 00968 00969 00970 00971 00972 00973 00974 00975 00976 00977 00978 00979 00980 00981 00982 00983 00984 00985 00986 00987 00988 00989 00990 00991 00992 00993 00994 00995 00996 00997 00998 00999 01000 01001 01002 01003 01004 01005 01006 01007 01008 01009         } 01010 }

class="fragment">00880 { libmesh_assert(elem); const unsigned int Dim = elem->dim(); // Only constrain elements in 2,3D. if (Dim == 1) return; // Only constrain active and ancestor elements if (elem->subactive()) return; // We currently always use LAGRANGE mappings for geometry const FEType fe_type(elem->default_order(), LAGRANGE); std::vector<const Node*> my_nodes, parent_nodes; // Look at the element faces. Check to see if we need to // build constraints. for (unsigned int s=0; s<elem->n_sides(); s++) if (elem->neighbor(s) != NULL && elem->neighbor(s) != remote_elem) if (elem->neighbor(s)->level() < elem->level()) // constrain dofs shared between { // this element and ones coarser // than this element. // Get pointers to the elements of interest and its parent. const Elem* parent = elem->parent(); // This can't happen... Only level-0 elements have NULL // parents, and no level-0 elements can be at a higher // level than their neighbors! libmesh_assert(parent); const AutoPtr<Elem> my_side (elem->build_side(s)); const AutoPtr<Elem> parent_side (parent->build_side(s)); const unsigned int n_side_nodes = my_side->n_nodes(); my_nodes.clear(); my_nodes.reserve (n_side_nodes); parent_nodes.clear(); parent_nodes.reserve (n_side_nodes); for (unsigned int n=0; n != n_side_nodes; ++n) my_nodes.push_back(my_side->get_node(n)); for (unsigned int n=0; n != n_side_nodes; ++n) parent_nodes.push_back(parent_side->get_node(n)); for (unsigned int my_side_n=0; my_side_n < n_side_nodes; my_side_n++) { libmesh_assert_less (my_side_n, FEInterface::n_dofs(Dim-1, fe_type, my_side->type())); const Node* my_node = my_nodes[my_side_n]; // The support point of the DOF const Point& support_point = *my_node; // Figure out where my node lies on their reference element. const Point mapped_point = FEInterface::inverse_map(Dim-1, fe_type, parent_side.get(), support_point); // Compute the parent's side shape function values. for (unsigned int their_side_n=0; their_side_n < n_side_nodes; their_side_n++) { libmesh_assert_less (their_side_n, FEInterface::n_dofs(Dim-1, fe_type, parent_side->type())); const Node* their_node = parent_nodes[their_side_n]; libmesh_assert(their_node); const Real their_value = FEInterface::shape(Dim-1, fe_type, parent_side->type(), their_side_n, mapped_point); const Real their_mag = std::abs(their_value); #ifdef DEBUG // Protect for the case u_i ~= u_j, // in which case i better equal j. if (their_mag > 0.999) { libmesh_assert_equal_to (my_node, their_node); libmesh_assert_less (std::abs(their_value - 1.), 0.001); } else #endif // To make nodal constraints useful for constructing // sparsity patterns faster, we need to get EVERY // POSSIBLE constraint coupling identified, even if // there is no coupling in the isoparametric // Lagrange case. if (their_mag < 1.e-5) { // since we may be running this method concurretly // on multiple threads we need to acquire a lock // before modifying the shared constraint_row object. Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx); // A reference to the constraint row. NodeConstraintRow& constraint_row = constraints[my_node].first; constraint_row.insert(std::make_pair (their_node, 0.)); } // To get nodal coordinate constraints right, only // add non-zero and non-identity values for Lagrange // basis functions. else // (1.e-5 <= their_mag <= .999) { // since we may be running this method concurretly // on multiple threads we need to acquire a lock // before modifying the shared constraint_row object. Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx); // A reference to the constraint row. NodeConstraintRow& constraint_row = constraints[my_node].first; constraint_row.insert(std::make_pair (their_node, their_value)); } } }

static void libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints	(	DofConstraints &	constraints,
		DofMap &	dof_map,
		const PeriodicBoundaries &	boundaries,
		const MeshBase &	mesh,
		const PointLocatorBase *	point_locator,
		const unsigned int	variable_number,
		const Elem *	elem
	)			`[static, inherited]`

Computes the constraint matrix contributions (for meshes with periodic boundary conditions) corresponding to variable number var_number, using generic projections.

void libMesh::FEAbstract::compute_periodic_node_constraints	(	NodeConstraints &	constraints,
		const PeriodicBoundaries &	boundaries,
		const MeshBase &	mesh,
		const PointLocatorBase *	point_locator,
		const Elem *	elem
	)			`[static, inherited]`

Computes the node position constraint equation contributions (for meshes with periodic boundary conditions)

Definition at line 1021 of file fe_abstract.C.

References libMesh::Elem::active(), libMesh::PeriodicBoundaries::boundary(), libMesh::MeshBase::boundary_info, libMesh::Elem::build_side(), libMesh::Elem::default_order(), libMesh::Elem::dim(), libMesh::FEAbstract::fe_type, libMesh::PeriodicBoundaryBase::get_corresponding_pos(), libMesh::invalid_uint, libMesh::FEInterface::inverse_map(), libMeshEnums::LAGRANGE, libMesh::Elem::level(), libMesh::FEInterface::n_dofs(), libMesh::Elem::n_sides(), libMesh::PeriodicBoundaries::neighbor(), libMesh::Elem::neighbor(), libMesh::PeriodicBoundaryBase::pairedboundary, libMesh::Real, libMesh::FEInterface::shape(), and libMesh::Threads::spin_mtx.

01026 {
01027   // Only bother if we truly have periodic boundaries
01028   if (boundaries.empty())
01029     return;
01030 
01031   libmesh_assert(elem);
01032 
01033   // Only constrain active elements with this method
01034   if (!elem->active())
01035     return;
01036 
01037   const unsigned int Dim = elem->dim();
01038 
01039   // We currently always use LAGRANGE mappings for geometry
01040   const FEType fe_type(elem->default_order(), LAGRANGE);
01041 
01042   std::vector<const Node*> my_nodes, neigh_nodes;
01043 
01044   // Look at the element faces.  Check to see if we need to
01045   // build constraints.
01046   for (unsigned int s=0; s<elem->n_sides(); s++)
01047     {
01048       if (elem->neighbor(s))
01049         continue;
01050 
01051       const std::vector<boundary_id_type>& bc_ids = mesh.boundary_info->boundary_ids (elem, s);
01052       for (std::vector<boundary_id_type>::const_iterator id_it=bc_ids.begin(); id_it!=bc_ids.end(); ++id_it)
01053         {
01054           const boundary_id_type boundary_id = *id_it;
01055           const PeriodicBoundaryBase *periodic = boundaries.boundary(boundary_id);
01056           if (periodic)
01057             {
01058               libmesh_assert(point_locator);
01059 
01060               // Get pointers to the element's neighbor.
01061               const Elem* neigh = boundaries.neighbor(boundary_id, *point_locator, elem, s);
01062 
01063               // h refinement constraints:
01064               // constrain dofs shared between
01065               // this element and ones as coarse
01066               // as or coarser than this element.
01067               if (neigh->level() <= elem->level())
01068                 {
01069                   unsigned int s_neigh =
01070                     mesh.boundary_info->side_with_boundary_id (neigh, periodic->pairedboundary);
01071                   libmesh_assert_not_equal_to (s_neigh, libMesh::invalid_uint);
01072 
01073 #ifdef LIBMESH_ENABLE_AMR
01074                   libmesh_assert(neigh->active());
01075 #endif // #ifdef LIBMESH_ENABLE_AMR
01076 
01077                   const AutoPtr<Elem> my_side    (elem->build_side(s));
01078                   const AutoPtr<Elem> neigh_side (neigh->build_side(s_neigh));
01079 
01080                   const unsigned int n_side_nodes = my_side->n_nodes();
01081 
01082                   my_nodes.clear();
01083                   my_nodes.reserve (n_side_nodes);
01084                   neigh_nodes.clear();
01085                   neigh_nodes.reserve (n_side_nodes);
01086 
01087                   for (unsigned int n=0; n != n_side_nodes; ++n)
01088                     my_nodes.push_back(my_side->get_node(n));
01089 
01090                   for (unsigned int n=0; n != n_side_nodes; ++n)
01091                     neigh_nodes.push_back(neigh_side->get_node(n));
01092 
01093                   // Make sure we're not adding recursive constraints
01094                   // due to the redundancy in the way we add periodic
01095                   // boundary constraints, or adding constraints to
01096                   // nodes that already have AMR constraints
01097                   std::vector<bool> skip_constraint(n_side_nodes, false);
01098 
01099                   for (unsigned int my_side_n=0;
01100                        my_side_n < n_side_nodes;
01101                        my_side_n++)
01102                     {
01103                       libmesh_assert_less (my_side_n, FEInterface::n_dofs(Dim-1, fe_type, my_side->type()));
01104 
01105                       const Node* my_node = my_nodes[my_side_n];
01106 
01107                       // Figure out where my node lies on their reference element.
01108                       const Point neigh_point = periodic->get_corresponding_pos(*my_node);
01109 
01110                       const Point mapped_point = FEInterface::inverse_map(Dim-1, fe_type,
01111                                                                           neigh_side.get(),
01112                                                                           neigh_point);
01113 
01114                       // If we've already got a constraint on this
01115                       // node, then the periodic constraint is
01116                       // redundant
01117                       {
01118                         Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
01119 
01120                         if (constraints.count(my_node))
01121                           {
01122                             skip_constraint[my_side_n] = true;
01123                             continue;
01124                           }
01125                       }
01126 
01127                       // Compute the neighbors's side shape function values.
01128                       for (unsigned int their_side_n=0;
01129                            their_side_n < n_side_nodes;
01130                            their_side_n++)
01131                         {
01132                           libmesh_assert_less (their_side_n, FEInterface::n_dofs(Dim-1, fe_type, neigh_side->type()));
01133 
01134                           const Node* their_node = neigh_nodes[their_side_n];
01135 
01136                           // If there's a constraint on an opposing node,
01137                           // we need to see if it's constrained by
01138                           // *our side* making any periodic constraint
01139                           // on us recursive
01140                           {
01141                             Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
01142 
01143                             if (!constraints.count(their_node))
01144                               continue;
01145 
01146                             const NodeConstraintRow& their_constraint_row =
01147                               constraints[their_node].first;
01148 
01149                             for (unsigned int orig_side_n=0;
01150                                  orig_side_n < n_side_nodes;
01151                                  orig_side_n++)
01152                               {
01153                                 libmesh_assert_less (orig_side_n, FEInterface::n_dofs(Dim-1, fe_type, my_side->type()));
01154 
01155                                 const Node* orig_node = my_nodes[orig_side_n];
01156 
01157                                 if (their_constraint_row.count(orig_node))
01158                                   skip_constraint[orig_side_n] = true;
01159                               }
01160                           }
01161                         }
01162                     }
01163                   for (unsigned int my_side_n=0;
01164                        my_side_n < n_side_nodes;
01165                        my_side_n++)
01166                     {
01167                       libmesh_assert_less (my_side_n, FEInterface::n_dofs(Dim-1, fe_type, my_side->type()));
01168 
01169                       if (skip_constraint[my_side_n])
01170                         continue;
01171 
01172                       const Node* my_node = my_nodes[my_side_n];
01173 
01174                       // Figure out where my node lies on their reference element.
01175                       const Point neigh_point = periodic->get_corresponding_pos(*my_node);
01176 
01177                       // Figure out where my node lies on their reference element.
01178                       const Point mapped_point = FEInterface::inverse_map(Dim-1, fe_type,
01179                                                                           neigh_side.get(),
01180                                                                           neigh_point);
01181 
01182                       for (unsigned int their_side_n=0;
01183                            their_side_n < n_side_nodes;
01184                            their_side_n++)
01185                         {
01186                           libmesh_assert_less (their_side_n, FEInterface::n_dofs(Dim-1, fe_type, neigh_side->type()));
01187 
01188                           const Node* their_node = neigh_nodes[their_side_n];
01189                           libmesh_assert(their_node);
01190 
01191                           const Real their_value = FEInterface::shape(Dim-1,
01192                                                                       fe_type,
01193                                                                       neigh_side->type(),
01194                                                                       their_side_n,
01195                                                                       mapped_point);
01196 
01197                           // since we may be running this method concurretly
01198                           // on multiple threads we need to acquire a lock
01199                           // before modifying the shared constraint_row object.
01200                           {
01201                             Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
01202 
01203                             NodeConstraintRow& constraint_row =
01204                               constraints[my_node].first;
01205 
01206                             constraint_row.insert(std::make_pair(their_node,
01207                                                                  their_value));
01208                           }
01209                         }
01210                     }
01211                 }
01212             }
01213         }
01214     }
01215 }

static void libMesh::FEGenericBase< FEOutputType< T >::type >::compute_proj_constraints	(	DofConstraints &	constraints,
		DofMap &	dof_map,
		const unsigned int	variable_number,
		const Elem *	elem
	)			`[static, inherited]`

Computes the constraint matrix contributions (for non-conforming adapted meshes) corresponding to variable number var_number, using generic projections.

Referenced by libMesh::FE< Dim, T >::compute_constraints().

virtual void libMesh::FEGenericBase< FEOutputType< T >::type >::compute_shape_functions	(	const Elem *	elem,
		const std::vector< Point > &	qp
	)			`[protected, virtual, inherited]`

After having updated the jacobian and the transformation from local to global coordinates in FEAbstract::compute_map(), the first derivatives of the shape functions are transformed to global coordinates, giving dphi, dphidx, dphidy, and dphidz. This method should rarely be re-defined in derived classes, but still should be usable for children. Therefore, keep it protected.

Implements libMesh::FEAbstract.

Reimplemented in libMesh::FEXYZ< Dim >.

Referenced by libMesh::FE< Dim, T >::reinit().

void libMesh::ReferenceCounter::disable_print_counter_info ( ) [static, inherited]

Definition at line 106 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

00107 {
00108   _enable_print_counter = false;
00109   return;
00110 }

static void libMesh::FE< Dim, T >::dofs_on_edge	(	const Elem *const	elem,
		const Order	o,
		unsigned int	e,
		std::vector< unsigned int > &	di
	)			`[static, inherited]`

Fills the vector di with the local degree of freedom indices associated with edge e of element elem

On a p-refined element, o should be the base order of the element.

static void libMesh::FE< Dim, T >::dofs_on_side	(	const Elem *const	elem,
		const Order	o,
		unsigned int	s,
		std::vector< unsigned int > &	di
	)			`[static, inherited]`

Fills the vector di with the local degree of freedom indices associated with side s of element elem

On a p-refined element, o should be the base order of the element.

virtual void libMesh::FE< Dim, T >::edge_reinit	(	const Elem *	elem,
		const unsigned int	edge,
		const Real	tolerance = `TOLERANCE`,
		const std::vector< Point > *const	pts = `NULL`,
		const std::vector< Real > *const	weights = `NULL`
	)			`[virtual, inherited]`

Reinitializes all the physical element-dependent data based on the edge. The tolerance paremeter is passed to the involved call to inverse_map(). By default the shape functions and associated data are computed at the quadrature points specified by the quadrature rule qrule, but may be any points specified on the reference side element specified in the optional argument pts.

Implements libMesh::FEAbstract.

void libMesh::ReferenceCounter::enable_print_counter_info ( ) [static, inherited]

Methods to enable/disable the reference counter output from print_info()

Definition at line 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

00101 {
00102   _enable_print_counter = true;
00103   return;
00104 }

virtual FEContinuity libMesh::FE< Dim, T >::get_continuity ( ) const [virtual, inherited]

Returns:: the continuity level of the finite element.

Implements libMesh::FEAbstract.

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_curl_phi ( ) const [inline, inherited]

Returns:: the curl of the shape function at the quadrature points.

Definition at line 238 of file fe_base.h.

00239   { libmesh_assert(!calculations_started || calculate_curl_phi);
00240     calculate_curl_phi = calculate_dphiref = true; return curl_phi; }

const std::vector<Real>& libMesh::FEAbstract::get_curvatures ( ) const [inline, inherited]

Returns:: the curvatures for use in face integration.

Definition at line 380 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

00381   { return this->_fe_map->get_curvatures();}

const std::vector<std::vector<OutputTensor> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phi ( ) const [inline, inherited]

Returns:: the shape function second derivatives at the quadrature points.

Definition at line 304 of file fe_base.h.

00305   { libmesh_assert(!calculations_started || calculate_d2phi);
00306     calculate_d2phi = calculate_dphiref = true; return d2phi; }

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phideta2 ( ) const [inline, inherited]

Returns:: the shape function second derivatives at the quadrature points, in reference coordinates

Definition at line 384 of file fe_base.h.

00385   { libmesh_assert(!calculations_started || calculate_d2phi);
00386     calculate_d2phi = calculate_dphiref = true; return d2phideta2; }

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidetadzeta ( ) const [inline, inherited]

Returns:: the shape function second derivatives at the quadrature points, in reference coordinates

Definition at line 392 of file fe_base.h.

00393   { libmesh_assert(!calculations_started || calculate_d2phi);
00394     calculate_d2phi = calculate_dphiref = true; return d2phidetadzeta; }

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidx2 ( ) const [inline, inherited]

Returns:: the shape function second derivatives at the quadrature points.

Definition at line 312 of file fe_base.h.

00313   { libmesh_assert(!calculations_started || calculate_d2phi);
00314     calculate_d2phi = calculate_dphiref = true; return d2phidx2; }

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxdy ( ) const [inline, inherited]

Returns:: the shape function second derivatives at the quadrature points.

Definition at line 320 of file fe_base.h.

00321   { libmesh_assert(!calculations_started || calculate_d2phi);
00322     calculate_d2phi = calculate_dphiref = true; return d2phidxdy; }

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxdz ( ) const [inline, inherited]

Returns:: the shape function second derivatives at the quadrature points.

Definition at line 328 of file fe_base.h.

00329   { libmesh_assert(!calculations_started || calculate_d2phi);
00330     calculate_d2phi = calculate_dphiref = true; return d2phidxdz; }

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxi2 ( ) const [inline, inherited]

Returns:: the shape function second derivatives at the quadrature points, in reference coordinates

Definition at line 360 of file fe_base.h.

00361   { libmesh_assert(!calculations_started || calculate_d2phi);
00362     calculate_d2phi = calculate_dphiref = true; return d2phidxi2; }

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxideta ( ) const [inline, inherited]

Returns:: the shape function second derivatives at the quadrature points, in reference coordinates

Definition at line 368 of file fe_base.h.

00369   { libmesh_assert(!calculations_started || calculate_d2phi);
00370     calculate_d2phi = calculate_dphiref = true; return d2phidxideta; }

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxidzeta ( ) const [inline, inherited]

Returns:: the shape function second derivatives at the quadrature points, in reference coordinates

Definition at line 376 of file fe_base.h.

00377   { libmesh_assert(!calculations_started || calculate_d2phi);
00378     calculate_d2phi = calculate_dphiref = true; return d2phidxidzeta; }

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidy2 ( ) const [inline, inherited]

Returns:: the shape function second derivatives at the quadrature points.

Definition at line 336 of file fe_base.h.

00337   { libmesh_assert(!calculations_started || calculate_d2phi);
00338     calculate_d2phi =  calculate_dphiref = true; return d2phidy2; }

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidydz ( ) const [inline, inherited]

Returns:: the shape function second derivatives at the quadrature points.

Definition at line 344 of file fe_base.h.

00345   { libmesh_assert(!calculations_started || calculate_d2phi);
00346     calculate_d2phi = calculate_dphiref = true; return d2phidydz; }

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidz2 ( ) const [inline, inherited]

Returns:: the shape function second derivatives at the quadrature points.

Definition at line 352 of file fe_base.h.

00353   { libmesh_assert(!calculations_started || calculate_d2phi);
00354     calculate_d2phi = calculate_dphiref = true; return d2phidz2; }

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidzeta2 ( ) const [inline, inherited]

Returns:: the shape function second derivatives at the quadrature points, in reference coordinates

Definition at line 400 of file fe_base.h.

00401   { libmesh_assert(!calculations_started || calculate_d2phi);
00402     calculate_d2phi = calculate_dphiref = true; return d2phidzeta2; }

const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdeta2 ( ) const [inline, inherited]

Returns:: the second partial derivatives in eta.

Definition at line 267 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

00268   { return this->_fe_map->get_d2xyzdeta2(); }

const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdetadzeta ( ) const [inline, inherited]

Returns:: the second partial derivatives in eta-zeta.

Definition at line 297 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

00298   { return this->_fe_map->get_d2xyzdetadzeta(); }

const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdxi2 ( ) const [inline, inherited]

Returns:: the second partial derivatives in xi.

Definition at line 261 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

00262   { return this->_fe_map->get_d2xyzdxi2(); }

const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdxideta ( ) const [inline, inherited]

Returns:: the second partial derivatives in xi-eta.

Definition at line 283 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

00284   { return this->_fe_map->get_d2xyzdxideta(); }

const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdxidzeta ( ) const [inline, inherited]

Returns:: the second partial derivatives in xi-zeta.

Definition at line 291 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

00292   { return this->_fe_map->get_d2xyzdxidzeta(); }

const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdzeta2 ( ) const [inline, inherited]

Returns:: the second partial derivatives in zeta.

Definition at line 275 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

00276   { return this->_fe_map->get_d2xyzdzeta2(); }

const std::vector<Real>& libMesh::FEAbstract::get_detadx ( ) const [inline, inherited]

Returns:: the deta/dx entry in the transformation matrix from physical to local coordinates.

Definition at line 327 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

00328   { return this->_fe_map->get_detadx(); }

const std::vector<Real>& libMesh::FEAbstract::get_detady ( ) const [inline, inherited]

Returns:: the deta/dy entry in the transformation matrix from physical to local coordinates.

Definition at line 334 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

00335   { return this->_fe_map->get_detady(); }

const std::vector<Real>& libMesh::FEAbstract::get_detadz ( ) const [inline, inherited]

Returns:: the deta/dz entry in the transformation matrix from physical to local coordinates.

Definition at line 341 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

00342   { return this->_fe_map->get_detadz(); }

const std::vector<std::vector<OutputDivergence> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_div_phi ( ) const [inline, inherited]

Returns:: the divergence of the shape function at the quadrature points.

Definition at line 246 of file fe_base.h.

00247   { libmesh_assert(!calculations_started || calculate_div_phi);
00248     calculate_div_phi = calculate_dphiref = true; return div_phi; }

const std::vector<OutputGradient>& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphase ( ) const [inline, inherited]

Returns:: the global first derivative of the phase term which is used in infinite elements, evaluated at the quadrature points.

In case of the general finite element class FE this field is initialized to all zero, so that the variational formulation for an infinite element returns correct element matrices for a mesh using both finite and infinite elements.

Definition at line 418 of file fe_base.h.

00419       { return dphase; }

const std::vector<std::vector<OutputGradient> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphi ( ) const [inline, inherited]

Returns:: the shape function derivatives at the quadrature points.

Definition at line 230 of file fe_base.h.

00231   { libmesh_assert(!calculations_started || calculate_dphi);
00232     calculate_dphi = calculate_dphiref = true; return dphi; }

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphideta ( ) const [inline, inherited]

Returns:: the shape function eta-derivative at the quadrature points.

Definition at line 286 of file fe_base.h.

00287   { libmesh_assert(!calculations_started || calculate_dphiref);
00288     calculate_dphiref = true; return dphideta; }

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidx ( ) const [inline, inherited]

Returns:: the shape function x-derivative at the quadrature points.

Definition at line 254 of file fe_base.h.

00255   { libmesh_assert(!calculations_started || calculate_dphi);
00256     calculate_dphi = calculate_dphiref = true; return dphidx; }

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidxi ( ) const [inline, inherited]

Returns:: the shape function xi-derivative at the quadrature points.

Definition at line 278 of file fe_base.h.

00279   { libmesh_assert(!calculations_started || calculate_dphiref);
00280     calculate_dphiref = true; return dphidxi; }

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidy ( ) const [inline, inherited]

Returns:: the shape function y-derivative at the quadrature points.

Definition at line 262 of file fe_base.h.

00263   { libmesh_assert(!calculations_started || calculate_dphi);
00264     calculate_dphi = calculate_dphiref = true; return dphidy; }

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidz ( ) const [inline, inherited]

Returns:: the shape function z-derivative at the quadrature points.

Definition at line 270 of file fe_base.h.

00271   { libmesh_assert(!calculations_started || calculate_dphi);
00272     calculate_dphi = calculate_dphiref = true; return dphidz; }

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidzeta ( ) const [inline, inherited]

Returns:: the shape function zeta-derivative at the quadrature points.

Definition at line 294 of file fe_base.h.

00295   { libmesh_assert(!calculations_started || calculate_dphiref);
00296     calculate_dphiref = true; return dphidzeta; }

const std::vector<Real>& libMesh::FEAbstract::get_dxidx ( ) const [inline, inherited]

Returns:: the dxi/dx entry in the transformation matrix from physical to local coordinates.

Definition at line 306 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

00307   { return this->_fe_map->get_dxidx(); }

const std::vector<Real>& libMesh::FEAbstract::get_dxidy ( ) const [inline, inherited]

Returns:: the dxi/dy entry in the transformation matrix from physical to local coordinates.

Definition at line 313 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

00314   { return this->_fe_map->get_dxidy(); }

const std::vector<Real>& libMesh::FEAbstract::get_dxidz ( ) const [inline, inherited]

Returns:: the dxi/dz entry in the transformation matrix from physical to local coordinates.

Definition at line 320 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

00321   { return this->_fe_map->get_dxidz(); }

const std::vector<RealGradient>& libMesh::FEAbstract::get_dxyzdeta ( ) const [inline, inherited]

Returns:: the element tangents in eta-direction at the quadrature points.

Definition at line 248 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

00249   { return this->_fe_map->get_dxyzdeta(); }

const std::vector<RealGradient>& libMesh::FEAbstract::get_dxyzdxi ( ) const [inline, inherited]

Returns:: the element tangents in xi-direction at the quadrature points.

Definition at line 241 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

00242   { return this->_fe_map->get_dxyzdxi(); }

const std::vector<RealGradient>& libMesh::FEAbstract::get_dxyzdzeta ( ) const [inline, inherited]

Returns:: the element tangents in zeta-direction at the quadrature points.

Definition at line 255 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

00256   { return _fe_map->get_dxyzdzeta(); }

const std::vector<Real>& libMesh::FEAbstract::get_dzetadx ( ) const [inline, inherited]

Returns:: the dzeta/dx entry in the transformation matrix from physical to local coordinates.

Definition at line 348 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

00349   { return this->_fe_map->get_dzetadx(); }

const std::vector<Real>& libMesh::FEAbstract::get_dzetady ( ) const [inline, inherited]

Returns:: the dzeta/dy entry in the transformation matrix from physical to local coordinates.

Definition at line 355 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

00356   { return this->_fe_map->get_dzetady(); }

const std::vector<Real>& libMesh::FEAbstract::get_dzetadz ( ) const [inline, inherited]

Returns:: the dzeta/dz entry in the transformation matrix from physical to local coordinates.

Definition at line 362 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

00363   { return this->_fe_map->get_dzetadz(); }

FEFamily libMesh::FEAbstract::get_family ( ) const [inline, inherited]

Returns:: the finite element family of this element.

Definition at line 439 of file fe_abstract.h.

References libMesh::FEType::family, and libMesh::FEAbstract::fe_type.

Referenced by libMesh::FE< Dim, T >::FE().

00439 { return fe_type.family; }

const FEMap& libMesh::FEAbstract::get_fe_map ( ) const [inline, inherited]

Returns:: the mapping object

Definition at line 444 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map, and libMesh::AutoPtr< Tp >::get().

Referenced by libMesh::InfFE< Dim, T_radial, T_map >::combine_base_radial(), libMesh::InfFE< Dim, T_radial, T_map >::init_face_shape_functions(), libMesh::HCurlFETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_curl(), libMesh::H1FETransformation< OutputShape >::map_d2phi(), libMesh::H1FETransformation< OutputShape >::map_div(), libMesh::H1FETransformation< OutputShape >::map_dphi(), and libMesh::HCurlFETransformation< OutputShape >::map_phi().

00444 { return *_fe_map.get(); }

FEType libMesh::FEAbstract::get_fe_type ( ) const [inline, inherited]

Returns:: the FE Type (approximation order and family) of the finite element.

Definition at line 418 of file fe_abstract.h.

References libMesh::FEAbstract::fe_type.

Referenced by libMesh::FEMContext::build_new_fe(), libMesh::HCurlFETransformation< OutputShape >::map_phi(), libMesh::H1FETransformation< OutputShape >::map_phi(), and libMesh::ProjectFEMSolution::operator()().

00418 { return fe_type; }

std::string libMesh::ReferenceCounter::get_info ( ) [static, inherited]

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

References libMesh::ReferenceCounter::_counts, and libMesh::Quality::name().

Referenced by libMesh::ReferenceCounter::print_info().

00048 {
00049 #if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
00050 
00051   std::ostringstream oss;
00052 
00053   oss << '\n'
00054       << " ---------------------------------------------------------------------------- \n"
00055       << "| Reference count information                                                |\n"
00056       << " ---------------------------------------------------------------------------- \n";
00057 
00058   for (Counts::iterator it = _counts.begin();
00059        it != _counts.end(); ++it)
00060     {
00061       const std::string name(it->first);
00062       const unsigned int creations    = it->second.first;
00063       const unsigned int destructions = it->second.second;
00064 
00065       oss << "| " << name << " reference count information:\n"
00066           << "|  Creations:    " << creations    << '\n'
00067           << "|  Destructions: " << destructions << '\n';
00068     }
00069 
00070   oss << " ---------------------------------------------------------------------------- \n";
00071 
00072   return oss.str();
00073 
00074 #else
00075 
00076   return "";
00077 
00078 #endif
00079 }

const std::vector<Real>& libMesh::FEAbstract::get_JxW ( ) const [inline, inherited]

Returns:: the element Jacobian times the quadrature weight for each quadrature point.

Definition at line 234 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

Referenced by libMesh::ExactErrorEstimator::find_squared_element_error(), and libMesh::ProjectFEMSolution::operator()().

00235   { return this->_fe_map->get_JxW(); }

const std::vector<Point>& libMesh::FEAbstract::get_normals ( ) const [inline, inherited]

Returns:: the normal vectors for face integration.

Definition at line 374 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

00375   { return this->_fe_map->get_normals(); }

Order libMesh::FEAbstract::get_order ( ) const [inline, inherited]

Returns:: the approximation order of the finite element.

Definition at line 423 of file fe_abstract.h.

References libMesh::FEAbstract::_p_level, libMesh::FEAbstract::fe_type, and libMesh::FEType::order.

Referenced by libMesh::FEXYZ< Dim >::compute_face_values(), libMesh::FEXYZ< Dim >::init_shape_functions(), and libMesh::FE< Dim, T >::init_shape_functions().

00423 { return static_cast<Order>(fe_type.order + _p_level); }

unsigned int libMesh::FEAbstract::get_p_level ( ) const [inline, inherited]

Returns:: the p refinement level that the current shape functions have been calculated for.

Definition at line 413 of file fe_abstract.h.

References libMesh::FEAbstract::_p_level.

00413 { return _p_level; }

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_phi ( ) const [inline, inherited]

Returns:: the shape function values at the quadrature points on the element.

Definition at line 222 of file fe_base.h.

00223   { libmesh_assert(!calculations_started || calculate_phi);
00224     calculate_phi = true; return phi; }

void libMesh::FEAbstract::get_refspace_nodes	(	const ElemType	t,
		std::vector< Point > &	nodes
	)			`[static, inherited]`

returns the reference space nodes coordinates given the element type

Definition at line 415 of file fe_abstract.C.

References libMeshEnums::EDGE2, libMeshEnums::EDGE3, libMesh::err, libMeshEnums::HEX20, libMeshEnums::HEX27, libMeshEnums::HEX8, libMeshEnums::PRISM15, libMeshEnums::PRISM18, libMeshEnums::PRISM6, libMeshEnums::PYRAMID5, libMeshEnums::QUAD4, libMeshEnums::QUAD8, libMeshEnums::QUAD9, libMeshEnums::TET10, libMeshEnums::TET4, libMeshEnums::TRI3, and libMeshEnums::TRI6.

Referenced by libMesh::FE< Dim, T >::side_map().

00416 {
00417   switch(itemType)
00418   {
00419     case EDGE2:
00420     {
00421        nodes.resize(2);
00422        nodes[0] = Point (-1.,0.,0.);
00423        nodes[1] = Point (1.,0.,0.);
00424        return;
00425     }
00426     case EDGE3:
00427     {
00428        nodes.resize(3);
00429        nodes[0] = Point (-1.,0.,0.);
00430        nodes[1] = Point (1.,0.,0.);
00431        nodes[2] = Point (0.,0.,0.);
00432        return;
00433     }
00434     case TRI3:
00435     {
00436        nodes.resize(3);
00437        nodes[0] = Point (0.,0.,0.);
00438        nodes[1] = Point (1.,0.,0.);
00439        nodes[2] = Point (0.,1.,0.);
00440        return;
00441     }
00442     case TRI6:
00443     {
00444        nodes.resize(6);
00445        nodes[0] = Point (0.,0.,0.);
00446        nodes[1] = Point (1.,0.,0.);
00447        nodes[2] = Point (0.,1.,0.);
00448        nodes[3] = Point (.5,0.,0.);
00449        nodes[4] = Point (.5,.5,0.);
00450        nodes[5] = Point (0.,.5,0.);
00451        return;
00452     }
00453     case QUAD4:
00454     {
00455        nodes.resize(4);
00456        nodes[0] = Point (-1.,-1.,0.);
00457        nodes[1] = Point (1.,-1.,0.);
00458        nodes[2] = Point (1.,1.,0.);
00459        nodes[3] = Point (-1.,1.,0.);
00460        return;
00461     }
00462     case QUAD8:
00463     {
00464        nodes.resize(8);
00465        nodes[0] = Point (-1.,-1.,0.);
00466        nodes[1] = Point (1.,-1.,0.);
00467        nodes[2] = Point (1.,1.,0.);
00468        nodes[3] = Point (-1.,1.,0.);
00469        nodes[4] = Point (0.,-1.,0.);
00470        nodes[5] = Point (1.,0.,0.);
00471        nodes[6] = Point (0.,1.,0.);
00472        nodes[7] = Point (-1.,0.,0.);
00473        return;
00474     }
00475     case QUAD9:
00476     {
00477        nodes.resize(9);
00478        nodes[0] = Point (-1.,-1.,0.);
00479        nodes[1] = Point (1.,-1.,0.);
00480        nodes[2] = Point (1.,1.,0.);
00481        nodes[3] = Point (-1.,1.,0.);
00482        nodes[4] = Point (0.,-1.,0.);
00483        nodes[5] = Point (1.,0.,0.);
00484        nodes[6] = Point (0.,1.,0.);
00485        nodes[7] = Point (-1.,0.,0.);
00486        nodes[8] = Point (0.,0.,0.);
00487        return;
00488     }
00489     case TET4:
00490     {
00491        nodes.resize(4);
00492        nodes[0] = Point (0.,0.,0.);
00493        nodes[1] = Point (1.,0.,0.);
00494        nodes[2] = Point (0.,1.,0.);
00495        nodes[3] = Point (0.,0.,1.);
00496        return;
00497     }
00498     case TET10:
00499     {
00500        nodes.resize(10);
00501        nodes[0] = Point (0.,0.,0.);
00502        nodes[1] = Point (1.,0.,0.);
00503        nodes[2] = Point (0.,1.,0.);
00504        nodes[3] = Point (0.,0.,1.);
00505        nodes[4] = Point (.5,0.,0.);
00506        nodes[5] = Point (.5,.5,0.);
00507        nodes[6] = Point (0.,.5,0.);
00508        nodes[7] = Point (0.,0.,.5);
00509        nodes[8] = Point (.5,0.,.5);
00510        nodes[9] = Point (0.,.5,.5);
00511        return;
00512     }
00513     case HEX8:
00514     {
00515        nodes.resize(8);
00516        nodes[0] = Point (-1.,-1.,-1.);
00517        nodes[1] = Point (1.,-1.,-1.);
00518        nodes[2] = Point (1.,1.,-1.);
00519        nodes[3] = Point (-1.,1.,-1.);
00520        nodes[4] = Point (-1.,-1.,1.);
00521        nodes[5] = Point (1.,-1.,1.);
00522        nodes[6] = Point (1.,1.,1.);
00523        nodes[7] = Point (-1.,1.,1.);
00524        return;
00525     }
00526     case HEX20:
00527     {
00528        nodes.resize(20);
00529        nodes[0] = Point (-1.,-1.,-1.);
00530        nodes[1] = Point (1.,-1.,-1.);
00531        nodes[2] = Point (1.,1.,-1.);
00532        nodes[3] = Point (-1.,1.,-1.);
00533        nodes[4] = Point (-1.,-1.,1.);
00534        nodes[5] = Point (1.,-1.,1.);
00535        nodes[6] = Point (1.,1.,1.);
00536        nodes[7] = Point (-1.,1.,1.);
00537        nodes[8] = Point (0.,-1.,-1.);
00538        nodes[9] = Point (1.,0.,-1.);
00539        nodes[10] = Point (0.,1.,-1.);
00540        nodes[11] = Point (-1.,0.,-1.);
00541        nodes[12] = Point (-1.,-1.,0.);
00542        nodes[13] = Point (1.,-1.,0.);
00543        nodes[14] = Point (1.,1.,0.);
00544        nodes[15] = Point (-1.,1.,0.);
00545        nodes[16] = Point (0.,-1.,1.);
00546        nodes[17] = Point (1.,0.,1.);
00547        nodes[18] = Point (0.,1.,1.);
00548        nodes[19] = Point (-1.,0.,1.);
00549        return;
00550     }
00551     case HEX27:
00552     {
00553        nodes.resize(27);
00554        nodes[0] = Point (-1.,-1.,-1.);
00555        nodes[1] = Point (1.,-1.,-1.);
00556        nodes[2] = Point (1.,1.,-1.);
00557        nodes[3] = Point (-1.,1.,-1.);
00558        nodes[4] = Point (-1.,-1.,1.);
00559        nodes[5] = Point (1.,-1.,1.);
00560        nodes[6] = Point (1.,1.,1.);
00561        nodes[7] = Point (-1.,1.,1.);
00562        nodes[8] = Point (0.,-1.,-1.);
00563        nodes[9] = Point (1.,0.,-1.);
00564        nodes[10] = Point (0.,1.,-1.);
00565        nodes[11] = Point (-1.,0.,-1.);
00566        nodes[12] = Point (-1.,-1.,0.);
00567        nodes[13] = Point (1.,-1.,0.);
00568        nodes[14] = Point (1.,1.,0.);
00569        nodes[15] = Point (-1.,1.,0.);
00570        nodes[16] = Point (0.,-1.,1.);
00571        nodes[17] = Point (1.,0.,1.);
00572        nodes[18] = Point (0.,1.,1.);
00573        nodes[19] = Point (-1.,0.,1.);
00574        nodes[20] = Point (0.,0.,-1.);
00575        nodes[21] = Point (0.,-1.,0.);
00576        nodes[22] = Point (1.,0.,0.);
00577        nodes[23] = Point (0.,1.,0.);
00578        nodes[24] = Point (-1.,0.,0.);
00579        nodes[25] = Point (0.,0.,1.);
00580        nodes[26] = Point (0.,0.,0.);
00581        return;
00582     }
00583     case PRISM6:
00584     {
00585        nodes.resize(6);
00586        nodes[0] = Point (0.,0.,-1.);
00587        nodes[1] = Point (1.,0.,-1.);
00588        nodes[2] = Point (0.,1.,-1.);
00589        nodes[3] = Point (0.,0.,1.);
00590        nodes[4] = Point (1.,0.,1.);
00591        nodes[5] = Point (0.,1.,1.);
00592        return;
00593     }
00594     case PRISM15:
00595     {
00596        nodes.resize(15);
00597        nodes[0] = Point (0.,0.,-1.);
00598        nodes[1] = Point (1.,0.,-1.);
00599        nodes[2] = Point (0.,1.,-1.);
00600        nodes[3] = Point (0.,0.,1.);
00601        nodes[4] = Point (1.,0.,1.);
00602        nodes[5] = Point (0.,1.,1.);
00603        nodes[6] = Point (.5,0.,-1.);
00604        nodes[7] = Point (.5,.5,-1.);
00605        nodes[8] = Point (0.,.5,-1.);
00606        nodes[9] = Point (0.,0.,0.);
00607        nodes[10] = Point (1.,0.,0.);
00608        nodes[11] = Point (0.,1.,0.);
00609        nodes[12] = Point (.5,0.,1.);
00610        nodes[13] = Point (.5,.5,1.);
00611        nodes[14] = Point (0.,.5,1.);
00612        return;
00613     }
00614     case PRISM18:
00615     {
00616        nodes.resize(18);
00617        nodes[0] = Point (0.,0.,-1.);
00618        nodes[1] = Point (1.,0.,-1.);
00619        nodes[2] = Point (0.,1.,-1.);
00620        nodes[3] = Point (0.,0.,1.);
00621        nodes[4] = Point (1.,0.,1.);
00622        nodes[5] = Point (0.,1.,1.);
00623        nodes[6] = Point (.5,0.,-1.);
00624        nodes[7] = Point (.5,.5,-1.);
00625        nodes[8] = Point (0.,.5,-1.);
00626        nodes[9] = Point (0.,0.,0.);
00627        nodes[10] = Point (1.,0.,0.);
00628        nodes[11] = Point (0.,1.,0.);
00629        nodes[12] = Point (.5,0.,1.);
00630        nodes[13] = Point (.5,.5,1.);
00631        nodes[14] = Point (0.,.5,1.);
00632        nodes[15] = Point (.5,0.,0.);
00633        nodes[16] = Point (.5,.5,0.);
00634        nodes[17] = Point (0.,.5,0.);
00635        return;
00636     }
00637     case PYRAMID5:
00638     {
00639        nodes.resize(5);
00640        nodes[0] = Point (-1.,-1.,0.);
00641        nodes[1] = Point (1.,-1.,0.);
00642        nodes[2] = Point (1.,1.,0.);
00643        nodes[3] = Point (-1.,1.,0.);
00644        nodes[4] = Point (-1.,-1.,1.);
00645        return;
00646     }
00647     default:
00648     {
00649       libMesh::err << "ERROR: Unknown element type " << itemType << std::endl;
00650       libmesh_error();
00651     }
00652   }
00653   return;
00654 }

const std::vector<RealGradient>& libMesh::FEGenericBase< FEOutputType< T >::type >::get_Sobolev_dweight ( ) const [inline, inherited]

Returns:: the first global derivative of the multiplicative weight at each quadrature point. See get_Sobolev_weight() for details. In case of FE initialized to all zero.

Definition at line 442 of file fe_base.h.

00443       { return dweight; }

const std::vector<Real>& libMesh::FEGenericBase< FEOutputType< T >::type >::get_Sobolev_weight ( ) const [inline, inherited]

Returns:: the multiplicative weight at each quadrature point. This weight is used for certain infinite element weak formulations, so that weighted Sobolev spaces are used for the trial function space. This renders the variational form easily computable.

In case of the general finite element class FE this field is initialized to all ones, so that the variational formulation for an infinite element returns correct element matrices for a mesh using both finite and infinite elements.

Definition at line 434 of file fe_base.h.

00435       { return weight; }

const std::vector<std::vector<Point> >& libMesh::FEAbstract::get_tangents ( ) const [inline, inherited]

Returns:: the tangent vectors for face integration.

Definition at line 368 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

00369   { return this->_fe_map->get_tangents(); }

ElemType libMesh::FEAbstract::get_type ( ) const [inline, inherited]

Returns:: the element type that the current shape functions have been calculated for. Useful in determining when shape functions must be recomputed.

Definition at line 407 of file fe_abstract.h.

References libMesh::FEAbstract::elem_type.

Referenced by libMesh::FEXYZ< Dim >::compute_face_values(), libMesh::FE< Dim, T >::edge_reinit(), libMesh::FEXYZ< Dim >::init_shape_functions(), libMesh::FE< Dim, T >::init_shape_functions(), and libMesh::InfFE< Dim, T_radial, T_map >::reinit().

00407 { return elem_type; }

const std::vector<Point>& libMesh::FEAbstract::get_xyz ( ) const [inline, inherited]

Returns:: the xyz spatial locations of the quadrature points on the element.

Definition at line 227 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map.

Referenced by libMesh::FEXYZ< Dim >::compute_shape_functions(), libMesh::ExactErrorEstimator::find_squared_element_error(), and libMesh::ProjectFEMSolution::operator()().

00228   { return this->_fe_map->get_xyz(); }

void libMesh::ReferenceCounter::increment_constructor_count ( const std::string & name ) [inline, protected, inherited]

Increments the construction counter. Should be called in the constructor of any derived class that will be reference counted.

Definition at line 163 of file reference_counter.h.

References libMesh::ReferenceCounter::_counts, and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::ReferenceCountedObject().

00164 {
00165   Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
00166   std::pair<unsigned int, unsigned int>& p = _counts[name];
00167 
00168   p.first++;
00169 }

void libMesh::ReferenceCounter::increment_destructor_count ( const std::string & name ) [inline, protected, inherited]

Increments the destruction counter. Should be called in the destructor of any derived class that will be reference counted.

Definition at line 176 of file reference_counter.h.

References libMesh::ReferenceCounter::_counts, and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::~ReferenceCountedObject().

00177 {
00178   Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
00179   std::pair<unsigned int, unsigned int>& p = _counts[name];
00180 
00181   p.second++;
00182 }

virtual void libMesh::FE< Dim, T >::init_base_shape_functions	(	const std::vector< Point > &	qp,
		const Elem *	e
	)			`[protected, virtual, inherited]`

Initialize the data fields for the base of an an infinite element.

Implements libMesh::FEGenericBase< FEOutputType< T >::type >.

virtual void libMesh::FE< Dim, T >::init_shape_functions	(	const std::vector< Point > &	qp,
		const Elem *	e
	)			`[protected, virtual, inherited]`

Update the various member data fields phi, dphidxi, dphideta, dphidzeta, etc. for the current element. These data will be computed at the points qp, which are generally (but need not be) the quadrature points.

static void libMesh::FE< Dim, T >::inverse_map	(	const Elem *	elem,
		const std::vector< Point > &	physical_points,
		std::vector< Point > &	reference_points,
		const Real	tolerance = `TOLERANCE`,
		const bool	secure = `true`
	)			`[static, inherited]`

Takes a number points in physical space (in the physical_points vector) and finds their location on the reference element for the input element elem. The values on the reference element are returned in the vector reference_points. The optional parameter tolerance defines how close is "good enough." The map inversion iteration computes the sequence $\{ p_n \}$ , and the iteration is terminated when $\|p - p_n\| < \mbox{\texttt{tolerance}}$

static Point libMesh::FE< Dim, T >::inverse_map	(	const Elem *	elem,
		const Point &	p,
		const Real	tolerance = `TOLERANCE`,
		const bool	secure = `true`
	)			`[static, inherited]`

Returns:: the location (on the reference element) of the point p located in physical space. This function requires inverting the (possibly nonlinear) transformation map, so it is not trivial. The optional parameter tolerance defines how close is "good enough." The map inversion iteration computes the sequence $\{ p_n \}$ , and the iteration is terminated when $\|p - p_n\| < \mbox{\texttt{tolerance}}$

virtual bool libMesh::FE< Dim, T >::is_hierarchic ( ) const [virtual, inherited]

Returns:: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

static Point libMesh::FE< Dim, T >::map	(	const Elem *	elem,
		const Point &	reference_point
	)			`[static, inherited]`

Returns:: the location (in physical space) of the point p located on the reference element.

static Point libMesh::FE< Dim, T >::map_eta	(	const Elem *	elem,
		const Point &	reference_point
	)			`[static, inherited]`

Returns:: d(xyz)/deta (in physical space) of the point p located on the reference element.

static Point libMesh::FE< Dim, T >::map_xi	(	const Elem *	elem,
		const Point &	reference_point
	)			`[static, inherited]`

Returns:: d(xyz)/dxi (in physical space) of the point p located on the reference element.

static Point libMesh::FE< Dim, T >::map_zeta	(	const Elem *	elem,
		const Point &	reference_point
	)			`[static, inherited]`

Returns:: d(xyz)/dzeta (in physical space) of the point p located on the reference element.

static unsigned int libMesh::FE< Dim, T >::n_dofs	(	const ElemType	t,
		const Order	o
	)			`[static, inherited]`

Returns:: the number of shape functions associated with this finite element.

On a p-refined element, o should be the total order of the element.

static unsigned int libMesh::FE< Dim, T >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)			`[static, inherited]`

Returns:: the number of dofs at node n for a finite element of type t and order o.

On a p-refined element, o should be the total order of the element.

static unsigned int libMesh::FE< Dim, T >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)			`[static, inherited]`

Returns:: the number of dofs interior to the element, not associated with any interior nodes.

On a p-refined element, o should be the total order of the element.

static unsigned int libMesh::ReferenceCounter::n_objects ( ) [inline, static, inherited]

Prints the number of outstanding (created, but not yet destroyed) objects.

Definition at line 79 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

00080   { return _n_objects; }

virtual unsigned int libMesh::FE< Dim, T >::n_quadrature_points ( ) const [virtual, inherited]

Returns:: the total number of quadrature points. Call this to get an upper bound for the for loop in your simulation for matrix assembly of the current element.

Implements libMesh::FEAbstract.

static unsigned int libMesh::FE< Dim, T >::n_shape_functions	(	const ElemType	t,
		const Order	o
	)			`[inline, static, inherited]`

Returns:: the number of shape functions associated with a finite element of type t and approximation order o.

On a p-refined element, o should be the total order of the element.

Definition at line 226 of file fe.h.

00228   { return FE<Dim,T>::n_dofs (t,o); }

virtual unsigned int libMesh::FE< Dim, T >::n_shape_functions ( ) const [virtual, inherited]

Returns:: the number of shape functions associated with this finite element.

Implements libMesh::FEAbstract.

static void libMesh::FE< Dim, T >::nodal_soln	(	const Elem *	elem,
		const Order	o,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)			`[static, inherited]`

Build the nodal soln from the element soln. This is the solution that will be plotted.

On a p-refined element, o should be the base order of the element.

bool libMesh::FEAbstract::on_reference_element	(	const Point &	p,
		const ElemType	t,
		const Real	eps = `TOLERANCE`
	)			`[static, inherited]`

Returns:: true if the point p is located on the reference element for element type t, false otherwise. Since we are doing floating point comparisons here the parameter eps can be specified to indicate a tolerance. For example, $x \le 1$ becomes $x \le 1 + \epsilon$ .

Definition at line 656 of file fe_abstract.C.

References libMeshEnums::EDGE2, libMeshEnums::EDGE3, libMeshEnums::EDGE4, libMesh::err, libMeshEnums::HEX20, libMeshEnums::HEX27, libMeshEnums::HEX8, libMeshEnums::INFHEX8, libMeshEnums::INFPRISM6, libMeshEnums::NODEELEM, libMeshEnums::PRISM15, libMeshEnums::PRISM18, libMeshEnums::PRISM6, libMeshEnums::PYRAMID5, libMeshEnums::QUAD4, libMeshEnums::QUAD8, libMeshEnums::QUAD9, libMesh::Real, libMeshEnums::TET10, libMeshEnums::TET4, libMeshEnums::TRI3, and libMeshEnums::TRI6.

Referenced by libMesh::FE< Dim, T >::inverse_map().

00657 {
00658   libmesh_assert_greater_equal (eps, 0.);
00659 
00660   const Real xi   = p(0);
00661 #if LIBMESH_DIM > 1
00662   const Real eta  = p(1);
00663 #else
00664   const Real eta  = 0.;
00665 #endif
00666 #if LIBMESH_DIM > 2
00667   const Real zeta = p(2);
00668 #else
00669   const Real zeta  = 0.;
00670 #endif
00671 
00672   switch (t)
00673     {
00674     case NODEELEM:
00675       {
00676         return (!xi && !eta && !zeta);
00677       }
00678     case EDGE2:
00679     case EDGE3:
00680     case EDGE4:
00681       {
00682         // The reference 1D element is [-1,1].
00683         if ((xi >= -1.-eps) &&
00684             (xi <=  1.+eps))
00685           return true;
00686 
00687         return false;
00688       }
00689 
00690 
00691     case TRI3:
00692     case TRI6:
00693       {
00694         // The reference triangle is isocoles
00695         // and is bound by xi=0, eta=0, and xi+eta=1.
00696         if ((xi  >= 0.-eps) &&
00697             (eta >= 0.-eps) &&
00698             ((xi + eta) <= 1.+eps))
00699           return true;
00700 
00701         return false;
00702       }
00703 
00704 
00705     case QUAD4:
00706     case QUAD8:
00707     case QUAD9:
00708       {
00709         // The reference quadrilateral element is [-1,1]^2.
00710         if ((xi  >= -1.-eps) &&
00711             (xi  <=  1.+eps) &&
00712             (eta >= -1.-eps) &&
00713             (eta <=  1.+eps))
00714           return true;
00715 
00716         return false;
00717       }
00718 
00719 
00720     case TET4:
00721     case TET10:
00722       {
00723         // The reference tetrahedral is isocoles
00724         // and is bound by xi=0, eta=0, zeta=0,
00725         // and xi+eta+zeta=1.
00726         if ((xi   >= 0.-eps) &&
00727             (eta  >= 0.-eps) &&
00728             (zeta >= 0.-eps) &&
00729             ((xi + eta + zeta) <= 1.+eps))
00730           return true;
00731 
00732         return false;
00733       }
00734 
00735 
00736     case HEX8:
00737     case HEX20:
00738     case HEX27:
00739       {
00740         /*
00741           if ((xi   >= -1.) &&
00742           (xi   <=  1.) &&
00743           (eta  >= -1.) &&
00744           (eta  <=  1.) &&
00745           (zeta >= -1.) &&
00746           (zeta <=  1.))
00747           return true;
00748         */
00749 
00750         // The reference hexahedral element is [-1,1]^3.
00751         if ((xi   >= -1.-eps) &&
00752             (xi   <=  1.+eps) &&
00753             (eta  >= -1.-eps) &&
00754             (eta  <=  1.+eps) &&
00755             (zeta >= -1.-eps) &&
00756             (zeta <=  1.+eps))
00757           {
00758             //      libMesh::out << "Strange Point:\n";
00759             //      p.print();
00760             return true;
00761           }
00762 
00763         return false;
00764       }
00765 
00766     case PRISM6:
00767     case PRISM15:
00768     case PRISM18:
00769       {
00770         // Figure this one out...
00771         // inside the reference triange with zeta in [-1,1]
00772         if ((xi   >=  0.-eps) &&
00773             (eta  >=  0.-eps) &&
00774             (zeta >= -1.-eps) &&
00775             (zeta <=  1.+eps) &&
00776             ((xi + eta) <= 1.+eps))
00777           return true;
00778 
00779         return false;
00780       }
00781 
00782 
00783     case PYRAMID5:
00784       {
00785         libMesh::err << "BEN: Implement this you lazy bastard!"
00786                       << std::endl;
00787         libmesh_error();
00788 
00789         return false;
00790       }
00791 
00792 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
00793     case INFHEX8:
00794       {
00795         // The reference infhex8 is a [-1,1]^3.
00796         if ((xi   >= -1.-eps) &&
00797             (xi   <=  1.+eps) &&
00798             (eta  >= -1.-eps) &&
00799             (eta  <=  1.+eps) &&
00800             (zeta >= -1.-eps) &&
00801             (zeta <=  1.+eps))
00802           {
00803             return true;
00804           }
00805         return false;
00806       }
00807 
00808     case INFPRISM6:
00809       {
00810         // inside the reference triange with zeta in [-1,1]
00811         if ((xi   >=  0.-eps) &&
00812             (eta  >=  0.-eps) &&
00813             (zeta >= -1.-eps) &&
00814             (zeta <=  1.+eps) &&
00815             ((xi + eta) <= 1.+eps))
00816           {
00817             return true;
00818           }
00819 
00820         return false;
00821       }
00822 #endif
00823 
00824     default:
00825       libMesh::err << "ERROR: Unknown element type " << t << std::endl;
00826       libmesh_error();
00827     }
00828 
00829   // If we get here then the point is _not_ in the
00830   // reference element.   Better return false.
00831 
00832   return false;
00833 }

void libMesh::FEGenericBase< FEOutputType< T >::type >::print_d2phi ( std::ostream & os ) const [virtual, inherited]

Prints the value of each shape function's second derivatives at each quadrature point.

Implements libMesh::FEAbstract.

void libMesh::FEGenericBase< FEOutputType< T >::type >::print_dphi ( std::ostream & os ) const [virtual, inherited]

Prints the value of each shape function's derivative at each quadrature point.

Implements libMesh::FEAbstract.

void libMesh::ReferenceCounter::print_info ( std::ostream & out = libMesh::out ) [static, inherited]

Prints the reference information, by default to libMesh::out.

Definition at line 88 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter, and libMesh::ReferenceCounter::get_info().

00089 {
00090   if( _enable_print_counter ) out_stream << ReferenceCounter::get_info();
00091 }

void libMesh::FEAbstract::print_info ( std::ostream & os ) const [inherited]

Prints all the relevant information about the current element.

Definition at line 851 of file fe_abstract.C.

References libMesh::FEAbstract::print_dphi(), libMesh::FEAbstract::print_JxW(), libMesh::FEAbstract::print_phi(), and libMesh::FEAbstract::print_xyz().

Referenced by libMesh::operator<<().

00852 {
00853   os << "phi[i][j]: Shape function i at quadrature pt. j" << std::endl;
00854   this->print_phi(os);
00855 
00856   os << "dphi[i][j]: Shape function i's gradient at quadrature pt. j" << std::endl;
00857   this->print_dphi(os);
00858 
00859   os << "XYZ locations of the quadrature pts." << std::endl;
00860   this->print_xyz(os);
00861 
00862   os << "Values of JxW at the quadrature pts." << std::endl;
00863   this->print_JxW(os);
00864 }

void libMesh::FEAbstract::print_JxW ( std::ostream & os ) const [inherited]

Prints the Jacobian times the weight for each quadrature point.

Definition at line 838 of file fe_abstract.C.

References libMesh::FEAbstract::_fe_map.

Referenced by libMesh::FEAbstract::print_info().

00839 {
00840   this->_fe_map->print_JxW(os);
00841 }

void libMesh::FEGenericBase< FEOutputType< T >::type >::print_phi ( std::ostream & os ) const [virtual, inherited]

Prints the value of each shape function at each quadrature point.

Implements libMesh::FEAbstract.

void libMesh::FEAbstract::print_xyz ( std::ostream & os ) const [inherited]

Prints the spatial location of each quadrature point (on the physical element).

Definition at line 845 of file fe_abstract.C.

References libMesh::FEAbstract::_fe_map.

Referenced by libMesh::FEAbstract::print_info().

00846 {
00847   this->_fe_map->print_xyz(os);
00848 }

virtual void libMesh::FE< Dim, T >::reinit	(	const Elem *	elem,
		const unsigned int	side,
		const Real	tolerance = `TOLERANCE`,
		const std::vector< Point > *const	pts = `NULL`,
		const std::vector< Real > *const	weights = `NULL`
	)			`[virtual, inherited]`

Reinitializes all the physical element-dependent data based on the side of face. The tolerance paremeter is passed to the involved call to inverse_map(). By default the shape functions and associated data are computed at the quadrature points specified by the quadrature rule qrule, but may be any points specified on the reference side element specified in the optional argument pts.

Implements libMesh::FEAbstract.

virtual void libMesh::FE< Dim, T >::reinit	(	const Elem *	elem,
		const std::vector< Point > *const	pts = `NULL`,
		const std::vector< Real > *const	weights = `NULL`
	)			`[virtual, inherited]`

This is at the core of this class. Use this for each new element in the mesh. Reinitializes all the physical element-dependent data based on the current element elem. By default the shape functions and associated data are computed at the quadrature points specified by the quadrature rule qrule, but may be any points specified on the reference element specified in the optional argument pts.

Implements libMesh::FEAbstract.

static OutputShape libMesh::FE< Dim, T >::shape	(	const Elem *	elem,
		const Order	o,
		const unsigned int	i,
		const Point &	p
	)			`[static, inherited]`

Returns:: the value of the $i^{th}$ shape function at point p. This method allows you to specify the imension, element type, and order directly. This allows the method to be static.

On a p-refined element, o should be the base order of the element.

static OutputShape libMesh::FE< Dim, T >::shape	(	const ElemType	t,
		const Order	o,
		const unsigned int	i,
		const Point &	p
	)			`[static, inherited]`

Returns:: the value of the $i^{th}$ shape function at point p. This method allows you to specify the imension, element type, and order directly. This allows the method to be static.

On a p-refined element, o should be the total order of the element.

static OutputShape libMesh::FE< Dim, T >::shape_deriv	(	const Elem *	elem,
		const Order	o,
		const unsigned int	i,
		const unsigned int	j,
		const Point &	p
	)			`[static, inherited]`

Returns:: the $j^{th}$ derivative of the $i^{th}$ shape function. You must specify element type, and order directly.

On a p-refined element, o should be the base order of the element.

static OutputShape libMesh::FE< Dim, T >::shape_deriv	(	const ElemType	t,
		const Order	o,
		const unsigned int	i,
		const unsigned int	j,
		const Point &	p
	)			`[static, inherited]`

Returns:: the $j^{th}$ derivative of the $i^{th}$ shape function at point p. This method allows you to specify the dimension, element type, and order directly.

On a p-refined element, o should be the total order of the element.

static OutputShape libMesh::FE< Dim, T >::shape_second_deriv	(	const Elem *	elem,
		const Order	o,
		const unsigned int	i,
		const unsigned int	j,
		const Point &	p
	)			`[static, inherited]`

Returns:: the second $j^{th}$ derivative of the $i^{th}$ shape function at the point p. Note that cross-derivatives are also possible, i.e. j = 0 ==> d^2 phi / dxi^2 j = 1 ==> d^2 phi / dxi deta j = 2 ==> d^2 phi / deta^2 j = 3 ==> d^2 phi / dxi dzeta j = 4 ==> d^2 phi / deta dzeta j = 5 ==> d^2 phi / dzeta^2

Note: Computing second derivatives is not currently supported for all element types: C1 (Clough and Hermite), Lagrange, Hierarchic, L2_Hierarchic, and Monomial are supported. All other element types return an error when asked for second derivatives.

On a p-refined element, o should be the base order of the element.

static OutputShape libMesh::FE< Dim, T >::shape_second_deriv	(	const ElemType	t,
		const Order	o,
		const unsigned int	i,
		const unsigned int	j,
		const Point &	p
	)			`[static, inherited]`

Returns:: the second $j^{th}$ derivative of the $i^{th}$ shape function at the point p. Note that cross-derivatives are also possible, i.e. j = 0 ==> d^2 phi / dxi^2 j = 1 ==> d^2 phi / dxi deta j = 2 ==> d^2 phi / deta^2 j = 3 ==> d^2 phi / dxi dzeta j = 4 ==> d^2 phi / deta dzeta j = 5 ==> d^2 phi / dzeta^2

Note: Computing second derivatives is not currently supported for all element types: C1 (Clough and Hermite), Lagrange, Hierarchic, L2_Hierarchic, and Monomial are supported. All other element types return an error when asked for second derivatives.

On a p-refined element, o should be the total order of the element.

virtual bool libMesh::FE< Dim, T >::shapes_need_reinit ( ) const [virtual, inherited]

Returns:: true when the shape functions (for this FEFamily) depend on the particular element, and therefore needs to be re-initialized for each new element. false otherwise.

Implements libMesh::FEAbstract.

virtual void libMesh::FE< Dim, T >::side_map	(	const Elem *	elem,
		const Elem *	side,
		const unsigned int	s,
		const std::vector< Point > &	reference_side_points,
		std::vector< Point > &	reference_points
	)			`[virtual, inherited]`

Computes the reference space quadrature points on the side of an element based on the side quadrature points.

Implements libMesh::FEAbstract.

Friends And Related Function Documentation

friend class InfFE [friend, inherited]

make InfFE classes friends, so that these may access the private map, map_xyz methods

Reimplemented from libMesh::FEGenericBase< FEOutputType< T >::type >.

Definition at line 443 of file fe.h.

std::ostream& operator<<	(	std::ostream &	os,
		const FEAbstract &	fe
	)			`[friend, inherited]`

Same as above, but allows you to print to a stream.

Member Data Documentation

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts [static, protected, inherited]

Actually holds the data.

Definition at line 118 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::get_info(), libMesh::ReferenceCounter::increment_constructor_count(), and libMesh::ReferenceCounter::increment_destructor_count().

bool libMesh::ReferenceCounter::_enable_print_counter = true [static, protected, inherited]

Flag to control whether reference count information is printed when print_info is called.

Definition at line 137 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::disable_print_counter_info(), libMesh::ReferenceCounter::enable_print_counter_info(), and libMesh::ReferenceCounter::print_info().

AutoPtr<FEMap> libMesh::FEAbstract::_fe_map [protected, inherited]

Definition at line 509 of file fe_abstract.h.

AutoPtr<FETransformationBase<FEOutputType< T >::type > > libMesh::FEGenericBase< FEOutputType< T >::type >::_fe_trans [protected, inherited]

Object that handles computing shape function values, gradients, etc in the physical domain.

Definition at line 502 of file fe_base.h.

Threads::spin_mutex libMesh::ReferenceCounter::_mutex [static, protected, inherited]

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 131 of file reference_counter.h.

Threads::atomic< unsigned int > libMesh::ReferenceCounter::_n_objects [static, protected, inherited]

The number of objects. Print the reference count information when the number returns to 0.

Definition at line 126 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::n_objects(), libMesh::ReferenceCounter::ReferenceCounter(), and libMesh::ReferenceCounter::~ReferenceCounter().

unsigned int libMesh::FEAbstract::_p_level [protected, inherited]

The p refinement level the current data structures are set up for.

Definition at line 570 of file fe_abstract.h.

Referenced by libMesh::FEAbstract::get_order(), libMesh::FEAbstract::get_p_level(), libMesh::FE< Dim, T >::reinit(), and libMesh::FE< Dim, T >::side_map().

std::vector<Point> libMesh::FE< Dim, T >::cached_nodes [protected, inherited]

An array of the node locations on the last element we computed on

Definition at line 473 of file fe.h.

bool libMesh::FEAbstract::calculate_curl_phi [mutable, protected, inherited]

Should we calculate shape function curls?

Definition at line 541 of file fe_abstract.h.

Referenced by libMesh::FEGenericBase< OutputType >::compute_shape_functions(), libMesh::FEGenericBase< Real >::get_curl_phi(), and libMesh::FE< Dim, T >::init_shape_functions().

bool libMesh::FEAbstract::calculate_d2phi [mutable, protected, inherited]

Should we calculate shape function hessians?

Definition at line 536 of file fe_abstract.h.

bool libMesh::FEAbstract::calculate_div_phi [mutable, protected, inherited]

Should we calculate shape function divergences?

Definition at line 546 of file fe_abstract.h.

Referenced by libMesh::FEGenericBase< OutputType >::compute_shape_functions(), libMesh::FEGenericBase< Real >::get_div_phi(), and libMesh::FE< Dim, T >::init_shape_functions().

bool libMesh::FEAbstract::calculate_dphi [mutable, protected, inherited]

Should we calculate shape function gradients?

Definition at line 531 of file fe_abstract.h.

Referenced by libMesh::FEXYZ< Dim >::compute_shape_functions(), libMesh::FEGenericBase< OutputType >::compute_shape_functions(), libMesh::FEGenericBase< Real >::get_dphi(), libMesh::FEGenericBase< Real >::get_dphidx(), libMesh::FEGenericBase< Real >::get_dphidy(), libMesh::FEGenericBase< Real >::get_dphidz(), libMesh::FE< Dim, T >::init_base_shape_functions(), libMesh::FEXYZ< Dim >::init_shape_functions(), and libMesh::FE< Dim, T >::init_shape_functions().

bool libMesh::FEAbstract::calculate_dphiref [mutable, protected, inherited]

Should we calculate reference shape function gradients?

Definition at line 551 of file fe_abstract.h.

bool libMesh::FEAbstract::calculate_phi [mutable, protected, inherited]

Should we calculate shape functions?

Definition at line 526 of file fe_abstract.h.

Referenced by libMesh::FEXYZ< Dim >::compute_shape_functions(), libMesh::FEGenericBase< OutputType >::compute_shape_functions(), libMesh::FEGenericBase< Real >::get_phi(), libMesh::FE< Dim, T >::init_base_shape_functions(), libMesh::FEXYZ< Dim >::init_shape_functions(), and libMesh::FE< Dim, T >::init_shape_functions().

bool libMesh::FEAbstract::calculations_started [mutable, protected, inherited]

Have calculations with this object already been started? Then all get_* functions should already have been called.

Definition at line 521 of file fe_abstract.h.

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::curl_phi [protected, inherited]

Shape function curl values. Only defined for vector types.

Definition at line 517 of file fe_base.h.

Referenced by libMesh::FE< Dim, T >::init_shape_functions().

std::vector<std::vector<OutputTensor> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phi [protected, inherited]

Shape function second derivative values.

Definition at line 560 of file fe_base.h.

Referenced by libMesh::FEXYZ< Dim >::compute_shape_functions(), libMesh::FEXYZ< Dim >::init_shape_functions(), and libMesh::FE< Dim, T >::init_shape_functions().

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phideta2 [protected, inherited]

Shape function second derivatives in the eta direction.

Definition at line 580 of file fe_base.h.

Referenced by libMesh::FE< Dim, T >::init_shape_functions().

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidetadzeta [protected, inherited]

Shape function second derivatives in the eta-zeta direction.

Definition at line 585 of file fe_base.h.

Referenced by libMesh::FE< Dim, T >::init_shape_functions().

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidx2 [protected, inherited]

Shape function second derivatives in the x direction.

Definition at line 595 of file fe_base.h.

Referenced by libMesh::FEXYZ< Dim >::compute_shape_functions(), libMesh::FEXYZ< Dim >::init_shape_functions(), and libMesh::FE< Dim, T >::init_shape_functions().

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidxdy [protected, inherited]

Shape function second derivatives in the x-y direction.

Definition at line 600 of file fe_base.h.

Referenced by libMesh::FEXYZ< Dim >::compute_shape_functions(), libMesh::FEXYZ< Dim >::init_shape_functions(), and libMesh::FE< Dim, T >::init_shape_functions().

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidxdz [protected, inherited]

Shape function second derivatives in the x-z direction.

Definition at line 605 of file fe_base.h.

Referenced by libMesh::FEXYZ< Dim >::compute_shape_functions(), libMesh::FEXYZ< Dim >::init_shape_functions(), and libMesh::FE< Dim, T >::init_shape_functions().

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidxi2 [protected, inherited]

Shape function second derivatives in the xi direction.

Definition at line 565 of file fe_base.h.

Referenced by libMesh::FEXYZ< Dim >::init_shape_functions(), and libMesh::FE< Dim, T >::init_shape_functions().

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidxideta [protected, inherited]

Shape function second derivatives in the xi-eta direction.

Definition at line 570 of file fe_base.h.

Referenced by libMesh::FE< Dim, T >::init_shape_functions().

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidxidzeta [protected, inherited]

Shape function second derivatives in the xi-zeta direction.

Definition at line 575 of file fe_base.h.

Referenced by libMesh::FE< Dim, T >::init_shape_functions().

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidy2 [protected, inherited]

Shape function second derivatives in the y direction.

Definition at line 610 of file fe_base.h.

Referenced by libMesh::FEXYZ< Dim >::compute_shape_functions(), libMesh::FEXYZ< Dim >::init_shape_functions(), and libMesh::FE< Dim, T >::init_shape_functions().

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidydz [protected, inherited]

Shape function second derivatives in the y-z direction.

Definition at line 615 of file fe_base.h.

Referenced by libMesh::FEXYZ< Dim >::compute_shape_functions(), libMesh::FEXYZ< Dim >::init_shape_functions(), and libMesh::FE< Dim, T >::init_shape_functions().

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidz2 [protected, inherited]

Shape function second derivatives in the z direction.

Definition at line 620 of file fe_base.h.

Referenced by libMesh::FEXYZ< Dim >::compute_shape_functions(), libMesh::FEXYZ< Dim >::init_shape_functions(), and libMesh::FE< Dim, T >::init_shape_functions().

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidzeta2 [protected, inherited]

Shape function second derivatives in the zeta direction.

Definition at line 590 of file fe_base.h.

Referenced by libMesh::FE< Dim, T >::init_shape_functions().

const unsigned int libMesh::FEAbstract::dim [protected, inherited]

The dimensionality of the object

Definition at line 515 of file fe_abstract.h.

Referenced by libMesh::FEGenericBase< OutputType >::coarsened_dof_values(), libMesh::FEXYZ< Dim >::compute_face_values(), libMesh::InfFE< Dim, T_radial, T_map >::compute_shape_functions(), libMesh::FEXYZ< Dim >::compute_shape_functions(), libMesh::FEGenericBase< OutputType >::compute_shape_functions(), libMesh::InfFE< Dim, T_radial, T_map >::reinit(), and libMesh::FE< Dim, T >::reinit().

std::vector<std::vector<OutputDivergence> > libMesh::FEGenericBase< FEOutputType< T >::type >::div_phi [protected, inherited]

Shape function divergence values. Only defined for vector types.

Definition at line 522 of file fe_base.h.

Referenced by libMesh::FE< Dim, T >::init_shape_functions().

std::vector<OutputGradient> libMesh::FEGenericBase< FEOutputType< T >::type >::dphase [protected, inherited]

Used for certain infinite element families: the first derivatives of the phase term in global coordinates, over all quadrature points.

Definition at line 638 of file fe_base.h.

Referenced by libMesh::FEXYZ< Dim >::init_shape_functions(), and libMesh::FE< Dim, T >::init_shape_functions().

std::vector<std::vector<OutputGradient> > libMesh::FEGenericBase< FEOutputType< T >::type >::dphi [protected, inherited]

Shape function derivative values.

Definition at line 512 of file fe_base.h.

Referenced by libMesh::FEXYZ< Dim >::compute_face_values(), libMesh::FEXYZ< Dim >::compute_shape_functions(), libMesh::FEXYZ< Dim >::init_shape_functions(), and libMesh::FE< Dim, T >::init_shape_functions().

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::dphideta [protected, inherited]

Shape function derivatives in the eta direction.

Definition at line 532 of file fe_base.h.

Referenced by libMesh::FE< Dim, T >::init_shape_functions().

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::dphidx [protected, inherited]

Shape function derivatives in the x direction.

Definition at line 542 of file fe_base.h.

Referenced by libMesh::FEXYZ< Dim >::compute_face_values(), libMesh::FEXYZ< Dim >::compute_shape_functions(), libMesh::FEXYZ< Dim >::init_shape_functions(), and libMesh::FE< Dim, T >::init_shape_functions().

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::dphidxi [protected, inherited]

Shape function derivatives in the xi direction.

Definition at line 527 of file fe_base.h.

Referenced by libMesh::FE< Dim, T >::init_shape_functions().

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::dphidy [protected, inherited]

Shape function derivatives in the y direction.

Definition at line 547 of file fe_base.h.

Referenced by libMesh::FEXYZ< Dim >::compute_face_values(), libMesh::FEXYZ< Dim >::compute_shape_functions(), libMesh::FEXYZ< Dim >::init_shape_functions(), and libMesh::FE< Dim, T >::init_shape_functions().

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::dphidz [protected, inherited]

Shape function derivatives in the z direction.

Definition at line 552 of file fe_base.h.

Referenced by libMesh::FEXYZ< Dim >::compute_face_values(), libMesh::FEXYZ< Dim >::compute_shape_functions(), libMesh::FEXYZ< Dim >::init_shape_functions(), and libMesh::FE< Dim, T >::init_shape_functions().

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::dphidzeta [protected, inherited]

Shape function derivatives in the zeta direction.

Definition at line 537 of file fe_base.h.

Referenced by libMesh::FE< Dim, T >::init_shape_functions().

std::vector<RealGradient> libMesh::FEGenericBase< FEOutputType< T >::type >::dweight [protected, inherited]

Used for certain infinite element families: the global derivative of the additional radial weight $1/{r^2}$ , over all quadrature points.

Definition at line 645 of file fe_base.h.

Referenced by libMesh::FEXYZ< Dim >::init_shape_functions(), and libMesh::FE< Dim, T >::init_shape_functions().

ElemType libMesh::FEAbstract::elem_type [protected, inherited]

The element type the current data structures are set up for.

Definition at line 564 of file fe_abstract.h.

Referenced by libMesh::FE< Dim, T >::attach_quadrature_rule(), libMesh::FEGenericBase< OutputType >::coarsened_dof_values(), libMesh::FE< Dim, T >::edge_reinit(), libMesh::FEAbstract::get_type(), libMesh::FE< Dim, T >::init_base_shape_functions(), libMesh::FE< Dim, T >::n_shape_functions(), libMesh::InfFE< Dim, T_radial, T_map >::reinit(), libMesh::FEXYZ< Dim >::reinit(), libMesh::FE< Dim, T >::reinit(), and libMesh::FE< Dim, T >::side_map().

const FEType libMesh::FEAbstract::fe_type [protected, inherited]

The finite element type for this object. Note that this should be constant for the object.

Definition at line 558 of file fe_abstract.h.

Referenced by libMesh::InfFE< Dim, T_radial, T_map >::attach_quadrature_rule(), libMesh::FEGenericBase< OutputType >::coarsened_dof_values(), libMesh::InfFE< Dim, T_radial, T_map >::combine_base_radial(), libMesh::FEXYZ< Dim >::compute_face_values(), libMesh::FEAbstract::compute_node_constraints(), libMesh::FEAbstract::compute_periodic_node_constraints(), libMesh::FEXYZ< Dim >::compute_shape_functions(), libMesh::FEAbstract::get_family(), libMesh::FEAbstract::get_fe_type(), libMesh::FEAbstract::get_order(), libMesh::InfFE< Dim, T_radial, T_map >::InfFE(), libMesh::InfFE< Dim, T_radial, T_map >::init_face_shape_functions(), libMesh::InfFE< Dim, T_radial, T_map >::init_shape_functions(), libMesh::FE< Dim, T >::init_shape_functions(), libMesh::FE< Dim, T >::n_shape_functions(), and libMesh::InfFE< Dim, T_radial, T_map >::reinit().

unsigned int libMesh::FE< Dim, T >::last_edge [protected, inherited]

Definition at line 480 of file fe.h.

ElemType libMesh::FE< Dim, T >::last_side [protected, inherited]

The last side and last edge we did a reinit on

Definition at line 478 of file fe.h.

std::vector<std::vector<OutputShape> > libMesh::FEGenericBase< FEOutputType< T >::type >::phi [protected, inherited]

Shape function values.

Definition at line 507 of file fe_base.h.

Referenced by libMesh::FEXYZ< Dim >::compute_face_values(), libMesh::FEXYZ< Dim >::compute_shape_functions(), libMesh::FEXYZ< Dim >::init_shape_functions(), and libMesh::FE< Dim, T >::init_shape_functions().

QBase* libMesh::FEAbstract::qrule [protected, inherited]

A pointer to the quadrature rule employed

Definition at line 575 of file fe_abstract.h.

Referenced by libMesh::InfFE< Dim, T_radial, T_map >::attach_quadrature_rule(), libMesh::FE< Dim, T >::attach_quadrature_rule(), libMesh::FEGenericBase< OutputType >::coarsened_dof_values(), libMesh::FE< Dim, T >::edge_reinit(), libMesh::InfFE< Dim, T_radial, T_map >::init_face_shape_functions(), libMesh::FE< Dim, T >::n_quadrature_points(), libMesh::InfFE< Dim, T_radial, T_map >::reinit(), libMesh::FEXYZ< Dim >::reinit(), and libMesh::FE< Dim, T >::reinit().

bool libMesh::FEAbstract::shapes_on_quadrature [protected, inherited]

A flag indicating if current data structures correspond to quadrature rule points

Definition at line 581 of file fe_abstract.h.

Referenced by libMesh::FE< Dim, T >::edge_reinit(), libMesh::FEXYZ< Dim >::reinit(), libMesh::FE< Dim, T >::reinit(), and libMesh::FE< Dim, T >::side_map().

std::vector<Real> libMesh::FEGenericBase< FEOutputType< T >::type >::weight [protected, inherited]

Used for certain infinite element families: the additional radial weight $1/{r^2}$ in local coordinates, over all quadrature points.

Definition at line 652 of file fe_base.h.

Referenced by libMesh::FEXYZ< Dim >::init_shape_functions(), and libMesh::FE< Dim, T >::init_shape_functions().

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

fe.h

libMesh::FEL2Lagrange< Dim > Class Template Reference

Public Types

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Static Protected Attributes

Friends

Detailed Description

template<unsigned int Dim> class libMesh::FEL2Lagrange< Dim >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation

template<unsigned int Dim>
class libMesh::FEL2Lagrange< Dim >