]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Enforce -pedantic -ansi when using the gcc compiler in order to get closer to the...
authorWolfgang Bangerth <bangerth@math.tamu.edu>
Wed, 14 Jun 2000 11:16:48 +0000 (11:16 +0000)
committerWolfgang Bangerth <bangerth@math.tamu.edu>
Wed, 14 Jun 2000 11:16:48 +0000 (11:16 +0000)
Doing so required a whole lot of changes, which mostly fall into the following to categories:
1/ Adding `typename' when accessing template dependent names, such as
   vector<T>::iterator.
2/ When accessing member classes of templatized parent classes, full qualification is
   required. Thus, when in Derived<dim>::f we want to access the type Base<dim>::ExcSomething,
   we have to use typename Base<dim>::ExcSomething now.

Overall, these changes should lead to more portable code.

git-svn-id: https://svn.dealii.org/trunk@3011 0785d39b-7218-0410-832d-ea1e28bc413d

40 files changed:
deal.II/base/source/function_lib.cc
deal.II/configure
deal.II/configure.in
deal.II/deal.II/include/dofs/dof_accessor.templates.h
deal.II/deal.II/include/fe/fe_values.h
deal.II/deal.II/include/grid/tria_accessor.templates.h
deal.II/deal.II/include/numerics/data_out.h
deal.II/deal.II/source/dofs/dof_accessor.cc
deal.II/deal.II/source/fe/fe.cc
deal.II/deal.II/source/fe/fe_lib.criss_cross.cc
deal.II/deal.II/source/fe/fe_lib.dg.cc
deal.II/deal.II/source/fe/fe_lib.dg.constant.cc
deal.II/deal.II/source/fe/fe_lib.dgp1.cc
deal.II/deal.II/source/fe/fe_lib.dgp2.cc
deal.II/deal.II/source/fe/fe_lib.dgp3.cc
deal.II/deal.II/source/fe/fe_lib.linear.cc
deal.II/deal.II/source/fe/fe_system.cc
deal.II/deal.II/source/fe/fe_values.cc
deal.II/deal.II/source/fe/q1_mapping.cc
deal.II/deal.II/source/grid/persistent_tria.cc
deal.II/deal.II/source/grid/tria_accessor.cc
deal.II/deal.II/source/grid/tria_boundary.cc
deal.II/deal.II/source/multigrid/mg_dof_accessor.cc
deal.II/deal.II/source/numerics/base.cc
deal.II/deal.II/source/numerics/data_out.cc
deal.II/deal.II/source/numerics/data_out_stack.cc
deal.II/deal.II/source/numerics/derivative_approximation.cc
deal.II/deal.II/source/numerics/error_estimator.cc
deal.II/deal.II/source/numerics/gradient_estimator.cc
deal.II/examples/step-6/step-6.cc
deal.II/examples/step-9/step-9.cc
deal.II/lac/include/lac/solver_bicgstab.h
deal.II/lac/include/lac/solver_qmrs.h
deal.II/lac/include/lac/vector_memory.h
tests/big-tests/convergence/convergence.cc
tests/big-tests/error-estimation/error-estimation.cc
tests/big-tests/multigrid/multigrid.cc
tests/big-tests/nonlinear/fixed-point-iteration/nonlinear.cc
tests/big-tests/poisson/equation.cc
tests/deal.II/wave-test-3.cc

index 14f8f594eec2be1b4dcbfc34ad9330f7dd6ecc56..b33804a119c4dfe4c66cd3ab7849d4ddedffa67b 100644 (file)
 
 #include <cmath>
 
+
+// in strict ANSI C mode, the following constants are not defined by
+// default, so we do it ourselves
+#ifndef M_PI
+#  define      M_PI            3.14159265358979323846
+#endif
+
+#ifndef M_PI_2
+#  define      M_PI_2          1.57079632679489661923
+#endif
+
+
+
+
+
 template<int dim>
 double
 PillowFunction<dim>::value (const Point<dim>   &p,
index a39af221eb0e1c4ab8303344b784919825164d92..48a44a580dede957016e55d964ae0434a4017803 100755 (executable)
@@ -1156,7 +1156,7 @@ fi
 
 if test $GXX = yes ; then
   CXXFLAGSO="-O2 -Wuninitialized -felide-constructors -fnonnull-objects -ftemplate-depth-32"
-  CXXFLAGSG="-DDEBUG -ggdb -Wall -W -Wtraditional -Wpointer-arith -Wbad-function-cast -Wwrite-strings -Wmissing-prototypes -Wmissing-declarations -Wnested-externs -Winline -Woverloaded-virtual -Wstrict-prototypes -Wsynth -Wsign-compare -Wconversion -ftemplate-depth-32"
+  CXXFLAGSG="-DDEBUG -ggdb -ansi -pedantic -Wall -W -Wtraditional -Wpointer-arith -Wbad-function-cast -Wwrite-strings -Wmissing-prototypes -Wmissing-declarations -Wnested-externs -Winline -Woverloaded-virtual -Wstrict-prototypes -Wsynth -Wsign-compare -Wconversion -ftemplate-depth-32"
 
                       
   case "$GXXVERSION" in
index 0974d8ba5334d8e330a3b42c2df928eeab0aa48e..e8ac7576bb505cbca18bfbabc9a4fb44b80acea8 100644 (file)
@@ -89,7 +89,7 @@ dnl -------------------------------------------------------------
 
 if test $GXX = yes ; then
   CXXFLAGSO="-O2 -Wuninitialized -felide-constructors -fnonnull-objects -ftemplate-depth-32"
-  CXXFLAGSG="-DDEBUG -ggdb -Wall -W -Wtraditional -Wpointer-arith -Wbad-function-cast -Wwrite-strings -Wmissing-prototypes -Wmissing-declarations -Wnested-externs -Winline -Woverloaded-virtual -Wstrict-prototypes -Wsynth -Wsign-compare -Wconversion -ftemplate-depth-32"
+  CXXFLAGSG="-DDEBUG -ggdb -ansi -pedantic -Wall -W -Wtraditional -Wpointer-arith -Wbad-function-cast -Wwrite-strings -Wmissing-prototypes -Wmissing-declarations -Wnested-externs -Winline -Woverloaded-virtual -Wstrict-prototypes -Wsynth -Wsign-compare -Wconversion -ftemplate-depth-32"
 
   dnl set some flags that are specific to some versions of the
   dnl compiler:
index 9731e925139e460e8a15a6805e03e1a2e07de08b..43c2f7576fe3802570b60ccc7de91b809b0b291d 100644 (file)
@@ -82,10 +82,21 @@ inline
 unsigned int
 DoFObjectAccessor<1,dim>::dof_index (const unsigned int i) const
 {
-  Assert (dof_handler != 0, ExcInvalidObject());
+                                  // since the exception classes are
+                                  // from a template dependent base
+                                  // class, we have to fully qualify
+                                  // them. to work around more
+                                  // trouble, typedef the template
+                                  // dependent base class to a
+                                  // non-template dependent name and
+                                  // use that to specify the
+                                  // qualified exception names
+  typedef DoFAccessor<dim> BaseClass;
+  
+  Assert (dof_handler != 0, typename BaseClass::ExcInvalidObject());
                                   // make sure a FE has been selected
                                   // and enough room was reserved
-  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+  Assert (dof_handler->selected_fe != 0, typename BaseClass::ExcInvalidObject());
   Assert (i<dof_handler->selected_fe->dofs_per_line,
          ExcIndexRange (i, 0, dof_handler->selected_fe->dofs_per_line));
 
@@ -100,8 +111,19 @@ unsigned int
 DoFObjectAccessor<1,dim>::vertex_dof_index (const unsigned int vertex,
                                            const unsigned int i) const
 {
-  Assert (dof_handler != 0, ExcInvalidObject());
-  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+                                  // since the exception classes are
+                                  // from a template dependent base
+                                  // class, we have to fully qualify
+                                  // them. to work around more
+                                  // trouble, typedef the template
+                                  // dependent base class to a
+                                  // non-template dependent name and
+                                  // use that to specify the
+                                  // qualified exception names
+  typedef DoFAccessor<dim> BaseClass;
+  
+  Assert (dof_handler != 0, typename BaseClass::ExcInvalidObject());
+  Assert (dof_handler->selected_fe != 0, typename BaseClass::ExcInvalidObject());
   Assert (vertex<2, ExcIndexRange (i,0,2));
   Assert (i<dof_handler->selected_fe->dofs_per_vertex,
          ExcIndexRange (i, 0, dof_handler->selected_fe->dofs_per_vertex));
@@ -118,11 +140,22 @@ inline
 void
 DoFObjectAccessor<1,dim>::get_dof_indices (vector<unsigned int> &dof_indices) const
 {
-  Assert (dof_handler != 0, ExcInvalidObject());
-  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+                                  // since the exception classes are
+                                  // from a template dependent base
+                                  // class, we have to fully qualify
+                                  // them. to work around more
+                                  // trouble, typedef the template
+                                  // dependent base class to a
+                                  // non-template dependent name and
+                                  // use that to specify the
+                                  // qualified exception names
+  typedef DoFAccessor<dim> BaseClass;
+  
+  Assert (dof_handler != 0, typename BaseClass::ExcInvalidObject());
+  Assert (dof_handler->selected_fe != 0, typename BaseClass::ExcInvalidObject());
   Assert (dof_indices.size() == (2*dof_handler->get_fe().dofs_per_vertex +
                                 dof_handler->get_fe().dofs_per_line),
-         ExcVectorDoesNotMatch());
+         typename BaseClass::ExcVectorDoesNotMatch());
 
   const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
                     dofs_per_line   = dof_handler->get_fe().dofs_per_line;
@@ -169,10 +202,12 @@ template <int dim>
 inline
 unsigned int DoFObjectAccessor<2,dim>::dof_index (const unsigned int i) const
 {
-  Assert (dof_handler != 0, ExcInvalidObject());
+  Assert (dof_handler != 0,
+         typename DoFAccessor<dim>::ExcInvalidObject());
                                   // make sure a FE has been selected
                                   // and enough room was reserved
-  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+  Assert (dof_handler->selected_fe != 0,
+         typename DoFAccessor<dim>::ExcInvalidObject());
   Assert (i<dof_handler->selected_fe->dofs_per_quad,
          ExcIndexRange (i, 0, dof_handler->selected_fe->dofs_per_quad));
 
@@ -187,8 +222,10 @@ unsigned int
 DoFObjectAccessor<2,dim>::vertex_dof_index (const unsigned int vertex,
                                            const unsigned int i) const
 {
-  Assert (dof_handler != 0, ExcInvalidObject());
-  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+  Assert (dof_handler != 0,
+         typename DoFAccessor<dim>::ExcInvalidObject());
+  Assert (dof_handler->selected_fe != 0,
+         typename DoFAccessor<dim>::ExcInvalidObject());
   Assert (vertex<4, ExcIndexRange (i,0,4));
   Assert (i<dof_handler->selected_fe->dofs_per_vertex,
          ExcIndexRange (i, 0, dof_handler->selected_fe->dofs_per_vertex));
@@ -205,12 +242,14 @@ inline
 void
 DoFObjectAccessor<2,dim>::get_dof_indices (vector<unsigned int> &dof_indices) const
 {
-  Assert (dof_handler != 0, ExcInvalidObject());
-  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+  Assert (dof_handler != 0,
+         typename DoFAccessor<dim>::ExcInvalidObject());
+  Assert (dof_handler->selected_fe != 0,
+         typename DoFAccessor<dim>::ExcInvalidObject());
   Assert (dof_indices.size() == (4*dof_handler->get_fe().dofs_per_vertex +
                                 4*dof_handler->get_fe().dofs_per_line +
                                 dof_handler->get_fe().dofs_per_quad),
-         ExcVectorDoesNotMatch());
+         typename DoFAccessor<dim>::ExcVectorDoesNotMatch());
 
   const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
                     dofs_per_line   = dof_handler->get_fe().dofs_per_line,
@@ -280,10 +319,12 @@ inline
 unsigned int
 DoFObjectAccessor<3,dim>::dof_index (const unsigned int i) const
 {
-  Assert (dof_handler != 0, ExcInvalidObject());
+  Assert (dof_handler != 0,
+         typename DoFAccessor<dim>::ExcInvalidObject());
                                   // make sure a FE has been selected
                                   // and enough room was reserved
-  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+  Assert (dof_handler->selected_fe != 0,
+         typename DoFAccessor<dim>::ExcInvalidObject());
   Assert (i<dof_handler->selected_fe->dofs_per_hex,
          ExcIndexRange (i, 0, dof_handler->selected_fe->dofs_per_hex));
 
@@ -298,8 +339,10 @@ unsigned int
 DoFObjectAccessor<3,dim>::vertex_dof_index (const unsigned int vertex,
                                            const unsigned int i) const
 {
-  Assert (dof_handler != 0, ExcInvalidObject());
-  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+  Assert (dof_handler != 0,
+         typename DoFAccessor<dim>::ExcInvalidObject());
+  Assert (dof_handler->selected_fe != 0,
+         typename DoFAccessor<dim>::ExcInvalidObject());
   Assert (vertex<8, ExcIndexRange (i,0,8));
   Assert (i<dof_handler->selected_fe->dofs_per_vertex,
          ExcIndexRange (i, 0, dof_handler->selected_fe->dofs_per_vertex));
@@ -316,13 +359,15 @@ inline
 void
 DoFObjectAccessor<3,dim>::get_dof_indices (vector<unsigned int> &dof_indices) const
 {
-  Assert (dof_handler != 0, ExcInvalidObject());
-  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+  Assert (dof_handler != 0,
+         typename DoFAccessor<dim>::ExcInvalidObject());
+  Assert (dof_handler->selected_fe != 0,
+         typename DoFAccessor<dim>::ExcInvalidObject());
   Assert (dof_indices.size() == (8*dof_handler->get_fe().dofs_per_vertex +
                                 12*dof_handler->get_fe().dofs_per_line +
                                 6*dof_handler->get_fe().dofs_per_quad +
                                 dof_handler->get_fe().dofs_per_hex),
-         ExcVectorDoesNotMatch());
+         typename DoFAccessor<dim>::ExcVectorDoesNotMatch());
 
   const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
                     dofs_per_line   = dof_handler->get_fe().dofs_per_line,
index 633f7957209d926a26623ceccf09ab766870e496..1d5dea2b953bb835ea35c000376010bd9b01643b 100644 (file)
@@ -1259,6 +1259,8 @@ class FESubfaceValues : public FEFaceValuesBase<dim>
 };
 
 
+
+
 /*------------------------ Inline functions: FEValuesBase ------------------------*/
 
 
@@ -1273,6 +1275,7 @@ const FullMatrix<double> & FEValuesBase<dim>::get_shape_values () const
 };
 
 
+
 template <int dim>
 inline
 const vector<vector<Tensor<1,dim> > > &
@@ -1283,6 +1286,7 @@ FEValuesBase<dim>::get_shape_grads () const
 };
 
 
+
 template <int dim>
 inline
 const vector<vector<Tensor<2,dim> > > &
@@ -1293,45 +1297,55 @@ FEValuesBase<dim>::get_shape_2nd_derivatives () const
 };
 
 
+
 template <int dim>
 inline
 const vector<Point<dim> > &
-FEValuesBase<dim>::get_quadrature_points () const {
+FEValuesBase<dim>::get_quadrature_points () const
+{
   Assert (update_flags & update_q_points, ExcAccessToUninitializedField());
   return quadrature_points;
 };
 
 
+
 template <int dim>
 inline
 const vector<Point<dim> > &
-FEValuesBase<dim>::get_support_points () const {
+FEValuesBase<dim>::get_support_points () const
+{
   Assert (update_flags & update_support_points, ExcAccessToUninitializedField());
   return support_points;
 };
 
 
+
 template <int dim>
 inline
 const vector<double> &
-FEValuesBase<dim>::get_JxW_values () const {
+FEValuesBase<dim>::get_JxW_values () const
+{
   Assert (update_flags & update_JxW_values, ExcAccessToUninitializedField());
   return JxW_values;
 };
 
 
+
 template <int dim>
 inline
 const FiniteElement<dim> & 
-FEValuesBase<dim>::get_fe () const {
+FEValuesBase<dim>::get_fe () const
+{
   return *fe;
 };
 
 
+
 template <int dim>
 inline
 const DoFHandler<dim>::cell_iterator &
-FEValuesBase<dim>::get_cell() const {
+FEValuesBase<dim>::get_cell() const
+{
   return present_cell;
 };
 
@@ -1341,8 +1355,10 @@ FEValuesBase<dim>::get_cell() const {
 template <int dim>
 inline
 const vector<Point<dim> > &
-FEFaceValuesBase<dim>::get_normal_vectors () const {
-  Assert (update_flags & update_normal_vectors, ExcAccessToUninitializedField());
+FEFaceValuesBase<dim>::get_normal_vectors () const
+{
+  Assert (update_flags & update_normal_vectors,
+         typename FEValuesBase<dim>::ExcAccessToUninitializedField());
   return normal_vectors;
 };
 
index 8be18157867b8685227fcc4daef4128bb75d56ca..51e5e35e362b9702f654b4d8a4a59c9796b008ef 100644 (file)
@@ -103,7 +103,8 @@ template <int dim>
 inline
 bool
 TriaObjectAccessor<1,dim>::used () const {
-  Assert (state() == valid, ExcDereferenceInvalidObject());
+  Assert (state() == valid,
+         typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
   return tria->levels[present_level]->lines.used[present_index];
 };
 
@@ -112,7 +113,7 @@ template <int dim>
 inline
 bool
 TriaObjectAccessor<1,dim>::user_flag_set () const {
-  Assert (used(), ExcCellNotUsed());
+  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
   return tria->levels[present_level]->lines.user_flags[present_index];
 };
 
@@ -121,7 +122,7 @@ template <int dim>
 inline
 void
 TriaObjectAccessor<1,dim>::set_user_flag () const {
-  Assert (used(), ExcCellNotUsed());
+  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
   tria->levels[present_level]->lines.user_flags[present_index] = true;
 };
 
@@ -130,7 +131,7 @@ template <int dim>
 inline
 void
 TriaObjectAccessor<1,dim>::clear_user_flag () const {
-  Assert (used(), ExcCellNotUsed());
+  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
   tria->levels[present_level]->lines.user_flags[present_index] = false;
 };
 
@@ -145,7 +146,7 @@ TriaObjectAccessor<1,dim>::child (const unsigned int i) const {
   
 #ifdef DEBUG
   if (q.state() != past_the_end)
-    Assert (q->used(), ExcUnusedCellAsChild());
+    Assert (q->used(), typename TriaAccessor<dim>::ExcUnusedCellAsChild());
 #endif
   return q;
 };
@@ -164,7 +165,7 @@ template <int dim>
 inline
 bool
 TriaObjectAccessor<1,dim>::has_children () const {
-  Assert (state() == valid, ExcDereferenceInvalidObject());
+  Assert (state() == valid, typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
   return (tria->levels[present_level]->lines.children[present_index] != -1);
 }
 
@@ -240,7 +241,8 @@ template <int dim>
 inline
 bool
 TriaObjectAccessor<2,dim>::used () const {
-  Assert (state() == valid, ExcDereferenceInvalidObject());
+  Assert (state() == valid,
+         typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
   return tria->levels[present_level]->quads.used[present_index];
 };
 
@@ -249,7 +251,7 @@ template <int dim>
 inline
 bool
 TriaObjectAccessor<2,dim>::user_flag_set () const {
-  Assert (used(), ExcCellNotUsed());
+  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
   return tria->levels[present_level]->quads.user_flags[present_index];
 };
 
@@ -258,7 +260,7 @@ template <int dim>
 inline
 void
 TriaObjectAccessor<2,dim>::set_user_flag () const {
-  Assert (used(), ExcCellNotUsed());
+  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
   tria->levels[present_level]->quads.user_flags[present_index] = true;
 };
 
@@ -267,7 +269,7 @@ template <int dim>
 inline
 void
 TriaObjectAccessor<2,dim>::clear_user_flag () const {
-  Assert (used(), ExcCellNotUsed());
+  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
   tria->levels[present_level]->quads.user_flags[present_index] = false;
 };
 
@@ -306,7 +308,7 @@ TriaObjectAccessor<2,dim>::child (const unsigned int i) const {
   
 #ifdef DEBUG
   if (q.state() != past_the_end)
-    Assert (q->used(), ExcUnusedCellAsChild());
+    Assert (q->used(), typename TriaAccessor<dim>::ExcUnusedCellAsChild());
 #endif
   return q;
 };
@@ -324,7 +326,7 @@ template <int dim>
 inline
 bool
 TriaObjectAccessor<2,dim>::has_children () const {
-  Assert (state() == valid, ExcDereferenceInvalidObject());
+  Assert (state() == valid, typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
   return (tria->levels[present_level]->quads.children[present_index] != -1);
 };
 
@@ -402,7 +404,8 @@ template <int dim>
 inline
 bool
 TriaObjectAccessor<3,dim>::used () const {
-  Assert (state() == valid, ExcDereferenceInvalidObject());
+  Assert (state() == valid,
+         typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
   return tria->levels[present_level]->hexes.used[present_index];
 };
 
@@ -411,7 +414,7 @@ template <int dim>
 inline
 bool
 TriaObjectAccessor<3,dim>::user_flag_set () const {
-  Assert (used(), ExcCellNotUsed());
+  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
   return tria->levels[present_level]->hexes.user_flags[present_index];
 };
 
@@ -420,7 +423,7 @@ template <int dim>
 inline
 void
 TriaObjectAccessor<3,dim>::set_user_flag () const {
-  Assert (used(), ExcCellNotUsed());
+  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
   tria->levels[present_level]->hexes.user_flags[present_index] = true;
 };
 
@@ -428,7 +431,7 @@ TriaObjectAccessor<3,dim>::set_user_flag () const {
 template <int dim>
 inline
 void TriaObjectAccessor<3,dim>::clear_user_flag () const {
-  Assert (used(), ExcCellNotUsed());
+  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
   tria->levels[present_level]->hexes.user_flags[present_index] = false;
 };
 
@@ -437,7 +440,7 @@ template <int dim>
 inline
 TriaIterator<dim,TriaObjectAccessor<1,dim> >
 TriaObjectAccessor<3,dim>::line (const unsigned int i) const {
-  Assert (used(), ExcCellNotUsed());
+  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
   Assert (i<12, ExcIndexRange (i,0,12));
 
                                   // egcs 1.1.2 gets into trouble if we
@@ -474,7 +477,7 @@ template <int dim>
 inline
 TriaIterator<dim,TriaObjectAccessor<2,dim> >
 TriaObjectAccessor<3,dim>::quad (const unsigned int i) const {
-  Assert (used(), ExcCellNotUsed());
+  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
   return
     TriaIterator<dim,TriaObjectAccessor<2,dim> >
     (
@@ -535,7 +538,7 @@ TriaObjectAccessor<3,dim>::child (const unsigned int i) const
   
 #ifdef DEBUG
   if (q.state() != past_the_end)
-    Assert (q->used(), ExcUnusedCellAsChild());
+    Assert (q->used(), typename TriaAccessor<dim>::ExcUnusedCellAsChild());
 #endif
   return q;
 };
@@ -551,7 +554,7 @@ int TriaObjectAccessor<3,dim>::child_index (unsigned int i) const {
 
 template <int dim>
 bool TriaObjectAccessor<3,dim>::has_children () const {
-  Assert (state() == valid, ExcDereferenceInvalidObject());
+  Assert (state() == valid, typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
   return (tria->levels[present_level]->hexes.children[present_index] != -1);
 };
 
@@ -927,7 +930,7 @@ inline
 int
 CellAccessor<dim>::neighbor_index (const unsigned int i) const {
   Assert (i<GeometryInfo<dim>::faces_per_cell,
-         ExcInvalidNeighbor(i));
+         typename TriaAccessor<dim>::ExcInvalidNeighbor(i));
   return tria->levels[present_level]->
     neighbors[present_index*GeometryInfo<dim>::faces_per_cell+i].second;
 };
@@ -936,19 +939,22 @@ CellAccessor<dim>::neighbor_index (const unsigned int i) const {
 template <int dim>
 inline
 int
-CellAccessor<dim>::neighbor_level (const unsigned int i) const {
+CellAccessor<dim>::neighbor_level (const unsigned int i) const
+{
   Assert (i<GeometryInfo<dim>::faces_per_cell,
-         ExcInvalidNeighbor(i));
+         typename TriaAccessor<dim>::ExcInvalidNeighbor(i));
   return tria->levels[present_level]->
     neighbors[present_index*GeometryInfo<dim>::faces_per_cell+i].first;
 };
 
 
+
 template <int dim>
 inline
 bool
-CellAccessor<dim>::refine_flag_set () const {
-  Assert (used(), ExcCellNotUsed());
+CellAccessor<dim>::refine_flag_set () const
+{
+  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
                                   // cells flagged for refinement must be active
                                   // (the #set_refine_flag# function checks this,
                                   // but activity may change when refinement is
@@ -960,31 +966,38 @@ CellAccessor<dim>::refine_flag_set () const {
 };
 
 
+
 template <int dim>
 inline
 void
-CellAccessor<dim>::set_refine_flag () const {
+CellAccessor<dim>::set_refine_flag () const
+{
   Assert (used() && active(), ExcRefineCellNotActive());
-  Assert (!coarsen_flag_set(), ExcCellFlaggedForCoarsening());
+  Assert (!coarsen_flag_set(),
+         ExcCellFlaggedForCoarsening());
   
   tria->levels[present_level]->refine_flags[present_index] = true;
 };
 
 
+
 template <int dim>
 inline
 void
-CellAccessor<dim>::clear_refine_flag () const {
+CellAccessor<dim>::clear_refine_flag () const
+{
   Assert (used() && active(), ExcRefineCellNotActive());
   tria->levels[present_level]->refine_flags[present_index] = false;
 };
 
 
+
 template <int dim>
 inline
 bool
-CellAccessor<dim>::coarsen_flag_set () const {
-  Assert (used(), ExcCellNotUsed());
+CellAccessor<dim>::coarsen_flag_set () const
+{
+  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
                                   // cells flagged for coarsening must be active
                                   // (the #set_refine_flag# function checks this,
                                   // but activity may change when refinement is
@@ -996,10 +1009,12 @@ CellAccessor<dim>::coarsen_flag_set () const {
 };
 
 
+
 template <int dim>
 inline
 void
-CellAccessor<dim>::set_coarsen_flag () const {
+CellAccessor<dim>::set_coarsen_flag () const
+{
   Assert (used() && active(), ExcRefineCellNotActive());
   Assert (!refine_flag_set(), ExcCellFlaggedForRefinement());
   
@@ -1007,47 +1022,55 @@ CellAccessor<dim>::set_coarsen_flag () const {
 };
 
 
+
 template <int dim>
 inline
 void
-CellAccessor<dim>::clear_coarsen_flag () const {
+CellAccessor<dim>::clear_coarsen_flag () const
+{
   Assert (used() && active(), ExcRefineCellNotActive());
   tria->levels[present_level]->coarsen_flags[present_index] = false;
 };
 
 
+
 template <int dim>
 inline
 TriaIterator<dim,CellAccessor<dim> >
-CellAccessor<dim>::neighbor (const unsigned int i) const {
+CellAccessor<dim>::neighbor (const unsigned int i) const
+{
   TriaIterator<dim,CellAccessor<dim> > q (tria, neighbor_level (i), neighbor_index (i));
 
 #ifdef DEBUG
   if (q.state() != past_the_end)
-    Assert (q->used(), ExcUnusedCellAsNeighbor());
+    Assert (q->used(), typename TriaAccessor<dim>::ExcUnusedCellAsNeighbor());
 #endif
   return q;
 };
 
 
+
 template <int dim>
 inline
 TriaIterator<dim,CellAccessor<dim> >
-CellAccessor<dim>::child (const unsigned int i) const {
+CellAccessor<dim>::child (const unsigned int i) const
+{
   TriaIterator<dim,CellAccessor<dim> > q (tria, present_level+1, child_index (i));
 
 #ifdef DEBUG
   if (q.state() != past_the_end)
-    Assert (q->used(), ExcUnusedCellAsChild());
+    Assert (q->used(), typename TriaAccessor<dim>::ExcUnusedCellAsChild());
 #endif
   return q;
 };
 
 
+
 template <int dim>
 inline
 bool
-CellAccessor<dim>::active () const {
+CellAccessor<dim>::active () const
+{
   return !has_children();
 };
 
index 490584367f4f8f0b8a9f8226c753b7921ddf3a1b..3442db7b7ea69bbf3eceede15252ce34c097df5a 100644 (file)
@@ -486,7 +486,7 @@ class DataOut : public DataOut_DoFData<dim>
                                      * used, the function is called
                                      * once and generates all patches.
                                      */
-    void DataOut<dim>::build_some_patches (Data data);
+    void build_some_patches (Data data);
 };
 
 
index 191e4c861f795fdcfd9e6ddf0449adb87c2276e6..a31776eaf4d9d1d7d371cb9a6d46a8debbd3dcf8 100644 (file)
@@ -51,9 +51,23 @@ template <int dim>
 void DoFObjectAccessor<1, dim>::set_vertex_dof_index (const unsigned int vertex,
                                                      const unsigned int i,
                                                      const unsigned int index) const
+
 {
-  Assert (dof_handler != 0, ExcInvalidObject());
-  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+                                  // since the exception classes are
+                                  // from a template dependent base
+                                  // class, we have to fully qualify
+                                  // them. to work around more
+                                  // trouble, typedef the template
+                                  // dependent base class to a
+                                  // non-template dependent name and
+                                  // use that to specify the
+                                  // qualified exception names
+  typedef DoFAccessor<dim> BaseClass;
+  
+  Assert (dof_handler != 0,
+         typename BaseClass::ExcInvalidObject());
+  Assert (dof_handler->selected_fe != 0,
+         typename BaseClass::ExcInvalidObject());
   Assert (vertex<2, ExcIndexRange (i,0,2));
   Assert (i<dof_handler->selected_fe->dofs_per_vertex,
          ExcIndexRange (i, 0, dof_handler->selected_fe->dofs_per_vertex));
@@ -69,14 +83,28 @@ void DoFObjectAccessor<1, dim>::set_vertex_dof_index (const unsigned int vertex,
 template <int dim>
 void DoFObjectAccessor<1, dim>::
 distribute_local_to_global (const Vector<double> &local_source,
-                           Vector<double>       &global_destination) const {
-  Assert (dof_handler != 0, ExcInvalidObject());
-  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+                           Vector<double>       &global_destination) const
+{
+                                  // since the exception classes are
+                                  // from a template dependent base
+                                  // class, we have to fully qualify
+                                  // them. to work around more
+                                  // trouble, typedef the template
+                                  // dependent base class to a
+                                  // non-template dependent name and
+                                  // use that to specify the
+                                  // qualified exception names
+  typedef DoFAccessor<dim> BaseClass;
+  
+  Assert (dof_handler != 0,
+         typename BaseClass::ExcInvalidObject());
+  Assert (dof_handler->selected_fe != 0,
+         typename BaseClass::ExcInvalidObject());
   Assert (local_source.size() == (2*dof_handler->get_fe().dofs_per_vertex +
                                  dof_handler->get_fe().dofs_per_line),
-         ExcVectorDoesNotMatch());
+         typename BaseClass::ExcVectorDoesNotMatch());
   Assert (dof_handler->n_dofs() == global_destination.size(),
-         ExcVectorDoesNotMatch());
+         typename BaseClass::ExcVectorDoesNotMatch());
 
   const unsigned int n_dofs = local_source.size();
   
@@ -94,18 +122,32 @@ distribute_local_to_global (const Vector<double> &local_source,
 template <int dim>
 void DoFObjectAccessor<1, dim>::
 distribute_local_to_global (const FullMatrix<double> &local_source,
-                           SparseMatrix<double>     &global_destination) const {
-  Assert (dof_handler != 0, ExcInvalidObject());
-  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+                           SparseMatrix<double>     &global_destination) const
+{
+                                  // since the exception classes are
+                                  // from a template dependent base
+                                  // class, we have to fully qualify
+                                  // them. to work around more
+                                  // trouble, typedef the template
+                                  // dependent base class to a
+                                  // non-template dependent name and
+                                  // use that to specify the
+                                  // qualified exception names
+  typedef DoFAccessor<dim> BaseClass;
+  
+  Assert (dof_handler != 0,
+         typename BaseClass::ExcInvalidObject());
+  Assert (dof_handler->selected_fe != 0,
+         typename BaseClass::ExcInvalidObject());
   Assert (local_source.m() == (2*dof_handler->get_fe().dofs_per_vertex +
                               dof_handler->get_fe().dofs_per_line),
-         ExcVectorDoesNotMatch());
+         typename BaseClass::ExcVectorDoesNotMatch());
   Assert (local_source.m() == local_source.n(),
-         ExcMatrixDoesNotMatch());
+         typename BaseClass::ExcMatrixDoesNotMatch());
   Assert (dof_handler->n_dofs() == global_destination.m(),
-         ExcMatrixDoesNotMatch());
+         typename BaseClass::ExcMatrixDoesNotMatch());
   Assert (global_destination.m() == global_destination.n(),
-         ExcMatrixDoesNotMatch());
+         typename BaseClass::ExcMatrixDoesNotMatch());
 
   const unsigned int n_dofs = local_source.m();
 
@@ -135,7 +177,7 @@ DoFObjectAccessor<1,dim>::get_dof_values (const InputVector &values,
          DoFAccessor<1>::ExcVectorDoesNotMatch());
   Assert (values.size() == dof_handler->n_dofs(),
          DoFAccessor<1>::ExcVectorDoesNotMatch());
-  Assert (has_children() == false, ExcNotActive());
+  Assert (has_children() == false, DoFAccessor<1>::ExcNotActive());
   
   const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
                     dofs_per_line   = dof_handler->get_fe().dofs_per_line;
@@ -166,7 +208,7 @@ DoFObjectAccessor<1,dim>::set_dof_values (const Vector<number> &local_values,
          DoFAccessor<1>::ExcVectorDoesNotMatch());
   Assert (values.size() == dof_handler->n_dofs(),
          DoFAccessor<1>::ExcVectorDoesNotMatch());
-  Assert (has_children() == false, ExcNotActive());
+  Assert (has_children() == false, DoFAccessor<1>::ExcNotActive());
   
   const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
                     dofs_per_line   = dof_handler->get_fe().dofs_per_line;
@@ -189,10 +231,12 @@ template <int dim>
 void DoFObjectAccessor<2, dim>::set_dof_index (const unsigned int i,
                                               const unsigned int index) const
 {
-  Assert (dof_handler != 0, ExcInvalidObject());
+  Assert (dof_handler != 0,
+         typename DoFAccessor<dim>::ExcInvalidObject());
                                   // make sure a FE has been selected
                                   // and enough room was reserved
-  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+  Assert (dof_handler->selected_fe != 0,
+         typename DoFAccessor<dim>::ExcInvalidObject());
   Assert (i<dof_handler->selected_fe->dofs_per_quad,
          ExcIndexRange (i, 0, dof_handler->selected_fe->dofs_per_quad));
 
@@ -208,8 +252,10 @@ DoFObjectAccessor<2, dim>::set_vertex_dof_index (const unsigned int vertex,
                                                 const unsigned int i,
                                                 const unsigned int index) const
 {
-  Assert (dof_handler != 0, ExcInvalidObject());
-  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+  Assert (dof_handler != 0,
+         typename DoFAccessor<dim>::ExcInvalidObject());
+  Assert (dof_handler->selected_fe != 0,
+         typename DoFAccessor<dim>::ExcInvalidObject());
   Assert (vertex<4, ExcIndexRange (i,0,4));
   Assert (i<dof_handler->selected_fe->dofs_per_vertex,
          ExcIndexRange (i, 0, dof_handler->selected_fe->dofs_per_vertex));
@@ -226,14 +272,16 @@ template <int dim>
 void DoFObjectAccessor<2, dim>::
 distribute_local_to_global (const Vector<double> &local_source,
                            Vector<double>       &global_destination) const {
-  Assert (dof_handler != 0, ExcInvalidObject());
-  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+  Assert (dof_handler != 0,
+         typename DoFAccessor<dim>::ExcInvalidObject());
+  Assert (dof_handler->selected_fe != 0,
+         typename DoFAccessor<dim>::ExcInvalidObject());
   Assert (local_source.size() == (4*dof_handler->get_fe().dofs_per_vertex +
                                  4*dof_handler->get_fe().dofs_per_line +
                                  dof_handler->get_fe().dofs_per_quad),
-         ExcVectorDoesNotMatch());
+         typename DoFAccessor<dim>::ExcVectorDoesNotMatch());
   Assert (dof_handler->n_dofs() == global_destination.size(),
-         ExcVectorDoesNotMatch());
+         typename DoFAccessor<dim>::ExcVectorDoesNotMatch());
 
   const unsigned int n_dofs = local_source.size();
 
@@ -252,18 +300,20 @@ template <int dim>
 void DoFObjectAccessor<2, dim>::
 distribute_local_to_global (const FullMatrix<double> &local_source,
                            SparseMatrix<double>     &global_destination) const {
-  Assert (dof_handler != 0, ExcInvalidObject());
-  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+  Assert (dof_handler != 0,
+         typename DoFAccessor<dim>::ExcInvalidObject());
+  Assert (dof_handler->selected_fe != 0,
+         typename DoFAccessor<dim>::ExcInvalidObject());
   Assert (local_source.m() == (4*dof_handler->get_fe().dofs_per_vertex +
                               4*dof_handler->get_fe().dofs_per_line +
                               dof_handler->get_fe().dofs_per_quad),
-         ExcMatrixDoesNotMatch());
+         typename DoFAccessor<dim>::ExcMatrixDoesNotMatch());
   Assert (local_source.m() == local_source.n(),
-         ExcMatrixDoesNotMatch());
+         typename DoFAccessor<dim>::ExcMatrixDoesNotMatch());
   Assert (dof_handler->n_dofs() == global_destination.m(),
-         ExcMatrixDoesNotMatch());
+         typename DoFAccessor<dim>::ExcMatrixDoesNotMatch());
   Assert (global_destination.m() == global_destination.n(),
-         ExcMatrixDoesNotMatch());
+         typename DoFAccessor<dim>::ExcMatrixDoesNotMatch());
   
   const unsigned int n_dofs = local_source.m();
 
@@ -287,13 +337,16 @@ DoFObjectAccessor<2,dim>::get_dof_values (const InputVector &values,
 {
   Assert (dim==2, ExcInternalError());
   
-  Assert (dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
-  Assert (&dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+  Assert (dof_handler != 0,
+         typename DoFAccessor<dim>::ExcInvalidObject());
+  Assert (&dof_handler->get_fe() != 0,
+         typename DoFAccessor<dim>::ExcInvalidObject());
   Assert (local_values.size() == dof_handler->get_fe().dofs_per_cell,
-         DoFAccessor<dim>::ExcVectorDoesNotMatch());
+         typename DoFAccessor<dim>::ExcVectorDoesNotMatch());
   Assert (values.size() == dof_handler->n_dofs(),
-         DoFAccessor<dim>::ExcVectorDoesNotMatch());
-  Assert (has_children() == false, ExcNotActive());
+         typename DoFAccessor<dim>::ExcVectorDoesNotMatch());
+  Assert (has_children() == false, typename DoFAccessor<dim>::
+         ExcNotActive());
   
   const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
                     dofs_per_line   = dof_handler->get_fe().dofs_per_line,
@@ -322,13 +375,16 @@ DoFObjectAccessor<2,dim>::set_dof_values (const Vector<number> &local_values,
 {
   Assert (dim==2, ExcInternalError());
   
-  Assert (dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
-  Assert (&dof_handler->get_fe() != 0, DoFAccessor<dim>::ExcInvalidObject());
+  Assert (dof_handler != 0,
+         typename DoFAccessor<dim>::ExcInvalidObject());
+  Assert (&dof_handler->get_fe() != 0,
+         typename DoFAccessor<dim>::ExcInvalidObject());
   Assert (local_values.size() == dof_handler->get_fe().dofs_per_cell,
-         DoFAccessor<dim>::ExcVectorDoesNotMatch());
+         typename DoFAccessor<dim>::ExcVectorDoesNotMatch());
   Assert (values.size() == dof_handler->n_dofs(),
-         DoFAccessor<dim>::ExcVectorDoesNotMatch());
-  Assert (has_children() == false, ExcNotActive());
+         typename DoFAccessor<dim>::ExcVectorDoesNotMatch());
+  Assert (has_children() == false,
+         typename DoFAccessor<dim>::ExcNotActive());
   
   const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
                     dofs_per_line   = dof_handler->get_fe().dofs_per_line,
@@ -355,10 +411,12 @@ template <int dim>
 void DoFObjectAccessor<3, dim>::set_dof_index (const unsigned int i,
                                               const unsigned int index) const
 {
-  Assert (dof_handler != 0, ExcInvalidObject());
+  Assert (dof_handler != 0,
+         typename DoFAccessor<dim>::ExcInvalidObject());
                                   // make sure a FE has been selected
                                   // and enough room was reserved
-  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+  Assert (dof_handler->selected_fe != 0,
+         typename DoFAccessor<dim>::ExcInvalidObject());
   Assert (i<dof_handler->selected_fe->dofs_per_hex,
          ExcIndexRange (i, 0, dof_handler->selected_fe->dofs_per_hex));
 
@@ -373,9 +431,12 @@ void DoFObjectAccessor<3, dim>::set_vertex_dof_index (const unsigned int vertex,
                                                      const unsigned int i,
                                                      const unsigned int index) const
 {
-  Assert (dof_handler != 0, ExcInvalidObject());
-  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
-  Assert (vertex<8, ExcIndexRange (i,0,8));
+  Assert (dof_handler != 0,
+         typename DoFAccessor<dim>::ExcInvalidObject());
+  Assert (dof_handler->selected_fe != 0,
+         typename DoFAccessor<dim>::ExcInvalidObject());
+  Assert (vertex<8,
+         ExcIndexRange (i,0,8));
   Assert (i<dof_handler->selected_fe->dofs_per_vertex,
          ExcIndexRange (i, 0, dof_handler->selected_fe->dofs_per_vertex));
 
@@ -391,15 +452,17 @@ template <int dim>
 void DoFObjectAccessor<3, dim>::
 distribute_local_to_global (const Vector<double> &local_source,
                            Vector<double>       &global_destination) const {
-  Assert (dof_handler != 0, ExcInvalidObject());
-  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+  Assert (dof_handler != 0,
+         typename DoFAccessor<dim>::ExcInvalidObject());
+  Assert (dof_handler->selected_fe != 0,
+         typename DoFAccessor<dim>::ExcInvalidObject());
   Assert (local_source.size() == (8*dof_handler->get_fe().dofs_per_vertex +
                                  12*dof_handler->get_fe().dofs_per_line +
                                  6*dof_handler->get_fe().dofs_per_quad +
                                  dof_handler->get_fe().dofs_per_hex),
-         ExcVectorDoesNotMatch());
+         typename DoFAccessor<dim>::ExcVectorDoesNotMatch());
   Assert (dof_handler->n_dofs() == global_destination.size(),
-         ExcVectorDoesNotMatch());
+         typename DoFAccessor<dim>::ExcVectorDoesNotMatch());
 
   const unsigned int n_dofs = local_source.size();
 
@@ -419,19 +482,21 @@ void DoFObjectAccessor<3, dim>::
 distribute_local_to_global (const FullMatrix<double> &local_source,
                            SparseMatrix<double>     &global_destination) const
 {
-  Assert (dof_handler != 0, ExcInvalidObject());
-  Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
+  Assert (dof_handler != 0,
+         typename DoFAccessor<dim>::ExcInvalidObject());
+  Assert (dof_handler->selected_fe != 0,
+         typename DoFAccessor<dim>::ExcInvalidObject());
   Assert (local_source.m() == (8*dof_handler->get_fe().dofs_per_vertex +
                               12*dof_handler->get_fe().dofs_per_line +
                               6*dof_handler->get_fe().dofs_per_quad +
                               dof_handler->get_fe().dofs_per_hex),
-         ExcMatrixDoesNotMatch());
+         typename DoFAccessor<dim>::ExcMatrixDoesNotMatch());
   Assert (local_source.m() == local_source.n(),
-         ExcMatrixDoesNotMatch());
+         typename DoFAccessor<dim>::ExcMatrixDoesNotMatch());
   Assert (dof_handler->n_dofs() == global_destination.m(),
-         ExcMatrixDoesNotMatch());
+         typename DoFAccessor<dim>::ExcMatrixDoesNotMatch());
   Assert (global_destination.m() == global_destination.n(),
-         ExcMatrixDoesNotMatch());
+         typename DoFAccessor<dim>::ExcMatrixDoesNotMatch());
   
   const unsigned int n_dofs = local_source.m();
 
@@ -461,7 +526,8 @@ DoFObjectAccessor<3,dim>::get_dof_values (const InputVector &values,
          DoFAccessor<3>::ExcVectorDoesNotMatch());
   Assert (values.size() == dof_handler->n_dofs(),
          DoFAccessor<3>::ExcVectorDoesNotMatch());
-  Assert (has_children() == false, ExcNotActive());
+  Assert (has_children() == false,
+         DoFAccessor<3>::ExcNotActive());
   
   const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
                     dofs_per_line   = dof_handler->get_fe().dofs_per_line,
@@ -494,13 +560,16 @@ DoFObjectAccessor<3,dim>::set_dof_values (const Vector<number> &local_values,
 {
   Assert (dim==3, ExcInternalError());
 
-  Assert (dof_handler != 0, DoFAccessor<3>::ExcInvalidObject());
-  Assert (&dof_handler->get_fe() != 0, DoFAccessor<3>::ExcInvalidObject());
+  Assert (dof_handler != 0,
+         DoFAccessor<3>::ExcInvalidObject());
+  Assert (&dof_handler->get_fe() != 0,
+         DoFAccessor<3>::ExcInvalidObject());
   Assert (local_values.size() == dof_handler->get_fe().dofs_per_cell,
          DoFAccessor<3>::ExcVectorDoesNotMatch());
   Assert (values.size() == dof_handler->n_dofs(),
          DoFAccessor<3>::ExcVectorDoesNotMatch());
-  Assert (has_children() == false, ExcNotActive());
+  Assert (has_children() == false,
+         DoFAccessor<3>::ExcNotActive());
   
   const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
                     dofs_per_line   = dof_handler->get_fe().dofs_per_line,
index bc0a1c0168a654b6a5d3826e8400835622cdbc61..d9234f41d7c6bbd90c6e2832e7c288edf7e8e47e 100644 (file)
@@ -441,15 +441,20 @@ void FiniteElement<dim>::fill_fe_face_values (const DoFHandler<dim>::cell_iterat
                                              vector<Point<dim> > &normal_vectors,
                                              const bool           compute_normal_vectors,
                                              const FullMatrix<double>      &shape_values_transform,
-                                             const vector<vector<Tensor<1,dim> > > &shape_gradients_transform) const {
+                                             const vector<vector<Tensor<1,dim> > > &shape_gradients_transform) const
+{
   Assert (jacobians.size() == unit_points.size(),
-         ExcWrongFieldDimension(jacobians.size(), unit_points.size()));
+         typename FiniteElementBase<dim>::ExcWrongFieldDimension(jacobians.size(),
+                                                                 unit_points.size()));
   Assert (q_points.size() == unit_points.size(),
-         ExcWrongFieldDimension(q_points.size(), unit_points.size()));
+         typename FiniteElementBase<dim>::ExcWrongFieldDimension(q_points.size(),
+                                                                 unit_points.size()));
   Assert (global_unit_points.size() == unit_points.size(),
-         ExcWrongFieldDimension(global_unit_points.size(), unit_points.size()));
+         typename FiniteElementBase<dim>::ExcWrongFieldDimension(global_unit_points.size(),
+                                                                 unit_points.size()));
   Assert (support_points.size() == dofs_per_face,
-         ExcWrongFieldDimension(support_points.size(), dofs_per_face));
+         typename FiniteElementBase<dim>::ExcWrongFieldDimension(support_points.size(),
+                                                                 dofs_per_face));
   
                                   // size not checked since not used
   static vector<Point<dim> > dummy(0);
@@ -490,13 +495,17 @@ void FiniteElement<dim>::fill_fe_subface_values (const DoFHandler<dim>::cell_ite
                                                 vector<Point<dim> > &normal_vectors,
                                                 const bool           compute_normal_vectors,
                                                 const FullMatrix<double>      &shape_values_transform,
-                                                const vector<vector<Tensor<1,dim> > > &shape_gradients_transform) const {
+                                                const vector<vector<Tensor<1,dim> > > &shape_gradients_transform) const
+{
   Assert (jacobians.size() == unit_points.size(),
-         ExcWrongFieldDimension(jacobians.size(), unit_points.size()));
+         typename FiniteElementBase<dim>::ExcWrongFieldDimension(jacobians.size(),
+                                                                 unit_points.size()));
   Assert (q_points.size() == unit_points.size(),
-         ExcWrongFieldDimension(q_points.size(), unit_points.size()));
+         typename FiniteElementBase<dim>::ExcWrongFieldDimension(q_points.size(),
+                                                                 unit_points.size()));
   Assert (global_unit_points.size() == unit_points.size(),
-         ExcWrongFieldDimension(global_unit_points.size(), unit_points.size()));
+         typename FiniteElementBase<dim>::ExcWrongFieldDimension(global_unit_points.size(),
+                                                                 unit_points.size()));
 
   static vector<Point<dim> > dummy(0); // size not checked since not used
   fill_fe_values (cell, global_unit_points,
index 2819712774610b6a632ecdc3e64b34556cf02242..a1a8cc5a634107cd2c7dd36f6f429e418c24cec5 100644 (file)
@@ -910,11 +910,14 @@ void FECrissCross<dim>::fill_fe_values (const DoFHandler<dim>::cell_iterator &ce
                                        const FullMatrix<double>         &shape_values_transform,
                                        const vector<vector<Tensor<1,dim> > > &/*shape_grad_transform*/) const {
   Assert (jacobians.size() == unit_points.size(),
-         ExcWrongFieldDimension(jacobians.size(), unit_points.size()));
+         typename FiniteElementBase<dim>::ExcWrongFieldDimension(jacobians.size(),
+                                                                 unit_points.size()));
   Assert (q_points.size() == unit_points.size(),
-         ExcWrongFieldDimension(q_points.size(), unit_points.size()));
+         typename FiniteElementBase<dim>::ExcWrongFieldDimension(q_points.size(),
+                                                                 unit_points.size()));
   Assert (support_points.size() == dofs_per_cell,
-         ExcWrongFieldDimension(support_points.size(), dofs_per_cell));
+         typename FiniteElementBase<dim>::ExcWrongFieldDimension(support_points.size(),
+                                                                 dofs_per_cell));
 
 
   unsigned int n_points=unit_points.size();
index 0a3386f340475d8dde26f5e27b474b1c1a322bdc..1b23d5c99ccde5d2da3ace038b7209235865d244 100644 (file)
@@ -4412,6 +4412,7 @@ FEDG_Q3<3>::FEDG_Q3():
 };
 
 
+
 template<>
 FEDG_Q4<3>::FEDG_Q4():
                FEQ4<3>(1)
@@ -4427,36 +4428,43 @@ FEDG_Q4<3>::FEDG_Q4():
 template <int dim>
 void
 FEDG_Q1<dim>::get_face_support_points (const typename DoFHandler<dim>::face_iterator &,
-                                         vector<Point<dim> >  &support_points) const {
+                                      vector<Point<dim> >  &support_points) const
+{
   Assert ((support_points.size() == 0),
-         ExcWrongFieldDimension (support_points.size(),0));
+         FiniteElementBase<dim>::ExcWrongFieldDimension (support_points.size(),0));
 };
 
 
+
 template <int dim>
 void
 FEDG_Q2<dim>::get_face_support_points (const typename DoFHandler<dim>::face_iterator &,
-                                               vector<Point<dim> >  &support_points) const {
+                                               vector<Point<dim> >  &support_points) const
+{
   Assert ((support_points.size() == 0),
-         ExcWrongFieldDimension (support_points.size(),0));
+         FiniteElementBase<dim>::ExcWrongFieldDimension (support_points.size(),0));
 };
 
 
+
 template <int dim>
 void
 FEDG_Q3<dim>::get_face_support_points (const typename DoFHandler<dim>::face_iterator &,
-                                           vector<Point<dim> >  &support_points) const {
+                                      vector<Point<dim> >  &support_points) const
+{
   Assert ((support_points.size() == 0),
-         ExcWrongFieldDimension (support_points.size(),0));
+         FiniteElementBase<dim>::ExcWrongFieldDimension (support_points.size(),0));
 };
 
 
+
 template <int dim>
 void
 FEDG_Q4<dim>::get_face_support_points (const typename DoFHandler<dim>::face_iterator &,
-                                             vector<Point<dim> >  &support_points) const {
+                                      vector<Point<dim> >  &support_points) const
+{
   Assert ((support_points.size() == 0),
-         ExcWrongFieldDimension (support_points.size(),0));
+         FiniteElementBase<dim>::ExcWrongFieldDimension (support_points.size(),0));
 };
 
 
index 75ae78833625b8ad989be47901da1caf22c878d1..a6d457bc5cba6276b67762ee73bde8614f6d7c10 100644 (file)
@@ -42,13 +42,15 @@ FEDG_Q0<dim>::FEDG_Q0 () :
 template <>
 void
 FEDG_Q0<1>::get_face_support_points (const DoFHandler<1>::face_iterator &,
-                                    vector<Point<1> >  &) const {
+                                    vector<Point<1> >  &) const
+{
   Assert (false, ExcInternalError());
 };
 
 #endif
 
 
+
 template <int dim>
 inline
 double
@@ -60,22 +62,24 @@ FEDG_Q0<dim>::shape_value (const unsigned int i,
 };
 
 
+
 template <int dim>
 inline
 Tensor<1,dim>
 FEDG_Q0<dim>::shape_grad (const unsigned int i,
-                              const Point<dim>&) const
+                         const Point<dim>&) const
 {
   Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
   return Tensor<1,dim> ();
 };
 
 
+
 template <int dim>
 inline
 Tensor<2,dim>
 FEDG_Q0<dim>::shape_grad_grad (const unsigned int i,
-                                 const Point<dim> &) const
+                              const Point<dim> &) const
 {
   Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
 
@@ -83,45 +87,55 @@ FEDG_Q0<dim>::shape_grad_grad (const unsigned int i,
 };
 
 
+
 template <int dim>
 void FEDG_Q0<dim>::get_local_mass_matrix (const DoFHandler<dim>::cell_iterator &cell,
-                                              FullMatrix<double> &local_mass_matrix) const {
+                                         FullMatrix<double> &local_mass_matrix) const
+{
   Assert (local_mass_matrix.n() == dofs_per_cell,
-         ExcWrongFieldDimension(local_mass_matrix.n(),dofs_per_cell));
+         FiniteElementBase<dim>::ExcWrongFieldDimension(local_mass_matrix.n(),
+                                                        dofs_per_cell));
   Assert (local_mass_matrix.m() == dofs_per_cell,
-         ExcWrongFieldDimension(local_mass_matrix.m(),dofs_per_cell));
+         FiniteElementBase<dim>::ExcWrongFieldDimension(local_mass_matrix.m(),
+                                                        dofs_per_cell));
 
   local_mass_matrix(0,0) = cell->measure();
 };
 
 
+
 template <int dim>
 void
-FEDG_Q0<dim>::get_unit_support_points (vector<Point<dim> > &unit_points) const {
+FEDG_Q0<dim>::get_unit_support_points (vector<Point<dim> > &unit_points) const
+{
   Assert (unit_points.size() == dofs_per_cell,
-         ExcWrongFieldDimension (unit_points.size(), dofs_per_cell));
+         FiniteElementBase<dim>::ExcWrongFieldDimension (unit_points.size(), dofs_per_cell));
   for (unsigned int d=0; d<dim; ++d)
     unit_points[0](d) = 0.5;
 };
 
 
+
 template <int dim>
 void
 FEDG_Q0<dim>::get_support_points (const typename DoFHandler<dim>::cell_iterator &cell,
-                                      vector<Point<dim> >  &support_points) const {
+                                 vector<Point<dim> >  &support_points) const
+{
   Assert (support_points.size() == dofs_per_cell,
-         ExcWrongFieldDimension (support_points.size(), dofs_per_cell));
+         FiniteElementBase<dim>::ExcWrongFieldDimension (support_points.size(), dofs_per_cell));
   
   support_points[0] = cell->center();
 };
 
 
+
 template <int dim>
 void
 FEDG_Q0<dim>::get_face_support_points (const typename DoFHandler<dim>::face_iterator &,
-                                           vector<Point<dim> >  &support_points) const {
+                                      vector<Point<dim> >  &support_points) const
+{
   Assert ((support_points.size() == 0),
-         ExcWrongFieldDimension (support_points.size(),0));
+         FiniteElementBase<dim>::ExcWrongFieldDimension (support_points.size(),0));
 };
 
 
index a5b45f21872b7eca3ba21ff25b0666936765d913..fb40f756fa183632bc641a0d3c766b81da48a71b 100644 (file)
@@ -355,7 +355,8 @@ FEDG_P1<dim>::get_support_points (const typename DoFHandler<dim>::cell_iterator
                                   vector<Point<dim> >  &support_points) const
 {
   Assert (support_points.size() == dofs_per_cell,
-         ExcWrongFieldDimension (support_points.size(), dofs_per_cell));
+         typename FiniteElementBase<dim>::ExcWrongFieldDimension (support_points.size(),
+                                                                  dofs_per_cell));
   
   for (unsigned int vertex=0; vertex<GeometryInfo<dim>::vertices_per_cell; ++vertex)
     support_points[vertex] = cell->vertex(vertex);
@@ -369,8 +370,8 @@ FEDG_P1<dim>::get_face_support_points (const typename DoFHandler<dim>::face_iter
 {
   Assert ((support_points.size() == dofs_per_face) &&
          (support_points.size() == GeometryInfo<dim>::vertices_per_face),
-         ExcWrongFieldDimension (support_points.size(),
-                                 GeometryInfo<dim>::vertices_per_face));
+         typename FiniteElementBase<dim>::ExcWrongFieldDimension (support_points.size(),
+                                                                  GeometryInfo<dim>::vertices_per_face));
 
   for (unsigned int vertex=0; vertex<dofs_per_face; ++vertex)
     support_points[vertex] = face->vertex(vertex);
index 4c148ed2236e0192075fa7e0e40087082f6e1271..223ddaa531d5b06fa89dd18b0df0f876ed08cc78 100644 (file)
@@ -337,7 +337,8 @@ FEDG_P2<dim>::get_support_points (const typename DoFHandler<dim>::cell_iterator
                                   vector<Point<dim> >  &support_points) const
 {
   Assert (support_points.size() == dofs_per_cell,
-         ExcWrongFieldDimension (support_points.size(), dofs_per_cell));
+         typename FiniteElementBase<dim>::ExcWrongFieldDimension (support_points.size(),
+                                                                  dofs_per_cell));
   
   for (unsigned int vertex=0; vertex<GeometryInfo<dim>::vertices_per_cell; ++vertex)
     support_points[vertex] = cell->vertex(vertex);
@@ -351,8 +352,8 @@ FEDG_P2<dim>::get_face_support_points (const typename DoFHandler<dim>::face_iter
 {
   Assert ((support_points.size() == dofs_per_face) &&
          (support_points.size() == GeometryInfo<dim>::vertices_per_face),
-         ExcWrongFieldDimension (support_points.size(),
-                                 GeometryInfo<dim>::vertices_per_face));
+         typename FiniteElementBase<dim>::ExcWrongFieldDimension (support_points.size(),
+                                                                  GeometryInfo<dim>::vertices_per_face));
 
   for (unsigned int vertex=0; vertex<dofs_per_face; ++vertex)
     support_points[vertex] = face->vertex(vertex);
index 0dc598fdde1a533bec11aa9fe041083d4e29d99a..807855abfb93f54ca1c1c92b4ba67321bfd8bbdb 100644 (file)
@@ -348,7 +348,8 @@ FEDG_P3<dim>::get_support_points (const typename DoFHandler<dim>::cell_iterator
                                   vector<Point<dim> >  &support_points) const
 {
   Assert (support_points.size() == dofs_per_cell,
-         ExcWrongFieldDimension (support_points.size(), dofs_per_cell));
+         typename FiniteElementBase<dim>::ExcWrongFieldDimension (support_points.size(),
+                                                                  dofs_per_cell));
   
   for (unsigned int vertex=0; vertex<GeometryInfo<dim>::vertices_per_cell; ++vertex)
     support_points[vertex] = cell->vertex(vertex);
@@ -362,8 +363,8 @@ FEDG_P3<dim>::get_face_support_points (const typename DoFHandler<dim>::face_iter
 {
   Assert ((support_points.size() == dofs_per_face) &&
          (support_points.size() == GeometryInfo<dim>::vertices_per_face),
-         ExcWrongFieldDimension (support_points.size(),
-                                 GeometryInfo<dim>::vertices_per_face));
+         typename FiniteElementBase<dim>::ExcWrongFieldDimension (support_points.size(),
+                                                                  GeometryInfo<dim>::vertices_per_face));
 
   for (unsigned int vertex=0; vertex<dofs_per_face; ++vertex)
     support_points[vertex] = face->vertex(vertex);
index 913bf63499f146883d1a4628488feecd2c96588a..37906ffe413e0350fc14cf9c93d79f65c99c5ada 100644 (file)
@@ -867,7 +867,8 @@ void
 FEQ1<dim>::get_support_points (const typename DoFHandler<dim>::cell_iterator &cell,
                                   vector<Point<dim> >  &support_points) const {
   Assert (support_points.size() == dofs_per_cell,
-         ExcWrongFieldDimension (support_points.size(), dofs_per_cell));
+         typename FiniteElementBase<dim>::ExcWrongFieldDimension (support_points.size(),
+                                                                  dofs_per_cell));
   
   for (unsigned int vertex=0; vertex<GeometryInfo<dim>::vertices_per_cell; ++vertex)
     support_points[vertex] = cell->vertex(vertex);
@@ -880,6 +881,7 @@ FEQ1<dim>::get_face_support_points (const typename DoFHandler<dim>::face_iterato
                                        vector<Point<dim> >  &support_points) const {
   Assert ((support_points.size() == dofs_per_face) &&
          (support_points.size() == GeometryInfo<dim>::vertices_per_face),
+         typename FiniteElementBase<dim>::
          ExcWrongFieldDimension (support_points.size(),
                                  GeometryInfo<dim>::vertices_per_face));
 
index e20955631c8eccb7570834b4d6aa9da4d487fbf1..3a58b3a0b23ead8ec038e85282ee185d955b0c0a 100644 (file)
@@ -767,7 +767,9 @@ void FESystem<dim>::get_unit_support_points (
   vector<Point<dim> > &unit_support_points) const
 {
   Assert(unit_support_points.size() == dofs_per_cell,
-        ExcWrongFieldDimension (unit_support_points.size(), dofs_per_cell));
+        typename FiniteElementBase<dim>::
+        ExcWrongFieldDimension (unit_support_points.size(),
+                                dofs_per_cell));
 
   vector<Point<dim> > base_unit_support_points (base_element(0).dofs_per_cell);
   unsigned int component = 0;
@@ -818,7 +820,9 @@ void FESystem<dim>::get_support_points (const DoFHandler<dim>::cell_iterator &ce
                                        vector<Point<dim> > &support_points) const
 {
   Assert(support_points.size() == dofs_per_cell,
-        ExcWrongFieldDimension (support_points.size(), dofs_per_cell));
+        typename FiniteElementBase<dim>::
+        ExcWrongFieldDimension (support_points.size(),
+                                dofs_per_cell));
 
   vector<Point<dim> > base_support_points (base_element(0).dofs_per_cell);
   unsigned int component = 0;
@@ -847,7 +851,9 @@ void FESystem<dim>::get_face_support_points (const DoFHandler<dim>::face_iterato
                                             vector<Point<dim> > & support_points) const
 {
   Assert (support_points.size() == dofs_per_face,
-         ExcWrongFieldDimension (support_points.size(), dofs_per_face));
+         typename FiniteElementBase<dim>::
+         ExcWrongFieldDimension (support_points.size(),
+                                 dofs_per_face));
 
   vector<Point<dim> > base_support_points (base_element(0).dofs_per_face);
   unsigned int comp = 0;
@@ -874,9 +880,13 @@ void FESystem<dim>::get_local_mass_matrix (const DoFHandler<dim>::cell_iterator
                                           FullMatrix<double>  &local_mass_matrix) const
 {
   Assert (local_mass_matrix.n() == dofs_per_cell,
-         ExcWrongFieldDimension(local_mass_matrix.n(),dofs_per_cell));
+         typename FiniteElementBase<dim>::
+         ExcWrongFieldDimension(local_mass_matrix.n(),
+                                dofs_per_cell));
   Assert (local_mass_matrix.m() == dofs_per_cell,
-         ExcWrongFieldDimension(local_mass_matrix.m(),dofs_per_cell));
+         typename FiniteElementBase<dim>::
+         ExcWrongFieldDimension(local_mass_matrix.m(),
+                                dofs_per_cell));
 
                                   // track which component we are
                                   // presently working with, since we
index d1cf51ff7c65e2a2d82eece9e1f13f221e54dd72..0aef5bdfbee72e669d3401183b53bf1fc60f1e0d 100644 (file)
@@ -338,7 +338,7 @@ FEValues<dim>::FEValues (const FiniteElement<dim> &fe,
                unit_quadrature_points(quadrature.get_points())
 {
   Assert ((update_flags & update_normal_vectors) == false,
-         ExcInvalidUpdateFlag());
+         typename FEValuesBase<dim>::ExcInvalidUpdateFlag());
 
   for (unsigned int i=0; i<fe.dofs_per_cell; ++i)
     for (unsigned int j=0; j<n_quadrature_points; ++j) 
@@ -376,7 +376,7 @@ void FEValues<dim>::reinit (const typename DoFHandler<dim>::cell_iterator &cell)
   Assert (static_cast<const FiniteElementData<dim>&>(*fe)
          ==
          static_cast<const FiniteElementData<dim>&>(cell->get_dof_handler().get_fe()),
-         ExcFEDontMatch());
+         typename FEValuesBase<dim>::ExcFEDontMatch());
   
                                   // fill jacobi matrices and real
                                   // quadrature points
@@ -497,7 +497,7 @@ FEFaceValuesBase<dim>::normal_vector (const unsigned int i) const
 {
   Assert (i<normal_vectors.size(), ExcIndexRange(i, 0, normal_vectors.size()));
   Assert (update_flags & update_normal_vectors,
-         ExcAccessToUninitializedField());
+         typename FEValuesBase<dim>::ExcAccessToUninitializedField());
   
   return normal_vectors[i];
 };
@@ -568,7 +568,7 @@ void FEFaceValues<dim>::reinit (const typename DoFHandler<dim>::cell_iterator &c
   Assert (static_cast<const FiniteElementData<dim>&>(*fe)
          ==
          static_cast<const FiniteElementData<dim>&>(cell->get_dof_handler().get_fe()),
-         ExcFEDontMatch());
+         typename FEValuesBase<dim>::ExcFEDontMatch());
   Assert (face_no < GeometryInfo<dim>::faces_per_cell,
          ExcIndexRange (face_no, 0, GeometryInfo<dim>::faces_per_cell));
   
@@ -678,7 +678,7 @@ FESubfaceValues<dim>::FESubfaceValues (const FiniteElement<dim> &fe,
                                       fe)
 {
   Assert ((update_flags & update_support_points) == false,
-         ExcInvalidUpdateFlag());
+         typename FEValuesBase<dim>::ExcInvalidUpdateFlag());
   
   unit_face_quadrature_points = quadrature.get_points();
   weights = quadrature.get_weights ();  
@@ -752,7 +752,7 @@ void FESubfaceValues<dim>::reinit (const typename DoFHandler<dim>::cell_iterator
   Assert (static_cast<const FiniteElementData<dim>&>(*fe)
          ==
          static_cast<const FiniteElementData<dim>&>(cell->get_dof_handler().get_fe()),
-         ExcFEDontMatch());
+         typename FEValuesBase<dim>::ExcFEDontMatch());
   Assert (face_no < GeometryInfo<dim>::faces_per_cell,
          ExcIndexRange (face_no, 0, GeometryInfo<dim>::faces_per_cell));
   Assert (subface_no < GeometryInfo<dim>::subfaces_per_face,
index 4545fbf7fc5d565b3d8d5e794ad8a99dbea58e94..7ce933a7a9d97948606b3e1898193a886687e84f 100644 (file)
@@ -546,13 +546,17 @@ void FEQ1Mapping<dim>::fill_fe_values (const DoFHandler<dim>::cell_iterator &cel
                                       const vector<vector<Tensor<1,dim> > > &shape_grad_transform) const
 {
   Assert ((!compute_jacobians) || (jacobians.size() == unit_points.size()),
-         ExcWrongFieldDimension(jacobians.size(), unit_points.size()));
+         typename FiniteElementBase<dim>::ExcWrongFieldDimension(jacobians.size(),
+                                                                 unit_points.size()));
   Assert ((!compute_jacobians_grad) || (jacobians_grad.size() == unit_points.size()),
-         ExcWrongFieldDimension(jacobians_grad.size(), unit_points.size()));
+         typename FiniteElementBase<dim>::ExcWrongFieldDimension(jacobians_grad.size(),
+                                                                 unit_points.size()));
   Assert ((!compute_q_points) || (q_points.size() == unit_points.size()),
-         ExcWrongFieldDimension(q_points.size(), unit_points.size()));
+         typename FiniteElementBase<dim>::ExcWrongFieldDimension(q_points.size(),
+                                                                 unit_points.size()));
   Assert ((!compute_support_points) || (support_points.size() == dofs_per_cell),
-         ExcWrongFieldDimension(support_points.size(), dofs_per_cell));
+         typename FiniteElementBase<dim>::ExcWrongFieldDimension(support_points.size(),
+                                                                 dofs_per_cell));
 
 
   unsigned int n_points=unit_points.size();
index c13536a0b3df8f478607e983971ba20165c54040..0b16f09e73b820118689de95e426980a20b58dcb 100644 (file)
@@ -108,7 +108,7 @@ PersistentTriangulation<dim>::write_flags(ostream &out) const
 {
   const unsigned int n_flag_levels=refine_flags.size();
   
-  AssertThrow (out, ExcIO());
+  AssertThrow (out, typename Triangulation<dim>::ExcIO());
 
   out << mn_persistent_tria_flags_begin << ' ' << n_flag_levels << endl;
 
@@ -122,7 +122,7 @@ PersistentTriangulation<dim>::write_flags(ostream &out) const
   
   out << mn_persistent_tria_flags_end << endl;
 
-  AssertThrow (out, ExcIO());
+  AssertThrow (out, typename Triangulation<dim>::ExcIO());
 }
 
 
@@ -130,13 +130,15 @@ template <int dim>
 void
 PersistentTriangulation<dim>::read_flags(istream &in)
 {
-  Assert(refine_flags.size()==0 && coarsen_flags.size()==0, ExcTriaNotEmpty());
+  Assert(refine_flags.size()==0 && coarsen_flags.size()==0,
+        ExcTriaNotEmpty());
 
-  AssertThrow (in, ExcIO());
+  AssertThrow (in, typename Triangulation<dim>::ExcIO());
 
   unsigned int magic_number;
   in >> magic_number;
-  AssertThrow(magic_number==mn_persistent_tria_flags_begin, ExcGridReadError());
+  AssertThrow(magic_number==mn_persistent_tria_flags_begin,
+             typename Triangulation<dim>::ExcGridReadError());
 
   unsigned int n_flag_levels;
   in >> n_flag_levels;
@@ -151,9 +153,10 @@ PersistentTriangulation<dim>::read_flags(istream &in)
     }
   
   in >> magic_number;
-  AssertThrow(magic_number==mn_persistent_tria_flags_end, ExcGridReadError());
+  AssertThrow(magic_number==mn_persistent_tria_flags_end,
+             typename Triangulation<dim>::ExcGridReadError());
 
-  AssertThrow (in, ExcIO());
+  AssertThrow (in, typename Triangulation<dim>::ExcIO());
 }
 
 
index 5e013d01134c8b6e990b893eeeccc0cb48439c87..a6f9354fc3a97d11cc64e2ff1986e0922cf6c900 100644 (file)
 /*------------------------ Functions: LineAccessor ---------------------------*/
 
 template <int dim>
-void TriaObjectAccessor<1, dim>::set (const Line &line) const {
+void TriaObjectAccessor<1, dim>::set (const Line &line) const
+{
   tria->levels[present_level]->lines.lines[present_index] = line;
 };
 
 
+
 template <int dim>
-int TriaObjectAccessor<1, dim>::vertex_index (const unsigned int i) const {
+int TriaObjectAccessor<1, dim>::vertex_index (const unsigned int i) const
+{
   Assert (i<2, ExcIndexRange(i,0,2));
   return tria->levels[present_level]->lines.lines[present_index].vertex (i);
 };
 
 
+
 template <int dim>
 Point<dim> &
-TriaObjectAccessor<1, dim>::vertex (const unsigned int i) const {
+TriaObjectAccessor<1, dim>::vertex (const unsigned int i) const
+{
   return tria->vertices[vertex_index(i)];
 };
 
 
+
 template <int dim>
-void TriaObjectAccessor<1, dim>::set_used_flag () const {
-  Assert (state() == valid, ExcDereferenceInvalidObject());
+void TriaObjectAccessor<1, dim>::set_used_flag () const
+{
+  Assert (state() == valid,
+         typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
   tria->levels[present_level]->lines.used[present_index] = true;
 };
 
 
+
 template <int dim>
-void TriaObjectAccessor<1, dim>::clear_used_flag () const {
-  Assert (state() == valid, ExcDereferenceInvalidObject());
+void TriaObjectAccessor<1, dim>::clear_used_flag () const
+{
+  Assert (state() == valid,
+         typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
   tria->levels[present_level]->lines.used[present_index] = false;
 };
 
 
+
 template <int dim>
-void TriaObjectAccessor<1, dim>::recursively_set_user_flag () const {
+void TriaObjectAccessor<1, dim>::recursively_set_user_flag () const
+{
   set_user_flag ();
 
   if (has_children())
@@ -69,8 +82,10 @@ void TriaObjectAccessor<1, dim>::recursively_set_user_flag () const {
 };
 
 
+
 template <int dim>
-void TriaObjectAccessor<1, dim>::recursively_clear_user_flag () const {
+void TriaObjectAccessor<1, dim>::recursively_clear_user_flag () const
+{
   clear_user_flag ();
 
   if (has_children())
@@ -79,95 +94,122 @@ void TriaObjectAccessor<1, dim>::recursively_clear_user_flag () const {
 };
 
 
+
 template <int dim>
-void TriaObjectAccessor<1, dim>::set_user_pointer (void *p) const {
-  Assert (used(), ExcCellNotUsed());
+void TriaObjectAccessor<1, dim>::set_user_pointer (void *p) const
+{
+  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
   tria->levels[present_level]->lines.user_pointers[present_index] = p;
 };
 
 
+
 template <int dim>
-void TriaObjectAccessor<1, dim>::clear_user_pointer () const {
-  Assert (used(), ExcCellNotUsed());
+void TriaObjectAccessor<1, dim>::clear_user_pointer () const
+{
+  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
   tria->levels[present_level]->lines.user_pointers[present_index] = 0;
 };
 
 
+
 template <int dim>
-void * TriaObjectAccessor<1, dim>::user_pointer () const {
-  Assert (used(), ExcCellNotUsed());
+void * TriaObjectAccessor<1, dim>::user_pointer () const
+{
+  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
   return tria->levels[present_level]->lines.user_pointers[present_index];
 };
 
 
+
 template <int dim>
-void TriaObjectAccessor<1, dim>::set_children (const int index) const {
-  Assert (used(), ExcCellNotUsed());
+void TriaObjectAccessor<1, dim>::set_children (const int index) const
+{
+  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
   Assert ((index==-1) ||
-         (!has_children() && (index>=0)), ExcCantSetChildren(index));
+         (!has_children() && (index>=0)),
+         typename TriaAccessor<dim>::ExcCantSetChildren(index));
   
   tria->levels[present_level]->lines.children[present_index] = index;
 };
 
 
+
 template <int dim>
-void TriaObjectAccessor<1, dim>::clear_children () const {
+void TriaObjectAccessor<1, dim>::clear_children () const
+{
   set_children (-1);
 };
 
 
+
 template <int dim>
-unsigned char TriaObjectAccessor<1, dim>::boundary_indicator () const {
-  Assert (dim>=2, ExcNotUsefulForThisDimension());
-  Assert (used(), ExcCellNotUsed());
+unsigned char TriaObjectAccessor<1, dim>::boundary_indicator () const
+{
+  Assert (dim>=2, typename TriaAccessor<dim>::ExcNotUsefulForThisDimension());
+  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
 
   return tria->levels[present_level]->lines.material_id[present_index];
 };
 
 
+
 template <int dim>
-void TriaObjectAccessor<1, dim>::set_boundary_indicator (unsigned char boundary_ind) const {
-  Assert (dim>=2, ExcNotUsefulForThisDimension());
-  Assert (used(), ExcCellNotUsed());
+void TriaObjectAccessor<1, dim>::set_boundary_indicator (unsigned char boundary_ind) const
+{
+  Assert (dim>=2, typename TriaAccessor<dim>::ExcNotUsefulForThisDimension());
+  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
 
   tria->levels[present_level]->lines.material_id[present_index] = boundary_ind;
 };
 
 
+
 template <int dim>
-bool TriaObjectAccessor<1, dim>::at_boundary () const {
+bool TriaObjectAccessor<1, dim>::at_boundary () const
+{
                                   // error checking is done
                                   // in boundary_indicator()
   return (boundary_indicator() != 255);
 };
 
 
+
 template <int dim>
-double TriaObjectAccessor<1, dim>::diameter () const {
+double TriaObjectAccessor<1, dim>::diameter () const
+{
   return sqrt((vertex(1)-vertex(0)).square());
 };
 
 
+
 template <int dim>
-Point<dim> TriaObjectAccessor<1, dim>::center () const {
+Point<dim> TriaObjectAccessor<1, dim>::center () const
+{
   return (vertex(1)+vertex(0))/2.;
 };
 
 
+
 template <int dim>
-Point<dim> TriaObjectAccessor<1, dim>::barycenter () const {
+Point<dim> TriaObjectAccessor<1, dim>::barycenter () const
+{
   return (vertex(1)+vertex(0))/2.;
 };
 
 
+
 template <int dim>
-double TriaObjectAccessor<1, dim>::measure () const {
+double TriaObjectAccessor<1, dim>::measure () const
+{
   return sqrt((vertex(1)-vertex(0)).square());
 };
 
 
+
 template <int dim>
-unsigned int TriaObjectAccessor<1, dim>::number_of_children () const {
+unsigned int TriaObjectAccessor<1, dim>::number_of_children () const
+{
   if (!has_children())
     return 1;
   else
@@ -183,13 +225,16 @@ unsigned int TriaObjectAccessor<1, dim>::number_of_children () const {
 /*------------------------ Functions: QuadAccessor ---------------------------*/
 
 template <int dim>
-void TriaObjectAccessor<2, dim>::set (const Quad &quad) const {
+void TriaObjectAccessor<2, dim>::set (const Quad &quad) const
+{
   tria->levels[present_level]->quads.quads[present_index] = quad;
 };
 
 
+
 template <int dim>
-int TriaObjectAccessor<2, dim>::vertex_index (const unsigned int corner) const {
+int TriaObjectAccessor<2, dim>::vertex_index (const unsigned int corner) const
+{
   Assert (corner<4, ExcIndexRange(corner,0,4));
 
   const int corner_convention[4] = { 0,0,1,1 };
@@ -197,30 +242,38 @@ int TriaObjectAccessor<2, dim>::vertex_index (const unsigned int corner) const {
 };
 
 
+
 template <int dim>
 Point<dim> &
-TriaObjectAccessor<2, dim>::vertex (const unsigned int i) const {
+TriaObjectAccessor<2, dim>::vertex (const unsigned int i) const
+{
   return tria->vertices[vertex_index(i)];
 };
 
 
+
 template <int dim>
 void
-TriaObjectAccessor<2, dim>::set_used_flag () const {
-  Assert (state() == valid, ExcDereferenceInvalidObject());
+TriaObjectAccessor<2, dim>::set_used_flag () const
+{
+  Assert (state() == valid, typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
   tria->levels[present_level]->quads.used[present_index] = true;
 };
 
 
+
 template <int dim>
-void TriaObjectAccessor<2, dim>::clear_used_flag () const {
-  Assert (state() == valid, ExcDereferenceInvalidObject());
+void TriaObjectAccessor<2, dim>::clear_used_flag () const
+{
+  Assert (state() == valid, typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
   tria->levels[present_level]->quads.used[present_index] = false;
 };
 
 
+
 template <int dim>
-void TriaObjectAccessor<2, dim>::recursively_set_user_flag () const {
+void TriaObjectAccessor<2, dim>::recursively_set_user_flag () const
+{
   set_user_flag ();
 
   if (has_children())
@@ -229,8 +282,10 @@ void TriaObjectAccessor<2, dim>::recursively_set_user_flag () const {
 };
 
 
+
 template <int dim>
-void TriaObjectAccessor<2, dim>::recursively_clear_user_flag () const {
+void TriaObjectAccessor<2, dim>::recursively_clear_user_flag () const
+{
   clear_user_flag ();
 
   if (has_children())
@@ -239,78 +294,100 @@ void TriaObjectAccessor<2, dim>::recursively_clear_user_flag () const {
 };
 
 
+
 template <int dim>
-void TriaObjectAccessor<2, dim>::set_user_pointer (void *p) const {
-  Assert (used(), ExcCellNotUsed());
+void TriaObjectAccessor<2, dim>::set_user_pointer (void *p) const
+{
+  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
   tria->levels[present_level]->quads.user_pointers[present_index] = p;
 };
 
 
+
 template <int dim>
-void TriaObjectAccessor<2, dim>::clear_user_pointer () const {
-  Assert (used(), ExcCellNotUsed());
+void TriaObjectAccessor<2, dim>::clear_user_pointer () const
+{
+  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
   tria->levels[present_level]->quads.user_pointers[present_index] = 0;
 };
 
 
+
 template <int dim>
-void * TriaObjectAccessor<2, dim>::user_pointer () const {
-  Assert (used(), ExcCellNotUsed());
+void * TriaObjectAccessor<2, dim>::user_pointer () const
+{
+  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
   return tria->levels[present_level]->quads.user_pointers[present_index];
 };
 
 
+
 template <int dim>
-void TriaObjectAccessor<2, dim>::set_children (const int index) const {
-  Assert (used(), ExcCellNotUsed());
+void TriaObjectAccessor<2, dim>::set_children (const int index) const
+{
+  Assert (used(),
+         typename TriaAccessor<dim>::ExcCellNotUsed());
   Assert ((index==-1) ||
-         (!has_children() && (index>=0)), ExcCantSetChildren(index));
+         (!has_children() && (index>=0)),
+         typename TriaAccessor<dim>::ExcCantSetChildren(index));
 
   tria->levels[present_level]->quads.children[present_index] = index;
 };
 
 
+
 template <int dim>
-void TriaObjectAccessor<2, dim>::clear_children () const {
+void TriaObjectAccessor<2, dim>::clear_children () const
+{
   set_children (-1);
 };
 
 
+
 template <int dim>
-unsigned char TriaObjectAccessor<2, dim>::boundary_indicator () const {
-  Assert (dim>=3, ExcNotUsefulForThisDimension());
-  Assert (used(), ExcCellNotUsed());
+unsigned char TriaObjectAccessor<2, dim>::boundary_indicator () const
+{
+  Assert (dim>=3, typename TriaAccessor<dim>::ExcNotUsefulForThisDimension());
+  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
 
   return tria->levels[present_level]->quads.material_id[present_index];
 };
 
 
+
 template <int dim>
-void TriaObjectAccessor<2, dim>::set_boundary_indicator (unsigned char boundary_ind) const {
-  Assert (dim>=3, ExcNotUsefulForThisDimension());
-  Assert (used(), ExcCellNotUsed());
+void TriaObjectAccessor<2, dim>::set_boundary_indicator (unsigned char boundary_ind) const
+{
+  Assert (dim>=3, typename TriaAccessor<dim>::ExcNotUsefulForThisDimension());
+  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
 
   tria->levels[present_level]->quads.material_id[present_index] = boundary_ind;
 };
 
 
+
 template <int dim>
-bool TriaObjectAccessor<2, dim>::at_boundary () const {
+bool TriaObjectAccessor<2, dim>::at_boundary () const
+{
                                   // error checking is done
                                   // in boundary_indicator()
   return (boundary_indicator() != 255);
 };
 
 
+
 template <int dim>
-double TriaObjectAccessor<2, dim>::diameter () const {
+double TriaObjectAccessor<2, dim>::diameter () const
+{
   return sqrt(max((vertex(2)-vertex(0)).square(),
                  (vertex(3)-vertex(1)).square()));
 };
 
 
+
 template <int dim>
-Point<dim> TriaObjectAccessor<2, dim>::center () const {
+Point<dim> TriaObjectAccessor<2, dim>::center () const
+{
   return (vertex(0)+vertex(1)+vertex(2)+vertex(3))/4.;
 };
 
@@ -318,7 +395,8 @@ Point<dim> TriaObjectAccessor<2, dim>::center () const {
 #if deal_II_dimension == 2
 
 template <>
-Point<2> TriaObjectAccessor<2, 2>::barycenter () const {
+Point<2> TriaObjectAccessor<2, 2>::barycenter () const
+{
                                   // the evaluation of the formulae
                                   // is a bit tricky when done dimension
                                   // independant, so we write this function
@@ -392,8 +470,10 @@ Point<2> TriaObjectAccessor<2, 2>::barycenter () const {
 };
 
 
+
 template <>
-double TriaObjectAccessor<2, 2>::measure () const {
+double TriaObjectAccessor<2, 2>::measure () const
+{
                                   // the evaluation of the formulae
                                   // is a bit tricky when done dimension
                                   // independant, so we write this function
@@ -444,7 +524,8 @@ double TriaObjectAccessor<2, 2>::measure () const {
 #if deal_II_dimension == 3
 
 template <>
-Point<3> TriaObjectAccessor<2, 3>::barycenter () const {
+Point<3> TriaObjectAccessor<2, 3>::barycenter () const
+{
                                   // the evaluation of the formulae
                                   // is a bit tricky when done dimension
                                   // independant, so we write this function
@@ -497,8 +578,10 @@ Point<3> TriaObjectAccessor<2, 3>::barycenter () const {
 };
 
 
+
 template <>
-double TriaObjectAccessor<2, 3>::measure () const {
+double TriaObjectAccessor<2, 3>::measure () const
+{
                                   // the evaluation of the formulae
                                   // is a bit tricky when done dimension
                                   // independant, so we write this function
@@ -514,7 +597,8 @@ double TriaObjectAccessor<2, 3>::measure () const {
 
 
 template <int dim>
-unsigned int TriaObjectAccessor<2, dim>::number_of_children () const {
+unsigned int TriaObjectAccessor<2, dim>::number_of_children () const
+{
   if (!has_children())
     return 1;
   else
@@ -530,13 +614,16 @@ unsigned int TriaObjectAccessor<2, dim>::number_of_children () const {
 /*------------------------ Functions: TriaObjectAccessor ---------------------------*/
 
 template <int dim>
-void TriaObjectAccessor<3, dim>::set (const Hexahedron &hex) const {
+void TriaObjectAccessor<3, dim>::set (const Hexahedron &hex) const
+{
   tria->levels[present_level]->hexes.hexes[present_index] = hex;
 };
 
 
+
 template <int dim>
-int TriaObjectAccessor<3, dim>::vertex_index (const unsigned int corner) const {
+int TriaObjectAccessor<3, dim>::vertex_index (const unsigned int corner) const
+{
   Assert (corner<8, ExcIndexRange(corner,0,8));
 
                                   // get the corner indices by asking
@@ -549,29 +636,37 @@ int TriaObjectAccessor<3, dim>::vertex_index (const unsigned int corner) const {
 };
 
 
+
 template <int dim>
 Point<dim> &
-TriaObjectAccessor<3, dim>::vertex (const unsigned int i) const {
+TriaObjectAccessor<3, dim>::vertex (const unsigned int i) const
+{
   return tria->vertices[vertex_index(i)];
 };
 
 
+
 template <int dim>
-void TriaObjectAccessor<3, dim>::set_used_flag () const {
-  Assert (state() == valid, ExcDereferenceInvalidObject());
+void TriaObjectAccessor<3, dim>::set_used_flag () const
+{
+  Assert (state() == valid, typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
   tria->levels[present_level]->hexes.used[present_index] = true;
 };
 
 
+
 template <int dim>
-void TriaObjectAccessor<3, dim>::clear_used_flag () const {
-  Assert (state() == valid, ExcDereferenceInvalidObject());
+void TriaObjectAccessor<3, dim>::clear_used_flag () const
+{
+  Assert (state() == valid, typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
   tria->levels[present_level]->hexes.used[present_index] = false;
 };
 
 
+
 template <int dim>
-void TriaObjectAccessor<3, dim>::recursively_set_user_flag () const {
+void TriaObjectAccessor<3, dim>::recursively_set_user_flag () const
+{
   set_user_flag ();
 
   if (has_children())
@@ -580,8 +675,10 @@ void TriaObjectAccessor<3, dim>::recursively_set_user_flag () const {
 };
 
 
+
 template <int dim>
-void TriaObjectAccessor<3, dim>::recursively_clear_user_flag () const {
+void TriaObjectAccessor<3, dim>::recursively_clear_user_flag () const
+{
   clear_user_flag ();
 
   if (has_children())
@@ -590,71 +687,90 @@ void TriaObjectAccessor<3, dim>::recursively_clear_user_flag () const {
 };
 
 
+
 template <int dim>
-void TriaObjectAccessor<3, dim>::set_user_pointer (void *p) const {
-  Assert (used(), ExcCellNotUsed());
+void TriaObjectAccessor<3, dim>::set_user_pointer (void *p) const
+{
+  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
   tria->levels[present_level]->hexes.user_pointers[present_index] = p;
 };
 
 
+
 template <int dim>
-void TriaObjectAccessor<3, dim>::clear_user_pointer () const {
-  Assert (used(), ExcCellNotUsed());
+void TriaObjectAccessor<3, dim>::clear_user_pointer () const
+{
+  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
   tria->levels[present_level]->hexes.user_pointers[present_index] = 0;
 };
 
 
+
 template <int dim>
-void * TriaObjectAccessor<3, dim>::user_pointer () const {
-  Assert (used(), ExcCellNotUsed());
+void * TriaObjectAccessor<3, dim>::user_pointer () const
+{
+  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
   return tria->levels[present_level]->hexes.user_pointers[present_index];
 };
 
 
+
 template <int dim>
-void TriaObjectAccessor<3, dim>::set_children (const int index) const {
-  Assert (used(), ExcCellNotUsed());
+void TriaObjectAccessor<3, dim>::set_children (const int index) const
+{
+  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
   Assert ((index==-1) ||
-         (!has_children() && (index>=0)), ExcCantSetChildren(index));
+         (!has_children() && (index>=0)),
+         typename TriaAccessor<dim>::ExcCantSetChildren(index));
 
   tria->levels[present_level]->hexes.children[present_index] = index;
 };
 
 
+
 template <int dim>
-void TriaObjectAccessor<3, dim>::clear_children () const {
+void TriaObjectAccessor<3, dim>::clear_children () const
+{
   set_children (-1);
 };
 
 
+
 template <int dim>
-unsigned char TriaObjectAccessor<3, dim>::boundary_indicator () const {
-  Assert (dim<4, ExcNotUsefulForThisDimension());
-  Assert (used(), ExcCellNotUsed());
+unsigned char TriaObjectAccessor<3, dim>::boundary_indicator () const
+{
+  Assert (dim<4, typename TriaAccessor<dim>::ExcNotUsefulForThisDimension());
+  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
 
   return tria->levels[present_level]->hexes.material_id[present_index];
 };
 
 
+
 template <int dim>
-void TriaObjectAccessor<3, dim>::set_boundary_indicator (unsigned char boundary_ind) const {
-  Assert (dim<4, ExcNotUsefulForThisDimension());
-  Assert (used(), ExcCellNotUsed());
+void TriaObjectAccessor<3, dim>::set_boundary_indicator (unsigned char boundary_ind) const
+{
+  Assert (dim<4, typename TriaAccessor<dim>::ExcNotUsefulForThisDimension());
+  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
 
   tria->levels[present_level]->hexes.material_id[present_index] = boundary_ind;
 };
 
 
+
 template <int dim>
-bool TriaObjectAccessor<3, dim>::at_boundary () const {
+bool TriaObjectAccessor<3, dim>::at_boundary () const
+{
                                   // error checking is done
                                   // in boundary_indicator()
   return (boundary_indicator() != 255);
 };
 
 
+
 template <int dim>
-double TriaObjectAccessor<3, dim>::diameter () const {
+double TriaObjectAccessor<3, dim>::diameter () const
+{
   return sqrt(max( max((vertex(6)-vertex(0)).square(),
                       (vertex(7)-vertex(1)).square()),
                   max((vertex(4)-vertex(2)).square(),
@@ -662,8 +778,10 @@ double TriaObjectAccessor<3, dim>::diameter () const {
 };
 
 
+
 template <int dim>
-Point<dim> TriaObjectAccessor<3, dim>::center () const {
+Point<dim> TriaObjectAccessor<3, dim>::center () const
+{
   return (vertex(0)+vertex(1)+vertex(2)+vertex(3)+
          vertex(4)+vertex(5)+vertex(6)+vertex(7))/8.;
 };
@@ -672,7 +790,8 @@ Point<dim> TriaObjectAccessor<3, dim>::center () const {
 #if deal_II_dimension == 3
 
 template <>
-Point<3> TriaObjectAccessor<3, 3>::barycenter () const {
+Point<3> TriaObjectAccessor<3, 3>::barycenter () const
+{
 /*
   Get the computation of the barycenter by this little Maple script. We
   use the trilinear mapping of the unit hex to the real hex.
@@ -1319,8 +1438,10 @@ x[7]*y[3]-z[5]*x[6]*y[4]-z[5]*x[4]*y[1]+z[5]*x[4]*y[6]+x[1]*y[6]*z[2]+x[2]*y[6]
 };
 
 
+
 template <>
-double TriaObjectAccessor<3, 3>::measure () const {
+double TriaObjectAccessor<3, 3>::measure () const
+{
 /*
   Get the computation of the measure by the same little Maple script as above.
 */
@@ -1398,8 +1519,10 @@ y[2]*x[3]*z[6]/12.0+s2+s1+x[2]*y[0]*z[3]/12.0;
 #endif
 
 
+
 template <int dim>
-unsigned int TriaObjectAccessor<3, dim>::number_of_children () const {
+unsigned int TriaObjectAccessor<3, dim>::number_of_children () const
+{
   if (!has_children())
     return 1;
   else
@@ -1418,20 +1541,25 @@ unsigned int TriaObjectAccessor<3, dim>::number_of_children () const {
 #if deal_II_dimension == 1
 
 template <>
-bool CellAccessor<1>::at_boundary () const {
+bool CellAccessor<1>::at_boundary () const
+{
   return at_boundary(0) || at_boundary(1);
 };
 
 
+
 template <>
-unsigned char CellAccessor<1>::material_id () const {
+unsigned char CellAccessor<1>::material_id () const
+{
   Assert (used(), ExcCellNotUsed());
   return tria->levels[present_level]->lines.material_id[present_index];
 };
 
 
+
 template <>
-void CellAccessor<1>::set_material_id (const unsigned char mat_id) const {
+void CellAccessor<1>::set_material_id (const unsigned char mat_id) const
+{
   Assert (used(), ExcCellNotUsed());
   tria->levels[present_level]->lines.material_id[present_index]
     = mat_id;                                           
@@ -1447,20 +1575,25 @@ void CellAccessor<1>::set_material_id (const unsigned char mat_id) const {
 #if deal_II_dimension == 2
 
 template <>
-bool CellAccessor<2>::at_boundary () const {
+bool CellAccessor<2>::at_boundary () const
+{
   return at_boundary(0) || at_boundary(1) || at_boundary(2) || at_boundary(3);
 };
 
 
+
 template <>
-unsigned char CellAccessor<2>::material_id () const {
+unsigned char CellAccessor<2>::material_id () const
+{
   Assert (used(), ExcCellNotUsed());
   return tria->levels[present_level]->quads.material_id[present_index];
 };
 
 
+
 template <>
-void CellAccessor<2>::set_material_id (const unsigned char mat_id) const {
+void CellAccessor<2>::set_material_id (const unsigned char mat_id) const
+{
   Assert (used(), ExcCellNotUsed());
   tria->levels[present_level]->quads.material_id[present_index]
     = mat_id;                                           
@@ -1475,22 +1608,27 @@ void CellAccessor<2>::set_material_id (const unsigned char mat_id) const {
 #if deal_II_dimension == 3
 
 template <>
-bool CellAccessor<3>::at_boundary () const {
+bool CellAccessor<3>::at_boundary () const
+{
   return (at_boundary(0) || at_boundary(1) ||
          at_boundary(2) || at_boundary(3) ||
          at_boundary(4) || at_boundary(5));
 };
 
 
+
 template <>
-unsigned char CellAccessor<3>::material_id () const {
+unsigned char CellAccessor<3>::material_id () const
+{
   Assert (used(), ExcCellNotUsed());
   return tria->levels[present_level]->hexes.material_id[present_index];
 };
 
 
+
 template <>
-void CellAccessor<3>::set_material_id (const unsigned char mat_id) const {
+void CellAccessor<3>::set_material_id (const unsigned char mat_id) const
+{
   Assert (used(), ExcCellNotUsed());
   tria->levels[present_level]->hexes.material_id[present_index]
     = mat_id;                                           
@@ -1504,8 +1642,10 @@ void CellAccessor<3>::set_material_id (const unsigned char mat_id) const {
 
 template <int dim>
 void CellAccessor<dim>::set_neighbor (const unsigned int i,
-                                     const TriaIterator<dim,CellAccessor<dim> > &pointer) const {
-  Assert (i<GeometryInfo<dim>::faces_per_cell, ExcInvalidNeighbor(i));
+                                     const TriaIterator<dim,CellAccessor<dim> > &pointer) const
+{
+  Assert (i<GeometryInfo<dim>::faces_per_cell,
+         typename TriaAccessor<dim>::ExcInvalidNeighbor(i));
 
   if (pointer.state() == valid)
     {
@@ -1528,15 +1668,16 @@ void CellAccessor<dim>::set_neighbor (const unsigned int i,
 };
 
 
+
 template <int dim>
 unsigned int CellAccessor<dim>::neighbor_of_neighbor (const unsigned int neighbor) const
 {
                                   // make sure that the neighbor is
                                   // not on a coarser level
   Assert (neighbor_level(neighbor) == present_level,
-         ExcNeighborIsCoarser());
+         typename TriaAccessor<dim>::ExcNeighborIsCoarser());
   Assert (neighbor < GeometryInfo<dim>::faces_per_cell,
-         ExcInvalidNeighbor(neighbor));
+         typename TriaAccessor<dim>::ExcInvalidNeighbor(neighbor));
 
   const TriaIterator<dim,CellAccessor<dim> > neighbor_cell = this->neighbor(neighbor);
   
@@ -1579,9 +1720,11 @@ unsigned int CellAccessor<dim>::neighbor_of_neighbor (const unsigned int neighbo
 };
 
 
+
 template <int dim>
-bool CellAccessor<dim>::at_boundary (const unsigned int i) const {
-  Assert (used(), ExcCellNotUsed());
+bool CellAccessor<dim>::at_boundary (const unsigned int i) const
+{
+  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
   Assert (i<GeometryInfo<dim>::faces_per_cell,
          ExcIndexRange (i,0,GeometryInfo<dim>::faces_per_cell));
   
@@ -1589,6 +1732,7 @@ bool CellAccessor<dim>::at_boundary (const unsigned int i) const {
 };
 
 
+
 // explicit instantiations
 template class TriaAccessor<deal_II_dimension>;
 template class TriaObjectAccessor<1, deal_II_dimension>;
index 23e3a7142a56f286093705e87eac958796909f4c..8fa2eff1cfc97b28d49bbd38ae62d2401f3cc1f7 100644 (file)
@@ -47,7 +47,7 @@ template <int dim>
 Point<dim>
 StraightBoundary<dim>::get_new_point_on_quad (const typename Triangulation<dim>::quad_iterator &) const 
 {
-  Assert (false, ExcPureVirtualFunctionCalled());
+  Assert (false, typename Boundary<dim>::ExcPureVirtualFunctionCalled());
   return Point<dim>();
 };
 
index c81fcd9fefa84f87342a8bdca17fd5ec3dc6de6d..c2a31faeb013c56d2c58ec48d96d9a34f9610819 100644 (file)
@@ -143,7 +143,7 @@ MGDoFObjectAccessor<1,dim>::get_mg_dof_values (const Vector<number> &values,
 
   const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
                     dofs_per_line   = dof_handler->get_fe().dofs_per_line;
-  vector<number>::iterator next_dof_value=dof_values.begin();
+  typename vector<number>::iterator next_dof_value=dof_values.begin();
   for (unsigned int vertex=0; vertex<2; ++vertex)
     for (unsigned int d=0; d<dofs_per_vertex; ++d)
       *next_dof_value++ = values(mg_vertex_dof_index(vertex,d));
@@ -308,7 +308,7 @@ MGDoFObjectAccessor<2,dim>::get_mg_dof_values (const Vector<number> &values,
   const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
                     dofs_per_line   = dof_handler->get_fe().dofs_per_line,
                     dofs_per_quad   = dof_handler->get_fe().dofs_per_quad;
-  vector<number>::iterator next_dof_value=dof_values.begin();
+  typename vector<number>::iterator next_dof_value=dof_values.begin();
   for (unsigned int vertex=0; vertex<4; ++vertex)
     for (unsigned int d=0; d<dofs_per_vertex; ++d)
       *next_dof_value++ = values(mg_vertex_dof_index(vertex,d));
@@ -498,7 +498,7 @@ MGDoFObjectAccessor<3,dim>::get_mg_dof_values (const Vector<number> &values,
                     dofs_per_line   = dof_handler->get_fe().dofs_per_line,
                     dofs_per_quad   = dof_handler->get_fe().dofs_per_quad,
                     dofs_per_hex    = dof_handler->get_fe().dofs_per_hex;
-  vector<number>::iterator next_dof_value=dof_values.begin();
+  typename vector<number>::iterator next_dof_value=dof_values.begin();
   for (unsigned int vertex=0; vertex<8; ++vertex)
     for (unsigned int d=0; d<dofs_per_vertex; ++d)
       *next_dof_value++ = values(mg_vertex_dof_index(vertex,d));
index ddf586f3ae171a41fa3fe1add10224a31eb5f21b..523441d82c7b7d2cf2506a4eea98625f9b4f2991 100644 (file)
@@ -132,7 +132,7 @@ void ProblemBase<dim>::assemble (const Equation<dim>      &equation,
                                   // in the docs
   map<unsigned int, double> boundary_value_list;
 
-  for (FunctionMap::const_iterator dirichlet = dirichlet_bc.begin() ;
+  for (typename FunctionMap::const_iterator dirichlet = dirichlet_bc.begin() ;
        dirichlet != dirichlet_bc.end() ; ++dirichlet)
     VectorTools::interpolate_boundary_values (*dof_handler,
                                              dirichlet->first,
index baeb073f28f2a21e4402e472ba5ddf92a74eb036..d9940c5076bb88d01ccdc95beece87c51e20dd4f 100644 (file)
@@ -178,10 +178,12 @@ vector<string> DataOut_DoFData<dim>::get_dataset_names () const
   vector<string> names;
                                   // collect the names of dof
                                   // and cell data
-  for (vector<DataEntry>::const_iterator d=dof_data.begin(); d!=dof_data.end(); ++d)
+  for (typename vector<DataEntry>::const_iterator d=dof_data.begin();
+       d!=dof_data.end(); ++d)
     for (unsigned int i=0; i<d->names.size(); ++i)
       names.push_back (d->names[i]);
-  for (vector<DataEntry>::const_iterator d=cell_data.begin(); d!=cell_data.end(); ++d)
+  for (typename vector<DataEntry>::const_iterator d=cell_data.begin();
+       d!=cell_data.end(); ++d)
     {
       Assert (d->names.size() == 1, ExcInternalError());
       names.push_back (d->names[0]);
@@ -214,7 +216,7 @@ void DataOut<dim>::build_some_patches (Data data)
   const unsigned int n_q_points = patch_points.n_quadrature_points;
   
   unsigned int cell_number = 0;
-  vector<DataOutBase::Patch<dim> >::iterator patch = patches.begin();
+  typename vector<DataOutBase::Patch<dim> >::iterator patch = patches.begin();
   DoFHandler<dim>::cell_iterator cell=first_cell();
 
                                   // get first cell in this thread
@@ -286,7 +288,7 @@ template <int dim>
 void DataOut<dim>::build_patches (const unsigned int n_subdivisions,
                                  const unsigned int n_threads_) 
 {
-  Assert (dofs != 0, ExcNoDoFHandlerSelected());
+  Assert (dofs != 0, typename DataOut_DoFData<dim>::ExcNoDoFHandlerSelected());
 
 #ifdef DEAL_II_USE_MT
   const unsigned int n_threads = n_threads_;
index 747d359aab7eaa0827e8f0d6c9df14378af0c908..38e470d4ac58d5aa67c8736ca1cbb67790c3dc48 100644 (file)
@@ -39,10 +39,12 @@ void DataOutStack<dim>::new_parameter_value (const double p,
                                   //
                                   // this is to prevent serious waste of
                                   // memory
-  for (vector<DataVector>::const_iterator i=dof_data.begin(); i!=dof_data.end(); ++i)
+  for (typename vector<DataVector>::const_iterator i=dof_data.begin();
+       i!=dof_data.end(); ++i)
     Assert (i->data.size() == 0,
            ExcDataNotCleared ());
-  for (vector<DataVector>::const_iterator i=cell_data.begin(); i!=cell_data.end(); ++i)
+  for (typename vector<DataVector>::const_iterator i=cell_data.begin();
+       i!=cell_data.end(); ++i)
     Assert (i->data.size() == 0,
            ExcDataNotCleared ());
   
@@ -80,12 +82,12 @@ void DataOutStack<dim>::declare_data_vector (const vector<string> &names,
                                   // used twice
   for (vector<string>::const_iterator name=names.begin(); name!=names.end(); ++name)
     {
-      for (vector<DataVector>::const_iterator data_set=dof_data.begin();
+      for (typename vector<DataVector>::const_iterator data_set=dof_data.begin();
           data_set!=dof_data.end(); ++data_set)
        for (unsigned int i=0; i<data_set->names.size(); ++i)
          Assert (*name != data_set->names[i], ExcNameAlreadyUsed(*name));
 
-      for (vector<DataVector>::const_iterator data_set=cell_data.begin();
+      for (typename vector<DataVector>::const_iterator data_set=cell_data.begin();
           data_set!=cell_data.end(); ++data_set)
        for (unsigned int i=0; i<data_set->names.size(); ++i)
          Assert (*name != data_set->names[i], ExcNameAlreadyUsed(*name));
@@ -139,7 +141,7 @@ void DataOutStack<dim>::add_data_vector (const Vector<number> &vec,
   
   if (vec.size() == dof_handler->n_dofs())
     {
-      vector<DataVector>::iterator data_vector=dof_data.begin();
+      typename vector<DataVector>::iterator data_vector=dof_data.begin();
       for (; data_vector!=dof_data.end(); ++data_vector)
        if (data_vector->names == names)
          {
@@ -153,7 +155,7 @@ void DataOutStack<dim>::add_data_vector (const Vector<number> &vec,
     }
   else
     {
-      vector<DataVector>::iterator data_vector=cell_data.begin();
+      typename vector<DataVector>::iterator data_vector=cell_data.begin();
       for (; data_vector!=cell_data.end(); ++data_vector)
        if (data_vector->names == names)
          {
@@ -213,9 +215,9 @@ void DataOutStack<dim>::build_patches (const unsigned int n_subdivisions)
 
                                   // now loop over all cells and
                                   // actually create the patches
-  vector<DataOutBase::Patch<dim+1> >::iterator patch = &patches[patches.size()-n_patches];
-  unsigned int                           cell_number = 0;
-  for (DoFHandler<dim>::active_cell_iterator cell=dof_handler->begin_active();
+  typename vector<DataOutBase::Patch<dim+1> >::iterator patch = &patches[patches.size()-n_patches];
+  unsigned int                                    cell_number = 0;
+  for (typename DoFHandler<dim>::active_cell_iterator cell=dof_handler->begin_active();
        cell != dof_handler->end(); ++cell, ++patch, ++cell_number)
     {
       Assert (patch != patches.end(), ExcInternalError());
@@ -293,10 +295,12 @@ void DataOutStack<dim>::finish_parameter_value ()
 {
                                   // release lock on dof handler
   dof_handler = 0;
-  for (vector<DataVector>::iterator i=dof_data.begin(); i!=dof_data.end(); ++i)
+  for (typename vector<DataVector>::iterator i=dof_data.begin();
+       i!=dof_data.end(); ++i)
     i->data.reinit (0);
   
-  for (vector<DataVector>::iterator i=cell_data.begin(); i!=cell_data.end(); ++i)
+  for (typename vector<DataVector>::iterator i=cell_data.begin();
+       i!=cell_data.end(); ++i)
     i->data.reinit (0);
 };
 
@@ -313,10 +317,10 @@ template <int dim>
 vector<string> DataOutStack<dim>::get_dataset_names () const
 {
   vector<string> names;
-  for (vector<DataVector>::const_iterator dataset=dof_data.begin();
+  for (typename vector<DataVector>::const_iterator dataset=dof_data.begin();
        dataset!=dof_data.end(); ++dataset)
     names.insert (names.end(), dataset->names.begin(), dataset->names.end());
-  for (vector<DataVector>::const_iterator dataset=cell_data.begin();
+  for (typename vector<DataVector>::const_iterator dataset=cell_data.begin();
        dataset!=cell_data.end(); ++dataset)
     names.insert (names.end(), dataset->names.begin(), dataset->names.end());
   
index 18f2ba2fefd037ff91ed1910e7da4dc0e3cd0911..0c90b9e97e65d2ff5f8da539cb0dbb591d04701e 100644 (file)
@@ -181,7 +181,7 @@ GradientEstimator::estimate_threaded (const DoFHandler<dim> &dof_handler,
                                       // now loop over all active
                                       // neighbors and collect the
                                       // data we need
-      vector<DoFHandler<dim>::active_cell_iterator>::const_iterator
+      typename vector<DoFHandler<dim>::active_cell_iterator>::const_iterator
        neighbor_ptr = active_neighbors.begin();
       for (; neighbor_ptr!=active_neighbors.end(); ++neighbor_ptr)
        {
index 4786c2567d2028c6460fee244605327f5bf9302e..d0dc99d44c64d1948ee20b860b7e27b4b7801e29 100644 (file)
@@ -92,7 +92,7 @@ KellyErrorEstimator<dim>::Data::Data(const DoFHandler<dim>   &dof,
   Assert (neumann_bc.find(255) == neumann_bc.end(),
          ExcInvalidBoundaryIndicator());
   
-  for (FunctionMap::const_iterator i=neumann_bc.begin(); i!=neumann_bc.end(); ++i)
+  for (typename FunctionMap::const_iterator i=neumann_bc.begin(); i!=neumann_bc.end(); ++i)
     Assert (i->second->n_components == n_components, ExcInvalidBoundaryFunction());
   
                                   // the last cell, often needed
index 18f2ba2fefd037ff91ed1910e7da4dc0e3cd0911..0c90b9e97e65d2ff5f8da539cb0dbb591d04701e 100644 (file)
@@ -181,7 +181,7 @@ GradientEstimator::estimate_threaded (const DoFHandler<dim> &dof_handler,
                                       // now loop over all active
                                       // neighbors and collect the
                                       // data we need
-      vector<DoFHandler<dim>::active_cell_iterator>::const_iterator
+      typename vector<DoFHandler<dim>::active_cell_iterator>::const_iterator
        neighbor_ptr = active_neighbors.begin();
       for (; neighbor_ptr!=active_neighbors.end(); ++neighbor_ptr)
        {
index a2ec11793b22b053c59c123bf50404f3e04b4c9c..b4b3b8635a3b920bea0e03713eb8a1fce786c86b 100644 (file)
@@ -893,7 +893,7 @@ void LaplaceProblem<dim>::run ()
                                   // obtain a reasonable view on the
                                   // solution, we rescale the z-axis
                                   // by a factor of four.
-  DataOut<dim>::EpsFlags eps_flags;
+  typename DataOut<dim>::EpsFlags eps_flags;
   eps_flags.z_scaling = 4;
   
   DataOut<dim> data_out;
index 996be16f80273bc55ab0dcbf682af029eade92d6..12b95372cdd1e09a6f07b89f635bd32d42ffde58 100644 (file)
 #include <fstream>
 
 
+
+// in strict ANSI C mode, the following constants are not defined by
+// default, so we do it ourselves
+#ifndef M_PI
+#  define      M_PI            3.14159265358979323846
+#endif
+
+
+
 template <int dim>
 class AdvectionProblem 
 {
@@ -525,7 +534,7 @@ void AdvectionProblem<dim>::run ()
       output_results (cycle);
     };
 
-  DataOut<dim>::EpsFlags eps_flags;
+  typename DataOut<dim>::EpsFlags eps_flags;
   eps_flags.z_scaling = 4;
   
   DataOut<dim> data_out;
index c1838ed788004bbec674bbcfb030287bbe2607d0..182b07c136d80c010b53b52f14a0009e1e50b141 100644 (file)
@@ -265,7 +265,8 @@ SolverBicgstab<VECTOR>::iterate(const MATRIX& A,
 
 //TODO: Find better breakdown criterion (G)
 
-      if (fabs(alpha) > 1.e10) return ReturnState(breakdown);
+      if (fabs(alpha) > 1.e10)
+       return typename Solver<VECTOR>::ReturnState(breakdown);
     
       s.equ(1., r, -alpha, v);
       precondition(z,s);
@@ -307,7 +308,7 @@ SolverBicgstab<VECTOR>::solve(const MATRIX &A,
 
   step = 0;
 
-  ReturnState state = breakdown;
+  typename Solver<VECTOR>::ReturnState state = breakdown;
   
   do 
     {
index c6f181d570eb9e9fa936508f917d60ab96f2eb05..20ce79596fc78123fd398f9f138c941ba463a44b 100644 (file)
@@ -238,7 +238,7 @@ SolverQMRS<VECTOR>::solve (const MATRIX &A,
 
   step = 0;
   
-  ReturnState state = breakdown;
+  typename Solver<VECTOR>::ReturnState state = breakdown;
 
   do 
     {
@@ -263,6 +263,8 @@ SolverQMRS<VECTOR>::solve (const MATRIX &A,
   return state;
 };
 
+
+
 template<class VECTOR>
 template<class MATRIX, class Preconditioner>
 typename Solver<VECTOR>::ReturnState 
@@ -299,7 +301,7 @@ SolverQMRS<VECTOR>::iterate(const MATRIX& A,
   res = A.residual(v, q, b);
 
   if (control().check(step, res) == SolverControl::success)
-    return ReturnState(success);
+    return success;
 
   p = v;
   
@@ -322,7 +324,7 @@ while (state == SolverControl::iterate)
 //TODO: Find a really good breakdown criterion
 // The absolute one detects breakdown instead of convergence
       if (fabs(sigma) < additional_data.breakdown)
-       return ReturnState(breakdown);
+       return breakdown;
                                       // Step 3
       alpha = rho/sigma;
       //deallog << "alpha:" << alpha << endl;
@@ -349,12 +351,12 @@ while (state == SolverControl::iterate)
        res = sqrt((it+1)*tau);
       state = control().check(step,res);
       if (state == SolverControl::success)
-       return ReturnState(success);
+       return success;
       else if (state == SolverControl::failure)
-       return ReturnState(exceeded);
+       return exceeded;
                                       // Step 6
       if (fabs(rho) < additional_data.breakdown)
-       return ReturnState(breakdown);
+       return breakdown;
                                       // Step 7
       rho_old = rho;
       precondition(q,v);
@@ -364,7 +366,7 @@ while (state == SolverControl::iterate)
       p.sadd(beta,v);
       precondition(q,p);
     }
-  return ReturnState(exceeded);
+  return exceeded;
 }
 
 
index c0960b7ca20e1a24c3c6939ac4474ce98cb266c5..f9084da451a0c2fd0377dc1a2c19317da7cc34ab 100644 (file)
@@ -172,8 +172,9 @@ template<typename Vector>
 GrowingVectorMemory<Vector>::GrowingVectorMemory(const unsigned int initial_size)
                : pool(initial_size)
 {
-  for (vector<entry_type>::iterator i=pool.begin();i != pool.end()
-                                     ;++i)
+  for (typename vector<entry_type>::iterator i=pool.begin();
+       i != pool.end();
+       ++i)
     {
       i->first = false;
       i->second = new Vector;
@@ -182,11 +183,14 @@ GrowingVectorMemory<Vector>::GrowingVectorMemory(const unsigned int initial_size
 }
 
 
+
 template<typename Vector>
 GrowingVectorMemory<Vector>::~GrowingVectorMemory()
 {
   unsigned int n = 0;
-  for (vector<entry_type>::iterator i=pool.begin();i != pool.end() ;++i)
+  for (typename vector<entry_type>::iterator i=pool.begin();
+       i != pool.end();
+       ++i)
     {
       if (i->first == true)
        ++n;
@@ -202,12 +206,15 @@ GrowingVectorMemory<Vector>::~GrowingVectorMemory()
 }
 
 
+
 template<typename Vector>
 Vector*
 GrowingVectorMemory<Vector>::alloc()
 {
   ++n_alloc;
-  for (vector<entry_type>::iterator i=pool.begin();i != pool.end() ;++i)
+  for (typename vector<entry_type>::iterator i=pool.begin();
+       i != pool.end();
+       ++i)
     {
       if (i->first == false)
        {
@@ -223,11 +230,12 @@ GrowingVectorMemory<Vector>::alloc()
 }
 
 
+
 template<typename Vector>
 void
 GrowingVectorMemory<Vector>::free(const Vector* const v)
 {
-  for (vector<entry_type>::iterator i=pool.begin();i != pool.end() ;++i)
+  for (typename vector<entry_type>::iterator i=pool.begin();i != pool.end() ;++i)
     {
       if (v == (i->second))
        {
@@ -235,7 +243,7 @@ GrowingVectorMemory<Vector>::free(const Vector* const v)
          return;
        }
     }
-  Assert(false, ExcNotAllocatedHere());
+  Assert(false, typename VectorMemory<Vector>::ExcNotAllocatedHere());
 }
 
 
index 38bffd824e37e0aee24dd989d879ff16e5c8481c..423492109ffbbb9b7a16da8874d47051dee73774 100644 (file)
@@ -182,7 +182,7 @@ template <int dim>
 void PoissonEquation<dim>::assemble (FullMatrix<double>  &,
                                     const FEValues<dim> &,
                                     const DoFHandler<dim>::cell_iterator &) const {
-  Assert (false, ExcPureVirtualFunctionCalled());
+  Assert (false, typename Equation<dim>::ExcPureVirtualFunctionCalled());
 };
 
 
@@ -191,7 +191,7 @@ template <int dim>
 void PoissonEquation<dim>::assemble (Vector<double>      &,
                                     const FEValues<dim> &,
                                     const DoFHandler<dim>::cell_iterator &) const {
-  Assert (false, ExcPureVirtualFunctionCalled());
+  Assert (false, typename Equation<dim>::ExcPureVirtualFunctionCalled());
 };
 
 
index cd11fc86302830fb5c641227eda18d00ca8a2c61..6d181e222ea536ab163d0f4ad2f971bf9ee348a9 100644 (file)
@@ -310,7 +310,7 @@ template <int dim>
 void PoissonEquation<dim>::assemble (FullMatrix<double>  &,
                                     const FEValues<dim> &,
                                     const DoFHandler<dim>::cell_iterator &) const {
-  Assert (false, ExcPureVirtualFunctionCalled());
+  Assert (false, typename Equation<dim>::ExcPureVirtualFunctionCalled());
 };
 
 
@@ -319,7 +319,7 @@ template <int dim>
 void PoissonEquation<dim>::assemble (Vector<double>      &,
                                     const FEValues<dim> &,
                                     const DoFHandler<dim>::cell_iterator &) const {
-  Assert (false, ExcPureVirtualFunctionCalled());
+  Assert (false, typename Equation<dim>::ExcPureVirtualFunctionCalled());
 };
 
 
index 2782a285c8ffaa3f2db4b4b9d027ec9c03dc4ffd..891b8cbe5829a1bf85da40f70376fabcc510bbd0 100644 (file)
@@ -461,7 +461,7 @@ void LaplaceProblem<dim>::run ()
       solve ();
       output_results (cycle);
 
-  DataOut<dim>::EpsFlags eps_flags;
+  typename DataOut<dim>::EpsFlags eps_flags;
   eps_flags.z_scaling = 4;
   
   DataOut<dim> data_out;
index 5c305727dcb3dc8c77a4309936cf3c123a869c0d..1ab5f1b2a9bd6f369559853d6834fa66a7040185 100644 (file)
@@ -132,7 +132,7 @@ template <int dim>
 void PoissonEquation<dim>::assemble (FullMatrix<double>  &,
                                     const FEValues<dim> &,
                                     const DoFHandler<dim>::cell_iterator &) const {
-  Assert (false, ExcPureVirtualFunctionCalled());
+  Assert (false, typename Equation<dim>::ExcPureVirtualFunctionCalled());
 };
 
 
@@ -141,7 +141,7 @@ template <int dim>
 void PoissonEquation<dim>::assemble (Vector<double>      &,
                                     const FEValues<dim> &,
                                     const DoFHandler<dim>::cell_iterator &) const {
-  Assert (false, ExcPureVirtualFunctionCalled());
+  Assert (false, typename Equation<dim>::ExcPureVirtualFunctionCalled());
 };
 
 
index 9610c7e8885ca34903f1e5a215ed645f94b2c479..08eda933997f530a9406fa4ea87348dd231d87e5 100644 (file)
@@ -66,7 +66,7 @@ template <int dim>
 void PoissonEquation<dim>::assemble (FullMatrix<double>  &,
                                     const FEValues<dim> &,
                                     const DoFHandler<dim>::cell_iterator &) const {
-  Assert (false, ExcPureVirtualFunctionCalled());
+  Assert (false, typename Equation<dim>::ExcPureVirtualFunctionCalled());
 };
 
 
@@ -75,7 +75,7 @@ template <int dim>
 void PoissonEquation<dim>::assemble (Vector<double>      &,
                                     const FEValues<dim> &,
                                     const DoFHandler<dim>::cell_iterator &) const {
-  Assert (false, ExcPureVirtualFunctionCalled());
+  Assert (false, typename Equation<dim>::ExcPureVirtualFunctionCalled());
 };
 
 
index 40a9ac44a6e785726dacb771e4647b499b13355b..f596a461efaaae4421af1f76b795632a1ebef82b 100644 (file)
@@ -138,6 +138,15 @@ class TimeStep_Primal :  public TimeStep_Wave<dim>
     virtual void solve_primal_problem ();    
     virtual string branch_signature () const;
     virtual void wake_up (const unsigned int wakeup_level);
+    virtual void end_sweep ()
+      {
+       TimeStep_Wave<dim>::end_sweep();
+      };
+    virtual void sleep (const unsigned int sleep_level)
+      {
+       TimeStep_Wave<dim>::sleep (sleep_level);
+      };
+    
     
   private:
     void assemble_vectors (Vector<double> &right_hand_side1,
@@ -175,6 +184,16 @@ class TimeStep_Dual :  public TimeStep_Wave<dim>
     virtual string branch_signature () const;
     virtual void wake_up (const unsigned int wakeup_level);
 
+    virtual void end_sweep ()
+      {
+       TimeStep_Wave<dim>::end_sweep();
+      };
+    virtual void sleep (const unsigned int sleep_level)
+      {
+       TimeStep_Wave<dim>::sleep (sleep_level);
+      };
+    
+
   private:
     void assemble_vectors (Vector<double> &right_hand_side1,
                           Vector<double> &right_hand_side2);
@@ -2804,7 +2823,7 @@ double EvaluateSeismicSignal<dim>::evaluate () {
   const unsigned int n_q_points = quadrature_face->n_quadrature_points;
 
   ofstream out((base_file_name + ".seismic").c_str());
-  AssertThrow (out, ExcIO());
+  AssertThrow (out, typename EvaluationBase<dim>::ExcIO());
   
   DoFHandler<dim>::active_cell_iterator cell = dof->begin_active(),
                                        endc = dof->end();
@@ -2847,7 +2866,7 @@ double EvaluateSeismicSignal<dim>::evaluate () {
              << endl
              << endl;
        };
-  AssertThrow (out, ExcIO());
+  AssertThrow (out, typename EvaluationBase<dim>::ExcIO());
   out.close ();
   
   if (time!=0)
@@ -5596,16 +5615,16 @@ void TimeStep_Dual<dim>::do_initial_step () {
        solver_steps1 = solve (system_matrix, u, tmp_u_bar),
        solver_steps2 = solve (system_matrix, v, tmp_v_bar);
 
-      statistic_data = StatisticData (tria->n_active_cells(),
-                                     dof_handler->n_dofs(),
-                                     solver_steps1, solver_steps2,
-                                     compute_energy ());
+      statistic_data = typename TimeStep_Wave<dim>::StatisticData (tria->n_active_cells(),
+                                                                  dof_handler->n_dofs(),
+                                                                  solver_steps1, solver_steps2,
+                                                                  compute_energy ());
     }
   else
-    statistic_data = StatisticData (tria->n_active_cells(),
-                                   dof_handler->n_dofs(),
-                                   0, 0,
-                                   make_pair (0.0, 0.0));
+    statistic_data = typename TimeStep_Wave<dim>::StatisticData (tria->n_active_cells(),
+                                                                dof_handler->n_dofs(),
+                                                                0, 0,
+                                                                make_pair (0.0, 0.0));
   deallog << "." << endl;
 };
 
@@ -5732,11 +5751,11 @@ void TimeStep_Dual<dim>::do_timestep ()
   
   const unsigned int solver_steps2 = solve (system_matrix, u, right_hand_side2);
 
-  statistic_data = StatisticData (tria->n_active_cells(),
-                                 dof_handler->n_dofs(),
-                                 solver_steps1,
-                                 solver_steps2,
-                                 compute_energy ());
+  statistic_data = typename TimeStep_Wave<dim>::StatisticData (tria->n_active_cells(),
+                                                              dof_handler->n_dofs(),
+                                                              solver_steps1,
+                                                              solver_steps2,
+                                                              compute_energy ());
   
   deallog << "." << endl;
 };
@@ -5813,7 +5832,7 @@ void TimeStep_Dual<dim>::build_rhs (Vector<double> &right_hand_side1,
     = static_cast<const TimeStepBase_Wave<dim>*>(next_timestep)->get_timestep_dual();
 
   Assert (previous_time_level.tria->n_cells(0) == tria->n_cells(0),
-         ExcCoarsestGridsDiffer());
+         typename TimeStep_Wave<dim>::ExcCoarsestGridsDiffer());
 
                                   // convenience typedef
   typedef DoFHandler<dim>::cell_iterator cell_iterator;
@@ -7507,10 +7526,12 @@ void TimeStep<dim>::write_statistics_descriptions (ostream                   &ou
                                                   const WaveParameters<dim> &parameters)
 {
   out << "#  Primal problem:" << endl;
-  TimeStep_Primal<dim>::StatisticData::write_descriptions (out);
+  typename TimeStep_Primal<dim>::StatisticData xp;
+  xp.write_descriptions (out);
 
   out << "#  Dual problem:" << endl;
-  TimeStep_Dual<dim>::StatisticData::write_descriptions (out);
+  typename TimeStep_Dual<dim>::StatisticData xd;
+  xd.write_descriptions (out);
 
   out << "#  Error estimation:" << endl;
   TimeStep_ErrorEstimation<dim>::StatisticData::write_descriptions (out);
@@ -7593,7 +7614,7 @@ void TimeStep_Postprocess<dim>::postprocess_timestep ()
       deallog << "[o]";
 
       DataOut<dim> out;
-      DataOut<dim>::OutputFormat output_format
+      typename DataOut<dim>::OutputFormat output_format
        = DataOut<dim>::parse_output_format (parameters.output_format);
       
       string data_filename     = (parameters.output_directory +
@@ -7865,11 +7886,11 @@ void TimeStep_Primal<dim>::do_initial_step ()
                                   // set energy to zero since we
                                   // don't want to assemble the matrices
                                   // needed for this
-  statistic_data = StatisticData (tria->n_active_cells(),
-                                 dof_handler->n_dofs(),
-                                 0,
-                                 0,
-                                 make_pair (0.0, 0.0));
+  statistic_data = typename TimeStep_Wave<dim>::StatisticData (tria->n_active_cells(),
+                                                              dof_handler->n_dofs(),
+                                                              0,
+                                                              0,
+                                                              make_pair (0.0, 0.0));
 
   deallog << "." << endl;
 };
@@ -7991,11 +8012,11 @@ if (parameters.extrapolate_old_solutions)
 
   const unsigned int solver_steps2 = solve (system_matrix, v, right_hand_side2);
 
-  statistic_data = StatisticData (tria->n_active_cells(),
-                                 dof_handler->n_dofs(),
-                                 solver_steps1,
-                                 solver_steps2,
-                                 compute_energy ());
+  statistic_data = typename TimeStep_Wave<dim>::StatisticData (tria->n_active_cells(),
+                                                              dof_handler->n_dofs(),
+                                                              solver_steps1,
+                                                              solver_steps2,
+                                                              compute_energy ());
   
   deallog << "." << endl;
 };
@@ -8059,7 +8080,7 @@ void TimeStep_Primal<dim>::build_rhs (Vector<double> &right_hand_side1,
     = static_cast<const TimeStepBase_Wave<dim>*>(previous_timestep)->get_timestep_primal();
 
   Assert (previous_time_level.tria->n_cells(0) == tria->n_cells(0),
-         ExcCoarsestGridsDiffer());
+         typename TimeStep_Wave<dim>::ExcCoarsestGridsDiffer());
 
                                   // convenience typedef
   typedef DoFHandler<dim>::cell_iterator cell_iterator;

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.