]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
regular names for FEDG
authorguido <guido@0785d39b-7218-0410-832d-ea1e28bc413d>
Tue, 4 May 1999 16:27:13 +0000 (16:27 +0000)
committerguido <guido@0785d39b-7218-0410-832d-ea1e28bc413d>
Tue, 4 May 1999 16:27:13 +0000 (16:27 +0000)
git-svn-id: https://svn.dealii.org/trunk@1267 0785d39b-7218-0410-832d-ea1e28bc413d

deal.II/deal.II/include/fe/fe_lib.dg.h
deal.II/deal.II/source/fe/fe_lib.dg.cc
deal.II/deal.II/source/fe/fe_lib.dg.constant.cc

index 03b996dc345447959a9d0ab38477a2fbb56098a8..821f8975f386861693604d210168703a4f198901 100644 (file)
@@ -8,6 +8,11 @@
 
 #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
@@ -104,9 +109,9 @@ class FEDGConstant : public FELinearMapping<dim> {
  *
  * 
  * 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
@@ -118,12 +123,12 @@ class FEDGConstant : public FELinearMapping<dim> {
  * @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
@@ -150,9 +155,9 @@ class FEDGLinear : public FELinear<dim>{
  * 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
@@ -164,12 +169,12 @@ class FEDGLinear : public FELinear<dim>{
  * @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
@@ -196,9 +201,9 @@ class FEDGQuadraticSub : public FEQuadraticSub<dim>{
  * 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
@@ -210,12 +215,12 @@ class FEDGQuadraticSub : public FEQuadraticSub<dim>{
  * @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
@@ -241,9 +246,9 @@ class FEDGCubicSub : public FECubicSub<dim>{
  * 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
@@ -255,12 +260,12 @@ class FEDGCubicSub : public FECubicSub<dim>{
  * @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
index 4936b596829562882c61403eba4d633309c41e8b..a51421a299685eba7d9d8a56ca00b3555a21ff99 100644 (file)
@@ -6,29 +6,29 @@
 
 
 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));
@@ -37,7 +37,7 @@ FEDGLinear<dim>::get_face_support_points (const typename DoFHandler<dim>::face_i
 
 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];
 };
@@ -46,7 +46,7 @@ FEDGLinear<dim>::restrict (const unsigned int child) const {
 
 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));
@@ -55,7 +55,7 @@ FEDGQuadraticSub<dim>::get_face_support_points (const typename DoFHandler<dim>::
 
 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];
 };
@@ -64,7 +64,7 @@ FEDGQuadraticSub<dim>::restrict (const unsigned int child) const {
 
 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));
@@ -73,7 +73,7 @@ FEDGCubicSub<dim>::get_face_support_points (const typename DoFHandler<dim>::face
 
 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];
 };
@@ -83,7 +83,7 @@ FEDGCubicSub<dim>::restrict (const unsigned int child) const {
 
 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));
@@ -92,7 +92,7 @@ FEDGQuarticSub<dim>::get_face_support_points (const typename DoFHandler<dim>::fa
 
 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];
 };
@@ -101,7 +101,7 @@ FEDGQuarticSub<dim>::restrict (const unsigned int child) const {
 
 
 // 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>;
index 10ced322caaabb888787ecb69f0642d19a11be95..700e54f419e9a86418cd826f25577dbe18239193 100644 (file)
@@ -13,7 +13,7 @@
 #if deal_II_dimension == 1
 
 template <>
-FEDGConstant<1>::FEDGConstant () :
+FEDG_Q0<1>::FEDG_Q0 () :
                FELinearMapping<1> (0, 1)
 {
                                   // for restriction and prolongation matrices:
@@ -45,7 +45,7 @@ FEDGConstant<1>::FEDGConstant () :
 
 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());
 };
@@ -58,7 +58,7 @@ FEDGConstant<1>::get_face_support_points (const typename DoFHandler<1>::face_ite
 #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
@@ -90,7 +90,7 @@ FEDGConstant<2>::FEDGConstant () :
 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));
@@ -102,7 +102,7 @@ FEDGConstant<dim>::shape_value (const unsigned int 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));
@@ -114,7 +114,7 @@ FEDGConstant<dim>::shape_grad (const unsigned int 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));
@@ -125,7 +125,7 @@ FEDGConstant<dim>::shape_grad_grad (const unsigned int 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));
@@ -139,7 +139,7 @@ void FEDGConstant<dim>::get_local_mass_matrix (const DoFHandler<dim>::cell_itera
 
 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)
@@ -149,7 +149,7 @@ FEDGConstant<dim>::get_unit_support_points (vector<Point<dim> > &unit_points) co
 
 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));
@@ -160,7 +160,7 @@ FEDGConstant<dim>::get_support_points (const typename DoFHandler<dim>::cell_iter
 
 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));
@@ -170,7 +170,7 @@ FEDGConstant<dim>::get_face_support_points (const typename DoFHandler<dim>::face
 
 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];
 };
@@ -179,4 +179,4 @@ FEDGConstant<dim>::restrict (const unsigned int child) const {
 
 // explicit instantiations
 
-template class FEDGConstant<deal_II_dimension>;
+template class FEDG_Q0<deal_II_dimension>;

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.