#include <fe/fe_linear_mapping.h>
+#define FELinear FEQ1
+#define FEQuadraticSub FEQ2
+#define FECubicSub FEQ3
+#define FEQuarticSub FEQ4
/**
* Define a (bi-, tri-, etc)linear finite element in #dim# space dimensions,
*/
template <int dim>
-class FELinear : public FELinearMapping<dim> {
+class FEQ1 : public FELinearMapping<dim> {
public:
/**
* Constructor
*/
- FELinear ();
+ FEQ1 ();
protected:
/**
* Constructor that is called by the
* matrices are build.
* For more detail see class #FEDGLinear#.
*/
- FELinear (const int);
+ FEQ1 (const int);
public:
/**
* @author Wolfgang Bangerth, 1998, 1999
*/
template <int dim>
-class FEQuadraticSub : public FELinearMapping<dim> {
+class FEQ2 : public FELinearMapping<dim> {
public:
/**
* Constructor
*/
- FEQuadraticSub ();
+ FEQ2 ();
protected:
/**
* Constructor that is called by the
* For more detail see class
* #FEDGQuadraticSub#.
*/
- FEQuadraticSub (const int);
+ FEQ2 (const int);
public:
/**
* @author Wolfgang Bangerth, 1998
*/
template <int dim>
-class FECubicSub : public FELinearMapping<dim> {
+class FEQ3 : public FELinearMapping<dim> {
public:
/**
* Constructor
*/
- FECubicSub ();
+ FEQ3 ();
protected:
/**
* For more detail see class
* #FEDGCubicSub#.
*/
- FECubicSub (const int);
+ FEQ3 (const int);
public:
/**
* @author Wolfgang Bangerth, 1998
*/
template <int dim>
-class FEQuarticSub : public FELinearMapping<dim> {
+class FEQ4 : public FELinearMapping<dim> {
public:
/**
* Constructor
*/
- FEQuarticSub ();
+ FEQ4 ();
protected:
/**
* For more detail see class
* #FEDGQuarticSub#.
*/
- FEQuarticSub (const int);
+ FEQ4 (const int);
public:
/**
// declare explicit specializations before use:
-template <> void FECubicSub<deal_II_dimension>::initialize_matrices ();
+template <> void FEQ3<deal_II_dimension>::initialize_matrices ();
#if deal_II_dimension == 1
template <>
-FECubicSub<1>::FECubicSub () :
+FEQ3<1>::FEQ3 () :
FELinearMapping<1> (1, 2) {
initialize_matrices ();
};
template <>
-FECubicSub<1>::FECubicSub (const int) :
+FEQ3<1>::FEQ3 (const int) :
FELinearMapping<1> (0, 4)
{
initialize_matrices ();
template <>
-void FECubicSub<1>::initialize_matrices () {
+void FEQ3<1>::initialize_matrices () {
prolongation[0](0,0) = 1.0;
prolongation[0](0,1) = 0.0;
template <>
double
-FECubicSub<1>::shape_value (const unsigned int i,
+FEQ3<1>::shape_value (const unsigned int i,
const Point<1> &p) const
{
Assert((i<total_dofs), ExcInvalidIndex(i));
template <>
Tensor<1,1>
-FECubicSub<1>::shape_grad (const unsigned int i,
+FEQ3<1>::shape_grad (const unsigned int i,
const Point<1> &p) const
{
Assert((i<total_dofs), ExcInvalidIndex(i));
template <>
Tensor<2,1>
-FECubicSub<1>::shape_grad_grad (const unsigned int i,
+FEQ3<1>::shape_grad_grad (const unsigned int i,
const Point<1> &p) const
{
Assert (i<total_dofs, ExcInvalidIndex(i));
template <>
-void FECubicSub<1>::get_unit_support_points (vector<Point<1> > &unit_points) const {
+void FEQ3<1>::get_unit_support_points (vector<Point<1> > &unit_points) const {
FiniteElement<1>::get_unit_support_points (unit_points);
};
template <>
-void FECubicSub<1>::get_support_points (const typename DoFHandler<1>::cell_iterator &cell,
+void FEQ3<1>::get_support_points (const typename DoFHandler<1>::cell_iterator &cell,
vector<Point<1> > &support_points) const {
FiniteElement<1>::get_support_points (cell, support_points);
};
template <>
-void FECubicSub<1>::get_face_support_points (const typename DoFHandler<1>::face_iterator &,
+void FEQ3<1>::get_face_support_points (const typename DoFHandler<1>::face_iterator &,
vector<Point<1> > &) const {
Assert (false, ExcInternalError());
};
template <>
-void FECubicSub<1>::get_local_mass_matrix (const DoFHandler<1>::cell_iterator &cell,
+void FEQ3<1>::get_local_mass_matrix (const DoFHandler<1>::cell_iterator &cell,
FullMatrix<double> &local_mass_matrix) const {
Assert (local_mass_matrix.n() == total_dofs,
ExcWrongFieldDimension(local_mass_matrix.n(),total_dofs));
#if deal_II_dimension == 2
template <>
-FECubicSub<2>::FECubicSub () :
+FEQ3<2>::FEQ3 () :
FELinearMapping<2> (1, 2, 4)
{
interface_constraints(0,0) = -1.0/16.0;
template <>
-FECubicSub<2>::FECubicSub (const int) :
+FEQ3<2>::FEQ3 (const int) :
FELinearMapping<2> (0, 0, 16)
{
initialize_matrices ();
template <>
-void FECubicSub<2>::initialize_matrices () {
+void FEQ3<2>::initialize_matrices () {
prolongation[0](0,0) = 1.0;
prolongation[0](1,0) = -1.0/16.0;
prolongation[0](1,1) = -1.0/16.0;
template <>
double
-FECubicSub<2>::shape_value (const unsigned int i,
+FEQ3<2>::shape_value (const unsigned int i,
const Point<2> &p) const
{
Assert (i<total_dofs, ExcInvalidIndex(i));
template <>
Tensor<1,2>
-FECubicSub<2>::shape_grad (const unsigned int i,
+FEQ3<2>::shape_grad (const unsigned int i,
const Point<2> &p) const
{
Assert (i<total_dofs, ExcInvalidIndex(i));
template <>
Tensor<2,2>
-FECubicSub<2>::shape_grad_grad (const unsigned int i,
+FEQ3<2>::shape_grad_grad (const unsigned int i,
const Point<2> &p) const
{
Assert (i<total_dofs, ExcInvalidIndex(i));
template <>
-void FECubicSub<2>::get_local_mass_matrix (const DoFHandler<2>::cell_iterator &cell,
+void FEQ3<2>::get_local_mass_matrix (const DoFHandler<2>::cell_iterator &cell,
FullMatrix<double> &local_mass_matrix) const {
Assert (local_mass_matrix.n() == total_dofs,
ExcWrongFieldDimension(local_mass_matrix.n(),total_dofs));
template <>
-void FECubicSub<2>::get_unit_support_points (vector<Point<2> > &unit_points) const {
+void FEQ3<2>::get_unit_support_points (vector<Point<2> > &unit_points) const {
Assert (unit_points.size() == total_dofs,
ExcWrongFieldDimension (unit_points.size(), total_dofs));
template <>
-void FECubicSub<2>::get_support_points (const typename DoFHandler<2>::cell_iterator &cell,
+void FEQ3<2>::get_support_points (const typename DoFHandler<2>::cell_iterator &cell,
vector<Point<2> > &support_points) const {
Assert (support_points.size() == total_dofs,
ExcWrongFieldDimension (support_points.size(), total_dofs));
template <>
-void FECubicSub<2>::get_face_support_points (const typename DoFHandler<2>::face_iterator &face,
+void FEQ3<2>::get_face_support_points (const typename DoFHandler<2>::face_iterator &face,
vector<Point<2> > &support_points) const {
Assert (support_points.size() == dofs_per_face,
ExcWrongFieldDimension (support_points.size(), dofs_per_face));
#if deal_II_dimension == 3
template <>
-FECubicSub<3>::FECubicSub () :
+FEQ3<3>::FEQ3 () :
FELinearMapping<3> (1, 2, 4, 8)
{
interface_constraints(0,0) = 1.0/256.0;
template <>
-FECubicSub<3>::FECubicSub (const int) :
+FEQ3<3>::FEQ3 (const int) :
FELinearMapping<3> (0, 0, 0, 64)
{
initialize_matrices ();
template <>
-void FECubicSub<3>::initialize_matrices () {
+void FEQ3<3>::initialize_matrices () {
prolongation[0](0,0) = 1.0;
prolongation[0](1,0) = -1.0/16.0;
prolongation[0](1,1) = -1.0/16.0;
template <>
double
-FECubicSub<3>::shape_value (const unsigned int i,
+FEQ3<3>::shape_value (const unsigned int i,
const Point<3> &p) const
{
Assert (i<total_dofs, ExcInvalidIndex(i));
template <>
Tensor<1,3>
-FECubicSub<3>::shape_grad (const unsigned int i,
+FEQ3<3>::shape_grad (const unsigned int i,
const Point<3> &p) const
{
Assert (i<total_dofs, ExcInvalidIndex(i));
template <>
Tensor<2,3>
-FECubicSub<3>::shape_grad_grad (const unsigned int i,
+FEQ3<3>::shape_grad_grad (const unsigned int i,
const Point<3> &p) const
{
Assert (i<total_dofs, ExcInvalidIndex(i));
template <>
void
-FECubicSub<3>::get_local_mass_matrix (const DoFHandler<3>::cell_iterator &,
+FEQ3<3>::get_local_mass_matrix (const DoFHandler<3>::cell_iterator &,
FullMatrix<double> &local_mass_matrix) const
{
Assert (local_mass_matrix.n() == total_dofs,
template <>
-void FECubicSub<3>::get_unit_support_points (vector<Point<3> > &unit_points) const {
+void FEQ3<3>::get_unit_support_points (vector<Point<3> > &unit_points) const {
Assert (unit_points.size() == total_dofs,
ExcWrongFieldDimension (unit_points.size(), total_dofs));
unit_points[0] = Point<3>(0, 0, 0);
template <>
-void FECubicSub<3>::get_support_points (const typename DoFHandler<3>::cell_iterator &cell,
+void FEQ3<3>::get_support_points (const typename DoFHandler<3>::cell_iterator &cell,
vector<Point<3> > &support_points) const {
Assert (support_points.size() == total_dofs,
ExcWrongFieldDimension (support_points.size(), total_dofs));
template <>
-void FECubicSub<3>::get_face_support_points (const typename DoFHandler<3>::face_iterator &face,
+void FEQ3<3>::get_face_support_points (const typename DoFHandler<3>::face_iterator &face,
vector<Point<3> > &support_points) const {
Assert (support_points.size() == dofs_per_face,
ExcWrongFieldDimension (support_points.size(), dofs_per_face));
// explicit instantiations
-template class FECubicSub<deal_II_dimension>;
+template class FEQ3<deal_II_dimension>;
// declare explicit specializations before use:
-template <> void FELinear<deal_II_dimension>::initialize_matrices ();
+template <> void FEQ1<deal_II_dimension>::initialize_matrices ();
#if deal_II_dimension == 1
template <>
-FELinear<1>::FELinear () :
+FEQ1<1>::FEQ1 () :
FELinearMapping<1> (1, 0)
{
initialize_matrices ();
template <>
-FELinear<1>::FELinear (const int) :
+FEQ1<1>::FEQ1 (const int) :
FELinearMapping<1> (0, 2)
{
initialize_matrices ();
template <>
-void FELinear<1>::initialize_matrices () {
+void FEQ1<1>::initialize_matrices () {
// for restriction and prolongation matrices:
// note that we do not add up all the
// contributions since then we would get
template <>
double
-FELinear<1>::shape_value(const unsigned int i,
+FEQ1<1>::shape_value(const unsigned int i,
const Point<1> &p) const
{
Assert((i<total_dofs), ExcInvalidIndex(i));
template <>
inline
Tensor<1,1>
-FELinear<1>::shape_grad(const unsigned int i,
+FEQ1<1>::shape_grad(const unsigned int i,
const Point<1>&) const
{
Assert((i<total_dofs), ExcInvalidIndex(i));
template <>
inline
Tensor<2,1>
-FELinear<1>::shape_grad_grad (const unsigned int i,
+FEQ1<1>::shape_grad_grad (const unsigned int i,
const Point<1> &) const
{
Assert((i<total_dofs), ExcInvalidIndex(i));
template <>
-void FELinear<1>::get_unit_support_points (vector<Point<1> > &support_points) const {
+void FEQ1<1>::get_unit_support_points (vector<Point<1> > &support_points) const {
FiniteElement<1>::get_unit_support_points (support_points);
};
template <>
-void FELinear<1>::get_support_points (const typename DoFHandler<1>::cell_iterator &cell,
+void FEQ1<1>::get_support_points (const typename DoFHandler<1>::cell_iterator &cell,
vector<Point<1> > &support_points) const {
FiniteElement<1>::get_support_points (cell, support_points);
};
template <>
-void FELinear<1>::get_face_support_points (const typename DoFHandler<1>::face_iterator &,
+void FEQ1<1>::get_face_support_points (const typename DoFHandler<1>::face_iterator &,
vector<Point<1> > &) const {
Assert (false, ExcInternalError());
};
template <>
-void FELinear<1>::get_local_mass_matrix (const DoFHandler<1>::cell_iterator &cell,
+void FEQ1<1>::get_local_mass_matrix (const DoFHandler<1>::cell_iterator &cell,
FullMatrix<double> &local_mass_matrix) const {
Assert (local_mass_matrix.n() == total_dofs,
ExcWrongFieldDimension(local_mass_matrix.n(),total_dofs));
#if deal_II_dimension == 2
template <>
-FELinear<2>::FELinear () :
+FEQ1<2>::FEQ1 () :
FELinearMapping<2> (1, 0, 0)
{
interface_constraints(0,0) = 1./2.;
template <>
-FELinear<2>::FELinear (const int) :
+FEQ1<2>::FEQ1 (const int) :
FELinearMapping<2> (0, 0, 4)
{
initialize_matrices ();
template <>
-void FELinear<2>::initialize_matrices () {
+void FEQ1<2>::initialize_matrices () {
restriction[0](0,0) = 1.0;
restriction[1](1,1) = 1.0;
restriction[2](2,2) = 1.0;
template <>
inline
double
-FELinear<2>::shape_value (const unsigned int i,
+FEQ1<2>::shape_value (const unsigned int i,
const Point<2>& p) const
{
Assert((i<total_dofs), ExcInvalidIndex(i));
template <>
inline
Tensor<1,2>
-FELinear<2>::shape_grad (const unsigned int i,
+FEQ1<2>::shape_grad (const unsigned int i,
const Point<2>& p) const
{
Assert((i<total_dofs), ExcInvalidIndex(i));
template <>
inline
Tensor<2,2>
-FELinear<2>::shape_grad_grad (const unsigned int i,
+FEQ1<2>::shape_grad_grad (const unsigned int i,
const Point<2> &) const
{
Assert((i<total_dofs), ExcInvalidIndex(i));
template <>
-void FELinear<2>::get_local_mass_matrix (const DoFHandler<2>::cell_iterator &cell,
+void FEQ1<2>::get_local_mass_matrix (const DoFHandler<2>::cell_iterator &cell,
FullMatrix<double> &local_mass_matrix) const {
Assert (local_mass_matrix.n() == total_dofs,
ExcWrongFieldDimension(local_mass_matrix.n(),total_dofs));
template <>
-void FELinear<2>::get_unit_support_points (vector<Point<2> > &unit_points) const {
+void FEQ1<2>::get_unit_support_points (vector<Point<2> > &unit_points) const {
Assert (unit_points.size() == total_dofs,
ExcWrongFieldDimension (unit_points.size(), total_dofs));
#if deal_II_dimension == 3
template <>
-FELinear<3>::FELinear () :
+FEQ1<3>::FEQ1 () :
FELinearMapping<3> (1, 0, 0, 0)
{
interface_constraints(0,0) = 1.0/4.0;
template <>
-FELinear<3>::FELinear (const int) :
+FEQ1<3>::FEQ1 (const int) :
FELinearMapping<3> (0, 0, 0, 8)
{
initialize_matrices ();
template <>
-void FELinear<3>::initialize_matrices () {
+void FEQ1<3>::initialize_matrices () {
restriction[0](0,0) = 1.0;
restriction[1](1,1) = 1.0;
restriction[2](2,2) = 1.0;
template <>
inline
double
-FELinear<3>::shape_value (const unsigned int i,
+FEQ1<3>::shape_value (const unsigned int i,
const Point<3>& p) const
{
Assert((i<total_dofs), ExcInvalidIndex(i));
template <>
inline
Tensor<1,3>
-FELinear<3>::shape_grad (const unsigned int i,
+FEQ1<3>::shape_grad (const unsigned int i,
const Point<3>& p) const
{
Assert((i<total_dofs), ExcInvalidIndex(i));
template <>
inline
Tensor<2,3>
-FELinear<3>::shape_grad_grad (const unsigned int i,
+FEQ1<3>::shape_grad_grad (const unsigned int i,
const Point<3> &p) const
{
Assert((i<total_dofs), ExcInvalidIndex(i));
template <>
-void FELinear<3>::get_local_mass_matrix (const DoFHandler<3>::cell_iterator &,
+void FEQ1<3>::get_local_mass_matrix (const DoFHandler<3>::cell_iterator &,
FullMatrix<double> &local_mass_matrix) const {
Assert (local_mass_matrix.n() == total_dofs,
ExcWrongFieldDimension(local_mass_matrix.n(),total_dofs));
template <>
-void FELinear<3>::get_unit_support_points (vector<Point<3> > &unit_points) const {
+void FEQ1<3>::get_unit_support_points (vector<Point<3> > &unit_points) const {
Assert (unit_points.size() == total_dofs,
ExcWrongFieldDimension (unit_points.size(), total_dofs));
template <int dim>
void
-FELinear<dim>::get_support_points (const typename DoFHandler<dim>::cell_iterator &cell,
+FEQ1<dim>::get_support_points (const typename DoFHandler<dim>::cell_iterator &cell,
vector<Point<dim> > &support_points) const {
Assert (support_points.size() == total_dofs,
ExcWrongFieldDimension (support_points.size(), total_dofs));
template <int dim>
void
-FELinear<dim>::get_face_support_points (const typename DoFHandler<dim>::face_iterator &face,
+FEQ1<dim>::get_face_support_points (const typename DoFHandler<dim>::face_iterator &face,
vector<Point<dim> > &support_points) const {
Assert ((support_points.size() == dofs_per_face) &&
(support_points.size() == GeometryInfo<dim>::vertices_per_face),
// explicit instantiations
-template class FELinear<deal_II_dimension>;
+template class FEQ1<deal_II_dimension>;
// declare explicit specializations before use:
-template <> void FEQuadraticSub<deal_II_dimension>::initialize_matrices ();
+template <> void FEQ2<deal_II_dimension>::initialize_matrices ();
#if deal_II_dimension == 1
template <>
-FEQuadraticSub<1>::FEQuadraticSub () :
+FEQ2<1>::FEQ2 () :
FELinearMapping<1> (1, 1) {
initialize_matrices ();
};
template <>
-FEQuadraticSub<1>::FEQuadraticSub (const int) :
+FEQ2<1>::FEQ2 (const int) :
FELinearMapping<1> (0, 3) {
initialize_matrices ();
};
template <>
-void FEQuadraticSub<1>::initialize_matrices () {
+void FEQ2<1>::initialize_matrices () {
/*
Get the prolongation matrices by the following little maple script:
template <>
double
-FEQuadraticSub<1>::shape_value(const unsigned int i,
+FEQ2<1>::shape_value(const unsigned int i,
const Point<1> &p) const
{
Assert((i<total_dofs), ExcInvalidIndex(i));
template <>
Tensor<1,1>
-FEQuadraticSub<1>::shape_grad(const unsigned int i,
+FEQ2<1>::shape_grad(const unsigned int i,
const Point<1> &p) const
{
Assert((i<total_dofs), ExcInvalidIndex(i));
template <>
Tensor<2,1>
-FEQuadraticSub<1>::shape_grad_grad (const unsigned int i,
+FEQ2<1>::shape_grad_grad (const unsigned int i,
const Point<1> &) const
{
Assert((i<total_dofs), ExcInvalidIndex(i));
template <>
-void FEQuadraticSub<1>::get_unit_support_points (vector<Point<1> > &unit_points) const {
+void FEQ2<1>::get_unit_support_points (vector<Point<1> > &unit_points) const {
FiniteElement<1>::get_unit_support_points (unit_points);
};
template <>
-void FEQuadraticSub<1>::get_support_points (const typename DoFHandler<1>::cell_iterator &cell,
+void FEQ2<1>::get_support_points (const typename DoFHandler<1>::cell_iterator &cell,
vector<Point<1> > &support_points) const {
FiniteElement<1>::get_support_points (cell, support_points);
};
template <>
-void FEQuadraticSub<1>::get_face_support_points (const typename DoFHandler<1>::face_iterator &,
+void FEQ2<1>::get_face_support_points (const typename DoFHandler<1>::face_iterator &,
vector<Point<1> > &) const {
Assert (false, ExcInternalError());
};
template <>
-void FEQuadraticSub<1>::get_local_mass_matrix (const DoFHandler<1>::cell_iterator &cell,
+void FEQ2<1>::get_local_mass_matrix (const DoFHandler<1>::cell_iterator &cell,
FullMatrix<double> &local_mass_matrix) const {
Assert (local_mass_matrix.n() == total_dofs,
ExcWrongFieldDimension(local_mass_matrix.n(),total_dofs));
#if deal_II_dimension == 2
template <>
-FEQuadraticSub<2>::FEQuadraticSub () :
+FEQ2<2>::FEQ2 () :
FELinearMapping<2> (1, 1, 1)
{
interface_constraints(0,2) = 1.0;
template <>
-FEQuadraticSub<2>::FEQuadraticSub (const int) :
+FEQ2<2>::FEQ2 (const int) :
FELinearMapping<2> (0, 0, 9)
{
initialize_matrices ();
template <>
-void FEQuadraticSub<2>::initialize_matrices () {
+void FEQ2<2>::initialize_matrices () {
/*
Get the prolongation and restriction matrices by the following little maple script:
template <>
double
-FEQuadraticSub<2>::shape_value (const unsigned int i,
+FEQ2<2>::shape_value (const unsigned int i,
const Point<2> &p) const
{
Assert (i<total_dofs, ExcInvalidIndex(i));
template <>
Tensor<1,2>
-FEQuadraticSub<2>::shape_grad (const unsigned int i,
+FEQ2<2>::shape_grad (const unsigned int i,
const Point<2> &p) const
{
Assert (i<total_dofs, ExcInvalidIndex(i));
template <>
Tensor<2,2>
-FEQuadraticSub<2>::shape_grad_grad (const unsigned int i,
+FEQ2<2>::shape_grad_grad (const unsigned int i,
const Point<2> &p) const
{
Assert (i<total_dofs, ExcInvalidIndex(i));
template <>
-void FEQuadraticSub<2>::get_local_mass_matrix (const DoFHandler<2>::cell_iterator &cell,
+void FEQ2<2>::get_local_mass_matrix (const DoFHandler<2>::cell_iterator &cell,
FullMatrix<double> &local_mass_matrix) const {
Assert (local_mass_matrix.n() == total_dofs,
ExcWrongFieldDimension(local_mass_matrix.n(),total_dofs));
template <>
-void FEQuadraticSub<2>::get_unit_support_points (vector<Point<2> > &unit_points) const {
+void FEQ2<2>::get_unit_support_points (vector<Point<2> > &unit_points) const {
Assert (unit_points.size() == total_dofs,
ExcWrongFieldDimension (unit_points.size(), total_dofs));
template <>
-void FEQuadraticSub<2>::get_support_points (const typename DoFHandler<2>::cell_iterator &cell,
+void FEQ2<2>::get_support_points (const typename DoFHandler<2>::cell_iterator &cell,
vector<Point<2> > &support_points) const {
Assert (support_points.size() == total_dofs,
ExcWrongFieldDimension (support_points.size(), total_dofs));
template <>
-void FEQuadraticSub<2>::get_face_support_points (const typename DoFHandler<2>::face_iterator &face,
+void FEQ2<2>::get_face_support_points (const typename DoFHandler<2>::face_iterator &face,
vector<Point<2> > &support_points) const {
Assert (support_points.size() == dofs_per_face,
ExcWrongFieldDimension (support_points.size(), dofs_per_face));
#if deal_II_dimension == 3
template <>
-FEQuadraticSub<3>::FEQuadraticSub () :
+FEQ2<3>::FEQ2 () :
FELinearMapping<3> (1, 1, 1, 1)
{
interface_constraints(0,8) = 1.0;
template <>
-FEQuadraticSub<3>::FEQuadraticSub (const int) :
+FEQ2<3>::FEQ2 (const int) :
FELinearMapping<3> (0, 0, 0, 27)
{
initialize_matrices ();
template <>
-void FEQuadraticSub<3>::initialize_matrices () {
+void FEQ2<3>::initialize_matrices () {
prolongation[0](0,0) = 1.0;
prolongation[0](1,8) = 1.0;
prolongation[0](2,20) = 1.0;
template <>
double
-FEQuadraticSub<3>::shape_value (const unsigned int i,
+FEQ2<3>::shape_value (const unsigned int i,
const Point<3> &p) const
{
Assert (i<total_dofs, ExcInvalidIndex(i));
template <>
Tensor<1,3>
-FEQuadraticSub<3>::shape_grad (const unsigned int i,
+FEQ2<3>::shape_grad (const unsigned int i,
const Point<3> &p) const
{
Assert (i<total_dofs, ExcInvalidIndex(i));
template <>
Tensor<2,3>
-FEQuadraticSub<3>::shape_grad_grad (const unsigned int i,
+FEQ2<3>::shape_grad_grad (const unsigned int i,
const Point<3> &p) const
{
Assert (i<total_dofs, ExcInvalidIndex(i));
template <>
-void FEQuadraticSub<3>::get_local_mass_matrix (const DoFHandler<3>::cell_iterator &,
+void FEQ2<3>::get_local_mass_matrix (const DoFHandler<3>::cell_iterator &,
FullMatrix<double> &local_mass_matrix) const {
Assert (local_mass_matrix.n() == total_dofs,
ExcWrongFieldDimension(local_mass_matrix.n(),total_dofs));
template <>
-void FEQuadraticSub<3>::get_unit_support_points (vector<Point<3> > &unit_points) const {
+void FEQ2<3>::get_unit_support_points (vector<Point<3> > &unit_points) const {
Assert (unit_points.size() == total_dofs,
ExcWrongFieldDimension (unit_points.size(), total_dofs));
template <>
-void FEQuadraticSub<3>::get_support_points (const typename DoFHandler<3>::cell_iterator &cell,
+void FEQ2<3>::get_support_points (const typename DoFHandler<3>::cell_iterator &cell,
vector<Point<3> > &support_points) const {
Assert (support_points.size() == total_dofs,
ExcWrongFieldDimension (support_points.size(), total_dofs));
template <>
-void FEQuadraticSub<3>::get_face_support_points (const typename DoFHandler<3>::face_iterator &face,
+void FEQ2<3>::get_face_support_points (const typename DoFHandler<3>::face_iterator &face,
vector<Point<3> > &support_points) const {
Assert (support_points.size() == dofs_per_face,
ExcWrongFieldDimension (support_points.size(), dofs_per_face));
// explicit instantiations
-template class FEQuadraticSub<deal_II_dimension>;
+template class FEQ2<deal_II_dimension>;
// declare explicit specializations before use:
-template <> void FEQuarticSub<deal_II_dimension>::initialize_matrices ();
+template <> void FEQ4<deal_II_dimension>::initialize_matrices ();
#if deal_II_dimension == 1
template <>
-FEQuarticSub<1>::FEQuarticSub () :
+FEQ4<1>::FEQ4 () :
FELinearMapping<1> (1, 3) {
initialize_matrices ();
};
template <>
-FEQuarticSub<1>::FEQuarticSub (const int) :
+FEQ4<1>::FEQ4 (const int) :
FELinearMapping<1> (0, 5) {
initialize_matrices ();
};
template <>
-void FEQuarticSub<1>::initialize_matrices () {
+void FEQ4<1>::initialize_matrices () {
prolongation[0](0,0) = 1.0;
prolongation[0](1,3) = 1.0;
prolongation[0](2,0) = 35.0/128.0;
template <>
double
-FEQuarticSub<1>::shape_value(const unsigned int i,
+FEQ4<1>::shape_value(const unsigned int i,
const Point<1> &p) const
{
Assert((i<total_dofs), ExcInvalidIndex(i));
template <>
Tensor<1,1>
-FEQuarticSub<1>::shape_grad(const unsigned int i,
+FEQ4<1>::shape_grad(const unsigned int i,
const Point<1> &p) const
{
Assert((i<total_dofs), ExcInvalidIndex(i));
template <>
Tensor<2,1>
-FEQuarticSub<1>::shape_grad_grad (const unsigned int i,
+FEQ4<1>::shape_grad_grad (const unsigned int i,
const Point<1> &p) const
{
Assert (i<total_dofs, ExcInvalidIndex(i));
template <>
-void FEQuarticSub<1>::get_unit_support_points (vector<Point<1> > &unit_points) const {
+void FEQ4<1>::get_unit_support_points (vector<Point<1> > &unit_points) const {
FiniteElement<1>::get_unit_support_points (unit_points);
};
template <>
-void FEQuarticSub<1>::get_support_points (const typename DoFHandler<1>::cell_iterator &cell,
+void FEQ4<1>::get_support_points (const typename DoFHandler<1>::cell_iterator &cell,
vector<Point<1> > &support_points) const {
FiniteElement<1>::get_support_points (cell, support_points);
};
template <>
-void FEQuarticSub<1>::get_face_support_points (const typename DoFHandler<1>::face_iterator &,
+void FEQ4<1>::get_face_support_points (const typename DoFHandler<1>::face_iterator &,
vector<Point<1> > &) const {
Assert (false, ExcInternalError());
};
template <>
-void FEQuarticSub<1>::get_local_mass_matrix (const DoFHandler<1>::cell_iterator &cell,
+void FEQ4<1>::get_local_mass_matrix (const DoFHandler<1>::cell_iterator &cell,
FullMatrix<double> &local_mass_matrix) const {
Assert (local_mass_matrix.n() == total_dofs,
ExcWrongFieldDimension(local_mass_matrix.n(),total_dofs));
#if deal_II_dimension == 2
template <>
-FEQuarticSub<2>::FEQuarticSub () :
+FEQ4<2>::FEQ4 () :
FELinearMapping<2> (1, 3, 9)
{
interface_constraints(0,3) = 1.0;
template <>
-FEQuarticSub<2>::FEQuarticSub (const int) :
+FEQ4<2>::FEQ4 (const int) :
FELinearMapping<2> (0, 0, 25)
{
initialize_matrices ();
template <>
-void FEQuarticSub<2>::initialize_matrices () {
+void FEQ4<2>::initialize_matrices () {
prolongation[0](0,0) = 1.0;
prolongation[0](1,5) = 1.0;
prolongation[0](2,24) = 1.0;
template <>
double
-FEQuarticSub<2>::shape_value (const unsigned int i,
+FEQ4<2>::shape_value (const unsigned int i,
const Point<2> &p) const
{
Assert (i<total_dofs, ExcInvalidIndex(i));
template <>
Tensor<1,2>
-FEQuarticSub<2>::shape_grad (const unsigned int i,
+FEQ4<2>::shape_grad (const unsigned int i,
const Point<2> &p) const
{
Assert (i<total_dofs, ExcInvalidIndex(i));
template <>
Tensor<2,2>
-FEQuarticSub<2>::shape_grad_grad (const unsigned int i,
+FEQ4<2>::shape_grad_grad (const unsigned int i,
const Point<2> &p) const
{
Assert (i<total_dofs, ExcInvalidIndex(i));
template <>
-void FEQuarticSub<2>::get_local_mass_matrix (const DoFHandler<2>::cell_iterator &cell,
+void FEQ4<2>::get_local_mass_matrix (const DoFHandler<2>::cell_iterator &cell,
FullMatrix<double> &local_mass_matrix) const {
Assert (local_mass_matrix.n() == total_dofs,
ExcWrongFieldDimension(local_mass_matrix.n(),total_dofs));
template <>
-void FEQuarticSub<2>::get_unit_support_points (vector<Point<2> > &unit_points) const {
+void FEQ4<2>::get_unit_support_points (vector<Point<2> > &unit_points) const {
Assert (unit_points.size() == total_dofs,
ExcWrongFieldDimension (unit_points.size(), total_dofs));
template <>
-void FEQuarticSub<2>::get_support_points (const typename DoFHandler<2>::cell_iterator &cell,
+void FEQ4<2>::get_support_points (const typename DoFHandler<2>::cell_iterator &cell,
vector<Point<2> > &support_points) const {
Assert (support_points.size() == total_dofs,
ExcWrongFieldDimension (support_points.size(), total_dofs));
template <>
-void FEQuarticSub<2>::get_face_support_points (const typename DoFHandler<2>::face_iterator &face,
+void FEQ4<2>::get_face_support_points (const typename DoFHandler<2>::face_iterator &face,
vector<Point<2> > &support_points) const {
Assert (support_points.size() == dofs_per_face,
ExcWrongFieldDimension (support_points.size(), dofs_per_face));
// explicit instantiations
-template class FEQuarticSub<deal_II_dimension>;
+template class FEQ4<deal_II_dimension>;