]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Fix a really frightening number of places where we need to indicate access to members...
authorWolfgang Bangerth <bangerth@math.tamu.edu>
Tue, 7 May 2002 06:53:21 +0000 (06:53 +0000)
committerWolfgang Bangerth <bangerth@math.tamu.edu>
Tue, 7 May 2002 06:53:21 +0000 (06:53 +0000)
git-svn-id: https://svn.dealii.org/trunk@5832 0785d39b-7218-0410-832d-ea1e28bc413d

12 files changed:
deal.II/base/include/base/point.h
deal.II/base/source/auto_derivative_function.cc
deal.II/base/source/function.cc
deal.II/base/source/function_lib_cutoff.cc
deal.II/base/source/quadrature.cc
deal.II/base/source/quadrature_lib.cc
deal.II/deal.II/include/dofs/dof_accessor.templates.h
deal.II/deal.II/include/grid/tria_accessor.templates.h
deal.II/lac/include/lac/full_matrix.templates.h
deal.II/lac/include/lac/precondition_block.templates.h
deal.II/lac/include/lac/sparse_ilu.templates.h
deal.II/lac/include/lac/swappable_vector.templates.h

index 4dfd03f7daef64b89096963fc36b768a7ef9b2aa..71e53792edb97b2290dc3f943badaa701682b244 100644 (file)
@@ -17,6 +17,7 @@
 #include <base/config.h>
 #include <base/exceptions.h>
 #include <base/tensor_base.h>
