* The vector has to have the
* right size before being passed
* to this function. This
- * function is only callable for active
- * cells.
- */
- template <typename number>
- void get_dof_values (const Vector<number> &values,
- Vector<number> &local_values) const;
+ * function is only callable for
+ * active cells.
+ *
+ * The input vector may be either
+ * a #Vector<float>#,
+ * #Vector<double>#, or a
+ * #BlockVector<...,double>#. It
+ * is in the responsibility of
+ * the caller to assure that the
+ * types of the numbers stored in
+ * input and output vectors are
+ * compatible and with similar
+ * accuracy.
+ */
+ template <class InputVector, typename number>
+ void get_dof_values (const InputVector &values,
+ Vector<number> &local_values) const;
/**
* This function is the counterpart to
* The vector has to have the
* right size before being passed
* to this function.
- */
- template <typename number>
+ *
+ * The output vector may be either
+ * a #Vector<float>#,
+ * #Vector<double>#, or a
+ * #BlockVector<...,double>#. It
+ * is in the responsibility of
+ * the caller to assure that the
+ * types of the numbers stored in
+ * input and output vectors are
+ * compatible and with similar
+ * accuracy.
+ */
+ template <class OutputVector, typename number>
void set_dof_values (const Vector<number> &local_values,
- Vector<number> &values) const;
+ OutputVector &values) const;
/**
* Pointer to the #i#th line
* has the right size beforehand. This
* function is only callable for active
* cells.
- */
- template <typename number>
- void get_dof_values (const Vector<number> &values,
- Vector<number> &local_values) const;
+ *
+ * The input vector may be either
+ * a #Vector<float>#,
+ * #Vector<double>#, or a
+ * #BlockVector<...,double>#. It
+ * is in the responsibility of
+ * the caller to assure that the
+ * types of the numbers stored in
+ * input and output vectors are
+ * compatible and with similar
+ * accuracy.
+ */
+ template <class InputVector, typename number>
+ void get_dof_values (const InputVector &values,
+ Vector<number> &local_values) const;
/**
* This function is the counterpart to
*
* It is assumed that both vectors already
* have the right size beforehand.
- */
- template <typename number>
+ *
+ * The output vector may be either
+ * a #Vector<float>#,
+ * #Vector<double>#, or a
+ * #BlockVector<...,double>#. It
+ * is in the responsibility of
+ * the caller to assure that the
+ * types of the numbers stored in
+ * input and output vectors are
+ * compatible and with similar
+ * accuracy.
+ */
+ template <class OutputVector, typename number>
void set_dof_values (const Vector<number> &local_values,
- Vector<number> &values) const;
+ OutputVector &values) const;
/**
* Return the #i#th child as a DoF line
* has the right size beforehand. This
* function is only callable for active
* cells.
- */
- template <typename number>
- void get_dof_values (const Vector<number> &values,
- Vector<number> &local_values) const;
+ *
+ * The input vector may be either
+ * a #Vector<float>#,
+ * #Vector<double>#, or a
+ * #BlockVector<...,double>#. It
+ * is in the responsibility of
+ * the caller to assure that the
+ * types of the numbers stored in
+ * input and output vectors are
+ * compatible and with similar
+ * accuracy.
+ */
+ template <class InputVector, typename number>
+ void get_dof_values (const InputVector &values,
+ Vector<number> &local_values) const;
/**
* This function is the counterpart to
*
* It is assumed that both vectors already
* have the right size beforehand.
- */
- template <typename number>
+ *
+ * The output vector may be either
+ * a #Vector<float>#,
+ * #Vector<double>#, or a
+ * #BlockVector<...,double>#. It
+ * is in the responsibility of
+ * the caller to assure that the
+ * types of the numbers stored in
+ * input and output vectors are
+ * compatible and with similar
+ * accuracy.
+ */
+ template <class OutputVector, typename number>
void set_dof_values (const Vector<number> &local_values,
- Vector<number> &values) const;
+ OutputVector &values) const;
/**
* Return a pointer to the #i#th line
* has the right size beforehand. This
* function is only callable for active
* cells.
- */
- template <typename number>
- void get_dof_values (const Vector<number> &values,
- Vector<number> &local_values) const;
+ *
+ * The input vector may be either
+ * a #Vector<float>#,
+ * #Vector<double>#, or a
+ * #BlockVector<...,double>#. It
+ * is in the responsibility of
+ * the caller to assure that the
+ * types of the numbers stored in
+ * input and output vectors are
+ * compatible and with similar
+ * accuracy.
+ */
+ template <class InputVector, typename number>
+ void get_dof_values (const InputVector &values,
+ Vector<number> &local_values) const;
/**
* This function is the counterpart to
*
* It is assumed that both vectors already
* have the right size beforehand.
- */
- template <typename number>
+ *
+ * The output vector may be either
+ * a #Vector<float>#,
+ * #Vector<double>#, or a
+ * #BlockVector<...,double>#. It
+ * is in the responsibility of
+ * the caller to assure that the
+ * types of the numbers stored in
+ * input and output vectors are
+ * compatible and with similar
+ * accuracy.
+ */
+ template <class OutputVector, typename number>
void set_dof_values (const Vector<number> &local_values,
- Vector<number> &values) const;
+ OutputVector &values) const;
/**
* Return a pointer to the #i#th line
* cells by the finite element
* objects.
*/
- template <typename number>
- void get_interpolated_dof_values (const Vector<number> &values,
- Vector<number> &interpolated_values) const;
+ template <class InputVector, typename number>
+ void get_interpolated_dof_values (const InputVector &values,
+ Vector<number> &interpolated_values) const;
/**
* This, again, is the counterpart to
* presently only provided for
* cells by the finite element
* objects.
- */
- template <typename number>
+ *
+ * The output vector may be either
+ * a #Vector<float>#,
+ * #Vector<double>#, or a
+ * #BlockVector<...,double>#. It
+ * is in the responsibility of
+ * the caller to assure that the
+ * types of the numbers stored in
+ * input and output vectors are
+ * compatible and with similar
+ * accuracy.
+ */
+ template <class OutputVector, typename number>
void set_dof_values_by_interpolation (const Vector<number> &local_values,
- Vector<number> &values) const;
+ OutputVector &values) const;
/**
* Exception
*
* The function assumes that the
* #values# object already has the
- * right size.
+ * right size.
+ *
+ * The actual data type of the
+ * input vector may be either a
+ * #Vector<double>#,
+ * #Vector<float>#, or
+ * #BlockVector<double,...>#.
*/
- void get_function_values (const Vector<double> &fe_function,
- vector<double> &values) const;
+ template <class InputVector>
+ void get_function_values (const InputVector &fe_function,
+ vector<double> &values) const;
/**
- * Access to vector valued finite element functions.
+ * Access to vector valued finite
+ * element functions.
*
* This function does the same as
* the other #get_function_values#,
* but applied to multi-component
* elements.
- */
- void get_function_values (const Vector<double> &fe_function,
+ *
+ * The actual data type of the
+ * input vector may be either a
+ * #Vector<double>#,
+ * #Vector<float>#, or
+ * #BlockVector<double,...>#.
+ */
+ template <class InputVector>
+ void get_function_values (const InputVector &fe_function,
vector<Vector<double> > &values) const;
/**
* The function assumes that the
* #gradients# object already has the
* right size.
- */
- void get_function_grads (const Vector<double> &fe_function,
+ *
+ * The actual data type of the
+ * input vector may be either a
+ * #Vector<double>#,
+ * #Vector<float>#, or
+ * #BlockVector<double,...>#.
+ */
+ template <class InputVector>
+ void get_function_grads (const InputVector &fe_function,
vector<Tensor<1,dim> > &gradients) const;
/**
* the other #get_function_values#,
* but applied to multi-component
* elements.
- */
- void get_function_grads (const Vector<double> &fe_function,
+ *
+ * The actual data type of the
+ * input vector may be either a
+ * #Vector<double>#,
+ * #Vector<float>#, or
+ * #BlockVector<double,...>#.
+ */
+ template <class InputVector>
+ void get_function_grads (const InputVector &fe_function,
vector<vector<Tensor<1,dim> > > &gradients) const;
/**
* The function assumes that the
* #second_derivatives# object already has
* the right size.
- */
- void get_function_2nd_derivatives (const Vector<double> &fe_function,
+ *
+ * The actual data type of the
+ * input vector may be either a
+ * #Vector<double>#,
+ * #Vector<float>#, or
+ * #BlockVector<double,...>#.
+ */
+ template <class InputVector>
+ void get_function_2nd_derivatives (const InputVector &fe_function,
vector<Tensor<2,dim> > &second_derivatives) const;
/**
#include <fe/fe.h>
#include <lac/vector.h>
+#include <lac/block_vector.h>
#include <lac/sparse_matrix.h>
#include <vector>
template <int dim>
-template <typename number>
+template <class InputVector, typename number>
void
-DoFObjectAccessor<1,dim>::get_dof_values (const Vector<number> &values,
- Vector<number> &local_values) const
+DoFObjectAccessor<1,dim>::get_dof_values (const InputVector &values,
+ Vector<number> &local_values) const
{
Assert (dim==1, ExcInternalError());
template <int dim>
-template <typename number>
+template <class OutputVector, typename number>
void
DoFObjectAccessor<1,dim>::set_dof_values (const Vector<number> &local_values,
- Vector<number> &values) const {
+ OutputVector &values) const
+{
Assert (dim==1, ExcInternalError());
Assert (dof_handler != 0, DoFAccessor<1>::ExcInvalidObject());
template <int dim>
-template <typename number>
+template <class InputVector, typename number>
void
-DoFObjectAccessor<2,dim>::get_dof_values (const Vector<number> &values,
- Vector<number> &local_values) const
+DoFObjectAccessor<2,dim>::get_dof_values (const InputVector &values,
+ Vector<number> &local_values) const
{
Assert (dim==2, ExcInternalError());
template <int dim>
-template <typename number>
+template <class OutputVector, typename number>
void
DoFObjectAccessor<2,dim>::set_dof_values (const Vector<number> &local_values,
- Vector<number> &values) const
+ OutputVector &values) const
{
Assert (dim==2, ExcInternalError());
template <int dim>
-template <typename number>
+template <class InputVector, typename number>
void
-DoFObjectAccessor<3,dim>::get_dof_values (const Vector<number> &values,
- Vector<number> &local_values) const
+DoFObjectAccessor<3,dim>::get_dof_values (const InputVector &values,
+ Vector<number> &local_values) const
{
Assert (dim==3, ExcInternalError());
template <int dim>
-template <typename number>
+template <class OutputVector, typename number>
void
DoFObjectAccessor<3,dim>::set_dof_values (const Vector<number> &local_values,
- Vector<number> &values) const
+ OutputVector &values) const
{
Assert (dim==3, ExcInternalError());
template <int dim>
-template <typename number>
+template <class InputVector, typename number>
void
-DoFCellAccessor<dim>::get_interpolated_dof_values (const Vector<number> &values,
- Vector<number> &interpolated_values) const
+DoFCellAccessor<dim>::get_interpolated_dof_values (const InputVector &values,
+ Vector<number> &interpolated_values) const
{
const unsigned int dofs_per_cell = dof_handler->get_fe().dofs_per_cell;
template <int dim>
-template <typename number>
+template <class OutputVector, typename number>
void
DoFCellAccessor<dim>::set_dof_values_by_interpolation (const Vector<number> &local_values,
- Vector<number> &values) const
+ OutputVector &values) const
{
const unsigned int dofs_per_cell = dof_handler->get_fe().dofs_per_cell;
};
+
+// --------------------------------------------------------------------------
// explicit instantiations
// for double
template
void
-DoFObjectAccessor<1,deal_II_dimension>::
-get_dof_values (const Vector<double> &,
- Vector<double> &) const;
+DoFObjectAccessor<1,deal_II_dimension>::get_dof_values (const Vector<double> &,
+ Vector<double> &) const;
template
void
-DoFObjectAccessor<1,deal_II_dimension>::
-set_dof_values (const Vector<double> &,
- Vector<double> &) const;
+DoFObjectAccessor<1,deal_II_dimension>::set_dof_values (const Vector<double> &,
+ Vector<double> &) const;
// for float
template
void
-DoFObjectAccessor<1,deal_II_dimension>::
-get_dof_values (const Vector<float> &,
- Vector<float> &) const;
+DoFObjectAccessor<1,deal_II_dimension>::get_dof_values (const Vector<float> &,
+ Vector<float> &) const;
+
+template
+void
+DoFObjectAccessor<1,deal_II_dimension>::set_dof_values (const Vector<float> &,
+ Vector<float> &) const;
+
+
+// for block vector 2
+template
+void
+DoFObjectAccessor<1,deal_II_dimension>::get_dof_values (const BlockVector<2,double> &,
+ Vector<float> &) const;
+
+template
+void
+DoFObjectAccessor<1,deal_II_dimension>::set_dof_values (const Vector<double> &,
+ BlockVector<2,double> &) const;
+
+
+// for block vector 3
+template
+void
+DoFObjectAccessor<1,deal_II_dimension>::get_dof_values (const BlockVector<3,double> &,
+ Vector<float> &) const;
template
void
-DoFObjectAccessor<1,deal_II_dimension>::
-set_dof_values (const Vector<float> &,
- Vector<float> &) const;
+DoFObjectAccessor<1,deal_II_dimension>::set_dof_values (const Vector<double> &,
+ BlockVector<3,double> &) const;
+
+
+
#if deal_II_dimension >= 2
// for double
template
void
-DoFObjectAccessor<2,deal_II_dimension>::
-get_dof_values (const Vector<double> &,
- Vector<double> &) const;
+DoFObjectAccessor<2,deal_II_dimension>::get_dof_values (const Vector<double> &,
+ Vector<double> &) const;
template
void
-DoFObjectAccessor<2,deal_II_dimension>::
-set_dof_values (const Vector<double> &,
- Vector<double> &) const;
+DoFObjectAccessor<2,deal_II_dimension>::set_dof_values (const Vector<double> &,
+ Vector<double> &) const;
// for float
template
void
-DoFObjectAccessor<2,deal_II_dimension>::
-get_dof_values (const Vector<float> &,
- Vector<float> &) const;
+DoFObjectAccessor<2,deal_II_dimension>::get_dof_values (const Vector<float> &,
+ Vector<float> &) const;
+
+template
+void
+DoFObjectAccessor<2,deal_II_dimension>::set_dof_values (const Vector<float> &,
+ Vector<float> &) const;
+
+// for block vector 2
template
void
-DoFObjectAccessor<2,deal_II_dimension>::
-set_dof_values (const Vector<float> &,
- Vector<float> &) const;
+DoFObjectAccessor<2,deal_II_dimension>::get_dof_values (const BlockVector<2,double> &,
+ Vector<float> &) const;
+
+template
+void
+DoFObjectAccessor<2,deal_II_dimension>::set_dof_values (const Vector<double> &,
+ BlockVector<2,double> &) const;
+
+
+// for block vector 3
+template
+void
+DoFObjectAccessor<2,deal_II_dimension>::get_dof_values (const BlockVector<3,double> &,
+ Vector<float> &) const;
+
+template
+void
+DoFObjectAccessor<2,deal_II_dimension>::set_dof_values (const Vector<double> &,
+ BlockVector<3,double> &) const;
+
#endif
// for double
template
void
-DoFObjectAccessor<3,deal_II_dimension>::
-get_dof_values (const Vector<double> &,
- Vector<double> &) const;
+DoFObjectAccessor<3,deal_II_dimension>::get_dof_values (const Vector<double> &,
+ Vector<double> &) const;
template
void
-DoFObjectAccessor<3,deal_II_dimension>::
-set_dof_values (const Vector<double> &,
- Vector<double> &) const;
+DoFObjectAccessor<3,deal_II_dimension>::set_dof_values (const Vector<double> &,
+ Vector<double> &) const;
// for float
template
void
-DoFObjectAccessor<3,deal_II_dimension>::
-get_dof_values (const Vector<float> &,
- Vector<float> &) const;
+DoFObjectAccessor<3,deal_II_dimension>::get_dof_values (const Vector<float> &,
+ Vector<float> &) const;
+
+template
+void
+DoFObjectAccessor<3,deal_II_dimension>::set_dof_values (const Vector<float> &,
+ Vector<float> &) const;
+
+
+// for block vector 2
+template
+void
+DoFObjectAccessor<3,deal_II_dimension>::get_dof_values (const BlockVector<2,double> &,
+ Vector<float> &) const;
+template
+void
+DoFObjectAccessor<3,deal_II_dimension>::set_dof_values (const Vector<double> &,
+ BlockVector<2,double> &) const;
+
+
+// for block vector 3
+template
+void
+DoFObjectAccessor<3,deal_II_dimension>::get_dof_values (const BlockVector<3,double> &,
+ Vector<float> &) const;
template
void
-DoFObjectAccessor<3,deal_II_dimension>::
-set_dof_values (const Vector<float> &,
- Vector<float> &) const;
+DoFObjectAccessor<3,deal_II_dimension>::set_dof_values (const Vector<double> &,
+ BlockVector<3,double> &) const;
+
+
#endif
+
template
void
DoFCellAccessor<deal_II_dimension>::
Vector<float> &) const;
+template
+void
+DoFCellAccessor<deal_II_dimension>::
+get_interpolated_dof_values (const BlockVector<2,double> &,
+ Vector<double> &) const;
+
+template
+void
+DoFCellAccessor<deal_II_dimension>::
+set_dof_values_by_interpolation(const Vector<double> &,
+ BlockVector<3,double> &) const;
+
+
#if deal_II_dimension == 1
template class DoFObjectAccessor<1, 1>;
#endif
#include <grid/tria_boundary.h>
#include <dofs/dof_accessor.h>
#include <lac/vector.h>
+#include <lac/block_vector.h>
/*------------------------------- FEValuesBase ---------------------------*/
{};
+
template <int dim>
double FEValuesBase<dim>::shape_value (const unsigned int i,
- const unsigned int j) const {
+ const unsigned int j) const
+{
Assert (update_flags & update_values, ExcAccessToUninitializedField());
Assert (selected_dataset<shape_values.size(),
ExcIndexRange (selected_dataset, 0, shape_values.size()));
};
+
template <int dim>
-void FEValuesBase<dim>::get_function_values (const Vector<double> &fe_function,
- vector<double> &values) const
+template <class InputVector>
+void FEValuesBase<dim>::get_function_values (const InputVector &fe_function,
+ vector<double> &values) const
{
Assert (fe->n_components() == 1,
ExcWrongNoOfComponents());
};
+
template <int dim>
-void FEValuesBase<dim>::get_function_values (const Vector<double> &fe_function,
+template <class InputVector>
+void FEValuesBase<dim>::get_function_values (const InputVector &fe_function,
vector< Vector<double> > &values) const
{
Assert (n_quadrature_points == values.size(),
};
+
template <int dim>
const Tensor<1,dim> &
FEValuesBase<dim>::shape_grad (const unsigned int i,
};
+
template <int dim>
-void FEValuesBase<dim>::get_function_grads (const Vector<double> &fe_function,
+template <class InputVector>
+void FEValuesBase<dim>::get_function_grads (const InputVector &fe_function,
vector<Tensor<1,dim> > &gradients) const
{
Assert (fe->n_components() == 1,
};
};
+
+
template <int dim>
-void FEValuesBase<dim>::get_function_grads (const Vector<double> &fe_function,
+template <class InputVector>
+void FEValuesBase<dim>::get_function_grads (const InputVector &fe_function,
vector<vector<Tensor<1,dim> > > &gradients) const
{
Assert (n_quadrature_points == gradients.size(),
};
+
template <int dim>
const Tensor<2,dim> &
FEValuesBase<dim>::shape_2nd_derivative (const unsigned int i,
- const unsigned int j) const {
+ const unsigned int j) const
+{
Assert (i<shape_2nd_derivatives.size(),
ExcIndexRange (i, 0, shape_2nd_derivatives.size()));
Assert (j<shape_2nd_derivatives[i].size(),
};
+
template <int dim>
-void FEValuesBase<dim>::get_function_2nd_derivatives (const Vector<double> &fe_function,
+template <class InputVector>
+void FEValuesBase<dim>::get_function_2nd_derivatives (const InputVector &fe_function,
vector<Tensor<2,dim> > &second_derivatives) const
{
Assert (fe->n_components() == 1,
};
+
template <int dim>
const Point<dim> &
FEValuesBase<dim>::quadrature_point (const unsigned int i) const
};
+
template <int dim>
const Point<dim> &
FEValuesBase<dim>::support_point (const unsigned int i) const
};
+
template <int dim>
double FEValuesBase<dim>::JxW (const unsigned int i) const
{
};
+
template <int dim>
-void FEValues<dim>::reinit (const typename DoFHandler<dim>::cell_iterator &cell) {
+void FEValues<dim>::reinit (const typename DoFHandler<dim>::cell_iterator &cell)
+{
present_cell = cell;
// fill jacobi matrices and real
// quadrature points
{};
+
template <int dim>
const Point<dim> &
-FEFaceValuesBase<dim>::normal_vector (const unsigned int i) const {
+FEFaceValuesBase<dim>::normal_vector (const unsigned int i) const
+{
Assert (i<normal_vectors.size(), ExcIndexRange(i, 0, normal_vectors.size()));
Assert (update_flags & update_normal_vectors,
ExcAccessToUninitializedField());
template <int dim>
void FEFaceValues<dim>::reinit (const typename DoFHandler<dim>::cell_iterator &cell,
- const unsigned int face_no) {
+ const unsigned int face_no)
+{
present_cell = cell;
selected_dataset = face_no;
// fill jacobi matrices and real
};
+
template <int dim>
void FESubfaceValues<dim>::reinit (const typename DoFHandler<dim>::cell_iterator &cell,
const unsigned int face_no,
template class FEFaceValues<deal_II_dimension>;
template class FESubfaceValues<deal_II_dimension>;
#endif
+
+
+//-----------------------------------------------------------------------------
+
+template
+void FEValuesBase<deal_II_dimension>::get_function_values (const Vector<double> &,
+ vector<double> &) const;
+template
+void FEValuesBase<deal_II_dimension>::get_function_values (const Vector<float> &,
+ vector<double> &) const;
+template
+void FEValuesBase<deal_II_dimension>::get_function_values (const BlockVector<2,double> &,
+ vector<double> &) const;
+template
+void FEValuesBase<deal_II_dimension>::get_function_values (const BlockVector<3,double> &,
+ vector<double> &) const;
+
+//-----------------------------------------------------------------------------
+
+template
+void FEValuesBase<deal_II_dimension>::get_function_values (const Vector<double> &,
+ vector<Vector<double> > &) const;
+template
+void FEValuesBase<deal_II_dimension>::get_function_values (const Vector<float> &,
+ vector<Vector<double> > &) const;
+template
+void FEValuesBase<deal_II_dimension>::get_function_values (const BlockVector<2,double> &,
+ vector<Vector<double> > &) const;
+template
+void FEValuesBase<deal_II_dimension>::get_function_values (const BlockVector<3,double> &,
+ vector<Vector<double> > &) const;
+
+//-----------------------------------------------------------------------------
+
+template
+void FEValuesBase<deal_II_dimension>::get_function_grads (const Vector<double> &,
+ vector<Tensor<1,deal_II_dimension> > &) const;
+template
+void FEValuesBase<deal_II_dimension>::get_function_grads (const Vector<float> &,
+ vector<Tensor<1,deal_II_dimension> > &) const;
+template
+void FEValuesBase<deal_II_dimension>::get_function_grads (const BlockVector<2,double> &,
+ vector<Tensor<1,deal_II_dimension> > &) const;
+template
+void FEValuesBase<deal_II_dimension>::get_function_grads (const BlockVector<3,double> &,
+ vector<Tensor<1,deal_II_dimension> > &) const;
+
+//-----------------------------------------------------------------------------
+
+template
+void FEValuesBase<deal_II_dimension>::get_function_grads (const Vector<double> &,
+ vector<vector<Tensor<1,deal_II_dimension> > > &) const;
+template
+void FEValuesBase<deal_II_dimension>::get_function_grads (const Vector<float> &,
+ vector<vector<Tensor<1,deal_II_dimension> > > &) const;
+template
+void FEValuesBase<deal_II_dimension>::get_function_grads (const BlockVector<2,double> &,
+ vector<vector<Tensor<1,deal_II_dimension> > > &) const;
+template
+void FEValuesBase<deal_II_dimension>::get_function_grads (const BlockVector<3,double> &,
+ vector<vector<Tensor<1,deal_II_dimension> > > &) const;
+
+//-----------------------------------------------------------------------------
+
+template
+void FEValuesBase<deal_II_dimension>::get_function_2nd_derivatives (const Vector<double> &,
+ vector<Tensor<2,deal_II_dimension> > &) const;
+template
+void FEValuesBase<deal_II_dimension>::get_function_2nd_derivatives (const Vector<float> &,
+ vector<Tensor<2,deal_II_dimension> > &) const;
+template
+void FEValuesBase<deal_II_dimension>::get_function_2nd_derivatives (const BlockVector<2,double> &,
+ vector<Tensor<2,deal_II_dimension> > &) const;
+template
+void FEValuesBase<deal_II_dimension>::get_function_2nd_derivatives (const BlockVector<3,double> &,
+ vector<Tensor<2,deal_II_dimension> > &) const;
template <>
void FEQ1Mapping<2>::compute_jacobian_matrices (const DoFHandler<2>::cell_iterator &cell,
- const vector<Point<2> > &unit_points,
- vector<Tensor<2,2> > &jacobians)
+ const vector<Point<2> > &unit_points,
+ vector<Tensor<2,2> > &jacobians)
{
const unsigned int dim = 2;