]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Make compilation process specific of the space dimension wanted. This avoid unnecessa...
authorWolfgang Bangerth <bangerth@math.tamu.edu>
Tue, 2 Jun 1998 11:26:13 +0000 (11:26 +0000)
committerWolfgang Bangerth <bangerth@math.tamu.edu>
Tue, 2 Jun 1998 11:26:13 +0000 (11:26 +0000)
git-svn-id: https://svn.dealii.org/trunk@372 0785d39b-7218-0410-832d-ea1e28bc413d

21 files changed:
deal.II/base/source/function.cc
deal.II/base/source/quadrature.cc
deal.II/base/source/quadrature_lib.cc
deal.II/deal.II/Attic/examples/poisson/Makefile
deal.II/deal.II/Attic/examples/poisson/equation.cc
deal.II/deal.II/Make.global_options
deal.II/deal.II/source/dofs/dof_accessor.cc
deal.II/deal.II/source/dofs/dof_handler.cc
deal.II/deal.II/source/fe/fe.cc
deal.II/deal.II/source/fe/fe_lib.linear.cc
deal.II/deal.II/source/fe/fe_values.cc
deal.II/deal.II/source/grid/tria.cc
deal.II/deal.II/source/grid/tria_accessor.cc
deal.II/deal.II/source/numerics/assembler.cc
deal.II/deal.II/source/numerics/base.cc
deal.II/deal.II/source/numerics/data_io.cc
deal.II/deal.II/source/numerics/error_estimator.cc
deal.II/deal.II/source/numerics/matrices.cc
deal.II/deal.II/source/numerics/vectors.cc
tests/big-tests/poisson/Makefile
tests/big-tests/poisson/equation.cc

index 4218a50a18de8a1642a66b4445b40a747e04587e..f6d462218000e29e7c01733edb7afba67ad9ff2a 100644 (file)
@@ -151,11 +151,7 @@ void ConstantFunction<dim>::value_list (const vector<Point<dim> > &points,
 
 
 // explicit instantiations
-template class Function<1>;
-template class Function<2>;
 
-template class ZeroFunction<1>;
-template class ZeroFunction<2>;
-
-template class ConstantFunction<1>;
-template class ConstantFunction<2>;
+template class Function<deal_II_dimension>;
+template class ZeroFunction<deal_II_dimension>;
+template class ConstantFunction<deal_II_dimension>;
index c84fba356a557dc29f3f6d6f7722a952e3e1a11e..63182b380b32197b60c6c5eeb5b099dd9074fcf9 100644 (file)
@@ -46,6 +46,7 @@ const vector<double> & Quadrature<dim>::get_weights () const {
 
 
 
+#if deal_II_dimension == 2
 
 template <>
 void QProjector<2>::project_to_face (const Quadrature<1> &quadrature,
@@ -147,9 +148,10 @@ void QProjector<2>::project_to_subface (const Quadrature<1> &quadrature,
       };
 };
 
+#endif
 
 
 
-// explicite instantiations
+// explicit instantiations; note: we need them all for all dimensions
 template class Quadrature<1>;
 template class Quadrature<2>;
index 127862ba9b46a8eb3cbe9026ddf6d54f05b815d8..595e72cb5be4669029504dfb203877bfaa82c7e8 100644 (file)
@@ -4,6 +4,13 @@
 #include <cmath>
 
 
+// please note: for a given dimension, we need the quadrature formulae
+// for all lower dimensions as well. That is why in this file the check
+// is for deal_II_dimension >= any_number and not for ==
+
+
+
+#if deal_II_dimension >= 1
 
 template <>
 QGauss2<1>::QGauss2 () :
@@ -30,59 +37,138 @@ QGauss2<1>::QGauss2 () :
 
 
 template <>
-QGauss2<2>::QGauss2 () :
-               Quadrature<2> (4)
+QGauss3<1>::QGauss3 () :
+               Quadrature<1> (3)
 {
                                   // points on [-1,1]
-  static const double xpts_normal[] = { -sqrt(1./3.), sqrt(1./3.) };
+  static const double xpts_normal[] = { -sqrt(3./5.),
+                                       0.,
+                                       sqrt(3./5.) };
                                   // weights on [-1,1]
-  static const double wts_normal[]  = { 1., 1. };
+  static const double wts_normal[]  = { 5./9.,
+                                       8./9.,
+                                       5./9. };
 
-                                  // points and weights on [0,1]^2
+                                  // points and weights on [0,1]
   static const double xpts[] = { (xpts_normal[0]+1)/2.,
-                                (xpts_normal[0]+1)/2.,
                                 (xpts_normal[1]+1)/2.,
-                                (xpts_normal[1]+1)/2.  };
-  static const double ypts[] = { (xpts_normal[0]+1)/2.,
+                                (xpts_normal[2]+1)/2. };
+  static const double wts[]  = { wts_normal[0]/2.,
+                                wts_normal[1]/2.,
+                                wts_normal[2]/2. };
+
+  for (unsigned int i=0; i<n_quadrature_points; ++i) 
+    {
+      quadrature_points[i] = Point<1>(xpts[i]);
+      weights[i] = wts[i];
+    };
+};
+
+
+template <>
+QGauss4<1>::QGauss4 () :
+               Quadrature<1> (4)
+{
+                                  // points on [-1,1]
+  static const double xpts_normal[] = { -sqrt(1./7.*(3-4*sqrt(0.3))),
+                                       -sqrt(1./7.*(3+4*sqrt(0.3))),
+                                       +sqrt(1./7.*(3-4*sqrt(0.3))),
+                                       +sqrt(1./7.*(3+4*sqrt(0.3)))  };
+                                  // weights on [-1,1]
+  static const double wts_normal[]  = { 1./2. + 1./12.*sqrt(10./3.),
+                                       1./2. - 1./12.*sqrt(10./3.),
+                                       1./2. + 1./12.*sqrt(10./3.),
+                                       1./2. - 1./12.*sqrt(10./3.)  };
+
+                                  // points and weights on [0,1]
+  static const double xpts[] = { (xpts_normal[0]+1)/2.,
                                 (xpts_normal[1]+1)/2.,
-                                (xpts_normal[0]+1)/2.,
-                                (xpts_normal[1]+1)/2.  };
-  static const double wts[]  = { wts_normal[0]/4.,
-                                wts_normal[1]/4.,
-                                wts_normal[0]/4.,
-                                wts_normal[1]/4.  };
+                                (xpts_normal[2]+1)/2.,
+                                (xpts_normal[3]+1)/2. };
+  static const double wts[]  = { wts_normal[0]/2.,
+                                wts_normal[1]/2.,
+                                wts_normal[2]/2.,
+                                wts_normal[3]/2. };
 
   for (unsigned int i=0; i<n_quadrature_points; ++i) 
     {
-      quadrature_points[i] = Point<2>(xpts[i], ypts[i]);
+      quadrature_points[i] = Point<1>(xpts[i]);
       weights[i] = wts[i];
     };
 };
 
 
 
+template <>
+QGauss5<1>::QGauss5 () :
+               Quadrature<1> (5)
+{
+                                  // points on [-1,1]
+  static const double xpts_normal[] = { -sqrt(1./9.*(5.-2*sqrt(10./7.))),
+                                       -sqrt(1./9.*(5.+2*sqrt(10./7.))),
+                                       0,
+                                       +sqrt(1./9.*(5.-2*sqrt(10./7.))),
+                                       +sqrt(1./9.*(5.+2*sqrt(10./7.)))  };
+                                  // weights on [-1,1]
+  static const double wts_normal[]  = { 0.3*(-0.7+5.*sqrt(0.7))/(-2.+5.*sqrt(0.7)),
+                                       0.3*(+0.7+5.*sqrt(0.7))/(+2.+5.*sqrt(0.7)),
+                                       128./225.,
+                                       0.3*(-0.7+5.*sqrt(0.7))/(-2.+5.*sqrt(0.7)),
+                                       0.3*(+0.7+5.*sqrt(0.7))/(+2.+5.*sqrt(0.7)) };
+
+                                  // points and weights on [0,1]
+  static const double xpts[] = { (xpts_normal[0]+1)/2.,
+                                (xpts_normal[1]+1)/2.,
+                                (xpts_normal[2]+1)/2.,
+                                (xpts_normal[3]+1)/2.,
+                                (xpts_normal[4]+1)/2. };
+  static const double wts[]  = { wts_normal[0]/2.,
+                                wts_normal[1]/2.,
+                                wts_normal[2]/2.,
+                                wts_normal[3]/2.,
+                                wts_normal[4]/2. };
+
+  for (unsigned int i=0; i<n_quadrature_points; ++i) 
+    {
+      quadrature_points[i] = Point<1>(xpts[i]);
+      weights[i] = wts[i];
+    };
+};
+
 
 
 template <>
-QGauss3<1>::QGauss3 () :
-               Quadrature<1> (3)
+QGauss6<1>::QGauss6 () :
+               Quadrature<1> (6)
 {
                                   // points on [-1,1]
-  static const double xpts_normal[] = { -sqrt(3./5.),
-                                       0.,
-                                       sqrt(3./5.) };
+  static const double xpts_normal[] = { -0.932469514203152,
+                                       -0.661209386466265,
+                                       -0.238619186083197,
+                                       +0.238619186083197,
+                                       +0.661209386466265,
+                                       +0.932469514203152  };
                                   // weights on [-1,1]
-  static const double wts_normal[]  = { 5./9.,
-                                       8./9.,
-                                       5./9. };
+  static const double wts_normal[]  = { 0.171324492379170,
+                                       0.360761573048139,
+                                       0.467913934572691,
+                                       0.467913934572691,
+                                       0.360761573048139,
+                                       0.171324492379170  };
 
                                   // points and weights on [0,1]
   static const double xpts[] = { (xpts_normal[0]+1)/2.,
                                 (xpts_normal[1]+1)/2.,
-                                (xpts_normal[2]+1)/2. };
+                                (xpts_normal[2]+1)/2.,
+                                (xpts_normal[3]+1)/2.,
+                                (xpts_normal[4]+1)/2.,
+                                (xpts_normal[5]+1)/2. };
   static const double wts[]  = { wts_normal[0]/2.,
                                 wts_normal[1]/2.,
-                                wts_normal[2]/2. };
+                                wts_normal[2]/2.,
+                                wts_normal[3]/2.,
+                                wts_normal[4]/2.,
+                                wts_normal[5]/2. };
 
   for (unsigned int i=0; i<n_quadrature_points; ++i) 
     {
@@ -94,47 +180,170 @@ QGauss3<1>::QGauss3 () :
 
 
 template <>
-QGauss3<2>::QGauss3 () :
-               Quadrature<2> (9)
+QGauss7<1>::QGauss7 () :
+               Quadrature<1> (7)
 {
                                   // points on [-1,1]
-  static const double xpts_normal[] = { -sqrt(3./5.),
-                                       0.,
-                                       sqrt(3./5.) };
+  static const double xpts_normal[] = { -0.949107912342759,
+                                       -0.741531185599394,
+                                       -0.405845151377397,
+                                       0,
+                                       +0.405845151377397,
+                                       +0.741531185599394,
+                                       +0.949107912342759 };
                                   // weights on [-1,1]
-  static const double wts_normal[]  = { 5./9.,
-                                       8./9.,
-                                       5./9. };
+  static const double wts_normal[]  = { 0.129484966168870,
+                                       0.279705391489277,
+                                       0.381830050505119,
+                                       0.417959183673469,
+                                       0.381830050505119,
+                                       0.279705391489277,
+                                       0.129484966168870  };
 
-                                  // points and weights on [0,1]^2
+                                  // points and weights on [0,1]
   static const double xpts[] = { (xpts_normal[0]+1)/2.,
                                 (xpts_normal[1]+1)/2.,
                                 (xpts_normal[2]+1)/2.,
-                                (xpts_normal[0]+1)/2.,
+                                (xpts_normal[3]+1)/2.,
+                                (xpts_normal[4]+1)/2.,
+                                (xpts_normal[5]+1)/2.,
+                                (xpts_normal[6]+1)/2. };
+  static const double wts[]  = { wts_normal[0]/2.,
+                                wts_normal[1]/2.,
+                                wts_normal[2]/2.,
+                                wts_normal[3]/2.,
+                                wts_normal[4]/2.,
+                                wts_normal[5]/2.,
+                                wts_normal[6]/2. };
+
+  for (unsigned int i=0; i<n_quadrature_points; ++i) 
+    {
+      quadrature_points[i] = Point<1>(xpts[i]);
+      weights[i] = wts[i];
+    };
+};
+
+
+
+template <>
+QGauss8<1>::QGauss8 () :
+               Quadrature<1> (8)
+{
+                                  // points on [-1,1]
+  static const double xpts_normal[] = { -0.960289856497536,
+                                       -0.796666477413627,
+                                       -0.525532409916329,
+                                       -0.183434642495650,
+                                       +0.183434642495650,
+                                       +0.525532409916329,
+                                       +0.796666477413627,
+                                       +0.960289856497536 };
+                                  // weights on [-1,1]
+  static const double wts_normal[]  = { 0.101228536200376,
+                                       0.222381034453374,
+                                       0.313706645877887,
+                                       0.362683783378362,
+                                       0.362683783378362,
+                                       0.313706645877887,
+                                       0.222381034453374,
+                                       0.101228536200376  };
+
+                                  // points and weights on [0,1]
+  static const double xpts[] = { (xpts_normal[0]+1)/2.,
                                 (xpts_normal[1]+1)/2.,
                                 (xpts_normal[2]+1)/2.,
+                                (xpts_normal[3]+1)/2.,
+                                (xpts_normal[4]+1)/2.,
+                                (xpts_normal[5]+1)/2.,
+                                (xpts_normal[6]+1)/2.,
+                                (xpts_normal[7]+1)/2. };
+  static const double wts[]  = { wts_normal[0]/2.,
+                                wts_normal[1]/2.,
+                                wts_normal[2]/2.,
+                                wts_normal[3]/2.,
+                                wts_normal[4]/2.,
+                                wts_normal[5]/2.,
+                                wts_normal[6]/2.,
+                                wts_normal[7]/2. };
+
+  for (unsigned int i=0; i<n_quadrature_points; ++i) 
+    {
+      quadrature_points[i] = Point<1>(xpts[i]);
+      weights[i] = wts[i];
+    };
+};
+
+
+
+template <>
+QMidpoint<1>::QMidpoint () :
+               Quadrature<1>(1)
+{
+  quadrature_points[0] = Point<1>(0.5);
+  weights[0] = 1.0;
+};
+
+
+
+template <>
+QSimpson<1>::QSimpson () :
+               Quadrature<1> (3)
+{
+  static const double xpts[] = { 0.0, 0.5, 1.0 };
+  static const double wts[]  = { 1./6., 2./3., 1./6. };
+
+  for (unsigned int i=0; i<n_quadrature_points; ++i) 
+    {
+      quadrature_points[i] = Point<1>(xpts[i]);
+      weights[i] = wts[i];
+    };
+};
+
+
+
+template <>
+QTrapez<1>::QTrapez () :
+               Quadrature<1> (2)
+{
+  static const double xpts[] = { 0.0, 1.0 };
+  static const double wts[]  = { 0.5, 0.5 };
+
+  for (unsigned int i=0; i<n_quadrature_points; ++i) 
+    {
+      quadrature_points[i] = Point<1>(xpts[i]);
+      weights[i] = wts[i];
+    };
+};
+
+#endif
+
+
+
+#if deal_II_dimension >= 2
+
+template <>
+QGauss2<2>::QGauss2 () :
+               Quadrature<2> (4)
+{
+                                  // points on [-1,1]
+  static const double xpts_normal[] = { -sqrt(1./3.), sqrt(1./3.) };
+                                  // weights on [-1,1]
+  static const double wts_normal[]  = { 1., 1. };
+
+                                  // points and weights on [0,1]^2
+  static const double xpts[] = { (xpts_normal[0]+1)/2.,
                                 (xpts_normal[0]+1)/2.,
                                 (xpts_normal[1]+1)/2.,
-                                (xpts_normal[2]+1)/2.  };
+                                (xpts_normal[1]+1)/2.  };
   static const double ypts[] = { (xpts_normal[0]+1)/2.,
-                                (xpts_normal[0]+1)/2.,
-                                (xpts_normal[0]+1)/2.,
-                                (xpts_normal[1]+1)/2.,
-                                (xpts_normal[1]+1)/2.,
                                 (xpts_normal[1]+1)/2.,
-                                (xpts_normal[2]+1)/2.,
-                                (xpts_normal[2]+1)/2.,
-                                (xpts_normal[2]+1)/2.  };
-  static const double wts[]  = { wts_normal[0]/2.*wts_normal[0]/2.,
-                                wts_normal[1]/2.*wts_normal[0]/2.,
-                                wts_normal[2]/2.*wts_normal[0]/2.,
-                                wts_normal[0]/2.*wts_normal[1]/2.,
-                                wts_normal[1]/2.*wts_normal[1]/2.,
-                                wts_normal[2]/2.*wts_normal[1]/2.,
-                                wts_normal[0]/2.*wts_normal[2]/2.,
-                                wts_normal[1]/2.*wts_normal[2]/2.,
-                                wts_normal[2]/2.*wts_normal[2]/2. };
-  
+                                (xpts_normal[0]+1)/2.,
+                                (xpts_normal[1]+1)/2.  };
+  static const double wts[]  = { wts_normal[0]/4.,
+                                wts_normal[1]/4.,
+                                wts_normal[0]/4.,
+                                wts_normal[1]/4.  };
+
   for (unsigned int i=0; i<n_quadrature_points; ++i) 
     {
       quadrature_points[i] = Point<2>(xpts[i], ypts[i]);
@@ -144,37 +353,51 @@ QGauss3<2>::QGauss3 () :
 
 
 
-
-
-
 template <>
-QGauss4<1>::QGauss4 () :
-               Quadrature<1> (4)
+QGauss3<2>::QGauss3 () :
+               Quadrature<2> (9)
 {
                                   // points on [-1,1]
-  static const double xpts_normal[] = { -sqrt(1./7.*(3-4*sqrt(0.3))),
-                                       -sqrt(1./7.*(3+4*sqrt(0.3))),
-                                       +sqrt(1./7.*(3-4*sqrt(0.3))),
-                                       +sqrt(1./7.*(3+4*sqrt(0.3)))  };
+  static const double xpts_normal[] = { -sqrt(3./5.),
+                                       0.,
+                                       sqrt(3./5.) };
                                   // weights on [-1,1]
-  static const double wts_normal[]  = { 1./2. + 1./12.*sqrt(10./3.),
-                                       1./2. - 1./12.*sqrt(10./3.),
-                                       1./2. + 1./12.*sqrt(10./3.),
-                                       1./2. - 1./12.*sqrt(10./3.)  };
+  static const double wts_normal[]  = { 5./9.,
+                                       8./9.,
+                                       5./9. };
 
-                                  // points and weights on [0,1]
+                                  // points and weights on [0,1]^2
   static const double xpts[] = { (xpts_normal[0]+1)/2.,
                                 (xpts_normal[1]+1)/2.,
                                 (xpts_normal[2]+1)/2.,
-                                (xpts_normal[3]+1)/2. };
-  static const double wts[]  = { wts_normal[0]/2.,
-                                wts_normal[1]/2.,
-                                wts_normal[2]/2.,
-                                wts_normal[3]/2. };
-
+                                (xpts_normal[0]+1)/2.,
+                                (xpts_normal[1]+1)/2.,
+                                (xpts_normal[2]+1)/2.,
+                                (xpts_normal[0]+1)/2.,
+                                (xpts_normal[1]+1)/2.,
+                                (xpts_normal[2]+1)/2.  };
+  static const double ypts[] = { (xpts_normal[0]+1)/2.,
+                                (xpts_normal[0]+1)/2.,
+                                (xpts_normal[0]+1)/2.,
+                                (xpts_normal[1]+1)/2.,
+                                (xpts_normal[1]+1)/2.,
+                                (xpts_normal[1]+1)/2.,
+                                (xpts_normal[2]+1)/2.,
+                                (xpts_normal[2]+1)/2.,
+                                (xpts_normal[2]+1)/2.  };
+  static const double wts[]  = { wts_normal[0]/2.*wts_normal[0]/2.,
+                                wts_normal[1]/2.*wts_normal[0]/2.,
+                                wts_normal[2]/2.*wts_normal[0]/2.,
+                                wts_normal[0]/2.*wts_normal[1]/2.,
+                                wts_normal[1]/2.*wts_normal[1]/2.,
+                                wts_normal[2]/2.*wts_normal[1]/2.,
+                                wts_normal[0]/2.*wts_normal[2]/2.,
+                                wts_normal[1]/2.*wts_normal[2]/2.,
+                                wts_normal[2]/2.*wts_normal[2]/2. };
+  
   for (unsigned int i=0; i<n_quadrature_points; ++i) 
     {
-      quadrature_points[i] = Point<1>(xpts[i]);
+      quadrature_points[i] = Point<2>(xpts[i], ypts[i]);
       weights[i] = wts[i];
     };
 };
