Hi, Folks --
I need FE::reinit() to work at arbitrary locations for the side version
of reinit(). Attached is a patch that adds this functionality for both
the side version of reinit() and for edge_reinit(). I wasn't completely
sure what to do for the InfFE case for the side case, so in the patch,
if someone calls the side version of reinit or edge_reinit, an error
message is printed and libmesh_error is called.
I also anticipate eventually wanting to be able to supply both positions
and quadrature weights, so I also added an optional weights argument to
all of the reinit functions. If the user specifies points but not
weights, then the patch reverts to using the same dummy weights as usual
(all 1's).
-- Boyce
Index: include/fe/fe.h
===================================================================
--- include/fe/fe.h (revision 4359)
+++ include/fe/fe.h (working copy)
@@ -300,25 +300,38 @@
* argument \p pts.
*/
virtual void reinit (const Elem* elem,
- const std::vector<Point>* const pts = NULL);
+ const std::vector<Point>* const pts = NULL,
+ const std::vector<Real>* const weights = NULL);
/**
* Reinitializes all the physical element-dependent data based on
* the \p side of \p face. The \p tolerance paremeter is passed to
- * the involved call to \p inverse_map().
+ * the involved call to \p inverse_map(). By default the shape
+ * functions and associated data are computed at the quadrature
+ * points specified by the quadrature rule \p qrule, but may be any
+ * points specified on the reference \em side element specified in
+ * the optional argument \p pts.
*/
virtual void reinit (const Elem* elem,
const unsigned int side,
- const Real tolerance = TOLERANCE);
+ const Real tolerance = TOLERANCE,
+ const std::vector<Point>* const pts = NULL,
+ const std::vector<Real>* const weights = NULL);
/**
* Reinitializes all the physical element-dependent data based on
* the \p edge. The \p tolerance paremeter is passed to the
- * involved call to \p inverse_map().
+ * involved call to \p inverse_map(). By default the shape
+ * functions and associated data are computed at the quadrature
+ * points specified by the quadrature rule \p qrule, but may be any
+ * points specified on the reference \em side element specified in
+ * the optional argument \p pts.
*/
virtual void edge_reinit (const Elem* elem,
const unsigned int edge,
- const Real tolerance = TOLERANCE);
+ const Real tolerance = TOLERANCE,
+ const std::vector<Point>* const pts = NULL,
+ const std::vector<Real>* const weights = NULL);
/**
* Provides the class with the quadrature rule, which provides the
Index: include/fe/fe_base.h
===================================================================
--- include/fe/fe_base.h (revision 4359)
+++ include/fe/fe_base.h (working copy)
@@ -131,7 +131,7 @@
* This is at the core of this class. Use this for each
* new element in the mesh. Reinitializes the requested physical
* element-dependent data based on the current element
- * \p elem. By default the element data computed at the quadrature
+ * \p elem. By default the element data are computed at the quadrature
* points specified by the quadrature rule \p qrule, but any set
* of points on the reference element may be specified in the optional
* argument \p pts.
@@ -142,25 +142,36 @@
* \p reinit().
*/
virtual void reinit (const Elem* elem,
- const std::vector<Point>* const pts = NULL) = 0;
+ const std::vector<Point>* const pts = NULL,
+ const std::vector<Real>* const weights = NULL) = 0;
/**
* Reinitializes all the physical element-dependent data based on
* the \p side of the element \p elem. The \p tolerance paremeter
- * is passed to the involved call to \p inverse_map().
+ * is passed to the involved call to \p inverse_map(). By default the
+ * element data are computed at the quadrature points specified by the
+ * quadrature rule \p qrule, but any set of points on the reference
+ * \em side element may be specified in the optional argument \p pts.
*/
virtual void reinit (const Elem* elem,
const unsigned int side,
- const Real tolerance = TOLERANCE) = 0;
+ const Real tolerance = TOLERANCE,
+ const std::vector<Point>* const pts = NULL,
+ const std::vector<Real>* const weights = NULL) = 0;
/**
* Reinitializes all the physical element-dependent data based on
* the \p edge of the element \p elem. The \p tolerance paremeter
- * is passed to the involved call to \p inverse_map().
+ * is passed to the involved call to \p inverse_map(). By default the
+ * element data are computed at the quadrature points specified by the
+ * quadrature rule \p qrule, but any set of points on the reference
+ * \em edge element may be specified in the optional argument \p pts.
*/
virtual void edge_reinit (const Elem* elem,
const unsigned int edge,
- const Real tolerance = TOLERANCE) = 0;
+ const Real tolerance = TOLERANCE,
+ const std::vector<Point>* pts = NULL,
+ const std::vector<Real>* weights = NULL) = 0;
/**
* @returns true if the point p is located on the reference element
Index: include/fe/inf_fe.h
===================================================================
--- include/fe/inf_fe.h (revision 4359)
+++ include/fe/inf_fe.h (working copy)
@@ -405,7 +405,8 @@
* \p elem.
*/
virtual void reinit (const Elem* elem,
- const std::vector<Point>* const pts);
+ const std::vector<Point>* const pts = NULL,
+ const std::vector<Real>* const weights = NULL);
/**
* Not implemented yet. Reinitializes all the physical
@@ -414,7 +415,9 @@
*/
virtual void reinit (const Elem* elem,
const unsigned int side,
- const Real tolerance = TOLERANCE);
+ const Real tolerance = TOLERANCE,
+ const std::vector<Point>* const pts = NULL,
+ const std::vector<Real>* const weights = NULL);
/**
* Not implemented yet. Reinitializes all the physical
@@ -423,7 +426,9 @@
*/
virtual void edge_reinit (const Elem* elem,
const unsigned int edge,
- const Real tolerance = TOLERANCE);
+ const Real tolerance = TOLERANCE,
+ const std::vector<Point>* const pts = NULL,
+ const std::vector<Real>* const weights = NULL);
/**
* The use of quadrature rules with the \p InfFE class is somewhat
Index: src/fe/inf_fe.C
===================================================================
--- src/fe/inf_fe.C (revision 4359)
+++ src/fe/inf_fe.C (working copy)
@@ -158,7 +158,8 @@
template <unsigned int Dim, FEFamily T_radial, InfMapType T_map>
void InfFE<Dim,T_radial,T_map>::reinit(const Elem* inf_elem,
- const std::vector<Point>* const pts)
+ const std::vector<Point>* const pts,
+ const std::vector<Real>* const weights)
{
libmesh_assert (base_fe != NULL);
libmesh_assert (base_fe->qrule != NULL);
@@ -268,11 +269,17 @@
// combine the base and radial shapes
this->combine_base_radial (inf_elem);
- // dummy weights
- std::vector<Real> dummy_weights (pts->size(), 1.);
+ // weights
+ if (weights != NULL)
+ {
+ this->compute_map (*weights, inf_elem);
+ }
+ else
+ {
+ std::vector<Real> dummy_weights (pts->size(), 1.);
+ this->compute_map (dummy_weights, inf_elem);
+ }
- this->compute_map (dummy_weights, inf_elem);
-
// finally compute the ifem shapes
this->compute_shape_functions (inf_elem);
}
Index: src/fe/inf_fe_boundary.C
===================================================================
--- src/fe/inf_fe_boundary.C (revision 4359)
+++ src/fe/inf_fe_boundary.C (working copy)
@@ -41,8 +41,17 @@
template <unsigned int Dim, FEFamily T_radial, InfMapType T_base>
void InfFE<Dim,T_radial,T_base>::reinit(const Elem* inf_elem,
const unsigned int s,
- const Real tolerance)
+ const Real tolerance,
+ const std::vector<Point>* const pts,
+ const std::vector<Real>* const weights)
{
+ if (pts != NULL)
+ {
+ libMesh::err << "ERROR: User-specified points for infinite elements "
+ << "not implemented!" << std::endl;
+ libmesh_error();
+ }
+
// We don't do this for 1D elements!
libmesh_assert (Dim != 1);
@@ -101,7 +110,9 @@
template <unsigned int Dim, FEFamily T_radial, InfMapType T_base>
void InfFE<Dim,T_radial,T_base>::edge_reinit(const Elem*,
const unsigned int,
- const Real)
+ const Real,
+ const std::vector<Point>* const
pts,
+ const std::vector<Real>* const
weights)
{
// We don't do this for 1D elements!
//libmesh_assert (Dim != 1);
@@ -109,6 +120,13 @@
libMesh::err << "ERROR: Edge conditions for infinite elements "
<< "not implemented!" << std::endl;
libmesh_error();
+
+ if (pts != NULL)
+ {
+ libMesh::err << "ERROR: User-specified points for infinite elements "
+ << "not implemented!" << std::endl;
+ libmesh_error();
+ }
}
@@ -275,12 +293,12 @@
//#include "inf_fe_instantiate_1D.h"
//#include "inf_fe_instantiate_2D.h"
//#include "inf_fe_instantiate_3D.h"
-INSTANTIATE_INF_FE_MBRF(1,CARTESIAN,void,reinit(const Elem*,const unsigned
int, const Real));
-INSTANTIATE_INF_FE_MBRF(2,CARTESIAN,void,reinit(const Elem*,const unsigned
int, const Real));
-INSTANTIATE_INF_FE_MBRF(3,CARTESIAN,void,reinit(const Elem*,const unsigned
int, const Real));
-INSTANTIATE_INF_FE_MBRF(1,CARTESIAN,void,edge_reinit(const Elem*,const
unsigned int, const Real));
-INSTANTIATE_INF_FE_MBRF(2,CARTESIAN,void,edge_reinit(const Elem*,const
unsigned int, const Real));
-INSTANTIATE_INF_FE_MBRF(3,CARTESIAN,void,edge_reinit(const Elem*,const
unsigned int, const Real));
+INSTANTIATE_INF_FE_MBRF(1,CARTESIAN,void,reinit(const Elem*,const unsigned
int, const Real, const std::vector<Point>* const, const std::vector<Real>*
const));
+INSTANTIATE_INF_FE_MBRF(2,CARTESIAN,void,reinit(const Elem*,const unsigned
int, const Real, const std::vector<Point>* const, const std::vector<Real>*
const));
+INSTANTIATE_INF_FE_MBRF(3,CARTESIAN,void,reinit(const Elem*,const unsigned
int, const Real, const std::vector<Point>* const, const std::vector<Real>*
const));
+INSTANTIATE_INF_FE_MBRF(1,CARTESIAN,void,edge_reinit(const Elem*,const
unsigned int, const Real, const std::vector<Point>* const, const
std::vector<Real>* const));
+INSTANTIATE_INF_FE_MBRF(2,CARTESIAN,void,edge_reinit(const Elem*,const
unsigned int, const Real, const std::vector<Point>* const, const
std::vector<Real>* const));
+INSTANTIATE_INF_FE_MBRF(3,CARTESIAN,void,edge_reinit(const Elem*,const
unsigned int, const Real, const std::vector<Point>* const, const
std::vector<Real>* const));
INSTANTIATE_INF_FE_MBRF(1,CARTESIAN,void,init_face_shape_functions(const
std::vector<Point>&,const Elem*));
INSTANTIATE_INF_FE_MBRF(2,CARTESIAN,void,init_face_shape_functions(const
std::vector<Point>&,const Elem*));
INSTANTIATE_INF_FE_MBRF(3,CARTESIAN,void,init_face_shape_functions(const
std::vector<Point>&,const Elem*));
Index: src/fe/fe.C
===================================================================
--- src/fe/fe.C (revision 4359)
+++ src/fe/fe.C (working copy)
@@ -114,7 +114,8 @@
template <unsigned int Dim, FEFamily T>
void FE<Dim,T>::reinit(const Elem* elem,
- const std::vector<Point>* const pts)
+ const std::vector<Point>* const pts,
+ const std::vector<Real>* const weights)
{
libmesh_assert (elem != NULL);
@@ -206,9 +207,15 @@
// different types of maps
if (pts != NULL)
{
- std::vector<Real> dummy_weights (pts->size(), 1.);
-
- this->compute_map (dummy_weights, elem);
+ if (weights != NULL)
+ {
+ this->compute_map (*weights, elem);
+ }
+ else
+ {
+ std::vector<Real> dummy_weights (pts->size(), 1.);
+ this->compute_map (dummy_weights, elem);
+ }
}
else
{
Index: src/fe/fe_boundary.C
===================================================================
--- src/fe/fe_boundary.C (revision 4359)
+++ src/fe/fe_boundary.C (working copy)
@@ -39,7 +39,9 @@
template <> \
void FE<_dim,_type>::_func(const Elem*, \
const unsigned int, \
- const Real) \
+ const Real, \
+ const std::vector<Point>* const, \
+ const std::vector<Real>* const) \
{ \
libMesh::err << "ERROR: This method makes no sense for low-D elements!" \
<< std::endl; \
@@ -85,50 +87,87 @@
template <unsigned int Dim, FEFamily T>
void FE<Dim,T>::reinit(const Elem* elem,
const unsigned int s,
- const Real tolerance)
+ const Real tolerance,
+ const std::vector<Point>* const pts,
+ const std::vector<Real>* const weights)
{
libmesh_assert (elem != NULL);
- libmesh_assert (qrule != NULL);
+ libmesh_assert (qrule != NULL || pts != NULL);
// We now do this for 1D elements!
// libmesh_assert (Dim != 1);
// Build the side of interest
const AutoPtr<Elem> side(elem->build_side(s));
-
// Find the max p_level to select
// the right quadrature rule for side integration
unsigned int side_p_level = elem->p_level();
if (elem->neighbor(s) != NULL)
- side_p_level = std::max(side_p_level, elem->neighbor(s)->p_level());
-
- // initialize quadrature rule
- qrule->init(side->type(), side_p_level);
+ side_p_level = std::max(side_p_level, elem->neighbor(s)->p_level());
- // FIXME - could this break if the same FE object was used
- // for both volume and face integrals? - RHS
- // We might not need to reinitialize the shape functions
- if ((this->get_type() != elem->type()) ||
- (s != last_side) ||
- (this->get_p_level() != side_p_level) ||
- this->shapes_need_reinit())
+ // Initialize the shape functions at the user-specified
+ // points
+ if (pts != NULL)
{
// Set the element type
elem_type = elem->type();
// Set the last_side
- last_side = s;
+ last_side = std::numeric_limits<unsigned int>::max();
// Set the last p level
_p_level = side_p_level;
-
+
// Initialize the face shape functions
- this->init_face_shape_functions (qrule->get_points(), side.get());
+ this->init_face_shape_functions (*pts, side.get());
+
+ // Compute the Jacobian*Weight on the face for integration
+ if (weights != NULL)
+ {
+ this->compute_face_map (*weights, side.get());
+ }
+ else
+ {
+ std::vector<Real> dummy_weights (pts->size(), 1.);
+ this->compute_face_map (dummy_weights, side.get());
+ }
}
-
- // Compute the Jacobian*Weight on the face for integration
- this->compute_face_map (qrule->get_weights(), side.get());
+ // If there are no user specified points, we use the
+ // quadrature rule
+ else
+ {
+ // initialize quadrature rule
+ if (pts != NULL) qrule->init(side->type(), side_p_level);
+ // FIXME - could this break if the same FE object was used
+ // for both volume and face integrals? - RHS
+ // We might not need to reinitialize the shape functions
+ if ((this->get_type() != elem->type()) ||
+ (s != last_side) ||
+ (this->get_p_level() != side_p_level) ||
+ this->shapes_need_reinit() ||
+ !shapes_on_quadrature)
+ {
+ // Set the element type
+ elem_type = elem->type();
+
+ // Set the last_side
+ last_side = s;
+
+ // Set the last p level
+ _p_level = side_p_level;
+
+ // Initialize the face shape functions
+ this->init_face_shape_functions (qrule->get_points(), side.get());
+ }
+
+ // Compute the Jacobian*Weight on the face for integration
+ this->compute_face_map (qrule->get_weights(), side.get());
+
+ // The shape functions correspond to the qrule
+ shapes_on_quadrature = true;
+ }
+
// make a copy of the Jacobian for integration
const std::vector<Real> JxW_int(JxW);
@@ -139,7 +178,10 @@
// compute the shape function and derivative values
// at the points qp
this->reinit (elem, &qp);
-
+
+ // The shape functions correspond to the qrule
+ shapes_on_quadrature = (qrule != NULL);
+
// copy back old data
JxW = JxW_int;
}
@@ -149,36 +191,68 @@
template <unsigned int Dim, FEFamily T>
void FE<Dim,T>::edge_reinit(const Elem* elem,
const unsigned int e,
- const Real tolerance)
+ const Real tolerance,
+ const std::vector<Point>* const pts,
+ const std::vector<Real>* const weights)
{
libmesh_assert (elem != NULL);
- libmesh_assert (qrule != NULL);
+ libmesh_assert (qrule != NULL || pts != NULL);
// We don't do this for 1D elements!
libmesh_assert (Dim != 1);
// Build the side of interest
const AutoPtr<Elem> edge(elem->build_edge(e));
- // initialize quadrature rule
- qrule->init(edge->type(), elem->p_level());
-
- // We might not need to reinitialize the shape functions
- if ((this->get_type() != elem->type()) ||
- (e != last_edge) ||
- this->shapes_need_reinit())
+ // Initialize the shape functions at the user-specified
+ // points
+ if (pts != NULL)
{
// Set the element type
elem_type = elem->type();
// Set the last_edge
- last_edge = e;
+ last_edge = std::numeric_limits<unsigned int>::max();
// Initialize the edge shape functions
- this->init_edge_shape_functions (qrule->get_points(), edge.get());
+ this->init_edge_shape_functions (*pts, edge.get());
+
+ // Compute the Jacobian*Weight on the face for integration
+ if (weights != NULL)
+ {
+ this->compute_edge_map (*weights, edge.get());
+ }
+ else
+ {
+ std::vector<Real> dummy_weights (pts->size(), 1.);
+ this->compute_edge_map (dummy_weights, edge.get());
+ }
}
+ // If there are no user specified points, we use the
+ // quadrature rule
+ else
+ {
+ // initialize quadrature rule
+ qrule->init(edge->type(), elem->p_level());
+
+ // We might not need to reinitialize the shape functions
+ if ((this->get_type() != elem->type()) ||
+ (e != last_edge) ||
+ this->shapes_need_reinit() ||
+ !shapes_on_quadrature)
+ {
+ // Set the element type
+ elem_type = elem->type();
+
+ // Set the last_edge
+ last_edge = e;
+
+ // Initialize the edge shape functions
+ this->init_edge_shape_functions (qrule->get_points(), edge.get());
+ }
- // Compute the Jacobian*Weight on the face for integration
- this->compute_edge_map (qrule->get_weights(), edge.get());
+ // Compute the Jacobian*Weight on the face for integration
+ this->compute_edge_map (qrule->get_weights(), edge.get());
+ }
// make a copy of the Jacobian for integration
const std::vector<Real> JxW_int(JxW);
@@ -190,7 +264,10 @@
// compute the shape function and derivative values
// at the points qp
this->reinit (elem, &qp);
-
+
+ // The shape functions correspond to the qrule
+ shapes_on_quadrature = (qrule != NULL);
+
// copy back old data
JxW = JxW_int;
}
@@ -706,62 +783,62 @@
//--------------------------------------------------------------
// Explicit instantiations
-template void FE<1,LAGRANGE>::reinit(Elem const*, unsigned int, Real);
-template void FE<1,HIERARCHIC>::reinit(Elem const*, unsigned int, Real);
-template void FE<1,CLOUGH>::reinit(Elem const*, unsigned int, Real);
-template void FE<1,HERMITE>::reinit(Elem const*, unsigned int, Real);
-template void FE<1,MONOMIAL>::reinit(Elem const*, unsigned int, Real);
-template void FE<1,SCALAR>::reinit(Elem const*, unsigned int, Real);
+template void FE<1,LAGRANGE>::reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<1,HIERARCHIC>::reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<1,CLOUGH>::reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<1,HERMITE>::reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<1,MONOMIAL>::reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<1,SCALAR>::reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES
-template void FE<1,BERNSTEIN>::reinit(Elem const*, unsigned int, Real);
-template void FE<1,SZABAB>::reinit(Elem const*, unsigned int, Real);
+template void FE<1,BERNSTEIN>::reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<1,SZABAB>::reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
#endif
-template void FE<1,XYZ>::reinit(Elem const*, unsigned int, Real);
+template void FE<1,XYZ>::reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
-template void FE<2,LAGRANGE>::reinit(Elem const*, unsigned int, Real);
-template void FE<2,LAGRANGE>::edge_reinit(Elem const*, unsigned int, Real);
-template void FE<2,HIERARCHIC>::reinit(Elem const*, unsigned int, Real);
-template void FE<2,HIERARCHIC>::edge_reinit(Elem const*, unsigned int, Real);
-template void FE<2,CLOUGH>::reinit(Elem const*, unsigned int, Real);
-template void FE<2,CLOUGH>::edge_reinit(Elem const*, unsigned int, Real);
-template void FE<2,HERMITE>::reinit(Elem const*, unsigned int, Real);
-template void FE<2,HERMITE>::edge_reinit(Elem const*, unsigned int, Real);
-template void FE<2,MONOMIAL>::reinit(Elem const*, unsigned int, Real);
-template void FE<2,MONOMIAL>::edge_reinit(Elem const*, unsigned int, Real);
-template void FE<2,SCALAR>::reinit(Elem const*, unsigned int, Real);
-template void FE<2,SCALAR>::edge_reinit(Elem const*, unsigned int, Real);
+template void FE<2,LAGRANGE>::reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<2,LAGRANGE>::edge_reinit(Elem const*, unsigned int, Real,
const std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<2,HIERARCHIC>::reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<2,HIERARCHIC>::edge_reinit(Elem const*, unsigned int, Real,
const std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<2,CLOUGH>::reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<2,CLOUGH>::edge_reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<2,HERMITE>::reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<2,HERMITE>::edge_reinit(Elem const*, unsigned int, Real,
const std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<2,MONOMIAL>::reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<2,MONOMIAL>::edge_reinit(Elem const*, unsigned int, Real,
const std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<2,SCALAR>::reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<2,SCALAR>::edge_reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES
-template void FE<2,BERNSTEIN>::reinit(Elem const*, unsigned int, Real);
-template void FE<2,BERNSTEIN>::edge_reinit(Elem const*, unsigned int, Real);
-template void FE<2,SZABAB>::reinit(Elem const*, unsigned int, Real);
-template void FE<2,SZABAB>::edge_reinit(Elem const*, unsigned int, Real);
+template void FE<2,BERNSTEIN>::reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<2,BERNSTEIN>::edge_reinit(Elem const*, unsigned int, Real,
const std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<2,SZABAB>::reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<2,SZABAB>::edge_reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
#endif
-template void FE<2,XYZ>::reinit(Elem const*, unsigned int, Real);
-template void FE<2,XYZ>::edge_reinit(Elem const*, unsigned int, Real);
+template void FE<2,XYZ>::reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<2,XYZ>::edge_reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
// Intel 9.1 complained it needed this in devel mode.
template void FE<2,XYZ>::init_face_shape_functions(const std::vector<Point>&,
const Elem*);
-template void FE<3,LAGRANGE>::reinit(Elem const*, unsigned int, Real);
-template void FE<3,LAGRANGE>::edge_reinit(Elem const*, unsigned int, Real);
-template void FE<3,HIERARCHIC>::reinit(Elem const*, unsigned int, Real);
-template void FE<3,HIERARCHIC>::edge_reinit(Elem const*, unsigned int, Real);
-template void FE<3,CLOUGH>::reinit(Elem const*, unsigned int, Real);
-template void FE<3,CLOUGH>::edge_reinit(Elem const*, unsigned int, Real);
-template void FE<3,HERMITE>::reinit(Elem const*, unsigned int, Real);
-template void FE<3,HERMITE>::edge_reinit(Elem const*, unsigned int, Real);
-template void FE<3,MONOMIAL>::reinit(Elem const*, unsigned int, Real);
-template void FE<3,MONOMIAL>::edge_reinit(Elem const*, unsigned int, Real);
-template void FE<3,SCALAR>::reinit(Elem const*, unsigned int, Real);
-template void FE<3,SCALAR>::edge_reinit(Elem const*, unsigned int, Real);
+template void FE<3,LAGRANGE>::reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<3,LAGRANGE>::edge_reinit(Elem const*, unsigned int, Real,
const std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<3,HIERARCHIC>::reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<3,HIERARCHIC>::edge_reinit(Elem const*, unsigned int, Real,
const std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<3,CLOUGH>::reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<3,CLOUGH>::edge_reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<3,HERMITE>::reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<3,HERMITE>::edge_reinit(Elem const*, unsigned int, Real,
const std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<3,MONOMIAL>::reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<3,MONOMIAL>::edge_reinit(Elem const*, unsigned int, Real,
const std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<3,SCALAR>::reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<3,SCALAR>::edge_reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
#ifdef LIBMESH_ENABLE_HIGHER_ORDER_SHAPES
-template void FE<3,BERNSTEIN>::reinit(Elem const*, unsigned int, Real);
-template void FE<3,BERNSTEIN>::edge_reinit(Elem const*, unsigned int, Real);
-template void FE<3,SZABAB>::reinit(Elem const*, unsigned int, Real);
-template void FE<3,SZABAB>::edge_reinit(Elem const*, unsigned int, Real);
+template void FE<3,BERNSTEIN>::reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<3,BERNSTEIN>::edge_reinit(Elem const*, unsigned int, Real,
const std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<3,SZABAB>::reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<3,SZABAB>::edge_reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
#endif
-template void FE<3,XYZ>::reinit(Elem const*, unsigned int, Real);
-template void FE<3,XYZ>::edge_reinit(Elem const*, unsigned int, Real);
+template void FE<3,XYZ>::reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
+template void FE<3,XYZ>::edge_reinit(Elem const*, unsigned int, Real, const
std::vector<Point>* const, const std::vector<Real>* const);
// Intel 9.1 complained it needed this in devel mode.
template void FE<3,XYZ>::init_face_shape_functions(const std::vector<Point>&,
const Elem*);
------------------------------------------------------------------------------
Benefiting from Server Virtualization: Beyond Initial Workload
Consolidation -- Increasing the use of server virtualization is a top
priority.Virtualization can reduce costs, simplify management, and improve
application availability and disaster protection. Learn more about boosting
the value of server virtualization. http://p.sf.net/sfu/vmware-sfdev2dev
_______________________________________________
Libmesh-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/libmesh-devel
