#include <fe/fe_lib.lagrange.h>
+#define FEDGConstant FEDG_Q0
+#define FEDGLinear FEDG_Q1
+#define FEDGQuadraticSub FEDG_Q2
+#define FEDGCubicSub FEDG_Q3
+#define FEDGQuarticSub FEDG_Q4
/**
* Define a constant discontinuous finite element in #dim#
* @author Ralf Hartmann, 1998
*/
template <int dim>
-class FEDGConstant : public FELinearMapping<dim> {
+class FEDG_Q0 : public FELinearMapping<dim> {
public:
/**
* Constructor
*/
- FEDGConstant ();
+ FEDG_Q0 ();
/**
* Return the value of the #i#th shape
*
*
* This class is derived from and provides substantially the same
- * as the #FELinear# class. The only difference is the new constructor that
- * calls #FELinear::FELinear(const int)#, the protected constructor of the
- * #FELinear# class using a #FiniteElement# with no dofs in the vertices and
+ * as the #FEQ1# class. The only difference is the new constructor that
+ * calls #FEQ1::FEQ1(const int)#, the protected constructor of the
+ * #FEQ1# class using a #FiniteElement# with no dofs in the vertices and
* $2^d$ dofs per cell. As now the cells do not share any vertex-dof with
* a neighboring cell the $2^d$ dofs per cell can be choosen independently not
* needing any constraints and allowing the use of discontinuous Galerkin
* @author Ralf Hartmann, 1998
*/
template <int dim>
-class FEDGLinear : public FELinear<dim>{
+class FEDG_Q1 : public FEQ1<dim>{
public:
/**
* Constructor
*/
- FEDGLinear();
+ FEDG_Q1();
/**
* Refer to the base class for detailed
* unit cell to the real cell allowing discontinuous Galerkin methods.
*
* This class is derived from and provides substantially the same
- * as the #FEQuadraticSub# class. The only difference is the new constructor that
- * calls #FEQuadraticSub::FEQuadraticSub(const int)#, the protected constructor of the
- * #FEQuadraticSub# class using a #FiniteElement# with no dofs in the vertices, no dofs on the lines and
+ * as the #FEQ2# class. The only difference is the new constructor that
+ * calls #FEQ2::FEQ2(const int)#, the protected constructor of the
+ * #FEQ2# class using a #FiniteElement# with no dofs in the vertices, no dofs on the lines and
* $3^d$ dofs per cell. As now the cells do not share any vertex-dof with
* a neighboring cell the $3^d$ dofs per cell can be choosen independently not
* needing any constraints and allowing the use of discontinuous Galerkin
* @author Ralf Hartmann, 1998
*/
template <int dim>
-class FEDGQuadraticSub : public FEQuadraticSub<dim>{
+class FEDG_Q2 : public FEQ2<dim>{
public:
/**
* Constructor
*/
- FEDGQuadraticSub();
+ FEDG_Q2();
/**
* Refer to the base class for detailed
* unit cell to the real cell allowing discontinuous Galerkin methods.
*
* This class is derived from and provides substantially the same
- * as the #FECubicSub# class. The only difference is the new constructor that
- * calls #FECubicSub::FECubicSub(const int)#, the protected constructor of the
- * #FECubicSub# class using a #FiniteElement# with no dofs in the vertices, no dofs on the lines and
+ * as the #FEQ3# class. The only difference is the new constructor that
+ * calls #FEQ3::FEQ3(const int)#, the protected constructor of the
+ * #FEQ3# class using a #FiniteElement# with no dofs in the vertices, no dofs on the lines and
* $4^d$ dofs per cell. As now the cells do not share any vertex-dof with
* a neighboring cell the $4^d$ dofs per cell can be choosen independently not
* needing any constraints and allowing the use of discontinuous Galerkin
* @author Ralf Hartmann, 1998
*/
template <int dim>
-class FEDGCubicSub : public FECubicSub<dim>{
+class FEDG_Q3 : public FEQ3<dim>{
public:
/**
* Constructor
*/
- FEDGCubicSub();
+ FEDG_Q3();
/**
* Refer to the base class for detailed
* unit cell to the real cell allowing discontinuous Galerkin methods.
*
* This class is derived from and provides substantially the same
- * as the #FEQuarticSub# class. The only difference is the new constructor that
- * calls #FEQuarticSub::FEQuarticSub(const int)#, the protected constructor of the
- * #FEQuarticSub# class using a #FiniteElement# with no dofs in the vertices, no dofs on the lines and
+ * as the #FEQ4# class. The only difference is the new constructor that
+ * calls #FEQ4::FEQ4(const int)#, the protected constructor of the
+ * #FEQ4# class using a #FiniteElement# with no dofs in the vertices, no dofs on the lines and
* $5^d$ dofs per cell. As now the cells do not share any vertex-dof with
* a neighboring cell the $5^d$ dofs per cell can be choosen independently not
* needing any constraints and allowing the use of discontinuous Galerkin
* @author Ralf Hartmann, 1998
*/
template <int dim>
-class FEDGQuarticSub : public FEQuarticSub<dim>{
+class FEDG_Q4 : public FEQ4<dim>{
public:
/**
* Constructor
*/
- FEDGQuarticSub();
+ FEDG_Q4();
/**
* Refer to the base class for detailed
template<int dim>
-FEDGLinear<dim>::FEDGLinear():
- FELinear<dim>(1) {};
+FEDG_Q1<dim>::FEDG_Q1():
+ FEQ1<dim>(1) {};
template<int dim>
-FEDGQuadraticSub<dim>::FEDGQuadraticSub():
- FEQuadraticSub<dim>(1) {};
+FEDG_Q2<dim>::FEDG_Q2():
+ FEQ2<dim>(1) {};
template<int dim>
-FEDGCubicSub<dim>::FEDGCubicSub():
- FECubicSub<dim>(1) {};
+FEDG_Q3<dim>::FEDG_Q3():
+ FEQ3<dim>(1) {};
template<int dim>
-FEDGQuarticSub<dim>::FEDGQuarticSub():
- FEQuarticSub<dim>(1) {};
+FEDG_Q4<dim>::FEDG_Q4():
+ FEQ4<dim>(1) {};
template <int dim>
void
-FEDGLinear<dim>::get_face_support_points (const typename DoFHandler<dim>::face_iterator &,
+FEDG_Q1<dim>::get_face_support_points (const typename DoFHandler<dim>::face_iterator &,
vector<Point<dim> > &support_points) const {
Assert ((support_points.size() == 0),
ExcWrongFieldDimension (support_points.size(),0));
template <int dim>
const FullMatrix<double> &
-FEDGLinear<dim>::restrict (const unsigned int child) const {
+FEDG_Q1<dim>::restrict (const unsigned int child) const {
Assert (false, ExcNotImplemented());
return restriction[child];
};
template <int dim>
void
-FEDGQuadraticSub<dim>::get_face_support_points (const typename DoFHandler<dim>::face_iterator &,
+FEDG_Q2<dim>::get_face_support_points (const typename DoFHandler<dim>::face_iterator &,
vector<Point<dim> > &support_points) const {
Assert ((support_points.size() == 0),
ExcWrongFieldDimension (support_points.size(),0));
template <int dim>
const FullMatrix<double> &
-FEDGQuadraticSub<dim>::restrict (const unsigned int child) const {
+FEDG_Q2<dim>::restrict (const unsigned int child) const {
Assert (false, ExcNotImplemented());
return restriction[child];
};
template <int dim>
void
-FEDGCubicSub<dim>::get_face_support_points (const typename DoFHandler<dim>::face_iterator &,
+FEDG_Q3<dim>::get_face_support_points (const typename DoFHandler<dim>::face_iterator &,
vector<Point<dim> > &support_points) const {
Assert ((support_points.size() == 0),
ExcWrongFieldDimension (support_points.size(),0));
template <int dim>
const FullMatrix<double> &
-FEDGCubicSub<dim>::restrict (const unsigned int child) const {
+FEDG_Q3<dim>::restrict (const unsigned int child) const {
Assert (false, ExcNotImplemented());
return restriction[child];
};
template <int dim>
void
-FEDGQuarticSub<dim>::get_face_support_points (const typename DoFHandler<dim>::face_iterator &,
+FEDG_Q4<dim>::get_face_support_points (const typename DoFHandler<dim>::face_iterator &,
vector<Point<dim> > &support_points) const {
Assert ((support_points.size() == 0),
ExcWrongFieldDimension (support_points.size(),0));
template <int dim>
const FullMatrix<double> &
-FEDGQuarticSub<dim>::restrict (const unsigned int child) const {
+FEDG_Q4<dim>::restrict (const unsigned int child) const {
Assert (false, ExcNotImplemented());
return restriction[child];
};
// explicit instantiations
-template class FEDGLinear<deal_II_dimension>;
-template class FEDGQuadraticSub<deal_II_dimension>;
-template class FEDGCubicSub<deal_II_dimension>;
-template class FEDGQuarticSub<deal_II_dimension>;
+template class FEDG_Q1<deal_II_dimension>;
+template class FEDG_Q2<deal_II_dimension>;
+template class FEDG_Q3<deal_II_dimension>;
+template class FEDG_Q4<deal_II_dimension>;
#if deal_II_dimension == 1
template <>
-FEDGConstant<1>::FEDGConstant () :
+FEDG_Q0<1>::FEDG_Q0 () :
FELinearMapping<1> (0, 1)
{
// for restriction and prolongation matrices:
template <>
void
-FEDGConstant<1>::get_face_support_points (const typename DoFHandler<1>::face_iterator &,
+FEDG_Q0<1>::get_face_support_points (const typename DoFHandler<1>::face_iterator &,
vector<Point<1> > &) const {
Assert (false, ExcInternalError());
};
#if deal_II_dimension == 2
template <>
-FEDGConstant<2>::FEDGConstant () :
+FEDG_Q0<2>::FEDG_Q0 () :
FELinearMapping<2> (0, 0, 1)
{
// The restriction matrices got crazy values
template <int dim>
inline
double
-FEDGConstant<dim>::shape_value (const unsigned int i,
+FEDG_Q0<dim>::shape_value (const unsigned int i,
const Point<dim>&) const
{
Assert((i<total_dofs), ExcInvalidIndex(i));
template <int dim>
inline
Tensor<1,dim>
-FEDGConstant<dim>::shape_grad (const unsigned int i,
+FEDG_Q0<dim>::shape_grad (const unsigned int i,
const Point<dim>&) const
{
Assert((i<total_dofs), ExcInvalidIndex(i));
template <int dim>
inline
Tensor<2,dim>
-FEDGConstant<dim>::shape_grad_grad (const unsigned int i,
+FEDG_Q0<dim>::shape_grad_grad (const unsigned int i,
const Point<dim> &) const
{
Assert((i<total_dofs), ExcInvalidIndex(i));
template <int dim>
-void FEDGConstant<dim>::get_local_mass_matrix (const DoFHandler<dim>::cell_iterator &cell,
+void FEDG_Q0<dim>::get_local_mass_matrix (const DoFHandler<dim>::cell_iterator &cell,
FullMatrix<double> &local_mass_matrix) const {
Assert (local_mass_matrix.n() == total_dofs,
ExcWrongFieldDimension(local_mass_matrix.n(),total_dofs));
template <int dim>
void
-FEDGConstant<dim>::get_unit_support_points (vector<Point<dim> > &unit_points) const {
+FEDG_Q0<dim>::get_unit_support_points (vector<Point<dim> > &unit_points) const {
Assert (unit_points.size() == total_dofs,
ExcWrongFieldDimension (unit_points.size(), total_dofs));
for (unsigned int d=0; d<dim; ++d)
template <int dim>
void
-FEDGConstant<dim>::get_support_points (const typename DoFHandler<dim>::cell_iterator &cell,
+FEDG_Q0<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
-FEDGConstant<dim>::get_face_support_points (const typename DoFHandler<dim>::face_iterator &,
+FEDG_Q0<dim>::get_face_support_points (const typename DoFHandler<dim>::face_iterator &,
vector<Point<dim> > &support_points) const {
Assert ((support_points.size() == 0),
ExcWrongFieldDimension (support_points.size(),0));
template <int dim>
const FullMatrix<double> &
-FEDGConstant<dim>::restrict (const unsigned int child) const {
+FEDG_Q0<dim>::restrict (const unsigned int child) const {
Assert (false, ExcNotImplemented());
return restriction[child];
};
// explicit instantiations
-template class FEDGConstant<deal_II_dimension>;
+template class FEDG_Q0<deal_II_dimension>;