@@ -255,45 +478,6 @@ QGauss4<2>::QGauss4 () :
 
 
 
-
-template <>
-QGauss5<1>::QGauss5 () :
-               Quadrature<1> (5)
-{
-                                  // points on [-1,1]
-  static const double xpts_normal[] = { -sqrt(1./9.*(5.-2*sqrt(10./7.))),
-                                       -sqrt(1./9.*(5.+2*sqrt(10./7.))),
-                                       0,
-                                       +sqrt(1./9.*(5.-2*sqrt(10./7.))),
-                                       +sqrt(1./9.*(5.+2*sqrt(10./7.)))  };
-                                  // weights on [-1,1]
-  static const double wts_normal[]  = { 0.3*(-0.7+5.*sqrt(0.7))/(-2.+5.*sqrt(0.7)),
-                                       0.3*(+0.7+5.*sqrt(0.7))/(+2.+5.*sqrt(0.7)),
-                                       128./225.,
-                                       0.3*(-0.7+5.*sqrt(0.7))/(-2.+5.*sqrt(0.7)),
-                                       0.3*(+0.7+5.*sqrt(0.7))/(+2.+5.*sqrt(0.7)) };
-
-                                  // points and weights on [0,1]
-  static const double xpts[] = { (xpts_normal[0]+1)/2.,
-                                (xpts_normal[1]+1)/2.,
-                                (xpts_normal[2]+1)/2.,
-                                (xpts_normal[3]+1)/2.,
-                                (xpts_normal[4]+1)/2. };
-  static const double wts[]  = { wts_normal[0]/2.,
-                                wts_normal[1]/2.,
-                                wts_normal[2]/2.,
-                                wts_normal[3]/2.,
-                                wts_normal[4]/2. };
-
-  for (unsigned int i=0; i<n_quadrature_points; ++i) 
-    {
-      quadrature_points[i] = Point<1>(xpts[i]);
-      weights[i] = wts[i];
-    };
-};
-
-
-
 template <>
 QGauss5<2>::QGauss5 () :
                Quadrature<2> (25)
@@ -411,160 +595,6 @@ QGauss5<2>::QGauss5 () :
 
 
 
-template <>
-QGauss6<1>::QGauss6 () :
-               Quadrature<1> (6)
-{
-                                  // points on [-1,1]
-  static const double xpts_normal[] = { -0.932469514203152,
-                                       -0.661209386466265,
-                                       -0.238619186083197,
-                                       +0.238619186083197,
-                                       +0.661209386466265,
-                                       +0.932469514203152  };
-                                  // weights on [-1,1]
-  static const double wts_normal[]  = { 0.171324492379170,
-                                       0.360761573048139,
-                                       0.467913934572691,
-                                       0.467913934572691,
-                                       0.360761573048139,
-                                       0.171324492379170  };
-
-                                  // points and weights on [0,1]
-  static const double xpts[] = { (xpts_normal[0]+1)/2.,
-                                (xpts_normal[1]+1)/2.,
-                                (xpts_normal[2]+1)/2.,
-                                (xpts_normal[3]+1)/2.,
-                                (xpts_normal[4]+1)/2.,
-                                (xpts_normal[5]+1)/2. };
-  static const double wts[]  = { wts_normal[0]/2.,
-                                wts_normal[1]/2.,
-                                wts_normal[2]/2.,
-                                wts_normal[3]/2.,
-                                wts_normal[4]/2.,
-                                wts_normal[5]/2. };
-
-  for (unsigned int i=0; i<n_quadrature_points; ++i) 
-    {
-      quadrature_points[i] = Point<1>(xpts[i]);
-      weights[i] = wts[i];
-    };
-};
-
-
-
-template <>
-QGauss7<1>::QGauss7 () :
-               Quadrature<1> (7)
-{
-                                  // points on [-1,1]
-  static const double xpts_normal[] = { -0.949107912342759,
-                                       -0.741531185599394,
-                                       -0.405845151377397,
-                                       0,
-                                       +0.405845151377397,
-                                       +0.741531185599394,
-                                       +0.949107912342759 };
-                                  // weights on [-1,1]
-  static const double wts_normal[]  = { 0.129484966168870,
-                                       0.279705391489277,
-                                       0.381830050505119,
-                                       0.417959183673469,
-                                       0.381830050505119,
-                                       0.279705391489277,
-                                       0.129484966168870  };
-
-                                  // points and weights on [0,1]
-  static const double xpts[] = { (xpts_normal[0]+1)/2.,
-                                (xpts_normal[1]+1)/2.,
-                                (xpts_normal[2]+1)/2.,
-                                (xpts_normal[3]+1)/2.,
-                                (xpts_normal[4]+1)/2.,
-                                (xpts_normal[5]+1)/2.,
-                                (xpts_normal[6]+1)/2. };
-  static const double wts[]  = { wts_normal[0]/2.,
-                                wts_normal[1]/2.,
-                                wts_normal[2]/2.,
-                                wts_normal[3]/2.,
-                                wts_normal[4]/2.,
-                                wts_normal[5]/2.,
-                                wts_normal[6]/2. };
-
-  for (unsigned int i=0; i<n_quadrature_points; ++i) 
-    {
-      quadrature_points[i] = Point<1>(xpts[i]);
-      weights[i] = wts[i];
-    };
-};
-
-
-
-template <>
-QGauss8<1>::QGauss8 () :
-               Quadrature<1> (8)
-{
-                                  // points on [-1,1]
-  static const double xpts_normal[] = { -0.960289856497536,
-                                       -0.796666477413627,
-                                       -0.525532409916329,
-                                       -0.183434642495650,
-                                       +0.183434642495650,
-                                       +0.525532409916329,
-                                       +0.796666477413627,
-                                       +0.960289856497536 };
-                                  // weights on [-1,1]
-  static const double wts_normal[]  = { 0.101228536200376,
-                                       0.222381034453374,
-                                       0.313706645877887,
-                                       0.362683783378362,
-                                       0.362683783378362,
-                                       0.313706645877887,
-                                       0.222381034453374,
-                                       0.101228536200376  };
-
-                                  // points and weights on [0,1]
-  static const double xpts[] = { (xpts_normal[0]+1)/2.,
-                                (xpts_normal[1]+1)/2.,
-                                (xpts_normal[2]+1)/2.,
-                                (xpts_normal[3]+1)/2.,
-                                (xpts_normal[4]+1)/2.,
-                                (xpts_normal[5]+1)/2.,
-                                (xpts_normal[6]+1)/2.,
-                                (xpts_normal[7]+1)/2. };
-  static const double wts[]  = { wts_normal[0]/2.,
-                                wts_normal[1]/2.,
-                                wts_normal[2]/2.,
-                                wts_normal[3]/2.,
-                                wts_normal[4]/2.,
-                                wts_normal[5]/2.,
-                                wts_normal[6]/2.,
-                                wts_normal[7]/2. };
-
-  for (unsigned int i=0; i<n_quadrature_points; ++i) 
-    {
-      quadrature_points[i] = Point<1>(xpts[i]);
-      weights[i] = wts[i];
-    };
-};
-
-
-
-
-
-
-
-
-
-template <>
-QMidpoint<1>::QMidpoint () :
-               Quadrature<1>(1)
-{
-  quadrature_points[0] = Point<1>(0.5);
-  weights[0] = 1.0;
-};
-
-
-
 template <>
 QMidpoint<2>::QMidpoint () :
                Quadrature<2>(1)
@@ -575,23 +605,6 @@ QMidpoint<2>::QMidpoint () :
 
 
 
-
-template <>
-QSimpson<1>::QSimpson () :
-               Quadrature<1> (3)
-{
-  static const double xpts[] = { 0.0, 0.5, 1.0 };
-  static const double wts[]  = { 1./6., 2./3., 1./6. };
-
-  for (unsigned int i=0; i<n_quadrature_points; ++i) 
-    {
-      quadrature_points[i] = Point<1>(xpts[i]);
-      weights[i] = wts[i];
-    };
-};
-
-
-
 template <>
 QSimpson<2>::QSimpson () :
                Quadrature<2> (9)
@@ -615,25 +628,6 @@ QSimpson<2>::QSimpson () :
 
 
 
-
-
-
-template <>
-QTrapez<1>::QTrapez () :
-               Quadrature<1> (2)
-{
-  static const double xpts[] = { 0.0, 1.0 };
-  static const double wts[]  = { 0.5, 0.5 };
-
-  for (unsigned int i=0; i<n_quadrature_points; ++i) 
-    {
-      quadrature_points[i] = Point<1>(xpts[i]);
-      weights[i] = wts[i];
-    };
-};
-
-
-
 template <>
 QTrapez<2>::QTrapez () :
                Quadrature<2> (4)
@@ -649,6 +643,4 @@ QTrapez<2>::QTrapez () :
     };
 };
 
-
-
-
+#endif
index 6c3cbc83fbce9fe715ccd6d383b40c92a6508e97..7fcb84c7b66b4382434ae1659bbff4b3e0af3fc2 100644 (file)
@@ -15,7 +15,7 @@ debug-mode = on
 
 # If you want your program to be linked with extra object or library
 # files, specify them here:
-user-libs = ../../../mia/control.o
+user-libs = ../../../mia/control.o ../../lib/libfe.g.a
 
 # To run the program, use "make run"; to give parameters to the program,
 # give the parameters to the following variable:
index ea43603d23af54617c570d65d91430ef4d56b149..c598c614beb165bf81bca392a076ddd8b26f7cf8 100644 (file)
@@ -5,7 +5,7 @@
 
 
 
-
+#if deal_II_dimension == 1
 
 void PoissonEquation<1>::assemble (dFMatrix            &cell_matrix,
                                   dVector             &rhs,
@@ -24,8 +24,12 @@ void PoissonEquation<1>::assemble (dFMatrix            &cell_matrix,
       };
 };
 
+#endif
+
 
 
+#if deal_II_dimension == 2
+
 void PoissonEquation<2>::assemble (dFMatrix            &cell_matrix,
                                   dVector             &rhs,
                                   const FEValues<2>   &fe_values,
@@ -50,6 +54,8 @@ void PoissonEquation<2>::assemble (dFMatrix            &cell_matrix,
       };
 };
 
+#endif
+
 
 
 template <int dim>