+#include <cmath>
 
 
 /**
index 96fa2898e1b0a79ddef48520a1a7a64f0132ea8f..5d44b32cc4e34f2509268e808dde6b0f863b1f92 100644 (file)
@@ -120,14 +120,15 @@ template <int dim>
 void AutoDerivativeFunction<dim>::vector_gradient (const Point<dim>       &p,
                                                   typename std::vector<Tensor<1,dim> > &gradients) const
 {
-  Assert (gradients.size() == n_components, ExcDimensionMismatch(gradients.size(), n_components));
+  Assert (gradients.size() == this->n_components,
+         ExcDimensionMismatch(gradients.size(), this->n_components));
   
   switch (formula)
     {
       case UpwindEuler:
       {
        Point<dim> q1;
-       Vector<double> v(n_components), v1(n_components);
+       Vector<double> v(this->n_components), v1(this->n_components);
        const double h_inv=1./h;
        for (unsigned int i=0; i<dim; ++i)
          {
@@ -135,7 +136,7 @@ void AutoDerivativeFunction<dim>::vector_gradient (const Point<dim>       &p,
            vector_value(p, v);
            vector_value(q1, v1);
            
-           for (unsigned int comp=0; comp<n_components; ++comp)
+           for (unsigned int comp=0; comp<this->n_components; ++comp)
              gradients[comp][i]=(v(comp)-v1(comp))*h_inv;
          }
        break;
@@ -143,7 +144,7 @@ void AutoDerivativeFunction<dim>::vector_gradient (const Point<dim>       &p,
       case Euler:
       {
        Point<dim> q1, q2;
-       Vector<double> v1(n_components), v2(n_components);
+       Vector<double> v1(this->n_components), v2(this->n_components);
        const double h_inv_2=1./(2*h);
        for (unsigned int i=0; i<dim; ++i)
          {
@@ -152,7 +153,7 @@ void AutoDerivativeFunction<dim>::vector_gradient (const Point<dim>       &p,
            vector_value(q1, v1);
            vector_value(q2, v2);
            
-           for (unsigned int comp=0; comp<n_components; ++comp)
+           for (unsigned int comp=0; comp<this->n_components; ++comp)
              gradients[comp][i]=(v1(comp)-v2(comp))*h_inv_2;
          }
        break;
@@ -160,7 +161,9 @@ void AutoDerivativeFunction<dim>::vector_gradient (const Point<dim>       &p,
       case FourthOrder:
       {
        Point<dim> q1, q2, q3, q4;
-       Vector<double> v1(n_components), v2(n_components), v3(n_components), v4(n_components);
+       Vector<double>
+         v1(this->n_components), v2(this->n_components),
+         v3(this->n_components), v4(this->n_components);
        const double h_inv_12=1./(12*h);
        for (unsigned int i=0; i<dim; ++i)
          {
@@ -173,7 +176,7 @@ void AutoDerivativeFunction<dim>::vector_gradient (const Point<dim>       &p,
            vector_value(q3, v3);
            vector_value(q4, v4);
            
-           for (unsigned int comp=0; comp<n_components; ++comp)
+           for (unsigned int comp=0; comp<this->n_components; ++comp)
              gradients[comp][i]=(-v1(comp)+8*v2(comp)-8*v3(comp)+v4(comp))*h_inv_12;
          }
        break;
@@ -250,8 +253,8 @@ vector_gradient_list (const typename std::vector<Point<dim> >            &points
   Assert (gradients.size() == points.size(),
          ExcDimensionMismatch(gradients.size(), points.size()));
   for (unsigned p=0; p<points.size(); ++p)
-    Assert (gradients[p].size() == n_components,
-           ExcDimensionMismatch(gradients.size(), n_components));
+    Assert (gradients[p].size() == this->n_components,
+           ExcDimensionMismatch(gradients.size(), this->n_components));
     
   switch (formula)
     {
@@ -262,7 +265,7 @@ vector_gradient_list (const typename std::vector<Point<dim> >            &points
          for (unsigned int i=0; i<dim; ++i)
            {
              q1=points[p]-ht[i];
-             for (unsigned int comp=0; comp<n_components; ++comp)
+             for (unsigned int comp=0; comp<this->n_components; ++comp)
                gradients[p][comp][i]=(value(points[p], comp)-value(q1, comp))/h;
          }
        break;
@@ -275,7 +278,7 @@ vector_gradient_list (const typename std::vector<Point<dim> >            &points
            {
              q1=points[p]+ht[i];
              q2=points[p]-ht[i];
-             for (unsigned int comp=0; comp<n_components; ++comp)
+             for (unsigned int comp=0; comp<this->n_components; ++comp)
                gradients[p][comp][i]=(value(q1, comp)-value(q2, comp))/(2*h);
            }
        break;
@@ -290,7 +293,7 @@ vector_gradient_list (const typename std::vector<Point<dim> >            &points
              q1=q2+ht[i];
              q3=points[p]-ht[i];
              q4=q3-ht[i];
-             for (unsigned int comp=0; comp<n_components; ++comp)
+             for (unsigned int comp=0; comp<this->n_components; ++comp)
                gradients[p][comp][i]=(-  value(q1, comp)
                                       +8*value(q2, comp)
                                       -8*value(q3, comp)
index 3c303360067659117493195e48b0a64c2117e3da..d97171adafca93a86267dfc700461b6bd9444f72 100644 (file)
@@ -217,8 +217,8 @@ template <int dim>
 void ZeroFunction<dim>::vector_value (const Point<dim> &,
                                      Vector<double>   &return_value) const
 {
-  Assert (return_value.size() == n_components,
-         ExcDimensionMismatch (return_value.size(), n_components));
+  Assert (return_value.size() == this->n_components,
+         ExcDimensionMismatch (return_value.size(), this->n_components));
 
   std::fill (return_value.begin(), return_value.end(), 0.0);
 };
@@ -244,8 +244,8 @@ void ZeroFunction<dim>::vector_value_list (const typename std::vector<Point<dim>
 
   for (unsigned int i=0; i<points.size(); ++i)
     {
-      Assert (values[i].size() == n_components,
-             ExcDimensionMismatch(values[i].size(), n_components));
+      Assert (values[i].size() == this->n_components,
+             ExcDimensionMismatch(values[i].size(), this->n_components));
       std::fill (values[i].begin(), values[i].end(), 0.);
     };
 };
@@ -263,10 +263,10 @@ template <int dim>
 void ZeroFunction<dim>::vector_gradient (const Point<dim>       &,
                                         typename std::vector<Tensor<1,dim> > &gradients) const
 {
-  Assert (gradients.size() == n_components,
-         ExcDimensionMismatch(gradients.size(), n_components));
+  Assert (gradients.size() == this->n_components,
+         ExcDimensionMismatch(gradients.size(), this->n_components));
 
-  for (unsigned int c=0; c<n_components; ++c)
+  for (unsigned int c=0; c<this->n_components; ++c)
     gradients[c].clear ();
 };
 
@@ -292,9 +292,9 @@ void ZeroFunction<dim>::vector_gradient_list (const typename std::vector<Point<d
          ExcDimensionMismatch(gradients.size(), points.size()));
   for (unsigned int i=0; i<points.size(); ++i)
     {
-      Assert (gradients[i].size() == n_components,
-             ExcDimensionMismatch(gradients[i].size(), n_components));
-      for (unsigned int c=0; c<n_components; ++c)
+      Assert (gradients[i].size() == this->n_components,
+             ExcDimensionMismatch(gradients[i].size(), this->n_components));
+      for (unsigned int c=0; c<this->n_components; ++c)
        gradients[i][c].clear ();
     };
 };
@@ -306,7 +306,8 @@ template <int dim>
 ConstantFunction<dim>::ConstantFunction (const double value,
                                         const unsigned int n_components) :
                ZeroFunction<dim> (n_components),
-  function_value    (value) {};
+  function_value    (value)
+{};
 
 
 template <int dim>
@@ -325,8 +326,8 @@ template <int dim>
 void ConstantFunction<dim>::vector_value (const Point<dim> &,
                                          Vector<double>   &return_value) const
 {
-  Assert (return_value.size() == n_components,
-         ExcDimensionMismatch (return_value.size(), n_components));
+  Assert (return_value.size() == this->n_components,
+         ExcDimensionMismatch (return_value.size(), this->n_components));
 
   std::fill (return_value.begin(), return_value.end(), function_value);
 };
@@ -353,8 +354,8 @@ void ConstantFunction<dim>::vector_value_list (const typename std::vector<Point<
 
   for (unsigned int i=0; i<points.size(); ++i)
     {
-      Assert (values[i].size() == n_components,
-             ExcDimensionMismatch(values[i].size(), n_components));
+      Assert (values[i].size() == this->n_components,
+             ExcDimensionMismatch(values[i].size(), this->n_components));
       std::fill (values[i].begin(), values[i].end(), function_value);
     };
 };
@@ -386,11 +387,11 @@ template <int dim>
 void ComponentSelectFunction<dim>::vector_value (const Point<dim> &,
                                                 Vector<double>   &return_value) const
 {
-  Assert (return_value.size() == n_components,
-         ExcDimensionMismatch (return_value.size(), n_components));
+  Assert (return_value.size() == this->n_components,
+         ExcDimensionMismatch (return_value.size(), this->n_components));
 
   std::fill (return_value.begin(), return_value.end(), 0.);
-  return_value(selected) = function_value;
+  return_value(selected) = this->function_value;
 }
 
 
@@ -404,10 +405,10 @@ void ComponentSelectFunction<dim>::vector_value_list (const typename std::vector
 
   for (unsigned int i=0; i<points.size(); ++i)
     {
-      Assert (values[i].size() == n_components,
-             ExcDimensionMismatch(values[i].size(), n_components));
+      Assert (values[i].size() == this->n_components,
+             ExcDimensionMismatch(values[i].size(), this->n_components));
       std::fill (values[i].begin(), values[i].end(), 0.);
-      values[i](selected) = function_value;
+      values[i](selected) = this->function_value;
     }
 }
 
index 53660bacb8caaa5fcfcee79be7bad87c88f74a7e..59105accd22768608585e96c2e65cfa09f36d29c 100644 (file)
@@ -87,8 +87,10 @@ namespace Functions
   CutOffFunctionLinfty<dim>::value (const Point<dim>   &p,
                                    const unsigned int component) const
   {
-    if (selected==no_component || component==selected)
-      return ((center.distance(p)<radius) ? 1. : 0.);
+    if (this->selected==CutOffFunctionBase<dim>::no_component
+       ||
+       component==this->selected)
+      return ((this->center.distance(p)<this->radius) ? 1. : 0.);
     return 0.;
   }
 
@@ -101,13 +103,15 @@ namespace Functions
   {
     Assert (values.size() == points.size(),
            ExcDimensionMismatch(values.size(), points.size()));
-    Assert (component < n_components,
-           ExcIndexRange(component,0,n_components));
+    Assert (component < this->n_components,
+           ExcIndexRange(component,0,this->n_components));
     
 
-    if (selected==no_component || component==selected)
+    if (this->selected==CutOffFunctionBase<dim>::no_component
+       ||
+       component==this->selected)
       for (unsigned int k=0;k<values.size();++k)
-       values[k] = (center.distance(points[k])<radius) ? 1. : 0.;
+       values[k] = (this->center.distance(points[k])<this->radius) ? 1. : 0.;
     else
       std::fill (values.begin(), values.end(), 0.);
   }
@@ -124,13 +128,14 @@ namespace Functions
 
     for (unsigned int k=0;k<values.size();++k)
       {
-       double val = (center.distance(points[k])<radius) ? 1. : 0.;
-       if (selected==no_component)
+       const double
+         val = (this->center.distance(points[k])<this->radius) ? 1. : 0.;
+       if (this->selected==CutOffFunctionBase<dim>::no_component)
          values[k] = val;
        else
          {
            values[k].clear ();
-           values[k](selected) = val;
+           values[k](this->selected) = val;
          }
       }
   }
@@ -151,10 +156,12 @@ namespace Functions
   CutOffFunctionW1<dim>::value (const Point<dim>   &p,
                                const unsigned int component) const
   {
-    if (selected==no_component || component==selected)
+    if (this->selected==CutOffFunctionBase<dim>::no_component
+       ||
+       component==this->selected)
       {
-       const double d = center.distance(p);
-       return ((d<radius) ? (radius-d) : 0.);
+       const double d = this->center.distance(p);
+       return ((d<this->radius) ? (this->radius-d) : 0.);
       }
     return 0.;  
   }
@@ -169,11 +176,13 @@ namespace Functions
     Assert (values.size() == points.size(),
            ExcDimensionMismatch(values.size(), points.size()));
     
-    if (selected==no_component || component==selected)
+    if (this->selected==CutOffFunctionBase<dim>::no_component
+       ||
+       component==this->selected)
       for (unsigned int i=0;i<values.size();++i)
        {
-         const double d = center.distance(points[i]);
-         values[i] = ((d<radius) ? (radius-d) : 0.);
+         const double d = this->center.distance(points[i]);
+         values[i] = ((d<this->radius) ? (this->radius-d) : 0.);
        }
     else
       std::fill (values.begin(), values.end(), 0.);
@@ -192,14 +201,15 @@ namespace Functions
 
     for (unsigned int k=0;k<values.size();++k)
       {
-       const double d = center.distance(points[k]);
-       double val = (d<radius) ? (radius-d) : 0.;
-       if (selected==no_component)
+       const double d = this->center.distance(points[k]);
+       const double
+         val = (d<this->radius) ? (this->radius-d) : 0.;
+       if (this->selected==CutOffFunctionBase<dim>::no_component)
          values[k] = val;
        else
          {
            values[k].clear ();
-           values[k](selected) = val;
+           values[k](this->selected) = val;
          }
       }
   }
@@ -220,10 +230,12 @@ namespace Functions
   CutOffFunctionCinfty<dim>::value (const Point<dim>   &p,
                                    const unsigned int component) const
   {
-    if (selected==no_component || component==selected)
+    if (this->selected==CutOffFunctionBase<dim>::no_component
+       ||
+       component==this->selected)
       {
-       const double d = center.distance(p);
-       const double r = radius;
+       const double d = this->center.distance(p);
+       const double r = this->radius;
        if (d>=r)
          return 0.;
        const double e = -r*r/(r*r-d*d);
@@ -242,12 +254,14 @@ namespace Functions
     Assert (values.size() == points.size(),
            ExcDimensionMismatch(values.size(), points.size()));
     
-    const double r = radius;
+    const double r = this->radius;
 
-    if (selected==no_component || component==selected)
-      for (unsigned int i=0;i<values.size();++i)
+    if (this->selected==CutOffFunctionBase<dim>::no_component
+       ||
+       component==this->selected)
+      for (unsigned int i=0; i<values.size();++i)
        {
-         const double d = center.distance(points[i]);
+         const double d = this->center.distance(points[i]);
          if (d>=r)
            {
              values[i] = 0.;
@@ -272,23 +286,23 @@ namespace Functions
 
     for (unsigned int k=0;k<values.size();++k)
       {
-       const double d = center.distance(points[k]);
-       const double r = radius;
+       const double d = this->center.distance(points[k]);
+       const double r = this->radius;
        double e = 0.;
        double val = 0.;
-       if (d<radius)
+       if (d<this->radius)
          {
            e = -r*r/(r*r-d*d);
            if (e>-50)
              val = M_E * exp(e);
          }
 
-       if (selected==no_component)
+       if (this->selected==CutOffFunctionBase<dim>::no_component)
          values[k] = val;
        else
          {
            values[k].clear ();
-           values[k](selected) = val;
+           values[k](this->selected) = val;
          }
       }
   }
@@ -300,14 +314,14 @@ namespace Functions
   CutOffFunctionCinfty<dim>::gradient (const Point<dim>   &p,
                                       const unsigned int) const
   {
-    const double d = center.distance(p);
-    const double r = radius;
+    const double d = this->center.distance(p);
+    const double r = this->radius;
     if (d>=r)
       return Tensor<1,dim>();
     const double e = -d*d/(r-d)/(r+d);
     return  ((e<-50) ?
             Point<dim>() :
-            (p-center)/d*(-2.0*r*r/pow(-r*r+d*d,2.0)*d*exp(e)));
+            (p-this->center)/d*(-2.0*r*r/pow(-r*r+d*d,2.0)*d*exp(e)));
   }
   
 
index 71da6368c94452666060141206debdd649c1fb11..cdfae8341f226d8fec5eed6b132c9e85873c432d 100644 (file)
@@ -744,10 +744,12 @@ QIterated<1>::QIterated (const Quadrature<1> &base_quadrature,
       for (unsigned int copy=0; copy<n_copies; ++copy)
        for (unsigned int q_point=0; q_point<base_quadrature.n_quadrature_points; ++q_point)
          {
-           quadrature_points[next_point] = Point<1>(base_quadrature.point(q_point)(0) / n_copies
-                                                    +
-                                                    (1.0*copy)/n_copies);
-           weights[next_point]           = base_quadrature.weight(q_point) / n_copies;
+           this->quadrature_points[next_point]
+             = Point<1>(base_quadrature.point(q_point)(0) / n_copies
+                        +
+                        (1.0*copy)/n_copies);
+           this->weights[next_point]
+             = base_quadrature.weight(q_point) / n_copies;
 
            ++next_point;
          };
@@ -793,9 +795,10 @@ QIterated<1>::QIterated (const Quadrature<1> &base_quadrature,
                (base_quadrature.point(q_point) == Point<1>(0.0)))
              continue;
            
-           quadrature_points[next_point] = Point<1>(base_quadrature.point(q_point)(0) / n_copies
-                                                    +
-                                                    (1.0*copy)/n_copies);
+           this->quadrature_points[next_point]
+             = Point<1>(base_quadrature.point(q_point)(0) / n_copies
+                        +
+                        (1.0*copy)/n_copies);
 
                                             // if this is the
                                             // rightmost point of one
@@ -804,9 +807,10 @@ QIterated<1>::QIterated (const Quadrature<1> &base_quadrature,
                                             // double weight
            if ((copy != n_copies-1) &&
                (base_quadrature.point(q_point) == Point<1>(1.0)))
-             weights[next_point] = double_point_weight;
+             this->weights[next_point] = double_point_weight;
            else
-             weights[next_point] = base_quadrature.weight(q_point) / n_copies;
+             this->weights[next_point] = base_quadrature.weight(q_point) /
+                                         n_copies;
            
            ++next_point;
          };
@@ -814,8 +818,8 @@ QIterated<1>::QIterated (const Quadrature<1> &base_quadrature,
 
 #if DEBUG
   double sum_of_weights = 0;
-  for (unsigned int i=0; i<n_quadrature_points; ++i)
-    sum_of_weights += weight(i);
+  for (unsigned int i=0; i<this->n_quadrature_points; ++i)
+    sum_of_weights += this->weight(i);
   Assert (std::fabs(sum_of_weights-1) < 1e-15,
          ExcSumOfWeightsNotOne());
 #endif
index 9e1950e1fe396a017c9abc3ad82a00541b2e99af..b2c0847144135a683b385c5d4e9044942af5ee9e 100644 (file)
@@ -62,12 +62,12 @@ QGauss<1>::QGauss (const unsigned int n)
       while (abs(p1/pp) > 1.e-19);
 
       double x = .5*z;
-      quadrature_points[i-1] = Point<1>(.5-x);
-      quadrature_points[n-i] = Point<1>(.5+x);
+      this->quadrature_points[i-1] = Point<1>(.5-x);
+      this->quadrature_points[n-i] = Point<1>(.5+x);
       
       double w = 1./((1.-z*z)*pp*pp);
-      weights[i-1] = w;
-      weights[n-i] = w;
+      this->weights[i-1] = w;
+      this->weights[n-i] = w;
     }
 }
 
@@ -88,10 +88,10 @@ QGauss2<1>::QGauss2 () :
   static const double wts[]  = { wts_normal[0]/2.,
                                 wts_normal[1]/2.  };
 
-  for (unsigned int i=0; i<n_quadrature_points; ++i) 
+  for (unsigned int i=0; i<this->n_quadrature_points; ++i) 
     {
-      quadrature_points[i] = Point<1>(xpts[i]);
-      weights[i] = wts[i];
+      this->quadrature_points[i] = Point<1>(xpts[i]);
+      this->weights[i] = wts[i];
     };
 };
 
@@ -117,10 +117,10 @@ QGauss3<1>::QGauss3 () :
                                 wts_normal[1]/2.,
                                 wts_normal[2]/2. };
 
-  for (unsigned int i=0; i<n_quadrature_points; ++i) 
+  for (unsigned int i=0; i<this->n_quadrature_points; ++i) 
     {
-      quadrature_points[i] = Point<1>(xpts[i]);
-      weights[i] = wts[i];
+      this->quadrature_points[i] = Point<1>(xpts[i]);
+      this->weights[i] = wts[i];
     };
 };
 
@@ -150,10 +150,10 @@ QGauss4<1>::QGauss4 () :
                                 wts_normal[2]/2.,
                                 wts_normal[3]/2. };
 
-  for (unsigned int i=0; i<n_quadrature_points; ++i) 
+  for (unsigned int i=0; i<this->n_quadrature_points; ++i) 
     {
-      quadrature_points[i] = Point<1>(xpts[i]);
-      weights[i] = wts[i];
+      this->quadrature_points[i] = Point<1>(xpts[i]);
+      this->weights[i] = wts[i];
     };
 };
 
@@ -187,10 +187,10 @@ QGauss5<1>::QGauss5 () :
                                 wts_normal[3]/2.,
                                 wts_normal[4]/2. };
 
-  for (unsigned int i=0; i<n_quadrature_points; ++i) 
+  for (unsigned int i=0; i<this->n_quadrature_points; ++i) 
     {
-      quadrature_points[i] = Point<1>(xpts[i]);
-      weights[i] = wts[i];
+      this->quadrature_points[i] = Point<1>(xpts[i]);
+      this->weights[i] = wts[i];
     };
 };
 
@@ -228,10 +228,10 @@ QGauss6<1>::QGauss6 () :
                                 wts_normal[4]/2.,
                                 wts_normal[5]/2. };
 
-  for (unsigned int i=0; i<n_quadrature_points; ++i) 
+  for (unsigned int i=0; i<this->n_quadrature_points; ++i) 
     {
-      quadrature_points[i] = Point<1>(xpts[i]);
-      weights[i] = wts[i];
+      this->quadrature_points[i] = Point<1>(xpts[i]);
+      this->weights[i] = wts[i];
     };
 };
 
@@ -273,10 +273,10 @@ QGauss7<1>::QGauss7 () :
                                 wts_normal[5]/2.,
                                 wts_normal[6]/2. };
 
-  for (unsigned int i=0; i<n_quadrature_points; ++i) 
+  for (unsigned int i=0; i<this->n_quadrature_points; ++i) 
     {
-      quadrature_points[i] = Point<1>(xpts[i]);
-      weights[i] = wts[i];
+      this->quadrature_points[i] = Point<1>(xpts[i]);
+      this->weights[i] = wts[i];
     };
 };
 
@@ -286,8 +286,8 @@ template <>
 QMidpoint<1>::QMidpoint () :
                Quadrature<1>(1)
 {
-  quadrature_points[0] = Point<1>(0.5);
-  weights[0] = 1.0;
+  this->quadrature_points[0] = Point<1>(0.5);
+  this->weights[0] = 1.0;
 };
 
 
@@ -298,10 +298,10 @@ QTrapez<1>::QTrapez () :
   static const double xpts[] = { 0.0, 1.0 };
   static const double wts[]  = { 0.5, 0.5 };
 
-  for (unsigned int i=0; i<n_quadrature_points; ++i) 
+  for (unsigned int i=0; i<this->n_quadrature_points; ++i) 
     {
-      quadrature_points[i] = Point<1>(xpts[i]);
-      weights[i] = wts[i];
+      this->quadrature_points[i] = Point<1>(xpts[i]);
+      this->weights[i] = wts[i];
     };
 };
 
@@ -313,10 +313,10 @@ QSimpson<1>::QSimpson () :
   static const double xpts[] = { 0.0, 0.5, 1.0 };
   static const double wts[]  = { 1./6., 2./3., 1./6. };
 
-  for (unsigned int i=0; i<n_quadrature_points; ++i) 
+  for (unsigned int i=0; i<this->n_quadrature_points; ++i) 
     {
-      quadrature_points[i] = Point<1>(xpts[i]);
-      weights[i] = wts[i];
+      this->quadrature_points[i] = Point<1>(xpts[i]);
+      this->weights[i] = wts[i];
     };
 };
 
@@ -328,10 +328,10 @@ QMilne<1>::QMilne () :
   static const double xpts[] = { 0.0, .25, .5, .75, 1.0 };
   static const double wts[]  = { 7./90., 32./90., 12./90., 32./90., 7./90. };
 
-  for (unsigned int i=0; i<n_quadrature_points; ++i) 
+  for (unsigned int i=0; i<this->n_quadrature_points; ++i) 
     {
-      quadrature_points[i] = Point<1>(xpts[i]);
-      weights[i] = wts[i];
+      this->quadrature_points[i] = Point<1>(xpts[i]);
+      this->weights[i] = wts[i];
     };
 };
 
@@ -345,10 +345,10 @@ QWeddle<1>::QWeddle () :
                                 27./840., 216./840., 41./840.
   };
 
-  for (unsigned int i=0; i<n_quadrature_points; ++i) 
+  for (unsigned int i=0; i<this->n_quadrature_points; ++i) 
     {
-      quadrature_points[i] = Point<1>(xpts[i]);
-      weights[i] = wts[i];
+      this->quadrature_points[i] = Point<1>(xpts[i]);
+      this->weights[i] = wts[i];
     };
 };
 
index 558f1626f080dfe0da64199bda31a65ef1220776..65f7ca249eafba47e0a89c3743665fe22065b242 100644 (file)
@@ -68,7 +68,7 @@ inline
 DoFAccessor<dim> &
 DoFAccessor<dim>::operator = (const DoFAccessor<dim> &da)
 {
-  set_dof_handler (da.dof_handler);
+  this->set_dof_handler (da.dof_handler);
   return *this;
 };
 
@@ -93,15 +93,15 @@ DoFObjectAccessor<1,dim>::dof_index (const unsigned int i) const
                                   // qualified exception names
   typedef DoFAccessor<dim> BaseClass;
   
-  Assert (dof_handler != 0, typename BaseClass::ExcInvalidObject());
+  Assert (this->dof_handler != 0, typename BaseClass::ExcInvalidObject());
                                   // make sure a FE has been selected
                                   // and enough room was reserved
-  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));
+  Assert (this->dof_handler->selected_fe != 0, typename BaseClass::ExcInvalidObject());
+  Assert (i<this->dof_handler->selected_fe->dofs_per_line,
+         ExcIndexRange (i, 0, this->dof_handler->selected_fe->dofs_per_line));
 
-  return dof_handler->levels[present_level]
-    ->line_dofs[present_index*dof_handler->selected_fe->dofs_per_line+i];
+  return this->dof_handler->levels[this->present_level]
+    ->line_dofs[this->present_index*this->dof_handler->selected_fe->dofs_per_line+i];
 };
 
 
@@ -122,16 +122,16 @@ DoFObjectAccessor<1,dim>::vertex_dof_index (const unsigned int vertex,
                                   // qualified exception names
   typedef DoFAccessor<dim> BaseClass;
   
-  Assert (dof_handler != 0, typename BaseClass::ExcInvalidObject());
-  Assert (dof_handler->selected_fe != 0, typename BaseClass::ExcInvalidObject());
+  Assert (this->dof_handler != 0, typename BaseClass::ExcInvalidObject());
+  Assert (this->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));
+  Assert (i<this->dof_handler->selected_fe->dofs_per_vertex,
+         ExcIndexRange (i, 0, this->dof_handler->selected_fe->dofs_per_vertex));
 
-  const unsigned int dof_number = (vertex_index(vertex) *
-                                  dof_handler->selected_fe->dofs_per_vertex +
+  const unsigned int dof_number = (this->vertex_index(vertex) *
+                                  this->dof_handler->selected_fe->dofs_per_vertex +
                                   i);
-  return dof_handler->vertex_dofs[dof_number];
+  return this->dof_handler->vertex_dofs[dof_number];
 };
 
 
@@ -151,14 +151,14 @@ DoFObjectAccessor<1,dim>::get_dof_indices (std::vector<unsigned int> &dof_indice
                                   // 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),
+  Assert (this->dof_handler != 0, typename BaseClass::ExcInvalidObject());
+  Assert (this->dof_handler->selected_fe != 0, typename BaseClass::ExcInvalidObject());
+  Assert (dof_indices.size() == (2*this->dof_handler->get_fe().dofs_per_vertex +
+                                this->dof_handler->get_fe().dofs_per_line),
          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;
+  const unsigned int dofs_per_vertex = this->dof_handler->get_fe().dofs_per_vertex,
+                    dofs_per_line   = this->dof_handler->get_fe().dofs_per_line;
   std::vector<unsigned int>::iterator next = dof_indices.begin();
   for (unsigned int vertex=0; vertex<2; ++vertex)
     for (unsigned int d=0; d<dofs_per_vertex; ++d)
@@ -173,10 +173,10 @@ inline
 TriaIterator<dim,DoFObjectAccessor<1,dim> >
 DoFObjectAccessor<1,dim>::child (const unsigned int i) const
 {
-  TriaIterator<dim,DoFObjectAccessor<1,dim> > q (tria,
-                                                present_level+1,
-                                                child_index (i),
-                                                dof_handler);
+  TriaIterator<dim,DoFObjectAccessor<1,dim> > q (this->tria,
+                                                this->present_level+1,
+                                                this->child_index (i),
+                                                this->dof_handler);
   
 #ifdef DEBUG
   if (q.state() != IteratorState::past_the_end)
@@ -192,7 +192,7 @@ void
 DoFObjectAccessor<1,dim>::copy_from (const DoFObjectAccessor<1,dim> &a)
 {
   BaseClass::copy_from (a);
-  set_dof_handler (a.dof_handler);
+  this->set_dof_handler (a.dof_handler);
 };
 
 
@@ -202,17 +202,17 @@ template <int dim>
 inline
 unsigned int DoFObjectAccessor<2,dim>::dof_index (const unsigned int i) const
 {
-  Assert (dof_handler != 0,
+  Assert (this->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,
+  Assert (this->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));
+  Assert (i<this->dof_handler->selected_fe->dofs_per_quad,
+         ExcIndexRange (i, 0, this->dof_handler->selected_fe->dofs_per_quad));
 
-  return dof_handler->levels[present_level]
-    ->quad_dofs[present_index*dof_handler->selected_fe->dofs_per_quad+i];
+  return this->dof_handler->levels[this->present_level]
+    ->quad_dofs[this->present_index*this->dof_handler->selected_fe->dofs_per_quad+i];
 };
 
 
@@ -222,18 +222,18 @@ unsigned int
 DoFObjectAccessor<2,dim>::vertex_dof_index (const unsigned int vertex,
                                            const unsigned int i) const
 {
-  Assert (dof_handler != 0,
+  Assert (this->dof_handler != 0,
          typename DoFAccessor<dim>::ExcInvalidObject());
-  Assert (dof_handler->selected_fe != 0,
+  Assert (this->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));
+  Assert (i<this->dof_handler->selected_fe->dofs_per_vertex,
+         ExcIndexRange (i, 0, this->dof_handler->selected_fe->dofs_per_vertex));
 
-  const unsigned int dof_number = (vertex_index(vertex) *
-                                  dof_handler->selected_fe->dofs_per_vertex +
+  const unsigned int dof_number = (this->vertex_index(vertex) *
+                                  this->dof_handler->selected_fe->dofs_per_vertex +
                                   i);
-  return dof_handler->vertex_dofs[dof_number];
+  return this->dof_handler->vertex_dofs[dof_number];
 };
 
 
@@ -248,18 +248,18 @@ inline
 void
 DoFObjectAccessor<2,dim>::get_dof_indices (std::vector<unsigned int> &dof_indices) const
 {
-  Assert (dof_handler != 0,
+  Assert (this->dof_handler != 0,
          typename DoFAccessor<dim>::ExcInvalidObject());
-  Assert (dof_handler->selected_fe != 0,
+  Assert (this->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),
+  Assert (dof_indices.size() == (4*this->dof_handler->get_fe().dofs_per_vertex +
+                                4*this->dof_handler->get_fe().dofs_per_line +
+                                this->dof_handler->get_fe().dofs_per_quad),
          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,
-                    dofs_per_quad   = dof_handler->get_fe().dofs_per_quad;
+  const unsigned int dofs_per_vertex = this->dof_handler->get_fe().dofs_per_vertex,
+                    dofs_per_line   = this->dof_handler->get_fe().dofs_per_line,
+                    dofs_per_quad   = this->dof_handler->get_fe().dofs_per_quad;
   std::vector<unsigned int>::iterator next = dof_indices.begin();
   for (unsigned int vertex=0; vertex<4; ++vertex)
     for (unsigned int d=0; d<dofs_per_vertex; ++d)
@@ -281,10 +281,10 @@ DoFObjectAccessor<2,dim>::line (const unsigned int i) const
 
   return TriaIterator<dim,DoFObjectAccessor<1,dim> >
     (
-      tria,
-      present_level,
-      line_index (i),
-      dof_handler
+      this->tria,
+      this->present_level,
+      this->line_index (i),
+      this->dof_handler
     );
 };
 
@@ -294,10 +294,10 @@ inline
 TriaIterator<dim,DoFObjectAccessor<2,dim> >
 DoFObjectAccessor<2,dim>::child (const unsigned int i) const
 {
-  TriaIterator<dim,DoFObjectAccessor<2,dim> > q (tria,
-                                                present_level+1,
-                                                child_index (i),
-                                                dof_handler);
+  TriaIterator<dim,DoFObjectAccessor<2,dim> > q (this->tria,
+                                                this->present_level+1,
+                                                this->child_index (i),
+                                                this->dof_handler);
   
 #ifdef DEBUG
   if (q.state() != IteratorState::past_the_end)
@@ -313,7 +313,7 @@ void
 DoFObjectAccessor<2,dim>::copy_from (const DoFObjectAccessor<2,dim> &a)
 {
   BaseClass::copy_from (a);
-  set_dof_handler (a.dof_handler);
+  this->set_dof_handler (a.dof_handler);
 };
 
 
@@ -325,17 +325,17 @@ inline
 unsigned int
 DoFObjectAccessor<3,dim>::dof_index (const unsigned int i) const
 {
-  Assert (dof_handler != 0,
+  Assert (this->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,
+  Assert (this->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));
+  Assert (i<this->dof_handler->selected_fe->dofs_per_hex,
+         ExcIndexRange (i, 0, this->dof_handler->selected_fe->dofs_per_hex));
 
-  return dof_handler->levels[present_level]
-    ->hex_dofs[present_index*dof_handler->selected_fe->dofs_per_hex+i];
+  return this->dof_handler->levels[this->present_level]
+    ->hex_dofs[this->present_index*this->dof_handler->selected_fe->dofs_per_hex+i];
 };
 
 
@@ -345,18 +345,18 @@ unsigned int
 DoFObjectAccessor<3,dim>::vertex_dof_index (const unsigned int vertex,
                                            const unsigned int i) const
 {
-  Assert (dof_handler != 0,
+  Assert (this->dof_handler != 0,
          typename DoFAccessor<dim>::ExcInvalidObject());
-  Assert (dof_handler->selected_fe != 0,
+  Assert (this->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));
+  Assert (i<this->dof_handler->selected_fe->dofs_per_vertex,
+         ExcIndexRange (i, 0, this->dof_handler->selected_fe->dofs_per_vertex));
 
-  const unsigned int dof_number = (vertex_index(vertex) *
-                                  dof_handler->selected_fe->dofs_per_vertex +
+  const unsigned int dof_number = (this->vertex_index(vertex) *
+                                  this->dof_handler->selected_fe->dofs_per_vertex +
                                   i);
-  return dof_handler->vertex_dofs[dof_number];
+  return this->dof_handler->vertex_dofs[dof_number];
 };
 
 
@@ -365,20 +365,20 @@ inline
 void
 DoFObjectAccessor<3,dim>::get_dof_indices (std::vector<unsigned int> &dof_indices) const
 {
-  Assert (dof_handler != 0,
+  Assert (this->dof_handler != 0,
          typename DoFAccessor<dim>::ExcInvalidObject());
-  Assert (dof_handler->selected_fe != 0,
+  Assert (this->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),
+  Assert (dof_indices.size() == (8*this->dof_handler->get_fe().dofs_per_vertex +
+                                12*this->dof_handler->get_fe().dofs_per_line +
+                                6*this->dof_handler->get_fe().dofs_per_quad +
+                                this->dof_handler->get_fe().dofs_per_hex),
          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,
-                    dofs_per_quad   = dof_handler->get_fe().dofs_per_quad,
-                    dofs_per_hex    = dof_handler->get_fe().dofs_per_hex;
+  const unsigned int dofs_per_vertex = this->dof_handler->get_fe().dofs_per_vertex,
+                    dofs_per_line   = this->dof_handler->get_fe().dofs_per_line,
+                    dofs_per_quad   = this->dof_handler->get_fe().dofs_per_quad,
+                    dofs_per_hex    = this->dof_handler->get_fe().dofs_per_hex;
   std::vector<unsigned int>::iterator next = dof_indices.begin();
   for (unsigned int vertex=0; vertex<8; ++vertex)
     for (unsigned int d=0; d<dofs_per_vertex; ++d)
@@ -402,10 +402,10 @@ DoFObjectAccessor<3,dim>::line (const unsigned int i) const
   TriaIterator<dim,TriaObjectAccessor<1,dim> > l = BaseClass::line(i);
   return TriaIterator<dim,DoFObjectAccessor<1,dim> >
     (
-      tria,
-      present_level,
+      this->tria,
+      this->present_level,
       l->index(),
-      dof_handler
+      this->dof_handler
     );
 };
 
@@ -419,10 +419,10 @@ DoFObjectAccessor<3,dim>::quad (const unsigned int i) const
 
   return TriaIterator<dim,DoFObjectAccessor<2,dim> >
     (
-      tria,
-      present_level,
-      quad_index (i),
-      dof_handler
+      this->tria,
+      this->present_level,
+      this->quad_index (i),
+      this->dof_handler
     );
 };
 
@@ -432,10 +432,10 @@ inline
 TriaIterator<dim,DoFObjectAccessor<3,dim> >
 DoFObjectAccessor<3,dim>::child (const unsigned int i) const
 {
-  TriaIterator<dim,DoFObjectAccessor<3,dim> > q (tria,
-                                                present_level+1,
-                                                child_index (i),
-                                                dof_handler);
+  TriaIterator<dim,DoFObjectAccessor<3,dim> > q (this->tria,
+                                                this->present_level+1,
+                                                this->child_index (i),
+                                                this->dof_handler);
   
 #ifdef DEBUG
   if (q.state() != IteratorState::past_the_end)
@@ -449,7 +449,7 @@ template <int dim>
 void DoFObjectAccessor<3,dim>::copy_from (const DoFObjectAccessor<3,dim> &a)
 {
   BaseClass::copy_from (a);
-  set_dof_handler (a.dof_handler);
+  this->set_dof_handler (a.dof_handler);
 };
 
 
@@ -461,10 +461,10 @@ inline
 TriaIterator<dim,DoFCellAccessor<dim> >
 DoFCellAccessor<dim>::neighbor (const unsigned int i) const
 {
-  TriaIterator<dim,DoFCellAccessor<dim> > q (tria,
-                                            neighbor_level (i),
-                                            neighbor_index (i),
-                                            dof_handler);
+  TriaIterator<dim,DoFCellAccessor<dim> > q (this->tria,
+                                            this->neighbor_level (i),
+                                            this->neighbor_index (i),
+                                            this->dof_handler);
   
 #ifdef DEBUG
   if (q.state() != IteratorState::past_the_end)
@@ -479,10 +479,10 @@ inline
 TriaIterator<dim,DoFCellAccessor<dim> >
 DoFCellAccessor<dim>::child (const unsigned int i) const
 {
-  TriaIterator<dim,DoFCellAccessor<dim> > q (tria,
-                                            present_level+1,
-                                            child_index (i),
-                                            dof_handler);
+  TriaIterator<dim,DoFCellAccessor<dim> > q (this->tria,
+                                            this->present_level+1,
+                                            this->child_index (i),
+                                            this->dof_handler);
   
 #ifdef DEBUG
   if (q.state() != IteratorState::past_the_end)
index e5d17ed87d85dd490ff21ff919395a20c646a894..802d7b7c8ce541a24c6244ebe5c5195b123c6cc1 100644 (file)
@@ -117,9 +117,9 @@ inline
 bool
 TriaObjectAccessor<1,dim>::used () const
 {
-  Assert (state() == IteratorState::valid,
+  Assert (this->state() == IteratorState::valid,
          typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
-  return tria->levels[present_level]->lines.used[present_index];
+  return this->tria->levels[this->present_level]->lines.used[this->present_index];
 };
 
 
@@ -129,8 +129,8 @@ inline
 bool
 TriaObjectAccessor<1,dim>::user_flag_set () const
 {
-  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
-  return tria->levels[present_level]->lines.user_flags[present_index];
+  Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
+  return this->tria->levels[this->present_level]->lines.user_flags[this->present_index];
 };
 
 
@@ -140,8 +140,8 @@ inline
 void
 TriaObjectAccessor<1,dim>::set_user_flag () const
 {
-  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
-  tria->levels[present_level]->lines.user_flags[present_index] = true;
+  Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
+  this->tria->levels[this->present_level]->lines.user_flags[this->present_index] = true;
 };
 
 
@@ -151,8 +151,8 @@ inline
 void
 TriaObjectAccessor<1,dim>::clear_user_flag () const
 {
-  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
-  tria->levels[present_level]->lines.user_flags[present_index] = false;
+  Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
+  this->tria->levels[this->present_level]->lines.user_flags[this->present_index] = false;
 };
 
 
@@ -165,7 +165,7 @@ TriaObjectAccessor<1,dim>::child (const unsigned int i) const
   Assert (i<2, ExcIndexRange(i,0,2));
   
   TriaIterator<dim,TriaObjectAccessor<1,dim> >
-    q (tria, present_level+1, child_index (i));
+    q (tria, this->present_level+1, child_index (i));
   
   Assert ((q.state() == IteratorState::past_the_end) || q->used(),
          typename TriaAccessor<dim>::ExcUnusedCellAsChild());
@@ -181,7 +181,7 @@ int
 TriaObjectAccessor<1,dim>::child_index (unsigned const int i) const
 {
   Assert (i<2, ExcIndexRange(i,0,2));
-  return tria->levels[present_level]->lines.children[present_index]+i;
+  return this->tria->levels[this->present_level]->lines.children[this->present_index]+i;
 };
 
 
@@ -191,9 +191,9 @@ inline
 bool
 TriaObjectAccessor<1,dim>::has_children () const
 {
-  Assert (state() == IteratorState::valid,
+  Assert (this->state() == IteratorState::valid,
          typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
-  return (tria->levels[present_level]->lines.children[present_index] != -1);
+  return (this->tria->levels[this->present_level]->lines.children[this->present_index] != -1);
 }
 
 
@@ -218,22 +218,22 @@ inline
 void
 TriaObjectAccessor<1,dim>::operator ++ ()
 {
-  ++present_index;
+  ++this->present_index;
                                   // is index still in the range of
                                   // the vector?
-  while (present_index
+  while (this->present_index
         >=
-        static_cast<int>(tria->levels[present_level]->lines.lines.size()))
+        static_cast<int>(this->tria->levels[this->present_level]->lines.lines.size()))
     {
                                       // no -> go one level up until we find
                                       // one with more than zero cells
-      ++present_level;
-      present_index = 0;
+      ++this->present_level;
+      this->present_index = 0;
                                       // highest level reached?
-      if (present_level >= static_cast<int>(tria->levels.size()))
+      if (this->present_level >= static_cast<int>(this->tria->levels.size()))
        {
                                           // return with past the end pointer
-         present_level = present_index = -1;
+         this->present_level = this->present_index = -1;
          return;
        };
     };
@@ -246,22 +246,22 @@ inline
 void
 TriaObjectAccessor<1,dim>::operator -- ()
 {
-  --present_index;
+  --this->present_index;
                                   // is index still in the range of
                                   // the vector?
-  while (present_index < 0) 
+  while (this->present_index < 0) 
     {
                                       // no -> go one level down
-      --present_level;
+      --this->present_level;
                                       // lowest level reached?
-      if (present_level == -1) 
+      if (this->present_level == -1) 
        {
                                           // return with past the end pointer
-         present_level = present_index = -1;
+         this->present_level = this->present_index = -1;
          return;
        };
                                       // else
-      present_index = tria->levels[present_level]->lines.lines.size()-1;
+      this->present_index = this->tria->levels[this->present_level]->lines.lines.size()-1;
     };
 };
 
@@ -274,9 +274,9 @@ inline
 bool
 TriaObjectAccessor<2,dim>::used () const
 {
-  Assert (state() == IteratorState::valid,
+  Assert (this->state() == IteratorState::valid,
          typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
-  return tria->levels[present_level]->quads.used[present_index];
+  return this->tria->levels[this->present_level]->quads.used[this->present_index];
 };
 
 
@@ -286,8 +286,8 @@ inline
 bool
 TriaObjectAccessor<2,dim>::user_flag_set () const
 {
-  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
-  return tria->levels[present_level]->quads.user_flags[present_index];
+  Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
+  return this->tria->levels[this->present_level]->quads.user_flags[this->present_index];
 };
 
 
@@ -297,8 +297,8 @@ inline
 void
 TriaObjectAccessor<2,dim>::set_user_flag () const
 {
-  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
-  tria->levels[present_level]->quads.user_flags[present_index] = true;
+  Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
+  this->tria->levels[this->present_level]->quads.user_flags[this->present_index] = true;
 };
 
 
@@ -308,8 +308,8 @@ inline
 void
 TriaObjectAccessor<2,dim>::clear_user_flag () const
 {
-  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
-  tria->levels[present_level]->quads.user_flags[present_index] = false;
+  Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
+  this->tria->levels[this->present_level]->quads.user_flags[this->present_index] = false;
 };
 
 
@@ -323,7 +323,7 @@ TriaObjectAccessor<2,dim>::line (const unsigned int i) const
     TriaIterator<dim,TriaObjectAccessor<1,dim> >
     (
       tria,
-      present_level,
+      this->present_level,
       line_index (i)
     );
 };
@@ -337,7 +337,7 @@ TriaObjectAccessor<2,dim>::line_index (const unsigned int i) const
 {
   Assert (i<4, ExcIndexRange(i,0,4));
 
-  return tria->levels[present_level]->quads.quads[present_index].line(i);
+  return this->tria->levels[this->present_level]->quads.quads[this->present_index].line(i);
 };
 
 
@@ -350,7 +350,7 @@ TriaObjectAccessor<2,dim>::child (const unsigned int i) const
   Assert (i<4, ExcIndexRange(i,0,4));
   
   TriaIterator<dim,TriaObjectAccessor<2,dim> >
-    q (tria, present_level+1, child_index (i));
+    q (tria, this->present_level+1, child_index (i));
   
   Assert ((q.state() == IteratorState::past_the_end) || q->used(),
          typename TriaAccessor<dim>::ExcUnusedCellAsChild());
@@ -365,7 +365,7 @@ inline
 int TriaObjectAccessor<2,dim>::child_index (const unsigned int i) const
 {
   Assert (i<4, ExcIndexRange(i,0,4));
-  return tria->levels[present_level]->quads.children[present_index]+i;
+  return this->tria->levels[this->present_level]->quads.children[this->present_index]+i;
 };
 
 
@@ -375,9 +375,9 @@ inline
 bool
 TriaObjectAccessor<2,dim>::has_children () const
 {
-  Assert (state() == IteratorState::valid,
+  Assert (this->state() == IteratorState::valid,
          typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
-  return (tria->levels[present_level]->quads.children[present_index] != -1);
+  return (this->tria->levels[this->present_level]->quads.children[this->present_index] != -1);
 };
 
 
@@ -405,21 +405,21 @@ inline
 void
 TriaObjectAccessor<2,dim>::operator ++ ()
 {
-  ++present_index;
+  ++this->present_index;
                                   // is index still in the range of
                                   // the vector?
-  while (present_index
+  while (this->present_index
         >=
-        static_cast<int>(tria->levels[present_level]->quads.quads.size()))
+        static_cast<int>(this->tria->levels[this->present_level]->quads.quads.size()))
     {
                                       // no -> go one level up
-      ++present_level;
-      present_index = 0;
+      ++this->present_level;
+      this->present_index = 0;
                                       // highest level reached?
-      if (present_level >= static_cast<int>(tria->levels.size()))
+      if (this->present_level >= static_cast<int>(this->tria->levels.size()))
        {
                                           // return with past the end pointer
-         present_level = present_index = -1;
+         this->present_level = this->present_index = -1;
          return;
        };
     };
@@ -432,22 +432,22 @@ inline
 void
 TriaObjectAccessor<2,dim>::operator -- ()
 {
-  --present_index;
+  --this->present_index;
                                   // is index still in the range of
                                   // the vector?
-  while (present_index < 0) 
+  while (this->present_index < 0) 
     {
                                       // no -> go one level down
-      --present_level;
+      --this->present_level;
                                       // lowest level reached?
-      if (present_level == -1) 
+      if (this->present_level == -1) 
        {
                                           // return with past the end pointer
-         present_level = present_index = -1;
+         this->present_level = this->present_index = -1;
          return;
        };
                                       // else
-      present_index = tria->levels[present_level]->quads.quads.size()-1;
+      this->present_index = this->tria->levels[this->present_level]->quads.quads.size()-1;
     };
 };
 
@@ -460,9 +460,9 @@ inline
 bool
 TriaObjectAccessor<3,dim>::used () const
 {
-  Assert (state() == IteratorState::valid,
+  Assert (this->state() == IteratorState::valid,
          typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
-  return tria->levels[present_level]->hexes.used[present_index];
+  return this->tria->levels[this->present_level]->hexes.used[this->present_index];
 };
 
 
@@ -472,8 +472,8 @@ inline
 bool
 TriaObjectAccessor<3,dim>::user_flag_set () const
 {
-  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
-  return tria->levels[present_level]->hexes.user_flags[present_index];
+  Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
+  return this->tria->levels[this->present_level]->hexes.user_flags[this->present_index];
 };
 
 
@@ -483,8 +483,8 @@ inline
 void
 TriaObjectAccessor<3,dim>::set_user_flag () const
 {
-  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
-  tria->levels[present_level]->hexes.user_flags[present_index] = true;
+  Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
+  this->tria->levels[this->present_level]->hexes.user_flags[this->present_index] = true;
 };
 
 
@@ -493,8 +493,8 @@ template <int dim>
 inline
 void TriaObjectAccessor<3,dim>::clear_user_flag () const
 {
-  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
-  tria->levels[present_level]->hexes.user_flags[present_index] = false;
+  Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
+  this->tria->levels[this->present_level]->hexes.user_flags[this->present_index] = false;
 };
 
 
@@ -504,7 +504,7 @@ inline
 TriaIterator<dim,TriaObjectAccessor<1,dim> >
 TriaObjectAccessor<3,dim>::line (const unsigned int i) const
 {
-  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
+  Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
   Assert (i<12, ExcIndexRange (i,0,12));
 
                                   // egcs 1.1.2 gets into trouble if we
@@ -543,12 +543,12 @@ inline
 TriaIterator<dim,TriaObjectAccessor<2,dim> >
 TriaObjectAccessor<3,dim>::quad (const unsigned int i) const
 {
-  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
+  Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
   return
     TriaIterator<dim,TriaObjectAccessor<2,dim> >
     (
       tria,
-      present_level,
+      this->present_level,
       quad_index (i)
     );
 };
@@ -592,7 +592,7 @@ TriaObjectAccessor<3,dim>::quad_index (const unsigned int i) const
 {
   Assert (i<6, ExcIndexRange(i,0,6));
 
-  return tria->levels[present_level]->hexes.hexes[present_index].quad(i);
+  return this->tria->levels[this->present_level]->hexes.hexes[this->present_index].quad(i);
 };
 
 
@@ -604,7 +604,7 @@ TriaObjectAccessor<3,dim>::child (const unsigned int i) const
 {
   Assert (i<8, ExcIndexRange(i,0,8));
   
-  TriaIterator<dim,TriaObjectAccessor<3,dim> > q (tria, present_level+1, child_index (i));
+  TriaIterator<dim,TriaObjectAccessor<3,dim> > q (tria, this->present_level+1, child_index (i));
   
   Assert ((q.state() == IteratorState::past_the_end) || q->used(),
          typename TriaAccessor<dim>::ExcUnusedCellAsChild());
@@ -619,7 +619,7 @@ inline
 int TriaObjectAccessor<3,dim>::child_index (const unsigned int i) const
 {
   Assert (i<8, ExcIndexRange(i,0,8));
-  return tria->levels[present_level]->hexes.children[present_index]+i;
+  return this->tria->levels[this->present_level]->hexes.children[this->present_index]+i;
 };
 
 
@@ -627,9 +627,9 @@ int TriaObjectAccessor<3,dim>::child_index (const unsigned int i) const
 template <int dim>
 bool TriaObjectAccessor<3,dim>::has_children () const
 {
-  Assert (state() == IteratorState::valid,
+  Assert (this->state() == IteratorState::valid,
          typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
-  return (tria->levels[present_level]->hexes.children[present_index] != -1);
+  return (this->tria->levels[this->present_level]->hexes.children[this->present_index] != -1);
 };
 
 
@@ -663,21 +663,21 @@ inline
 void
 TriaObjectAccessor<3,dim>::operator ++ ()
 {
-  ++present_index;
+  ++this->present_index;
                                   // is index still in the range of
                                   // the vector?
-  while (present_index
+  while (this->present_index
         >=
-        static_cast<int>(tria->levels[present_level]->hexes.hexes.size()))
+        static_cast<int>(this->tria->levels[this->present_level]->hexes.hexes.size()))
     {
                                       // no -> go one level up
-      ++present_level;
-      present_index = 0;
+      ++this->present_level;
+      this->present_index = 0;
                                       // highest level reached?
-      if (present_level >= static_cast<int>(tria->levels.size()))
+      if (this->present_level >= static_cast<int>(this->tria->levels.size()))
        {
                                           // return with past the end pointer
-         present_level = present_index = -1;
+         this->present_level = this->present_index = -1;
          return;
        };
     };
@@ -690,22 +690,22 @@ inline
 void
 TriaObjectAccessor<3,dim>::operator -- ()
 {
-  --present_index;
+  --this->present_index;
                                   // is index still in the range of
                                   // the vector?
-  while (present_index < 0) 
+  while (this->present_index < 0) 
     {
                                       // no -> go one level down
-      --present_level;
+      --this->present_level;
                                       // lowest level reached?
-      if (present_level == -1) 
+      if (this->present_level == -1) 
        {
                                           // return with past the end pointer
-         present_level = present_index = -1;
+         this->present_level = this->present_index = -1;
          return;
        };
                                       // else
-      present_index = tria->levels[present_level]->hexes.hexes.size()-1;
+      this->present_index = this->tria->levels[this->present_level]->hexes.hexes.size()-1;
     };
 };
 
@@ -718,8 +718,8 @@ inline
 bool
 TriaObjectAccessor<celldim,dim>::used () const
 {
-  Assert (state() == IteratorState::valid, ExcDereferenceInvalidObject());
-  return tria->levels[present_level]->hexes.used[present_index];
+  Assert (this->state() == IteratorState::valid, ExcDereferenceInvalidObject());
+  return this->tria->levels[this->present_level]->hexes.used[this->present_index];
 };
 
 
@@ -729,8 +729,8 @@ inline
 bool
 TriaObjectAccessor<celldim,dim>::user_flag_set () const
 {
-  Assert (used(), ExcCellNotUsed());
-  return tria->levels[present_level]->hexes.user_flags[present_index];
+  Assert (this->used(), ExcCellNotUsed());
+  return this->tria->levels[this->present_level]->hexes.user_flags[this->present_index];
 };
 
 
@@ -740,8 +740,8 @@ inline
 void
 TriaObjectAccessor<celldim,dim>::set_user_flag () const
 {
-  Assert (used(), ExcCellNotUsed());
-  tria->levels[present_level]->hexes.user_flags[present_index] = true;
+  Assert (this->used(), ExcCellNotUsed());
+  this->tria->levels[this->present_level]->hexes.user_flags[this->present_index] = true;
 };
 
 
@@ -750,8 +750,8 @@ template<int celldim, int dim>
 inline
 void TriaObjectAccessor<celldim,dim>::clear_user_flag () const
 {
-  Assert (used(), ExcCellNotUsed());
-  tria->levels[present_level]->hexes.user_flags[present_index] = false;
+  Assert (this->used(), ExcCellNotUsed());
+  this->tria->levels[this->present_level]->hexes.user_flags[this->present_index] = false;
 };
 
 
@@ -761,7 +761,7 @@ inline
 TriaIterator<dim,TriaObjectAccessor<1,dim> >
 TriaObjectAccessor<celldim,dim>::line (const unsigned int i) const
 {
-  Assert (used(), ExcCellNotUsed());
+  Assert (this->used(), ExcCellNotUsed());
   Assert (i < GeometryInfo<celldim>::lines_per_cell,
          ExcIndexRange(i,0,GeometryInfo<celldim>::lines_per_cell));
 
@@ -771,8 +771,8 @@ TriaObjectAccessor<celldim,dim>::line (const unsigned int i) const
            return
              TriaIterator<dim,TriaObjectAccessor<1,dim> >
              (
-               tria,
-               present_level,
+               this->tria,
+               this->present_level,
                line_index (i)
              );
       case 3:
@@ -798,7 +798,7 @@ TriaObjectAccessor<celldim,dim>::line (const unsigned int i) const
            Assert(false, ExcNotImplemented());
     }
   
-  return TriaIterator<dim,TriaObjectAccessor<1,dim> >(tria, -1, -1, 0);
+  return TriaIterator<dim,TriaObjectAccessor<1,dim> >(this->tria, -1, -1, 0);
 };
 
 
@@ -808,14 +808,14 @@ inline
 TriaIterator<dim,TriaObjectAccessor<2,dim> >
 TriaObjectAccessor<celldim,dim>::quad (const unsigned int i) const
 {
-  Assert (used(), ExcCellNotUsed());
+  Assert (this->used(), ExcCellNotUsed());
   Assert (i < GeometryInfo<celldim>::quads_per_cell,
          ExcIndexRange(i,0,GeometryInfo<celldim>::quads_per_cell));
   return
     TriaIterator<dim,TriaObjectAccessor<2,dim> >
     (
-      tria,
-      present_level,
+      this->tria,
+      this->present_level,
       quad_index (i)
     );
 };
@@ -833,8 +833,8 @@ TriaObjectAccessor<celldim,dim>::line_index (const unsigned int i) const
   switch(celldim)
     {
       case 2:
-           return tria->levels[present_level]
-             ->quads.quads[present_index].line(i);
+           return this->tria->levels[this->present_level]
+             ->quads.quads[this->present_index].line(i);
       case 3:
            if (i<4)
              return quad(0)->line_index(i);
@@ -870,7 +870,7 @@ TriaObjectAccessor<celldim,dim>::quad_index (const unsigned int i) const
   Assert (i < GeometryInfo<celldim>::quads_per_cell,
          ExcIndexRange(i,0,GeometryInfo<celldim>::quads_per_cell));
 
-  return tria->levels[present_level]->hexes.hexes[present_index].quad(i);
+  return this->tria->levels[this->present_level]->hexes.hexes[this->present_index].quad(i);
 };
 
 
@@ -884,7 +884,7 @@ TriaObjectAccessor<celldim,dim>::child (const unsigned int i) const
          ExcIndexRange(i,0,GeometryInfo<celldim>::children_per_cell));
   
   TriaIterator<dim,TriaObjectAccessor<celldim,dim> >
-    q (tria, present_level+1, child_index (i));
+    q (this->tria, this->present_level+1, child_index (i));
   
   Assert ((q.state() == IteratorState::past_the_end) || q->used(),
          ExcUnusedCellAsChild());
@@ -900,7 +900,7 @@ int TriaObjectAccessor<celldim,dim>::child_index (const unsigned int i) const
 {
   Assert (i < GeometryInfo<celldim>::children_per_cell,
          ExcIndexRange(i,0,GeometryInfo<celldim>::children_per_cell));
-  return tria->levels[present_level]->hexes.children[present_index]+i;
+  return this->tria->levels[this->present_level]->hexes.children[this->present_index]+i;
 };
 
 
@@ -908,9 +908,9 @@ int TriaObjectAccessor<celldim,dim>::child_index (const unsigned int i) const
 template<int celldim, int dim>
 bool TriaObjectAccessor<celldim,dim>::has_children () const
 {
-  Assert (state() == IteratorState::valid,
+  Assert (this->state() == IteratorState::valid,
          typename TriaAccessor<dim>::ExcDereferenceInvalidObject());
-  return (tria->levels[present_level]->hexes.children[present_index] != -1);
+  return (this->tria->levels[this->present_level]->hexes.children[this->present_index] != -1);
 };
 
 
@@ -931,10 +931,10 @@ TriaObjectAccessor<celldim,dim>::max_refinement_depth () const
                                   child(5)->max_refinement_depth() + 1,
                                   child(6)->max_refinement_depth() + 1,
                                   child(7)->max_refinement_depth() + 1  };
-  return max (max (max (depths[0], depths[1]),
-                  max (depths[2], depths[3])),
-             max (max (depths[4], depths[5]),
-                  max (depths[6], depths[7])));
+  return std::max (std::max (std::max (depths[0], depths[1]),
+                            std::max (depths[2], depths[3])),
+                  std::max (std::max (depths[4], depths[5]),
+                            std::max (depths[6], depths[7])));
 };
 
 
@@ -944,21 +944,21 @@ inline
 void
 TriaObjectAccessor<celldim,dim>::operator ++ ()
 {
-  ++present_index;
+  ++this->present_index;
                                   // is index still in the range of
                                   // the vector?
-  while (present_index
+  while (this->present_index
         >=
-        static_cast<int>(tria->levels[present_level]->hexes.hexes.size()))
+        static_cast<int>(this->tria->levels[this->present_level]->hexes.hexes.size()))
     {
                                       // no -> go one level up
-      ++present_level;
-      present_index = 0;
+      ++this->present_level;
+      this->present_index = 0;
                                       // highest level reached?
-      if (present_level >= static_cast<int>(tria->levels.size()))
+      if (this->present_level >= static_cast<int>(this->tria->levels.size()))
        {
                                           // return with past the end pointer
-         present_level = present_index = -1;
+         this->present_level = this->present_index = -1;
          return;
        };
     };
@@ -971,22 +971,22 @@ inline
 void
 TriaObjectAccessor<celldim,dim>::operator -- ()
 {
-  --present_index;
+  --this->present_index;
                                   // is index still in the range of
                                   // the vector?
-  while (present_index < 0) 
+  while (this->present_index < 0) 
     {
                                       // no -> go one level down
-      --present_level;
+      --this->present_level;
                                       // lowest level reached?
-      if (present_level == -1) 
+      if (this->present_level == -1) 
        {
                                           // return with past the end pointer
-         present_level = present_index = -1;
+         this->present_level = this->present_index = -1;
          return;
        };
                                       // else
-      present_index = tria->levels[present_level]->hexes.hexes.size()-1;
+      this->present_index = this->tria->levels[this->present_level]->hexes.hexes.size()-1;
     };
 };
 
@@ -1010,7 +1010,7 @@ inline
 Triangulation<2>::face_iterator
 CellAccessor<2>::face (const unsigned int i) const 
 {
-  return line(i);
+  return this->line(i);
 };
 
 
@@ -1032,8 +1032,8 @@ CellAccessor<dim>::neighbor_index (const unsigned int i) const
 {
   Assert (i<GeometryInfo<dim>::faces_per_cell,
          typename TriaAccessor<dim>::ExcInvalidNeighbor(i));
-  return tria->levels[present_level]->
-    neighbors[present_index*GeometryInfo<dim>::faces_per_cell+i].second;
+  return this->tria->levels[this->present_level]->
+    neighbors[this->present_index*GeometryInfo<dim>::faces_per_cell+i].second;
 };
 
 
@@ -1045,8 +1045,8 @@ CellAccessor<dim>::neighbor_level (const unsigned int i) const
 {
   Assert (i<GeometryInfo<dim>::faces_per_cell,
          typename TriaAccessor<dim>::ExcInvalidNeighbor(i));
-  return tria->levels[present_level]->
-    neighbors[present_index*GeometryInfo<dim>::faces_per_cell+i].first;
+  return this->tria->levels[this->present_level]->
+    neighbors[this->present_index*GeometryInfo<dim>::faces_per_cell+i].first;
 };
 
 
@@ -1056,15 +1056,15 @@ inline
 bool
 CellAccessor<dim>::refine_flag_set () const
 {
-  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
+  Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
                                   // cells flagged for refinement must be active
                                   // (the @p{set_refine_flag} function checks this,
                                   // but activity may change when refinement is
                                   // executed and for some reason the refine
                                   // flag is not cleared).
-  Assert (active() ||  !tria->levels[present_level]->refine_flags[present_index],
+  Assert (this->active() ||  !this->tria->levels[this->present_level]->refine_flags[this->present_index],
          ExcRefineCellNotActive());
-  return tria->levels[present_level]->refine_flags[present_index];
+  return this->tria->levels[this->present_level]->refine_flags[this->present_index];
 };
 
 
@@ -1074,11 +1074,11 @@ inline
 void
 CellAccessor<dim>::set_refine_flag () const
 {
-  Assert (used() && active(), ExcRefineCellNotActive());
+  Assert (this->used() && this->active(), ExcRefineCellNotActive());
   Assert (!coarsen_flag_set(),
          ExcCellFlaggedForCoarsening());
   
-  tria->levels[present_level]->refine_flags[present_index] = true;
+  this->tria->levels[this->present_level]->refine_flags[this->present_index] = true;
 };
 
 
@@ -1088,8 +1088,8 @@ inline
 void
 CellAccessor<dim>::clear_refine_flag () const
 {
-  Assert (used() && active(), ExcRefineCellNotActive());
-  tria->levels[present_level]->refine_flags[present_index] = false;
+  Assert (this->used() && this->active(), ExcRefineCellNotActive());
+  this->tria->levels[this->present_level]->refine_flags[this->present_index] = false;
 };
 
 
@@ -1099,15 +1099,15 @@ inline
 bool
 CellAccessor<dim>::coarsen_flag_set () const
 {
-  Assert (used(), typename TriaAccessor<dim>::ExcCellNotUsed());
+  Assert (this->used(), typename TriaAccessor<dim>::ExcCellNotUsed());
                                   // cells flagged for coarsening must be active
                                   // (the @p{set_refine_flag} function checks this,
                                   // but activity may change when refinement is
                                   // executed and for some reason the refine
                                   // flag is not cleared).
-  Assert (active() ||  !tria->levels[present_level]->coarsen_flags[present_index],
+  Assert (this->active() ||  !this->tria->levels[this->present_level]->coarsen_flags[this->present_index],
          ExcRefineCellNotActive());
-  return tria->levels[present_level]->coarsen_flags[present_index];
+  return this->tria->levels[this->present_level]->coarsen_flags[this->present_index];
 };
 
 
@@ -1117,10 +1117,10 @@ inline
 void
 CellAccessor<dim>::set_coarsen_flag () const
 {
-  Assert (used() && active(), ExcRefineCellNotActive());
+  Assert (this->used() && this->active(), ExcRefineCellNotActive());
   Assert (!refine_flag_set(), ExcCellFlaggedForRefinement());
   
-  tria->levels[present_level]->coarsen_flags[present_index] = true;
+  this->tria->levels[this->present_level]->coarsen_flags[this->present_index] = true;
 };
 
 
@@ -1130,8 +1130,8 @@ inline
 void
 CellAccessor<dim>::clear_coarsen_flag () const
 {
-  Assert (used() && active(), ExcRefineCellNotActive());
-  tria->levels[present_level]->coarsen_flags[present_index] = false;
+  Assert (this->used() && this->active(), ExcRefineCellNotActive());
+  this->tria->levels[this->present_level]->coarsen_flags[this->present_index] = false;
 };
 
 
@@ -1142,7 +1142,7 @@ TriaIterator<dim,CellAccessor<dim> >
 CellAccessor<dim>::neighbor (const unsigned int i) const
 {
   TriaIterator<dim,CellAccessor<dim> >
-    q (tria, neighbor_level (i), neighbor_index (i));
+    q (this->tria, neighbor_level (i), neighbor_index (i));
 
   Assert ((q.state() == IteratorState::past_the_end) || q->used(),
          typename TriaAccessor<dim>::ExcUnusedCellAsNeighbor());
@@ -1158,7 +1158,7 @@ TriaIterator<dim,CellAccessor<dim> >
 CellAccessor<dim>::child (const unsigned int i) const
 {
   TriaIterator<dim,CellAccessor<dim> >
-    q (tria, present_level+1, child_index (i));
+    q (this->tria, this->present_level+1, this->child_index (i));
 
   Assert ((q.state() == IteratorState::past_the_end) || q->used(),
          typename TriaAccessor<dim>::ExcUnusedCellAsChild());
@@ -1173,7 +1173,7 @@ inline
 bool
 CellAccessor<dim>::active () const
 {
-  return !has_children();
+  return !this->has_children();
 };
 
 
index 87342829438dcf4e4816802e1a732d824a41b741..2f6ad1bdd78d667ea84c657c4ba8357311ff4e48 100644 (file)
@@ -92,8 +92,8 @@ template <typename number>
 FullMatrix<number> &
 FullMatrix<number>::operator *= (const double factor)
 {
-  number       *p = &el(0,0);
-  const number *e = &el(0,0) + n()*m();
+  number       *p = &this->el(0,0);
+  const number *e = &this->el(0,0) + n()*m();
   while (p != e)
     *p++ *= factor;
 
@@ -291,7 +291,7 @@ void FullMatrix<number>::Tvmult (Vector<number2>       &dst,
        {
          number2 s = 0.;
          for (unsigned int j=0; j<size_m; ++j)
-           s += src(j) * el(j,i);
+           s += src(j) * this->el(j,i);
          dst(i) = s;
        };
     }
@@ -301,7 +301,7 @@ void FullMatrix<number>::Tvmult (Vector<number2>       &dst,
        {
          number2 s = 0.;
          for (unsigned int j=0; j<size_m; ++j)
-           s += src(j) * el(j,i);
+           s += src(j) * this->el(j,i);
          dst(i) += s;
        };
     };
@@ -327,7 +327,7 @@ double FullMatrix<number>::residual (Vector<number2>& dst,
     {
       s = right(i);
       for (unsigned int j=0; j<size_m; ++j)
-       s -= src(j) * el(i,j);
+       s -= src(j) * this->el(i,j);
       dst(i) = s;
       res += s*s;
     }
@@ -352,8 +352,8 @@ void FullMatrix<number>::forward (Vector<number2>       &dst,
   for (i=0; i<nu; ++i)
     {
       s = src(i);
-      for (j=0; j<i; ++j) s -= dst(j) * el(i,j);
-      dst(i) = s/el(i,i);
+      for (j=0; j<i; ++j) s -= dst(j) * this->el(i,j);
+      dst(i) = s/this->el(i,i);
     }
 }
 
@@ -372,8 +372,8 @@ void FullMatrix<number>::backward (Vector<number2>       &dst,
   for (int i=nu-1; i>=0; --i)
     {
       s = src(i);
-      for (j=i+1; j<nu; ++j) s -= dst(j) * el(i,j);
-      dst(i) = s/el(i,i);
+      for (j=i+1; j<nu; ++j) s -= dst(j) * this->el(i,j);
+      dst(i) = s/this->el(i,i);
     }
 }
 
@@ -390,7 +390,7 @@ void FullMatrix<number>::fill (const FullMatrix<number2> &src,
 
   for (unsigned int ii=0; ii<src.m() ; ++ii)
     for (unsigned int jj=0; jj<src.n() ; ++jj)
-      el(ii+i,jj+j) = src.el(ii,jj);
+      this->el(ii+i,jj+j) = src.el(ii,jj);
 }
 
 
@@ -400,14 +400,14 @@ void FullMatrix<number>::fill_permutation (const FullMatrix<number2> &src,
                                           const std::vector<unsigned int>& p_rows,
                                           const std::vector<unsigned int>& p_cols)
 {
-  Assert (p_rows.size() == n_rows(),
-         ExcDimensionMismatch (p_rows.size(), n_rows()));
-  Assert (p_cols.size() == n_cols(),
-         ExcDimensionMismatch (p_cols.size(), n_cols()));
-
-  for (unsigned int i=0;i<n_rows();++i)
-    for (unsigned int j=0;j<n_cols();++j)
-      el(i,j) = src(p_rows[i], p_cols[j]);
+  Assert (p_rows.size() == this->n_rows(),
+         ExcDimensionMismatch (p_rows.size(), this->n_rows()));
+  Assert (p_cols.size() == this->n_cols(),
+         ExcDimensionMismatch (p_cols.size(), this->n_cols()));
+
+  for (unsigned int i=0;i<this->n_rows();++i)
+    for (unsigned int j=0;j<this->n_cols();++j)
+      this->el(i,j) = src(p_rows[i], p_cols[j]);
 }
 
 
@@ -430,7 +430,7 @@ void FullMatrix<number>::add_row (const unsigned int i,
   Assert (this->data() != 0, ExcEmptyMatrix());
   
   for (unsigned int k=0; k<m(); ++k)
-    el(i,k) += s*el(j,k);
+    this->el(i,k) += s*this->el(j,k);
 }
 
 
@@ -445,7 +445,7 @@ void FullMatrix<number>::add_row (const unsigned int i,
   
   const unsigned int size_m = m();
   for (unsigned l=0; l<size_m; ++l)
-    el(i,l) += s*el(j,l) + t*el(k,l);
+    this->el(i,l) += s*this->el(j,l) + t*this->el(k,l);
 }
 
 
@@ -456,7 +456,7 @@ void FullMatrix<number>::add_col (const unsigned int i, const number s,
   Assert (this->data() != 0, ExcEmptyMatrix());
   
   for (unsigned int k=0; k<n(); ++k)
-    el(k,i) += s*el(k,j);
+    this->el(k,i) += s*this->el(k,j);
 }
 
 
@@ -468,7 +468,7 @@ void FullMatrix<number>::add_col (const unsigned int i, const number s,
   Assert (this->data() != 0, ExcEmptyMatrix());
   
   for (unsigned int l=0; l<n(); ++l)
-    el(l,i) += s*el(l,j) + t*el(l,k);
+    this->el(l,i) += s*this->el(l,j) + t*this->el(l,k);
 }
 
 
@@ -480,7 +480,7 @@ void FullMatrix<number>::swap_row (const unsigned int i, const unsigned int j)
   number s;
   for (unsigned int k=0; k<m(); ++k)
   {
-    s = el(i,k); el(i,k) = el(j,k); el(j,k) = s;
+    s = this->el(i,k); this->el(i,k) = this->el(j,k); this->el(j,k) = s;
   }
 }
 
@@ -493,7 +493,7 @@ void FullMatrix<number>::swap_col (const unsigned int i, const unsigned int j)
   number s;
   for (unsigned int k=0; k<n(); ++k)
   {
-    s = el(k,i); el(k,i) = el(k,j); el(k,j) = s;
+    s = this->el(k,i); this->el(k,i) = this->el(k,j); this->el(k,j) = s;
   }
 }
 
@@ -505,7 +505,7 @@ void FullMatrix<number>::diagadd (const number src)
   Assert (m() == n(), ExcDimensionMismatch(m(),n()));
   
   for (unsigned int i=0; i<n(); ++i)
-    el(i,i) += src;
+    this->el(i,i) += src;
 }
 
 
@@ -526,7 +526,7 @@ void FullMatrix<number>::mmult (FullMatrix<number2>       &dst,
        {
          number2 s = 0.;
          for (unsigned k=0; k<n(); k++)
-           s+= el(i,k) * src.el(k,j);
+           s+= this->el(i,k) * src.el(k,j);
          dst.el(i,j) = s;
        }
   else
@@ -535,7 +535,7 @@ void FullMatrix<number>::mmult (FullMatrix<number2>       &dst,
        {
          number2 s = 0.;
          for (unsigned k=0; k<n(); k++)
-           s+= el(i,k) * src.el(k,j);
+           s+= this->el(i,k) * src.el(k,j);
          dst.el(i,j) += s;
        }
 }
@@ -559,7 +559,7 @@ void FullMatrix<number>::Tmmult (FullMatrix<number2>       &dst,
        {
          number2 s = 0;
          for (unsigned int k=0; k<m(); k++)
-           s += el(k,i) * src.el(k,j);
+           s += this->el(k,i) * src.el(k,j);
          dst.el(i,j) = s;
        }
   else
@@ -568,7 +568,7 @@ void FullMatrix<number>::Tmmult (FullMatrix<number2>       &dst,
        {
          number2 s = 0;
          for (unsigned int k=0; k<m(); k++)
-           s += el(k,i) * src.el(k,j);
+           s += this->el(k,i) * src.el(k,j);
          dst.el(i,j) += s;
        }
 }
@@ -646,8 +646,8 @@ FullMatrix<number>::symmetrize ()
   for (unsigned int i=0; i<N; ++i)
     for (unsigned int j=i+1; j<N; ++j)
       {
-       const number t = (el(i,j) + el(j,i)) / 2;
-       el(i,j) = el(j,i) = t;
+       const number t = (this->el(i,j) + this->el(j,i)) / 2;
+       this->el(i,j) = this->el(j,i) = t;
       };
 };
 
@@ -664,7 +664,7 @@ number FullMatrix<number>::l1_norm () const
     {
       sum=0;
       for (unsigned int row=0; row<n_rows; ++row)
-       sum += std::fabs(el(row,col));
+       sum += std::fabs(this->el(row,col));
       if (sum > max)
        max = sum;
     }
@@ -684,7 +684,7 @@ number FullMatrix<number>::linfty_norm () const
     {
       sum=0;
       for (unsigned int col=0; col<n_cols; ++col)
-       sum += std::fabs(el(row,col));
+       sum += std::fabs(this->el(row,col));
       if (sum > max)
        max = sum;
     }
@@ -700,10 +700,10 @@ FullMatrix<number>::print (std::ostream       &s,
 {
   Assert (this->data() != 0, ExcEmptyMatrix());
   
-  for (unsigned int i=0; i<m(); ++i)
+  for (unsigned int i=0; i<this->m(); ++i)
     {
-      for (unsigned int j=0; j<n(); ++j)
-       s << std::setw(w) << std::setprecision(p) << el(i,j);
+      for (unsigned int j=0; j<this->n(); ++j)
+       s << std::setw(w) << std::setprecision(p) << this->el(i,j);
       s << std::endl;
     }
 }
@@ -1111,9 +1111,10 @@ FullMatrix<number>::determinant () const
 {
   Assert (this->data() != 0, ExcEmptyMatrix());
   
-  Assert (n_cols() == n_rows(),
-         ExcDimensionMismatch(n_cols(), n_rows()));
-  Assert ((n_cols()>=1) && (n_cols()<=3), ExcNotImplemented(n_cols()));
+  Assert (this->n_cols() == this->n_rows(),
+         ExcDimensionMismatch(this->n_cols(), this->n_rows()));
+  Assert ((this->n_cols()>=1) && (this->n_cols()<=3),
+         ExcNotImplemented(this->n_cols()));
   
   switch (this->n_cols()) 
     {
@@ -1174,11 +1175,12 @@ FullMatrix<number>::invert (const FullMatrix<number2> &M)
 {
   Assert (this->data() != 0, ExcEmptyMatrix());
   
-  Assert (n_cols() == n_rows(), ExcNotQuadratic());
-  Assert (n_cols() == M.n_cols(),
-          ExcDimensionMismatch(n_cols(),M.n_cols()));
-  Assert (n_rows() == M.n_rows(),
-         ExcDimensionMismatch(n_rows(),M.n_rows()));
+  Assert (this->n_cols() == this->n_rows(),
+         ExcNotQuadratic());
+  Assert (this->n_cols() == M.n_cols(),
+          ExcDimensionMismatch(this->n_cols(), M.n_cols()));
+  Assert (this->n_rows() == M.n_rows(),
+         ExcDimensionMismatch(this->n_rows(), M.n_rows()));
   
   switch (this->n_cols()) 
     {
@@ -1363,7 +1365,7 @@ FullMatrix<number>::print_formatted (std::ostream       &out,
 {
   unsigned int width = width_;
   
-  Assert ((this->data() != 0) || (n_cols()+n_rows()==0),
+  Assert ((this->data() != 0) || (this->n_cols()+this->n_rows()==0),
          ExcInternalError());
   
                                   // set output format, but store old
@@ -1406,7 +1408,7 @@ void
 FullMatrix<number>::gauss_jordan()
 {
   Assert (this->data() != 0, ExcEmptyMatrix());  
-  Assert (n_cols() == n_rows(), ExcNotQuadratic());
+  Assert (this->n_cols() == this->n_rows(), ExcNotQuadratic());
   
                                   // Gauss-Jordan-Algorithmus
                                   // cf. Stoer I (4th Edition) p. 153
@@ -1497,9 +1499,11 @@ FullMatrix<number>::householder(Vector<number2>& src)
 {
   Assert (this->data() != 0, ExcEmptyMatrix());
   
-  // m > n, src.n() = m
-  Assert (n_cols() <= n_rows(), ExcDimensionMismatch(n_cols(), n_rows()));
-  Assert (src.size() == n_rows(), ExcDimensionMismatch(src.size(), n_rows()));
+                                  // m > n, src.n() = m
+  Assert (this->n_cols() <= this->n_rows(),
+         ExcDimensionMismatch(this->n_cols(), this->n_rows()));
+  Assert (src.size() == this->n_rows(),
+         ExcDimensionMismatch(src.size(), this->n_rows()));
 
   for (unsigned int j=0 ; j<n() ; ++j)
   {
index 2699d3f196b454fdea038df90dfcfdcb00202ccc..85311331aa1d7408d4b9d86f3df29a6590e13cc7 100644 (file)
@@ -248,12 +248,12 @@ void PreconditionBlockJacobi<number,inverse_type>
                                   // exceptions that do not take
                                   // args...
   typedef PreconditionBlock<number,inverse_type> BaseClass;
-  Assert(A!=0, ExcNotInitialized());
+  Assert(this->A!=0, ExcNotInitialized());
   
-  const SparseMatrix<number> &M=*A;
-  const unsigned int n_cells=M.m()/blocksize;
+  const SparseMatrix<number> &M=*this->A;
+  const unsigned int n_cells=M.m()/this->blocksize;
 
-  Vector<number2> b_cell(blocksize), x_cell(blocksize);
+  Vector<number2> b_cell(this->blocksize), x_cell(this->blocksize);
 
                                       // cell_row, cell_column are the
                                       // numbering of the blocks (cells).
@@ -264,48 +264,56 @@ void PreconditionBlockJacobi<number,inverse_type>
                                       // of the unkowns.
   unsigned int row, row_cell, begin_diag_block=0;
 
-  if (!inverses_ready())
+  if (!this->inverses_ready())
     {
-      FullMatrix<number> M_cell(blocksize);
+      FullMatrix<number> M_cell(this->blocksize);
       for (unsigned int cell=0; cell<n_cells; ++cell)
        {
-         for (row=cell*blocksize, row_cell=0; row_cell<blocksize; ++row_cell, ++row)
+         for (row=cell*this->blocksize, row_cell=0;
+              row_cell<this->blocksize;
+              ++row_cell, ++row)
            {
              b_cell(row_cell)=src(row);
-             for (unsigned int column_cell=0, column=cell*blocksize;
-                  column_cell<blocksize; ++column_cell, ++column)
+             for (unsigned int column_cell=0, column=cell*this->blocksize;
+                  column_cell<this->blocksize; ++column_cell, ++column)
                M_cell(row_cell,column_cell)=M(row,column);
            }
          M_cell.householder(b_cell);
          M_cell.backward(x_cell,b_cell);
                                           // distribute x_cell to dst
-         for (row=cell*blocksize, row_cell=0; row_cell<blocksize; ++row_cell, ++row)
+         for (row=cell*this->blocksize, row_cell=0;
+              row_cell<this->blocksize;
+              ++row_cell, ++row)
            if (adding)
              dst(row)+=x_cell(row_cell);
            else
              dst(row)=x_cell(row_cell);
          
-         begin_diag_block+=blocksize;
+         begin_diag_block+=this->blocksize;
        }
     }
   else
     for (unsigned int cell=0; cell<n_cells; ++cell)
       {
-       for (row=cell*blocksize, row_cell=0; row_cell<blocksize; ++row_cell, ++row)
+       for (row=cell*this->blocksize, row_cell=0;
+            row_cell<this->blocksize;
+            ++row_cell, ++row)
          {
            b_cell(row_cell)=src(row);
          }
-       inverse(cell).vmult(x_cell, b_cell);
+       this->inverse(cell).vmult(x_cell, b_cell);
                                         // distribute x_cell to dst
-       for (row=cell*blocksize, row_cell=0; row_cell<blocksize; ++row_cell, ++row)
+       for (row=cell*this->blocksize, row_cell=0;
+            row_cell<this->blocksize;
+            ++row_cell, ++row)
          if (adding)
            dst(row)+=x_cell(row_cell);
          else
            dst(row)=x_cell(row_cell);
        
-       begin_diag_block+=blocksize;
+       begin_diag_block+=this->blocksize;
       }
-  dst.scale(relaxation);
+  dst.scale(this->relaxation);
 }
 
 
@@ -374,16 +382,16 @@ void PreconditionBlockSOR<number,inverse_type>::vmult (Vector<number2>       &ds
                                   // args...
   typedef PreconditionBlock<number,inverse_type> BaseClass;
 
-  Assert (A!=0, ExcNotInitialized());
+  Assert (this->A!=0, ExcNotInitialized());
   
-  const SparseMatrix<number> &M=*A;
-  const unsigned int n_cells=M.m()/blocksize;
+  const SparseMatrix<number> &M=*this->A;
+  const unsigned int n_cells=M.m()/this->blocksize;
 
   const SparsityPattern &spars    = M.get_sparsity_pattern();
   const unsigned int    *rowstart = spars.get_rowstart_indices();
   const unsigned int    *columns  = spars.get_column_numbers();
 
-  Vector<number2> b_cell(blocksize), x_cell(blocksize);
+  Vector<number2> b_cell(this->blocksize), x_cell(this->blocksize);
 
                                       // cell_row, cell_column are the
                                       // numbering of the blocks (cells).
@@ -395,35 +403,42 @@ void PreconditionBlockSOR<number,inverse_type>::vmult (Vector<number2>       &ds
   unsigned int row, column, row_cell, begin_diag_block=0;
   number2 b_cell_row;
 
-  if (!inverses_ready())
+  if (!this->inverses_ready())
     {
-      FullMatrix<number> M_cell(blocksize);
+      FullMatrix<number> M_cell(this->blocksize);
       for (unsigned int cell=0; cell<n_cells; ++cell)
        {
-         for (row=cell*blocksize, row_cell=0; row_cell<blocksize; ++row_cell, ++row)
+         for (row=cell*this->blocksize, row_cell=0;
+              row_cell<this->blocksize;
+              ++row_cell, ++row)
            {
              b_cell_row=src(row);
              for (unsigned int j=rowstart[row]; j<rowstart[row+1]; ++j)
                if ((column=columns[j]) < begin_diag_block)
                    b_cell_row -= M.global_entry(j) * dst(column);
              b_cell(row_cell)=b_cell_row;
-             for (unsigned int column_cell=0, column=cell*blocksize;
-                  column_cell<blocksize; ++column_cell, ++column)
+             for (unsigned int column_cell=0, column=cell*this->blocksize;
+                  column_cell<this->blocksize;
+                  ++column_cell, ++column)
                  M_cell(row_cell,column_cell)=M(row,column);
            }
          M_cell.householder(b_cell);
          M_cell.backward(x_cell,b_cell);
                                           // distribute x_cell to dst
-         for (row=cell*blocksize, row_cell=0; row_cell<blocksize; ++row_cell, ++row)
-           dst(row)=relaxation*x_cell(row_cell);
+         for (row=cell*this->blocksize, row_cell=0;
+              row_cell<this->blocksize;
+              ++row_cell, ++row)
+           dst(row)=this->relaxation*x_cell(row_cell);
          
-         begin_diag_block+=blocksize;
+         begin_diag_block+=this->blocksize;
        }
     }
   else
     for (unsigned int cell=0; cell<n_cells; ++cell)
       {
-       for (row=cell*blocksize, row_cell=0; row_cell<blocksize; ++row_cell, ++row)
+       for (row=cell*this->blocksize, row_cell=0;
+            row_cell<this->blocksize;
+            ++row_cell, ++row)
          {
            b_cell_row=src(row);
            for (unsigned int j=rowstart[row]; j<rowstart[row+1]; ++j)
@@ -433,12 +448,14 @@ void PreconditionBlockSOR<number,inverse_type>::vmult (Vector<number2>       &ds
                }
            b_cell(row_cell)=b_cell_row;
          }
-       inverse(cell).vmult(x_cell, b_cell);
+       this->inverse(cell).vmult(x_cell, b_cell);
                                         // distribute x_cell to dst
-       for (row=cell*blocksize, row_cell=0; row_cell<blocksize; ++row_cell, ++row)
-         dst(row)=relaxation*x_cell(row_cell);
+       for (row=cell*this->blocksize, row_cell=0;
+            row_cell<this->blocksize;
+            ++row_cell, ++row)
+         dst(row)=this->relaxation*x_cell(row_cell);
        
-       begin_diag_block+=blocksize;
+       begin_diag_block+=this->blocksize;
       }
 }
 
@@ -466,16 +483,16 @@ void PreconditionBlockSOR<number,inverse_type>::Tvmult (Vector<number2>       &d
                                   // args...
   typedef PreconditionBlock<number,inverse_type> BaseClass;
 
-  Assert (A!=0, ExcNotInitialized());
+  Assert (this->A!=0, ExcNotInitialized());
   
-  const SparseMatrix<number> &M=*A;
-  const unsigned int n_cells=M.m()/blocksize;
+  const SparseMatrix<number> &M=*this->A;
+  const unsigned int n_cells=M.m()/this->blocksize;
 
   const SparsityPattern &spars    = M.get_sparsity_pattern();
   const unsigned int    *rowstart = spars.get_rowstart_indices();
   const unsigned int    *columns  = spars.get_column_numbers();
 
-  Vector<number2> b_cell(blocksize), x_cell(blocksize);
+  Vector<number2> b_cell(this->blocksize), x_cell(this->blocksize);
 
                                       // cell_row, cell_column are the
                                       // numbering of the blocks (cells).
@@ -484,17 +501,20 @@ void PreconditionBlockSOR<number,inverse_type>::Tvmult (Vector<number2>       &d
                                       // blocks.
                                       // row, column are the global numbering
                                       // of the unkowns.
-  unsigned int row, column, row_cell, end_diag_block=blocksize *n_cells;
+  unsigned int row, column, row_cell;
+  unsigned int end_diag_block=this->blocksize *n_cells;
   number2 b_cell_row;
 
-  if (!inverses_ready())
+  if (!this->inverses_ready())
     {
-      FullMatrix<number> M_cell(blocksize);
+      FullMatrix<number> M_cell(this->blocksize);
       for (int icell=n_cells-1; icell>=0 ; --icell)
        {
          unsigned int cell = (unsigned int) icell;
                                           // Collect upper triangle
-         for (row=cell*blocksize, row_cell=0; row_cell<blocksize; ++row_cell, ++row)
+         for (row=cell*this->blocksize, row_cell=0;
+              row_cell<this->blocksize;
+              ++row_cell, ++row)
            {
              b_cell_row=src(row);
              for (unsigned int j=rowstart[row]; j<rowstart[row+1]; ++j)
@@ -506,24 +526,28 @@ void PreconditionBlockSOR<number,inverse_type>::Tvmult (Vector<number2>       &d
              
              b_cell(row_cell)=b_cell_row;
                                               // Collect diagonal block
-             for (unsigned int column_cell=0, column=cell*blocksize;
-                  column_cell<blocksize; ++column_cell, ++column)
+             for (unsigned int column_cell=0, column=cell*this->blocksize;
+                  column_cell<this->blocksize; ++column_cell, ++column)
                  M_cell(row_cell,column_cell)=M(row,column);
            }
          M_cell.householder(b_cell);
          M_cell.backward(x_cell,b_cell);
                                           // distribute x_cell to dst
-         for (row=cell*blocksize, row_cell=0; row_cell<blocksize; ++row_cell, ++row)
-           dst(row)=relaxation*x_cell(row_cell);
+         for (row=cell*this->blocksize, row_cell=0;
+              row_cell<this->blocksize;
+              ++row_cell, ++row)
+           dst(row)=this->relaxation*x_cell(row_cell);
          
-         end_diag_block-=blocksize;
+         end_diag_block-=this->blocksize;
        }
     }
   else
     for (int icell=n_cells-1; icell >=0 ; --icell)
       {
        unsigned int cell = (unsigned int) icell;
-       for (row=cell*blocksize, row_cell=0; row_cell<blocksize; ++row_cell, ++row)
+       for (row=cell*this->blocksize, row_cell=0;
+            row_cell<this->blocksize;
+            ++row_cell, ++row)
          {
            b_cell_row=src(row);
            for (unsigned int j=rowstart[row]; j<rowstart[row+1]; ++j)
@@ -534,12 +558,14 @@ void PreconditionBlockSOR<number,inverse_type>::Tvmult (Vector<number2>       &d
              }
            b_cell(row_cell)=b_cell_row;
          }
-       inverse(cell).vmult(x_cell, b_cell);
+       this->inverse(cell).vmult(x_cell, b_cell);
                                         // distribute x_cell to dst
-       for (row=cell*blocksize, row_cell=0; row_cell<blocksize; ++row_cell, ++row)
-         dst(row)=relaxation*x_cell(row_cell);
+       for (row=cell*this->blocksize, row_cell=0;
+            row_cell<this->blocksize;
+            ++row_cell, ++row)
+         dst(row)=this->relaxation*x_cell(row_cell);
        
-       end_diag_block-=blocksize;
+       end_diag_block-=this->blocksize;
       }
 }
 
@@ -549,7 +575,7 @@ void PreconditionBlockSOR<number,inverse_type>::Tvmult (Vector<number2>       &d
 template <typename number, typename inverse_type>
 PreconditionBlockSSOR<number,inverse_type>::PreconditionBlockSSOR ()
 {
-  store_diagonals = 1;
+  this->store_diagonals = 1;
 }
 
 
@@ -563,23 +589,23 @@ void PreconditionBlockSSOR<number,inverse_type>::vmult (Vector<number2>       &d
   
   PreconditionBlockSOR<number,inverse_type>::vmult(help, src);
 
-  Vector<inverse_type> cell_src(blocksize);
-  Vector<inverse_type> cell_dst(blocksize);
+  Vector<inverse_type> cell_src(this->blocksize);
+  Vector<inverse_type> cell_dst(this->blocksize);
   
-  const unsigned int n_cells = A->m()/blocksize;
+  const unsigned int n_cells = this->A->m()/this->blocksize;
 
                                   // Multiply with diagonal blocks
   for (unsigned int cell=0; cell<n_cells; ++cell)
     {
-      unsigned int row = cell*blocksize;
+      unsigned int row = cell*this->blocksize;
       
-      for (unsigned int row_cell=0; row_cell<blocksize; ++row_cell)
+      for (unsigned int row_cell=0; row_cell<this->blocksize; ++row_cell)
        cell_src(row_cell)=help(row+row_cell);
 
-      diagonal(cell).vmult(cell_dst, cell_src);
+      this->diagonal(cell).vmult(cell_dst, cell_src);
 
-      for (unsigned int row_cell=0; row_cell<blocksize; ++row_cell)
-       help(row+row_cell)=relaxation*cell_dst(row_cell);
+      for (unsigned int row_cell=0; row_cell<this->blocksize; ++row_cell)
+       help(row+row_cell)=this->relaxation*cell_dst(row_cell);
     }
   
   PreconditionBlockSOR<number,inverse_type>::Tvmult(dst, help);
@@ -595,23 +621,23 @@ void PreconditionBlockSSOR<number,inverse_type>::Tvmult (Vector<number2>       &
   
   PreconditionBlockSOR<number,inverse_type>::Tvmult(help, src);
 
-  Vector<inverse_type> cell_src(blocksize);
-  Vector<inverse_type> cell_dst(blocksize);
+  Vector<inverse_type> cell_src(this->blocksize);
+  Vector<inverse_type> cell_dst(this->blocksize);
   
-  const unsigned int n_cells = A->m()/blocksize;
+  const unsigned int n_cells = this->A->m()/this->blocksize;
 
                                   // Multiply with diagonal blocks
   for (unsigned int cell=0; cell<n_cells; ++cell)
     {
-      unsigned int row = cell*blocksize;
+      unsigned int row = cell*this->blocksize;
       
-      for (unsigned int row_cell=0; row_cell<blocksize; ++row_cell)
+      for (unsigned int row_cell=0; row_cell<this->blocksize; ++row_cell)
        cell_src(row_cell)=help(row+row_cell);
 
-      diagonal(cell).vmult(cell_dst, cell_src);
+      this->diagonal(cell).vmult(cell_dst, cell_src);
 
-      for (unsigned int row_cell=0; row_cell<blocksize; ++row_cell)
-       help(row+row_cell)=relaxation*cell_dst(row_cell);
+      for (unsigned int row_cell=0; row_cell<this->blocksize; ++row_cell)
+       help(row+row_cell)=this->relaxation*cell_dst(row_cell);
     }
   
   PreconditionBlockSOR<number,inverse_type>::vmult(dst, help);
index 47a0cdbc16530db7059a8d1069e4aa7754493229..608d889a0ccfadbce011650ea7def10f3e20703a 100644 (file)
@@ -58,8 +58,8 @@ void SparseILU<number>::decompose (const SparseMatrix<somenumber> &matrix,
                                   const double                    strengthen_diagonal)
 {
   Assert (matrix.m()==matrix.n(), ExcMatrixNotSquare ());
-  Assert (m()==n(),               ExcMatrixNotSquare ());
-  Assert (matrix.m()==m(),        ExcSizeMismatch(matrix.m(), m()));
+  Assert (this->m()==this->n(),   ExcMatrixNotSquare ());
+  Assert (matrix.m()==this->m(),  ExcSizeMismatch(matrix.m(), this->m()));
   
   Assert (strengthen_diagonal>=0, ExcInvalidStrengthening (strengthen_diagonal));
 
@@ -155,7 +155,7 @@ void SparseILU<number>::decompose (const SparseMatrix<somenumber> &matrix,
                  ExcDivideByZero());
       
       this->global_entry (rowstart_indices[row-1])
-       = 1./global_entry (rowstart_indices[row-1]);
+       = 1./this->global_entry (rowstart_indices[row-1]);
 
                                       // let k run over all lower-left
                                       // elements of row i; skip
@@ -215,7 +215,7 @@ void SparseILU<number>::decompose (const SparseMatrix<somenumber> &matrix,
                                   // element still has to be inverted
                                   // because the for-loop doesn't do
                                   // it...
- this->diag_element(this->m()-1) = 1./this->diag_element(m()-1);
+ this->diag_element(this->m()-1) = 1./this->diag_element(this->m()-1);
 
 /*
   OLD CODE, rather crude first implementation with an algorithm taken
@@ -271,7 +271,7 @@ void SparseILU<number>::apply_decomposition (Vector<somenumber>       &dst,
                                             const Vector<somenumber> &src) const 
 {
   Assert (dst.size() == src.size(), ExcSizeMismatch(dst.size(), src.size()));
-  Assert (dst.size() == m(), ExcSizeMismatch(dst.size(), m()));
+  Assert (dst.size() == this->m(), ExcSizeMismatch(dst.size(), this->m()));
   
   const unsigned int N=dst.size();
   const unsigned int * const rowstart_indices
index 07ed8d017d50b7f2a531a333acdc0a7d7a3e2299..7baefed61fef162eadb69f0767b010db005b3a15 100644 (file)
@@ -104,7 +104,7 @@ void SwappableVector<number>::swap_out (const std::string &name)
   
   filename = name;
   
-  Assert (size() != 0, ExcSizeZero());
+  Assert (this->size() != 0, ExcSizeZero());
 
                                   // if in MT mode, block all other
                                   // operations
@@ -118,10 +118,10 @@ void SwappableVector<number>::swap_out (const std::string &name)
   Assert (data_is_preloaded == false, ExcInternalError());
   
   std::ofstream tmp_out(filename.c_str());
-  block_write (tmp_out);
+  this->block_write (tmp_out);
   tmp_out.close ();
        
-  reinit (0);
+  this->reinit (0);
 
 #ifdef DEAL_II_USE_MT
   lock.release ();
@@ -181,7 +181,7 @@ void SwappableVector<number>::alert ()
                                   // calling this function while the
                                   // vector is active does no harm
                                   // either
-       (size() != 0))
+       (this->size() != 0))
     lock.release ();
   else
                                     // data has not been preloaded so
@@ -200,10 +200,10 @@ template <typename number>
 void SwappableVector<number>::reload_vector (const bool set_flag)
 {
   Assert (filename != "", ExcInvalidFilename (filename));
-  Assert (size() == 0, ExcSizeNonzero());
+  Assert (this->size() == 0, ExcSizeNonzero());
   
   std::ifstream tmp_in(filename.c_str());
-  block_read (tmp_in);
+  this->block_read (tmp_in);
   tmp_in.close ();
 
                                   // release the lock that was

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.