@@ -73,5 +79,4 @@ void PoissonEquation<dim>::assemble (dVector             &,
 
 
 
-template class PoissonEquation<1>;
 template class PoissonEquation<2>;
index 482794363a9720a080b5f1e70df044b7437e397a..556c86ad322b8ed24e99b566fa4d37dbd6257e21 100644 (file)
@@ -1,16 +1,18 @@
 # $Id$
 # Global options for all compilations
 
+deal_II_dimension=2
 
 CXX       = c++
 INCLUDE   = -I../../include -I../../../lac/include \
             -I../../../base/include -I../../../mia/include
 CXXFLAGS.g= -DDEBUG -g -Wall -W -pedantic -Wconversion \
             -Winline -Woverloaded-virtual -fno-rtti -fno-exceptions \
-            $(INCLUDE)
+            $(INCLUDE) -Ddeal_II_dimension=$(deal_II_dimension)
 CXXFLAGS  =-O3 -Wuninitialized -finline-functions -ffast-math \
            -funroll-loops -felide-constructors -fnonnull-objects \
-           -pg -fno-rtti -fno-exceptions $(INCLUDE)
+           -pg -fno-rtti -fno-exceptions $(INCLUDE) \
+           -Ddeal_II_dimension=$(deal_II_dimension)
 
 ifeq ($(shell uname),Linux)
 CXX       = /home/wolf/bin/gcc/bin/c++
index ab6223817d46f0062168da9bd5c05038899e0809..06c09029348af152f4777130dcd95a038b5bdc5e 100644 (file)
@@ -15,7 +15,7 @@
 /*------------------------- Functions: DoFLineAccessor -----------------------*/
 
 
-template <int dim, class BaseClass>
+template <int dim, typename BaseClass>
 int DoFLineAccessor<dim,BaseClass>::dof_index (const unsigned int i) const {
   Assert (dof_handler != 0, ExcInvalidObject());
                                   // make sure a FE has been selected
@@ -32,7 +32,7 @@ int DoFLineAccessor<dim,BaseClass>::dof_index (const unsigned int i) const {
 
 
 
-template <int dim, class BaseClass>
+template <int dim, typename BaseClass>
 void DoFLineAccessor<dim,BaseClass>::set_dof_index (const unsigned int i,
                                                    const int index) const {
   Assert (dof_handler != 0, ExcInvalidObject());
@@ -49,7 +49,7 @@ void DoFLineAccessor<dim,BaseClass>::set_dof_index (const unsigned int i,
 
 
 
-template <int dim, class BaseClass>
+template <int dim, typename BaseClass>
 int DoFLineAccessor<dim,BaseClass>::vertex_dof_index (const unsigned int vertex,
                                                      const unsigned int i) const {
   Assert (dof_handler != 0, ExcInvalidObject());
@@ -66,7 +66,7 @@ int DoFLineAccessor<dim,BaseClass>::vertex_dof_index (const unsigned int vertex,
 
 
   
-template <int dim, class BaseClass>
+template <int dim, typename BaseClass>
 void DoFLineAccessor<dim,BaseClass>::set_vertex_dof_index (const unsigned int vertex,
                                                           const unsigned int i,
                                                           const int index) const {
@@ -84,7 +84,7 @@ void DoFLineAccessor<dim,BaseClass>::set_vertex_dof_index (const unsigned int ve
 
 
 
-template <int dim, class BaseClass>
+template <int dim, typename BaseClass>
 void
 DoFLineAccessor<dim,BaseClass>::get_dof_indices (vector<int> &dof_indices) const {
   Assert (dof_handler != 0, ExcInvalidObject());
@@ -105,7 +105,7 @@ DoFLineAccessor<dim,BaseClass>::get_dof_indices (vector<int> &dof_indices) const
 
 
 
-template <int dim, class BaseClass>
+template <int dim, typename BaseClass>
 TriaIterator<dim,DoFLineAccessor<dim,BaseClass> >
 DoFLineAccessor<dim,BaseClass>::child (const unsigned int i) const {
   TriaIterator<dim,DoFLineAccessor<dim,BaseClass> > q (tria,
@@ -122,7 +122,7 @@ DoFLineAccessor<dim,BaseClass>::child (const unsigned int i) const {
 
 
 
-template <int dim, class BaseClass>
+template <int dim, typename BaseClass>
 void DoFLineAccessor<dim,BaseClass>::copy_from (const DoFLineAccessor<dim,BaseClass> &a) {
   BaseClass::copy_from (a);
   set_dof_handler (a.dof_handler);
@@ -133,7 +133,7 @@ void DoFLineAccessor<dim,BaseClass>::copy_from (const DoFLineAccessor<dim,BaseCl
 /*------------------------- Functions: DoFQuadAccessor -----------------------*/
 
 
-template <int dim, class BaseClass>
+template <int dim, typename BaseClass>
 int DoFQuadAccessor<dim,BaseClass>::dof_index (const unsigned int i) const {
   Assert (dof_handler != 0, ExcInvalidObject());
                                   // make sure a FE has been selected
@@ -148,7 +148,7 @@ int DoFQuadAccessor<dim,BaseClass>::dof_index (const unsigned int i) const {
 
 
 
-template <int dim, class BaseClass>
+template <int dim, typename BaseClass>
 void DoFQuadAccessor<dim,BaseClass>::set_dof_index (const unsigned int i,
                                                    const int index) const {
   Assert (dof_handler != 0, ExcInvalidObject());
@@ -164,7 +164,7 @@ void DoFQuadAccessor<dim,BaseClass>::set_dof_index (const unsigned int i,
 
 
 
-template <int dim, class BaseClass>
+template <int dim, typename BaseClass>
 int DoFQuadAccessor<dim,BaseClass>::vertex_dof_index (const unsigned int vertex,
                                                      const unsigned int i) const {
   Assert (dof_handler != 0, ExcInvalidObject());
@@ -181,7 +181,7 @@ int DoFQuadAccessor<dim,BaseClass>::vertex_dof_index (const unsigned int vertex,
 
 
   
-template <int dim, class BaseClass>
+template <int dim, typename BaseClass>
 void DoFQuadAccessor<dim,BaseClass>::set_vertex_dof_index (const unsigned int vertex,
                                                           const unsigned int i,
                                                           const int index) const {
@@ -199,7 +199,7 @@ void DoFQuadAccessor<dim,BaseClass>::set_vertex_dof_index (const unsigned int ve
 
 
 
-template <int dim, class BaseClass>
+template <int dim, typename BaseClass>
 void
 DoFQuadAccessor<dim,BaseClass>::get_dof_indices (vector<int> &dof_indices) const {
   Assert (dof_handler != 0, ExcInvalidObject());
@@ -225,7 +225,7 @@ DoFQuadAccessor<dim,BaseClass>::get_dof_indices (vector<int> &dof_indices) const
 
 
 
-template <int dim, class BaseClass>
+template <int dim, typename BaseClass>
 TriaIterator<dim,DoFLineAccessor<dim,LineAccessor<dim> > >
 DoFQuadAccessor<dim,BaseClass>::line (const unsigned int i) const {
   Assert (i<4, ExcInvalidIndex (i, 0, 4));
@@ -241,7 +241,7 @@ DoFQuadAccessor<dim,BaseClass>::line (const unsigned int i) const {
 
 
 
-template <int dim, class BaseClass>
+template <int dim, typename BaseClass>
 TriaIterator<dim,DoFQuadAccessor<dim,BaseClass> >
 DoFQuadAccessor<dim,BaseClass>::child (const unsigned int i) const {
   TriaIterator<dim,DoFQuadAccessor<dim,BaseClass> > q (tria,
@@ -258,7 +258,7 @@ DoFQuadAccessor<dim,BaseClass>::child (const unsigned int i) const {
 
 
 
-template <int dim, class BaseClass>
+template <int dim, typename BaseClass>
 void DoFQuadAccessor<dim,BaseClass>::copy_from (const DoFQuadAccessor<dim,BaseClass> &a) {
   BaseClass::copy_from (a);
   set_dof_handler (a.dof_handler);
@@ -303,6 +303,7 @@ DoFCellAccessor<dim>::child (const unsigned int i) const {
 
 
 
+#if deal_II_dimension == 1
 
 template <>
 DoFSubstructAccessor<1>::face_iterator
@@ -313,14 +314,6 @@ DoFCellAccessor<1>::face (const unsigned int) const {
 
 
 
-template <>
-DoFSubstructAccessor<2>::face_iterator
-DoFCellAccessor<2>::face (const unsigned int i) const {
-  return line(i);
-};
-
-
-
 template <>
 void
 DoFCellAccessor<1>::get_dof_values (const dVector &values,
@@ -342,6 +335,17 @@ DoFCellAccessor<1>::get_dof_values (const dVector &values,
     *next_dof_value++ = values(dof_index(d));
 };
 
+#endif
+
+
+
+#if deal_II_dimension == 2
+
+template <>
+DoFSubstructAccessor<2>::face_iterator
+DoFCellAccessor<2>::face (const unsigned int i) const {
+  return line(i);
+};
 
 
 
@@ -370,7 +374,7 @@ DoFCellAccessor<2>::get_dof_values (const dVector &values,
     *next_dof_value++ = values(dof_index(d));
 };
 
-
+#endif
 
 
 
@@ -379,23 +383,27 @@ DoFCellAccessor<2>::get_dof_values (const dVector &values,
 
 
 // explicit instantiations
+#if deal_II_dimension == 1
 template class DoFLineAccessor<1,CellAccessor<1> >;
 template class DoFCellAccessor<1>;
 
+template class TriaRawIterator<1,DoFCellAccessor<1> >;
+template class TriaIterator<1,DoFCellAccessor<1> >;
+template class TriaActiveIterator<1,DoFCellAccessor<1> >;
+#endif
+
+#if deal_II_dimension == 2
 template class DoFLineAccessor<2,LineAccessor<2> >;
 template class DoFQuadAccessor<2,QuadAccessor<2> >;
 template class DoFQuadAccessor<2,CellAccessor<2> >;
 template class DoFCellAccessor<2>;
 
-template class TriaRawIterator<1,DoFCellAccessor<1> >;
 template class TriaRawIterator<2,DoFLineAccessor<2,LineAccessor<2> > >;
 template class TriaRawIterator<2,DoFCellAccessor<2> >;
-
-template class TriaIterator<1,DoFCellAccessor<1> >;
 template class TriaIterator<2,DoFLineAccessor<2,LineAccessor<2> > >;
 template class TriaIterator<2,DoFCellAccessor<2> >;
-
-template class TriaActiveIterator<1,DoFCellAccessor<1> >;
 template class TriaActiveIterator<2,DoFLineAccessor<2,LineAccessor<2> > >;
 template class TriaActiveIterator<2,DoFCellAccessor<2> >;
+#endif
+
 
index 2ec740af63f089e0f51a59a586f6cb80b7892a3a..8b44e7658e137e8a4a01a4b04e74961782f4f29d 100644 (file)
@@ -15,6 +15,7 @@
 
 
 
+
 template <int dim>
 DoFHandler<dim>::DoFHandler (Triangulation<dim> *tria) :
                tria(tria),
@@ -32,6 +33,9 @@ DoFHandler<dim>::~DoFHandler () {
 
 
 
+
+#if deal_II_dimension == 1
+
 template <>
 DoFHandler<1>::raw_cell_iterator
 DoFHandler<1>::begin_raw (const unsigned int level) const {
@@ -112,183 +116,266 @@ DoFHandler<1>::last_active (const unsigned int level) const {
 
 
 
-
-
 template <>
-DoFHandler<2>::raw_cell_iterator
-DoFHandler<2>::begin_raw (const unsigned int level) const {
-  return begin_raw_quad (level);
+DoFDimensionInfo<1>::raw_face_iterator
+DoFHandler<1>::begin_raw_face (const unsigned int) const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
 };
 
 
 
 template <>
-DoFHandler<2>::cell_iterator
-DoFHandler<2>::begin (const unsigned int level) const {
-  return begin_quad (level);
+DoFDimensionInfo<1>::face_iterator
+DoFHandler<1>::begin_face (const unsigned int) const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
 };
 
 
 
 template <>
-DoFHandler<2>::active_cell_iterator
-DoFHandler<2>::begin_active (const unsigned int level) const {
-  return begin_active_quad (level);
+DoFDimensionInfo<1>::active_face_iterator
+DoFHandler<1>::begin_active_face (const unsigned int) const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
 };
 
 
 
 template <>
-DoFHandler<2>::raw_cell_iterator
-DoFHandler<2>::end () const {
-  return end_quad ();
+DoFDimensionInfo<1>::raw_face_iterator
+DoFHandler<1>::end_face () const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
 };
 
 
 
 template <>
-DoFHandler<2>::raw_cell_iterator
-DoFHandler<2>::last_raw () const {
-  return last_raw_quad ();
+DoFDimensionInfo<1>::raw_face_iterator
+DoFHandler<1>::last_raw_face () const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
 };
 
 
 
 template <>
-DoFHandler<2>::raw_cell_iterator
-DoFHandler<2>::last_raw (const unsigned int level) const {
-  return last_raw_quad (level);
+DoFDimensionInfo<1>::raw_face_iterator
+DoFHandler<1>::last_raw_face (const unsigned int) const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
 };
 
 
 
 template <>
-DoFHandler<2>::cell_iterator
-DoFHandler<2>::last () const {
-  return last_quad ();
+DoFDimensionInfo<1>::face_iterator
+DoFHandler<1>::last_face () const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
 };
 
 
 
 template <>
-DoFHandler<2>::cell_iterator
-DoFHandler<2>::last (const unsigned int level) const {
-  return last_quad (level);
+DoFDimensionInfo<1>::face_iterator
+DoFHandler<1>::last_face (const unsigned int) const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
 };
 
 
 
 template <>
-DoFHandler<2>::active_cell_iterator
-DoFHandler<2>::last_active () const {
-  return last_active_quad ();
+DoFDimensionInfo<1>::active_face_iterator
+DoFHandler<1>::last_active_face () const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
 };
 
 
 
 template <>
-DoFHandler<2>::active_cell_iterator
-DoFHandler<2>::last_active (const unsigned int level) const {
-  return last_active_quad (level);
+DoFDimensionInfo<1>::active_face_iterator
+DoFHandler<1>::last_active_face (const unsigned int) const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
 };
 
 
 
 
-//------------------------------------------------------------------
+template <>
+DoFHandler<1>::raw_quad_iterator
+DoFHandler<1>::begin_raw_quad (const unsigned int) const {
+  Assert (false, ExcNotImplemented());
+  return 0;
+};
 
 
 
 template <>
-DoFDimensionInfo<1>::raw_face_iterator
-DoFHandler<1>::begin_raw_face (const unsigned int) const {
-  Assert (false, ExcFunctionNotUseful());
+DoFHandler<1>::quad_iterator
+DoFHandler<1>::begin_quad (const unsigned int) const {
+  Assert (false, ExcNotImplemented());
   return 0;
 };
 
 
 
 template <>
-DoFDimensionInfo<1>::face_iterator
-DoFHandler<1>::begin_face (const unsigned int) const {
-  Assert (false, ExcFunctionNotUseful());
+DoFHandler<1>::active_quad_iterator
+DoFHandler<1>::begin_active_quad (const unsigned int) const {
+  Assert (false, ExcNotImplemented());
   return 0;
 };
 
 
 
 template <>
-DoFDimensionInfo<1>::active_face_iterator
-DoFHandler<1>::begin_active_face (const unsigned int) const {
-  Assert (false, ExcFunctionNotUseful());
+DoFHandler<1>::raw_quad_iterator
+DoFHandler<1>::end_quad () const {
+  Assert (false, ExcNotImplemented());
   return 0;
 };
 
 
 
 template <>
-DoFDimensionInfo<1>::raw_face_iterator
-DoFHandler<1>::end_face () const {
-  Assert (false, ExcFunctionNotUseful());
+DoFHandler<1>::raw_quad_iterator
+DoFHandler<1>::last_raw_quad (const unsigned int) const {
+  Assert (false, ExcNotImplemented());
   return 0;
 };
 
 
-
 template <>
-DoFDimensionInfo<1>::raw_face_iterator
-DoFHandler<1>::last_raw_face () const {
-  Assert (false, ExcFunctionNotUseful());
+DoFHandler<1>::quad_iterator
+DoFHandler<1>::last_quad (const unsigned int) const {
+  Assert (false, ExcNotImplemented());
   return 0;
 };
 
 
 
 template <>
-DoFDimensionInfo<1>::raw_face_iterator
-DoFHandler<1>::last_raw_face (const unsigned int) const {
-  Assert (false, ExcFunctionNotUseful());
+DoFHandler<1>::active_quad_iterator
+DoFHandler<1>::last_active_quad (const unsigned int) const {
+  Assert (false, ExcNotImplemented());
   return 0;
 };
 
 
 
 template <>
-DoFDimensionInfo<1>::face_iterator
-DoFHandler<1>::last_face () const {
-  Assert (false, ExcFunctionNotUseful());
+DoFHandler<1>::raw_quad_iterator
+DoFHandler<1>::last_raw_quad () const {
+  Assert (false, ExcNotImplemented());
   return 0;
 };
 
 
 
 template <>
-DoFDimensionInfo<1>::face_iterator
-DoFHandler<1>::last_face (const unsigned int) const {
-  Assert (false, ExcFunctionNotUseful());
+DoFHandler<1>::quad_iterator
+DoFHandler<1>::last_quad () const {
+  Assert (false, ExcNotImplemented());
   return 0;
 };
 
 
 
 template <>
-DoFDimensionInfo<1>::active_face_iterator
-DoFHandler<1>::last_active_face () const {
-  Assert (false, ExcFunctionNotUseful());
+DoFHandler<1>::active_quad_iterator
+DoFHandler<1>::last_active_quad () const {
+  Assert (false, ExcNotImplemented());
   return 0;
 };
 
+#endif
+
 
+#if deal_II_dimension == 2
 
 template <>
-DoFDimensionInfo<1>::active_face_iterator
-DoFHandler<1>::last_active_face (const unsigned int) const {
-  Assert (false, ExcFunctionNotUseful());
-  return 0;
+DoFHandler<2>::raw_cell_iterator
+DoFHandler<2>::begin_raw (const unsigned int level) const {
+  return begin_raw_quad (level);
+};
+
+
+
+template <>
+DoFHandler<2>::cell_iterator
+DoFHandler<2>::begin (const unsigned int level) const {
+  return begin_quad (level);
+};
+
+
+
+template <>
+DoFHandler<2>::active_cell_iterator
+DoFHandler<2>::begin_active (const unsigned int level) const {
+  return begin_active_quad (level);
 };
 
 
 
+template <>
+DoFHandler<2>::raw_cell_iterator
+DoFHandler<2>::end () const {
+  return end_quad ();
+};
+
+
+
+template <>
+DoFHandler<2>::raw_cell_iterator
+DoFHandler<2>::last_raw () const {
+  return last_raw_quad ();
+};
+
+
+
+template <>
+DoFHandler<2>::raw_cell_iterator
+DoFHandler<2>::last_raw (const unsigned int level) const {
+  return last_raw_quad (level);
+};
+
+
+
+template <>
+DoFHandler<2>::cell_iterator
+DoFHandler<2>::last () const {
+  return last_quad ();
+};
+
+
+
+template <>
+DoFHandler<2>::cell_iterator
+DoFHandler<2>::last (const unsigned int level) const {
+  return last_quad (level);
+};
+
+
+
+template <>
+DoFHandler<2>::active_cell_iterator
+DoFHandler<2>::last_active () const {
+  return last_active_quad ();
+};
+
+
+
+template <>
+DoFHandler<2>::active_cell_iterator
+DoFHandler<2>::last_active (const unsigned int level) const {
+  return last_active_quad (level);
+};
 
 
 template <>
@@ -369,10 +456,9 @@ DoFHandler<2>::last_active_face (const unsigned int level) const {
   return last_active_line (level);
 };
 
+#endif
 
 
-// ---------------------------------------------------------------
-
 
 
 template <int dim>
@@ -408,15 +494,6 @@ DoFHandler<dim>::begin_active_line (const unsigned int level) const {
 
 
 
-template <>
-DoFHandler<1>::raw_quad_iterator
-DoFHandler<1>::begin_raw_quad (const unsigned int) const {
-  Assert (false, ExcNotImplemented());
-  return 0;
-};
-
-
-
 template <int dim>
 typename DoFHandler<dim>::raw_quad_iterator
 DoFHandler<dim>::begin_raw_quad (const unsigned int level) const {
@@ -428,15 +505,6 @@ DoFHandler<dim>::begin_raw_quad (const unsigned int level) const {
 
 
 
-template <>
-DoFHandler<1>::quad_iterator
-DoFHandler<1>::begin_quad (const unsigned int) const {
-  Assert (false, ExcNotImplemented());
-  return 0;
-};
-
-
-
 template <int dim>
 typename DoFHandler<dim>::quad_iterator
 DoFHandler<dim>::begin_quad (const unsigned int level) const {
@@ -448,15 +516,6 @@ DoFHandler<dim>::begin_quad (const unsigned int level) const {
 
 
 
-template <>
-DoFHandler<1>::active_quad_iterator
-DoFHandler<1>::begin_active_quad (const unsigned int) const {
-  Assert (false, ExcNotImplemented());
-  return 0;
-};
-
-
-
 template <int dim>
 typename DoFHandler<dim>::active_quad_iterator
 DoFHandler<dim>::begin_active_quad (const unsigned int level) const {
@@ -476,15 +535,6 @@ DoFHandler<dim>::end_line () const {
 
 
 
-template <>
-DoFHandler<1>::raw_quad_iterator
-DoFHandler<1>::end_quad () const {
-  Assert (false, ExcNotImplemented());
-  return 0;
-};
-
-
-
 template <int dim>
 typename DoFHandler<dim>::raw_quad_iterator
 DoFHandler<dim>::end_quad () const {
@@ -493,7 +543,6 @@ DoFHandler<dim>::end_quad () const {
 
 
 
-
 template <int dim>
 typename DoFHandler<dim>::raw_line_iterator
 DoFHandler<dim>::last_raw_line (const unsigned int level) const {
@@ -527,14 +576,6 @@ DoFHandler<dim>::last_active_line (const unsigned int level) const {
 
 
 
-template <>
-DoFHandler<1>::raw_quad_iterator
-DoFHandler<1>::last_raw_quad (const unsigned int) const {
-  Assert (false, ExcNotImplemented());
-  return 0;
-};
-
-
 template <int dim>
 typename DoFHandler<dim>::raw_quad_iterator
 DoFHandler<dim>::last_raw_quad (const unsigned int level) const {
@@ -547,15 +588,6 @@ DoFHandler<dim>::last_raw_quad (const unsigned int level) const {
 
 
 
-template <>
-DoFHandler<1>::quad_iterator
-DoFHandler<1>::last_quad (const unsigned int) const {
-  Assert (false, ExcNotImplemented());
-  return 0;
-};
-
-
-
 template <int dim>
 typename DoFHandler<dim>::quad_iterator
 DoFHandler<dim>::last_quad (const unsigned int level) const {
@@ -568,15 +600,6 @@ DoFHandler<dim>::last_quad (const unsigned int level) const {
 
 
 
-template <>
-DoFHandler<1>::active_quad_iterator
-DoFHandler<1>::last_active_quad (const unsigned int) const {
-  Assert (false, ExcNotImplemented());
-  return 0;
-};
-
-
-
 template <int dim>
 typename DoFHandler<dim>::active_quad_iterator
 DoFHandler<dim>::last_active_quad (const unsigned int level) const {
@@ -597,15 +620,6 @@ DoFHandler<dim>::last_raw_line () const {
 
 
 
-template <>
-DoFHandler<1>::raw_quad_iterator
-DoFHandler<1>::last_raw_quad () const {
-  Assert (false, ExcNotImplemented());
-  return 0;
-};
-
-
-
 template <int dim>
 typename DoFHandler<dim>::raw_quad_iterator
 DoFHandler<dim>::last_raw_quad () const {
@@ -622,15 +636,6 @@ DoFHandler<dim>::last_line () const {
 
 
 
-template <>
-DoFHandler<1>::quad_iterator
-DoFHandler<1>::last_quad () const {
-  Assert (false, ExcNotImplemented());
-  return 0;
-};
-
-
-
 template <int dim>
 typename DoFHandler<dim>::quad_iterator
 DoFHandler<dim>::last_quad () const {
@@ -648,15 +653,6 @@ DoFHandler<dim>::last_active_line () const {
 
 
 
-template <>
-DoFHandler<1>::active_quad_iterator
-DoFHandler<1>::last_active_quad () const {
-  Assert (false, ExcNotImplemented());
-  return 0;
-};
-
-
-
 template <int dim>
 typename DoFHandler<dim>::active_quad_iterator
 DoFHandler<dim>::last_active_quad () const {
@@ -668,6 +664,13 @@ DoFHandler<dim>::last_active_quad () const {
 
 
 
+//------------------------------------------------------------------
+
+
+
+
+
+
 
 template <int dim>
 unsigned int DoFHandler<dim>::n_dofs () const {
@@ -676,6 +679,8 @@ unsigned int DoFHandler<dim>::n_dofs () const {
 
 
 
+#if deal_II_dimension == 1
+
 template <>
 unsigned int DoFHandler<1>::n_boundary_dofs () const {
   Assert (selected_fe != 0, ExcNoFESelected());
@@ -685,6 +690,19 @@ unsigned int DoFHandler<1>::n_boundary_dofs () const {
 
 
 
+template <>
+unsigned int DoFHandler<1>::n_boundary_dofs (const FunctionMap &) const {
+  Assert (selected_fe != 0, ExcNoFESelected());
+  Assert (false, ExcNotImplemented());
+  return 0;
+};
+
+#endif
+
+
+
+
+
 template <int dim>
 unsigned int DoFHandler<dim>::n_boundary_dofs () const {
   Assert (selected_fe != 0, ExcNoFESelected());
@@ -707,14 +725,6 @@ unsigned int DoFHandler<dim>::n_boundary_dofs () const {
 
 
 
-template <>
-unsigned int DoFHandler<1>::n_boundary_dofs (const FunctionMap &) const {
-  Assert (selected_fe != 0, ExcNoFESelected());
-  Assert (false, ExcNotImplemented());
-  return 0;
-};
-
-
 template <int dim>
 unsigned int DoFHandler<dim>::n_boundary_dofs (const FunctionMap &boundary_indicators) const {
   Assert (selected_fe != 0, ExcNoFESelected());
@@ -777,6 +787,8 @@ void DoFHandler<dim>::distribute_dofs (const FiniteElementBase<dim> &fe) {
 
 
 
+#if deal_II_dimension == 1
+
 template <>
 unsigned int DoFHandler<1>::distribute_dofs_on_cell (active_cell_iterator &cell,
                                                     unsigned int          next_free_dof) {
@@ -826,8 +838,10 @@ unsigned int DoFHandler<1>::distribute_dofs_on_cell (active_cell_iterator &cell,
   return next_free_dof;
 };
 
+#endif
 
 
+#if deal_II_dimension == 2
 
 template <>
 unsigned int DoFHandler<2>::distribute_dofs_on_cell (active_cell_iterator &cell,
@@ -874,6 +888,8 @@ unsigned int DoFHandler<2>::distribute_dofs_on_cell (active_cell_iterator &cell,
   return next_free_dof;
 };
 
+#endif
+
 
 
 template <int dim>
@@ -1058,6 +1074,7 @@ void DoFHandler<dim>::renumber_dofs (const RenumberingMethod method,
 };
 
 
+#if deal_II_dimension == 1
 
 template <>
 void DoFHandler<1>::do_renumbering (const vector<int> &new_numbers) {
@@ -1078,8 +1095,11 @@ void DoFHandler<1>::do_renumbering (const vector<int> &new_numbers) {
        *i = new_numbers[*i];
 };
 
+#endif
 
 
+#if deal_II_dimension == 2
+
 template <>
 void DoFHandler<2>::do_renumbering (const vector<int> &new_numbers) {
   for (vector<int>::iterator i=vertex_dofs.begin(); i!=vertex_dofs.end(); ++i)
@@ -1099,8 +1119,10 @@ void DoFHandler<2>::do_renumbering (const vector<int> &new_numbers) {
     };
 };
 
+#endif
 
 
+#if deal_II_dimension == 1
 
 template <>
 void DoFHandler<1>::make_constraint_matrix (ConstraintMatrix &cm) const {
@@ -1108,8 +1130,11 @@ void DoFHandler<1>::make_constraint_matrix (ConstraintMatrix &cm) const {
   cm.close ();
 };
 
+#endif
 
-  
+
+
+#if deal_II_dimension == 2
 
 template <>
 void DoFHandler<2>::make_constraint_matrix (ConstraintMatrix &constraints) const {
@@ -1177,6 +1202,7 @@ void DoFHandler<2>::make_constraint_matrix (ConstraintMatrix &constraints) const
   constraints.close ();
 };
 
+#endif
 
 
 
@@ -1204,6 +1230,7 @@ void DoFHandler<dim>::make_sparsity_pattern (dSMatrixStruct &sparsity) const {
 };
 
 
+#if deal_II_dimension == 1
 
 template <>
 void DoFHandler<1>::make_boundary_sparsity_pattern (const vector<int> &,
@@ -1214,6 +1241,18 @@ void DoFHandler<1>::make_boundary_sparsity_pattern (const vector<int> &,
 
 
 
+template <>
+void DoFHandler<1>::make_boundary_sparsity_pattern (const FunctionMap &,
+                                                   const vector<int> &,
+                                                   dSMatrixStruct &) const {
+  Assert (selected_fe != 0, ExcNoFESelected());
+  Assert (false, ExcInternalError());
+};
+
+#endif
+
+
+
 template <int dim>
 void DoFHandler<dim>::make_boundary_sparsity_pattern (const vector<int> &dof_to_boundary_mapping,
                                                      dSMatrixStruct &sparsity) const {
@@ -1252,16 +1291,6 @@ void DoFHandler<dim>::make_boundary_sparsity_pattern (const vector<int> &dof_to_
 
 
 
-template <>
-void DoFHandler<1>::make_boundary_sparsity_pattern (const FunctionMap &,
-                                                   const vector<int> &,
-                                                   dSMatrixStruct &) const {
-  Assert (selected_fe != 0, ExcNoFESelected());
-  Assert (false, ExcInternalError());
-};
-
-
-
 template <int dim>
 void DoFHandler<dim>::make_boundary_sparsity_pattern (const FunctionMap &boundary_indicators,
                                                      const vector<int> &dof_to_boundary_mapping,
@@ -1519,6 +1548,7 @@ void DoFHandler<dim>::transfer_cell (const typename DoFHandler<dim>::cell_iterat
 
 
 
+#if deal_II_dimension == 1
 
 template <>
 unsigned int DoFHandler<1>::max_couplings_between_dofs () const {
@@ -1528,6 +1558,35 @@ unsigned int DoFHandler<1>::max_couplings_between_dofs () const {
 
 
 
+template <>
+unsigned int DoFHandler<1>::max_couplings_between_boundary_dofs () const {
+  Assert (selected_fe != 0, ExcNoFESelected());
+  Assert (false, ExcInternalError());
+  return 0;
+};
+
+
+
+template <>
+unsigned int DoFHandler<1>::max_transfer_entries (const unsigned int max_level_diff) const {
+  Assert (max_level_diff<2, ExcOnlyOnelevelTransferImplemented());
+  switch (max_level_diff)
+    {
+      case 0:
+           return 1;
+      case 1:
+           return (2*selected_fe->dofs_per_line+
+                   selected_fe->dofs_per_vertex) * 2 + 1;
+    };
+  return 0;
+};
+
+#endif
+
+
+
+#if deal_II_dimension == 2
+
 template <>
 unsigned int DoFHandler<2>::max_couplings_between_dofs () const {
   Assert (selected_fe != 0, ExcNoFESelected());
@@ -1583,15 +1642,6 @@ unsigned int DoFHandler<2>::max_couplings_between_dofs () const {
 
 
 
-template <>
-unsigned int DoFHandler<1>::max_couplings_between_boundary_dofs () const {
-  Assert (selected_fe != 0, ExcNoFESelected());
-  Assert (false, ExcInternalError());
-  return 0;
-};
-
-
-
 template <>
 unsigned int DoFHandler<2>::max_couplings_between_boundary_dofs () const {
   Assert (selected_fe != 0, ExcNoFESelected());
@@ -1600,23 +1650,6 @@ unsigned int DoFHandler<2>::max_couplings_between_boundary_dofs () const {
 
 
 
-
-template <>
-unsigned int DoFHandler<1>::max_transfer_entries (const unsigned int max_level_diff) const {
-  Assert (max_level_diff<2, ExcOnlyOnelevelTransferImplemented());
-  switch (max_level_diff)
-    {
-      case 0:
-           return 1;
-      case 1:
-           return (2*selected_fe->dofs_per_line+
-                   selected_fe->dofs_per_vertex) * 2 + 1;
-    };
-  return 0;
-};
-
-
-
 template <>
 unsigned int DoFHandler<2>::max_transfer_entries (const unsigned int max_level_diff) const {
   Assert (max_level_diff<2, ExcOnlyOnelevelTransferImplemented());
@@ -1632,6 +1665,10 @@ unsigned int DoFHandler<2>::max_transfer_entries (const unsigned int max_level_d
   return 0;
 };
 
+#endif
+
+
+
 
 
 template <int dim>
@@ -1678,6 +1715,8 @@ void DoFHandler<dim>::distribute_cell_to_dof_vector (const dVector &cell_data,
 
 
 
+#if deal_II_dimension == 1
+
 template <>
 void DoFHandler<1>::map_dof_to_boundary_indices (vector<int> &) const {
   Assert (selected_fe != 0, ExcNoFESelected());
@@ -1686,6 +1725,17 @@ void DoFHandler<1>::map_dof_to_boundary_indices (vector<int> &) const {
 
 
 
+template <>
+void DoFHandler<1>::map_dof_to_boundary_indices (const FunctionMap &,
+                                                vector<int> &) const {
+  Assert (selected_fe != 0, ExcNoFESelected());
+  Assert (false, ExcNotImplemented());
+};
+
+#endif
+
+
+
 template <int dim>
 void DoFHandler<dim>::map_dof_to_boundary_indices (vector<int> &mapping) const {
   Assert (selected_fe != 0, ExcNoFESelected());
@@ -1714,15 +1764,6 @@ void DoFHandler<dim>::map_dof_to_boundary_indices (vector<int> &mapping) const {
 
 
 
-template <>
-void DoFHandler<1>::map_dof_to_boundary_indices (const FunctionMap &,
-                                                vector<int> &) const {
-  Assert (selected_fe != 0, ExcNoFESelected());
-  Assert (false, ExcNotImplemented());
-};
-
-
-
 template <int dim>
 void DoFHandler<dim>::map_dof_to_boundary_indices (const FunctionMap &boundary_indicators,
                                                   vector<int> &mapping) const {
@@ -1759,7 +1800,7 @@ void DoFHandler<dim>::map_dof_to_boundary_indices (const FunctionMap &boundary_i
 
 
 
-
+#if deal_II_dimension == 1
 
 template <>
 void DoFHandler<1>::reserve_space () {
@@ -1786,8 +1827,11 @@ void DoFHandler<1>::reserve_space () {
     };
 };
 
+#endif
 
 
+#if deal_II_dimension == 2
+
 template <>
 void DoFHandler<2>::reserve_space () {
   Assert (selected_fe != 0, ExcNoFESelected());
@@ -1818,13 +1862,12 @@ void DoFHandler<2>::reserve_space () {
     };
 };
 
-
+#endif
 
 
 
 /*-------------- Explicit Instantiations -------------------------------*/
-template class DoFHandler<1>;
-template class DoFHandler<2>;
+template class DoFHandler<deal_II_dimension>;
 
 
 
index b564fa2b1bcff2082c55c2fca03d251f4f48b009..e64d0b47105d5af0879ad9ae9a95c8a19f561a16 100644 (file)
@@ -12,6 +12,7 @@
 
 /*------------------------------- FiniteElementData ----------------------*/
 
+#if deal_II_dimension == 1
 
 bool FiniteElementData<1>::operator== (const FiniteElementData<1> &f) const {
   return ((dofs_per_vertex == f.dofs_per_vertex) &&
@@ -19,8 +20,12 @@ bool FiniteElementData<1>::operator== (const FiniteElementData<1> &f) const {
          (total_dofs == f.total_dofs));
 };
 
+#endif
 
 
+
+#if deal_II_dimension == 2
+
 bool FiniteElementData<2>::operator== (const FiniteElementData<2> &f) const {
   return ((dofs_per_vertex == f.dofs_per_vertex) &&
          (dofs_per_line == f.dofs_per_line) &&
@@ -28,14 +33,14 @@ bool FiniteElementData<2>::operator== (const FiniteElementData<2> &f) const {
          (total_dofs == f.total_dofs));
 };
 
-
+#endif
 
 
 
 /*------------------------------- FiniteElementBase ----------------------*/
 
 
-
+#if deal_II_dimension == 1
 
 template <>
 FiniteElementBase<1>::FiniteElementBase (const unsigned int dofs_per_vertex,
@@ -56,7 +61,10 @@ FiniteElementBase<1>::FiniteElementBase (const unsigned int dofs_per_vertex,
   interface_constraints(0,0)=1.;
 };
 
+#endif
+
 
+#if deal_II_dimension == 2
 
 template <>
 FiniteElementBase<2>::FiniteElementBase (const unsigned int dofs_per_vertex,
@@ -76,6 +84,8 @@ FiniteElementBase<2>::FiniteElementBase (const unsigned int dofs_per_vertex,
                                2*dofs_per_vertex+dofs_per_line);
 };
 
+#endif
+
 
 
 template <int dim>
@@ -126,6 +136,8 @@ bool FiniteElementBase<dim>::operator == (const FiniteElementBase<dim> &f) const
 // egcs wants this, but gcc2.8.1 produces an internal compiler error, so
 // we drop this declaration again for the time being
 
+#if deal_II_dimension == 1
+
 //template <>
 //void FiniteElement<1>::get_ansatz_points (const DoFHandler<1>::cell_iterator &cell,
 //                                       const Boundary<1> &,
@@ -170,20 +182,6 @@ void FiniteElement<1>::fill_fe_values (const DoFHandler<1>::cell_iterator &cell,
 };
 
 
-template <int dim>
-void FiniteElement<dim>::fill_fe_values (const DoFHandler<dim>::cell_iterator &,
-                                        const vector<Point<dim> > &,
-                                        vector<dFMatrix> &,
-                                        const bool,
-                                        vector<Point<dim> > &,
-                                        const bool,
-                                        vector<Point<dim> > &,
-                                        const bool,
-                                        const Boundary<dim> &) const {
-  Assert (false, ExcPureFunctionCalled());
-};
-
-
 
 template <>
 void FiniteElement<1>::fill_fe_face_values (const DoFHandler<1>::cell_iterator &,
@@ -205,6 +203,68 @@ void FiniteElement<1>::fill_fe_face_values (const DoFHandler<1>::cell_iterator &
 };
 
 
+template <>
+void FiniteElement<1>::fill_fe_subface_values (const DoFHandler<1>::cell_iterator &,
+                                              const unsigned int       ,
+                                              const unsigned int       ,
+                                              const vector<Point<0> > &,
+                                              const vector<Point<1> > &,
+                                              vector<dFMatrix>        &,
+                                              const bool               ,
+                                              vector<Point<1> >       &,
+                                              const bool               ,
+                                              vector<double>          &,
+                                              const bool               ,
+                                              vector<Point<1> >       &,
+                                              const bool,
+                                              const Boundary<1>       &) const {
+  Assert (false, ExcNotImplemented());
+};
+
+
+
+template <>
+void FiniteElement<1>::get_ansatz_points (const DoFHandler<1>::cell_iterator &cell,
+                                         const Boundary<1> &,
+                                         vector<Point<1> > &ansatz_points) const {
+  Assert (ansatz_points.size() == total_dofs,
+         ExcWrongFieldDimension(ansatz_points.size(), total_dofs));
+                                  // compute ansatz points. The first ones
+                                  // belong to vertex one, the second ones
+                                  // to vertex two, all following are
+                                  // equally spaced along the line
+  unsigned int next = 0;
+                                  // local mesh width
+  const double h=(cell->vertex(1)(0) - cell->vertex(0)(0));
+                                  // first the dofs in the vertices
+  for (unsigned int vertex=0; vertex<2; vertex++) 
+    for (unsigned int i=0; i<dofs_per_vertex; ++i)
+      ansatz_points[next++] = cell->vertex(vertex);
+  
+                                  // now dofs on line
+  for (unsigned int i=0; i<dofs_per_line; ++i) 
+    ansatz_points[next++] = cell->vertex(0) +
+                           Point<1>((i+1.0)/(total_dofs+1.0)*h);
+};
+
+#endif
+
+
+
+template <int dim>
+void FiniteElement<dim>::fill_fe_values (const DoFHandler<dim>::cell_iterator &,
+                                        const vector<Point<dim> > &,
+                                        vector<dFMatrix> &,
+                                        const bool,
+                                        vector<Point<dim> > &,
+                                        const bool,
+                                        vector<Point<dim> > &,
+                                        const bool,
+                                        const Boundary<dim> &) const {
+  Assert (false, ExcPureFunctionCalled());
+};
+
+
 
 template <int dim>
 void FiniteElement<dim>::fill_fe_face_values (const DoFHandler<dim>::cell_iterator &cell,
@@ -253,26 +313,6 @@ void FiniteElement<dim>::fill_fe_face_values (const DoFHandler<dim>::cell_iterat
 
 
 
-template <>
-void FiniteElement<1>::fill_fe_subface_values (const DoFHandler<1>::cell_iterator &,
-                                              const unsigned int       ,
-                                              const unsigned int       ,
-                                              const vector<Point<0> > &,
-                                              const vector<Point<1> > &,
-                                              vector<dFMatrix>        &,
-                                              const bool               ,
-                                              vector<Point<1> >       &,
-                                              const bool               ,
-                                              vector<double>          &,
-                                              const bool               ,
-                                              vector<Point<1> >       &,
-                                              const bool,
-                                              const Boundary<1>       &) const {
-  Assert (false, ExcNotImplemented());
-};
-
-
-
 template <int dim>
 void FiniteElement<dim>::fill_fe_subface_values (const DoFHandler<dim>::cell_iterator &cell,
                                                 const unsigned int           face_no,
@@ -313,33 +353,6 @@ void FiniteElement<dim>::fill_fe_subface_values (const DoFHandler<dim>::cell_ite
 
 
 
-
-template <>
-void FiniteElement<1>::get_ansatz_points (const DoFHandler<1>::cell_iterator &cell,
-                                         const Boundary<1> &,
-                                         vector<Point<1> > &ansatz_points) const {
-  Assert (ansatz_points.size() == total_dofs,
-         ExcWrongFieldDimension(ansatz_points.size(), total_dofs));
-                                  // compute ansatz points. The first ones
-                                  // belong to vertex one, the second ones
-                                  // to vertex two, all following are
-                                  // equally spaced along the line
-  unsigned int next = 0;
-                                  // local mesh width
-  const double h=(cell->vertex(1)(0) - cell->vertex(0)(0));
-                                  // first the dofs in the vertices
-  for (unsigned int vertex=0; vertex<2; vertex++) 
-    for (unsigned int i=0; i<dofs_per_vertex; ++i)
-      ansatz_points[next++] = cell->vertex(vertex);
-  
-                                  // now dofs on line
-  for (unsigned int i=0; i<dofs_per_line; ++i) 
-    ansatz_points[next++] = cell->vertex(0) +
-                           Point<1>((i+1.0)/(total_dofs+1.0)*h);
-};
-
-
-
 template <int dim>
 void FiniteElement<dim>::get_ansatz_points (const DoFHandler<dim>::cell_iterator &,
                                            const Boundary<dim> &,
@@ -351,14 +364,8 @@ void FiniteElement<dim>::get_ansatz_points (const DoFHandler<dim>::cell_iterator
 
 /*------------------------------- Explicit Instantiations -------------*/
 
-template class FiniteElementData<1>;
-template class FiniteElementData<2>;
-
-template class FiniteElementBase<1>;
-template class FiniteElementBase<2>;
-
-template class FiniteElement<1>;
-template class FiniteElement<2>;
-
+template class FiniteElementData<deal_II_dimension>;
+template class FiniteElementBase<deal_II_dimension>;
+template class FiniteElement<deal_II_dimension>;
 
 
index aeb5c4707e0fdd2ffea12b32f35c84ec78add996..0dc692538b0e74a9b639f7aa766794be42c53b16 100644 (file)
@@ -7,6 +7,7 @@
 #include <algorithm>
 
 
+#if deal_II_dimension == 1
 
 template <>
 FELinear<1>::FELinear () :
@@ -60,6 +61,7 @@ FELinear<1>::shape_value(const unsigned int i,
 
 
 template <>
+inline
 Point<1>
 FELinear<1>::shape_grad(const unsigned int i,
                        const Point<1>&) const
@@ -170,8 +172,13 @@ void FELinear<1>::get_local_mass_matrix (const DoFHandler<1>::cell_iterator &cel
   local_mass_matrix(0,1) = local_mass_matrix(1,0) = 1./6.*h;
 };
 
+#endif
 
 
+
+
+#if deal_II_dimension == 2
+
 template <>
 FELinear<2>::FELinear () :
                FiniteElement<2> (1, 0, 0)
@@ -281,6 +288,7 @@ FELinear<2>::shape_value (const unsigned int i,
 
 
 template <>
+inline
 Point<2>
 FELinear<2>::shape_grad (const unsigned int i,
                         const Point<2>& p) const
@@ -402,6 +410,115 @@ void FELinear<2>::get_local_mass_matrix (const DoFHandler<2>::cell_iterator &cel
 
 
 
+template <>
+void FELinear<2>::get_face_jacobians (const DoFHandler<2>::face_iterator &face,
+                                     const Boundary<2>         &,
+                                     const vector<Point<1> > &unit_points,
+                                     vector<double>      &face_jacobians) const {
+  Assert (unit_points.size() == face_jacobians.size(),
+         ExcWrongFieldDimension (unit_points.size(), face_jacobians.size()));
+
+                                  // a linear mapping for a single line
+                                  // produces particularly simple
+                                  // expressions for the jacobi
+                                  // determinant :-)
+  const double h = sqrt((face->vertex(1) - face->vertex(0)).square());
+  fill_n (face_jacobians.begin(),
+         unit_points.size(),
+         h);  
+};
+
+
+
+template <>
+void FELinear<2>::get_subface_jacobians (const DoFHandler<2>::face_iterator &face,
+                                        const unsigned int,
+                                        const vector<Point<1> > &unit_points,
+                                        vector<double>      &face_jacobians) const {
+  Assert (unit_points.size() == face_jacobians.size(),
+         ExcWrongFieldDimension (unit_points.size(), face_jacobians.size()));
+  Assert (face->at_boundary() == false,
+         ExcBoundaryFaceUsed ());
+
+                                  // a linear mapping for a single line
+                                  // produces particularly simple
+                                  // expressions for the jacobi
+                                  // determinant :-)
+  const double h = sqrt((face->vertex(1) - face->vertex(0)).square());
+  fill_n (face_jacobians.begin(),
+         unit_points.size(),
+         h/2);
+};
+
+
+
+template <>
+void FELinear<2>::get_normal_vectors (const DoFHandler<2>::cell_iterator &cell,
+                                     const unsigned int       face_no,
+                                     const Boundary<2> &,
+                                     const vector<Point<1> >  &unit_points,
+                                     vector<Point<2> >        &normal_vectors) const {
+  Assert (unit_points.size() == normal_vectors.size(),
+         ExcWrongFieldDimension (unit_points.size(), normal_vectors.size()));
+
+  const DoFHandler<2>::face_iterator face = cell->face(face_no);
+                                  // compute direction of line
+  const Point<2> line_direction = (face->vertex(1) - face->vertex(0));
+                                  // rotate to the right by 90 degrees
+  const Point<2> normal_direction(line_direction(1),
+                                 -line_direction(0));
+
+  if (face_no <= 1)
+                                    // for sides 0 and 1: return the correctly
+                                    // scaled vector
+    fill (normal_vectors.begin(), normal_vectors.end(),
+         normal_direction / sqrt(normal_direction.square()));
+  else
+                                    // for sides 2 and 3: scale and invert
+                                    // vector
+    fill (normal_vectors.begin(), normal_vectors.end(),
+         normal_direction / (-sqrt(normal_direction.square())));
+};
+
+
+
+template <>
+void FELinear<2>::get_normal_vectors (const DoFHandler<2>::cell_iterator &cell,
+                                     const unsigned int       face_no,
+                                     const unsigned int,
+                                     const vector<Point<1> >  &unit_points,
+                                     vector<Point<2> >        &normal_vectors) const {
+                                  // note, that in 2D the normal vectors to the
+                                  // subface have the same direction as that
+                                  // for the face
+  Assert (unit_points.size() == normal_vectors.size(),
+         ExcWrongFieldDimension (unit_points.size(), normal_vectors.size()));
+  Assert (cell->face(face_no)->at_boundary() == false,
+         ExcBoundaryFaceUsed ());
+
+  const DoFHandler<2>::face_iterator face = cell->face(face_no);
+                                  // compute direction of line
+  const Point<2> line_direction = (face->vertex(1) - face->vertex(0));
+                                  // rotate to the right by 90 degrees
+  const Point<2> normal_direction(line_direction(1),
+                                 -line_direction(0));
+
+  if (face_no <= 1)
+                                    // for sides 0 and 1: return the correctly
+                                    // scaled vector
+    fill (normal_vectors.begin(), normal_vectors.end(),
+         normal_direction / sqrt(normal_direction.square()));
+  else
+                                    // for sides 2 and 3: scale and invert
+                                    // vector
+    fill (normal_vectors.begin(), normal_vectors.end(),
+         normal_direction / (-sqrt(normal_direction.square())));
+};
+
+#endif
+
+
+
 template <int dim>
 void FELinear<dim>::fill_fe_values (const DoFHandler<dim>::cell_iterator &cell,
                                    const vector<Point<dim> >            &unit_points,
@@ -523,115 +640,11 @@ void FELinear<dim>::get_face_ansatz_points (const typename DoFHandler<dim>::face
 
 
 
-template <>
-void FELinear<2>::get_face_jacobians (const DoFHandler<2>::face_iterator &face,
-                                     const Boundary<2>         &,
-                                     const vector<Point<1> > &unit_points,
-                                     vector<double>      &face_jacobians) const {
-  Assert (unit_points.size() == face_jacobians.size(),
-         ExcWrongFieldDimension (unit_points.size(), face_jacobians.size()));
-
-                                  // a linear mapping for a single line
-                                  // produces particularly simple
-                                  // expressions for the jacobi
-                                  // determinant :-)
-  const double h = sqrt((face->vertex(1) - face->vertex(0)).square());
-  fill_n (face_jacobians.begin(),
-         unit_points.size(),
-         h);  
-};
-
-
-
-template <>
-void FELinear<2>::get_subface_jacobians (const DoFHandler<2>::face_iterator &face,
-                                        const unsigned int,
-                                        const vector<Point<1> > &unit_points,
-                                        vector<double>      &face_jacobians) const {
-  Assert (unit_points.size() == face_jacobians.size(),
-         ExcWrongFieldDimension (unit_points.size(), face_jacobians.size()));
-  Assert (face->at_boundary() == false,
-         ExcBoundaryFaceUsed ());
-
-                                  // a linear mapping for a single line
-                                  // produces particularly simple
-                                  // expressions for the jacobi
-                                  // determinant :-)
-  const double h = sqrt((face->vertex(1) - face->vertex(0)).square());
-  fill_n (face_jacobians.begin(),
-         unit_points.size(),
-         h/2);
-};
-
-
-
-template <>
-void FELinear<2>::get_normal_vectors (const DoFHandler<2>::cell_iterator &cell,
-                                     const unsigned int       face_no,
-                                     const Boundary<2> &,
-                                     const vector<Point<1> >  &unit_points,
-                                     vector<Point<2> >        &normal_vectors) const {
-  Assert (unit_points.size() == normal_vectors.size(),
-         ExcWrongFieldDimension (unit_points.size(), normal_vectors.size()));
-
-  const DoFHandler<2>::face_iterator face = cell->face(face_no);
-                                  // compute direction of line
-  const Point<2> line_direction = (face->vertex(1) - face->vertex(0));
-                                  // rotate to the right by 90 degrees
-  const Point<2> normal_direction(line_direction(1),
-                                 -line_direction(0));
-
-  if (face_no <= 1)
-                                    // for sides 0 and 1: return the correctly
-                                    // scaled vector
-    fill (normal_vectors.begin(), normal_vectors.end(),
-         normal_direction / sqrt(normal_direction.square()));
-  else
-                                    // for sides 2 and 3: scale and invert
-                                    // vector
-    fill (normal_vectors.begin(), normal_vectors.end(),
-         normal_direction / (-sqrt(normal_direction.square())));
-};
-
-
-
-template <>
-void FELinear<2>::get_normal_vectors (const DoFHandler<2>::cell_iterator &cell,
-                                     const unsigned int       face_no,
-                                     const unsigned int,
-                                     const vector<Point<1> >  &unit_points,
-                                     vector<Point<2> >        &normal_vectors) const {
-                                  // note, that in 2D the normal vectors to the
-                                  // subface have the same direction as that
-                                  // for the face
-  Assert (unit_points.size() == normal_vectors.size(),
-         ExcWrongFieldDimension (unit_points.size(), normal_vectors.size()));
-  Assert (cell->face(face_no)->at_boundary() == false,
-         ExcBoundaryFaceUsed ());
-
-  const DoFHandler<2>::face_iterator face = cell->face(face_no);
-                                  // compute direction of line
-  const Point<2> line_direction = (face->vertex(1) - face->vertex(0));
-                                  // rotate to the right by 90 degrees
-  const Point<2> normal_direction(line_direction(1),
-                                 -line_direction(0));
-
-  if (face_no <= 1)
-                                    // for sides 0 and 1: return the correctly
-                                    // scaled vector
-    fill (normal_vectors.begin(), normal_vectors.end(),
-         normal_direction / sqrt(normal_direction.square()));
-  else
-                                    // for sides 2 and 3: scale and invert
-                                    // vector
-    fill (normal_vectors.begin(), normal_vectors.end(),
-         normal_direction / (-sqrt(normal_direction.square())));
-};
-
 
 
 
 
+#if deal_II_dimension == 1
 
 template <>
 FEQuadratic<1>::FEQuadratic () :
@@ -716,9 +729,10 @@ void FEQuadratic<1>::get_normal_vectors (const DoFHandler<1>::cell_iterator &,
   Assert (false, ExcInternalError());
 };
 
+#endif
 
 
-
+#if deal_II_dimension == 2
 
 template <>
 FEQuadratic<2>::FEQuadratic () :
@@ -737,6 +751,8 @@ FEQuadratic<2>::FEQuadratic () :
   Assert (false, ExcNotImplemented());
 };
 
+#endif
+
 
 
 template <int dim>
@@ -862,7 +878,7 @@ void FEQuadratic<dim>::get_local_mass_matrix (const DoFHandler<dim>::cell_iterat
 
 
 
-
+#if deal_II_dimension == 1
 
 template <>
 FECubic<1>::FECubic () :
@@ -947,12 +963,17 @@ void FECubic<1>::get_normal_vectors (const DoFHandler<1>::cell_iterator &,
   Assert (false, ExcInternalError());
 };
 
+#endif
+
+
 
+#if deal_II_dimension == 2
 
 template <>
 FECubic<2>::FECubic () :
                FiniteElement<2> (1, 2, 4) {};
 
+#endif
 
 
 
@@ -1080,10 +1101,7 @@ void FECubic<dim>::get_local_mass_matrix (const DoFHandler<dim>::cell_iterator &
 
 // explicit instantiations
 
-template class FELinear<1>;
-template class FELinear<2>;
-template class FEQuadratic<1>;
-template class FEQuadratic<2>;
-template class FECubic<1>;
-template class FECubic<2>;
+template class FELinear<deal_II_dimension>;
+template class FEQuadratic<deal_II_dimension>;
+template class FECubic<deal_II_dimension>;
 
index 83414049a85ea9d60e5cdc5ba10a420e20913eaa..afa2c707910cc6e852499979591bbb6fb491a6b3 100644 (file)
@@ -497,13 +497,11 @@ void FESubfaceValues<dim>::reinit (const typename DoFHandler<dim>::cell_iterator
 
 /*------------------------------- Explicit Instantiations -------------*/
 
-template class FEValuesBase<1>;
-template class FEValuesBase<2>;
-
-template class FEValues<1>;
-template class FEValues<2>;
-
-template class FEFaceValuesBase<2>;
-template class FEFaceValues<2>;
-template class FESubfaceValues<2>;
-
+template class FEValuesBase<deal_II_dimension>;
+template class FEValues<deal_II_dimension>;
+
+#if deal_II_dimension >= 2
+template class FEFaceValuesBase<deal_II_dimension>;
+template class FEFaceValues<deal_II_dimension>;
+template class FESubfaceValues<deal_II_dimension>;
+#endif
index c133ffef7790db4313b6dfe24d2c0193acbc7f9b..7454caee48513788f8cb9ee51a35df364e3186e8 100644 (file)
@@ -38,7 +38,7 @@ Triangulation<dim>::~Triangulation () {
   for (unsigned int i=0; i<levels.size(); ++i)
     delete levels[i];
 
-  levels.resize (0);
+  levels.clear ();
 };
 
 
@@ -53,6 +53,7 @@ void Triangulation<dim>::set_boundary (const Boundary<dim> *boundary_object) {
 /*--------- Put the next functions a bit out-or-order to avoid use before
   --------- explicit specialization, which is not allowed.                */
 
+#if deal_II_dimension == 1
 template <>
 TriaDimensionInfo<1>::cell_iterator
 Triangulation<1>::begin (const unsigned int level) const {
@@ -60,29 +61,33 @@ Triangulation<1>::begin (const unsigned int level) const {
 };
 
 
-
 template <>
-TriaDimensionInfo<2>::cell_iterator
-Triangulation<2>::begin (const unsigned int level) const {
-  return begin_quad (level);
+TriaDimensionInfo<1>::raw_cell_iterator
+Triangulation<1>::end () const {
+  return end_line ();
 };
 
+#endif
+
 
+#if deal_II_dimension == 2
 
 template <>
-TriaDimensionInfo<1>::raw_cell_iterator
-Triangulation<1>::end () const {
-  return end_line ();
+TriaDimensionInfo<2>::cell_iterator
+Triangulation<2>::begin (const unsigned int level) const {
+  return begin_quad (level);
 };
 
 
 
+
 template <>
 TriaDimensionInfo<2>::raw_cell_iterator
 Triangulation<2>::end () const {
   return end_quad ();
 };
 
+#endif
 
 /*-----------------------------------------------------------------*/
 
@@ -111,6 +116,8 @@ void Triangulation<dim>::copy_triangulation (const Triangulation<dim> &old_tria)
 
 
 
+#if deal_II_dimension == 1
+
 template <>
 void Triangulation<1>::create_triangulation (const vector<Point<1> >    &v,
                                             const vector<CellData<1> > &cells,
@@ -210,6 +217,44 @@ void Triangulation<1>::create_triangulation (const vector<Point<1> >    &v,
 
 
 
+
+template <>
+void Triangulation<1>::create_hypercube (const double left,
+                                        const double right) {
+  Assert (vertices.size() == 0, ExcTriangulationNotEmpty());
+  Assert (n_lines() == 0, ExcTriangulationNotEmpty());
+
+  const Point<1> vertices[2] = { Point<1>(left), Point<1>(right) };
+  vector<CellData<1> > cells (1, CellData<1>());
+  cells[0].vertices[0] = 0;
+  cells[0].vertices[1] = 1;
+  cells[0].material_id = 0;
+  
+  create_triangulation (vector<Point<1> >(&vertices[0], &vertices[2]),
+                       cells,
+                       SubCellData());       // no boundary information
+};
+
+
+
+template <>
+void Triangulation<1>::create_hyper_L (const double, const double) {
+  Assert (false, ExcInternalError());
+};
+
+
+
+template <>
+void Triangulation<1>::create_hyper_ball (const Point<1> &, const double) {
+  Assert (false, ExcInternalError());
+};
+
+#endif
+
+
+
+#if deal_II_dimension == 2
+
 template <>
 void Triangulation<2>::create_triangulation (const vector<Point<2> >    &v,
                                             const vector<CellData<2> > &c,
@@ -497,26 +542,6 @@ void Triangulation<2>::create_triangulation (const vector<Point<2> >    &v,
 };
 
 
-
-template <>
-void Triangulation<1>::create_hypercube (const double left,
-                                        const double right) {
-  Assert (vertices.size() == 0, ExcTriangulationNotEmpty());
-  Assert (n_lines() == 0, ExcTriangulationNotEmpty());
-
-  const Point<1> vertices[2] = { Point<1>(left), Point<1>(right) };
-  vector<CellData<1> > cells (1, CellData<1>());
-  cells[0].vertices[0] = 0;
-  cells[0].vertices[1] = 1;
-  cells[0].material_id = 0;
-  
-  create_triangulation (vector<Point<1> >(&vertices[0], &vertices[2]),
-                       cells,
-                       SubCellData());       // no boundary information
-};
-
-
-
   
 template <>
 void Triangulation<2>::create_hypercube (const double left,
@@ -542,13 +567,6 @@ void Triangulation<2>::create_hypercube (const double left,
 
 
 
-template <>
-void Triangulation<1>::create_hyper_L (const double, const double) {
-  Assert (false, ExcInternalError());
-};
-
-
-
 template <>
 void Triangulation<2>::create_hyper_L (const double a, const double b) {
   const unsigned int dim=2;
@@ -580,13 +598,6 @@ void Triangulation<2>::create_hyper_L (const double a, const double b) {
 
 
 
-template <>
-void Triangulation<1>::create_hyper_ball (const Point<1> &, const double) {
-  Assert (false, ExcInternalError());
-};
-
-
-
 template <>
 void Triangulation<2>::create_hyper_ball (const Point<2> &p, const double radius) {
   const unsigned int dim=2;
@@ -620,6 +631,9 @@ void Triangulation<2>::create_hyper_ball (const Point<2> &p, const double radius
                        SubCellData());       // no boundary information
 };
 
+#endif
+
+
 
 
 
@@ -711,7 +725,7 @@ void Triangulation<dim>::load_refine_flags (istream &in) {
 };
 
 
-
+#if deal_II_dimension == 1
 
 template <>
 void Triangulation<1>::clear_user_flags () {
@@ -723,6 +737,16 @@ void Triangulation<1>::clear_user_flags () {
 
 
 
+template <>
+void Triangulation<1>::save_user_flags (ostream &out) const {
+  save_user_flags_line (out);
+};
+
+#endif
+
+
+#if deal_II_dimension == 2
+
 template <>
 void Triangulation<2>::clear_user_flags () {
   line_iterator line = begin_line(),
@@ -738,20 +762,14 @@ void Triangulation<2>::clear_user_flags () {
 
 
 
-
-template <>
-void Triangulation<1>::save_user_flags (ostream &out) const {
-  save_user_flags_line (out);
-};
-
-
-
 template <>
 void Triangulation<2>::save_user_flags (ostream &out) const {
   save_user_flags_line (out);
   save_user_flags_quad (out);
 };
 
+#endif
+
 
 
 template <int dim>
@@ -821,12 +839,24 @@ void Triangulation<dim>::load_user_flags_line (istream &in) {
 
 
 
+
+#if deal_II_dimension == 1
+
 template <>
 void Triangulation<1>::save_user_flags_quad (ostream &) const {
   Assert (false, ExcFunctionNotUseful());
 };
 
 
+template <>
+void Triangulation<1>::load_user_flags_quad (istream &) {
+  Assert (false, ExcFunctionNotUseful());
+};
+
+#endif
+
+
+
 
 template <int dim>
 void Triangulation<dim>::save_user_flags_quad (ostream &out) const {
@@ -857,13 +887,6 @@ void Triangulation<dim>::save_user_flags_quad (ostream &out) const {
 
 
 
-template <>
-void Triangulation<1>::load_user_flags_quad (istream &) {
-  Assert (false, ExcFunctionNotUseful());
-};
-
-
-
 template <int dim>
 void Triangulation<dim>::load_user_flags_quad (istream &in) {
   unsigned int magic_number;
@@ -902,6 +925,12 @@ void Triangulation<dim>::load_user_flags_quad (istream &in) {
 
 
 
+
+/*------------------------ Iterator functions ------------------------*/
+
+
+#if deal_II_dimension == 1
+
 template <>
 TriaDimensionInfo<1>::raw_cell_iterator
 Triangulation<1>::begin_raw (const unsigned int level) const {
@@ -966,79 +995,98 @@ Triangulation<1>::last_active (const unsigned int level) const {
 
 
 
-
-
 template <>
-TriaDimensionInfo<2>::raw_cell_iterator
-Triangulation<2>::begin_raw (const unsigned int level) const {
-  return begin_raw_quad (level);
+TriaDimensionInfo<1>::raw_face_iterator
+Triangulation<1>::begin_raw_face (const unsigned int) const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
 };
 
 
 
 template <>
-TriaDimensionInfo<2>::active_cell_iterator
-Triangulation<2>::begin_active (const unsigned int level) const {
-  return begin_active_quad (level);
+TriaDimensionInfo<1>::face_iterator
+Triangulation<1>::begin_face (const unsigned int) const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
 };
 
 
 
 template <>
-TriaDimensionInfo<2>::raw_cell_iterator
-Triangulation<2>::last_raw () const {
-  return last_raw_quad ();
+TriaDimensionInfo<1>::active_face_iterator
+Triangulation<1>::begin_active_face (const unsigned int) const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
 };
 
 
 
 template <>
-TriaDimensionInfo<2>::raw_cell_iterator
-Triangulation<2>::last_raw (const unsigned int level) const {
-  return last_raw_quad (level);
+TriaDimensionInfo<1>::raw_face_iterator
+Triangulation<1>::end_face () const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
 };
 
 
 
 template <>
-TriaDimensionInfo<2>::cell_iterator
-Triangulation<2>::last () const {
-  return last_quad ();
+TriaDimensionInfo<1>::raw_face_iterator
+Triangulation<1>::last_raw_face () const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
 };
 
 
 
 template <>
-TriaDimensionInfo<2>::cell_iterator
-Triangulation<2>::last (const unsigned int level) const {
-  return last_quad (level);
+TriaDimensionInfo<1>::raw_face_iterator
+Triangulation<1>::last_raw_face (const unsigned int) const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
 };
 
 
 
 template <>
-TriaDimensionInfo<2>::active_cell_iterator
-Triangulation<2>::last_active () const {
-  return last_active_quad ();
+TriaDimensionInfo<1>::face_iterator
+Triangulation<1>::last_face () const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
 };
 
 
 
 template <>
-TriaDimensionInfo<2>::active_cell_iterator
-Triangulation<2>::last_active (const unsigned int level) const {
-  return last_active_quad (level);
+TriaDimensionInfo<1>::face_iterator
+Triangulation<1>::last_face (const unsigned int) const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
 };
 
 
 
+template <>
+TriaDimensionInfo<1>::active_face_iterator
+Triangulation<1>::last_active_face () const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
+};
+
 
 
+template <>
+TriaDimensionInfo<1>::active_face_iterator
+Triangulation<1>::last_active_face (const unsigned int) const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
+};
 
 
 template <>
-TriaDimensionInfo<1>::raw_face_iterator
-Triangulation<1>::begin_raw_face (const unsigned int) const {
+TriaDimensionInfo<1>::raw_quad_iterator
+Triangulation<1>::begin_raw_quad (unsigned int) const {
   Assert (false, ExcFunctionNotUseful());
   return 0;
 };
@@ -1046,8 +1094,8 @@ Triangulation<1>::begin_raw_face (const unsigned int) const {
 
 
 template <>
-TriaDimensionInfo<1>::face_iterator
-Triangulation<1>::begin_face (const unsigned int) const {
+TriaDimensionInfo<1>::quad_iterator
+Triangulation<1>::begin_quad (unsigned int) const {
   Assert (false, ExcFunctionNotUseful());
   return 0;
 };
@@ -1055,8 +1103,8 @@ Triangulation<1>::begin_face (const unsigned int) const {
 
 
 template <>
-TriaDimensionInfo<1>::active_face_iterator
-Triangulation<1>::begin_active_face (const unsigned int) const {
+TriaDimensionInfo<1>::active_quad_iterator
+Triangulation<1>::begin_active_quad (unsigned int) const {
   Assert (false, ExcFunctionNotUseful());
   return 0;
 };
@@ -1064,8 +1112,8 @@ Triangulation<1>::begin_active_face (const unsigned int) const {
 
 
 template <>
-TriaDimensionInfo<1>::raw_face_iterator
-Triangulation<1>::end_face () const {
+TriaDimensionInfo<1>::raw_quad_iterator
+Triangulation<1>::end_quad () const {
   Assert (false, ExcFunctionNotUseful());
   return 0;
 };
@@ -1073,8 +1121,8 @@ Triangulation<1>::end_face () const {
 
 
 template <>
-TriaDimensionInfo<1>::raw_face_iterator
-Triangulation<1>::last_raw_face () const {
+TriaDimensionInfo<1>::raw_quad_iterator
+Triangulation<1>::last_raw_quad (const unsigned int) const {
   Assert (false, ExcFunctionNotUseful());
   return 0;
 };
@@ -1082,8 +1130,8 @@ Triangulation<1>::last_raw_face () const {
 
 
 template <>
-TriaDimensionInfo<1>::raw_face_iterator
-Triangulation<1>::last_raw_face (const unsigned int) const {
+TriaDimensionInfo<1>::raw_quad_iterator
+Triangulation<1>::last_raw_quad () const {
   Assert (false, ExcFunctionNotUseful());
   return 0;
 };
@@ -1091,8 +1139,8 @@ Triangulation<1>::last_raw_face (const unsigned int) const {
 
 
 template <>
-TriaDimensionInfo<1>::face_iterator
-Triangulation<1>::last_face () const {
+TriaDimensionInfo<1>::quad_iterator
+Triangulation<1>::last_quad (const unsigned int) const {
   Assert (false, ExcFunctionNotUseful());
   return 0;
 };
@@ -1100,8 +1148,8 @@ Triangulation<1>::last_face () const {
 
 
 template <>
-TriaDimensionInfo<1>::face_iterator
-Triangulation<1>::last_face (const unsigned int) const {
+TriaDimensionInfo<1>::quad_iterator
+Triangulation<1>::last_quad () const {
   Assert (false, ExcFunctionNotUseful());
   return 0;
 };
@@ -1109,8 +1157,8 @@ Triangulation<1>::last_face (const unsigned int) const {
 
 
 template <>
-TriaDimensionInfo<1>::active_face_iterator
-Triangulation<1>::last_active_face () const {
+TriaDimensionInfo<1>::active_quad_iterator
+Triangulation<1>::last_active_quad (const unsigned int) const {
   Assert (false, ExcFunctionNotUseful());
   return 0;
 };
@@ -1118,12 +1166,84 @@ Triangulation<1>::last_active_face () const {
 
 
 template <>
-TriaDimensionInfo<1>::active_face_iterator
-Triangulation<1>::last_active_face (const unsigned int) const {
+TriaDimensionInfo<1>::active_quad_iterator
+Triangulation<1>::last_active_quad () const {
   Assert (false, ExcFunctionNotUseful());
   return 0;
 };
 
+#endif
+
+
+
+
+#if deal_II_dimension == 2
+
+template <>
+TriaDimensionInfo<2>::raw_cell_iterator
+Triangulation<2>::begin_raw (const unsigned int level) const {
+  return begin_raw_quad (level);
+};
+
+
+
+template <>
+TriaDimensionInfo<2>::active_cell_iterator
+Triangulation<2>::begin_active (const unsigned int level) const {
+  return begin_active_quad (level);
+};
+
+
+
+template <>
+TriaDimensionInfo<2>::raw_cell_iterator
+Triangulation<2>::last_raw () const {
+  return last_raw_quad ();
+};
+
+
+
+template <>
+TriaDimensionInfo<2>::raw_cell_iterator
+Triangulation<2>::last_raw (const unsigned int level) const {
+  return last_raw_quad (level);
+};
+
+
+
+template <>
+TriaDimensionInfo<2>::cell_iterator
+Triangulation<2>::last () const {
+  return last_quad ();
+};
+
+
+
+template <>
+TriaDimensionInfo<2>::cell_iterator
+Triangulation<2>::last (const unsigned int level) const {
+  return last_quad (level);
+};
+
+
+
+template <>
+TriaDimensionInfo<2>::active_cell_iterator
+Triangulation<2>::last_active () const {
+  return last_active_quad ();
+};
+
+
+
+template <>
+TriaDimensionInfo<2>::active_cell_iterator
+Triangulation<2>::last_active (const unsigned int level) const {
+  return last_active_quad (level);
+};
+
+
+
+
 
 
 
@@ -1205,6 +1325,7 @@ Triangulation<2>::last_active_face (const unsigned int level) const {
   return last_active_line (level);
 };
 
+#endif
 
 
 
@@ -1225,15 +1346,6 @@ Triangulation<dim>::begin_raw_line (unsigned int level) const {
 
 
 
-template <>
-TriaDimensionInfo<1>::raw_quad_iterator
-Triangulation<1>::begin_raw_quad (unsigned int) const {
-  Assert (false, ExcFunctionNotUseful());
-  return 0;
-};
-
-
-
 template <int dim>
 typename TriaDimensionInfo<dim>::raw_quad_iterator
 Triangulation<dim>::begin_raw_quad (unsigned int level) const {
@@ -1266,15 +1378,6 @@ Triangulation<dim>::begin_line (unsigned int level) const {
 
 
 
-template <>
-TriaDimensionInfo<1>::quad_iterator
-Triangulation<1>::begin_quad (unsigned int) const {
-  Assert (false, ExcFunctionNotUseful());
-  return 0;
-};
-
-
-
 template <int dim>
 typename TriaDimensionInfo<dim>::quad_iterator
 Triangulation<dim>::begin_quad (unsigned int level) const {
@@ -1306,15 +1409,6 @@ Triangulation<dim>::begin_active_line (unsigned int level) const {
 
 
 
-template <>
-TriaDimensionInfo<1>::active_quad_iterator
-Triangulation<1>::begin_active_quad (unsigned int) const {
-  Assert (false, ExcFunctionNotUseful());
-  return 0;
-};
-
-
-
 template <int dim>
 typename TriaDimensionInfo<dim>::active_quad_iterator
 Triangulation<dim>::begin_active_quad (unsigned int level) const {
@@ -1341,15 +1435,6 @@ Triangulation<dim>::end_line () const {
 
 
 
-template <>
-TriaDimensionInfo<1>::raw_quad_iterator
-Triangulation<1>::end_quad () const {
-  Assert (false, ExcFunctionNotUseful());
-  return 0;
-};
-
-
-
 template <int dim>
 typename TriaDimensionInfo<dim>::raw_quad_iterator
 Triangulation<dim>::end_quad () const {
@@ -1376,15 +1461,6 @@ Triangulation<dim>::last_raw_line (const unsigned int level) const {
 
 
 
-template <>
-TriaDimensionInfo<1>::raw_quad_iterator
-Triangulation<1>::last_raw_quad (const unsigned int) const {
-  Assert (false, ExcFunctionNotUseful());
-  return 0;
-};
-
-
-
 template <int dim>
 typename TriaDimensionInfo<dim>::raw_quad_iterator
 Triangulation<dim>::last_raw_quad (const unsigned int level) const {
@@ -1409,15 +1485,6 @@ Triangulation<dim>::last_raw_line () const {
 
 
 
-template <>
-TriaDimensionInfo<1>::raw_quad_iterator
-Triangulation<1>::last_raw_quad () const {
-  Assert (false, ExcFunctionNotUseful());
-  return 0;
-};
-
-
-
 template <int dim>
 typename TriaDimensionInfo<dim>::raw_quad_iterator
 Triangulation<dim>::last_raw_quad () const {
@@ -1442,15 +1509,6 @@ Triangulation<dim>::last_line (const unsigned int level) const {
 
 
 
-template <>
-TriaDimensionInfo<1>::quad_iterator
-Triangulation<1>::last_quad (const unsigned int) const {
-  Assert (false, ExcFunctionNotUseful());
-  return 0;
-};
-
-
-
 template <int dim>
 typename TriaDimensionInfo<dim>::quad_iterator
 Triangulation<dim>::last_quad (const unsigned int level) const {
@@ -1474,16 +1532,6 @@ Triangulation<dim>::last_line () const {
 
 
 
-template <>
-TriaDimensionInfo<1>::quad_iterator
-Triangulation<1>::last_quad () const {
-  Assert (false, ExcFunctionNotUseful());
-  return 0;
-};
-
-
-
-
 template <int dim>
 typename TriaDimensionInfo<dim>::quad_iterator
 Triangulation<dim>::last_quad () const {
@@ -1508,16 +1556,6 @@ Triangulation<dim>::last_active_line (const unsigned int level) const {
 
 
 
-template <>
-TriaDimensionInfo<1>::active_quad_iterator
-Triangulation<1>::last_active_quad (const unsigned int) const {
-  Assert (false, ExcFunctionNotUseful());
-  return 0;
-};
-
-
-
-
 template <int dim>
 typename TriaDimensionInfo<dim>::active_quad_iterator
 Triangulation<dim>::last_active_quad (const unsigned int level) const {
@@ -1542,15 +1580,6 @@ Triangulation<dim>::last_active_line () const {
 
 
 
-template <>
-TriaDimensionInfo<1>::active_quad_iterator
-Triangulation<1>::last_active_quad () const {
-  Assert (false, ExcFunctionNotUseful());
-  return 0;
-};
-
-
-
 
 template <int dim>
 typename TriaDimensionInfo<dim>::active_quad_iterator
@@ -1574,20 +1603,6 @@ unsigned int Triangulation<dim>::n_cells () const {
 
 
 
-template <>
-unsigned int Triangulation<1>::n_cells (const unsigned int level) const {
-  return n_lines (level);
-};
-
-
-
-template <>
-unsigned int Triangulation<2>::n_cells (const unsigned int level) const {
-  return n_quads (level);
-};
-
-
-
 template <int dim>
 unsigned int Triangulation<dim>::n_active_cells () const {
   unsigned int n=0;
@@ -1598,18 +1613,40 @@ unsigned int Triangulation<dim>::n_active_cells () const {
 
 
 
+#if deal_II_dimension == 1
+
 template <>
 unsigned int Triangulation<1>::n_active_cells (const unsigned int level) const {
   return n_active_lines (level);
 };
 
 
+template <>
+unsigned int Triangulation<1>::n_cells (const unsigned int level) const {
+  return n_lines (level);
+};
+
+#endif
+
+
+
+#if deal_II_dimension == 2
+
+template <>
+unsigned int Triangulation<2>::n_cells (const unsigned int level) const {
+  return n_quads (level);
+};
+
+
 
 template <>
 unsigned int Triangulation<2>::n_active_cells (const unsigned int level) const {
   return n_active_quads (level);
 };
 
+#endif
+
+
 
 
 template <int dim>
@@ -1680,6 +1717,8 @@ unsigned int Triangulation<dim>::n_quads () const {
 
 
 
+#if deal_II_dimension == 1
+
 template <>
 unsigned int Triangulation<1>::n_quads (const unsigned int) const {
   Assert (false, ExcFunctionNotUseful());
@@ -1688,6 +1727,16 @@ unsigned int Triangulation<1>::n_quads (const unsigned int) const {
 
 
 
+template <>
+unsigned int Triangulation<1>::n_active_quads (const unsigned int) const {
+  Assert (false, ExcFunctionNotUseful());
+  return 0;
+};
+
+
+#endif
+
+
 template <int dim>
 unsigned int Triangulation<dim>::n_quads (const unsigned int level) const {
   if (levels[level]->quads.quads.size() == 0)
@@ -1717,14 +1766,6 @@ unsigned int Triangulation<dim>::n_active_quads () const {
 
 
 
-template <>
-unsigned int Triangulation<1>::n_active_quads (const unsigned int) const {
-  Assert (false, ExcFunctionNotUseful());
-  return 0;
-};
-
-
-
 template <int dim>
 unsigned int Triangulation<dim>::n_active_quads (const unsigned int level) const {
   if (levels[level]->quads.quads.size() == 0)
@@ -1752,11 +1793,15 @@ unsigned int Triangulation<dim>::n_levels () const {
 
 
 
+#if deal_II_dimension == 1
+
 template <>
 unsigned int Triangulation<1>::max_adjacent_cells () const {
   return 2;
 };
 
+#endif
+
 
 
 template <int dim>
@@ -1813,6 +1858,8 @@ void Triangulation<dim>::print_gnuplot (ostream &out, const unsigned int level)
 
 
 
+#if deal_II_dimension == 1
+
 template <>
 void Triangulation<1>::print_gnuplot (ostream &out,
                                      const active_cell_iterator & cell) const {
@@ -1821,7 +1868,10 @@ void Triangulation<1>::print_gnuplot (ostream &out,
       << endl;
 };
 
+#endif
+
 
+#if deal_II_dimension == 2
 
 template <>
 void Triangulation<2>::print_gnuplot (ostream &out,
@@ -1835,6 +1885,7 @@ void Triangulation<2>::print_gnuplot (ostream &out,
       << endl;
 };
 
+#endif
 
 
 
@@ -1875,12 +1926,15 @@ void Triangulation<dim>::refine_fixed_number (const dVector &criteria,
 };
 
 
+
+static
 inline
 double sqr(double a) {
   return a*a;
 };
 
 
+
 template <int dim>
 void Triangulation<dim>::refine_fixed_fraction (const dVector     &criteria,
                                                const double       fraction_of_error,
@@ -1965,6 +2019,8 @@ void Triangulation<dim>::refine_fixed_fraction (const dVector     &criteria,
 
 
 
+#if deal_II_dimension == 1
+
 template <>
 void Triangulation<1>::execute_refinement () {
   prepare_refinement ();
@@ -2151,10 +2207,11 @@ void Triangulation<1>::execute_refinement () {
 #endif
 };
 
+#endif
 
 
 
-
+#if deal_II_dimension == 2
 
 template <>
 void Triangulation<2>::execute_refinement () {
@@ -2735,6 +2792,7 @@ void Triangulation<2>::execute_refinement () {
 #endif
 };
 
+#endif
 
 
 
@@ -2955,6 +3013,8 @@ void TriangulationLevel<1>::monitor_memory (const unsigned int true_dimension) c
 
 
 
+#if deal_II_dimension >= 2
+
 void TriangulationLevel<2>::reserve_space (const unsigned int new_quads) {
   vector<bool>::iterator u = quads.used.begin(),
                         e = quads.used.end();
@@ -3018,12 +3078,11 @@ void TriangulationLevel<2>::monitor_memory (const unsigned int true_dimension) c
   TriangulationLevel<1>::monitor_memory (true_dimension);
 };
 
-
+#endif
 
 
 
 
 // explicit instantiations
-template class Triangulation<1>;
-template class Triangulation<2>;
+template class Triangulation<deal_II_dimension>;
 
index 75d49dbf646a55716765919a4b58139be316f549..47a92f974fd36b436bf0d0954a6984386d95013c 100644 (file)
@@ -69,10 +69,6 @@ IteratorState TriaAccessor<dim>::state () const {
 
 
 
-template class TriaAccessor<1>;
-template class TriaAccessor<2>;
-
-
 
 
 /*------------------------ Functions: LineAccessor ---------------------------*/
@@ -281,10 +277,6 @@ double LineAccessor<dim>::diameter () const {
 
 
 
-template class LineAccessor<1>;
-template class LineAccessor<2>;
-
-
 /*------------------------ Functions: QuadAccessor ---------------------------*/
 
 template <int dim>
@@ -519,15 +511,14 @@ double QuadAccessor<dim>::diameter () const {
 
 
 
-template class QuadAccessor<2>;
-
-
 
 
 
 /*------------------------ Functions: CellAccessor<1> -----------------------*/
 
 
+#if deal_II_dimension == 1
+
 template <>
 bool CellAccessor<1>::at_boundary () const {
   return at_boundary(0) || at_boundary(1);
@@ -561,11 +552,13 @@ CellAccessor<1>::face (const unsigned int) const {
   return 0;
 };
 
-
+#endif
 
 /*------------------------ Functions: CellAccessor<2> -----------------------*/
 
 
+#if deal_II_dimension == 2
+
 template <>
 bool CellAccessor<2>::at_boundary () const {
   return at_boundary(0) || at_boundary(1) || at_boundary(2) || at_boundary(3);
@@ -598,6 +591,8 @@ CellAccessor<2>::face (const unsigned int i) const {
   return line(i);
 };
 
+#endif
+
 
 /*------------------------ Functions: CellAccessor<dim> -----------------------*/
 
@@ -760,25 +755,25 @@ bool CellAccessor<dim>::active () const {
 
 
 // explicit instantiations
-template class CellAccessor<1>;
-template class CellAccessor<2>;
-
-template class TriaRawIterator<1,LineAccessor<1> >;
-template class TriaRawIterator<1,CellAccessor<1> >;
-template class TriaRawIterator<2,LineAccessor<2> >;
-template class TriaRawIterator<2,QuadAccessor<2> >;
-template class TriaRawIterator<2,CellAccessor<2> >;
-
-template class TriaIterator<1,LineAccessor<1> >;
-template class TriaIterator<1,CellAccessor<1> >;
-template class TriaIterator<2,LineAccessor<2> >;
-template class TriaIterator<2,QuadAccessor<2> >;
-template class TriaIterator<2,CellAccessor<2> >;
-
-template class TriaActiveIterator<1,LineAccessor<1> >;
-template class TriaActiveIterator<1,CellAccessor<1> >;
-template class TriaActiveIterator<2,LineAccessor<2> >;
-template class TriaActiveIterator<2,QuadAccessor<2> >;
-template class TriaActiveIterator<2,CellAccessor<2> >;
+template class TriaAccessor<deal_II_dimension>;
+template class LineAccessor<deal_II_dimension>;
+template class CellAccessor<deal_II_dimension>;
+template class TriaRawIterator<deal_II_dimension,LineAccessor<deal_II_dimension> >;
+template class TriaRawIterator<deal_II_dimension,CellAccessor<deal_II_dimension> >;
+template class TriaIterator<deal_II_dimension,LineAccessor<deal_II_dimension> >;
+template class TriaIterator<deal_II_dimension,CellAccessor<deal_II_dimension> >;
+template class TriaActiveIterator<deal_II_dimension,LineAccessor<deal_II_dimension> >;
+template class TriaActiveIterator<deal_II_dimension,CellAccessor<deal_II_dimension> >;
+
+#if deal_II_dimension >= 2
+template class QuadAccessor<deal_II_dimension>;
+template class TriaRawIterator<deal_II_dimension,QuadAccessor<deal_II_dimension> >;
+template class TriaIterator<deal_II_dimension,QuadAccessor<deal_II_dimension> >;
+template class TriaActiveIterator<deal_II_dimension,QuadAccessor<deal_II_dimension> >;
+#endif
+
+
+
+
 
 
index 14303c4512c1208f4ac031810f3430006c71e6d5..e62d3ef32e7ad2e611bff3abd23a37255fa82ff6 100644 (file)
@@ -158,20 +158,10 @@ void Assembler<dim>::assemble (const Equation<dim> &equation) {
 
 
 // explicit instantiations
-template class Equation<1>;
-template class Equation<2>;
+template class Equation<deal_II_dimension>;
+template class Assembler<deal_II_dimension>;
+template class AssemblerData<deal_II_dimension>;
 
-template class Assembler<1>;
-template class Assembler<2>;
-
-
-template class AssemblerData<1>;
-template class AssemblerData<2>;
-
-
-template class TriaRawIterator<1,Assembler<1> >;
-template class TriaIterator<1,Assembler<1> >;
-template class TriaActiveIterator<1,Assembler<1> >;
-template class TriaRawIterator<2,Assembler<2> >;
-template class TriaIterator<2,Assembler<2> >;
-template class TriaActiveIterator<2,Assembler<2> >;
+template class TriaRawIterator<deal_II_dimension,Assembler<deal_II_dimension> >;
+template class TriaIterator<deal_II_dimension,Assembler<deal_II_dimension> >;
+template class TriaActiveIterator<deal_II_dimension,Assembler<deal_II_dimension> >;
index 42900b3918e8fa89df7bc046a22559d57ca5342e..3f517bb8f9f629cd0f4f13c65012da28f0a0065f 100644 (file)
@@ -177,5 +177,4 @@ pair<char*,char*> ProblemBase<dim>::get_solution_name () const {
 
 
 // explicit instantiations
-template class ProblemBase<1>;
-template class ProblemBase<2>;
+template class ProblemBase<deal_II_dimension>;
index b3d2d571354634f54df286a7f77ee12e3229b313..52bc54b4edf23d64e1614cc47eadf847c4bed0d5 100644 (file)
@@ -388,11 +388,15 @@ void DataOut<dim>::write_ucd (ostream &out) const {
 
 
 
+#if deal_II_dimension == 1
+
 template <>
 unsigned int DataOut<1>::n_boundary_faces () const {
   return 0;
 };
 
+#endif
+
 
 
 template <int dim>
@@ -411,11 +415,15 @@ unsigned int DataOut<dim>::n_boundary_faces () const {
 
 
 
+
+#if deal_II_dimension == 1
+
 template <>
 void DataOut<1>::write_ucd_faces (ostream &, const unsigned int) const {
   return;
 };
 
+#endif
 
 
 template <int dim>
@@ -594,7 +602,6 @@ string DataOut<dim>::default_suffix (const OutputFormat output_format) {
 
 
 //explicite instantiations
-template class DataIn<1>;
-template class DataIn<2>;
-template class DataOut<1>;
-template class DataOut<2>;
+
+template class DataIn<deal_II_dimension>;
+template class DataOut<deal_II_dimension>;
index f1bfe385367dc4c97d966c8e966a00db33d35b83..b8c4177d7c0aa06f7cdac8bdcd0ccad00411229b 100644 (file)
 
 
 
-inline double sqr (const double x) {
+inline static double sqr (const double x) {
   return x*x;
 };
 
 
 
+#if deal_II_dimension == 1
+
 template <>
 void KellyErrorEstimator<1>::estimate_error (const DoFHandler<1> &,
                                             const Quadrature<0> &,
@@ -34,6 +36,7 @@ void KellyErrorEstimator<1>::estimate_error (const DoFHandler<1> &,
   Assert(false, ExcNotImplemented());
 };
 
+#endif
 
 
 template <int dim>
@@ -173,7 +176,7 @@ void KellyErrorEstimator<dim>::estimate_error (const DoFHandler<dim>    &dof,
 
 
 
-
+#if deal_II_dimension == 1
 
 template <>
 void KellyErrorEstimator<1>::integrate_over_regular_face (const active_cell_iterator &,
@@ -191,6 +194,23 @@ void KellyErrorEstimator<1>::integrate_over_regular_face (const active_cell_iter
 
 
 
+template <>
+void KellyErrorEstimator<1>::
+integrate_over_irregular_face (const active_cell_iterator &,
+                              const unsigned int          ,
+                              const FiniteElement<1>     &,
+                              const Boundary<1>          &,
+                              const unsigned int          ,
+                              FEFaceValues<1>            &,
+                              FESubfaceValues<1>         &,
+                              FaceIntegrals              &,
+                              const dVector              &) {
+  Assert (false, ExcInternalError());
+};
+
+#endif
+
+
 
 template <int dim>
 void KellyErrorEstimator<dim>::
@@ -336,22 +356,6 @@ integrate_over_regular_face (const active_cell_iterator &cell,
 
 
 
-template <>
-void KellyErrorEstimator<1>::
-integrate_over_irregular_face (const active_cell_iterator &,
-                              const unsigned int          ,
-                              const FiniteElement<1>     &,
-                              const Boundary<1>          &,
-                              const unsigned int          ,
-                              FEFaceValues<1>            &,
-                              FESubfaceValues<1>         &,
-                              FaceIntegrals              &,
-                              const dVector              &) {
-  Assert (false, ExcInternalError());
-};
-
-
-
 template <int dim>
 void KellyErrorEstimator<dim>::
 integrate_over_irregular_face (const active_cell_iterator &cell,
@@ -474,5 +478,4 @@ integrate_over_irregular_face (const active_cell_iterator &cell,
 
 // explicit instantiations
 
-template class KellyErrorEstimator<1>;
-template class KellyErrorEstimator<2>;
+template class KellyErrorEstimator<deal_II_dimension>;
index f13b4a666c7d56f12fc2971ee0ec49ef0b8582ec..ce7f1c71f280ff3c2b4fe9b25e8a8b13202cb436 100644 (file)
@@ -104,6 +104,7 @@ void MatrixCreator<dim>::create_mass_matrix (const DoFHandler<dim>    &dof,
 
 
 
+#if deal_II_dimension == 1
 
 template <>
 void MatrixCreator<1>::create_boundary_mass_matrix (const DoFHandler<1>    &,
@@ -118,6 +119,8 @@ void MatrixCreator<1>::create_boundary_mass_matrix (const DoFHandler<1>    &,
   Assert (false, ExcNotImplemented());
 };
 
+#endif
+
 
 
 template <int dim>
@@ -713,12 +716,8 @@ void LaplaceMatrix<dim>::assemble (dVector             &rhs,
 
 
 
-template class MatrixCreator<1>;
-template class MatrixCreator<2>;
-template class MatrixTools<1>;
-template class MatrixTools<2>;
-template class MassMatrix<1>;
-template class MassMatrix<2>;
-template class LaplaceMatrix<1>;
-template class LaplaceMatrix<2>;
+template class MatrixCreator<deal_II_dimension>;
+template class MatrixTools<deal_II_dimension>;
+template class MassMatrix<deal_II_dimension>;
+template class LaplaceMatrix<deal_II_dimension>;
 
index 2699f2451aa43252ba45549796b211d800e0c9c7..f206162778847136f9b39948c75db781e145ce62 100644 (file)
@@ -71,6 +71,7 @@ void VectorTools<dim>::interpolate (const DoFHandler<dim>    &dof,
 
 
 
+#if deal_II_dimension == 1
 
 template <>
 void VectorTools<1>::project (const DoFHandler<1>    &,
@@ -92,6 +93,8 @@ void VectorTools<1>::project (const DoFHandler<1>    &,
   Assert (false, ExcNotImplemented());
 };
 
+#endif
+
 
 
 
@@ -204,6 +207,8 @@ void VectorTools<dim>::create_right_hand_side (const DoFHandler<dim>    &dof,
 
 
 
+#if deal_II_dimension == 1
+
 template <>
 void
 VectorTools<1>::interpolate_boundary_values (const DoFHandler<1> &,
@@ -214,6 +219,7 @@ VectorTools<1>::interpolate_boundary_values (const DoFHandler<1> &,
   Assert (false, ExcNotImplemented());
 };
 
+#endif
 
 
 
@@ -527,5 +533,4 @@ void VectorTools<dim>::integrate_difference (const DoFHandler<dim>    &dof,
 };
 
 
-template VectorTools<1>;
-template VectorTools<2>;
+template VectorTools<deal_II_dimension>;
index 6c3cbc83fbce9fe715ccd6d383b40c92a6508e97..7fcb84c7b66b4382434ae1659bbff4b3e0af3fc2 100644 (file)
@@ -15,7 +15,7 @@ debug-mode = on
 
 # If you want your program to be linked with extra object or library
 # files, specify them here:
-user-libs = ../../../mia/control.o
+user-libs = ../../../mia/control.o ../../lib/libfe.g.a
 
 # To run the program, use "make run"; to give parameters to the program,
 # give the parameters to the following variable:
index ea43603d23af54617c570d65d91430ef4d56b149..c598c614beb165bf81bca392a076ddd8b26f7cf8 100644 (file)
@@ -5,7 +5,7 @@
 
 
 
-
+#if deal_II_dimension == 1
 
 void PoissonEquation<1>::assemble (dFMatrix            &cell_matrix,
                                   dVector             &rhs,
@@ -24,8 +24,12 @@ void PoissonEquation<1>::assemble (dFMatrix            &cell_matrix,
       };
 };
 
+#endif
+
 
 
+#if deal_II_dimension == 2
+
 void PoissonEquation<2>::assemble (dFMatrix            &cell_matrix,
                                   dVector             &rhs,
                                   const FEValues<2>   &fe_values,
@@ -50,6 +54,8 @@ void PoissonEquation<2>::assemble (dFMatrix            &cell_matrix,
       };
 };
 
+#endif
+
 
 
 template <int dim>
@@ -73,5 +79,4 @@ void PoissonEquation<dim>::assemble (dVector             &,
 
 
 
-template class PoissonEquation<1>;
 template class PoissonEquation<2>;

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.