]> https://gitweb.dealii.org/ - code-gallery.git/commitdiff
Use the usual indentation style.
authorWolfgang Bangerth <bangerth@math.tamu.edu>
Thu, 26 May 2016 23:21:13 +0000 (18:21 -0500)
committerWolfgang Bangerth <bangerth@math.tamu.edu>
Fri, 27 May 2016 15:26:40 +0000 (10:26 -0500)
goal_oriented_elastoplasticity/elastoplastic.cc

index 4b0d9ded6914773a129d5eb0e134a54cb83e1727..449a459f38a2546d9ba69e86c0648f0db96f17b4 100644 (file)
@@ -16,7 +16,7 @@
 
  *
  * Authors: Seyed Shahram Ghorashi, Bauhaus-Universit\"at Weimar, 2014
- *                                     Joerg Frohne, Texas A&M University and
+ *          Joerg Frohne, Texas A&M University and
  *                        University of Siegen, 2012, 2013
  *          Wolfgang Bangerth, Texas A&M University, 2012, 2013
  *          Timo Heister, Texas A&M University, 2013
@@ -109,8 +109,8 @@ namespace ElastoPlastic
                         const double height,
                         Triangulation<3,3> &result)
   {
-  //  Assert (input.n_levels() == 1,
-  //          ExcMessage ("The input triangulations must be coarse meshes."));
+    //  Assert (input.n_levels() == 1,
+    //          ExcMessage ("The input triangulations must be coarse meshes."));
     Assert(result.n_cells()==0, ExcMessage("resultin Triangulation need to be empty upon calling extrude_triangulation."));
     Assert(height>0, ExcMessage("The height in extrude_triangulation needs to be positive."));
     Assert(n_slices>=2, ExcMessage("The number of slices in extrude_triangulation needs to be at least 2."));
@@ -124,13 +124,13 @@ namespace ElastoPlastic
         for (unsigned int i=0; i<input.n_vertices(); ++i)
 
           {
-                       if (input.get_used_vertices()[i])
-                       {
-              const Point<2> &v = input.get_vertices()[i];
-              points[i+slice*input.n_vertices()](0) = v(0);
-              points[i+slice*input.n_vertices()](1) = v(1);
-              points[i+slice*input.n_vertices()](2) = height * slice / (n_slices-1);
-                       }
+            if (input.get_used_vertices()[i])
+              {
+                const Point<2> &v = input.get_vertices()[i];
+                points[i+slice*input.n_vertices()](0) = v(0);
+                points[i+slice*input.n_vertices()](1) = v(1);
+                points[i+slice*input.n_vertices()](2) = height * slice / (n_slices-1);
+              }
           }
       }
 
@@ -202,117 +202,117 @@ namespace ElastoPlastic
   {
 
 
-               template <int dim>
-               double get_von_Mises_stress(const SymmetricTensor<2, dim> &stress)
-               {
-
-                       //                      if (dim == 2)
-                       //                      {
-                       //                              von_Mises_stress = std::sqrt(  stress[0][0]*stress[0][0]
-                       //                                                                               + stress[1][1]*stress[1][1]
-                       //                                                                               - stress[0][0]*stress[1][1]
-                       //                                                                               + 3*stress[0][1]*stress[0][1]);
-                       //                      }else if (dim == 3)
-                       //                      {
-                       //                              von_Mises_stress = std::sqrt(  stress[0][0]*stress[0][0]
-                       //                                                                       + stress[1][1]*stress[1][1]
-                       //                                                                                           + stress[2][2]*stress[2][2]
-                       //                                                                       - stress[0][0]*stress[1][1]
-                       //                                                                                           - stress[1][1]*stress[2][2]
-                       //                                                                                           - stress[0][0]*stress[2][2]
-                       //                                                                               + 3*( stress[0][1]*stress[0][1]
-                       //                                                                                    +stress[1][2]*stress[1][2]
-                       //                                                                                    +stress[0][2]*stress[0][2]) );
-                       //                      }
-
-       // -----------------------------------------------
-       // "Perforated_strip_tension"
-       // plane stress
-//     const double von_Mises_stress = std::sqrt(  stress[0][0]*stress[0][0]
-//                                               + stress[1][1]*stress[1][1]
-//                                               - stress[0][0]*stress[1][1]
-//                                               + 3*stress[0][1]*stress[0][1]);
-       // -----------------------------------------------
-       // otherwise
-       // plane strain / 3d case
-       const double von_Mises_stress = std::sqrt(1.5) * (deviator(stress)).norm();
-       // -----------------------------------------------
-
-
-
-                       return von_Mises_stress;
-               }
-
-
-               template <int dim>
-               class PointValuesEvaluation
-               {
-               public:
-                       PointValuesEvaluation (const Point<dim>  &evaluation_point);
-
-                       void compute (const DoFHandler<dim>  &dof_handler,
-                                                                         const Vector<double>   &solution,
-                                                                               Vector<double>                           &point_values);
-
-                       DeclException1 (ExcEvaluationPointNotFound,
-                                                                                       Point<dim>,
-                                                                                       << "The evaluation point " << arg1
-                                                                                       << " was not found among the vertices of the present grid.");
-               private:
-                       const Point<dim>  evaluation_point;
-               };
-
-
-               template <int dim>
-               PointValuesEvaluation<dim>::
-               PointValuesEvaluation (const Point<dim>  &evaluation_point)
-                       :
-                       evaluation_point (evaluation_point)
-               {}
-
-
-
-               template <int dim>
-               void
-               PointValuesEvaluation<dim>::
-               compute (const DoFHandler<dim>  &dof_handler,
-                                          const Vector<double>   &solution,
-                                          Vector<double>                               &point_values)
-               {
-                       const unsigned int dofs_per_vertex = dof_handler.get_fe().dofs_per_vertex;
-                       AssertThrow (point_values.size() == dofs_per_vertex,
-                                                                        ExcDimensionMismatch (point_values.size(), dofs_per_vertex));
-                       point_values = 1e20;
-
-                       typename DoFHandler<dim>::active_cell_iterator
-                       cell = dof_handler.begin_active(),
-                       endc = dof_handler.end();
-                       bool evaluation_point_found = false;
-                       for (; (cell!=endc) && !evaluation_point_found; ++cell)
-                       {
-                               if (cell->is_locally_owned() && !evaluation_point_found)
-                                       for (unsigned int vertex=0;
-                                                        vertex<GeometryInfo<dim>::vertices_per_cell;
-                                                        ++vertex)
-                                       {
-                                               if (cell->vertex(vertex).distance (evaluation_point)
-                                                               <
-                                                               cell->diameter() * 1e-8)
-                                                       {
-                                                               for (unsigned int id=0; id!=dofs_per_vertex; ++id)
-                                                               {
-                                                                       point_values[id] = solution(cell->vertex_dof_index(vertex,id));
-                                                               }
-
-                                                               evaluation_point_found = true;
-                                                               break;
-                                                       }
-                                       }
-                       }
-
-                       AssertThrow (evaluation_point_found,
-                                                                        ExcEvaluationPointNotFound(evaluation_point));
-               }
+    template <int dim>
+    double get_von_Mises_stress(const SymmetricTensor<2, dim> &stress)
+    {
+
+      //      if (dim == 2)
+      //      {
+      //        von_Mises_stress = std::sqrt(  stress[0][0]*stress[0][0]
+      //                                                         + stress[1][1]*stress[1][1]
+      //                                                         - stress[0][0]*stress[1][1]
+      //                                                         + 3*stress[0][1]*stress[0][1]);
+      //      }else if (dim == 3)
+      //      {
+      //        von_Mises_stress = std::sqrt(  stress[0][0]*stress[0][0]
+      //                                                       + stress[1][1]*stress[1][1]
+      //                                                       + stress[2][2]*stress[2][2]
+      //                                                       - stress[0][0]*stress[1][1]
+      //                                                       - stress[1][1]*stress[2][2]
+      //                                                       - stress[0][0]*stress[2][2]
+      //                                                         + 3*( stress[0][1]*stress[0][1]
+      //                                                              +stress[1][2]*stress[1][2]
+      //                                                              +stress[0][2]*stress[0][2]) );
+      //      }
+
+      // -----------------------------------------------
+      // "Perforated_strip_tension"
+      // plane stress
+//      const double von_Mises_stress = std::sqrt(  stress[0][0]*stress[0][0]
+//                                                + stress[1][1]*stress[1][1]
+//                                                - stress[0][0]*stress[1][1]
+//                                                + 3*stress[0][1]*stress[0][1]);
+      // -----------------------------------------------
+      // otherwise
+      // plane strain / 3d case
+      const double von_Mises_stress = std::sqrt(1.5) * (deviator(stress)).norm();
+      // -----------------------------------------------
+
+
+
+      return von_Mises_stress;
+    }
+
+
+    template <int dim>
+    class PointValuesEvaluation
+    {
+    public:
+      PointValuesEvaluation (const Point<dim>  &evaluation_point);
+
+      void compute (const DoFHandler<dim>  &dof_handler,
+                    const Vector<double>   &solution,
+                    Vector<double>         &point_values);
+
+      DeclException1 (ExcEvaluationPointNotFound,
+                      Point<dim>,
+                      << "The evaluation point " << arg1
+                      << " was not found among the vertices of the present grid.");
+    private:
+      const Point<dim>  evaluation_point;
+    };
+
+
+    template <int dim>
+    PointValuesEvaluation<dim>::
+    PointValuesEvaluation (const Point<dim>  &evaluation_point)
+      :
+      evaluation_point (evaluation_point)
+    {}
+
+
+
+    template <int dim>
+    void
+    PointValuesEvaluation<dim>::
+    compute (const DoFHandler<dim>  &dof_handler,
+             const Vector<double>   &solution,
+             Vector<double>         &point_values)
+    {
+      const unsigned int dofs_per_vertex = dof_handler.get_fe().dofs_per_vertex;
+      AssertThrow (point_values.size() == dofs_per_vertex,
+                   ExcDimensionMismatch (point_values.size(), dofs_per_vertex));
+      point_values = 1e20;
+
+      typename DoFHandler<dim>::active_cell_iterator
+      cell = dof_handler.begin_active(),
+      endc = dof_handler.end();
+      bool evaluation_point_found = false;
+      for (; (cell!=endc) && !evaluation_point_found; ++cell)
+        {
+          if (cell->is_locally_owned() && !evaluation_point_found)
+            for (unsigned int vertex=0;
+                 vertex<GeometryInfo<dim>::vertices_per_cell;
+                 ++vertex)
+              {
+                if (cell->vertex(vertex).distance (evaluation_point)
+                    <
+                    cell->diameter() * 1e-8)
+                  {
+                    for (unsigned int id=0; id!=dofs_per_vertex; ++id)
+                      {
+                        point_values[id] = solution(cell->vertex_dof_index(vertex,id));
+                      }
+
+                    evaluation_point_found = true;
+                    break;
+                  }
+              }
+        }
+
+      AssertThrow (evaluation_point_found,
+                   ExcEvaluationPointNotFound(evaluation_point));
+    }
 
 
   }
@@ -337,9 +337,9 @@ namespace ElastoPlastic
   template <int dim>
   struct PointHistory
   {
-       SymmetricTensor<2,dim> old_stress;
-       SymmetricTensor<2,dim> old_strain;
-       Point<dim> point;
+    SymmetricTensor<2,dim> old_stress;
+    SymmetricTensor<2,dim> old_strain;
+    Point<dim> point;
   };
 
 
@@ -381,7 +381,7 @@ namespace ElastoPlastic
 
     bool
     get_grad_stress_strain_tensor (const SymmetricTensor<2, dim> &strain_tensor,
-                                                                                                                                        const std::vector<Tensor<2, dim> > &point_hessian,
+                                   const std::vector<Tensor<2, dim> > &point_hessian,
                                    Tensor<5, dim> &stress_strain_tensor_grad) const;
 
     void
@@ -490,7 +490,7 @@ namespace ElastoPlastic
   bool
   ConstitutiveLaw<dim>::
   get_grad_stress_strain_tensor (const SymmetricTensor<2, dim> &strain_tensor,
-                                                                                                                        const std::vector<Tensor<2, dim> > &point_hessian,
+                                 const std::vector<Tensor<2, dim> > &point_hessian,
                                  Tensor<5, dim> &stress_strain_tensor_grad) const
   {
     SymmetricTensor<2, dim> stress_tensor;
@@ -502,53 +502,54 @@ namespace ElastoPlastic
     const double von_Mises_stress = Evaluation::get_von_Mises_stress(stress_tensor);
 
     if (von_Mises_stress > sigma_0)
-    {
-       const SymmetricTensor<2, dim> deviator_strain_tensor = deviator(strain_tensor);
-       const double deviator_strain_tensor_norm = deviator_strain_tensor.norm();
-       const double multiplier = -(1-gamma)*sigma_0/(2*mu*std::pow(deviator_strain_tensor_norm,3));
-
-       Vector<double> multiplier_vector(dim);
-       multiplier_vector = 0;
-
-       for (unsigned int i=0; i!=dim; ++i)
-               for (unsigned int m=0; m!=dim; ++m)
-                       for (unsigned int n=0; n!=dim; ++n)
-                       {
-                               multiplier_vector(i) += deviator_strain_tensor[m][n] *
-                                                                                                                               ( 0.5*( point_hessian[m][n][i] + point_hessian[n][m][i] )
-                                                                                                                               + ( m==n && dim==2 ? -1/dim*(point_hessian[0][0][i]
-                                                                                                                                                            + point_hessian[1][1][i]) : 0 )
-                                                                                                                                 + ( m==n && dim==3 ? -1/dim*(point_hessian[0][0][i]
-                                                                                                                                                              + point_hessian[1][1][i]
-                                                                                                                                                              + point_hessian[2][2][i]) : 0 ) );
-                       }
-
-       // -----------------------------------------------
-       // "Perforated_strip_tension"
-       // plane stress
-//     const double VM_factor = std::sqrt(2);
-       // -----------------------------------------------
-       // otherwise
-       // plane strain / 3d case
-       const double VM_factor = std::sqrt(1.5);
-       // -----------------------------------------------
-
-       for (unsigned int i=0; i!=dim; ++i)
-               for (unsigned int j=0; j!=dim; ++j)
-                       for (unsigned int k=0; k!=dim; ++k)
-                               for (unsigned int l=0; l!=dim; ++l)
-                                       for (unsigned int m=0; m!=dim; ++m)
-                                       {
-                                               stress_strain_tensor_grad[i][j][k][l][m] = 1/VM_factor
-                                                                                                                                                                                                                        * multiplier
-                                                                                                                                                                                                                        * stress_strain_tensor_mu[i][j][k][l]
-                                                                                                                                                                                                                        * multiplier_vector(m);
-                                       }
-
-    }else
-    {
-       stress_strain_tensor_grad = 0;
-    }
+      {
+        const SymmetricTensor<2, dim> deviator_strain_tensor = deviator(strain_tensor);
+        const double deviator_strain_tensor_norm = deviator_strain_tensor.norm();
+        const double multiplier = -(1-gamma)*sigma_0/(2*mu*std::pow(deviator_strain_tensor_norm,3));
+
+        Vector<double> multiplier_vector(dim);
+        multiplier_vector = 0;
+
+        for (unsigned int i=0; i!=dim; ++i)
+          for (unsigned int m=0; m!=dim; ++m)
+            for (unsigned int n=0; n!=dim; ++n)
+              {
+                multiplier_vector(i) += deviator_strain_tensor[m][n] *
+                                        ( 0.5*( point_hessian[m][n][i] + point_hessian[n][m][i] )
+                                          + ( m==n && dim==2 ? -1/dim*(point_hessian[0][0][i]
+                                                                       + point_hessian[1][1][i]) : 0 )
+                                          + ( m==n && dim==3 ? -1/dim*(point_hessian[0][0][i]
+                                                                       + point_hessian[1][1][i]
+                                                                       + point_hessian[2][2][i]) : 0 ) );
+              }
+
+        // -----------------------------------------------
+        // "Perforated_strip_tension"
+        // plane stress
+//      const double VM_factor = std::sqrt(2);
+        // -----------------------------------------------
+        // otherwise
+        // plane strain / 3d case
+        const double VM_factor = std::sqrt(1.5);
+        // -----------------------------------------------
+
+        for (unsigned int i=0; i!=dim; ++i)
+          for (unsigned int j=0; j!=dim; ++j)
+            for (unsigned int k=0; k!=dim; ++k)
+              for (unsigned int l=0; l!=dim; ++l)
+                for (unsigned int m=0; m!=dim; ++m)
+                  {
+                    stress_strain_tensor_grad[i][j][k][l][m] = 1/VM_factor
+                                                               * multiplier
+                                                               * stress_strain_tensor_mu[i][j][k][l]
+                                                               * multiplier_vector(m);
+                  }
+
+      }
+    else
+      {
+        stress_strain_tensor_grad = 0;
+      }
 
     return (von_Mises_stress > sigma_0);
   }
@@ -619,18 +620,18 @@ namespace ElastoPlastic
   Tensor<2,2>
   get_rotation_matrix (const std::vector<Tensor<1,2> > &grad_u)
   {
-       // First, compute the curl of the velocity field from the gradients. Note
-       // that we are in 2d, so the rotation is a scalar:
-       const double curl = (grad_u[1][0] - grad_u[0][1]);
-
-       // From this, compute the angle of rotation:
-       const double angle = std::atan (curl);
-
-       // And from this, build the antisymmetric rotation matrix:
-       const double t[2][2] = {{ cos(angle), sin(angle) },
-                       {-sin(angle), cos(angle) }
-       };
-       return Tensor<2,2>(t);
+    // First, compute the curl of the velocity field from the gradients. Note
+    // that we are in 2d, so the rotation is a scalar:
+    const double curl = (grad_u[1][0] - grad_u[0][1]);
+
+    // From this, compute the angle of rotation:
+    const double angle = std::atan (curl);
+
+    // And from this, build the antisymmetric rotation matrix:
+    const double t[2][2] = {{ cos(angle), sin(angle) },
+      {-sin(angle), cos(angle) }
+    };
+    return Tensor<2,2>(t);
   }
 
 
@@ -638,65 +639,65 @@ namespace ElastoPlastic
   Tensor<2,3>
   get_rotation_matrix (const std::vector<Tensor<1,3> > &grad_u)
   {
-       // Again first compute the curl of the velocity field. This time, it is a
-       // real vector:
-       const Point<3> curl (grad_u[2][1] - grad_u[1][2],
-                                                                                        grad_u[0][2] - grad_u[2][0],
-                                                                                        grad_u[1][0] - grad_u[0][1]);
-
-       // From this vector, using its magnitude, compute the tangent of the angle
-       // of rotation, and from it the actual angle:
-       const double tan_angle = std::sqrt(curl*curl);
-       const double angle = std::atan (tan_angle);
-
-       // Now, here's one problem: if the angle of rotation is too small, that
-       // means that there is no rotation going on (for example a translational
-       // motion). In that case, the rotation matrix is the identity matrix.
-       //
-       // The reason why we stress that is that in this case we have that
-       // <code>tan_angle==0</code>. Further down, we need to divide by that
-       // number in the computation of the axis of rotation, and we would get
-       // into trouble when dividing doing so. Therefore, let's shortcut this and
-       // simply return the identity matrix if the angle of rotation is really
-       // small:
-       if (angle < 1e-9)
-       {
-               static const double rotation[3][3]
-               = {{ 1, 0, 0}, { 0, 1, 0 }, { 0, 0, 1 } };
-               static const Tensor<2,3> rot(rotation);
-               return rot;
-       }
-
-       // Otherwise compute the real rotation matrix. The algorithm for this is
-       // not exactly obvious, but can be found in a number of books,
-       // particularly on computer games where rotation is a very frequent
-       // operation. Online, you can find a description at
-       // http://www.makegames.com/3drotation/ and (this particular form, with
-       // the signs as here) at
-       // http://www.gamedev.net/reference/articles/article1199.asp:
-       const double c = std::cos(angle);
-       const double s = std::sin(angle);
-       const double t = 1-c;
-
-       const Point<3> axis = curl/tan_angle;
-       const double rotation[3][3]
-       = {{
-                       t *axis[0] *axis[0]+c,
-                       t *axis[0] *axis[1]+s *axis[2],
-                       t *axis[0] *axis[2]-s *axis[1]
-                },
-                {
-                       t *axis[0] *axis[1]-s *axis[2],
-                       t *axis[1] *axis[1]+c,
-                       t *axis[1] *axis[2]+s *axis[0]
-                },
-                {
-                       t *axis[0] *axis[2]+s *axis[1],
-                       t *axis[1] *axis[1]-s *axis[0],
-                       t *axis[2] *axis[2]+c
-                }
-               };
-       return Tensor<2,3>(rotation);
+    // Again first compute the curl of the velocity field. This time, it is a
+    // real vector:
+    const Point<3> curl (grad_u[2][1] - grad_u[1][2],
+                         grad_u[0][2] - grad_u[2][0],
+                         grad_u[1][0] - grad_u[0][1]);
+
+    // From this vector, using its magnitude, compute the tangent of the angle
+    // of rotation, and from it the actual angle:
+    const double tan_angle = std::sqrt(curl*curl);
+    const double angle = std::atan (tan_angle);
+
+    // Now, here's one problem: if the angle of rotation is too small, that
+    // means that there is no rotation going on (for example a translational
+    // motion). In that case, the rotation matrix is the identity matrix.
+    //
+    // The reason why we stress that is that in this case we have that
+    // <code>tan_angle==0</code>. Further down, we need to divide by that
+    // number in the computation of the axis of rotation, and we would get
+    // into trouble when dividing doing so. Therefore, let's shortcut this and
+    // simply return the identity matrix if the angle of rotation is really
+    // small:
+    if (angle < 1e-9)
+      {
+        static const double rotation[3][3]
+        = {{ 1, 0, 0}, { 0, 1, 0 }, { 0, 0, 1 } };
+        static const Tensor<2,3> rot(rotation);
+        return rot;
+      }
+
+    // Otherwise compute the real rotation matrix. The algorithm for this is
+    // not exactly obvious, but can be found in a number of books,
+    // particularly on computer games where rotation is a very frequent
+    // operation. Online, you can find a description at
+    // http://www.makegames.com/3drotation/ and (this particular form, with
+    // the signs as here) at
+    // http://www.gamedev.net/reference/articles/article1199.asp:
+    const double c = std::cos(angle);
+    const double s = std::sin(angle);
+    const double t = 1-c;
+
+    const Point<3> axis = curl/tan_angle;
+    const double rotation[3][3]
+    = {{
+        t *axis[0] *axis[0]+c,
+        t *axis[0] *axis[1]+s *axis[2],
+        t *axis[0] *axis[2]-s *axis[1]
+      },
+      {
+        t *axis[0] *axis[1]-s *axis[2],
+        t *axis[1] *axis[1]+c,
+        t *axis[1] *axis[2]+s *axis[0]
+      },
+      {
+        t *axis[0] *axis[2]+s *axis[1],
+        t *axis[1] *axis[1]-s *axis[0],
+        t *axis[2] *axis[2]+c
+      }
+    };
+    return Tensor<2,3>(rotation);
   }
 
 
@@ -709,129 +710,129 @@ namespace ElastoPlastic
   namespace EquationData
   {
 
-       /*
-               template <int dim>
-               class BoundaryForce : public Function<dim>
-               {
-               public:
-                       BoundaryForce ();
-
-                       virtual
-                       double value (const Point<dim> &p,
-                                                                               const unsigned int component = 0) const;
-
-                       virtual
-                       void vector_value (const Point<dim> &p,
-                                                                                                Vector<double> &values) const;
-               };
-
-               template <int dim>
-               BoundaryForce<dim>::BoundaryForce ()
-               :
-               Function<dim>(dim)
-               {}
-
-
-               template <int dim>
-               double
-               BoundaryForce<dim>::value (const Point<dim> &,
-                                                                                                                        const unsigned int) const
-               {
-                       return 0.;
-               }
-
-               template <int dim>
-               void
-               BoundaryForce<dim>::vector_value (const Point<dim> &p,
-                                                                                                                                                       Vector<double> &values) const
-               {
-                       for (unsigned int c = 0; c < this->n_components; ++c)
-                               values(c) = BoundaryForce<dim>::value(p, c);
-               }
-
-       // @sect3{The <code>BodyForce</code> class}
-               // Body forces are generally mediated by one of the four basic
-       // physical types of forces:
-               // gravity, strong and weak interaction, and electromagnetism. Unless one
-               // wants to consider subatomic objects (for which quasistatic deformation is
-               // irrelevant and an inappropriate description anyway), only gravity and
-               // electromagnetic forces need to be considered. Let us, for simplicity
-               // assume that our body has a certain mass density, but is either
-               // non-magnetic and not electrically conducting or that there are no
-               // significant electromagnetic fields around. In that case, the body forces
-               // are simply <code>rho g</code>, where <code>rho</code> is the material
-               // density and <code>g</code> is a vector in negative z-direction with
-               // magnitude 9.81 m/s^2.  Both the density and <code>g</code> are defined in
-               // the function, and we take as the density 7700 kg/m^3, a value commonly
-               // assumed for steel.
-               //
-               // To be a little more general and to be able to do computations in 2d as
-               // well, we realize that the body force is always a function returning a
-               // <code>dim</code> dimensional vector. We assume that gravity acts along
-               // the negative direction of the last, i.e. <code>dim-1</code>th
-               // coordinate. The rest of the implementation of this function should be
-               // mostly self-explanatory given similar definitions in previous example
-               // programs. Note that the body force is independent of the location; to
-               // avoid compiler warnings about unused function arguments, we therefore
-               // comment out the name of the first argument of the
-               // <code>vector_value</code> function:
-               template <int dim>
-               class BodyForce :  public Function<dim>
-               {
-               public:
-                       BodyForce ();
-
-                       virtual
-                       void
-                       vector_value (const Point<dim> &p,
-                                                                               Vector<double>   &values) const;
-
-                       virtual
-                       void
-                       vector_value_list (const std::vector<Point<dim> > &points,
-                                                                                                std::vector<Vector<double> >   &value_list) const;
-               };
-
-
-               template <int dim>
-               BodyForce<dim>::BodyForce ()
-               :
-               Function<dim> (dim)
-               {}
-
-
-               template <int dim>
-               inline
-               void
-               BodyForce<dim>::vector_value (const Point<dim> &p,
-                                                                                                                                       Vector<double>   &values) const
-               {
-                       Assert (values.size() == dim,
-                                                       ExcDimensionMismatch (values.size(), dim));
-
-                       const double g   = 9.81;
-                       const double rho = 7700;
-
-                       values = 0;
-                       values(dim-1) = -rho * g;
-               }
-
-
-
-               template <int dim>
-               void
-               BodyForce<dim>::vector_value_list (const std::vector<Point<dim> > &points,
-                                                                                                                                                        std::vector<Vector<double> >   &value_list) const
-               {
-                       const unsigned int n_points = points.size();
-
-                       Assert (value_list.size() == n_points,
-                                                       ExcDimensionMismatch (value_list.size(), n_points));
-
-                       for (unsigned int p=0; p<n_points; ++p)
-                               BodyForce<dim>::vector_value (points[p],
-                                                                                                                                                       value_list[p]);
-               }
+    /*
+    template <int dim>
+    class BoundaryForce : public Function<dim>
+    {
+    public:
+      BoundaryForce ();
+
+      virtual
+      double value (const Point<dim> &p,
+                    const unsigned int component = 0) const;
+
+      virtual
+      void vector_value (const Point<dim> &p,
+                         Vector<double> &values) const;
+    };
+
+    template <int dim>
+    BoundaryForce<dim>::BoundaryForce ()
+    :
+    Function<dim>(dim)
+    {}
+
+
+    template <int dim>
+    double
+    BoundaryForce<dim>::value (const Point<dim> &,
+                               const unsigned int) const
+    {
+      return 0.;
+    }
+
+    template <int dim>
+    void
+    BoundaryForce<dim>::vector_value (const Point<dim> &p,
+                                      Vector<double> &values) const
+    {
+      for (unsigned int c = 0; c < this->n_components; ++c)
+        values(c) = BoundaryForce<dim>::value(p, c);
+    }
+
+    // @sect3{The <code>BodyForce</code> class}
+    // Body forces are generally mediated by one of the four basic
+    // physical types of forces:
+    // gravity, strong and weak interaction, and electromagnetism. Unless one
+    // wants to consider subatomic objects (for which quasistatic deformation is
+    // irrelevant and an inappropriate description anyway), only gravity and
+    // electromagnetic forces need to be considered. Let us, for simplicity
+    // assume that our body has a certain mass density, but is either
+    // non-magnetic and not electrically conducting or that there are no
+    // significant electromagnetic fields around. In that case, the body forces
+    // are simply <code>rho g</code>, where <code>rho</code> is the material
+    // density and <code>g</code> is a vector in negative z-direction with
+    // magnitude 9.81 m/s^2.  Both the density and <code>g</code> are defined in
+    // the function, and we take as the density 7700 kg/m^3, a value commonly
+    // assumed for steel.
+    //
+    // To be a little more general and to be able to do computations in 2d as
+    // well, we realize that the body force is always a function returning a
+    // <code>dim</code> dimensional vector. We assume that gravity acts along
+    // the negative direction of the last, i.e. <code>dim-1</code>th
+    // coordinate. The rest of the implementation of this function should be
+    // mostly self-explanatory given similar definitions in previous example
+    // programs. Note that the body force is independent of the location; to
+    // avoid compiler warnings about unused function arguments, we therefore
+    // comment out the name of the first argument of the
+    // <code>vector_value</code> function:
+    template <int dim>
+    class BodyForce :  public Function<dim>
+    {
+    public:
+      BodyForce ();
+
+      virtual
+      void
+      vector_value (const Point<dim> &p,
+                    Vector<double>   &values) const;
+
+      virtual
+      void
+      vector_value_list (const std::vector<Point<dim> > &points,
+                         std::vector<Vector<double> >   &value_list) const;
+    };
+
+
+    template <int dim>
+    BodyForce<dim>::BodyForce ()
+    :
+    Function<dim> (dim)
+    {}
+
+
+    template <int dim>
+    inline
+    void
+    BodyForce<dim>::vector_value (const Point<dim> &p,
+                                  Vector<double>   &values) const
+    {
+      Assert (values.size() == dim,
+              ExcDimensionMismatch (values.size(), dim));
+
+      const double g   = 9.81;
+      const double rho = 7700;
+
+      values = 0;
+      values(dim-1) = -rho * g;
+    }
+
+
+
+    template <int dim>
+    void
+    BodyForce<dim>::vector_value_list (const std::vector<Point<dim> > &points,
+                                       std::vector<Vector<double> >   &value_list) const
+    {
+      const unsigned int n_points = points.size();
+
+      Assert (value_list.size() == n_points,
+              ExcDimensionMismatch (value_list.size(), n_points));
+
+      for (unsigned int p=0; p<n_points; ++p)
+        BodyForce<dim>::vector_value (points[p],
+                                      value_list[p]);
+    }
 
     // @sect3{The <code>IncrementalBoundaryValue</code> class}
 
@@ -864,30 +865,30 @@ namespace ElastoPlastic
     class IncrementalBoundaryValues :  public Function<dim>
     {
     public:
-       IncrementalBoundaryValues (const double present_time,
-                                                                                                                const double present_timestep);
+      IncrementalBoundaryValues (const double present_time,
+                                 const double present_timestep);
 
-       virtual
-       void
-       vector_value (const Point<dim> &p,
-                                                               Vector<double>   &values) const;
+      virtual
+      void
+      vector_value (const Point<dim> &p,
+                    Vector<double>   &values) const;
 
-       virtual
-       void
-       vector_value_list (const std::vector<Point<dim> > &points,
-                                                                                std::vector<Vector<double> >   &value_list) const;
+      virtual
+      void
+      vector_value_list (const std::vector<Point<dim> > &points,
+                         std::vector<Vector<double> >   &value_list) const;
 
     private:
-       const double velocity;
-       const double present_time;
-       const double present_timestep;
+      const double velocity;
+      const double present_time;
+      const double present_timestep;
     };
 
 
     template <int dim>
     IncrementalBoundaryValues<dim>::
     IncrementalBoundaryValues (const double present_time,
-                                                                                                        const double present_timestep)
+                               const double present_timestep)
     :
     Function<dim> (dim),
     velocity (.1),
@@ -900,13 +901,13 @@ namespace ElastoPlastic
     void
     IncrementalBoundaryValues<dim>::
     vector_value (const Point<dim> &p,
-                                                       Vector<double>   &values) const
+                  Vector<double>   &values) const
     {
-       Assert (values.size() == dim,
-                                       ExcDimensionMismatch (values.size(), dim));
+      Assert (values.size() == dim,
+              ExcDimensionMismatch (values.size(), dim));
 
-       values = 0;
-       values(2) = -present_timestep * velocity;
+      values = 0;
+      values(2) = -present_timestep * velocity;
     }
 
 
@@ -915,829 +916,829 @@ namespace ElastoPlastic
     void
     IncrementalBoundaryValues<dim>::
     vector_value_list (const std::vector<Point<dim> > &points,
-                                                                        std::vector<Vector<double> >   &value_list) const
+                       std::vector<Vector<double> >   &value_list) const
     {
-       const unsigned int n_points = points.size();
+      const unsigned int n_points = points.size();
 
-       Assert (value_list.size() == n_points,
-                                       ExcDimensionMismatch (value_list.size(), n_points));
+      Assert (value_list.size() == n_points,
+              ExcDimensionMismatch (value_list.size(), n_points));
 
-       for (unsigned int p=0; p<n_points; ++p)
-               IncrementalBoundaryValues<dim>::vector_value (points[p],
-                               value_list[p]);
+      for (unsigned int p=0; p<n_points; ++p)
+        IncrementalBoundaryValues<dim>::vector_value (points[p],
+            value_list[p]);
     }
     */
 
-       // ----------------------------- TimoshenkoBeam ---------------------------------------
-       /*
-               template <int dim>
-               class IncrementalBoundaryForce : public Function<dim>
-               {
-               public:
-                       IncrementalBoundaryForce (const double present_time,
-                                                                                                                               const double end_time);
-
-                       virtual
-                       void vector_value (const Point<dim> &p,
-                                                                                                Vector<double> &values) const;
-
-                       virtual
-                       void
-                       vector_value_list (const std::vector<Point<dim> > &points,
-                                                                                                std::vector<Vector<double> >   &value_list) const;
-               private:
-                       const double present_time,
-                                                                        end_time,
-                                                                        shear_force,
-                                                                        length,
-                                                                        depth,
-                                                                        thickness;
-               };
-
-               template <int dim>
-               IncrementalBoundaryForce<dim>::
-               IncrementalBoundaryForce (const double present_time,
-                                                                                                                               const double end_time)
-               :
-               Function<dim>(dim),
-               present_time (present_time),
-               end_time (end_time),
-               shear_force (2e4),
-               length (.48),
-               depth (.12),
-               thickness (.01)
-               {}
-
-               template <int dim>
-               void
-               IncrementalBoundaryForce<dim>::vector_value (const Point<dim> &p,
-                                                                                                                                                                                                Vector<double> &values) const
-               {
-                       AssertThrow (values.size() == dim,
-                                       ExcDimensionMismatch (values.size(), dim));
-                       AssertThrow (dim == 2, ExcNotImplemented());
-
-                       // compute traction on the right face of Timoshenko beam problem, t_bar
-                       double inertia_moment = (thickness*std::pow(depth,3)) / 12;
-
-                       double x = p(0);
-                       double y = p(1);
-
-                       AssertThrow(std::fabs(x-length)<1e-12, ExcNotImplemented());
-
-                       values(0) = 0;
-                       values(1) = - shear_force/(2*inertia_moment) * ( depth*depth/4-y*y );
-
-                       // compute the fraction of imposed force
-                       const double frac = present_time/end_time;
-
-                       values *= frac;
-               }
-
-               template <int dim>
-               void
-               IncrementalBoundaryForce<dim>::
-               vector_value_list (const std::vector<Point<dim> > &points,
-                                                                                        std::vector<Vector<double> >   &value_list) const
-               {
-                       const unsigned int n_points = points.size();
-
-                       Assert (value_list.size() == n_points,
-                                                       ExcDimensionMismatch (value_list.size(), n_points));
-
-                       for (unsigned int p=0; p<n_points; ++p)
-                               IncrementalBoundaryForce<dim>::vector_value (points[p],
-                                               value_list[p]);
-               }
-
-
-               template <int dim>
-               class BodyForce :  public ZeroFunction<dim>
-               {
-               public:
-                       BodyForce () : ZeroFunction<dim> (dim) {}
-               };
-
-               template <int dim>
-               class IncrementalBoundaryValues :  public Function<dim>
-               {
-               public:
-                       IncrementalBoundaryValues (const double present_time,
-                                                                                                                                const double end_time);
-
-                       virtual
-                       void
-                       vector_value (const Point<dim> &p,
-                                                                               Vector<double>   &values) const;
-
-                       virtual
-                       void
-                       vector_value_list (const std::vector<Point<dim> > &points,
-                                                                                                std::vector<Vector<double> >   &value_list) const;
-
-               private:
-                       const double present_time,
-                                                                        end_time,
-                                                                        shear_force,
-                                                                        Youngs_modulus,
-                                                                        Poissons_ratio,
-                                                                        length,
-                                                                        depth,
-                                                                        thickness;
-               };
-
-
-               template <int dim>
-               IncrementalBoundaryValues<dim>::
-               IncrementalBoundaryValues (const double present_time,
-                                                                                                                        const double end_time)
-               :
-               Function<dim> (dim),
-               present_time (present_time),
-               end_time (end_time),
-               shear_force (2e4),
-               Youngs_modulus (2.e11),
-               Poissons_ratio (.3),
-               length (.48),
-               depth (.12),
-               thickness (.01)
-               {}
-
-
-               template <int dim>
-               void
-               IncrementalBoundaryValues<dim>::
-               vector_value (const Point<dim> &p,
-                                                                       Vector<double>   &values) const
-               {
-                       AssertThrow (values.size() == dim,
-                                                                        ExcDimensionMismatch (values.size(), dim));
-                       AssertThrow (dim == 2, ExcNotImplemented());
-
-
-                       // compute exact displacement of Timoshenko beam problem, u_bar
-                       double inertia_moment = (thickness*std::pow(depth,3)) / 12;
-
-                       double x = p(0);
-                       double y = p(1);
-
-                       double fac = shear_force / (6*Youngs_modulus*inertia_moment);
-
-                       values(0) =  fac * y * ( (6*length-3*x)*x + (2+Poissons_ratio)*(y*y-depth*depth/4) );
-                       values(1) = -fac* ( 3*Poissons_ratio*y*y*(length-x) + 0.25*(4+5*Poissons_ratio)*depth*depth*x + (3*length-x)*x*x );
-
-                       // compute the fraction of imposed force
-                       const double frac = present_time/end_time;
-
-                       values *= frac;
-               }
-
-
-
-               template <int dim>
-               void
-               IncrementalBoundaryValues<dim>::
-               vector_value_list (const std::vector<Point<dim> > &points,
-                                                                                        std::vector<Vector<double> >   &value_list) const
-               {
-                       const unsigned int n_points = points.size();
-
-                       Assert (value_list.size() == n_points,
-                                                       ExcDimensionMismatch (value_list.size(), n_points));
-
-                       for (unsigned int p=0; p<n_points; ++p)
-                               IncrementalBoundaryValues<dim>::vector_value (points[p],
-                                               value_list[p]);
-               }
-               */
-
-       // ------------------------- Thick_tube_internal_pressure ----------------------------------
-       /*
-  template <int dim>
-               class IncrementalBoundaryForce : public Function<dim>
-               {
-               public:
-                       IncrementalBoundaryForce (const double present_time,
-                                                                                                                               const double end_time);
-
-                       virtual
-                       void vector_value (const Point<dim> &p,
-                                                                                                Vector<double> &values) const;
-
-                       virtual
-                       void
-                       vector_value_list (const std::vector<Point<dim> > &points,
-                                                                                                std::vector<Vector<double> >   &value_list) const;
-               private:
-                       const double present_time,
-                                                                        end_time,
-                                                                        pressure,
-                                                                        inner_radius;
-               };
-
-               template <int dim>
-               IncrementalBoundaryForce<dim>::
-               IncrementalBoundaryForce (const double present_time,
-                                                                                                                       const double end_time)
-               :
-               Function<dim>(dim),
-               present_time (present_time),
-               end_time (end_time),
-    pressure (0.6*2.4e8),
-//    pressure (1.94e8),
-    inner_radius(.1)
-               {}
-
-               template <int dim>
-               void
-               IncrementalBoundaryForce<dim>::vector_value (const Point<dim> &p,
-                                                                                                                                                                                                Vector<double> &values) const
-               {
-                       AssertThrow (dim == 2, ExcNotImplemented());
-                       AssertThrow (values.size() == dim,
-                                       ExcDimensionMismatch (values.size(), dim));
-
-       const double eps = 1.e-7 * inner_radius,
-                                                        radius = p.norm();
-                       // compute traction on the inner boundary, t_bar
-       AssertThrow(radius < (eps+inner_radius), ExcInternalError());
-
-       const double theta = std::atan2(p(1),p(0));
-
-       values(0) = pressure * std::cos(theta);
-       values(1) = pressure * std::sin(theta);
-
-                       // compute the fraction of imposed force
-                       const double frac = present_time/end_time;
-
-                       values *= frac;
-               }
-
-               template <int dim>
-               void
-               IncrementalBoundaryForce<dim>::
-               vector_value_list (const std::vector<Point<dim> > &points,
-                                                                                        std::vector<Vector<double> >   &value_list) const
-               {
-                       const unsigned int n_points = points.size();
-
-                       Assert (value_list.size() == n_points,
-                                                       ExcDimensionMismatch (value_list.size(), n_points));
-
-                       for (unsigned int p=0; p<n_points; ++p)
-                               IncrementalBoundaryForce<dim>::vector_value (points[p],
-                                               value_list[p]);
-               }
-
-
-               template <int dim>
-               class BodyForce :  public ZeroFunction<dim>
-               {
-               public:
-                       BodyForce () : ZeroFunction<dim> (dim) {}
-               };
-
-
-               template <int dim>
-               class IncrementalBoundaryValues :  public Function<dim>
-               {
-               public:
-                       IncrementalBoundaryValues (const double present_time,
-                                                                                                                                const double end_time);
-
-                       virtual
-                       void
-                       vector_value (const Point<dim> &p,
-                                                                               Vector<double>   &values) const;
-
-                       virtual
-                       void
-                       vector_value_list (const std::vector<Point<dim> > &points,
-                                                                                                std::vector<Vector<double> >   &value_list) const;
-
-               private:
-                       const double present_time,
-                                                                        end_time;
-               };
-
-
-               template <int dim>
-               IncrementalBoundaryValues<dim>::
-               IncrementalBoundaryValues (const double present_time,
-                                                                                                                        const double end_time)
-               :
-               Function<dim> (dim),
-               present_time (present_time),
-               end_time (end_time)
-               {}
-
-
-               template <int dim>
-               void
-               IncrementalBoundaryValues<dim>::
-               vector_value (const Point<dim> &p,
-                                                                       Vector<double>   &values) const
-               {
-                       AssertThrow (values.size() == dim,
-                                                                        ExcDimensionMismatch (values.size(), dim));
-                       AssertThrow (dim == 2, ExcNotImplemented());
-
-                       values = 0.;
-               }
-
-
-
-               template <int dim>
-               void
-               IncrementalBoundaryValues<dim>::
-               vector_value_list (const std::vector<Point<dim> > &points,
-                                                                                        std::vector<Vector<double> >   &value_list) const
-               {
-                       const unsigned int n_points = points.size();
-
-                       Assert (value_list.size() == n_points,
-                                                       ExcDimensionMismatch (value_list.size(), n_points));
-
-                       for (unsigned int p=0; p<n_points; ++p)
-                               IncrementalBoundaryValues<dim>::vector_value (points[p],
-                                               value_list[p]);
-               }
-               */
-
-               // ------------------------- Perforated_strip_tension ----------------------------------
-       /*
-               template <int dim>
-               class IncrementalBoundaryForce : public Function<dim>
-               {
-               public:
-                       IncrementalBoundaryForce (const double present_time,
-                                                                                                                               const double end_time);
-
-                       virtual
-                       void vector_value (const Point<dim> &p,
-                                                                                                Vector<double> &values) const;
-
-                       virtual
-                       void
-                       vector_value_list (const std::vector<Point<dim> > &points,
-                                                                                                std::vector<Vector<double> >   &value_list) const;
-               private:
-                       const double present_time,
-                                                                        end_time;
-               };
-
-               template <int dim>
-               IncrementalBoundaryForce<dim>::
-               IncrementalBoundaryForce (const double present_time,
-                                                                                                                       const double end_time)
-               :
-               Function<dim>(dim),
-               present_time (present_time),
-               end_time (end_time)
-               {}
-
-               template <int dim>
-               void
-               IncrementalBoundaryForce<dim>::vector_value (const Point<dim> &p,
-                                                                                                                                                                                                Vector<double> &values) const
-               {
-                       AssertThrow (values.size() == dim,
-                                                                        ExcDimensionMismatch (values.size(), dim));
-
-                       values = 0;
-
-                       // compute the fraction of imposed force
-                       const double frac = present_time/end_time;
-
-                       values *= frac;
-               }
-
-               template <int dim>
-               void
-               IncrementalBoundaryForce<dim>::
-               vector_value_list (const std::vector<Point<dim> > &points,
-                                                                                        std::vector<Vector<double> >   &value_list) const
-               {
-                       const unsigned int n_points = points.size();
-
-                       Assert (value_list.size() == n_points,
-                                                       ExcDimensionMismatch (value_list.size(), n_points));
-
-                       for (unsigned int p=0; p<n_points; ++p)
-                               IncrementalBoundaryForce<dim>::vector_value (points[p],
-                                               value_list[p]);
-               }
-
-
-               template <int dim>
-               class BodyForce :  public ZeroFunction<dim>
-               {
-               public:
-                       BodyForce () : ZeroFunction<dim> (dim) {}
-               };
-
-
-               template <int dim>
-               class IncrementalBoundaryValues :  public Function<dim>
-               {
-               public:
-                       IncrementalBoundaryValues (const double present_time,
-                                                                                                                                const double end_time);
-
-                       virtual
-                       void
-                       vector_value (const Point<dim> &p,
-                                                                               Vector<double>   &values) const;
-
-                       virtual
-                       void
-                       vector_value_list (const std::vector<Point<dim> > &points,
-                                                                                                std::vector<Vector<double> >   &value_list) const;
-
-               private:
-                       const double present_time,
-                                                                        end_time,
-                                                                        imposed_displacement,
-                                                                        height;
-               };
-
-
-               template <int dim>
-               IncrementalBoundaryValues<dim>::
-               IncrementalBoundaryValues (const double present_time,
-                                                                                                                        const double end_time)
-               :
-               Function<dim> (dim),
-               present_time (present_time),
-               end_time (end_time),
-               imposed_displacement (0.00055),
-               height (0.18)
-               {}
-
-
-               template <int dim>
-               void
-               IncrementalBoundaryValues<dim>::
-               vector_value (const Point<dim> &p,
-                                                                       Vector<double>   &values) const
-               {
-                       AssertThrow (values.size() == dim,
-                                                                        ExcDimensionMismatch (values.size(), dim));
-
-                       const double eps = 1.e-8 * height;
-
-                       values = 0.;
-
-                       // impose displacement only on the top edge
-                       if (std::abs(p[1]-height) < eps)
-                       {
-                               // compute the fraction of imposed displacement
-                               const double inc_frac = 1/end_time;
-
-                               values(1) = inc_frac*imposed_displacement;
-                       }
-
-               }
-
-
-
-               template <int dim>
-               void
-               IncrementalBoundaryValues<dim>::
-               vector_value_list (const std::vector<Point<dim> > &points,
-                                                                                        std::vector<Vector<double> >   &value_list) const
-               {
-                       const unsigned int n_points = points.size();
-
-                       Assert (value_list.size() == n_points,
-                                                       ExcDimensionMismatch (value_list.size(), n_points));
-
-                       for (unsigned int p=0; p<n_points; ++p)
-                               IncrementalBoundaryValues<dim>::vector_value (points[p],
-                                               value_list[p]);
-               }
-               */
-
-               // ------------------------- Cantiliver_beam_3d ----------------------------------
-         template <int dim>
-         class IncrementalBoundaryForce : public Function<dim>
-         {
-         public:
-               IncrementalBoundaryForce (const double present_time,
-                                                                                                                       const double end_time);
-
-               virtual
-               void vector_value (const Point<dim> &p,
-                                                                                        Vector<double> &values) const;
-
-               virtual
-               void
-               vector_value_list (const std::vector<Point<dim> > &points,
-                                                                                        std::vector<Vector<double> >   &value_list) const;
-
-         private:
-               const double present_time,
-                                                                end_time,
-                                                                pressure,
-                                                                height;
-         };
-
-         template <int dim>
-         IncrementalBoundaryForce<dim>::
-         IncrementalBoundaryForce (const double present_time,
-                                                                                                               const double end_time)
-         :
-         Function<dim>(dim),
-         present_time (present_time),
-         end_time (end_time),
-         pressure (6e6),
-         height (200e-3)
-         {}
-
-         template <int dim>
-         void
-         IncrementalBoundaryForce<dim>::vector_value (const Point<dim> &p,
-                                                                                                                                                                                        Vector<double> &values) const
-         {
-               AssertThrow (dim == 3, ExcNotImplemented());
-               AssertThrow (values.size() == dim,
-                                                                ExcDimensionMismatch (values.size(), dim));
-
-               const double eps = 1.e-7 * height;
-
-               // pressure should be imposed on the top surface, y = height
-               AssertThrow(std::abs(p[1]-(height/2)) < eps, ExcInternalError());
-
-               values = 0;
-
-               values(1) = -pressure;
-
-               // compute the fraction of imposed force
-               const double frac = present_time/end_time;
-
-               values *= frac;
-         }
-
-         template <int dim>
-         void
-         IncrementalBoundaryForce<dim>::
-         vector_value_list (const std::vector<Point<dim> > &points,
-                                                                                std::vector<Vector<double> >   &value_list) const
-         {
-               const unsigned int n_points = points.size();
-
-               Assert (value_list.size() == n_points,
-                                               ExcDimensionMismatch (value_list.size(), n_points));
-
-               for (unsigned int p=0; p<n_points; ++p)
-                       IncrementalBoundaryForce<dim>::vector_value (points[p], value_list[p]);
-         }
-
-
-         template <int dim>
-         class BodyForce :  public ZeroFunction<dim>
-         {
-         public:
-               BodyForce () : ZeroFunction<dim> (dim) {}
-         };
-
-
-         template <int dim>
-         class IncrementalBoundaryValues :  public Function<dim>
-         {
-         public:
-               IncrementalBoundaryValues (const double present_time,
-                                                                                                                        const double end_time);
-
-               virtual
-               void
-               vector_value (const Point<dim> &p,
-                                                                       Vector<double>   &values) const;
-
-               virtual
-               void
-               vector_value_list (const std::vector<Point<dim> > &points,
-                                                                                        std::vector<Vector<double> >   &value_list) const;
-
-         private:
-               const double present_time,
-                                                                end_time;
-         };
-
-
-         template <int dim>
-         IncrementalBoundaryValues<dim>::
-         IncrementalBoundaryValues (const double present_time,
-                                                                                                                const double end_time)
-         :
-         Function<dim> (dim),
-         present_time (present_time),
-         end_time (end_time)
-         {}
-
-
-         template <int dim>
-         void
-         IncrementalBoundaryValues<dim>::
-         vector_value (const Point<dim> &p,
-                                                               Vector<double>   &values) const
-         {
-               AssertThrow (values.size() == dim,
-                                                                ExcDimensionMismatch (values.size(), dim));
-               AssertThrow (dim == 3, ExcNotImplemented());
-
-               values = 0.;
-         }
-
-
-         template <int dim>
-         void
-         IncrementalBoundaryValues<dim>::
-         vector_value_list (const std::vector<Point<dim> > &points,
-                                                                                std::vector<Vector<double> >   &value_list) const
-         {
-               const unsigned int n_points = points.size();
-
-               Assert (value_list.size() == n_points,
-                                               ExcDimensionMismatch (value_list.size(), n_points));
-
-               for (unsigned int p=0; p<n_points; ++p)
-                       IncrementalBoundaryValues<dim>::vector_value (points[p], value_list[p]);
-         }
-
-               // -------------------------------------------------------------------------------
-  }
-
+    // ----------------------------- TimoshenkoBeam ---------------------------------------
+    /*
+    template <int dim>
+    class IncrementalBoundaryForce : public Function<dim>
+    {
+    public:
+      IncrementalBoundaryForce (const double present_time,
+                                const double end_time);
 
-  namespace DualFunctional
-  {
+      virtual
+      void vector_value (const Point<dim> &p,
+                         Vector<double> &values) const;
 
-               template <int dim>
-               class DualFunctionalBase : public Subscriptor
-               {
-               public:
-                       virtual
-                       void
-                       assemble_rhs (const DoFHandler<dim>              &dof_handler,
-                                                                               const Vector<double>             &solution,
-                                                                               const ConstitutiveLaw<dim> &constitutive_law,
-                                                                               const DoFHandler<dim>            &dof_handler_dual,
-                                                                               Vector<double>                   &rhs_dual) const = 0;
-               };
+      virtual
+      void
+      vector_value_list (const std::vector<Point<dim> > &points,
+                         std::vector<Vector<double> >   &value_list) const;
+    private:
+      const double present_time,
+                   end_time,
+                   shear_force,
+                   length,
+                   depth,
+                   thickness;
+    };
 
+    template <int dim>
+    IncrementalBoundaryForce<dim>::
+    IncrementalBoundaryForce (const double present_time,
+                                const double end_time)
+    :
+    Function<dim>(dim),
+    present_time (present_time),
+    end_time (end_time),
+    shear_force (2e4),
+    length (.48),
+    depth (.12),
+    thickness (.01)
+    {}
 
     template <int dim>
-    class PointValuesEvaluation : public DualFunctionalBase<dim>
+    void
+    IncrementalBoundaryForce<dim>::vector_value (const Point<dim> &p,
+                                                 Vector<double> &values) const
     {
-    public:
-      PointValuesEvaluation (const Point<dim> &evaluation_point);
+      AssertThrow (values.size() == dim,
+          ExcDimensionMismatch (values.size(), dim));
+      AssertThrow (dim == 2, ExcNotImplemented());
 
-      virtual
-      void
-      assemble_rhs (const DoFHandler<dim>               &dof_handler,
-                                                                               const Vector<double>             &solution,
-                                                                               const ConstitutiveLaw<dim> &constitutive_law,
-                                                                               const DoFHandler<dim>            &dof_handler_dual,
-                                                                               Vector<double>                   &rhs_dual) const;
+      // compute traction on the right face of Timoshenko beam problem, t_bar
+      double inertia_moment = (thickness*std::pow(depth,3)) / 12;
 
-      DeclException1 (ExcEvaluationPointNotFound,
-                      Point<dim>,
-                      << "The evaluation point " << arg1
-                      << " was not found among the vertices of the present grid.");
+      double x = p(0);
+      double y = p(1);
 
-    protected:
-      const Point<dim> evaluation_point;
-    };
+      AssertThrow(std::fabs(x-length)<1e-12, ExcNotImplemented());
 
+      values(0) = 0;
+      values(1) = - shear_force/(2*inertia_moment) * ( depth*depth/4-y*y );
 
-    template <int dim>
-    PointValuesEvaluation<dim>::
-    PointValuesEvaluation (const Point<dim> &evaluation_point)
-      :
-      evaluation_point (evaluation_point)
-    {}
+      // compute the fraction of imposed force
+      const double frac = present_time/end_time;
 
+      values *= frac;
+    }
 
     template <int dim>
     void
-    PointValuesEvaluation<dim>::
-    assemble_rhs (const DoFHandler<dim>                 &dof_handler,
-                                                                       const Vector<double>             &solution,
-                                                                       const ConstitutiveLaw<dim> &constitutive_law,
-                                                                       const DoFHandler<dim>            &dof_handler_dual,
-                                                                       Vector<double>                   &rhs_dual) const
+    IncrementalBoundaryForce<dim>::
+    vector_value_list (const std::vector<Point<dim> > &points,
+                       std::vector<Vector<double> >   &value_list) const
     {
-      rhs_dual.reinit (dof_handler_dual.n_dofs());
-      const unsigned int dofs_per_vertex = dof_handler_dual.get_fe().dofs_per_vertex;
+      const unsigned int n_points = points.size();
 
-      typename DoFHandler<dim>::active_cell_iterator
-      cell_dual = dof_handler_dual.begin_active(),
-      endc_dual = dof_handler_dual.end();
-      for (; cell_dual!=endc_dual; ++cell_dual)
-        for (unsigned int vertex=0;
-             vertex<GeometryInfo<dim>::vertices_per_cell;
-             ++vertex)
-          if (cell_dual->vertex(vertex).distance(evaluation_point)
-              < cell_dual->diameter()*1e-8)
-            {
-                       for (unsigned int id=0; id!=dofs_per_vertex; ++id)
-                       {
-                               rhs_dual(cell_dual->vertex_dof_index(vertex,id)) = 1;
-                       }
-              return;
-            }
+      Assert (value_list.size() == n_points,
+              ExcDimensionMismatch (value_list.size(), n_points));
 
-      AssertThrow (false, ExcEvaluationPointNotFound(evaluation_point));
+      for (unsigned int p=0; p<n_points; ++p)
+        IncrementalBoundaryForce<dim>::vector_value (points[p],
+            value_list[p]);
     }
 
 
     template <int dim>
-    class PointXDerivativesEvaluation : public DualFunctionalBase<dim>
+    class BodyForce :  public ZeroFunction<dim>
     {
     public:
-      PointXDerivativesEvaluation (const Point<dim> &evaluation_point);
+      BodyForce () : ZeroFunction<dim> (dim) {}
+    };
+
+    template <int dim>
+    class IncrementalBoundaryValues :  public Function<dim>
+    {
+    public:
+      IncrementalBoundaryValues (const double present_time,
+                                 const double end_time);
 
       virtual
       void
-      assemble_rhs (const DoFHandler<dim>               &dof_handler,
-                                                                               const Vector<double>             &solution,
-                                                                               const ConstitutiveLaw<dim> &constitutive_law,
-                                                                               const DoFHandler<dim>            &dof_handler_dual,
-                                                                               Vector<double>                   &rhs_dual) const;
+      vector_value (const Point<dim> &p,
+                    Vector<double>   &values) const;
 
-      DeclException1 (ExcEvaluationPointNotFound,
-                      Point<dim>,
-                      << "The evaluation point " << arg1
-                      << " was not found among the vertices of the present grid.");
+      virtual
+      void
+      vector_value_list (const std::vector<Point<dim> > &points,
+                         std::vector<Vector<double> >   &value_list) const;
 
-    protected:
-      const Point<dim> evaluation_point;
+    private:
+      const double present_time,
+                   end_time,
+                   shear_force,
+                   Youngs_modulus,
+                   Poissons_ratio,
+                   length,
+                   depth,
+                   thickness;
     };
 
 
     template <int dim>
-    PointXDerivativesEvaluation<dim>::
-    PointXDerivativesEvaluation (const Point<dim> &evaluation_point)
-      :
-      evaluation_point (evaluation_point)
+    IncrementalBoundaryValues<dim>::
+    IncrementalBoundaryValues (const double present_time,
+                               const double end_time)
+    :
+    Function<dim> (dim),
+    present_time (present_time),
+    end_time (end_time),
+    shear_force (2e4),
+    Youngs_modulus (2.e11),
+    Poissons_ratio (.3),
+    length (.48),
+    depth (.12),
+    thickness (.01)
     {}
 
 
     template <int dim>
     void
-    PointXDerivativesEvaluation<dim>::
-    assemble_rhs (const DoFHandler<dim>                 &dof_handler,
-                                                                       const Vector<double>             &solution,
-                                                                       const ConstitutiveLaw<dim> &constitutive_law,
-                                                                       const DoFHandler<dim>            &dof_handler_dual,
-                                                                       Vector<double>                   &rhs_dual) const
+    IncrementalBoundaryValues<dim>::
+    vector_value (const Point<dim> &p,
+                  Vector<double>   &values) const
     {
-      rhs_dual.reinit (dof_handler_dual.n_dofs());
-      const unsigned int dofs_per_vertex = dof_handler_dual.get_fe().dofs_per_vertex;
+      AssertThrow (values.size() == dim,
+                   ExcDimensionMismatch (values.size(), dim));
+      AssertThrow (dim == 2, ExcNotImplemented());
 
-      QGauss<dim> quadrature(4);
-      FEValues<dim>  fe_values (dof_handler_dual.get_fe(), quadrature,
-                                update_gradients |
-                                update_quadrature_points  |
-                                update_JxW_values);
-      const unsigned int n_q_points = fe_values.n_quadrature_points;
-      Assert ( n_q_points==quadrature.size() , ExcInternalError() );
-      const unsigned int dofs_per_cell = dof_handler_dual.get_fe().dofs_per_cell;
 
-      Vector<double> cell_rhs (dofs_per_cell);
-      std::vector<types::global_dof_index> local_dof_indices (dofs_per_cell);
+      // compute exact displacement of Timoshenko beam problem, u_bar
+      double inertia_moment = (thickness*std::pow(depth,3)) / 12;
 
-      double total_volume = 0;
+      double x = p(0);
+      double y = p(1);
 
-      typename DoFHandler<dim>::active_cell_iterator
-      cell = dof_handler_dual.begin_active(),
-      endc = dof_handler_dual.end();
-      for (; cell!=endc; ++cell)
-        if (cell->center().distance(evaluation_point) <=
-            cell->diameter())
-          {
-            fe_values.reinit (cell);
-            cell_rhs = 0;
+      double fac = shear_force / (6*Youngs_modulus*inertia_moment);
 
-            for (unsigned int q=0; q<n_q_points; ++q)
-              {
-                for (unsigned int i=0; i<dofs_per_cell; ++i)
-                {
-                       const unsigned int
-                       component_i = dof_handler_dual.get_fe().system_to_component_index(i).first;
+      values(0) =  fac * y * ( (6*length-3*x)*x + (2+Poissons_ratio)*(y*y-depth*depth/4) );
+      values(1) = -fac* ( 3*Poissons_ratio*y*y*(length-x) + 0.25*(4+5*Poissons_ratio)*depth*depth*x + (3*length-x)*x*x );
 
-                       cell_rhs(i) += fe_values.shape_grad(i,q)[0] *
-                                       fe_values.JxW (q);
-                }
+      // compute the fraction of imposed force
+      const double frac = present_time/end_time;
 
-                total_volume += fe_values.JxW (q);
-              }
+      values *= frac;
+    }
 
-            cell->get_dof_indices (local_dof_indices);
-            for (unsigned int i=0; i<dofs_per_cell; ++i)
-            {
-              rhs_dual(local_dof_indices[i]) += cell_rhs(i);
-            }
+
+
+    template <int dim>
+    void
+    IncrementalBoundaryValues<dim>::
+    vector_value_list (const std::vector<Point<dim> > &points,
+                       std::vector<Vector<double> >   &value_list) const
+    {
+      const unsigned int n_points = points.size();
+
+      Assert (value_list.size() == n_points,
+              ExcDimensionMismatch (value_list.size(), n_points));
+
+      for (unsigned int p=0; p<n_points; ++p)
+        IncrementalBoundaryValues<dim>::vector_value (points[p],
+            value_list[p]);
+    }
+    */
+
+    // ------------------------- Thick_tube_internal_pressure ----------------------------------
+    /*
+    template <int dim>
+      class IncrementalBoundaryForce : public Function<dim>
+      {
+      public:
+        IncrementalBoundaryForce (const double present_time,
+                                  const double end_time);
+
+        virtual
+        void vector_value (const Point<dim> &p,
+                           Vector<double> &values) const;
+
+        virtual
+        void
+        vector_value_list (const std::vector<Point<dim> > &points,
+                           std::vector<Vector<double> >   &value_list) const;
+      private:
+        const double present_time,
+                     end_time,
+                     pressure,
+                     inner_radius;
+      };
+
+      template <int dim>
+      IncrementalBoundaryForce<dim>::
+      IncrementalBoundaryForce (const double present_time,
+                                const double end_time)
+      :
+      Function<dim>(dim),
+      present_time (present_time),
+      end_time (end_time),
+      pressure (0.6*2.4e8),
+    //    pressure (1.94e8),
+      inner_radius(.1)
+      {}
+
+      template <int dim>
+      void
+      IncrementalBoundaryForce<dim>::vector_value (const Point<dim> &p,
+                                                   Vector<double> &values) const
+      {
+        AssertThrow (dim == 2, ExcNotImplemented());
+        AssertThrow (values.size() == dim,
+            ExcDimensionMismatch (values.size(), dim));
+
+        const double eps = 1.e-7 * inner_radius,
+                     radius = p.norm();
+        // compute traction on the inner boundary, t_bar
+        AssertThrow(radius < (eps+inner_radius), ExcInternalError());
+
+        const double theta = std::atan2(p(1),p(0));
+
+        values(0) = pressure * std::cos(theta);
+        values(1) = pressure * std::sin(theta);
+
+        // compute the fraction of imposed force
+        const double frac = present_time/end_time;
+
+        values *= frac;
+      }
+
+      template <int dim>
+      void
+      IncrementalBoundaryForce<dim>::
+      vector_value_list (const std::vector<Point<dim> > &points,
+                         std::vector<Vector<double> >   &value_list) const
+      {
+        const unsigned int n_points = points.size();
+
+        Assert (value_list.size() == n_points,
+                ExcDimensionMismatch (value_list.size(), n_points));
+
+        for (unsigned int p=0; p<n_points; ++p)
+          IncrementalBoundaryForce<dim>::vector_value (points[p],
+              value_list[p]);
+      }
+
+
+      template <int dim>
+      class BodyForce :  public ZeroFunction<dim>
+      {
+      public:
+        BodyForce () : ZeroFunction<dim> (dim) {}
+      };
+
+
+      template <int dim>
+      class IncrementalBoundaryValues :  public Function<dim>
+      {
+      public:
+        IncrementalBoundaryValues (const double present_time,
+                                   const double end_time);
+
+        virtual
+        void
+        vector_value (const Point<dim> &p,
+                      Vector<double>   &values) const;
+
+        virtual
+        void
+        vector_value_list (const std::vector<Point<dim> > &points,
+                           std::vector<Vector<double> >   &value_list) const;
+
+      private:
+        const double present_time,
+                     end_time;
+      };
+
+
+      template <int dim>
+      IncrementalBoundaryValues<dim>::
+      IncrementalBoundaryValues (const double present_time,
+                                 const double end_time)
+      :
+      Function<dim> (dim),
+      present_time (present_time),
+      end_time (end_time)
+      {}
+
+
+      template <int dim>
+      void
+      IncrementalBoundaryValues<dim>::
+      vector_value (const Point<dim> &p,
+                    Vector<double>   &values) const
+      {
+        AssertThrow (values.size() == dim,
+                     ExcDimensionMismatch (values.size(), dim));
+        AssertThrow (dim == 2, ExcNotImplemented());
+
+        values = 0.;
+      }
+
+
+
+      template <int dim>
+      void
+      IncrementalBoundaryValues<dim>::
+      vector_value_list (const std::vector<Point<dim> > &points,
+                         std::vector<Vector<double> >   &value_list) const
+      {
+        const unsigned int n_points = points.size();
+
+        Assert (value_list.size() == n_points,
+                ExcDimensionMismatch (value_list.size(), n_points));
+
+        for (unsigned int p=0; p<n_points; ++p)
+          IncrementalBoundaryValues<dim>::vector_value (points[p],
+              value_list[p]);
+      }
+      */
+
+    // ------------------------- Perforated_strip_tension ----------------------------------
+    /*
+    template <int dim>
+    class IncrementalBoundaryForce : public Function<dim>
+    {
+    public:
+      IncrementalBoundaryForce (const double present_time,
+                                const double end_time);
+
+      virtual
+      void vector_value (const Point<dim> &p,
+                         Vector<double> &values) const;
+
+      virtual
+      void
+      vector_value_list (const std::vector<Point<dim> > &points,
+                         std::vector<Vector<double> >   &value_list) const;
+    private:
+      const double present_time,
+                   end_time;
+    };
+
+    template <int dim>
+    IncrementalBoundaryForce<dim>::
+    IncrementalBoundaryForce (const double present_time,
+                              const double end_time)
+    :
+    Function<dim>(dim),
+    present_time (present_time),
+    end_time (end_time)
+    {}
+
+    template <int dim>
+    void
+    IncrementalBoundaryForce<dim>::vector_value (const Point<dim> &p,
+                                                 Vector<double> &values) const
+    {
+      AssertThrow (values.size() == dim,
+                   ExcDimensionMismatch (values.size(), dim));
+
+      values = 0;
+
+      // compute the fraction of imposed force
+      const double frac = present_time/end_time;
+
+      values *= frac;
+    }
+
+    template <int dim>
+    void
+    IncrementalBoundaryForce<dim>::
+    vector_value_list (const std::vector<Point<dim> > &points,
+                       std::vector<Vector<double> >   &value_list) const
+    {
+      const unsigned int n_points = points.size();
+
+      Assert (value_list.size() == n_points,
+              ExcDimensionMismatch (value_list.size(), n_points));
+
+      for (unsigned int p=0; p<n_points; ++p)
+        IncrementalBoundaryForce<dim>::vector_value (points[p],
+            value_list[p]);
+    }
+
+
+    template <int dim>
+    class BodyForce :  public ZeroFunction<dim>
+    {
+    public:
+      BodyForce () : ZeroFunction<dim> (dim) {}
+    };
+
+
+    template <int dim>
+    class IncrementalBoundaryValues :  public Function<dim>
+    {
+    public:
+      IncrementalBoundaryValues (const double present_time,
+                                 const double end_time);
+
+      virtual
+      void
+      vector_value (const Point<dim> &p,
+                    Vector<double>   &values) const;
+
+      virtual
+      void
+      vector_value_list (const std::vector<Point<dim> > &points,
+                         std::vector<Vector<double> >   &value_list) const;
+
+    private:
+      const double present_time,
+                   end_time,
+                   imposed_displacement,
+                   height;
+    };
+
+
+    template <int dim>
+    IncrementalBoundaryValues<dim>::
+    IncrementalBoundaryValues (const double present_time,
+                               const double end_time)
+    :
+    Function<dim> (dim),
+    present_time (present_time),
+    end_time (end_time),
+    imposed_displacement (0.00055),
+    height (0.18)
+    {}
+
+
+    template <int dim>
+    void
+    IncrementalBoundaryValues<dim>::
+    vector_value (const Point<dim> &p,
+                  Vector<double>   &values) const
+    {
+      AssertThrow (values.size() == dim,
+                   ExcDimensionMismatch (values.size(), dim));
+
+      const double eps = 1.e-8 * height;
+
+      values = 0.;
+
+      // impose displacement only on the top edge
+      if (std::abs(p[1]-height) < eps)
+      {
+        // compute the fraction of imposed displacement
+        const double inc_frac = 1/end_time;
+
+        values(1) = inc_frac*imposed_displacement;
+      }
+
+    }
+
+
+
+    template <int dim>
+    void
+    IncrementalBoundaryValues<dim>::
+    vector_value_list (const std::vector<Point<dim> > &points,
+                       std::vector<Vector<double> >   &value_list) const
+    {
+      const unsigned int n_points = points.size();
+
+      Assert (value_list.size() == n_points,
+              ExcDimensionMismatch (value_list.size(), n_points));
+
+      for (unsigned int p=0; p<n_points; ++p)
+        IncrementalBoundaryValues<dim>::vector_value (points[p],
+            value_list[p]);
+    }
+    */
+
+    // ------------------------- Cantiliver_beam_3d ----------------------------------
+    template <int dim>
+    class IncrementalBoundaryForce : public Function<dim>
+    {
+    public:
+      IncrementalBoundaryForce (const double present_time,
+                                const double end_time);
+
+      virtual
+      void vector_value (const Point<dim> &p,
+                         Vector<double> &values) const;
+
+      virtual
+      void
+      vector_value_list (const std::vector<Point<dim> > &points,
+                         std::vector<Vector<double> >   &value_list) const;
+
+    private:
+      const double present_time,
+            end_time,
+            pressure,
+            height;
+    };
+
+    template <int dim>
+    IncrementalBoundaryForce<dim>::
+    IncrementalBoundaryForce (const double present_time,
+                              const double end_time)
+      :
+      Function<dim>(dim),
+      present_time (present_time),
+      end_time (end_time),
+      pressure (6e6),
+      height (200e-3)
+    {}
+
+    template <int dim>
+    void
+    IncrementalBoundaryForce<dim>::vector_value (const Point<dim> &p,
+                                                 Vector<double> &values) const
+    {
+      AssertThrow (dim == 3, ExcNotImplemented());
+      AssertThrow (values.size() == dim,
+                   ExcDimensionMismatch (values.size(), dim));
+
+      const double eps = 1.e-7 * height;
+
+      // pressure should be imposed on the top surface, y = height
+      AssertThrow(std::abs(p[1]-(height/2)) < eps, ExcInternalError());
+
+      values = 0;
+
+      values(1) = -pressure;
+
+      // compute the fraction of imposed force
+      const double frac = present_time/end_time;
+
+      values *= frac;
+    }
+
+    template <int dim>
+    void
+    IncrementalBoundaryForce<dim>::
+    vector_value_list (const std::vector<Point<dim> > &points,
+                       std::vector<Vector<double> >   &value_list) const
+    {
+      const unsigned int n_points = points.size();
+
+      Assert (value_list.size() == n_points,
+              ExcDimensionMismatch (value_list.size(), n_points));
+
+      for (unsigned int p=0; p<n_points; ++p)
+        IncrementalBoundaryForce<dim>::vector_value (points[p], value_list[p]);
+    }
+
+
+    template <int dim>
+    class BodyForce :  public ZeroFunction<dim>
+    {
+    public:
+      BodyForce () : ZeroFunction<dim> (dim) {}
+    };
+
+
+    template <int dim>
+    class IncrementalBoundaryValues :  public Function<dim>
+    {
+    public:
+      IncrementalBoundaryValues (const double present_time,
+                                 const double end_time);
+
+      virtual
+      void
+      vector_value (const Point<dim> &p,
+                    Vector<double>   &values) const;
+
+      virtual
+      void
+      vector_value_list (const std::vector<Point<dim> > &points,
+                         std::vector<Vector<double> >   &value_list) const;
+
+    private:
+      const double present_time,
+            end_time;
+    };
+
+
+    template <int dim>
+    IncrementalBoundaryValues<dim>::
+    IncrementalBoundaryValues (const double present_time,
+                               const double end_time)
+      :
+      Function<dim> (dim),
+      present_time (present_time),
+      end_time (end_time)
+    {}
+
+
+    template <int dim>
+    void
+    IncrementalBoundaryValues<dim>::
+    vector_value (const Point<dim> &p,
+                  Vector<double>   &values) const
+    {
+      AssertThrow (values.size() == dim,
+                   ExcDimensionMismatch (values.size(), dim));
+      AssertThrow (dim == 3, ExcNotImplemented());
+
+      values = 0.;
+    }
+
+
+    template <int dim>
+    void
+    IncrementalBoundaryValues<dim>::
+    vector_value_list (const std::vector<Point<dim> > &points,
+                       std::vector<Vector<double> >   &value_list) const
+    {
+      const unsigned int n_points = points.size();
+
+      Assert (value_list.size() == n_points,
+              ExcDimensionMismatch (value_list.size(), n_points));
+
+      for (unsigned int p=0; p<n_points; ++p)
+        IncrementalBoundaryValues<dim>::vector_value (points[p], value_list[p]);
+    }
+
+    // -------------------------------------------------------------------------------
+  }
+
+
+  namespace DualFunctional
+  {
+
+    template <int dim>
+    class DualFunctionalBase : public Subscriptor
+    {
+    public:
+      virtual
+      void
+      assemble_rhs (const DoFHandler<dim>      &dof_handler,
+                    const Vector<double>       &solution,
+                    const ConstitutiveLaw<dim> &constitutive_law,
+                    const DoFHandler<dim>      &dof_handler_dual,
+                    Vector<double>             &rhs_dual) const = 0;
+    };
+
+
+    template <int dim>
+    class PointValuesEvaluation : public DualFunctionalBase<dim>
+    {
+    public:
+      PointValuesEvaluation (const Point<dim> &evaluation_point);
+
+      virtual
+      void
+      assemble_rhs (const DoFHandler<dim>      &dof_handler,
+                    const Vector<double>       &solution,
+                    const ConstitutiveLaw<dim> &constitutive_law,
+                    const DoFHandler<dim>      &dof_handler_dual,
+                    Vector<double>             &rhs_dual) const;
+
+      DeclException1 (ExcEvaluationPointNotFound,
+                      Point<dim>,
+                      << "The evaluation point " << arg1
+                      << " was not found among the vertices of the present grid.");
+
+    protected:
+      const Point<dim> evaluation_point;
+    };
+
+
+    template <int dim>
+    PointValuesEvaluation<dim>::
+    PointValuesEvaluation (const Point<dim> &evaluation_point)
+      :
+      evaluation_point (evaluation_point)
+    {}
+
+
+    template <int dim>
+    void
+    PointValuesEvaluation<dim>::
+    assemble_rhs (const DoFHandler<dim>      &dof_handler,
+                  const Vector<double>       &solution,
+                  const ConstitutiveLaw<dim> &constitutive_law,
+                  const DoFHandler<dim>      &dof_handler_dual,
+                  Vector<double>             &rhs_dual) const
+    {
+      rhs_dual.reinit (dof_handler_dual.n_dofs());
+      const unsigned int dofs_per_vertex = dof_handler_dual.get_fe().dofs_per_vertex;
+
+      typename DoFHandler<dim>::active_cell_iterator
+      cell_dual = dof_handler_dual.begin_active(),
+      endc_dual = dof_handler_dual.end();
+      for (; cell_dual!=endc_dual; ++cell_dual)
+        for (unsigned int vertex=0;
+             vertex<GeometryInfo<dim>::vertices_per_cell;
+             ++vertex)
+          if (cell_dual->vertex(vertex).distance(evaluation_point)
+              < cell_dual->diameter()*1e-8)
+            {
+              for (unsigned int id=0; id!=dofs_per_vertex; ++id)
+                {
+                  rhs_dual(cell_dual->vertex_dof_index(vertex,id)) = 1;
+                }
+              return;
+            }
+
+      AssertThrow (false, ExcEvaluationPointNotFound(evaluation_point));
+    }
+
+
+    template <int dim>
+    class PointXDerivativesEvaluation : public DualFunctionalBase<dim>
+    {
+    public:
+      PointXDerivativesEvaluation (const Point<dim> &evaluation_point);
+
+      virtual
+      void
+      assemble_rhs (const DoFHandler<dim>      &dof_handler,
+                    const Vector<double>       &solution,
+                    const ConstitutiveLaw<dim> &constitutive_law,
+                    const DoFHandler<dim>      &dof_handler_dual,
+                    Vector<double>             &rhs_dual) const;
+
+      DeclException1 (ExcEvaluationPointNotFound,
+                      Point<dim>,
+                      << "The evaluation point " << arg1
+                      << " was not found among the vertices of the present grid.");
+
+    protected:
+      const Point<dim> evaluation_point;
+    };
+
+
+    template <int dim>
+    PointXDerivativesEvaluation<dim>::
+    PointXDerivativesEvaluation (const Point<dim> &evaluation_point)
+      :
+      evaluation_point (evaluation_point)
+    {}
+
+
+    template <int dim>
+    void
+    PointXDerivativesEvaluation<dim>::
+    assemble_rhs (const DoFHandler<dim>      &dof_handler,
+                  const Vector<double>       &solution,
+                  const ConstitutiveLaw<dim> &constitutive_law,
+                  const DoFHandler<dim>      &dof_handler_dual,
+                  Vector<double>             &rhs_dual) const
+    {
+      rhs_dual.reinit (dof_handler_dual.n_dofs());
+      const unsigned int dofs_per_vertex = dof_handler_dual.get_fe().dofs_per_vertex;
+
+      QGauss<dim> quadrature(4);
+      FEValues<dim>  fe_values (dof_handler_dual.get_fe(), quadrature,
+                                update_gradients |
+                                update_quadrature_points  |
+                                update_JxW_values);
+      const unsigned int n_q_points = fe_values.n_quadrature_points;
+      Assert ( n_q_points==quadrature.size() , ExcInternalError() );
+      const unsigned int dofs_per_cell = dof_handler_dual.get_fe().dofs_per_cell;
+
+      Vector<double> cell_rhs (dofs_per_cell);
+      std::vector<types::global_dof_index> local_dof_indices (dofs_per_cell);
+
+      double total_volume = 0;
+
+      typename DoFHandler<dim>::active_cell_iterator
+      cell = dof_handler_dual.begin_active(),
+      endc = dof_handler_dual.end();
+      for (; cell!=endc; ++cell)
+        if (cell->center().distance(evaluation_point) <=
+            cell->diameter())
+          {
+            fe_values.reinit (cell);
+            cell_rhs = 0;
+
+            for (unsigned int q=0; q<n_q_points; ++q)
+              {
+                for (unsigned int i=0; i<dofs_per_cell; ++i)
+                  {
+                    const unsigned int
+                    component_i = dof_handler_dual.get_fe().system_to_component_index(i).first;
+
+                    cell_rhs(i) += fe_values.shape_grad(i,q)[0] *
+                                   fe_values.JxW (q);
+                  }
+
+                total_volume += fe_values.JxW (q);
+              }
+
+            cell->get_dof_indices (local_dof_indices);
+            for (unsigned int i=0; i<dofs_per_cell; ++i)
+              {
+                rhs_dual(local_dof_indices[i]) += cell_rhs(i);
+              }
           }
 
       AssertThrow (total_volume > 0,
@@ -1752,126 +1753,126 @@ namespace ElastoPlastic
     class MeanDisplacementFace : public DualFunctionalBase<dim>
     {
     public:
-       MeanDisplacementFace (const unsigned int face_id,
-                                                                               const std::vector<bool> comp_mask);
+      MeanDisplacementFace (const unsigned int face_id,
+                            const std::vector<bool> comp_mask);
 
-       virtual
-       void
-       assemble_rhs (const DoFHandler<dim>              &dof_handler,
-                                                                               const Vector<double>             &solution,
-                                                                               const ConstitutiveLaw<dim> &constitutive_law,
-                                                                               const DoFHandler<dim>            &dof_handler_dual,
-                                                                               Vector<double>                   &rhs_dual) const;
+      virtual
+      void
+      assemble_rhs (const DoFHandler<dim>      &dof_handler,
+                    const Vector<double>       &solution,
+                    const ConstitutiveLaw<dim> &constitutive_law,
+                    const DoFHandler<dim>      &dof_handler_dual,
+                    Vector<double>             &rhs_dual) const;
 
     protected:
-       const unsigned int face_id;
-       const std::vector<bool> comp_mask;
+      const unsigned int face_id;
+      const std::vector<bool> comp_mask;
     };
 
 
     template <int dim>
     MeanDisplacementFace<dim>::
     MeanDisplacementFace (const unsigned int face_id,
-                                                                                       const std::vector<bool> comp_mask )
-    :
-    face_id (face_id),
-    comp_mask (comp_mask)
+                          const std::vector<bool> comp_mask )
+      :
+      face_id (face_id),
+      comp_mask (comp_mask)
     {
-       AssertThrow(comp_mask.size() == dim,
-                                                       ExcDimensionMismatch (comp_mask.size(), dim) );
+      AssertThrow(comp_mask.size() == dim,
+                  ExcDimensionMismatch (comp_mask.size(), dim) );
     }
 
 
     template <int dim>
     void
     MeanDisplacementFace<dim>::
-    assemble_rhs (const DoFHandler<dim>                 &dof_handler,
-                                                                       const Vector<double>             &solution,
-                                                                       const ConstitutiveLaw<dim> &constitutive_law,
-                                                                       const DoFHandler<dim>            &dof_handler_dual,
-                                                                       Vector<double>                   &rhs_dual) const
+    assemble_rhs (const DoFHandler<dim>      &dof_handler,
+                  const Vector<double>       &solution,
+                  const ConstitutiveLaw<dim> &constitutive_law,
+                  const DoFHandler<dim>      &dof_handler_dual,
+                  Vector<double>             &rhs_dual) const
     {
-       AssertThrow (dim >= 2, ExcNotImplemented());
-
-       rhs_dual.reinit (dof_handler_dual.n_dofs());
-
-       const QGauss<dim-1> face_quadrature(dof_handler_dual.get_fe().tensor_degree()+1);
-       FEFaceValues<dim> fe_face_values (dof_handler_dual.get_fe(), face_quadrature,
-                                                                                                       update_values | update_JxW_values);
-
-       const unsigned int  dofs_per_vertex = dof_handler_dual.get_fe().dofs_per_vertex;
-       const unsigned int  dofs_per_cell = dof_handler_dual.get_fe().dofs_per_cell;
-       const unsigned int  n_face_q_points = face_quadrature.size();
-
-       AssertThrow(dofs_per_vertex == dim,
-                                                       ExcDimensionMismatch (dofs_per_vertex, dim) );
-
-       std::vector<unsigned int> comp_vector(dofs_per_vertex);
-       for (unsigned int i=0; i!=dofs_per_vertex; ++i)
-       {
-               if (comp_mask[i])
-               {
-                       comp_vector[i] = 1;
-               }
-       }
-
-       Vector<double>       cell_rhs (dofs_per_cell);
-
-       std::vector<types::global_dof_index> local_dof_indices (dofs_per_cell);
-
-       // bound_size : size of the boundary, in 2d is the length
-       //              and in the 3d case, area
-       double bound_size = 0.;
-
-       typename DoFHandler<dim>::active_cell_iterator
-       cell = dof_handler_dual.begin_active(),
-       endc = dof_handler_dual.end();
-       bool evaluation_face_found = false;
-       for (; cell!=endc; ++cell)
-       {
-               cell_rhs = 0;
-               for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
-               {
-                       if (cell->face(face)->at_boundary()
-                                       &&
-                                       cell->face(face)->boundary_indicator() == face_id)
-                       {
-                               if (!evaluation_face_found)
-                               {
-                                       evaluation_face_found = true;
-                               }
-                               fe_face_values.reinit (cell, face);
-
-                               for (unsigned int q_point=0; q_point<n_face_q_points; ++q_point)
-                               {
-                                       bound_size += fe_face_values.JxW(q_point);
-
-                                       for (unsigned int i=0; i<dofs_per_cell; ++i)
-                                       {
-                                               const unsigned int
-                                               component_i = dof_handler_dual.get_fe().system_to_component_index(i).first;
-
-                                               cell_rhs(i) += (fe_face_values.shape_value(i,q_point) *
-                                                                                                               comp_vector[component_i] *
-                                                                                               fe_face_values.JxW(q_point));
-                                       }
-
-                               }
-
-                       }
-               }
-
-               cell->get_dof_indices (local_dof_indices);
-               for (unsigned int i=0; i<dofs_per_cell; ++i)
-               {
-                       rhs_dual(local_dof_indices[i]) += cell_rhs(i);
-               }
-
-       }
-
-       AssertThrow(evaluation_face_found, ExcInternalError());
-
-       rhs_dual /= bound_size;
+      AssertThrow (dim >= 2, ExcNotImplemented());
+
+      rhs_dual.reinit (dof_handler_dual.n_dofs());
+
+      const QGauss<dim-1> face_quadrature(dof_handler_dual.get_fe().tensor_degree()+1);
+      FEFaceValues<dim> fe_face_values (dof_handler_dual.get_fe(), face_quadrature,
+                                        update_values | update_JxW_values);
+
+      const unsigned int  dofs_per_vertex = dof_handler_dual.get_fe().dofs_per_vertex;
+      const unsigned int  dofs_per_cell = dof_handler_dual.get_fe().dofs_per_cell;
+      const unsigned int  n_face_q_points = face_quadrature.size();
+
+      AssertThrow(dofs_per_vertex == dim,
+                  ExcDimensionMismatch (dofs_per_vertex, dim) );
+
+      std::vector<unsigned int> comp_vector(dofs_per_vertex);
+      for (unsigned int i=0; i!=dofs_per_vertex; ++i)
+        {
+          if (comp_mask[i])
+            {
+              comp_vector[i] = 1;
+            }
+        }
+
+      Vector<double>       cell_rhs (dofs_per_cell);
+
+      std::vector<types::global_dof_index> local_dof_indices (dofs_per_cell);
+
+      // bound_size : size of the boundary, in 2d is the length
+      //              and in the 3d case, area
+      double bound_size = 0.;
+
+      typename DoFHandler<dim>::active_cell_iterator
+      cell = dof_handler_dual.begin_active(),
+      endc = dof_handler_dual.end();
+      bool evaluation_face_found = false;
+      for (; cell!=endc; ++cell)
+        {
+          cell_rhs = 0;
+          for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
+            {
+              if (cell->face(face)->at_boundary()
+                  &&
+                  cell->face(face)->boundary_indicator() == face_id)
+                {
+                  if (!evaluation_face_found)
+                    {
+                      evaluation_face_found = true;
+                    }
+                  fe_face_values.reinit (cell, face);
+
+                  for (unsigned int q_point=0; q_point<n_face_q_points; ++q_point)
+                    {
+                      bound_size += fe_face_values.JxW(q_point);
+
+                      for (unsigned int i=0; i<dofs_per_cell; ++i)
+                        {
+                          const unsigned int
+                          component_i = dof_handler_dual.get_fe().system_to_component_index(i).first;
+
+                          cell_rhs(i) += (fe_face_values.shape_value(i,q_point) *
+                                          comp_vector[component_i] *
+                                          fe_face_values.JxW(q_point));
+                        }
+
+                    }
+
+                }
+            }
+
+          cell->get_dof_indices (local_dof_indices);
+          for (unsigned int i=0; i<dofs_per_cell; ++i)
+            {
+              rhs_dual(local_dof_indices[i]) += cell_rhs(i);
+            }
+
+        }
+
+      AssertThrow(evaluation_face_found, ExcInternalError());
+
+      rhs_dual /= bound_size;
     }
 
 
@@ -1880,144 +1881,144 @@ namespace ElastoPlastic
     class MeanStressFace : public DualFunctionalBase<dim>
     {
     public:
-       MeanStressFace (const unsigned int face_id,
-                                                                       const std::vector<std::vector<unsigned int> > &comp_stress);
+      MeanStressFace (const unsigned int face_id,
+                      const std::vector<std::vector<unsigned int> > &comp_stress);
 
-       virtual
-       void
-       assemble_rhs (const DoFHandler<dim>              &dof_handler,
-                                                                               const Vector<double>             &solution,
-                                                                               const ConstitutiveLaw<dim> &constitutive_law,
-                                                                               const DoFHandler<dim>            &dof_handler_dual,
-                                                                               Vector<double>                   &rhs_dual) const;
+      virtual
+      void
+      assemble_rhs (const DoFHandler<dim>      &dof_handler,
+                    const Vector<double>       &solution,
+                    const ConstitutiveLaw<dim> &constitutive_law,
+                    const DoFHandler<dim>      &dof_handler_dual,
+                    Vector<double>             &rhs_dual) const;
 
     protected:
-       const unsigned int face_id;
-       const std::vector<std::vector<unsigned int> >  comp_stress;
+      const unsigned int face_id;
+      const std::vector<std::vector<unsigned int> >  comp_stress;
     };
 
 
     template <int dim>
     MeanStressFace<dim>::
     MeanStressFace (const unsigned int face_id,
-                                                               const std::vector<std::vector<unsigned int> > &comp_stress )
-    :
-    face_id (face_id),
-    comp_stress (comp_stress)
+                    const std::vector<std::vector<unsigned int> > &comp_stress )
+      :
+      face_id (face_id),
+      comp_stress (comp_stress)
     {
-       AssertThrow(comp_stress.size() == dim,
-                                                       ExcDimensionMismatch (comp_stress.size(), dim) );
+      AssertThrow(comp_stress.size() == dim,
+                  ExcDimensionMismatch (comp_stress.size(), dim) );
     }
 
 
     template <int dim>
     void
     MeanStressFace<dim>::
-    assemble_rhs (const DoFHandler<dim>                 &dof_handler,
-                                                                       const Vector<double>             &solution,
-                                                                       const ConstitutiveLaw<dim> &constitutive_law,
-                                                                       const DoFHandler<dim>            &dof_handler_dual,
-                                                                       Vector<double>                   &rhs_dual) const
+    assemble_rhs (const DoFHandler<dim>      &dof_handler,
+                  const Vector<double>       &solution,
+                  const ConstitutiveLaw<dim> &constitutive_law,
+                  const DoFHandler<dim>      &dof_handler_dual,
+                  Vector<double>             &rhs_dual) const
     {
-       AssertThrow (dim >= 2, ExcNotImplemented());
+      AssertThrow (dim >= 2, ExcNotImplemented());
 
-       rhs_dual.reinit (dof_handler_dual.n_dofs());
+      rhs_dual.reinit (dof_handler_dual.n_dofs());
 
-       const QGauss<dim-1> face_quadrature(dof_handler_dual.get_fe().tensor_degree()+1);
+      const QGauss<dim-1> face_quadrature(dof_handler_dual.get_fe().tensor_degree()+1);
 
-       FEFaceValues<dim> fe_face_values (dof_handler.get_fe(), face_quadrature,
-                                                     update_gradients);
-       FEFaceValues<dim> fe_face_values_dual (dof_handler_dual.get_fe(), face_quadrature,
-                                                                update_gradients | update_JxW_values);
+      FEFaceValues<dim> fe_face_values (dof_handler.get_fe(), face_quadrature,
+                                        update_gradients);
+      FEFaceValues<dim> fe_face_values_dual (dof_handler_dual.get_fe(), face_quadrature,
+                                             update_gradients | update_JxW_values);
 
-       const unsigned int  dofs_per_cell_dual = dof_handler_dual.get_fe().dofs_per_cell;
-       const unsigned int  n_face_q_points = face_quadrature.size();
+      const unsigned int  dofs_per_cell_dual = dof_handler_dual.get_fe().dofs_per_cell;
+      const unsigned int  n_face_q_points = face_quadrature.size();
 
-       std::vector<SymmetricTensor<2, dim> > strain_tensor(n_face_q_points);
-       SymmetricTensor<4, dim> stress_strain_tensor;
+      std::vector<SymmetricTensor<2, dim> > strain_tensor(n_face_q_points);
+      SymmetricTensor<4, dim> stress_strain_tensor;
 
-       Vector<double>      cell_rhs (dofs_per_cell_dual);
+      Vector<double>      cell_rhs (dofs_per_cell_dual);
 
-       std::vector<types::global_dof_index> local_dof_indices (dofs_per_cell_dual);
+      std::vector<types::global_dof_index> local_dof_indices (dofs_per_cell_dual);
 
-       // bound_size : size of the boundary, in 2d is the length
-       //              and in the 3d case, area
-       double bound_size = 0.;
+      // bound_size : size of the boundary, in 2d is the length
+      //              and in the 3d case, area
+      double bound_size = 0.;
 
-       bool evaluation_face_found = false;
+      bool evaluation_face_found = false;
 
-       typename DoFHandler<dim>::active_cell_iterator
-       cell_dual = dof_handler_dual.begin_active(),
-       endc_dual = dof_handler_dual.end(),
+      typename DoFHandler<dim>::active_cell_iterator
+      cell_dual = dof_handler_dual.begin_active(),
+      endc_dual = dof_handler_dual.end(),
       cell = dof_handler.begin_active();
 
-       const FEValuesExtractors::Vector displacement(0);
+      const FEValuesExtractors::Vector displacement(0);
 
-       for (; cell_dual!=endc_dual; ++cell_dual, ++cell)
-       {
-               cell_rhs = 0;
-               for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
-               {
-                       if (cell_dual->face(face)->at_boundary()
-                                       &&
-                                       cell_dual->face(face)->boundary_indicator() == face_id)
-                       {
-                               if (!evaluation_face_found)
-                               {
-                                       evaluation_face_found = true;
-                               }
+      for (; cell_dual!=endc_dual; ++cell_dual, ++cell)
+        {
+          cell_rhs = 0;
+          for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
+            {
+              if (cell_dual->face(face)->at_boundary()
+                  &&
+                  cell_dual->face(face)->boundary_indicator() == face_id)
+                {
+                  if (!evaluation_face_found)
+                    {
+                      evaluation_face_found = true;
+                    }
 
-                               fe_face_values.reinit (cell, face);
-                               fe_face_values_dual.reinit (cell_dual, face);
+                  fe_face_values.reinit (cell, face);
+                  fe_face_values_dual.reinit (cell_dual, face);
 
-                               fe_face_values[displacement].get_function_symmetric_gradients(solution,
-                                                                                                                                                                                                                                                                         strain_tensor);
+                  fe_face_values[displacement].get_function_symmetric_gradients(solution,
+                      strain_tensor);
 
-                               for (unsigned int q_point=0; q_point<n_face_q_points; ++q_point)
-                               {
-                                       bound_size += fe_face_values_dual.JxW(q_point);
+                  for (unsigned int q_point=0; q_point<n_face_q_points; ++q_point)
+                    {
+                      bound_size += fe_face_values_dual.JxW(q_point);
 
-                               constitutive_law.get_stress_strain_tensor(strain_tensor[q_point],
-                                                                                                                                                                                                       stress_strain_tensor);
+                      constitutive_law.get_stress_strain_tensor(strain_tensor[q_point],
+                                                                stress_strain_tensor);
 
-                                       for (unsigned int i=0; i<dofs_per_cell_dual; ++i)
-                                       {
-                const SymmetricTensor<2, dim>
-                stress_phi_i = stress_strain_tensor
-                               * fe_face_values_dual[displacement].symmetric_gradient(i, q_point);
+                      for (unsigned int i=0; i<dofs_per_cell_dual; ++i)
+                        {
+                          const SymmetricTensor<2, dim>
+                          stress_phi_i = stress_strain_tensor
+                                         * fe_face_values_dual[displacement].symmetric_gradient(i, q_point);
 
-                                               for (unsigned int k=0; k!=dim; ++k)
-                                               {
-                                                       for (unsigned int l=0; l!=dim; ++l)
-                                                       {
-                                                               if ( comp_stress[k][l] == 1 )
-                                                               {
-                                                                       cell_rhs(i) += stress_phi_i[k][l]
-                                                                                                                               *
-                                                                                                                               fe_face_values_dual.JxW(q_point);
-                                                               }
+                          for (unsigned int k=0; k!=dim; ++k)
+                            {
+                              for (unsigned int l=0; l!=dim; ++l)
+                                {
+                                  if ( comp_stress[k][l] == 1 )
+                                    {
+                                      cell_rhs(i) += stress_phi_i[k][l]
+                                                     *
+                                                     fe_face_values_dual.JxW(q_point);
+                                    }
 
-                                                       }
-                                               }
+                                }
+                            }
 
-                                       }
+                        }
 
-                               }
+                    }
 
-                       }
-               }
+                }
+            }
 
-               cell_dual->get_dof_indices (local_dof_indices);
-               for (unsigned int i=0; i<dofs_per_cell_dual; ++i)
-               {
-                       rhs_dual(local_dof_indices[i]) += cell_rhs(i);
-               }
+          cell_dual->get_dof_indices (local_dof_indices);
+          for (unsigned int i=0; i<dofs_per_cell_dual; ++i)
+            {
+              rhs_dual(local_dof_indices[i]) += cell_rhs(i);
+            }
 
-       }
+        }
 
-       AssertThrow(evaluation_face_found, ExcInternalError());
+      AssertThrow(evaluation_face_found, ExcInternalError());
 
-       rhs_dual /= bound_size;
+      rhs_dual /= bound_size;
 
     }
 
@@ -2026,160 +2027,160 @@ namespace ElastoPlastic
     class MeanStressDomain : public DualFunctionalBase<dim>
     {
     public:
-       MeanStressDomain (const std::string     &base_mesh,
-                                                                         const std::vector<std::vector<unsigned int> > &comp_stress);
+      MeanStressDomain (const std::string &base_mesh,
+                        const std::vector<std::vector<unsigned int> > &comp_stress);
 
-       virtual
-       void
-       assemble_rhs (const DoFHandler<dim>              &dof_handler,
-                                                                               const Vector<double>             &solution,
-                                                                               const ConstitutiveLaw<dim> &constitutive_law,
-                                                                               const DoFHandler<dim>            &dof_handler_dual,
-                                                                               Vector<double>                   &rhs_dual) const;
+      virtual
+      void
+      assemble_rhs (const DoFHandler<dim>      &dof_handler,
+                    const Vector<double>       &solution,
+                    const ConstitutiveLaw<dim> &constitutive_law,
+                    const DoFHandler<dim>      &dof_handler_dual,
+                    Vector<double>             &rhs_dual) const;
 
     protected:
-       const std::string       base_mesh;
-       const std::vector<std::vector<unsigned int> >  comp_stress;
+      const std::string base_mesh;
+      const std::vector<std::vector<unsigned int> >  comp_stress;
     };
 
 
     template <int dim>
     MeanStressDomain<dim>::
-    MeanStressDomain (const std::string        &base_mesh,
-                                                                       const std::vector<std::vector<unsigned int> > &comp_stress )
-    :
-    base_mesh (base_mesh),
-    comp_stress (comp_stress)
+    MeanStressDomain (const std::string &base_mesh,
+                      const std::vector<std::vector<unsigned int> > &comp_stress )
+      :
+      base_mesh (base_mesh),
+      comp_stress (comp_stress)
     {
-       AssertThrow(comp_stress.size() == dim,
-                                                       ExcDimensionMismatch (comp_stress.size(), dim) );
+      AssertThrow(comp_stress.size() == dim,
+                  ExcDimensionMismatch (comp_stress.size(), dim) );
     }
 
 
     template <int dim>
     void
     MeanStressDomain<dim>::
-    assemble_rhs (const DoFHandler<dim>                 &dof_handler,
-                                                                       const Vector<double>             &solution,
-                                                                       const ConstitutiveLaw<dim> &constitutive_law,
-                                                                       const DoFHandler<dim>            &dof_handler_dual,
-                                                                       Vector<double>                   &rhs_dual) const
+    assemble_rhs (const DoFHandler<dim>      &dof_handler,
+                  const Vector<double>       &solution,
+                  const ConstitutiveLaw<dim> &constitutive_law,
+                  const DoFHandler<dim>      &dof_handler_dual,
+                  Vector<double>             &rhs_dual) const
     {
-       AssertThrow (base_mesh == "Cantiliver_beam_3d", ExcNotImplemented());
-       AssertThrow (dim == 3, ExcNotImplemented());
+      AssertThrow (base_mesh == "Cantiliver_beam_3d", ExcNotImplemented());
+      AssertThrow (dim == 3, ExcNotImplemented());
 
-       // Mean stress at the specified domain is of interest.
-       // The interest domains are located on the bottom and top of the flanges
-       // close to the clamped face, z = 0
-       // top domain: height/2 - thickness_flange <= y <= height/2
-       //             0 <= z <= 2 * thickness_flange
-       // bottom domain: -height/2 <= y <= -height/2 + thickness_flange
-       //             0 <= z <= 2 * thickness_flange
+      // Mean stress at the specified domain is of interest.
+      // The interest domains are located on the bottom and top of the flanges
+      // close to the clamped face, z = 0
+      // top domain: height/2 - thickness_flange <= y <= height/2
+      //             0 <= z <= 2 * thickness_flange
+      // bottom domain: -height/2 <= y <= -height/2 + thickness_flange
+      //             0 <= z <= 2 * thickness_flange
 
-       const double height = 200e-3,
-                                                        thickness_flange = 10e-3;
+      const double height = 200e-3,
+                   thickness_flange = 10e-3;
 
-       rhs_dual.reinit (dof_handler_dual.n_dofs());
+      rhs_dual.reinit (dof_handler_dual.n_dofs());
 
-       const QGauss<dim> quadrature_formula(dof_handler_dual.get_fe().tensor_degree()+1);
+      const QGauss<dim> quadrature_formula(dof_handler_dual.get_fe().tensor_degree()+1);
 
-       FEValues<dim> fe_values (dof_handler.get_fe(), quadrature_formula,
-                                            update_gradients);
-       FEValues<dim> fe_values_dual (dof_handler_dual.get_fe(), quadrature_formula,
-                                                 update_gradients | update_JxW_values);
+      FEValues<dim> fe_values (dof_handler.get_fe(), quadrature_formula,
+                               update_gradients);
+      FEValues<dim> fe_values_dual (dof_handler_dual.get_fe(), quadrature_formula,
+                                    update_gradients | update_JxW_values);
 
-       const unsigned int  dofs_per_cell_dual = dof_handler_dual.get_fe().dofs_per_cell;
-       const unsigned int  n_q_points = quadrature_formula.size();
+      const unsigned int  dofs_per_cell_dual = dof_handler_dual.get_fe().dofs_per_cell;
+      const unsigned int  n_q_points = quadrature_formula.size();
 
-       std::vector<SymmetricTensor<2, dim> > strain_tensor(n_q_points);
-       SymmetricTensor<4, dim> stress_strain_tensor;
+      std::vector<SymmetricTensor<2, dim> > strain_tensor(n_q_points);
+      SymmetricTensor<4, dim> stress_strain_tensor;
 
-       Vector<double>      cell_rhs (dofs_per_cell_dual);
+      Vector<double>      cell_rhs (dofs_per_cell_dual);
 
-       std::vector<types::global_dof_index> local_dof_indices (dofs_per_cell_dual);
+      std::vector<types::global_dof_index> local_dof_indices (dofs_per_cell_dual);
 
-       // domain_size : size of the interested domain, in 2d is the area
-       //              and in the 3d case, volume
-       double domain_size = 0.;
+      // domain_size : size of the interested domain, in 2d is the area
+      //              and in the 3d case, volume
+      double domain_size = 0.;
 
-       bool evaluation_domain_found = false;
+      bool evaluation_domain_found = false;
 
-       typename DoFHandler<dim>::active_cell_iterator
-       cell_dual = dof_handler_dual.begin_active(),
-       endc_dual = dof_handler_dual.end(),
+      typename DoFHandler<dim>::active_cell_iterator
+      cell_dual = dof_handler_dual.begin_active(),
+      endc_dual = dof_handler_dual.end(),
       cell = dof_handler.begin_active();
 
-       const FEValuesExtractors::Vector displacement(0);
-
-       for (; cell_dual!=endc_dual; ++cell_dual, ++cell)
-       {
-               const double y = cell->center()[1],
-                                                                z = cell->center()[2];
-       // top domain: height/2 - thickness_flange <= y <= height/2
-       //             0 <= z <= 2 * thickness_flange
-       // bottom domain: -height/2 <= y <= -height/2 + thickness_flange
-       //             0 <= z <= 2 * thickness_flange
-               if ( ((z > 0) && (z < 2*thickness_flange)) &&
-                                ( ((y > height/2 - thickness_flange) && (y < height/2)) ||
-                                                ((y > -height/2) && (y < -height/2 + thickness_flange)) ) )
-               {
-               cell_rhs = 0;
-
-                               if (!evaluation_domain_found)
-                               {
-                                       evaluation_domain_found = true;
-                               }
-
-               fe_values.reinit(cell);
-               fe_values_dual.reinit(cell_dual);
+      const FEValuesExtractors::Vector displacement(0);
 
-          fe_values[displacement].get_function_symmetric_gradients(solution,
-                                                                   strain_tensor);
+      for (; cell_dual!=endc_dual; ++cell_dual, ++cell)
+        {
+          const double y = cell->center()[1],
+                       z = cell->center()[2];
+          // top domain: height/2 - thickness_flange <= y <= height/2
+          //             0 <= z <= 2 * thickness_flange
+          // bottom domain: -height/2 <= y <= -height/2 + thickness_flange
+          //             0 <= z <= 2 * thickness_flange
+          if ( ((z > 0) && (z < 2*thickness_flange)) &&
+               ( ((y > height/2 - thickness_flange) && (y < height/2)) ||
+                 ((y > -height/2) && (y < -height/2 + thickness_flange)) ) )
+            {
+              cell_rhs = 0;
 
-                               for (unsigned int q_point=0; q_point<n_q_points; ++q_point)
-                               {
-                                       domain_size += fe_values_dual.JxW(q_point);
+              if (!evaluation_domain_found)
+                {
+                  evaluation_domain_found = true;
+                }
 
-                               constitutive_law.get_stress_strain_tensor(strain_tensor[q_point],
-                                                                                                                                                                                                       stress_strain_tensor);
+              fe_values.reinit(cell);
+              fe_values_dual.reinit(cell_dual);
 
-                                       for (unsigned int i=0; i<dofs_per_cell_dual; ++i)
-                                       {
-              const SymmetricTensor<2, dim>
-              stress_phi_i = stress_strain_tensor
-                             * fe_values_dual[displacement].symmetric_gradient(i, q_point);
+              fe_values[displacement].get_function_symmetric_gradients(solution,
+                                                                       strain_tensor);
+
+              for (unsigned int q_point=0; q_point<n_q_points; ++q_point)
+                {
+                  domain_size += fe_values_dual.JxW(q_point);
 
-                                               for (unsigned int k=0; k!=dim; ++k)
-                                               {
-                                                       for (unsigned int l=0; l!=dim; ++l)
-                                                       {
-                                                               if ( comp_stress[k][l] == 1 )
-                                                               {
-                                                                       cell_rhs(i) += stress_phi_i[k][l]
-                                                                                                                               *
-                                                                                                                               fe_values_dual.JxW(q_point);
-                                                               }
+                  constitutive_law.get_stress_strain_tensor(strain_tensor[q_point],
+                                                            stress_strain_tensor);
 
-                                                       }
-                                               }
+                  for (unsigned int i=0; i<dofs_per_cell_dual; ++i)
+                    {
+                      const SymmetricTensor<2, dim>
+                      stress_phi_i = stress_strain_tensor
+                                     * fe_values_dual[displacement].symmetric_gradient(i, q_point);
+
+                      for (unsigned int k=0; k!=dim; ++k)
+                        {
+                          for (unsigned int l=0; l!=dim; ++l)
+                            {
+                              if ( comp_stress[k][l] == 1 )
+                                {
+                                  cell_rhs(i) += stress_phi_i[k][l]
+                                                 *
+                                                 fe_values_dual.JxW(q_point);
+                                }
+
+                            }
+                        }
 
-                                       }
+                    }
 
-                               }
+                }
 
-               }
+            }
 
-               cell_dual->get_dof_indices (local_dof_indices);
-               for (unsigned int i=0; i<dofs_per_cell_dual; ++i)
-               {
-                       rhs_dual(local_dof_indices[i]) += cell_rhs(i);
-               }
+          cell_dual->get_dof_indices (local_dof_indices);
+          for (unsigned int i=0; i<dofs_per_cell_dual; ++i)
+            {
+              rhs_dual(local_dof_indices[i]) += cell_rhs(i);
+            }
 
-       }
+        }
 
-       AssertThrow(evaluation_domain_found, ExcInternalError());
+      AssertThrow(evaluation_domain_found, ExcInternalError());
 
-       rhs_dual /= domain_size;
+      rhs_dual /= domain_size;
 
     }
 
@@ -2188,31 +2189,31 @@ namespace ElastoPlastic
     class MeanStrainEnergyFace : public DualFunctionalBase<dim>
     {
     public:
-       MeanStrainEnergyFace (const unsigned int face_id,
-                                                                                               const Function<dim>      &lambda_function,
-                                                                                               const Function<dim>      &mu_function   );
+      MeanStrainEnergyFace (const unsigned int face_id,
+                            const Function<dim>      &lambda_function,
+                            const Function<dim>      &mu_function );
 
-       void assemble_rhs_nonlinear (const DoFHandler<dim> &primal_dof_handler,
-                                                                                                                                        const Vector<double>  &primal_solution,
-                                                                                                                                        const DoFHandler<dim> &dof_handler,
-                                                                                                                                        Vector<double>        &rhs) const;
+      void assemble_rhs_nonlinear (const DoFHandler<dim> &primal_dof_handler,
+                                   const Vector<double>  &primal_solution,
+                                   const DoFHandler<dim> &dof_handler,
+                                   Vector<double>        &rhs) const;
 
     protected:
-       const unsigned int face_id;
-       const SmartPointer<const Function<dim> >       lambda_function;
-       const SmartPointer<const Function<dim> >       mu_function;
+      const unsigned int face_id;
+      const SmartPointer<const Function<dim> >       lambda_function;
+      const SmartPointer<const Function<dim> >       mu_function;
     };
 
 
     template <int dim>
     MeanStrainEnergyFace<dim>::
     MeanStrainEnergyFace (const unsigned int face_id,
-                                                                                       const Function<dim>      &lambda_function,
-                                                                                       const Function<dim>      &mu_function )
-    :
-    face_id (face_id),
-    lambda_function (&lambda_function),
-    mu_function (&mu_function)
+                          const Function<dim>      &lambda_function,
+                          const Function<dim>      &mu_function )
+      :
+      face_id (face_id),
+      lambda_function (&lambda_function),
+      mu_function (&mu_function)
     {}
 
 
@@ -2220,151 +2221,151 @@ namespace ElastoPlastic
     void
     MeanStrainEnergyFace<dim>::
     assemble_rhs_nonlinear (const DoFHandler<dim> &primal_dof_handler,
-                                                                                               const Vector<double>  &primal_solution,
-                                                                                               const DoFHandler<dim> &dof_handler,
-                                                                                               Vector<double>        &rhs) const
+                            const Vector<double>  &primal_solution,
+                            const DoFHandler<dim> &dof_handler,
+                            Vector<double>        &rhs) const
     {
-       // Assemble right hand side of the dual problem when the quantity of interest is
-       // a nonlinear functinoal. In this case, the QoI should be linearized which depends
-       // on the solution of the primal problem.
-       // The extracter of the linearized QoI functional is the gradient of the the original
-       // QoI functional with the primal solution values.
-
-       AssertThrow (dim >= 2, ExcNotImplemented());
-
-       rhs.reinit (dof_handler.n_dofs());
-
-       const QGauss<dim-1> face_quadrature(dof_handler.get_fe().tensor_degree()+1);
-       FEFaceValues<dim> primal_fe_face_values (primal_dof_handler.get_fe(), face_quadrature,
-                                                                                                                                                                        update_quadrature_points |
-                                                                                                                                                                        update_gradients | update_hessians |
-                                                                                                                                                                        update_JxW_values);
-
-       FEFaceValues<dim> fe_face_values (dof_handler.get_fe(), face_quadrature,
-                                                                                                                                               update_values);
-
-       const unsigned int  dofs_per_vertex = primal_dof_handler.get_fe().dofs_per_vertex;
-       const unsigned int  n_face_q_points = face_quadrature.size();
-       const unsigned int  dofs_per_cell = dof_handler.get_fe().dofs_per_cell;
-
-       AssertThrow(dofs_per_vertex == dim,
-                                                       ExcDimensionMismatch (dofs_per_vertex, dim) );
-
-       std::vector< std::vector< Tensor<1,dim> > > primal_solution_gradients;
-       primal_solution_gradients.resize(n_face_q_points);
-
-       std::vector<std::vector<Tensor<2,dim> > >       primal_solution_hessians;
-       primal_solution_hessians.resize (n_face_q_points);
-
-       for (unsigned int i=0; i!=n_face_q_points; ++i)
-       {
-               primal_solution_gradients[i].resize (dofs_per_vertex);
-               primal_solution_hessians[i].resize      (dofs_per_vertex);
-       }
-
-       std::vector<double>   lambda_values (n_face_q_points);
-       std::vector<double>   mu_values (n_face_q_points);
-
-       Vector<double>      cell_rhs (dofs_per_cell);
-
-       std::vector<types::global_dof_index> local_dof_indices (dofs_per_cell);
-
-       // bound_size : size of the boundary, in 2d is the length
-       //              and in the 3d case, area
-       double bound_size  = 0.;
-
-       bool evaluation_face_found = false;
-
-       typename DoFHandler<dim>::active_cell_iterator
-       primal_cell = primal_dof_handler.begin_active(),
-       primal_endc = primal_dof_handler.end();
-
-       typename DoFHandler<dim>::active_cell_iterator
-       cell = dof_handler.begin_active(),
-       endc = dof_handler.end();
-
-       for (; cell!=endc; ++cell, ++primal_cell)
-       {
-               cell_rhs = 0;
-               for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
-               {
-                       if (cell->face(face)->at_boundary()
-                                       &&
-                                       cell->face(face)->boundary_indicator() == face_id)
-                       {
-                               if (!evaluation_face_found)
-                               {
-                                       evaluation_face_found = true;
-                               }
-                               primal_fe_face_values.reinit (primal_cell, face);
-
-                               primal_fe_face_values.get_function_grads (primal_solution,
-                                                                                                                                                                                                       primal_solution_gradients);
-
-                               primal_fe_face_values.get_function_hessians (primal_solution,
-                                                                                                                                                                                                                primal_solution_hessians);
-
-                               lambda_function->value_list (primal_fe_face_values.get_quadrature_points(), lambda_values);
-                               mu_function->value_list     (primal_fe_face_values.get_quadrature_points(), mu_values);
-
-                               fe_face_values.reinit (cell, face);
-
-                               for (unsigned int q_point=0; q_point<n_face_q_points; ++q_point)
-                               {
-                                       bound_size += primal_fe_face_values.JxW(q_point);
-
-                                       for (unsigned int m=0; m<dofs_per_cell; ++m)
-                                       {
-                                               const unsigned int
-                                               component_m = dof_handler.get_fe().system_to_component_index(m).first;
-
-                                               for (unsigned int i=0; i!=dofs_per_vertex; ++i)
-                                               {
-                                                       for (unsigned int j=0; j!=dofs_per_vertex; ++j)
-                                                       {
-                                                               cell_rhs(m) += fe_face_values.shape_value(m,q_point) *
-                                                                                                                               (
-                                                                                                                                               lambda_values[q_point] *
-                                                                                                                                               (
-                                                                                                                                                               primal_solution_hessians[q_point][i][i][component_m] * primal_solution_gradients[q_point][j][j]
-                                                                                                                                                               +
-                                                                                                                                                               primal_solution_gradients[q_point][i][i] * primal_solution_hessians[q_point][j][j][component_m]
-                                                                                                                                               )
-                                                                                                                                               +
-                                                                                                                                               mu_values[q_point] *
-                                                                                                                                               (
-                                                                                                                                                               2*primal_solution_hessians[q_point][j][i][component_m] * primal_solution_gradients[q_point][j][i]
-                                                                                                                                                               +
-                                                                                                                                                               primal_solution_hessians[q_point][i][j][component_m] * primal_solution_gradients[q_point][j][i]
-                                                                                                                                                               +
-                                                                                                                                                               primal_solution_gradients[q_point][i][j] * primal_solution_hessians[q_point][j][i][component_m]
-                                                                                                                                               )
-                                                                                                                               ) *
-                                                                                                                               primal_fe_face_values.JxW(q_point);
-
-                                                       }
-                                               }
-
-                                       } // end loop DoFs
+      // Assemble right hand side of the dual problem when the quantity of interest is
+      // a nonlinear functinoal. In this case, the QoI should be linearized which depends
+      // on the solution of the primal problem.
+      // The extracter of the linearized QoI functional is the gradient of the the original
+      // QoI functional with the primal solution values.
+
+      AssertThrow (dim >= 2, ExcNotImplemented());
 
+      rhs.reinit (dof_handler.n_dofs());
+
+      const QGauss<dim-1> face_quadrature(dof_handler.get_fe().tensor_degree()+1);
+      FEFaceValues<dim> primal_fe_face_values (primal_dof_handler.get_fe(), face_quadrature,
+                                               update_quadrature_points |
+                                               update_gradients | update_hessians |
+                                               update_JxW_values);
+
+      FEFaceValues<dim> fe_face_values (dof_handler.get_fe(), face_quadrature,
+                                        update_values);
+
+      const unsigned int  dofs_per_vertex = primal_dof_handler.get_fe().dofs_per_vertex;
+      const unsigned int  n_face_q_points = face_quadrature.size();
+      const unsigned int  dofs_per_cell = dof_handler.get_fe().dofs_per_cell;
+
+      AssertThrow(dofs_per_vertex == dim,
+                  ExcDimensionMismatch (dofs_per_vertex, dim) );
+
+      std::vector< std::vector< Tensor<1,dim> > > primal_solution_gradients;
+      primal_solution_gradients.resize(n_face_q_points);
+
+      std::vector<std::vector<Tensor<2,dim> > >   primal_solution_hessians;
+      primal_solution_hessians.resize (n_face_q_points);
+
+      for (unsigned int i=0; i!=n_face_q_points; ++i)
+        {
+          primal_solution_gradients[i].resize (dofs_per_vertex);
+          primal_solution_hessians[i].resize  (dofs_per_vertex);
+        }
+
+      std::vector<double>   lambda_values (n_face_q_points);
+      std::vector<double>   mu_values (n_face_q_points);
+
+      Vector<double>      cell_rhs (dofs_per_cell);
+
+      std::vector<types::global_dof_index> local_dof_indices (dofs_per_cell);
+
+      // bound_size : size of the boundary, in 2d is the length
+      //              and in the 3d case, area
+      double bound_size  = 0.;
+
+      bool evaluation_face_found = false;
+
+      typename DoFHandler<dim>::active_cell_iterator
+      primal_cell = primal_dof_handler.begin_active(),
+      primal_endc = primal_dof_handler.end();
+
+      typename DoFHandler<dim>::active_cell_iterator
+      cell = dof_handler.begin_active(),
+      endc = dof_handler.end();
+
+      for (; cell!=endc; ++cell, ++primal_cell)
+        {
+          cell_rhs = 0;
+          for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
+            {
+              if (cell->face(face)->at_boundary()
+                  &&
+                  cell->face(face)->boundary_indicator() == face_id)
+                {
+                  if (!evaluation_face_found)
+                    {
+                      evaluation_face_found = true;
+                    }
+                  primal_fe_face_values.reinit (primal_cell, face);
+
+                  primal_fe_face_values.get_function_grads (primal_solution,
+                                                            primal_solution_gradients);
+
+                  primal_fe_face_values.get_function_hessians (primal_solution,
+                                                               primal_solution_hessians);
+
+                  lambda_function->value_list (primal_fe_face_values.get_quadrature_points(), lambda_values);
+                  mu_function->value_list     (primal_fe_face_values.get_quadrature_points(), mu_values);
+
+                  fe_face_values.reinit (cell, face);
+
+                  for (unsigned int q_point=0; q_point<n_face_q_points; ++q_point)
+                    {
+                      bound_size += primal_fe_face_values.JxW(q_point);
+
+                      for (unsigned int m=0; m<dofs_per_cell; ++m)
+                        {
+                          const unsigned int
+                          component_m = dof_handler.get_fe().system_to_component_index(m).first;
+
+                          for (unsigned int i=0; i!=dofs_per_vertex; ++i)
+                            {
+                              for (unsigned int j=0; j!=dofs_per_vertex; ++j)
+                                {
+                                  cell_rhs(m) += fe_face_values.shape_value(m,q_point) *
+                                                 (
+                                                   lambda_values[q_point] *
+                                                   (
+                                                     primal_solution_hessians[q_point][i][i][component_m] * primal_solution_gradients[q_point][j][j]
+                                                     +
+                                                     primal_solution_gradients[q_point][i][i] * primal_solution_hessians[q_point][j][j][component_m]
+                                                   )
+                                                   +
+                                                   mu_values[q_point] *
+                                                   (
+                                                     2*primal_solution_hessians[q_point][j][i][component_m] * primal_solution_gradients[q_point][j][i]
+                                                     +
+                                                     primal_solution_hessians[q_point][i][j][component_m] * primal_solution_gradients[q_point][j][i]
+                                                     +
+                                                     primal_solution_gradients[q_point][i][j] * primal_solution_hessians[q_point][j][i][component_m]
+                                                   )
+                                                 ) *
+                                                 primal_fe_face_values.JxW(q_point);
+
+                                }
+                            }
+
+                        } // end loop DoFs
+
+
+                    }  // end loop Gauss points
+
+                }  // end if face
+            }  // end loop face
+
+          cell->get_dof_indices (local_dof_indices);
+          for (unsigned int i=0; i<dofs_per_cell; ++i)
+            {
+              rhs(local_dof_indices[i]) += cell_rhs(i);
+            }
+
+        }  // end loop cell
+
+      AssertThrow(evaluation_face_found, ExcInternalError());
+
+      rhs.scale (1./(2*bound_size));
 
-                               }  // end loop Gauss points
-
-                       }  // end if face
-               }  // end loop face
-
-               cell->get_dof_indices (local_dof_indices);
-               for (unsigned int i=0; i<dofs_per_cell; ++i)
-               {
-                       rhs(local_dof_indices[i]) += cell_rhs(i);
-               }
-
-       }  // end loop cell
-
-       AssertThrow(evaluation_face_found, ExcInternalError());
-
-       rhs.scale (1./(2*bound_size));
-
     }
 
 
@@ -2376,135 +2377,135 @@ namespace ElastoPlastic
   class DualSolver
   {
   public:
-       DualSolver (const Triangulation<dim>                                                                                            &triangulation,
-                                                 const FESystem<dim>                                                                                                   &fe,
-                                                 const Vector<double>                                                                                                          &solution,
-                                                 const ConstitutiveLaw<dim>                                                                                    &constitutive_law,
-                                                 const DualFunctional::DualFunctionalBase<dim>         &dual_functional,
-                                                 const unsigned int                                                                                                                    &timestep_no,
-                                                 const std::string                                                                                     &output_dir,
-                                                 const std::string                                                                                                     &base_mesh,
-                                           const double                                                                                                                        &present_time,
-                                           const double                                                                                                                        &end_time);
+    DualSolver (const Triangulation<dim>                        &triangulation,
+                const FESystem<dim>                             &fe,
+                const Vector<double>                            &solution,
+                const ConstitutiveLaw<dim>                      &constitutive_law,
+                const DualFunctional::DualFunctionalBase<dim>   &dual_functional,
+                const unsigned int                              &timestep_no,
+                const std::string                               &output_dir,
+                const std::string                               &base_mesh,
+                const double                                    &present_time,
+                const double                                    &end_time);
 
-       void compute_error_DWR (Vector<float> &estimated_error_per_cell);
+    void compute_error_DWR (Vector<float> &estimated_error_per_cell);
 
-       ~DualSolver ();
+    ~DualSolver ();
 
   private:
     void setup_system ();
     void compute_dirichlet_constraints ();
-       void assemble_matrix ();
-       void assemble_rhs ();
-       void solve ();
-       void output_results ();
+    void assemble_matrix ();
+    void assemble_rhs ();
+    void solve ();
+    void output_results ();
 
-       const FESystem<dim>     fe;
-       DoFHandler<dim>                     dof_handler;
-       const Vector<double>            solution;
+    const FESystem<dim>     fe;
+    DoFHandler<dim>         dof_handler;
+    const Vector<double>    solution;
 
-    const unsigned int                         fe_degree;
+    const unsigned int      fe_degree;
 
 
-    const unsigned int                         fe_degree_dual;
-    FESystem<dim>                      fe_dual;
-    DoFHandler<dim>                    dof_handler_dual;
+    const unsigned int      fe_degree_dual;
+    FESystem<dim>           fe_dual;
+    DoFHandler<dim>         dof_handler_dual;
 
     const QGauss<dim>       quadrature_formula;
-    const QGauss<dim - 1>      face_quadrature_formula;
+    const QGauss<dim - 1>   face_quadrature_formula;
 
-    ConstraintMatrix                           constraints_hanging_nodes_dual;
-    ConstraintMatrix                           constraints_dirichlet_and_hanging_nodes_dual;
+    ConstraintMatrix        constraints_hanging_nodes_dual;
+    ConstraintMatrix        constraints_dirichlet_and_hanging_nodes_dual;
 
-    SparsityPattern                            sparsity_pattern_dual;
-    SparseMatrix<double>               system_matrix_dual;
-    Vector<double>                                     system_rhs_dual;
-    Vector<double>                                     solution_dual;
+    SparsityPattern         sparsity_pattern_dual;
+    SparseMatrix<double>    system_matrix_dual;
+    Vector<double>          system_rhs_dual;
+    Vector<double>          solution_dual;
 
     const ConstitutiveLaw<dim> constitutive_law;
 
-       const SmartPointer<const Triangulation<dim> > triangulation;
+    const SmartPointer<const Triangulation<dim> > triangulation;
     const SmartPointer<const DualFunctional::DualFunctionalBase<dim> > dual_functional;
 
-    unsigned int                                               timestep_no;
+    unsigned int            timestep_no;
     std::string             output_dir;
     const std::string       base_mesh;
-    double                                                     present_time;
-    double                                                     end_time;
+    double                  present_time;
+    double                  end_time;
   };
 
 
   template<int dim>
   DualSolver<dim>::
-  DualSolver (const Triangulation<dim>                                                                                   &triangulation,
-                                         const FESystem<dim>                                                                                                   &fe,
-                                         const Vector<double>                                                                                                          &solution,
-                                         const ConstitutiveLaw<dim>                                                                                    &constitutive_law,
-                                         const DualFunctional::DualFunctionalBase<dim>         &dual_functional,
-                                                 const unsigned int                                                                                                                    &timestep_no,
-                                                 const std::string                                                                                     &output_dir,
-                                                 const std::string                                                                                                     &base_mesh,
-                                           const double                                                                                                                        &present_time,
-                                           const double                                                                                                                        &end_time)
-  :
-  fe (fe),
-  dof_handler (triangulation),
-  solution(solution),
-  fe_degree(fe.tensor_degree()),
-  fe_degree_dual(fe_degree + 1),
-  fe_dual(FE_Q<dim>(fe_degree_dual), dim),
-  dof_handler_dual (triangulation),
-  quadrature_formula (fe_degree_dual + 1),
-  face_quadrature_formula (fe_degree_dual + 1),
-  constitutive_law (constitutive_law),
-  triangulation (&triangulation),
-  dual_functional (&dual_functional),
-  timestep_no (timestep_no),
-  output_dir (output_dir),
-  base_mesh (base_mesh),
-  present_time (present_time),
-  end_time (end_time)
+  DualSolver (const Triangulation<dim>                        &triangulation,
+              const FESystem<dim>                             &fe,
+              const Vector<double>                            &solution,
+              const ConstitutiveLaw<dim>                      &constitutive_law,
+              const DualFunctional::DualFunctionalBase<dim>   &dual_functional,
+              const unsigned int                              &timestep_no,
+              const std::string                               &output_dir,
+              const std::string                               &base_mesh,
+              const double                                    &present_time,
+              const double                                    &end_time)
+    :
+    fe (fe),
+    dof_handler (triangulation),
+    solution(solution),
+    fe_degree(fe.tensor_degree()),
+    fe_degree_dual(fe_degree + 1),
+    fe_dual(FE_Q<dim>(fe_degree_dual), dim),
+    dof_handler_dual (triangulation),
+    quadrature_formula (fe_degree_dual + 1),
+    face_quadrature_formula (fe_degree_dual + 1),
+    constitutive_law (constitutive_law),
+    triangulation (&triangulation),
+    dual_functional (&dual_functional),
+    timestep_no (timestep_no),
+    output_dir (output_dir),
+    base_mesh (base_mesh),
+    present_time (present_time),
+    end_time (end_time)
   {}
 
 
   template<int dim>
   DualSolver<dim>::~DualSolver()
   {
-       dof_handler_dual.clear ();
+    dof_handler_dual.clear ();
   }
 
 
   template<int dim>
   void DualSolver<dim>::setup_system()
   {
-       dof_handler.distribute_dofs(fe);
+    dof_handler.distribute_dofs(fe);
 
-       dof_handler_dual.distribute_dofs (fe_dual);
-       std::cout << "    Number of degrees of freedom in dual problem:  "
-                                               << dof_handler_dual.n_dofs()
-                                               << std::endl;
+    dof_handler_dual.distribute_dofs (fe_dual);
+    std::cout << "    Number of degrees of freedom in dual problem:  "
+              << dof_handler_dual.n_dofs()
+              << std::endl;
 
-       constraints_hanging_nodes_dual.clear ();
-       DoFTools::make_hanging_node_constraints (dof_handler_dual,
-                                                                                                                                                                        constraints_hanging_nodes_dual);
-       constraints_hanging_nodes_dual.close ();
+    constraints_hanging_nodes_dual.clear ();
+    DoFTools::make_hanging_node_constraints (dof_handler_dual,
+                                             constraints_hanging_nodes_dual);
+    constraints_hanging_nodes_dual.close ();
 
     compute_dirichlet_constraints();
 
-       sparsity_pattern_dual.reinit (dof_handler_dual.n_dofs(),
-                                                                                                                               dof_handler_dual.n_dofs(),
-                                                                                                                               dof_handler_dual.max_couplings_between_dofs());
-       DoFTools::make_sparsity_pattern (dof_handler_dual, sparsity_pattern_dual);
+    sparsity_pattern_dual.reinit (dof_handler_dual.n_dofs(),
+                                  dof_handler_dual.n_dofs(),
+                                  dof_handler_dual.max_couplings_between_dofs());
+    DoFTools::make_sparsity_pattern (dof_handler_dual, sparsity_pattern_dual);
 
-//     constraints_hanging_nodes_dual.condense (sparsity_pattern_dual);
-       constraints_dirichlet_and_hanging_nodes_dual.condense (sparsity_pattern_dual);
+//    constraints_hanging_nodes_dual.condense (sparsity_pattern_dual);
+    constraints_dirichlet_and_hanging_nodes_dual.condense (sparsity_pattern_dual);
 
-       sparsity_pattern_dual.compress();
+    sparsity_pattern_dual.compress();
 
-       system_matrix_dual.reinit (sparsity_pattern_dual);
+    system_matrix_dual.reinit (sparsity_pattern_dual);
 
-       solution_dual.reinit (dof_handler_dual.n_dofs());
-       system_rhs_dual.reinit (dof_handler_dual.n_dofs());
+    solution_dual.reinit (dof_handler_dual.n_dofs());
+    system_rhs_dual.reinit (dof_handler_dual.n_dofs());
 
   }
 
@@ -2517,64 +2518,78 @@ namespace ElastoPlastic
     std::vector<bool> component_mask(dim);
 
     if (base_mesh == "Timoshenko beam")
-    {
-       VectorTools::interpolate_boundary_values(dof_handler_dual,
-                                                                                                                                                                        0,
-                                                                                                                                                                        EquationData::IncrementalBoundaryValues<dim>(present_time, end_time),
-                                                                                                                                                                        constraints_dirichlet_and_hanging_nodes_dual,
-                                                                                                                                                                        ComponentMask());
-    }else if (base_mesh == "Thick_tube_internal_pressure")
-    {
-       // the boundary x = 0
-       component_mask[0] = true; component_mask[1] = false;
-       VectorTools::interpolate_boundary_values (dof_handler_dual,
-                                                                                                                                                                               2,
-                                                                                                                                                                               EquationData::IncrementalBoundaryValues<dim>(present_time, end_time),
-                                                                                                                                                                               constraints_dirichlet_and_hanging_nodes_dual,
-                                                                                                                                                                               component_mask);
-       // the boundary y = 0
-       component_mask[0] = false; component_mask[1] = true;
-       VectorTools::interpolate_boundary_values (dof_handler_dual,
-                                                                                                                                                                               3,
-                                                                                                                                                                               EquationData::IncrementalBoundaryValues<dim>(present_time, end_time),
-                                                                                                                                                                               constraints_dirichlet_and_hanging_nodes_dual,
-                                                                                                                                                                               component_mask);
-    }else if (base_mesh == "Perforated_strip_tension")
-    {
-       // the boundary x = 0
-       component_mask[0] = true; component_mask[1] = false; component_mask[2] = false;
-       VectorTools::interpolate_boundary_values (dof_handler_dual,
-                                                                                                                                                                               4,
-                                                                                                                                                                               EquationData::IncrementalBoundaryValues<dim>(present_time, end_time),
-                                                                                                                                                                               constraints_dirichlet_and_hanging_nodes_dual,
-                                                                                                                                                                               component_mask);
-       // the boundary y = 0
-       component_mask[0] = false; component_mask[1] = true; component_mask[2] = false;
-       VectorTools::interpolate_boundary_values (dof_handler_dual,
-                                                                                                                                                                               1,
-                                                                                                                                                                               EquationData::IncrementalBoundaryValues<dim>(present_time, end_time),
-                                                                                                                                                                               constraints_dirichlet_and_hanging_nodes_dual,
-                                                                                                                                                                               component_mask);
-       // the boundary y = imposed incremental displacement
-       component_mask[0] = false; component_mask[1] = true; component_mask[2] = false;
-       VectorTools::interpolate_boundary_values (dof_handler_dual,
-                                                                                                                                                                               3,
-                                                                                                                                                                               EquationData::IncrementalBoundaryValues<dim>(present_time, end_time),
-                                                                                                                                                                               constraints_dirichlet_and_hanging_nodes_dual,
-                                                                                                                                                                               component_mask);
-    }else if (base_mesh == "Cantiliver_beam_3d")
-    {
-       // the boundary x = y = z = 0
-       component_mask[0] = true; component_mask[1] = true; component_mask[2] = true;
-       VectorTools::interpolate_boundary_values (dof_handler_dual,
-                                                                                                                                                                               1,
-                                                                                                                                                                               EquationData::IncrementalBoundaryValues<dim>(present_time, end_time),
-                                                                                                                                                                               constraints_dirichlet_and_hanging_nodes_dual,
-                                                                                                                                                                               component_mask);
-    }else
-    {
-       AssertThrow(false, ExcNotImplemented());
-    }
+      {
+        VectorTools::interpolate_boundary_values(dof_handler_dual,
+                                                 0,
+                                                 EquationData::IncrementalBoundaryValues<dim>(present_time, end_time),
+                                                 constraints_dirichlet_and_hanging_nodes_dual,
+                                                 ComponentMask());
+      }
+    else if (base_mesh == "Thick_tube_internal_pressure")
+      {
+        // the boundary x = 0
+        component_mask[0] = true;
+        component_mask[1] = false;
+        VectorTools::interpolate_boundary_values (dof_handler_dual,
+                                                  2,
+                                                  EquationData::IncrementalBoundaryValues<dim>(present_time, end_time),
+                                                  constraints_dirichlet_and_hanging_nodes_dual,
+                                                  component_mask);
+        // the boundary y = 0
+        component_mask[0] = false;
+        component_mask[1] = true;
+        VectorTools::interpolate_boundary_values (dof_handler_dual,
+                                                  3,
+                                                  EquationData::IncrementalBoundaryValues<dim>(present_time, end_time),
+                                                  constraints_dirichlet_and_hanging_nodes_dual,
+                                                  component_mask);
+      }
+    else if (base_mesh == "Perforated_strip_tension")
+      {
+        // the boundary x = 0
+        component_mask[0] = true;
+        component_mask[1] = false;
+        component_mask[2] = false;
+        VectorTools::interpolate_boundary_values (dof_handler_dual,
+                                                  4,
+                                                  EquationData::IncrementalBoundaryValues<dim>(present_time, end_time),
+                                                  constraints_dirichlet_and_hanging_nodes_dual,
+                                                  component_mask);
+        // the boundary y = 0
+        component_mask[0] = false;
+        component_mask[1] = true;
+        component_mask[2] = false;
+        VectorTools::interpolate_boundary_values (dof_handler_dual,
+                                                  1,
+                                                  EquationData::IncrementalBoundaryValues<dim>(present_time, end_time),
+                                                  constraints_dirichlet_and_hanging_nodes_dual,
+                                                  component_mask);
+        // the boundary y = imposed incremental displacement
+        component_mask[0] = false;
+        component_mask[1] = true;
+        component_mask[2] = false;
+        VectorTools::interpolate_boundary_values (dof_handler_dual,
+                                                  3,
+                                                  EquationData::IncrementalBoundaryValues<dim>(present_time, end_time),
+                                                  constraints_dirichlet_and_hanging_nodes_dual,
+                                                  component_mask);
+      }
+    else if (base_mesh == "Cantiliver_beam_3d")
+      {
+        // the boundary x = y = z = 0
+        component_mask[0] = true;
+        component_mask[1] = true;
+        component_mask[2] = true;
+        VectorTools::interpolate_boundary_values (dof_handler_dual,
+                                                  1,
+                                                  EquationData::IncrementalBoundaryValues<dim>(present_time, end_time),
+                                                  constraints_dirichlet_and_hanging_nodes_dual,
+                                                  component_mask);
+      }
+    else
+      {
+        AssertThrow(false, ExcNotImplemented());
+      }
 
     constraints_dirichlet_and_hanging_nodes_dual.close();
   }
@@ -2586,10 +2601,10 @@ namespace ElastoPlastic
     FEValues<dim> fe_values(fe, quadrature_formula, update_gradients);
 
     FEValues<dim> fe_values_dual(fe_dual, quadrature_formula,
-                                        update_values | update_gradients | update_JxW_values);
+                                 update_values | update_gradients | update_JxW_values);
 
     const unsigned int dofs_per_cell_dual = fe_dual.dofs_per_cell;
-    const unsigned int n_q_points                      = quadrature_formula.size();
+    const unsigned int n_q_points         = quadrature_formula.size();
 
     FullMatrix<double> cell_matrix (dofs_per_cell_dual, dofs_per_cell_dual);
 
@@ -2605,10 +2620,10 @@ namespace ElastoPlastic
     for (; cell_dual != endc_dual; ++cell_dual, ++cell)
       if (cell_dual->is_locally_owned())
         {
-               fe_values.reinit(cell);
+          fe_values.reinit(cell);
 
-               fe_values_dual.reinit(cell_dual);
-               cell_matrix = 0;
+          fe_values_dual.reinit(cell_dual);
+          cell_matrix = 0;
 
           std::vector<SymmetricTensor<2, dim> > strain_tensor(n_q_points);
           fe_values[displacement].get_function_symmetric_gradients(solution,
@@ -2616,31 +2631,31 @@ namespace ElastoPlastic
 
           for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
             {
-            SymmetricTensor<4, dim> stress_strain_tensor_linearized;
-            SymmetricTensor<4, dim> stress_strain_tensor;
-            constitutive_law.get_linearized_stress_strain_tensors(strain_tensor[q_point],
-                                                                  stress_strain_tensor_linearized,
-                                                                  stress_strain_tensor);
+              SymmetricTensor<4, dim> stress_strain_tensor_linearized;
+              SymmetricTensor<4, dim> stress_strain_tensor;
+              constitutive_law.get_linearized_stress_strain_tensors(strain_tensor[q_point],
+                                                                    stress_strain_tensor_linearized,
+                                                                    stress_strain_tensor);
 
-            for (unsigned int i = 0; i < dofs_per_cell_dual; ++i)
-              {
-                       const SymmetricTensor<2, dim>
-                       stress_phi_i = stress_strain_tensor_linearized
-                                                                                * fe_values_dual[displacement].symmetric_gradient(i, q_point);
+              for (unsigned int i = 0; i < dofs_per_cell_dual; ++i)
+                {
+                  const SymmetricTensor<2, dim>
+                  stress_phi_i = stress_strain_tensor_linearized
+                                 * fe_values_dual[displacement].symmetric_gradient(i, q_point);
 
-                for (unsigned int j = 0; j < dofs_per_cell_dual; ++j)
-                  cell_matrix(i, j) += (stress_phi_i
-                                        * fe_values_dual[displacement].symmetric_gradient(j, q_point)
-                                        * fe_values_dual.JxW(q_point));
+                  for (unsigned int j = 0; j < dofs_per_cell_dual; ++j)
+                    cell_matrix(i, j) += (stress_phi_i
+                                          * fe_values_dual[displacement].symmetric_gradient(j, q_point)
+                                          * fe_values_dual.JxW(q_point));
 
-              }
+                }
 
             }
 
           cell_dual->get_dof_indices(local_dof_indices);
           constraints_dirichlet_and_hanging_nodes_dual.distribute_local_to_global(cell_matrix,
-                                                                                                                                                                       local_dof_indices,
-                                                                                                                                                                       system_matrix_dual);
+              local_dof_indices,
+              system_matrix_dual);
 
         }
 
@@ -2650,54 +2665,54 @@ namespace ElastoPlastic
   template<int dim>
   void DualSolver<dim>::assemble_rhs()
   {
-       dual_functional->assemble_rhs (dof_handler, solution, constitutive_law,
-                                                                                                                                dof_handler_dual, system_rhs_dual);
-       constraints_dirichlet_and_hanging_nodes_dual.condense (system_rhs_dual);
+    dual_functional->assemble_rhs (dof_handler, solution, constitutive_law,
+                                   dof_handler_dual, system_rhs_dual);
+    constraints_dirichlet_and_hanging_nodes_dual.condense (system_rhs_dual);
   }
 
 
   template<int dim>
   void DualSolver<dim>::solve()
   {
-       // +++  direct solver +++++++++
-       SparseDirectUMFPACK             A_direct;
-       A_direct.initialize(system_matrix_dual);
-
-       // After the decomposition, we can use A_direct like a matrix representing
-       // the inverse of our system matrix, so to compute the solution we just
-       // have to multiply with the right hand side vector:
-       A_direct.vmult(solution_dual, system_rhs_dual);
-
-       // ++++  iterative solver ++ CG ++++ doesn't work
-//     SolverControl solver_control (5000, 1e-12);
-//     SolverCG<> cg (solver_control);
+    // +++  direct solver +++++++++
+    SparseDirectUMFPACK   A_direct;
+    A_direct.initialize(system_matrix_dual);
+
+    // After the decomposition, we can use A_direct like a matrix representing
+    // the inverse of our system matrix, so to compute the solution we just
+    // have to multiply with the right hand side vector:
+    A_direct.vmult(solution_dual, system_rhs_dual);
+
+    // ++++  iterative solver ++ CG ++++ doesn't work
+//    SolverControl solver_control (5000, 1e-12);
+//    SolverCG<> cg (solver_control);
 //
-//     PreconditionSSOR<> preconditioner;
-//     preconditioner.initialize(system_matrix_dual, 1.2);
+//    PreconditionSSOR<> preconditioner;
+//    preconditioner.initialize(system_matrix_dual, 1.2);
 //
-//     cg.solve (system_matrix_dual, solution_dual, system_rhs_dual,
-//                                             preconditioner);
+//    cg.solve (system_matrix_dual, solution_dual, system_rhs_dual,
+//              preconditioner);
 
-       // ++++  iterative solver ++ BiCGStab ++++++ doesn't work
-//     SolverControl solver_control (5000, 1e-12);
-//     SolverBicgstab<> bicgstab (solver_control);
+    // ++++  iterative solver ++ BiCGStab ++++++ doesn't work
+//    SolverControl solver_control (5000, 1e-12);
+//    SolverBicgstab<> bicgstab (solver_control);
 //
-//     PreconditionJacobi<> preconditioner;
-//     preconditioner.initialize(system_matrix_dual, 1.0);
+//    PreconditionJacobi<> preconditioner;
+//    preconditioner.initialize(system_matrix_dual, 1.0);
 //
-//     bicgstab.solve (system_matrix_dual, solution_dual, system_rhs_dual,
-//                                                                     preconditioner);
+//    bicgstab.solve (system_matrix_dual, solution_dual, system_rhs_dual,
+//                    preconditioner);
 
-       // +++++++++++++++++++++++++++++++++++++++++++++++++
+    // +++++++++++++++++++++++++++++++++++++++++++++++++
 
-       constraints_dirichlet_and_hanging_nodes_dual.distribute (solution_dual);
+    constraints_dirichlet_and_hanging_nodes_dual.distribute (solution_dual);
   }
 
   template<int dim>
   void DualSolver<dim>::output_results()
   {
     std::string filename = (output_dir + "dual-solution-" +
-                                                                                               Utilities::int_to_string(timestep_no, 4) + ".vtk");
+                            Utilities::int_to_string(timestep_no, 4) + ".vtk");
     std::ofstream output (filename.c_str());
     DataOut<dim> data_out;
     data_out.attach_dof_handler (dof_handler_dual);
@@ -2727,17 +2742,17 @@ namespace ElastoPlastic
   template<int dim>
   void DualSolver<dim>::compute_error_DWR (Vector<float> &estimated_error_per_cell)
   {
-       Assert (estimated_error_per_cell.size() == triangulation->n_global_active_cells(),
-                       ExcDimensionMismatch (estimated_error_per_cell.size(), triangulation->n_global_active_cells()));
+    Assert (estimated_error_per_cell.size() == triangulation->n_global_active_cells(),
+            ExcDimensionMismatch (estimated_error_per_cell.size(), triangulation->n_global_active_cells()));
 
-       // solve the dual problem
-       setup_system ();
-       assemble_matrix ();
-       assemble_rhs ();
-       solve ();
-       output_results ();
+    // solve the dual problem
+    setup_system ();
+    assemble_matrix ();
+    assemble_rhs ();
+    solve ();
+    output_results ();
 
-       // compuate the dual weights
+    // compuate the dual weights
     Vector<double> primal_solution (dof_handler_dual.n_dofs());
     FETools::interpolate (dof_handler,
                           solution,
@@ -2747,7 +2762,7 @@ namespace ElastoPlastic
 
     ConstraintMatrix constraints_hanging_nodes;
     DoFTools::make_hanging_node_constraints (dof_handler,
-                                                                                                                                                                constraints_hanging_nodes);
+                                             constraints_hanging_nodes);
     constraints_hanging_nodes.close();
     Vector<double> dual_weights (dof_handler_dual.n_dofs());
     FETools::interpolation_difference (dof_handler_dual,
@@ -2758,399 +2773,400 @@ namespace ElastoPlastic
                                        dual_weights);
 
     // estimate the error
-       FEValues<dim> fe_values(fe_dual, quadrature_formula,
-                                                                                                       update_values    |
-                                                                                                       update_gradients |
-                                                                                                       update_hessians  |
-                                                                                                       update_quadrature_points |
-                                                                                                       update_JxW_values);
-
-       const unsigned int n_q_points      = quadrature_formula.size();
-       std::vector<SymmetricTensor<2, dim> > strain_tensor(n_q_points);
-       SymmetricTensor<4, dim> stress_strain_tensor_linearized;
-       SymmetricTensor<4, dim> stress_strain_tensor;
-       Tensor<5, dim>                                  stress_strain_tensor_grad;
-       std::vector<std::vector<Tensor<2,dim> > > cell_hessians (n_q_points);
-       for (unsigned int i=0; i!=n_q_points; ++i)
-       {
-               cell_hessians[i].resize (dim);
-       }
-       std::vector<Vector<double> > dual_weights_cell_values (n_q_points, Vector<double>(dim));
-
-       const EquationData::BodyForce<dim> body_force;
-       std::vector<Vector<double> > body_force_values (n_q_points, Vector<double>(dim));
-       const FEValuesExtractors::Vector displacement(0);
-
-
-       FEFaceValues<dim> fe_face_values_cell(fe_dual, face_quadrature_formula,
-                                                                                                                                                               update_values                   |
-                                                                                                                                                               update_quadrature_points|
-                                                                                                                                                               update_gradients                |
-                                                                                                                                                               update_JxW_values               |
-                                                                                                                                                               update_normal_vectors),
-                                                                               fe_face_values_neighbor (fe_dual, face_quadrature_formula,
-                                                                                                                                                                                update_values     |
-                                                                                                                                                                                update_gradients  |
-                                                                                                                                                                                update_JxW_values |
-                                                                                                                                                                                update_normal_vectors);
-       FESubfaceValues<dim> fe_subface_values_cell (fe_dual, face_quadrature_formula,
-                                                                                                                                                                                        update_gradients);
-
-       const unsigned int n_face_q_points = face_quadrature_formula.size();
-       std::vector<Vector<double> > jump_residual (n_face_q_points, Vector<double>(dim));
-       std::vector<Vector<double> > dual_weights_face_values (n_face_q_points, Vector<double>(dim));
-
-       std::vector<std::vector<Tensor<1,dim> > > cell_grads(n_face_q_points);
-       for (unsigned int i=0; i!=n_face_q_points; ++i)
-       {
-               cell_grads[i].resize (dim);
-       }
-       std::vector<std::vector<Tensor<1,dim> > > neighbor_grads(n_face_q_points);
-       for (unsigned int i=0; i!=n_face_q_points; ++i)
-       {
-               neighbor_grads[i].resize (dim);
-       }
-       SymmetricTensor<2, dim> q_cell_strain_tensor;
-       SymmetricTensor<2, dim> q_neighbor_strain_tensor;
-       SymmetricTensor<4, dim> cell_stress_strain_tensor;
-       SymmetricTensor<4, dim> neighbor_stress_strain_tensor;
-
-
-       typename std::map<typename DoFHandler<dim>::face_iterator, Vector<double> >
-               face_integrals;
-       typename DoFHandler<dim>::active_cell_iterator
-                               cell = dof_handler_dual.begin_active(),
-                               endc = dof_handler_dual.end();
-       for (; cell!=endc; ++cell)
-               if (cell->is_locally_owned())
-               {
-                       for (unsigned int face_no=0;
-                                       face_no<GeometryInfo<dim>::faces_per_cell;
-                                       ++face_no)
-                       {
-                               face_integrals[cell->face(face_no)].reinit (dim);
-                               face_integrals[cell->face(face_no)] = -1e20;
-                       }
-               }
-
-       std::vector<Vector<float> > error_indicators_vector;
-       error_indicators_vector.resize( triangulation->n_active_cells(),
-                                                                                                                                       Vector<float>(dim) );
-
-       // ----------------- estimate_some -------------------------
-       cell = dof_handler_dual.begin_active();
-       unsigned int present_cell = 0;
-       for (; cell!=endc; ++cell, ++present_cell)
-               if (cell->is_locally_owned())
-               {
-                       // --------------- integrate_over_cell -------------------
-                       fe_values.reinit(cell);
-                       body_force.vector_value_list(fe_values.get_quadrature_points(),
-                                                                                                                                        body_force_values);
-                       fe_values[displacement].get_function_symmetric_gradients(primal_solution,
-                                                                                                                                                                                                                                                        strain_tensor);
-                       fe_values.get_function_hessians(primal_solution, cell_hessians);
-
-                       fe_values.get_function_values(dual_weights,
-                                                                                                                                               dual_weights_cell_values);
-
-                       for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
-                       {
-                               constitutive_law.get_linearized_stress_strain_tensors(strain_tensor[q_point],
-                                                                                                                                                                                                                                                       stress_strain_tensor_linearized,
-                                                                                                                                                                                                                                                       stress_strain_tensor);
-                               constitutive_law.get_grad_stress_strain_tensor(strain_tensor[q_point],
-                                                                                                                                                                                                                        cell_hessians[q_point],
-                                                                                                                                                                                                                        stress_strain_tensor_grad);
-
-                               for (unsigned int i=0; i!=dim; ++i)
-                               {
-                                       error_indicators_vector[present_cell](i) +=
-                                                       body_force_values[q_point](i)*
-                                                       dual_weights_cell_values[q_point](i)*
-                                                       fe_values.JxW(q_point);
-                                       for (unsigned int j=0; j!=dim; ++j)
-                                       {
-                                               for (unsigned int k=0; k!=dim; ++k)
-                                               {
-                                                       for (unsigned int l=0; l!=dim; ++l)
-                                                       {
-                                                               error_indicators_vector[present_cell](i) +=
-                                                                               (       stress_strain_tensor[i][j][k][l]*
-                                                                                       0.5*(cell_hessians[q_point][k][l][j]
-                                                                                                        +
-                                                                                                        cell_hessians[q_point][l][k][j])
-                                                                                       + stress_strain_tensor_grad[i][j][k][l][j] * strain_tensor[q_point][k][l]
-                                                                               ) *
-                                                                               dual_weights_cell_values[q_point](i) *
-                                                                               fe_values.JxW(q_point);
-                                                       }
-                                               }
-                                       }
-
-                               }
-
-                       }
-                       // -------------------------------------------------------
-                       // compute face_integrals
-                       for (unsigned int face_no=0;
-                                       face_no<GeometryInfo<dim>::faces_per_cell;
-                                       ++face_no)
-                       {
-                               if (cell->face(face_no)->at_boundary())
-                               {
-                                       for (unsigned int id=0; id!=dim; ++id)
-                                       {
-                                               face_integrals[cell->face(face_no)](id) = 0;
-                                       }
-                                       continue;
-                               }
-
-                               if ((cell->neighbor(face_no)->has_children() == false) &&
-                                               (cell->neighbor(face_no)->level() == cell->level()) &&
-                                               (cell->neighbor(face_no)->index() < cell->index()))
-                                       continue;
-
-                               if (cell->at_boundary(face_no) == false)
-                                       if (cell->neighbor(face_no)->level() < cell->level())
-                                               continue;
-
-
-                               if (cell->face(face_no)->has_children() == false)
-                               {
-                                       // ------------- integrate_over_regular_face -----------
-                                       fe_face_values_cell.reinit(cell, face_no);
-                                       fe_face_values_cell.get_function_grads (primal_solution,
-                                                                                                                                                                                                       cell_grads);
-
-                                       Assert (cell->neighbor(face_no).state() == IteratorState::valid,
-                                                                       ExcInternalError());
-                                       const unsigned int
-                                       neighbor_neighbor = cell->neighbor_of_neighbor (face_no);
-                                       const typename DoFHandler<dim>::active_cell_iterator
-                                                                       neighbor = cell->neighbor(face_no);
-
-                                       fe_face_values_neighbor.reinit(neighbor, neighbor_neighbor);
-                                       fe_face_values_neighbor.get_function_grads (primal_solution,
-                                                                                                                                                                                                                       neighbor_grads);
-
-                                       for (unsigned int q_point=0; q_point<n_face_q_points; ++q_point)
-                                       {
-                                               q_cell_strain_tensor = 0.;
-                                               q_neighbor_strain_tensor = 0.;
-                                               for (unsigned int i=0; i!=dim; ++i)
-                                               {
-                                                       for (unsigned int j=0; j!=dim; ++j)
-                                                       {
-                                                               q_cell_strain_tensor[i][j] = 0.5*(cell_grads[q_point][i][j] +
-                                                                                                                                                                                                       cell_grads[q_point][j][i] );
-                                                               q_neighbor_strain_tensor[i][j] = 0.5*(neighbor_grads[q_point][i][j] +
-                                                                                                                                                                                                                       neighbor_grads[q_point][j][i] );
-                                                       }
-                                               }
-
-                                               constitutive_law.get_stress_strain_tensor (q_cell_strain_tensor,
-                                                                                                                                                                                                                        cell_stress_strain_tensor);
-                                               constitutive_law.get_stress_strain_tensor (q_neighbor_strain_tensor,
-                                                                                                                                                                                                                        neighbor_stress_strain_tensor);
-
-                                               jump_residual[q_point] = 0.;
-                                               for (unsigned int i=0; i!=dim; ++i)
-                                               {
-                                                       for (unsigned int j=0; j!=dim; ++j)
-                                                       {
-                                                               for (unsigned int k=0; k!=dim; ++k)
-                                                               {
-                                                                       for (unsigned int l=0; l!=dim; ++l)
-                                                                       {
-                                                                               jump_residual[q_point](i) += (cell_stress_strain_tensor[i][j][k][l]*
-                                                                                                                                                                                                       q_cell_strain_tensor[k][l]
-                                                                                                                                                                                                       -
-                                                                                                                                                                                                       neighbor_stress_strain_tensor[i][j][k][l]*
-                                                                                                                                                                                                       q_neighbor_strain_tensor[k][l] )*
-                                                                                                                                                                                                fe_face_values_cell.normal_vector(q_point)[j];
-                                                                       }
-                                                               }
-                                                       }
-                                               }
-
-                                       }
-
-                                       fe_face_values_cell.get_function_values (dual_weights,
-                                                                                                                                                                dual_weights_face_values);
-
-                                       Vector<double> face_integral_vector(dim);
-                                       face_integral_vector = 0;
-                                       for (unsigned int q_point=0; q_point<n_face_q_points; ++q_point)
-                                       {
-                                               for (unsigned int i=0; i!=dim; ++i)
-                                               {
-                                                       face_integral_vector(i) += jump_residual[q_point](i) *
-                                                                                                                                                                dual_weights_face_values[q_point](i) *
-                                                                                                                                                                fe_face_values_cell.JxW(q_point);
-                                               }
-                                       }
-
-                                       Assert (face_integrals.find (cell->face(face_no)) != face_integrals.end(),
-                                                                       ExcInternalError());
-
-                                       for (unsigned int i=0; i!=dim; ++i)
-                                       {
-                                               Assert (face_integrals[cell->face(face_no)](i) == -1e20,
-                                                                               ExcInternalError());
-                                               face_integrals[cell->face(face_no)](i) = face_integral_vector(i);
-
-                                       }
-
-                                       // -----------------------------------------------------
-                               }else
-                               {
-                                       // ------------- integrate_over_irregular_face ---------
-                                       const typename DoFHandler<dim>::face_iterator
-                                       face = cell->face(face_no);
-                                       const typename DoFHandler<dim>::cell_iterator
-                                       neighbor = cell->neighbor(face_no);
-                                       Assert (neighbor.state() == IteratorState::valid,
-                                                                       ExcInternalError());
-                                       Assert (neighbor->has_children(),
-                                                                       ExcInternalError());
-
-                                       const unsigned int
-                                       neighbor_neighbor = cell->neighbor_of_neighbor (face_no);
-
-                                       for (unsigned int subface_no=0;
-                                                        subface_no<face->n_children(); ++subface_no)
-                                       {
-                                               const typename DoFHandler<dim>::active_cell_iterator
-                                               neighbor_child = cell->neighbor_child_on_subface (face_no, subface_no);
-                                               Assert (neighbor_child->face(neighbor_neighbor) ==
-                                                                               cell->face(face_no)->child(subface_no),
-                                                                               ExcInternalError());
-
-                                               fe_subface_values_cell.reinit (cell, face_no, subface_no);
-                                               fe_subface_values_cell.get_function_grads (primal_solution,
-                                                                                                                                                                                                                        cell_grads);
-                                               fe_face_values_neighbor.reinit (neighbor_child,
-                                                                                                                                                                               neighbor_neighbor);
-                                               fe_face_values_neighbor.get_function_grads (primal_solution,
-                                                                                                                                                                                                                               neighbor_grads);
-
-                                               for (unsigned int q_point=0; q_point<n_face_q_points; ++q_point)
-                                               {
-                                                       q_cell_strain_tensor = 0.;
-                                                       q_neighbor_strain_tensor = 0.;
-                                                       for (unsigned int i=0; i!=dim; ++i)
-                                                       {
-                                                               for (unsigned int j=0; j!=dim; ++j)
-                                                               {
-                                                                       q_cell_strain_tensor[i][j] = 0.5*(cell_grads[q_point][i][j] +
-                                                                                                                                                                                                               cell_grads[q_point][j][i] );
-                                                                       q_neighbor_strain_tensor[i][j] = 0.5*(neighbor_grads[q_point][i][j] +
-                                                                                                                                                                                                                               neighbor_grads[q_point][j][i] );
-                                                               }
-                                                       }
-
-                                                       constitutive_law.get_stress_strain_tensor (q_cell_strain_tensor,
-                                                                                                                                                                                                                                cell_stress_strain_tensor);
-                                                       constitutive_law.get_stress_strain_tensor (q_neighbor_strain_tensor,
-                                                                                                                                                                                                                                neighbor_stress_strain_tensor);
-
-                                                       jump_residual[q_point] = 0.;
-                                                       for (unsigned int i=0; i!=dim; ++i)
-                                                       {
-                                                               for (unsigned int j=0; j!=dim; ++j)
-                                                               {
-                                                                       for (unsigned int k=0; k!=dim; ++k)
-                                                                       {
-                                                                               for (unsigned int l=0; l!=dim; ++l)
-                                                                               {
-                                                                                       jump_residual[q_point](i) += (-cell_stress_strain_tensor[i][j][k][l]*
-                                                                                                                                                                                                               q_cell_strain_tensor[k][l]
-                                                                                                                                                                                                               +
-                                                                                                                                                                                                               neighbor_stress_strain_tensor[i][j][k][l]*
-                                                                                                                                                                                                               q_neighbor_strain_tensor[k][l] )*
-                                                                                                                                                                                                        fe_face_values_neighbor.normal_vector(q_point)[j];
-                                                                               }
-                                                                       }
-                                                               }
-                                                       }
-
-                                               }
-
-                                               fe_face_values_neighbor.get_function_values (dual_weights,
-                                                                                                                                                                                        dual_weights_face_values);
-
-                                               Vector<double> face_integral_vector(dim);
-                                               face_integral_vector = 0;
-                                               for (unsigned int q_point=0; q_point<n_face_q_points; ++q_point)
-                                               {
-                                                       for (unsigned int i=0; i!=dim; ++i)
-                                                       {
-                                                               face_integral_vector(i) += jump_residual[q_point](i) *
-                                                                                                                                                                        dual_weights_face_values[q_point](i) *
-                                                                                                                                                                        fe_face_values_neighbor.JxW(q_point);
-                                                       }
-                                               }
-
-                                               for (unsigned int i=0; i!=dim; ++i)
-                                               {
-                                                       face_integrals[neighbor_child->face(neighbor_neighbor)](i) = face_integral_vector(i);
-                                               }
-
-                                       }
-
-                                       Vector<double> sum (dim);
-                                       sum = 0;
-                                       for (unsigned int subface_no=0;
-                                                       subface_no<face->n_children(); ++subface_no)
-                                       {
-                                               Assert (face_integrals.find(face->child(subface_no)) !=
-                                                                               face_integrals.end(),
-                                                                               ExcInternalError());
-                                               for (unsigned int i=0; i!=dim; ++i)
-                                               {
-                                                       Assert (face_integrals[face->child(subface_no)](i) != -1e20,
-                                                                                       ExcInternalError());
-                                                       sum(i) += face_integrals[face->child(subface_no)](i);
-                                               }
-                                       }
-                                       for (unsigned int i=0; i!=dim; ++i)
-                                       {
-                                               face_integrals[face](i) = sum(i);
-                                       }
-
-
-                                       // -----------------------------------------------------
-                               }
-
-
-                       }
-               }
-       // ----------------------------------------------------------
-
-       present_cell=0;
-       cell = dof_handler_dual.begin_active();
-       for (; cell!=endc; ++cell, ++present_cell)
-               if (cell->is_locally_owned())
-               {
-                       for (unsigned int face_no=0; face_no<GeometryInfo<dim>::faces_per_cell;
-                                       ++face_no)
-                       {
-                               Assert(face_integrals.find(cell->face(face_no)) !=
-                                                        face_integrals.end(),
-                                                        ExcInternalError());
-
-                               for (unsigned int id=0; id!=dim; ++id)
-                               {
-                                       error_indicators_vector[present_cell](id)
-                                                                                                                               -= 0.5*face_integrals[cell->face(face_no)](id);
-                               }
-
-                       }
-
-                       estimated_error_per_cell(present_cell) = error_indicators_vector[present_cell].l2_norm();
-
-               }
+    FEValues<dim> fe_values(fe_dual, quadrature_formula,
+                            update_values    |
+                            update_gradients |
+                            update_hessians  |
+                            update_quadrature_points |
+                            update_JxW_values);
+
+    const unsigned int n_q_points      = quadrature_formula.size();
+    std::vector<SymmetricTensor<2, dim> > strain_tensor(n_q_points);
+    SymmetricTensor<4, dim> stress_strain_tensor_linearized;
+    SymmetricTensor<4, dim> stress_strain_tensor;
+    Tensor<5, dim>          stress_strain_tensor_grad;
+    std::vector<std::vector<Tensor<2,dim> > > cell_hessians (n_q_points);
+    for (unsigned int i=0; i!=n_q_points; ++i)
+      {
+        cell_hessians[i].resize (dim);
+      }
+    std::vector<Vector<double> > dual_weights_cell_values (n_q_points, Vector<double>(dim));
+
+    const EquationData::BodyForce<dim> body_force;
+    std::vector<Vector<double> > body_force_values (n_q_points, Vector<double>(dim));
+    const FEValuesExtractors::Vector displacement(0);
+
+
+    FEFaceValues<dim> fe_face_values_cell(fe_dual, face_quadrature_formula,
+                                          update_values           |
+                                          update_quadrature_points|
+                                          update_gradients        |
+                                          update_JxW_values       |
+                                          update_normal_vectors),
+                                          fe_face_values_neighbor (fe_dual, face_quadrature_formula,
+                                              update_values     |
+                                              update_gradients  |
+                                              update_JxW_values |
+                                              update_normal_vectors);
+    FESubfaceValues<dim> fe_subface_values_cell (fe_dual, face_quadrature_formula,
+                                                 update_gradients);
+
+    const unsigned int n_face_q_points = face_quadrature_formula.size();
+    std::vector<Vector<double> > jump_residual (n_face_q_points, Vector<double>(dim));
+    std::vector<Vector<double> > dual_weights_face_values (n_face_q_points, Vector<double>(dim));
+
+    std::vector<std::vector<Tensor<1,dim> > > cell_grads(n_face_q_points);
+    for (unsigned int i=0; i!=n_face_q_points; ++i)
+      {
+        cell_grads[i].resize (dim);
+      }
+    std::vector<std::vector<Tensor<1,dim> > > neighbor_grads(n_face_q_points);
+    for (unsigned int i=0; i!=n_face_q_points; ++i)
+      {
+        neighbor_grads[i].resize (dim);
+      }
+    SymmetricTensor<2, dim> q_cell_strain_tensor;
+    SymmetricTensor<2, dim> q_neighbor_strain_tensor;
+    SymmetricTensor<4, dim> cell_stress_strain_tensor;
+    SymmetricTensor<4, dim> neighbor_stress_strain_tensor;
+
+
+    typename std::map<typename DoFHandler<dim>::face_iterator, Vector<double> >
+    face_integrals;
+    typename DoFHandler<dim>::active_cell_iterator
+    cell = dof_handler_dual.begin_active(),
+    endc = dof_handler_dual.end();
+    for (; cell!=endc; ++cell)
+      if (cell->is_locally_owned())
+        {
+          for (unsigned int face_no=0;
+               face_no<GeometryInfo<dim>::faces_per_cell;
+               ++face_no)
+            {
+              face_integrals[cell->face(face_no)].reinit (dim);
+              face_integrals[cell->face(face_no)] = -1e20;
+            }
+        }
+
+    std::vector<Vector<float> > error_indicators_vector;
+    error_indicators_vector.resize( triangulation->n_active_cells(),
+                                    Vector<float>(dim) );
+
+    // ----------------- estimate_some -------------------------
+    cell = dof_handler_dual.begin_active();
+    unsigned int present_cell = 0;
+    for (; cell!=endc; ++cell, ++present_cell)
+      if (cell->is_locally_owned())
+        {
+          // --------------- integrate_over_cell -------------------
+          fe_values.reinit(cell);
+          body_force.vector_value_list(fe_values.get_quadrature_points(),
+                                       body_force_values);
+          fe_values[displacement].get_function_symmetric_gradients(primal_solution,
+                                                                   strain_tensor);
+          fe_values.get_function_hessians(primal_solution, cell_hessians);
+
+          fe_values.get_function_values(dual_weights,
+                                        dual_weights_cell_values);
+
+          for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
+            {
+              constitutive_law.get_linearized_stress_strain_tensors(strain_tensor[q_point],
+                                                                    stress_strain_tensor_linearized,
+                                                                    stress_strain_tensor);
+              constitutive_law.get_grad_stress_strain_tensor(strain_tensor[q_point],
+                                                             cell_hessians[q_point],
+                                                             stress_strain_tensor_grad);
+
+              for (unsigned int i=0; i!=dim; ++i)
+                {
+                  error_indicators_vector[present_cell](i) +=
+                    body_force_values[q_point](i)*
+                    dual_weights_cell_values[q_point](i)*
+                    fe_values.JxW(q_point);
+                  for (unsigned int j=0; j!=dim; ++j)
+                    {
+                      for (unsigned int k=0; k!=dim; ++k)
+                        {
+                          for (unsigned int l=0; l!=dim; ++l)
+                            {
+                              error_indicators_vector[present_cell](i) +=
+                                ( stress_strain_tensor[i][j][k][l]*
+                                  0.5*(cell_hessians[q_point][k][l][j]
+                                       +
+                                       cell_hessians[q_point][l][k][j])
+                                  + stress_strain_tensor_grad[i][j][k][l][j] * strain_tensor[q_point][k][l]
+                                ) *
+                                dual_weights_cell_values[q_point](i) *
+                                fe_values.JxW(q_point);
+                            }
+                        }
+                    }
+
+                }
+
+            }
+          // -------------------------------------------------------
+          // compute face_integrals
+          for (unsigned int face_no=0;
+               face_no<GeometryInfo<dim>::faces_per_cell;
+               ++face_no)
+            {
+              if (cell->face(face_no)->at_boundary())
+                {
+                  for (unsigned int id=0; id!=dim; ++id)
+                    {
+                      face_integrals[cell->face(face_no)](id) = 0;
+                    }
+                  continue;
+                }
+
+              if ((cell->neighbor(face_no)->has_children() == false) &&
+                  (cell->neighbor(face_no)->level() == cell->level()) &&
+                  (cell->neighbor(face_no)->index() < cell->index()))
+                continue;
+
+              if (cell->at_boundary(face_no) == false)
+                if (cell->neighbor(face_no)->level() < cell->level())
+                  continue;
+
+
+              if (cell->face(face_no)->has_children() == false)
+                {
+                  // ------------- integrate_over_regular_face -----------
+                  fe_face_values_cell.reinit(cell, face_no);
+                  fe_face_values_cell.get_function_grads (primal_solution,
+                                                          cell_grads);
+
+                  Assert (cell->neighbor(face_no).state() == IteratorState::valid,
+                          ExcInternalError());
+                  const unsigned int
+                  neighbor_neighbor = cell->neighbor_of_neighbor (face_no);
+                  const typename DoFHandler<dim>::active_cell_iterator
+                  neighbor = cell->neighbor(face_no);
+
+                  fe_face_values_neighbor.reinit(neighbor, neighbor_neighbor);
+                  fe_face_values_neighbor.get_function_grads (primal_solution,
+                                                              neighbor_grads);
+
+                  for (unsigned int q_point=0; q_point<n_face_q_points; ++q_point)
+                    {
+                      q_cell_strain_tensor = 0.;
+                      q_neighbor_strain_tensor = 0.;
+                      for (unsigned int i=0; i!=dim; ++i)
+                        {
+                          for (unsigned int j=0; j!=dim; ++j)
+                            {
+                              q_cell_strain_tensor[i][j] = 0.5*(cell_grads[q_point][i][j] +
+                                                                cell_grads[q_point][j][i] );
+                              q_neighbor_strain_tensor[i][j] = 0.5*(neighbor_grads[q_point][i][j] +
+                                                                    neighbor_grads[q_point][j][i] );
+                            }
+                        }
+
+                      constitutive_law.get_stress_strain_tensor (q_cell_strain_tensor,
+                                                                 cell_stress_strain_tensor);
+                      constitutive_law.get_stress_strain_tensor (q_neighbor_strain_tensor,
+                                                                 neighbor_stress_strain_tensor);
+
+                      jump_residual[q_point] = 0.;
+                      for (unsigned int i=0; i!=dim; ++i)
+                        {
+                          for (unsigned int j=0; j!=dim; ++j)
+                            {
+                              for (unsigned int k=0; k!=dim; ++k)
+                                {
+                                  for (unsigned int l=0; l!=dim; ++l)
+                                    {
+                                      jump_residual[q_point](i) += (cell_stress_strain_tensor[i][j][k][l]*
+                                                                    q_cell_strain_tensor[k][l]
+                                                                    -
+                                                                    neighbor_stress_strain_tensor[i][j][k][l]*
+                                                                    q_neighbor_strain_tensor[k][l] )*
+                                                                   fe_face_values_cell.normal_vector(q_point)[j];
+                                    }
+                                }
+                            }
+                        }
+
+                    }
+
+                  fe_face_values_cell.get_function_values (dual_weights,
+                                                           dual_weights_face_values);
+
+                  Vector<double> face_integral_vector(dim);
+                  face_integral_vector = 0;
+                  for (unsigned int q_point=0; q_point<n_face_q_points; ++q_point)
+                    {
+                      for (unsigned int i=0; i!=dim; ++i)
+                        {
+                          face_integral_vector(i) += jump_residual[q_point](i) *
+                                                     dual_weights_face_values[q_point](i) *
+                                                     fe_face_values_cell.JxW(q_point);
+                        }
+                    }
+
+                  Assert (face_integrals.find (cell->face(face_no)) != face_integrals.end(),
+                          ExcInternalError());
+
+                  for (unsigned int i=0; i!=dim; ++i)
+                    {
+                      Assert (face_integrals[cell->face(face_no)](i) == -1e20,
+                              ExcInternalError());
+                      face_integrals[cell->face(face_no)](i) = face_integral_vector(i);
+
+                    }
+
+                  // -----------------------------------------------------
+                }
+              else
+                {
+                  // ------------- integrate_over_irregular_face ---------
+                  const typename DoFHandler<dim>::face_iterator
+                  face = cell->face(face_no);
+                  const typename DoFHandler<dim>::cell_iterator
+                  neighbor = cell->neighbor(face_no);
+                  Assert (neighbor.state() == IteratorState::valid,
+                          ExcInternalError());
+                  Assert (neighbor->has_children(),
+                          ExcInternalError());
+
+                  const unsigned int
+                  neighbor_neighbor = cell->neighbor_of_neighbor (face_no);
+
+                  for (unsigned int subface_no=0;
+                       subface_no<face->n_children(); ++subface_no)
+                    {
+                      const typename DoFHandler<dim>::active_cell_iterator
+                      neighbor_child = cell->neighbor_child_on_subface (face_no, subface_no);
+                      Assert (neighbor_child->face(neighbor_neighbor) ==
+                              cell->face(face_no)->child(subface_no),
+                              ExcInternalError());
+
+                      fe_subface_values_cell.reinit (cell, face_no, subface_no);
+                      fe_subface_values_cell.get_function_grads (primal_solution,
+                                                                 cell_grads);
+                      fe_face_values_neighbor.reinit (neighbor_child,
+                                                      neighbor_neighbor);
+                      fe_face_values_neighbor.get_function_grads (primal_solution,
+                                                                  neighbor_grads);
+
+                      for (unsigned int q_point=0; q_point<n_face_q_points; ++q_point)
+                        {
+                          q_cell_strain_tensor = 0.;
+                          q_neighbor_strain_tensor = 0.;
+                          for (unsigned int i=0; i!=dim; ++i)
+                            {
+                              for (unsigned int j=0; j!=dim; ++j)
+                                {
+                                  q_cell_strain_tensor[i][j] = 0.5*(cell_grads[q_point][i][j] +
+                                                                    cell_grads[q_point][j][i] );
+                                  q_neighbor_strain_tensor[i][j] = 0.5*(neighbor_grads[q_point][i][j] +
+                                                                        neighbor_grads[q_point][j][i] );
+                                }
+                            }
+
+                          constitutive_law.get_stress_strain_tensor (q_cell_strain_tensor,
+                                                                     cell_stress_strain_tensor);
+                          constitutive_law.get_stress_strain_tensor (q_neighbor_strain_tensor,
+                                                                     neighbor_stress_strain_tensor);
+
+                          jump_residual[q_point] = 0.;
+                          for (unsigned int i=0; i!=dim; ++i)
+                            {
+                              for (unsigned int j=0; j!=dim; ++j)
+                                {
+                                  for (unsigned int k=0; k!=dim; ++k)
+                                    {
+                                      for (unsigned int l=0; l!=dim; ++l)
+                                        {
+                                          jump_residual[q_point](i) += (-cell_stress_strain_tensor[i][j][k][l]*
+                                                                        q_cell_strain_tensor[k][l]
+                                                                        +
+                                                                        neighbor_stress_strain_tensor[i][j][k][l]*
+                                                                        q_neighbor_strain_tensor[k][l] )*
+                                                                       fe_face_values_neighbor.normal_vector(q_point)[j];
+                                        }
+                                    }
+                                }
+                            }
+
+                        }
+
+                      fe_face_values_neighbor.get_function_values (dual_weights,
+                                                                   dual_weights_face_values);
+
+                      Vector<double> face_integral_vector(dim);
+                      face_integral_vector = 0;
+                      for (unsigned int q_point=0; q_point<n_face_q_points; ++q_point)
+                        {
+                          for (unsigned int i=0; i!=dim; ++i)
+                            {
+                              face_integral_vector(i) += jump_residual[q_point](i) *
+                                                         dual_weights_face_values[q_point](i) *
+                                                         fe_face_values_neighbor.JxW(q_point);
+                            }
+                        }
+
+                      for (unsigned int i=0; i!=dim; ++i)
+                        {
+                          face_integrals[neighbor_child->face(neighbor_neighbor)](i) = face_integral_vector(i);
+                        }
+
+                    }
+
+                  Vector<double> sum (dim);
+                  sum = 0;
+                  for (unsigned int subface_no=0;
+                       subface_no<face->n_children(); ++subface_no)
+                    {
+                      Assert (face_integrals.find(face->child(subface_no)) !=
+                              face_integrals.end(),
+                              ExcInternalError());
+                      for (unsigned int i=0; i!=dim; ++i)
+                        {
+                          Assert (face_integrals[face->child(subface_no)](i) != -1e20,
+                                  ExcInternalError());
+                          sum(i) += face_integrals[face->child(subface_no)](i);
+                        }
+                    }
+                  for (unsigned int i=0; i!=dim; ++i)
+                    {
+                      face_integrals[face](i) = sum(i);
+                    }
+
+
+                  // -----------------------------------------------------
+                }
+
+
+            }
+        }
+    // ----------------------------------------------------------
+
+    present_cell=0;
+    cell = dof_handler_dual.begin_active();
+    for (; cell!=endc; ++cell, ++present_cell)
+      if (cell->is_locally_owned())
+        {
+          for (unsigned int face_no=0; face_no<GeometryInfo<dim>::faces_per_cell;
+               ++face_no)
+            {
+              Assert(face_integrals.find(cell->face(face_no)) !=
+                     face_integrals.end(),
+                     ExcInternalError());
+
+              for (unsigned int id=0; id!=dim; ++id)
+                {
+                  error_indicators_vector[present_cell](id)
+                  -= 0.5*face_integrals[cell->face(face_no)](id);
+                }
+
+            }
+
+          estimated_error_per_cell(present_cell) = error_indicators_vector[present_cell].l2_norm();
+
+        }
   }
 
 
@@ -3197,7 +3213,7 @@ namespace ElastoPlastic
     void setup_system ();
     void compute_dirichlet_constraints ();
     void assemble_newton_system (const TrilinosWrappers::MPI::Vector &linearization_point,
-                                                                                                                                const TrilinosWrappers::MPI::Vector &delta_linearization_point);
+                                 const TrilinosWrappers::MPI::Vector &delta_linearization_point);
     void compute_nonlinear_residual (const TrilinosWrappers::MPI::Vector &linearization_point);
     void solve_newton_system ();
     void solve_newton ();
@@ -3278,7 +3294,7 @@ namespace ElastoPlastic
     // agree on where they are and how many there are on each cell. Thus, let
     // us first declare the quadrature formula that will be used throughout...
     const QGauss<dim>          quadrature_formula;
-    const QGauss<dim - 1>               face_quadrature_formula;
+    const QGauss<dim - 1>      face_quadrature_formula;
 
     // ... and then also have a vector of history objects, one per quadrature
     // point on those cells for which we are responsible (i.e. we don't store
@@ -3354,28 +3370,28 @@ namespace ElastoPlastic
 
     struct ErrorEstimationStrategy
     {
-       enum value
-       {
-               kelly_error,
-               residual_error,
-               weighted_residual_error,
-               weighted_kelly_error
-       };
+      enum value
+      {
+        kelly_error,
+        residual_error,
+        weighted_residual_error,
+        weighted_kelly_error
+      };
     };
-    typename ErrorEstimationStrategy::value                                             error_estimation_strategy;
+    typename ErrorEstimationStrategy::value            error_estimation_strategy;
 
-    Vector<float>                                                                                                                                                       estimated_error_per_cell;
+    Vector<float>                                      estimated_error_per_cell;
 
     const bool                                         transfer_solution;
     std::string                                        output_dir;
-    TableHandler                                                                                                                                                        table_results,
-                                                                                                                                                                                                        table_results_2,
-                                                                                                                                                                                                        table_results_3;
+    TableHandler                                       table_results,
+                                                       table_results_2,
+                                                       table_results_3;
 
     unsigned int                                       current_refinement_cycle;
 
-    const double                                                                                                                                                        max_relative_error;
-    float                                                                                                                                                                                       relative_error;
+    const double                                       max_relative_error;
+    float                                              relative_error;
 
     const bool                                         show_stresses;
   };
@@ -3406,14 +3422,14 @@ namespace ElastoPlastic
                       " global: one global refinement\n"
                       " percentage: a fixed percentage of cells gets refined using the selected error estimator.");
     prm.declare_entry("error estimation strategy", "kelly_error",
-                                                                       Patterns::Selection("kelly_error|residual_error|weighted_residual_error"),
-                                                                       "Error estimation strategy:\n"
-                                                                       " kelly_error: Kelly error estimator\n"
-                                                                       " residual_error: residual-based error estimator\n"
-                                                                       " weighted_residual_error: dual weighted residual (Goal-oriented) error estimator.\n");
+                      Patterns::Selection("kelly_error|residual_error|weighted_residual_error"),
+                      "Error estimation strategy:\n"
+                      " kelly_error: Kelly error estimator\n"
+                      " residual_error: residual-based error estimator\n"
+                      " weighted_residual_error: dual weighted residual (Goal-oriented) error estimator.\n");
     prm.declare_entry("maximum relative error","0.05",
-                                                                       Patterns::Double(),
-                                                                       "maximum relative error which plays the role of a criteria for refinement.");
+                      Patterns::Double(),
+                      "maximum relative error which plays the role of a criteria for refinement.");
     prm.declare_entry("number of cycles", "5",
                       Patterns::Integer(),
                       "Number of adaptive mesh refinement cycles to run.");
@@ -3428,20 +3444,20 @@ namespace ElastoPlastic
                       "zero on every mesh.");
     prm.declare_entry("base mesh", "Thick_tube_internal_pressure",
                       Patterns::Selection("Timoshenko beam|Thick_tube_internal_pressure|"
-                               "Perforated_strip_tension|Cantiliver_beam_3d"),
+                                          "Perforated_strip_tension|Cantiliver_beam_3d"),
                       "Select the shape of the domain: 'box' or 'half sphere'");
     prm.declare_entry("elasticity modulus","2.e11",
-                                                                       Patterns::Double(),
-                                                                       "Elasticity modulus of the material in MPa (N/mm2)");
+                      Patterns::Double(),
+                      "Elasticity modulus of the material in MPa (N/mm2)");
     prm.declare_entry("Poissons ratio","0.3",
-                                                                       Patterns::Double(),
-                                                                       "Poisson's ratio of the material");
+                      Patterns::Double(),
+                      "Poisson's ratio of the material");
     prm.declare_entry("yield stress","2.e11",
-                                                                       Patterns::Double(),
-                                                                       "Yield stress of the material in MPa (N/mm2)");
+                      Patterns::Double(),
+                      "Yield stress of the material in MPa (N/mm2)");
     prm.declare_entry("isotropic hardening parameter","0.",
-                                                                       Patterns::Double(),
-                                                                       "Isotropic hardening parameter of the material");
+                      Patterns::Double(),
+                      "Isotropic hardening parameter of the material");
     prm.declare_entry("show stresses", "false",
                       Patterns::Bool(),
                       "Whether illustrates the stresses and von Mises stresses or not.");
@@ -3504,13 +3520,13 @@ namespace ElastoPlastic
 
     strat = prm.get("error estimation strategy");
     if (strat == "kelly_error")
-       error_estimation_strategy = ErrorEstimationStrategy::kelly_error;
+      error_estimation_strategy = ErrorEstimationStrategy::kelly_error;
     else if (strat == "residual_error")
-       error_estimation_strategy = ErrorEstimationStrategy::residual_error;
+      error_estimation_strategy = ErrorEstimationStrategy::residual_error;
     else if (strat == "weighted_residual_error")
-       error_estimation_strategy = ErrorEstimationStrategy::weighted_residual_error;
+      error_estimation_strategy = ErrorEstimationStrategy::weighted_residual_error;
     else
-       AssertThrow(false, ExcNotImplemented());
+      AssertThrow(false, ExcNotImplemented());
 
     output_dir = prm.get("output directory");
     if (output_dir != "" && *(output_dir.rbegin()) != '/')
@@ -3550,468 +3566,485 @@ namespace ElastoPlastic
   ElastoPlasticProblem<dim>::make_grid ()
   {
     if (base_mesh == "Timoshenko beam")
-    {
-       AssertThrow (dim == 2, ExcNotImplemented());
-
-       const double length = .48,
-                                                        depth  = .12;
-
-       const Point<dim> point_1(0, -depth/2),
-                                                                        point_2(length, depth/2);
-
-       std::vector<unsigned int> repetitions(2);
-       repetitions[0] = 4;
-       repetitions[1] = 1;
-       GridGenerator::subdivided_hyper_rectangle(triangulation, repetitions, point_1, point_2);
-
-
-       // give the indicators to boundaries for specification,
-       //
-       //     ________100______
-       //     |                |
-       //   0 |                | 5
-       //     |________________|
-       //             100
-       // 0 to essential boundary conditions (left edge) which are as default
-       // 100 to the null boundaries (upper and lower edges) where we do not need to take care of them
-       // 5 to the natural boundaries (right edge) for imposing the traction force
-       typename Triangulation<dim>::cell_iterator
-       cell = triangulation.begin_active(),
-       endc = triangulation.end();
-       for (; cell!=endc; ++cell)
-       {
-               for (unsigned int face=0; face!=GeometryInfo<dim>::faces_per_cell; ++face)
-               {
-                       if ( std::fabs(cell->face(face)->center()(0)-length) < 1e-12 )
-                       {
-                               cell->face(face)->set_boundary_indicator(5);
-                       }else if ( ( std::fabs(cell->face(face)->center()(1)-(depth/2)) < 1e-12 )
-                                       ||
-                                       ( std::fabs(cell->face(face)->center()(1)-(-depth/2)) < 1e-12 ) )
-                       {
-                               cell->face(face)->set_boundary_indicator(100);
-                       }
-
-               }
-       }
-
-      triangulation.refine_global(n_initial_global_refinements);
-
-    }else if (base_mesh == "Thick_tube_internal_pressure")
-    {
-       // Example 1 from the paper: Zhong Z., .... A new numerical method for determining
-       // collapse load-carrying capacity of structure made of elasto-plastic material,
-       // J. Cent. South Univ. (2014) 21: 398-404
-       AssertThrow (dim == 2, ExcNotImplemented());
-
-       const Point<dim> center(0, 0);
-       const double inner_radius = .1,
-                                                        outer_radius = .2;
-       GridGenerator::quarter_hyper_shell(triangulation,
-                                                                                                                                                center, inner_radius, outer_radius,
-                                                                                                                                                0, true);
-
-       // give the indicators to boundaries for specification,
-
-       /*    _____
-            |     \
-            |       \
-          2 |         \ 1
-            |_          \
-              \          \
-             0 \         |
-                |________|
-                    3
-       */
-       // 0 - inner boundary  - natural boundary condition - impose the traction force
-       // 1 - outer boundary  - free boundary - we do not need to take care of them
-       // 2 - left boundary   - essential boundary condition - constrained to move along the x direction
-       // 3 - bottom boundary - essential boundary condition - constrained to move along the y direction
-
-       const HyperBallBoundary<dim> inner_boundary_description(center, inner_radius);
-       triangulation.set_boundary (0, inner_boundary_description);
-
-       const HyperBallBoundary<dim> outer_boundary_description(center, outer_radius);
-       triangulation.set_boundary (1, outer_boundary_description);
-
-      triangulation.refine_global(n_initial_global_refinements);
-
-      triangulation.set_boundary (0);
-      triangulation.set_boundary (1);
-
-    }else if (base_mesh == "Perforated_strip_tension")
-    {
-       // Example 2 from the paper: Zhong Z., .... A new numerical method for determining
-       // collapse load-carrying capacity of structure made of elasto-plastic material,
-       // J. Cent. South Univ. (2014) 21: 398-404
-       AssertThrow (dim == 3, ExcNotImplemented());
-
-       const int dim_2d = 2;
-       const Point<dim_2d> center_2d(0, 0);
-       const double inner_radius = 0.05,
-                                                                        outer_radius = 0.1,
-                                                                        height = 0.18,
-                                                                        thickness = 0.004;
-//                                                                      thickness = 0.01;
-
-       Triangulation<dim_2d> triangulation_1,
-                                                                                               triangulation_2,
-                                                                                               triangulation_2d;
-
-       const double eps = 1e-7 * inner_radius;
-       {
-               Point<dim_2d> point;
-
-               GridGenerator::quarter_hyper_shell(triangulation_1,
-                                                                                                                                                        center_2d, inner_radius, outer_radius,
-                                                                                                                                                        2);
-
-               // Modify the triangulation_1
-               typename Triangulation<dim_2d>::active_cell_iterator
-               cell = triangulation_1.begin_active(),
-               endc = triangulation_1.end();
-               std::vector<bool> treated_vertices(triangulation_1.n_vertices(), false);
-               for (; cell != endc; ++cell)
-               {
-                       for (unsigned int f=0; f<GeometryInfo<dim_2d>::faces_per_cell; ++f)
-                               if (cell->face(f)->at_boundary() && cell->face(f)->center()(0)>eps &&
-                                               cell->face(f)->center()(1)>eps )
-                               {
-                                       // distance of the face center from the center
-                                       point(0) = cell->face(f)->center()(0) - center_2d(0);
-                                       point(1) = cell->face(f)->center()(1) - center_2d(1);
-                                       if ( point.norm() > (inner_radius + eps) )
-                                       {
-                                               for (unsigned int v=0; v < GeometryInfo<dim_2d>::vertices_per_face; ++v)
-                                               {
-                                                       unsigned int vv = cell->face(f)->vertex_index(v);
-                                                       if (treated_vertices[vv] == false)
-                                                       {
-                                                               treated_vertices[vv] = true;
-                                                               if (vv==1)
-                                                               {
-                                                                       cell->face(f)->vertex(v) = center_2d+Point<dim_2d>(outer_radius,outer_radius);
-                                                               }
-                                                       }
-                                               }
-                                       }
-
-                               }
-               }
-
-       }
-
-       // Make the triangulation_2, a rectangular above the triangulation_1
-       {
-               const Point<dim_2d> point1 (0, outer_radius),
-                                                                                point2 (outer_radius, height);
-
-               GridGenerator::hyper_rectangle(triangulation_2, point1, point2);
-
-       }
-
-       // make the triangulation_2d and refine it
-       {
-                               // Merge the two triangulation_1 and triangulation_2
-                               GridGenerator::merge_triangulations(triangulation_1, triangulation_2, triangulation_2d);
-
-                               // Assign boundary indicators to the boundary faces
-                               /*
-                                *
-                                *    /\ y
-                                *     |
-                                *      _____3_____
-                                *     |          |
-                                *     |          |
-                                *   4 |          |
-                                *     |          |
-                                *     |          | 2
-                                *     |_         |
-                                *              \       |
-                                *      10 \      |
-                                *               |______|   ____________\  x
-                                *                  1                   /
-                                */
-                               {
-                                       typename Triangulation<dim_2d>::active_cell_iterator
-                                       cell = triangulation_2d.begin_active(),
-                                       endc = triangulation_2d.end();
-                                       for (; cell != endc; ++cell)
-                                       {
-                                               for (unsigned int f=0; f<GeometryInfo<dim_2d>::faces_per_cell; ++f)
-                                               {
-                                                       if (cell->face(f)->at_boundary())
-                                                       {
-                                                               if ( std::fabs(cell->face(f)->center()(1)) < eps )
-                                                               {
-                                                                       cell->face(f)->set_boundary_indicator(1);
-                                                               }else   if ( std::fabs(cell->face(f)->center()(0)-outer_radius) < eps )
-                                                               {
-                                                                       cell->face(f)->set_boundary_indicator(2);
-                                                               }else   if ( std::fabs(cell->face(f)->center()(1)-height) < eps )
-                                                               {
-                                                                       cell->face(f)->set_boundary_indicator(3);
-                                                               }else   if ( std::fabs(cell->face(f)->center()(0)) < eps )
-                                                               {
-                                                                       cell->face(f)->set_boundary_indicator(4);
-                                                               }else
-                                                               {
-                                                                       cell->face(f)->set_all_boundary_indicators(10);
-                                                               }
-
-                                                       }
-                                               }
-                                       }
-
-                               }
-
-                               const HyperBallBoundary<dim_2d> inner_boundary_description(center_2d, inner_radius);
-                               triangulation_2d.set_boundary (10, inner_boundary_description);
-
-                               triangulation_2d.refine_global(3);
-
-                               triangulation_2d.set_boundary (10);
-       }
-
-       // Extrude the triangulation_2d and make it 3d
-//     GridGenerator::extrude_triangulation(triangulation_2d,
-//                                                                                                                                                      2, thickness, triangulation);
-       extrude_triangulation(triangulation_2d,
-                                                                                               2, thickness, triangulation);
-
-       // Assign boundary indicators to the boundary faces
-       /*
-        *
-        *    /\ y
-        *     |
-        *      _____3_____
-        *     |          |
-        *     |          |
-        *   4 |          |
-        *     |    5|6   |
-        *     |          | 2
-        *     |_         |
-        *              \       |
-        *      10 \      |
-        *               |______|   ____________\  x
-        *                  1                   /
-        */
-       {
-       Point<dim> dist_vector;
-       Point<dim> center(center_2d(0), center_2d(1), 0);
-
-               typename Triangulation<dim>::active_cell_iterator
-               cell = triangulation.begin_active(),
-               endc = triangulation.end();
-               for (; cell != endc; ++cell)
-               {
-               for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
-               {
-                       if (cell->face(f)->at_boundary())
-                       {
-                               dist_vector = cell->face(f)->center() - center;
-
-                               if ( std::fabs(dist_vector(1)) < eps )
-                               {
-                                       cell->face(f)->set_boundary_indicator(1);
-                               }else   if ( std::fabs(dist_vector(0)-outer_radius) < eps )
-                               {
-                                       cell->face(f)->set_boundary_indicator(2);
-                               }else   if ( std::fabs(dist_vector(1)-height) < eps )
-                               {
-                                       cell->face(f)->set_boundary_indicator(3);
-                               }else   if ( std::fabs(dist_vector(0)) < eps )
-                               {
-                                       cell->face(f)->set_boundary_indicator(4);
-                               }else   if ( std::fabs(dist_vector(2)) < eps )
-                               {
-                                       cell->face(f)->set_boundary_indicator(5);
-                               }else   if ( std::fabs(dist_vector(2)-thickness) < eps )
-                               {
-                                       cell->face(f)->set_boundary_indicator(6);
-                               }else
-                               {
-                                       cell->face(f)->set_all_boundary_indicators(10);
-                               }
-
-                       }
-               }
-               }
-
-       }
-
-       const CylinderBoundary<dim> inner_boundary_description(inner_radius, 2);
-       triangulation.set_boundary (10, inner_boundary_description);
-
-      triangulation.refine_global(n_initial_global_refinements);
-
-      triangulation.set_boundary (10);
-
-    }else if (base_mesh == "Cantiliver_beam_3d")
-    {
-       // A rectangular tube made of Aluminium
-       // http://www.google.de/imgres?imgurl=http%3A%2F%2Fwww.americanaluminum.com%2Fimages%2Fstockshape-rectangletube.gif&imgrefurl=http%3A%2F%2Fwww.americanaluminum.com%2Fstandard%2FrectangleTube&h=280&w=300&tbnid=VPDNh4-DJz4wyM%3A&zoom=1&docid=9DoGJCkOeFqiSM&ei=L1AuVfG5GMvtO7DggdAF&tbm=isch&client=ubuntu&iact=rc&uact=3&dur=419&page=1&start=0&ndsp=33&ved=0CGYQrQMwFQ
-       // approximation of beam 17250
-       // units are in meter
-
-       AssertThrow (dim == 3, ExcNotImplemented());
-
-       const int dim_2d = 2;
-
-       const double length = .7,
-                                                        width = 80e-3,
-                                                        height = 200e-3,
-                                                        thickness_web = 10e-3,
-                                                        thickness_flange = 10e-3;
-
-       Triangulation<dim_2d> triangulation_b,
-                                                                                               triangulation_t,
-                                                                                         triangulation_l,
-                                                                                         triangulation_r,
-                                                                                               triangulation_2d;
-
-       const double eps = 1e-7 * width;
-       // Make the triangulation_b, a rectangular at the bottom of rectangular tube
-       {
-               const Point<dim_2d> point1 (-width/2, -height/2),
-                                                                                               point2 (width/2, -(height/2)+thickness_flange);
-
-               std::vector<unsigned int> repetitions(dim_2d);
-               repetitions[0] = 8;
-               repetitions[1] = 1;
-
-               GridGenerator::subdivided_hyper_rectangle(triangulation_b, repetitions, point1, point2);
-       }
-
-       // Make the triangulation_t, a rectangular at the top of rectangular tube
-       {
-               const Point<dim_2d> point1 (-width/2, (height/2)-thickness_flange),
-                                                                                               point2 (width/2, height/2);
-
-               std::vector<unsigned int> repetitions(dim_2d);
-               repetitions[0] = 8;
-               repetitions[1] = 1;
-
-               GridGenerator::subdivided_hyper_rectangle(triangulation_t, repetitions, point1, point2);
-       }
-
-       // Make the triangulation_l, a rectangular at the left of rectangular tube
-       {
-               const Point<dim_2d> point1 (-width/2, -(height/2)+thickness_flange),
-                                                                                               point2 (-(width/2)+thickness_web, (height/2)-thickness_flange);
-
-               std::vector<unsigned int> repetitions(dim_2d);
-               repetitions[0] = 1;
-               repetitions[1] = 18;
-
-               GridGenerator::subdivided_hyper_rectangle(triangulation_l, repetitions, point1, point2);
-       }
-
-       // Make the triangulation_r, a rectangular at the right of rectangular tube
-       {
-               const Point<dim_2d> point1 ((width/2)-thickness_web, -(height/2)+thickness_flange),
-                                                                                               point2 (width/2, (height/2)-thickness_flange);
-
-               std::vector<unsigned int> repetitions(dim_2d);
-               repetitions[0] = 1;
-               repetitions[1] = 18;
-
-               GridGenerator::subdivided_hyper_rectangle(triangulation_r, repetitions, point1, point2);
-       }
-
-       // make the triangulation_2d
-       {
-               // merging every two triangles to make triangulation_2d
-               Triangulation<dim_2d> triangulation_bl,
-                                                                                                       triangulation_blr;
-
-               GridGenerator::merge_triangulations(triangulation_b, triangulation_l, triangulation_bl);
-               GridGenerator::merge_triangulations(triangulation_bl, triangulation_r, triangulation_blr);
-               GridGenerator::merge_triangulations(triangulation_blr, triangulation_t, triangulation_2d);
-       }
-
-       // Extrude the triangulation_2d and make it 3d
-       const unsigned int n_slices = length*1000/20 + 1;
-       extrude_triangulation(triangulation_2d,
-                                                                                               n_slices, length, triangulation);
-
-       // Assign boundary indicators to the boundary faces
-       /*
-        *
-        *                     A
-        *            ---------*----------
-        *           /                   /|
-        *          /                   / |
-        *         /                   /  |
-        *        /       2    length /   |
-        *       /                   /    |
-        *      /                   /     |
-        *     /                   /      |
-        *    /        width      /       |
-        *    --------------------        |
-        *    | --------1-------. |       |
-        *    | :               : |       |
-        *    | :               : |h      |
-        *    | :      y   z    : |e      |
-        *    | :       | /     : |i     /
-        *    |1:       |___ x  :1|g    /
-        *    | :               : |h   /
-        *    | :               : |t  /
-        *    | :               : |  /
-        *    | :               : | /
-        *    | ----------------- |/
-        *    ---------1----------/
-        *
-                        *   face id:
-                        *   Essential boundary condition:
-                        *   1: z = 0: clamped, fixed in x, y and z directions
-                        *   Natural/Newmann boundary condition:
-                        *   2: y = height/2: traction face: pressure on the surface
-                        *   Quantity of interest:
-                        *   displacement at Point A (x=0, y=height/2, z=length)
-        */
-       {
-       Point<dim> dist_vector;
-       Point<dim> center(0, 0, 0);
-
-               typename Triangulation<dim>::active_cell_iterator
-               cell = triangulation.begin_active(),
-               endc = triangulation.end();
-               for (; cell != endc; ++cell)
-               {
-               for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
-               {
-                       if (cell->face(f)->at_boundary())
-                       {
-                               dist_vector = cell->face(f)->center() - center;
-
-                               if ( std::fabs(dist_vector(2)) < eps )
-                               {
-                                       cell->face(f)->set_boundary_indicator(1);
-                               }else   if ( std::fabs(dist_vector(1)-(height/2)) < eps )
-                               {
-                                       cell->face(f)->set_boundary_indicator(2);
-                               }else
-                               {
-                                       cell->face(f)->set_all_boundary_indicators(0);
-                               }
-
-                       }
-               }
-               }
-
-       }
-
-      triangulation.refine_global(n_initial_global_refinements);
-
-    }else
-    {
-       AssertThrow(false, ExcNotImplemented());
-    }
+      {
+        AssertThrow (dim == 2, ExcNotImplemented());
+
+        const double length = .48,
+                     depth  = .12;
+
+        const Point<dim> point_1(0, -depth/2),
+              point_2(length, depth/2);
+
+        std::vector<unsigned int> repetitions(2);
+        repetitions[0] = 4;
+        repetitions[1] = 1;
+        GridGenerator::subdivided_hyper_rectangle(triangulation, repetitions, point_1, point_2);
+
+
+        // give the indicators to boundaries for specification,
+        //
+        //     ________100______
+        //     |                |
+        //   0 |                | 5
+        //     |________________|
+        //             100
+        // 0 to essential boundary conditions (left edge) which are as default
+        // 100 to the null boundaries (upper and lower edges) where we do not need to take care of them
+        // 5 to the natural boundaries (right edge) for imposing the traction force
+        typename Triangulation<dim>::cell_iterator
+        cell = triangulation.begin_active(),
+        endc = triangulation.end();
+        for (; cell!=endc; ++cell)
+          {
+            for (unsigned int face=0; face!=GeometryInfo<dim>::faces_per_cell; ++face)
+              {
+                if ( std::fabs(cell->face(face)->center()(0)-length) < 1e-12 )
+                  {
+                    cell->face(face)->set_boundary_indicator(5);
+                  }
+                else if ( ( std::fabs(cell->face(face)->center()(1)-(depth/2)) < 1e-12 )
+                          ||
+                          ( std::fabs(cell->face(face)->center()(1)-(-depth/2)) < 1e-12 ) )
+                  {
+                    cell->face(face)->set_boundary_indicator(100);
+                  }
+
+              }
+          }
+
+        triangulation.refine_global(n_initial_global_refinements);
+
+      }
+    else if (base_mesh == "Thick_tube_internal_pressure")
+      {
+        // Example 1 from the paper: Zhong Z., .... A new numerical method for determining
+        // collapse load-carrying capacity of structure made of elasto-plastic material,
+        // J. Cent. South Univ. (2014) 21: 398-404
+        AssertThrow (dim == 2, ExcNotImplemented());
+
+        const Point<dim> center(0, 0);
+        const double inner_radius = .1,
+                     outer_radius = .2;
+        GridGenerator::quarter_hyper_shell(triangulation,
+                                           center, inner_radius, outer_radius,
+                                           0, true);
+
+        // give the indicators to boundaries for specification,
+
+        /*    _____
+             |     \
+             |       \
+           2 |         \ 1
+             |_          \
+               \          \
+              0 \         |
+                 |________|
+                     3
+        */
+        // 0 - inner boundary  - natural boundary condition - impose the traction force
+        // 1 - outer boundary  - free boundary - we do not need to take care of them
+        // 2 - left boundary   - essential boundary condition - constrained to move along the x direction
+        // 3 - bottom boundary - essential boundary condition - constrained to move along the y direction
+
+        const HyperBallBoundary<dim> inner_boundary_description(center, inner_radius);
+        triangulation.set_boundary (0, inner_boundary_description);
+
+        const HyperBallBoundary<dim> outer_boundary_description(center, outer_radius);
+        triangulation.set_boundary (1, outer_boundary_description);
+
+        triangulation.refine_global(n_initial_global_refinements);
+
+        triangulation.set_boundary (0);
+        triangulation.set_boundary (1);
+
+      }
+    else if (base_mesh == "Perforated_strip_tension")
+      {
+        // Example 2 from the paper: Zhong Z., .... A new numerical method for determining
+        // collapse load-carrying capacity of structure made of elasto-plastic material,
+        // J. Cent. South Univ. (2014) 21: 398-404
+        AssertThrow (dim == 3, ExcNotImplemented());
+
+        const int dim_2d = 2;
+        const Point<dim_2d> center_2d(0, 0);
+        const double inner_radius = 0.05,
+                     outer_radius = 0.1,
+                     height = 0.18,
+                     thickness = 0.004;
+//                   thickness = 0.01;
+
+        Triangulation<dim_2d> triangulation_1,
+                      triangulation_2,
+                      triangulation_2d;
+
+        const double eps = 1e-7 * inner_radius;
+        {
+          Point<dim_2d> point;
+
+          GridGenerator::quarter_hyper_shell(triangulation_1,
+                                             center_2d, inner_radius, outer_radius,
+                                             2);
+
+          // Modify the triangulation_1
+          typename Triangulation<dim_2d>::active_cell_iterator
+          cell = triangulation_1.begin_active(),
+          endc = triangulation_1.end();
+          std::vector<bool> treated_vertices(triangulation_1.n_vertices(), false);
+          for (; cell != endc; ++cell)
+            {
+              for (unsigned int f=0; f<GeometryInfo<dim_2d>::faces_per_cell; ++f)
+                if (cell->face(f)->at_boundary() && cell->face(f)->center()(0)>eps &&
+                    cell->face(f)->center()(1)>eps )
+                  {
+                    // distance of the face center from the center
+                    point(0) = cell->face(f)->center()(0) - center_2d(0);
+                    point(1) = cell->face(f)->center()(1) - center_2d(1);
+                    if ( point.norm() > (inner_radius + eps) )
+                      {
+                        for (unsigned int v=0; v < GeometryInfo<dim_2d>::vertices_per_face; ++v)
+                          {
+                            unsigned int vv = cell->face(f)->vertex_index(v);
+                            if (treated_vertices[vv] == false)
+                              {
+                                treated_vertices[vv] = true;
+                                if (vv==1)
+                                  {
+                                    cell->face(f)->vertex(v) = center_2d+Point<dim_2d>(outer_radius,outer_radius);
+                                  }
+                              }
+                          }
+                      }
+
+                  }
+            }
+
+        }
+
+        // Make the triangulation_2, a rectangular above the triangulation_1
+        {
+          const Point<dim_2d> point1 (0, outer_radius),
+                point2 (outer_radius, height);
+
+          GridGenerator::hyper_rectangle(triangulation_2, point1, point2);
+
+        }
+
+        // make the triangulation_2d and refine it
+        {
+          // Merge the two triangulation_1 and triangulation_2
+          GridGenerator::merge_triangulations(triangulation_1, triangulation_2, triangulation_2d);
+
+          // Assign boundary indicators to the boundary faces
+          /*
+           *
+           *    /\ y
+           *     |
+           *      _____3_____
+           *     |          |
+           *     |          |
+           *   4 |          |
+           *     |          |
+           *     |          | 2
+           *     |_         |
+           *        \       |
+           *      10 \      |
+           *         |______|   ____________\  x
+           *            1                   /
+           */
+          {
+            typename Triangulation<dim_2d>::active_cell_iterator
+            cell = triangulation_2d.begin_active(),
+            endc = triangulation_2d.end();
+            for (; cell != endc; ++cell)
+              {
+                for (unsigned int f=0; f<GeometryInfo<dim_2d>::faces_per_cell; ++f)
+                  {
+                    if (cell->face(f)->at_boundary())
+                      {
+                        if ( std::fabs(cell->face(f)->center()(1)) < eps )
+                          {
+                            cell->face(f)->set_boundary_indicator(1);
+                          }
+                        else if ( std::fabs(cell->face(f)->center()(0)-outer_radius) < eps )
+                          {
+                            cell->face(f)->set_boundary_indicator(2);
+                          }
+                        else if ( std::fabs(cell->face(f)->center()(1)-height) < eps )
+                          {
+                            cell->face(f)->set_boundary_indicator(3);
+                          }
+                        else if ( std::fabs(cell->face(f)->center()(0)) < eps )
+                          {
+                            cell->face(f)->set_boundary_indicator(4);
+                          }
+                        else
+                          {
+                            cell->face(f)->set_all_boundary_indicators(10);
+                          }
+
+                      }
+                  }
+              }
+
+          }
+
+          const HyperBallBoundary<dim_2d> inner_boundary_description(center_2d, inner_radius);
+          triangulation_2d.set_boundary (10, inner_boundary_description);
+
+          triangulation_2d.refine_global(3);
+
+          triangulation_2d.set_boundary (10);
+        }
+
+        // Extrude the triangulation_2d and make it 3d
+//      GridGenerator::extrude_triangulation(triangulation_2d,
+//                                           2, thickness, triangulation);
+        extrude_triangulation(triangulation_2d,
+                              2, thickness, triangulation);
+
+        // Assign boundary indicators to the boundary faces
+        /*
+         *
+         *    /\ y
+         *     |
+         *      _____3_____
+         *     |          |
+         *     |          |
+         *   4 |          |
+         *     |    5|6   |
+         *     |          | 2
+         *     |_         |
+         *        \       |
+         *      10 \      |
+         *         |______|   ____________\  x
+         *            1                   /
+         */
+        {
+          Point<dim> dist_vector;
+          Point<dim> center(center_2d(0), center_2d(1), 0);
+
+          typename Triangulation<dim>::active_cell_iterator
+          cell = triangulation.begin_active(),
+          endc = triangulation.end();
+          for (; cell != endc; ++cell)
+            {
+              for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
+                {
+                  if (cell->face(f)->at_boundary())
+                    {
+                      dist_vector = cell->face(f)->center() - center;
+
+                      if ( std::fabs(dist_vector(1)) < eps )
+                        {
+                          cell->face(f)->set_boundary_indicator(1);
+                        }
+                      else if ( std::fabs(dist_vector(0)-outer_radius) < eps )
+                        {
+                          cell->face(f)->set_boundary_indicator(2);
+                        }
+                      else if ( std::fabs(dist_vector(1)-height) < eps )
+                        {
+                          cell->face(f)->set_boundary_indicator(3);
+                        }
+                      else if ( std::fabs(dist_vector(0)) < eps )
+                        {
+                          cell->face(f)->set_boundary_indicator(4);
+                        }
+                      else if ( std::fabs(dist_vector(2)) < eps )
+                        {
+                          cell->face(f)->set_boundary_indicator(5);
+                        }
+                      else if ( std::fabs(dist_vector(2)-thickness) < eps )
+                        {
+                          cell->face(f)->set_boundary_indicator(6);
+                        }
+                      else
+                        {
+                          cell->face(f)->set_all_boundary_indicators(10);
+                        }
+
+                    }
+                }
+            }
+
+        }
+
+        const CylinderBoundary<dim> inner_boundary_description(inner_radius, 2);
+        triangulation.set_boundary (10, inner_boundary_description);
+
+        triangulation.refine_global(n_initial_global_refinements);
+
+        triangulation.set_boundary (10);
+
+      }
+    else if (base_mesh == "Cantiliver_beam_3d")
+      {
+        // A rectangular tube made of Aluminium
+        // http://www.google.de/imgres?imgurl=http%3A%2F%2Fwww.americanaluminum.com%2Fimages%2Fstockshape-rectangletube.gif&imgrefurl=http%3A%2F%2Fwww.americanaluminum.com%2Fstandard%2FrectangleTube&h=280&w=300&tbnid=VPDNh4-DJz4wyM%3A&zoom=1&docid=9DoGJCkOeFqiSM&ei=L1AuVfG5GMvtO7DggdAF&tbm=isch&client=ubuntu&iact=rc&uact=3&dur=419&page=1&start=0&ndsp=33&ved=0CGYQrQMwFQ
+        // approximation of beam 17250
+        // units are in meter
+
+        AssertThrow (dim == 3, ExcNotImplemented());
+
+        const int dim_2d = 2;
+
+        const double length = .7,
+                     width = 80e-3,
+                     height = 200e-3,
+                     thickness_web = 10e-3,
+                     thickness_flange = 10e-3;
+
+        Triangulation<dim_2d> triangulation_b,
+                      triangulation_t,
+                      triangulation_l,
+                      triangulation_r,
+                      triangulation_2d;
+
+        const double eps = 1e-7 * width;
+        // Make the triangulation_b, a rectangular at the bottom of rectangular tube
+        {
+          const Point<dim_2d> point1 (-width/2, -height/2),
+                point2 (width/2, -(height/2)+thickness_flange);
+
+          std::vector<unsigned int> repetitions(dim_2d);
+          repetitions[0] = 8;
+          repetitions[1] = 1;
+
+          GridGenerator::subdivided_hyper_rectangle(triangulation_b, repetitions, point1, point2);
+        }
+
+        // Make the triangulation_t, a rectangular at the top of rectangular tube
+        {
+          const Point<dim_2d> point1 (-width/2, (height/2)-thickness_flange),
+                point2 (width/2, height/2);
+
+          std::vector<unsigned int> repetitions(dim_2d);
+          repetitions[0] = 8;
+          repetitions[1] = 1;
+
+          GridGenerator::subdivided_hyper_rectangle(triangulation_t, repetitions, point1, point2);
+        }
+
+        // Make the triangulation_l, a rectangular at the left of rectangular tube
+        {
+          const Point<dim_2d> point1 (-width/2, -(height/2)+thickness_flange),
+                point2 (-(width/2)+thickness_web, (height/2)-thickness_flange);
+
+          std::vector<unsigned int> repetitions(dim_2d);
+          repetitions[0] = 1;
+          repetitions[1] = 18;
+
+          GridGenerator::subdivided_hyper_rectangle(triangulation_l, repetitions, point1, point2);
+        }
+
+        // Make the triangulation_r, a rectangular at the right of rectangular tube
+        {
+          const Point<dim_2d> point1 ((width/2)-thickness_web, -(height/2)+thickness_flange),
+                point2 (width/2, (height/2)-thickness_flange);
+
+          std::vector<unsigned int> repetitions(dim_2d);
+          repetitions[0] = 1;
+          repetitions[1] = 18;
+
+          GridGenerator::subdivided_hyper_rectangle(triangulation_r, repetitions, point1, point2);
+        }
+
+        // make the triangulation_2d
+        {
+          // merging every two triangles to make triangulation_2d
+          Triangulation<dim_2d> triangulation_bl,
+                        triangulation_blr;
+
+          GridGenerator::merge_triangulations(triangulation_b, triangulation_l, triangulation_bl);
+          GridGenerator::merge_triangulations(triangulation_bl, triangulation_r, triangulation_blr);
+          GridGenerator::merge_triangulations(triangulation_blr, triangulation_t, triangulation_2d);
+        }
+
+        // Extrude the triangulation_2d and make it 3d
+        const unsigned int n_slices = length*1000/20 + 1;
+        extrude_triangulation(triangulation_2d,
+                              n_slices, length, triangulation);
+
+        // Assign boundary indicators to the boundary faces
+        /*
+         *
+         *                     A
+         *            ---------*----------
+         *           /                   /|
+         *          /                   / |
+         *         /                   /  |
+         *        /       2    length /   |
+         *       /                   /    |
+         *      /                   /     |
+         *     /                   /      |
+         *    /        width      /       |
+         *    --------------------        |
+         *    | --------1-------. |       |
+         *    | :               : |       |
+         *    | :               : |h      |
+         *    | :      y   z    : |e      |
+         *    | :       | /     : |i     /
+         *    |1:       |___ x  :1|g    /
+         *    | :               : |h   /
+         *    | :               : |t  /
+         *    | :               : |  /
+         *    | :               : | /
+         *    | ----------------- |/
+         *    ---------1----------/
+         *
+         *   face id:
+         *   Essential boundary condition:
+         *   1: z = 0: clamped, fixed in x, y and z directions
+         *   Natural/Newmann boundary condition:
+         *   2: y = height/2: traction face: pressure on the surface
+         *   Quantity of interest:
+         *   displacement at Point A (x=0, y=height/2, z=length)
+         */
+        {
+          Point<dim> dist_vector;
+          Point<dim> center(0, 0, 0);
+
+          typename Triangulation<dim>::active_cell_iterator
+          cell = triangulation.begin_active(),
+          endc = triangulation.end();
+          for (; cell != endc; ++cell)
+            {
+              for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
+                {
+                  if (cell->face(f)->at_boundary())
+                    {
+                      dist_vector = cell->face(f)->center() - center;
+
+                      if ( std::fabs(dist_vector(2)) < eps )
+                        {
+                          cell->face(f)->set_boundary_indicator(1);
+                        }
+                      else if ( std::fabs(dist_vector(1)-(height/2)) < eps )
+                        {
+                          cell->face(f)->set_boundary_indicator(2);
+                        }
+                      else
+                        {
+                          cell->face(f)->set_all_boundary_indicators(0);
+                        }
+
+                    }
+                }
+            }
+
+        }
+
+        triangulation.refine_global(n_initial_global_refinements);
+
+      }
+    else
+      {
+        AssertThrow(false, ExcNotImplemented());
+      }
 
     pcout << "    Number of active cells:       "
-               << triangulation.n_active_cells()
-               << std::endl;
+          << triangulation.n_active_cells()
+          << std::endl;
   }
 
 
@@ -4032,13 +4065,13 @@ namespace ElastoPlastic
   ElastoPlasticProblem<dim>::setup_system ()
   {
     /* setup dofs and get index sets for locally owned and relevant dofs */
-       TimerOutput::Scope t(computing_timer, "Setup");
+    TimerOutput::Scope t(computing_timer, "Setup");
     {
       TimerOutput::Scope t(computing_timer, "Setup: distribute DoFs");
       dof_handler.distribute_dofs(fe);
       pcout << "    Number of degrees of freedom: "
-                       << dof_handler.n_dofs()
-                       << std::endl;
+            << dof_handler.n_dofs()
+            << std::endl;
 
       locally_owned_dofs = dof_handler.locally_owned_dofs();
       locally_relevant_dofs.clear();
@@ -4066,9 +4099,9 @@ namespace ElastoPlastic
     {
       TimerOutput::Scope t(computing_timer, "Setup: vectors");
       if (timestep_no==1 || current_refinement_cycle!=0)
-      {
-       solution.reinit(locally_relevant_dofs, mpi_communicator);
-      }
+        {
+          solution.reinit(locally_relevant_dofs, mpi_communicator);
+        }
       incremental_displacement.reinit(locally_relevant_dofs, mpi_communicator);
       newton_rhs.reinit(locally_owned_dofs, mpi_communicator);
       newton_rhs_residual.reinit(locally_owned_dofs, mpi_communicator);
@@ -4119,64 +4152,78 @@ namespace ElastoPlastic
     std::vector<bool> component_mask(dim);
 
     if (base_mesh == "Timoshenko beam")
-    {
-       VectorTools::interpolate_boundary_values(dof_handler,
-                                                                                                                                                                        0,
-                                                                                                                                                                        EquationData::IncrementalBoundaryValues<dim>(present_time, end_time),
-                                                                                                                                                                        constraints_dirichlet_and_hanging_nodes,
-                                                                                                                                                                        ComponentMask());
-    }else if (base_mesh == "Thick_tube_internal_pressure")
-    {
-       // the boundary x = 0
-       component_mask[0] = true; component_mask[1] = false;
-       VectorTools::interpolate_boundary_values (dof_handler,
-                                                                                                                                                                               2,
-                                                                                                                                                                               EquationData::IncrementalBoundaryValues<dim>(present_time, end_time),
-                                                                                                                                                                               constraints_dirichlet_and_hanging_nodes,
-                                                                                                                                                                               component_mask);
-       // the boundary y = 0
-       component_mask[0] = false; component_mask[1] = true;
-       VectorTools::interpolate_boundary_values (dof_handler,
-                                                                                                                                                                               3,
-                                                                                                                                                                               EquationData::IncrementalBoundaryValues<dim>(present_time, end_time),
-                                                                                                                                                                               constraints_dirichlet_and_hanging_nodes,
-                                                                                                                                                                               component_mask);
-    }else if (base_mesh == "Perforated_strip_tension")
-    {
-       // the boundary x = 0
-       component_mask[0] = true; component_mask[1] = false; component_mask[2] = false;
-       VectorTools::interpolate_boundary_values (dof_handler,
-                                                                                                                                                                               4,
-                                                                                                                                                                               EquationData::IncrementalBoundaryValues<dim>(present_time, end_time),
-                                                                                                                                                                               constraints_dirichlet_and_hanging_nodes,
-                                                                                                                                                                               component_mask);
-       // the boundary y = 0
-       component_mask[0] = false; component_mask[1] = true; component_mask[2] = false;
-       VectorTools::interpolate_boundary_values (dof_handler,
-                                                                                                                                                                               1,
-                                                                                                                                                                               EquationData::IncrementalBoundaryValues<dim>(present_time, end_time),
-                                                                                                                                                                               constraints_dirichlet_and_hanging_nodes,
-                                                                                                                                                                               component_mask);
-       // the boundary y = imposed incremental displacement
-       component_mask[0] = false; component_mask[1] = true; component_mask[2] = false;
-       VectorTools::interpolate_boundary_values (dof_handler,
-                                                                                                                                                                               3,
-                                                                                                                                                                               EquationData::IncrementalBoundaryValues<dim>(present_time, end_time),
-                                                                                                                                                                               constraints_dirichlet_and_hanging_nodes,
-                                                                                                                                                                               component_mask);
-    }else if (base_mesh == "Cantiliver_beam_3d")
-    {
-       // the boundary x = y = z = 0
-       component_mask[0] = true; component_mask[1] = true; component_mask[2] = true;
-       VectorTools::interpolate_boundary_values (dof_handler,
-                                                                                                                                                                               1,
-                                                                                                                                                                               EquationData::IncrementalBoundaryValues<dim>(present_time, end_time),
-                                                                                                                                                                               constraints_dirichlet_and_hanging_nodes,
-                                                                                                                                                                               component_mask);
-    }else
-    {
-       AssertThrow(false, ExcNotImplemented());
-    }
+      {
+        VectorTools::interpolate_boundary_values(dof_handler,
+                                                 0,
+                                                 EquationData::IncrementalBoundaryValues<dim>(present_time, end_time),
+                                                 constraints_dirichlet_and_hanging_nodes,
+                                                 ComponentMask());
+      }
+    else if (base_mesh == "Thick_tube_internal_pressure")
+      {
+        // the boundary x = 0
+        component_mask[0] = true;
+        component_mask[1] = false;
+        VectorTools::interpolate_boundary_values (dof_handler,
+                                                  2,
+                                                  EquationData::IncrementalBoundaryValues<dim>(present_time, end_time),
+                                                  constraints_dirichlet_and_hanging_nodes,
+                                                  component_mask);
+        // the boundary y = 0
+        component_mask[0] = false;
+        component_mask[1] = true;
+        VectorTools::interpolate_boundary_values (dof_handler,
+                                                  3,
+                                                  EquationData::IncrementalBoundaryValues<dim>(present_time, end_time),
+                                                  constraints_dirichlet_and_hanging_nodes,
+                                                  component_mask);
+      }
+    else if (base_mesh == "Perforated_strip_tension")
+      {
+        // the boundary x = 0
+        component_mask[0] = true;
+        component_mask[1] = false;
+        component_mask[2] = false;
+        VectorTools::interpolate_boundary_values (dof_handler,
+                                                  4,
+                                                  EquationData::IncrementalBoundaryValues<dim>(present_time, end_time),
+                                                  constraints_dirichlet_and_hanging_nodes,
+                                                  component_mask);
+        // the boundary y = 0
+        component_mask[0] = false;
+        component_mask[1] = true;
+        component_mask[2] = false;
+        VectorTools::interpolate_boundary_values (dof_handler,
+                                                  1,
+                                                  EquationData::IncrementalBoundaryValues<dim>(present_time, end_time),
+                                                  constraints_dirichlet_and_hanging_nodes,
+                                                  component_mask);
+        // the boundary y = imposed incremental displacement
+        component_mask[0] = false;
+        component_mask[1] = true;
+        component_mask[2] = false;
+        VectorTools::interpolate_boundary_values (dof_handler,
+                                                  3,
+                                                  EquationData::IncrementalBoundaryValues<dim>(present_time, end_time),
+                                                  constraints_dirichlet_and_hanging_nodes,
+                                                  component_mask);
+      }
+    else if (base_mesh == "Cantiliver_beam_3d")
+      {
+        // the boundary x = y = z = 0
+        component_mask[0] = true;
+        component_mask[1] = true;
+        component_mask[2] = true;
+        VectorTools::interpolate_boundary_values (dof_handler,
+                                                  1,
+                                                  EquationData::IncrementalBoundaryValues<dim>(present_time, end_time),
+                                                  constraints_dirichlet_and_hanging_nodes,
+                                                  component_mask);
+      }
+    else
+      {
+        AssertThrow(false, ExcNotImplemented());
+      }
 
 
     constraints_dirichlet_and_hanging_nodes.close();
@@ -4197,21 +4244,23 @@ namespace ElastoPlastic
   void
   ElastoPlasticProblem<dim>::
   assemble_newton_system (const TrilinosWrappers::MPI::Vector &linearization_point,
-                                                                                                 const TrilinosWrappers::MPI::Vector &delta_linearization_point)
+                          const TrilinosWrappers::MPI::Vector &delta_linearization_point)
   {
     TimerOutput::Scope t(computing_timer, "Assembling");
 
     types::boundary_id traction_surface_id;
     if (base_mesh == "Timoshenko beam")
-    {
-       traction_surface_id = 5;
-    }else if (base_mesh == "Thick_tube_internal_pressure")
-    {
-       traction_surface_id = 0;
-    }else if (base_mesh == "Cantiliver_beam_3d")
-    {
-       traction_surface_id = 2;
-    }
+      {
+        traction_surface_id = 5;
+      }
+    else if (base_mesh == "Thick_tube_internal_pressure")
+      {
+        traction_surface_id = 0;
+      }
+    else if (base_mesh == "Cantiliver_beam_3d")
+      {
+        traction_surface_id = 2;
+      }
 
     FEValues<dim> fe_values(fe, quadrature_formula,
                             update_values | update_gradients |
@@ -4225,14 +4274,14 @@ namespace ElastoPlastic
     const unsigned int n_face_q_points = face_quadrature_formula.size();
 
 
-    const EquationData::BodyForce<dim>          body_force;
-    std::vector<Vector<double> >                                        body_force_values(n_q_points,
-                                                                                                                                                                                                                                Vector<double>(dim));
+    const EquationData::BodyForce<dim>     body_force;
+    std::vector<Vector<double> >           body_force_values(n_q_points,
+                                                             Vector<double>(dim));
 
     const EquationData::
-    IncrementalBoundaryForce<dim>                               boundary_force(present_time, end_time);
+    IncrementalBoundaryForce<dim>          boundary_force(present_time, end_time);
     std::vector<Vector<double> >           boundary_force_values(n_face_q_points,
-                                                                                                                                                                                                                                        Vector<double>(dim));
+        Vector<double>(dim));
 
     FullMatrix<double>                     cell_matrix(dofs_per_cell, dofs_per_cell);
     Vector<double>                         cell_rhs(dofs_per_cell);
@@ -4256,7 +4305,7 @@ namespace ElastoPlastic
           cell_rhs = 0;
 
           fe_values[displacement].get_function_symmetric_gradients(delta_linearization_point,
-                                                                                                                                                                                                                                        incremental_strain_tensor);
+                                                                   incremental_strain_tensor);
 
           // For assembling the local right hand side contributions, we need
           // to access the prior linearized stress value in this quadrature
@@ -4266,13 +4315,13 @@ namespace ElastoPlastic
           // and then add an offset corresponding to the index of the
           // quadrature point we presently consider:
           const PointHistory<dim> *local_quadrature_points_history
-               = reinterpret_cast<PointHistory<dim>*>(cell->user_pointer());
-                               Assert (local_quadrature_points_history >=
-                                                               &quadrature_point_history.front(),
-                                                               ExcInternalError());
-                               Assert (local_quadrature_points_history <
-                                                               &quadrature_point_history.back(),
-                                                               ExcInternalError());
+            = reinterpret_cast<PointHistory<dim>*>(cell->user_pointer());
+          Assert (local_quadrature_points_history >=
+                  &quadrature_point_history.front(),
+                  ExcInternalError());
+          Assert (local_quadrature_points_history <
+                  &quadrature_point_history.back(),
+                  ExcInternalError());
 
           // In addition, we need the values of the external body forces at
           // the quadrature points on this cell:
@@ -4281,9 +4330,9 @@ namespace ElastoPlastic
 
           for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
             {
-                       SymmetricTensor<2, dim> tmp_strain_tensor_qpoint;
-                       tmp_strain_tensor_qpoint = local_quadrature_points_history[q_point].old_strain
-                                                                                                                                       + incremental_strain_tensor[q_point];
+              SymmetricTensor<2, dim> tmp_strain_tensor_qpoint;
+              tmp_strain_tensor_qpoint = local_quadrature_points_history[q_point].old_strain
+                                         + incremental_strain_tensor[q_point];
 
               SymmetricTensor<4, dim> stress_strain_tensor_linearized;
               SymmetricTensor<4, dim> stress_strain_tensor;
@@ -4293,9 +4342,9 @@ namespace ElastoPlastic
 
               Tensor<1, dim> rhs_values_body_force;
               for (unsigned int i = 0; i < dim; ++i)
-              {
-               rhs_values_body_force[i] = body_force_values[q_point][i];
-              }
+                {
+                  rhs_values_body_force[i] = body_force_values[q_point][i];
+                }
 
               for (unsigned int i = 0; i < dofs_per_cell; ++i)
                 {
@@ -4326,11 +4375,11 @@ namespace ElastoPlastic
                                           * fe_values.JxW(q_point));
 
                   cell_rhs(i) += (
-                                                                                ( stress_phi_i
-                                                                                        * incremental_strain_tensor[q_point] )
+                                   ( stress_phi_i
+                                     * incremental_strain_tensor[q_point] )
                                    -
                                    ( ( stress_strain_tensor
-                                     * fe_values[displacement].symmetric_gradient(i, q_point))
+                                       * fe_values[displacement].symmetric_gradient(i, q_point))
                                      * tmp_strain_tensor_qpoint )
                                    +
                                    ( fe_values[displacement].value(i, q_point)
@@ -4354,9 +4403,9 @@ namespace ElastoPlastic
                   {
                     Tensor<1, dim> rhs_values;
                     for (unsigned int i = 0; i < dim; ++i)
-                    {
-                       rhs_values[i] = boundary_force_values[q_point][i];
-                    }
+                      {
+                        rhs_values[i] = boundary_force_values[q_point][i];
+                      }
                     for (unsigned int i = 0; i < dofs_per_cell; ++i)
                       cell_rhs(i) += (fe_values_face[displacement].value(i, q_point)
                                       * rhs_values
@@ -4366,10 +4415,10 @@ namespace ElastoPlastic
 
           cell->get_dof_indices(local_dof_indices);
           constraints_dirichlet_and_hanging_nodes.distribute_local_to_global(cell_matrix, cell_rhs,
-                                                                                                                                                local_dof_indices,
-                                                                                                                                                newton_matrix,
-                                                                                                                                                newton_rhs,
-                                                                                                                                                true);
+              local_dof_indices,
+              newton_matrix,
+              newton_rhs,
+              true);
 
         }
 
@@ -4410,15 +4459,17 @@ namespace ElastoPlastic
   {
     types::boundary_id traction_surface_id;
     if (base_mesh == "Timoshenko beam")
-    {
-       traction_surface_id = 5;
-    }else if (base_mesh == "Thick_tube_internal_pressure")
-    {
-       traction_surface_id = 0;
-    }else if (base_mesh == "Cantiliver_beam_3d")
-    {
-       traction_surface_id = 2;
-    }
+      {
+        traction_surface_id = 5;
+      }
+    else if (base_mesh == "Thick_tube_internal_pressure")
+      {
+        traction_surface_id = 0;
+      }
+    else if (base_mesh == "Cantiliver_beam_3d")
+      {
+        traction_surface_id = 2;
+      }
 
     FEValues<dim> fe_values(fe, quadrature_formula,
                             update_values | update_gradients | update_quadrature_points |
@@ -4432,14 +4483,14 @@ namespace ElastoPlastic
     const unsigned int n_q_points      = quadrature_formula.size();
     const unsigned int n_face_q_points = face_quadrature_formula.size();
 
-    const EquationData::BodyForce<dim>          body_force;
-    std::vector<Vector<double> >                                        body_force_values(n_q_points,
-                                                                                                                                                                                                                                Vector<double>(dim));
+    const EquationData::BodyForce<dim>     body_force;
+    std::vector<Vector<double> >           body_force_values(n_q_points,
+                                                             Vector<double>(dim));
 
     const EquationData::
-    IncrementalBoundaryForce<dim>                               boundary_force(present_time, end_time);
+    IncrementalBoundaryForce<dim>          boundary_force(present_time, end_time);
     std::vector<Vector<double> >           boundary_force_values(n_face_q_points,
-                                                                                                                                                                                                                                        Vector<double>(dim));
+        Vector<double>(dim));
 
     Vector<double> cell_rhs(dofs_per_cell);
 
@@ -4466,7 +4517,7 @@ namespace ElastoPlastic
                                                                    strain_tensors);
 
           body_force.vector_value_list(fe_values.get_quadrature_points(),
-                                                                                                                        body_force_values);
+                                       body_force_values);
 
           for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
             {
@@ -4479,20 +4530,20 @@ namespace ElastoPlastic
 
               Tensor<1, dim> rhs_values_body_force;
               for (unsigned int i = 0; i < dim; ++i)
-              {
-               rhs_values_body_force[i] = body_force_values[q_point][i];
-              }
+                {
+                  rhs_values_body_force[i] = body_force_values[q_point][i];
+                }
 
               for (unsigned int i = 0; i < dofs_per_cell; ++i)
                 {
                   cell_rhs(i) += (fe_values[displacement].value(i, q_point)
-                                                                                                                                * rhs_values_body_force
-                                                                               -
-                                                                               strain_tensors[q_point]
-                                   * stress_strain_tensor
-                                   * fe_values[displacement].symmetric_gradient(i, q_point)
-                                  )
-                                  * fe_values.JxW(q_point);
+                                  * rhs_values_body_force
+                                  -
+                                  strain_tensors[q_point]
+                                  * stress_strain_tensor
+                                  * fe_values[displacement].symmetric_gradient(i, q_point)
+                                 )
+                                 * fe_values.JxW(q_point);
 
                   Tensor<1, dim> rhs_values;
                   rhs_values = 0;
@@ -4516,9 +4567,9 @@ namespace ElastoPlastic
                   {
                     Tensor<1, dim> rhs_values;
                     for (unsigned int i = 0; i < dim; ++i)
-                    {
-                       rhs_values[i] = boundary_force_values[q_point][i];
-                    }
+                      {
+                        rhs_values[i] = boundary_force_values[q_point][i];
+                      }
                     for (unsigned int i = 0; i < dofs_per_cell; ++i)
                       cell_rhs(i) += (fe_values_face[displacement].value(i, q_point) * rhs_values
                                       * fe_values_face.JxW(q_point));
@@ -4527,8 +4578,8 @@ namespace ElastoPlastic
 
           cell->get_dof_indices(local_dof_indices);
           constraints_dirichlet_and_hanging_nodes.distribute_local_to_global(cell_rhs,
-                                                                                                                                                                                                                                                                                local_dof_indices,
-                                                                                                                                                                                                                                                                                newton_rhs_residual);
+              local_dof_indices,
+              newton_rhs_residual);
 
         }
 
@@ -4688,13 +4739,13 @@ namespace ElastoPlastic
     TrilinosWrappers::MPI::Vector tmp_vector(locally_owned_dofs, mpi_communicator);
     TrilinosWrappers::MPI::Vector locally_relevant_tmp_vector(locally_relevant_dofs, mpi_communicator);
     TrilinosWrappers::MPI::Vector distributed_solution(locally_owned_dofs, mpi_communicator);
-    TrilinosWrappers::MPI::Vector      tmp_solution(locally_owned_dofs, mpi_communicator);
+    TrilinosWrappers::MPI::Vector tmp_solution(locally_owned_dofs, mpi_communicator);
 
     double residual_norm;
     double previous_residual_norm = -std::numeric_limits<double>::max();
 
     double disp_norm,
-                        previous_disp_norm = 0;
+           previous_disp_norm = 0;
 
     const double correct_sigma = sigma_0;
 
@@ -4715,14 +4766,14 @@ namespace ElastoPlastic
         pcout << "   Newton iteration " << newton_step << std::endl;
 
         pcout << "      Assembling system... " << std::endl;
-        newton_matrix                  = 0;
-        newton_rhs                                     = 0;
+        newton_matrix       = 0;
+        newton_rhs          = 0;
         newton_rhs_residual = 0;
 
         tmp_solution = solution;
         tmp_solution += incremental_displacement;
         assemble_newton_system(tmp_solution,
-                                                                                                incremental_displacement);
+                               incremental_displacement);
 
         pcout << "      Solving system... " << std::endl;
         solve_newton_system();
@@ -4760,8 +4811,8 @@ namespace ElastoPlastic
             ||
             (!transfer_solution && newton_step == 2))
           {
-                                               tmp_solution = solution;
-                                               tmp_solution += incremental_displacement;
+            tmp_solution = solution;
+            tmp_solution += incremental_displacement;
             compute_nonlinear_residual(tmp_solution);
             old_solution = incremental_displacement;
 
@@ -4817,16 +4868,16 @@ namespace ElastoPlastic
         // the iteration on the current mesh:
 //        if (residual_norm < 1e-10)
         if (residual_norm < 1e-7)
-               break;
+          break;
 
         pcout << "    difference of two consecutive incremental displacement l2 norm : "
-                                       << std::abs(disp_norm - previous_disp_norm) << std::endl;
+              << std::abs(disp_norm - previous_disp_norm) << std::endl;
         if ( std::abs(disp_norm - previous_disp_norm) < 1e-10 &&
-                       (residual_norm < 1e-5 || std::abs(residual_norm - previous_residual_norm)<1e-9) )
-        {
-               pcout << " Convergence by difference of two consecutive solution! " << std::endl;
-               break;
-        }
+             (residual_norm < 1e-5 || std::abs(residual_norm - previous_residual_norm)<1e-9) )
+          {
+            pcout << " Convergence by difference of two consecutive solution! " << std::endl;
+            break;
+          }
 
 
         previous_residual_norm = residual_norm;
@@ -4840,156 +4891,163 @@ namespace ElastoPlastic
   void
   ElastoPlasticProblem<dim>::compute_error ()
   {
-       TrilinosWrappers::MPI::Vector           tmp_solution(locally_owned_dofs, mpi_communicator);
-       tmp_solution = solution;
-       tmp_solution += incremental_displacement;
-
-       estimated_error_per_cell.reinit (triangulation.n_active_cells());
-       if (error_estimation_strategy == ErrorEstimationStrategy::kelly_error)
-       {
-               KellyErrorEstimator<dim>::estimate(dof_handler,
-                                                                                                                                                          QGauss<dim - 1>(fe.degree + 2),
-                                                                                                                                                          typename FunctionMap<dim>::type(),
-                                                                                                                                                          tmp_solution,
-                                                                                                                                                          estimated_error_per_cell);
-
-       }else if (error_estimation_strategy == ErrorEstimationStrategy::residual_error)
-       {
-               compute_error_residual(tmp_solution);
-
-       }else if (error_estimation_strategy == ErrorEstimationStrategy::weighted_residual_error)
-       {
-               // make a non-parallel copy of tmp_solution
-               Vector<double> copy_solution(tmp_solution);
-
-               // the dual function definition (it should be defined previously, e.g. input file)
-               if (base_mesh == "Timoshenko beam")
-               {
-                       double length = .48,
-                                                depth  = .12;
-
-               const Point<dim> evaluation_point(length, -depth/2);
-
-               DualFunctional::PointValuesEvaluation<dim> dual_functional(evaluation_point);
-
-               DualSolver<dim> dual_solver(triangulation, fe,
-                                                                                                                               copy_solution,
-                                                                                                                               constitutive_law, dual_functional,
-                                                                                                                               timestep_no, output_dir, base_mesh,
-                                                                                                                               present_time, end_time);
-
-               dual_solver.compute_error_DWR (estimated_error_per_cell);
-
-               }else if (base_mesh == "Thick_tube_internal_pressure")
-               {
-                       const unsigned int face_id = 0;
-        std::vector<std::vector<unsigned int> > comp_stress(dim);
-        for (unsigned int i=0; i!=dim; ++i)
-        {
-               comp_stress[i].resize(dim);
-               for (unsigned int j=0; j!=dim; ++j)
-               {
-                       comp_stress[i][j] = 1;
-               }
-        }
+    TrilinosWrappers::MPI::Vector   tmp_solution(locally_owned_dofs, mpi_communicator);
+    tmp_solution = solution;
+    tmp_solution += incremental_displacement;
+
+    estimated_error_per_cell.reinit (triangulation.n_active_cells());
+    if (error_estimation_strategy == ErrorEstimationStrategy::kelly_error)
+      {
+        KellyErrorEstimator<dim>::estimate(dof_handler,
+                                           QGauss<dim - 1>(fe.degree + 2),
+                                           typename FunctionMap<dim>::type(),
+                                           tmp_solution,
+                                           estimated_error_per_cell);
+
+      }
+    else if (error_estimation_strategy == ErrorEstimationStrategy::residual_error)
+      {
+        compute_error_residual(tmp_solution);
 
-               DualFunctional::MeanStressFace<dim> dual_functional(face_id, comp_stress);
+      }
+    else if (error_estimation_strategy == ErrorEstimationStrategy::weighted_residual_error)
+      {
+        // make a non-parallel copy of tmp_solution
+        Vector<double> copy_solution(tmp_solution);
 
-               DualSolver<dim> dual_solver(triangulation, fe,
-                                                                                                                               copy_solution,
-                                                                                                                               constitutive_law, dual_functional,
-                                                                                                                               timestep_no, output_dir, base_mesh,
-                                                                                                                               present_time, end_time);
+        // the dual function definition (it should be defined previously, e.g. input file)
+        if (base_mesh == "Timoshenko beam")
+          {
+            double length = .48,
+                   depth  = .12;
 
-               dual_solver.compute_error_DWR (estimated_error_per_cell);
+            const Point<dim> evaluation_point(length, -depth/2);
 
-               }else if (base_mesh == "Perforated_strip_tension")
-               {
-                       // .........................................
-                       // Mean stress_yy over the bottom boundary
-                       const unsigned int face_id = 1;
-        std::vector<std::vector<unsigned int> > comp_stress(dim);
-        for (unsigned int i=0; i!=dim; ++i)
-        {
-               comp_stress[i].resize(dim);
-               for (unsigned int j=0; j!=dim; ++j)
-               {
-                       comp_stress[i][j] = 0;
-               }
-        }
-        comp_stress[1][1] = 1;
+            DualFunctional::PointValuesEvaluation<dim> dual_functional(evaluation_point);
+
+            DualSolver<dim> dual_solver(triangulation, fe,
+                                        copy_solution,
+                                        constitutive_law, dual_functional,
+                                        timestep_no, output_dir, base_mesh,
+                                        present_time, end_time);
+
+            dual_solver.compute_error_DWR (estimated_error_per_cell);
+
+          }
+        else if (base_mesh == "Thick_tube_internal_pressure")
+          {
+            const unsigned int face_id = 0;
+            std::vector<std::vector<unsigned int> > comp_stress(dim);
+            for (unsigned int i=0; i!=dim; ++i)
+              {
+                comp_stress[i].resize(dim);
+                for (unsigned int j=0; j!=dim; ++j)
+                  {
+                    comp_stress[i][j] = 1;
+                  }
+              }
 
-               DualFunctional::MeanStressFace<dim> dual_functional(face_id, comp_stress);
+            DualFunctional::MeanStressFace<dim> dual_functional(face_id, comp_stress);
 
-               // .........................................
+            DualSolver<dim> dual_solver(triangulation, fe,
+                                        copy_solution,
+                                        constitutive_law, dual_functional,
+                                        timestep_no, output_dir, base_mesh,
+                                        present_time, end_time);
 
-               DualSolver<dim> dual_solver(triangulation, fe,
-                                                                                                                               copy_solution,
-                                                                                                                               constitutive_law, dual_functional,
-                                                                                                                               timestep_no, output_dir, base_mesh,
-                                                                                                                               present_time, end_time);
+            dual_solver.compute_error_DWR (estimated_error_per_cell);
 
-               dual_solver.compute_error_DWR (estimated_error_per_cell);
+          }
+        else if (base_mesh == "Perforated_strip_tension")
+          {
+            // .........................................
+            // Mean stress_yy over the bottom boundary
+            const unsigned int face_id = 1;
+            std::vector<std::vector<unsigned int> > comp_stress(dim);
+            for (unsigned int i=0; i!=dim; ++i)
+              {
+                comp_stress[i].resize(dim);
+                for (unsigned int j=0; j!=dim; ++j)
+                  {
+                    comp_stress[i][j] = 0;
+                  }
+              }
+            comp_stress[1][1] = 1;
 
-               }else if (base_mesh == "Cantiliver_beam_3d")
-               {
-                       // Quantity of interest:
-                       // -----------------------------------------------------------
-                       // displacement at Point A (x=0, y=height/2, z=length)
-                       /*
-       const double length = .7,
-                                                        height = 200e-3;
+            DualFunctional::MeanStressFace<dim> dual_functional(face_id, comp_stress);
 
-               const Point<dim> evaluation_point(0, height/2, length);
+            // .........................................
 
-               DualFunctional::PointValuesEvaluation<dim> dual_functional(evaluation_point);
-               */
+            DualSolver<dim> dual_solver(triangulation, fe,
+                                        copy_solution,
+                                        constitutive_law, dual_functional,
+                                        timestep_no, output_dir, base_mesh,
+                                        present_time, end_time);
 
-                       // -----------------------------------------------------------
-       // Mean stress at the specified domain is of interest.
-       // The interest domains are located on the bottom and top of the flanges
-       // close to the clamped face, z = 0
-       // top domain: height/2 - thickness_flange <= y <= height/2
-       //             0 <= z <= 2 * thickness_flange
-       // bottom domain: -height/2 <= y <= -height/2 + thickness_flange
-       //             0 <= z <= 2 * thickness_flange
+            dual_solver.compute_error_DWR (estimated_error_per_cell);
 
-        std::vector<std::vector<unsigned int> > comp_stress(dim);
-        for (unsigned int i=0; i!=dim; ++i)
-        {
-               comp_stress[i].resize(dim);
-               for (unsigned int j=0; j!=dim; ++j)
-               {
-                       comp_stress[i][j] = 1;
-               }
-        }
-               DualFunctional::MeanStressDomain<dim>   dual_functional(base_mesh, comp_stress);
+          }
+        else if (base_mesh == "Cantiliver_beam_3d")
+          {
+            // Quantity of interest:
+            // -----------------------------------------------------------
+            // displacement at Point A (x=0, y=height/2, z=length)
+            /*
+            const double length = .7,
+                         height = 200e-3;
+
+            const Point<dim> evaluation_point(0, height/2, length);
+
+            DualFunctional::PointValuesEvaluation<dim> dual_functional(evaluation_point);
+            */
+
+            // -----------------------------------------------------------
+            // Mean stress at the specified domain is of interest.
+            // The interest domains are located on the bottom and top of the flanges
+            // close to the clamped face, z = 0
+            // top domain: height/2 - thickness_flange <= y <= height/2
+            //             0 <= z <= 2 * thickness_flange
+            // bottom domain: -height/2 <= y <= -height/2 + thickness_flange
+            //             0 <= z <= 2 * thickness_flange
+
+            std::vector<std::vector<unsigned int> > comp_stress(dim);
+            for (unsigned int i=0; i!=dim; ++i)
+              {
+                comp_stress[i].resize(dim);
+                for (unsigned int j=0; j!=dim; ++j)
+                  {
+                    comp_stress[i][j] = 1;
+                  }
+              }
+            DualFunctional::MeanStressDomain<dim> dual_functional(base_mesh, comp_stress);
 
-                       // -----------------------------------------------------------
+            // -----------------------------------------------------------
 
-               DualSolver<dim> dual_solver(triangulation, fe,
-                                                                                                                               copy_solution,
-                                                                                                                               constitutive_law, dual_functional,
-                                                                                                                               timestep_no, output_dir, base_mesh,
-                                                                                                                               present_time, end_time);
+            DualSolver<dim> dual_solver(triangulation, fe,
+                                        copy_solution,
+                                        constitutive_law, dual_functional,
+                                        timestep_no, output_dir, base_mesh,
+                                        present_time, end_time);
 
-               dual_solver.compute_error_DWR (estimated_error_per_cell);
+            dual_solver.compute_error_DWR (estimated_error_per_cell);
 
-               }else
-               {
-                       AssertThrow(false, ExcNotImplemented());
-               }
+          }
+        else
+          {
+            AssertThrow(false, ExcNotImplemented());
+          }
 
 
-       }else
-       {
-               AssertThrow(false, ExcNotImplemented());
-       }
+      }
+    else
+      {
+        AssertThrow(false, ExcNotImplemented());
+      }
 
 
-       relative_error = estimated_error_per_cell.l2_norm() / tmp_solution.l2_norm();
+    relative_error = estimated_error_per_cell.l2_norm() / tmp_solution.l2_norm();
 
-       pcout << "Estimated relative error = " << relative_error << std::endl;
+    pcout << "Estimated relative error = " << relative_error << std::endl;
 
   }
 
@@ -4997,382 +5055,383 @@ namespace ElastoPlastic
   void
   ElastoPlasticProblem<dim>::compute_error_residual (const TrilinosWrappers::MPI::Vector &tmp_solution)
   {
-               FEValues<dim> fe_values(fe, quadrature_formula,
-                                                                                                               update_values    |
-                                                                                                               update_gradients |
-                                                                                                               update_hessians  |
-                                                                                                               update_quadrature_points |
-                                                                                                               update_JxW_values);
-
-               const unsigned int n_q_points      = quadrature_formula.size();
-               std::vector<SymmetricTensor<2, dim> > strain_tensor(n_q_points);
-               SymmetricTensor<4, dim> stress_strain_tensor_linearized;
-               SymmetricTensor<4, dim> stress_strain_tensor;
-               Tensor<5, dim>                                  stress_strain_tensor_grad;
-               std::vector<std::vector<Tensor<2,dim> > > cell_hessians (n_q_points);
-               for (unsigned int i=0; i!=n_q_points; ++i)
-               {
-                       cell_hessians[i].resize (dim);
-               }
-               const EquationData::BodyForce<dim> body_force;
-
-               std::vector<Vector<double> > body_force_values (n_q_points, Vector<double>(dim));
-               const FEValuesExtractors::Vector displacement(0);
-
-
-               FEFaceValues<dim> fe_face_values_cell(fe, face_quadrature_formula,
-                                                                                                                                                                       update_values                   |
-                                                                                                                                                                       update_quadrature_points|
-                                                                                                                                                                       update_gradients                |
-                                                                                                                                                                       update_JxW_values               |
-                                                                                                                                                                       update_normal_vectors),
-                                                                                       fe_face_values_neighbor (fe, face_quadrature_formula,
-                                                                                                                                                                                        update_values     |
-                                                                                                                                                                                        update_gradients  |
-                                                                                                                                                                                        update_JxW_values |
-                                                                                                                                                                                        update_normal_vectors);
-               FESubfaceValues<dim> fe_subface_values_cell (fe, face_quadrature_formula,
-                                                                                                                                                                                                update_gradients);
-
-               const unsigned int n_face_q_points = face_quadrature_formula.size();
-               std::vector<Vector<double> > jump_residual (n_face_q_points, Vector<double>(dim));
-               std::vector<std::vector<Tensor<1,dim> > > cell_grads(n_face_q_points);
-               for (unsigned int i=0; i!=n_face_q_points; ++i)
-               {
-                       cell_grads[i].resize (dim);
-               }
-               std::vector<std::vector<Tensor<1,dim> > > neighbor_grads(n_face_q_points);
-               for (unsigned int i=0; i!=n_face_q_points; ++i)
-               {
-                       neighbor_grads[i].resize (dim);
-               }
-               SymmetricTensor<2, dim> q_cell_strain_tensor;
-               SymmetricTensor<2, dim> q_neighbor_strain_tensor;
-               SymmetricTensor<4, dim> cell_stress_strain_tensor;
-               SymmetricTensor<4, dim> neighbor_stress_strain_tensor;
-
-
-               typename std::map<typename DoFHandler<dim>::face_iterator, Vector<double> >
-                       face_integrals;
-               typename DoFHandler<dim>::active_cell_iterator
-                                       cell = dof_handler.begin_active(),
-                                       endc = dof_handler.end();
-               for (; cell!=endc; ++cell)
-                       if (cell->is_locally_owned())
-                       {
-                               for (unsigned int face_no=0;
-                                               face_no<GeometryInfo<dim>::faces_per_cell;
-                                               ++face_no)
-                               {
-                                       face_integrals[cell->face(face_no)].reinit (dim);
-                                       face_integrals[cell->face(face_no)] = -1e20;
-                               }
-                       }
-
-               std::vector<Vector<float> > error_indicators_vector;
-               error_indicators_vector.resize( triangulation.n_active_cells(),
-                                                                                                                                               Vector<float>(dim) );
-
-               // ----------------- estimate_some -------------------------
-               cell = dof_handler.begin_active();
-               unsigned int present_cell = 0;
-               for (; cell!=endc; ++cell, ++present_cell)
-                       if (cell->is_locally_owned())
-                       {
-                               // --------------- integrate_over_cell -------------------
-                               fe_values.reinit(cell);
-                                body_force.vector_value_list(fe_values.get_quadrature_points(),
-                                                                                                                                                       body_force_values);
-                               fe_values[displacement].get_function_symmetric_gradients(tmp_solution,
-                                                                                                                                                                                                                                                                strain_tensor);
-                               fe_values.get_function_hessians(tmp_solution, cell_hessians);
-
-                               for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
-                               {
-                                       constitutive_law.get_linearized_stress_strain_tensors(strain_tensor[q_point],
-                                                                                                                                                                                                                                                               stress_strain_tensor_linearized,
-                                                                                                                                                                                                                                                               stress_strain_tensor);
-                                       constitutive_law.get_grad_stress_strain_tensor(strain_tensor[q_point],
-                                                                                                                                                                                                                                cell_hessians[q_point],
-                                                                                                                                                                                                                                stress_strain_tensor_grad);
-
-                                       for (unsigned int i=0; i!=dim; ++i)
-                                       {
-                                               error_indicators_vector[present_cell](i) +=
-                                                               body_force_values[q_point](i)*fe_values.JxW(q_point);
-                                               for (unsigned int j=0; j!=dim; ++j)
-                                               {
-                                                       for (unsigned int k=0; k!=dim; ++k)
-                                                       {
-                                                               for (unsigned int l=0; l!=dim; ++l)
-                                                               {
-                                                                       error_indicators_vector[present_cell](i) +=
-                                                                                       (       stress_strain_tensor[i][j][k][l]*
-                                                                                               0.5*(cell_hessians[q_point][k][l][j]
-                                                                                                                +
-                                                                                                                cell_hessians[q_point][l][k][j])
-                                                                                               + stress_strain_tensor_grad[i][j][k][l][j] * strain_tensor[q_point][k][l]
-                                                                                       ) *
-                                                                                       fe_values.JxW(q_point);
-                                                               }
-                                                       }
-                                               }
-
-                                       }
-
-                               }
-                               // -------------------------------------------------------
-                               // compute face_integrals
-                               for (unsigned int face_no=0;
-                                               face_no<GeometryInfo<dim>::faces_per_cell;
-                                               ++face_no)
-                               {
-                                       if (cell->face(face_no)->at_boundary())
-                                       {
-                                               for (unsigned int id=0; id!=dim; ++id)
-                                               {
-                                                       face_integrals[cell->face(face_no)](id) = 0;
-                                               }
-                                               continue;
-                                       }
-
-                                       if ((cell->neighbor(face_no)->has_children() == false) &&
-                                                       (cell->neighbor(face_no)->level() == cell->level()) &&
-                                                       (cell->neighbor(face_no)->index() < cell->index()))
-                                               continue;
-
-                                       if (cell->at_boundary(face_no) == false)
-                                               if (cell->neighbor(face_no)->level() < cell->level())
-                                                       continue;
-
-
-                                       if (cell->face(face_no)->has_children() == false)
-                                       {
-                                               // ------------- integrate_over_regular_face -----------
-                                               fe_face_values_cell.reinit(cell, face_no);
-                                               fe_face_values_cell.get_function_grads (tmp_solution,
-                                                                                                                                                                                                               cell_grads);
-
-                                               Assert (cell->neighbor(face_no).state() == IteratorState::valid,
-                                                                               ExcInternalError());
-                                               const unsigned int
-                                               neighbor_neighbor = cell->neighbor_of_neighbor (face_no);
-                                               const typename DoFHandler<dim>::active_cell_iterator
-                                                                               neighbor = cell->neighbor(face_no);
-
-                                               fe_face_values_neighbor.reinit(neighbor, neighbor_neighbor);
-                                               fe_face_values_neighbor.get_function_grads (tmp_solution,
-                                                                                                                                                                                                                               neighbor_grads);
-
-                                               for (unsigned int q_point=0; q_point<n_face_q_points; ++q_point)
-                                               {
-                                                       q_cell_strain_tensor = 0.;
-                                                       q_neighbor_strain_tensor = 0.;
-                                                       for (unsigned int i=0; i!=dim; ++i)
-                                                       {
-                                                               for (unsigned int j=0; j!=dim; ++j)
-                                                               {
-                                                                       q_cell_strain_tensor[i][j] = 0.5*(cell_grads[q_point][i][j] +
-                                                                                                                                                                                                               cell_grads[q_point][j][i] );
-                                                                       q_neighbor_strain_tensor[i][j] = 0.5*(neighbor_grads[q_point][i][j] +
-                                                                                                                                                                                                                               neighbor_grads[q_point][j][i] );
-                                                               }
-                                                       }
-
-                                                       constitutive_law.get_stress_strain_tensor (q_cell_strain_tensor,
-                                                                                                                                                                                                                                cell_stress_strain_tensor);
-                                                       constitutive_law.get_stress_strain_tensor (q_neighbor_strain_tensor,
-                                                                                                                                                                                                                                neighbor_stress_strain_tensor);
-
-                                                       jump_residual[q_point] = 0.;
-                                                       for (unsigned int i=0; i!=dim; ++i)
-                                                       {
-                                                               for (unsigned int j=0; j!=dim; ++j)
-                                                               {
-                                                                       for (unsigned int k=0; k!=dim; ++k)
-                                                                       {
-                                                                               for (unsigned int l=0; l!=dim; ++l)
-                                                                               {
-                                                                                       jump_residual[q_point](i) += (cell_stress_strain_tensor[i][j][k][l]*
-                                                                                                                                                                                                               q_cell_strain_tensor[k][l]
-                                                                                                                                                                                                               -
-                                                                                                                                                                                                               neighbor_stress_strain_tensor[i][j][k][l]*
-                                                                                                                                                                                                               q_neighbor_strain_tensor[k][l] )*
-                                                                                                                                                                                                        fe_face_values_cell.normal_vector(q_point)[j];
-                                                                               }
-                                                                       }
-                                                               }
-                                                       }
-
-                                               }
-
-                                               Vector<double> face_integral_vector(dim);
-                                               face_integral_vector = 0;
-                                               for (unsigned int q_point=0; q_point<n_face_q_points; ++q_point)
-                                               {
-                                                       for (unsigned int i=0; i!=dim; ++i)
-                                                       {
-                                                               face_integral_vector(i) += jump_residual[q_point](i) *
-                                                                               fe_face_values_cell.JxW(q_point);
-                                                       }
-                                               }
-
-                                               Assert (face_integrals.find (cell->face(face_no)) != face_integrals.end(),
-                                                                               ExcInternalError());
-
-                                               for (unsigned int i=0; i!=dim; ++i)
-                                               {
-                                                       Assert (face_integrals[cell->face(face_no)](i) == -1e20,
-                                                                                       ExcInternalError());
-                                                       face_integrals[cell->face(face_no)](i) = face_integral_vector(i);
-
-                                               }
-
-                                               // -----------------------------------------------------
-                                       }else
-                                       {
-                                               // ------------- integrate_over_irregular_face ---------
-                                               const typename DoFHandler<dim>::face_iterator
-                                               face = cell->face(face_no);
-                                               const typename DoFHandler<dim>::cell_iterator
-                                               neighbor = cell->neighbor(face_no);
-                                               Assert (neighbor.state() == IteratorState::valid,
-                                                                               ExcInternalError());
-                                               Assert (neighbor->has_children(),
-                                                                               ExcInternalError());
-
-                                               const unsigned int
-                                               neighbor_neighbor = cell->neighbor_of_neighbor (face_no);
-
-                                               for (unsigned int subface_no=0;
-                                                                subface_no<face->n_children(); ++subface_no)
-                                               {
-                                                       const typename DoFHandler<dim>::active_cell_iterator
-                                                       neighbor_child = cell->neighbor_child_on_subface (face_no, subface_no);
-                                                       Assert (neighbor_child->face(neighbor_neighbor) ==
-                                                                                       cell->face(face_no)->child(subface_no),
-                                                                                       ExcInternalError());
-
-                                                       fe_subface_values_cell.reinit (cell, face_no, subface_no);
-                                                       fe_subface_values_cell.get_function_grads (tmp_solution,
-                                                                                                                                                                                                                                cell_grads);
-                                                       fe_face_values_neighbor.reinit (neighbor_child,
-                                                                                                                                                                                       neighbor_neighbor);
-                                                       fe_face_values_neighbor.get_function_grads (tmp_solution,
-                                                                                                                                                                                                                                       neighbor_grads);
-
-                                                       for (unsigned int q_point=0; q_point<n_face_q_points; ++q_point)
-                                                       {
-                                                               q_cell_strain_tensor = 0.;
-                                                               q_neighbor_strain_tensor = 0.;
-                                                               for (unsigned int i=0; i!=dim; ++i)
-                                                               {
-                                                                       for (unsigned int j=0; j!=dim; ++j)
-                                                                       {
-                                                                               q_cell_strain_tensor[i][j] = 0.5*(cell_grads[q_point][i][j] +
-                                                                                                                                                                                                                       cell_grads[q_point][j][i] );
-                                                                               q_neighbor_strain_tensor[i][j] = 0.5*(neighbor_grads[q_point][i][j] +
-                                                                                                                                                                                                                                       neighbor_grads[q_point][j][i] );
-                                                                       }
-                                                               }
-
-                                                               constitutive_law.get_stress_strain_tensor (q_cell_strain_tensor,
-                                                                                                                                                                                                                                        cell_stress_strain_tensor);
-                                                               constitutive_law.get_stress_strain_tensor (q_neighbor_strain_tensor,
-                                                                                                                                                                                                                                        neighbor_stress_strain_tensor);
-
-                                                               jump_residual[q_point] = 0.;
-                                                               for (unsigned int i=0; i!=dim; ++i)
-                                                               {
-                                                                       for (unsigned int j=0; j!=dim; ++j)
-                                                                       {
-                                                                               for (unsigned int k=0; k!=dim; ++k)
-                                                                               {
-                                                                                       for (unsigned int l=0; l!=dim; ++l)
-                                                                                       {
-                                                                                               jump_residual[q_point](i) += (-cell_stress_strain_tensor[i][j][k][l]*
-                                                                                                                                                                                                                       q_cell_strain_tensor[k][l]
-                                                                                                                                                                                                                       +
-                                                                                                                                                                                                                       neighbor_stress_strain_tensor[i][j][k][l]*
-                                                                                                                                                                                                                       q_neighbor_strain_tensor[k][l] )*
-                                                                                                                                                                                                                fe_face_values_neighbor.normal_vector(q_point)[j];
-                                                                                       }
-                                                                               }
-                                                                       }
-                                                               }
-
-                                                       }
-
-                                                       Vector<double> face_integral_vector(dim);
-                                                       face_integral_vector = 0;
-                                                       for (unsigned int q_point=0; q_point<n_face_q_points; ++q_point)
-                                                       {
-                                                               for (unsigned int i=0; i!=dim; ++i)
-                                                               {
-                                                                       face_integral_vector(i) += jump_residual[q_point](i) *
-                                                                                                                                                                                fe_face_values_neighbor.JxW(q_point);
-                                                               }
-                                                       }
-
-                                                       for (unsigned int i=0; i!=dim; ++i)
-                                                       {
-                                                               face_integrals[neighbor_child->face(neighbor_neighbor)](i) = face_integral_vector(i);
-                                                       }
-
-                                               }
-
-                                               Vector<double> sum (dim);
-                                               sum = 0;
-                                               for (unsigned int subface_no=0;
-                                                               subface_no<face->n_children(); ++subface_no)
-                                               {
-                                                       Assert (face_integrals.find(face->child(subface_no)) !=
-                                                                                       face_integrals.end(),
-                                                                                       ExcInternalError());
-                                                       for (unsigned int i=0; i!=dim; ++i)
-                                                       {
-                                                               Assert (face_integrals[face->child(subface_no)](i) != -1e20,
-                                                                                               ExcInternalError());
-                                                               sum(i) += face_integrals[face->child(subface_no)](i);
-                                                       }
-                                               }
-                                               for (unsigned int i=0; i!=dim; ++i)
-                                               {
-                                                       face_integrals[face](i) = sum(i);
-                                               }
-
-
-                                               // -----------------------------------------------------
-                                       }
-
-
-                               }
-                       }
-               // ----------------------------------------------------------
-
-               present_cell=0;
-               cell = dof_handler.begin_active();
-               for (; cell!=endc; ++cell, ++present_cell)
-                       if (cell->is_locally_owned())
-                       {
-                               for (unsigned int face_no=0; face_no<GeometryInfo<dim>::faces_per_cell;
-                                               ++face_no)
-                               {
-                                       Assert(face_integrals.find(cell->face(face_no)) !=
-                                                                face_integrals.end(),
-                                                                ExcInternalError());
-
-                                       for (unsigned int id=0; id!=dim; ++id)
-                                       {
-                                               error_indicators_vector[present_cell](id)
-                                                                                                                                       -= 0.5*face_integrals[cell->face(face_no)](id);
-                                       }
-
-                               }
-
-                               estimated_error_per_cell(present_cell) = error_indicators_vector[present_cell].l2_norm();
-
-                       }
+    FEValues<dim> fe_values(fe, quadrature_formula,
+                            update_values    |
+                            update_gradients |
+                            update_hessians  |
+                            update_quadrature_points |
+                            update_JxW_values);
+
+    const unsigned int n_q_points      = quadrature_formula.size();
+    std::vector<SymmetricTensor<2, dim> > strain_tensor(n_q_points);
+    SymmetricTensor<4, dim> stress_strain_tensor_linearized;
+    SymmetricTensor<4, dim> stress_strain_tensor;
+    Tensor<5, dim>          stress_strain_tensor_grad;
+    std::vector<std::vector<Tensor<2,dim> > > cell_hessians (n_q_points);
+    for (unsigned int i=0; i!=n_q_points; ++i)
+      {
+        cell_hessians[i].resize (dim);
+      }
+    const EquationData::BodyForce<dim> body_force;
+
+    std::vector<Vector<double> > body_force_values (n_q_points, Vector<double>(dim));
+    const FEValuesExtractors::Vector displacement(0);
+
+
+    FEFaceValues<dim> fe_face_values_cell(fe, face_quadrature_formula,
+                                          update_values           |
+                                          update_quadrature_points|
+                                          update_gradients        |
+                                          update_JxW_values       |
+                                          update_normal_vectors),
+                                          fe_face_values_neighbor (fe, face_quadrature_formula,
+                                              update_values     |
+                                              update_gradients  |
+                                              update_JxW_values |
+                                              update_normal_vectors);
+    FESubfaceValues<dim> fe_subface_values_cell (fe, face_quadrature_formula,
+                                                 update_gradients);
+
+    const unsigned int n_face_q_points = face_quadrature_formula.size();
+    std::vector<Vector<double> > jump_residual (n_face_q_points, Vector<double>(dim));
+    std::vector<std::vector<Tensor<1,dim> > > cell_grads(n_face_q_points);
+    for (unsigned int i=0; i!=n_face_q_points; ++i)
+      {
+        cell_grads[i].resize (dim);
+      }
+    std::vector<std::vector<Tensor<1,dim> > > neighbor_grads(n_face_q_points);
+    for (unsigned int i=0; i!=n_face_q_points; ++i)
+      {
+        neighbor_grads[i].resize (dim);
+      }
+    SymmetricTensor<2, dim> q_cell_strain_tensor;
+    SymmetricTensor<2, dim> q_neighbor_strain_tensor;
+    SymmetricTensor<4, dim> cell_stress_strain_tensor;
+    SymmetricTensor<4, dim> neighbor_stress_strain_tensor;
+
+
+    typename std::map<typename DoFHandler<dim>::face_iterator, Vector<double> >
+    face_integrals;
+    typename DoFHandler<dim>::active_cell_iterator
+    cell = dof_handler.begin_active(),
+    endc = dof_handler.end();
+    for (; cell!=endc; ++cell)
+      if (cell->is_locally_owned())
+        {
+          for (unsigned int face_no=0;
+               face_no<GeometryInfo<dim>::faces_per_cell;
+               ++face_no)
+            {
+              face_integrals[cell->face(face_no)].reinit (dim);
+              face_integrals[cell->face(face_no)] = -1e20;
+            }
+        }
+
+    std::vector<Vector<float> > error_indicators_vector;
+    error_indicators_vector.resize( triangulation.n_active_cells(),
+                                    Vector<float>(dim) );
+
+    // ----------------- estimate_some -------------------------
+    cell = dof_handler.begin_active();
+    unsigned int present_cell = 0;
+    for (; cell!=endc; ++cell, ++present_cell)
+      if (cell->is_locally_owned())
+        {
+          // --------------- integrate_over_cell -------------------
+          fe_values.reinit(cell);
+          body_force.vector_value_list(fe_values.get_quadrature_points(),
+                                       body_force_values);
+          fe_values[displacement].get_function_symmetric_gradients(tmp_solution,
+                                                                   strain_tensor);
+          fe_values.get_function_hessians(tmp_solution, cell_hessians);
+
+          for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
+            {
+              constitutive_law.get_linearized_stress_strain_tensors(strain_tensor[q_point],
+                                                                    stress_strain_tensor_linearized,
+                                                                    stress_strain_tensor);
+              constitutive_law.get_grad_stress_strain_tensor(strain_tensor[q_point],
+                                                             cell_hessians[q_point],
+                                                             stress_strain_tensor_grad);
+
+              for (unsigned int i=0; i!=dim; ++i)
+                {
+                  error_indicators_vector[present_cell](i) +=
+                    body_force_values[q_point](i)*fe_values.JxW(q_point);
+                  for (unsigned int j=0; j!=dim; ++j)
+                    {
+                      for (unsigned int k=0; k!=dim; ++k)
+                        {
+                          for (unsigned int l=0; l!=dim; ++l)
+                            {
+                              error_indicators_vector[present_cell](i) +=
+                                ( stress_strain_tensor[i][j][k][l]*
+                                  0.5*(cell_hessians[q_point][k][l][j]
+                                       +
+                                       cell_hessians[q_point][l][k][j])
+                                  + stress_strain_tensor_grad[i][j][k][l][j] * strain_tensor[q_point][k][l]
+                                ) *
+                                fe_values.JxW(q_point);
+                            }
+                        }
+                    }
+
+                }
+
+            }
+          // -------------------------------------------------------
+          // compute face_integrals
+          for (unsigned int face_no=0;
+               face_no<GeometryInfo<dim>::faces_per_cell;
+               ++face_no)
+            {
+              if (cell->face(face_no)->at_boundary())
+                {
+                  for (unsigned int id=0; id!=dim; ++id)
+                    {
+                      face_integrals[cell->face(face_no)](id) = 0;
+                    }
+                  continue;
+                }
+
+              if ((cell->neighbor(face_no)->has_children() == false) &&
+                  (cell->neighbor(face_no)->level() == cell->level()) &&
+                  (cell->neighbor(face_no)->index() < cell->index()))
+                continue;
+
+              if (cell->at_boundary(face_no) == false)
+                if (cell->neighbor(face_no)->level() < cell->level())
+                  continue;
+
+
+              if (cell->face(face_no)->has_children() == false)
+                {
+                  // ------------- integrate_over_regular_face -----------
+                  fe_face_values_cell.reinit(cell, face_no);
+                  fe_face_values_cell.get_function_grads (tmp_solution,
+                                                          cell_grads);
+
+                  Assert (cell->neighbor(face_no).state() == IteratorState::valid,
+                          ExcInternalError());
+                  const unsigned int
+                  neighbor_neighbor = cell->neighbor_of_neighbor (face_no);
+                  const typename DoFHandler<dim>::active_cell_iterator
+                  neighbor = cell->neighbor(face_no);
+
+                  fe_face_values_neighbor.reinit(neighbor, neighbor_neighbor);
+                  fe_face_values_neighbor.get_function_grads (tmp_solution,
+                                                              neighbor_grads);
+
+                  for (unsigned int q_point=0; q_point<n_face_q_points; ++q_point)
+                    {
+                      q_cell_strain_tensor = 0.;
+                      q_neighbor_strain_tensor = 0.;
+                      for (unsigned int i=0; i!=dim; ++i)
+                        {
+                          for (unsigned int j=0; j!=dim; ++j)
+                            {
+                              q_cell_strain_tensor[i][j] = 0.5*(cell_grads[q_point][i][j] +
+                                                                cell_grads[q_point][j][i] );
+                              q_neighbor_strain_tensor[i][j] = 0.5*(neighbor_grads[q_point][i][j] +
+                                                                    neighbor_grads[q_point][j][i] );
+                            }
+                        }
+
+                      constitutive_law.get_stress_strain_tensor (q_cell_strain_tensor,
+                                                                 cell_stress_strain_tensor);
+                      constitutive_law.get_stress_strain_tensor (q_neighbor_strain_tensor,
+                                                                 neighbor_stress_strain_tensor);
+
+                      jump_residual[q_point] = 0.;
+                      for (unsigned int i=0; i!=dim; ++i)
+                        {
+                          for (unsigned int j=0; j!=dim; ++j)
+                            {
+                              for (unsigned int k=0; k!=dim; ++k)
+                                {
+                                  for (unsigned int l=0; l!=dim; ++l)
+                                    {
+                                      jump_residual[q_point](i) += (cell_stress_strain_tensor[i][j][k][l]*
+                                                                    q_cell_strain_tensor[k][l]
+                                                                    -
+                                                                    neighbor_stress_strain_tensor[i][j][k][l]*
+                                                                    q_neighbor_strain_tensor[k][l] )*
+                                                                   fe_face_values_cell.normal_vector(q_point)[j];
+                                    }
+                                }
+                            }
+                        }
+
+                    }
+
+                  Vector<double> face_integral_vector(dim);
+                  face_integral_vector = 0;
+                  for (unsigned int q_point=0; q_point<n_face_q_points; ++q_point)
+                    {
+                      for (unsigned int i=0; i!=dim; ++i)
+                        {
+                          face_integral_vector(i) += jump_residual[q_point](i) *
+                                                     fe_face_values_cell.JxW(q_point);
+                        }
+                    }
+
+                  Assert (face_integrals.find (cell->face(face_no)) != face_integrals.end(),
+                          ExcInternalError());
+
+                  for (unsigned int i=0; i!=dim; ++i)
+                    {
+                      Assert (face_integrals[cell->face(face_no)](i) == -1e20,
+                              ExcInternalError());
+                      face_integrals[cell->face(face_no)](i) = face_integral_vector(i);
+
+                    }
+
+                  // -----------------------------------------------------
+                }
+              else
+                {
+                  // ------------- integrate_over_irregular_face ---------
+                  const typename DoFHandler<dim>::face_iterator
+                  face = cell->face(face_no);
+                  const typename DoFHandler<dim>::cell_iterator
+                  neighbor = cell->neighbor(face_no);
+                  Assert (neighbor.state() == IteratorState::valid,
+                          ExcInternalError());
+                  Assert (neighbor->has_children(),
+                          ExcInternalError());
+
+                  const unsigned int
+                  neighbor_neighbor = cell->neighbor_of_neighbor (face_no);
+
+                  for (unsigned int subface_no=0;
+                       subface_no<face->n_children(); ++subface_no)
+                    {
+                      const typename DoFHandler<dim>::active_cell_iterator
+                      neighbor_child = cell->neighbor_child_on_subface (face_no, subface_no);
+                      Assert (neighbor_child->face(neighbor_neighbor) ==
+                              cell->face(face_no)->child(subface_no),
+                              ExcInternalError());
+
+                      fe_subface_values_cell.reinit (cell, face_no, subface_no);
+                      fe_subface_values_cell.get_function_grads (tmp_solution,
+                                                                 cell_grads);
+                      fe_face_values_neighbor.reinit (neighbor_child,
+                                                      neighbor_neighbor);
+                      fe_face_values_neighbor.get_function_grads (tmp_solution,
+                                                                  neighbor_grads);
+
+                      for (unsigned int q_point=0; q_point<n_face_q_points; ++q_point)
+                        {
+                          q_cell_strain_tensor = 0.;
+                          q_neighbor_strain_tensor = 0.;
+                          for (unsigned int i=0; i!=dim; ++i)
+                            {
+                              for (unsigned int j=0; j!=dim; ++j)
+                                {
+                                  q_cell_strain_tensor[i][j] = 0.5*(cell_grads[q_point][i][j] +
+                                                                    cell_grads[q_point][j][i] );
+                                  q_neighbor_strain_tensor[i][j] = 0.5*(neighbor_grads[q_point][i][j] +
+                                                                        neighbor_grads[q_point][j][i] );
+                                }
+                            }
+
+                          constitutive_law.get_stress_strain_tensor (q_cell_strain_tensor,
+                                                                     cell_stress_strain_tensor);
+                          constitutive_law.get_stress_strain_tensor (q_neighbor_strain_tensor,
+                                                                     neighbor_stress_strain_tensor);
+
+                          jump_residual[q_point] = 0.;
+                          for (unsigned int i=0; i!=dim; ++i)
+                            {
+                              for (unsigned int j=0; j!=dim; ++j)
+                                {
+                                  for (unsigned int k=0; k!=dim; ++k)
+                                    {
+                                      for (unsigned int l=0; l!=dim; ++l)
+                                        {
+                                          jump_residual[q_point](i) += (-cell_stress_strain_tensor[i][j][k][l]*
+                                                                        q_cell_strain_tensor[k][l]
+                                                                        +
+                                                                        neighbor_stress_strain_tensor[i][j][k][l]*
+                                                                        q_neighbor_strain_tensor[k][l] )*
+                                                                       fe_face_values_neighbor.normal_vector(q_point)[j];
+                                        }
+                                    }
+                                }
+                            }
+
+                        }
+
+                      Vector<double> face_integral_vector(dim);
+                      face_integral_vector = 0;
+                      for (unsigned int q_point=0; q_point<n_face_q_points; ++q_point)
+                        {
+                          for (unsigned int i=0; i!=dim; ++i)
+                            {
+                              face_integral_vector(i) += jump_residual[q_point](i) *
+                                                         fe_face_values_neighbor.JxW(q_point);
+                            }
+                        }
+
+                      for (unsigned int i=0; i!=dim; ++i)
+                        {
+                          face_integrals[neighbor_child->face(neighbor_neighbor)](i) = face_integral_vector(i);
+                        }
+
+                    }
+
+                  Vector<double> sum (dim);
+                  sum = 0;
+                  for (unsigned int subface_no=0;
+                       subface_no<face->n_children(); ++subface_no)
+                    {
+                      Assert (face_integrals.find(face->child(subface_no)) !=
+                              face_integrals.end(),
+                              ExcInternalError());
+                      for (unsigned int i=0; i!=dim; ++i)
+                        {
+                          Assert (face_integrals[face->child(subface_no)](i) != -1e20,
+                                  ExcInternalError());
+                          sum(i) += face_integrals[face->child(subface_no)](i);
+                        }
+                    }
+                  for (unsigned int i=0; i!=dim; ++i)
+                    {
+                      face_integrals[face](i) = sum(i);
+                    }
+
+
+                  // -----------------------------------------------------
+                }
+
+
+            }
+        }
+    // ----------------------------------------------------------
+
+    present_cell=0;
+    cell = dof_handler.begin_active();
+    for (; cell!=endc; ++cell, ++present_cell)
+      if (cell->is_locally_owned())
+        {
+          for (unsigned int face_no=0; face_no<GeometryInfo<dim>::faces_per_cell;
+               ++face_no)
+            {
+              Assert(face_integrals.find(cell->face(face_no)) !=
+                     face_integrals.end(),
+                     ExcInternalError());
+
+              for (unsigned int id=0; id!=dim; ++id)
+                {
+                  error_indicators_vector[present_cell](id)
+                  -= 0.5*face_integrals[cell->face(face_no)](id);
+                }
+
+            }
+
+          estimated_error_per_cell(present_cell) = error_indicators_vector[present_cell].l2_norm();
+
+        }
 
   }
 
@@ -5390,81 +5449,81 @@ namespace ElastoPlastic
   void
   ElastoPlasticProblem<dim>::refine_grid ()
   {
-       // ---------------------------------------------------------------
-       // Make a field variable for history varibales to be able to
-       // transfer the data to the quadrature points of the new mesh
-       FE_DGQ<dim> history_fe (1);
-       DoFHandler<dim> history_dof_handler (triangulation);
-       history_dof_handler.distribute_dofs (history_fe);
-       std::vector< std::vector< Vector<double> > >
-                                       history_stress_field (dim, std::vector< Vector<double> >(dim)),
-                                       local_history_stress_values_at_qpoints (dim, std::vector< Vector<double> >(dim)),
-                                       local_history_stress_fe_values (dim, std::vector< Vector<double> >(dim));
-
-
-       std::vector< std::vector< Vector<double> > >
-                                       history_strain_field (dim, std::vector< Vector<double> >(dim)),
-                                       local_history_strain_values_at_qpoints (dim, std::vector< Vector<double> >(dim)),
-                                       local_history_strain_fe_values (dim, std::vector< Vector<double> >(dim));
-
-       for (unsigned int i=0; i<dim; i++)
-               for (unsigned int j=0; j<dim; j++)
-               {
-                       history_stress_field[i][j].reinit(history_dof_handler.n_dofs());
-                       local_history_stress_values_at_qpoints[i][j].reinit(quadrature_formula.size());
-                       local_history_stress_fe_values[i][j].reinit(history_fe.dofs_per_cell);
-
-                       history_strain_field[i][j].reinit(history_dof_handler.n_dofs());
-                       local_history_strain_values_at_qpoints[i][j].reinit(quadrature_formula.size());
-                       local_history_strain_fe_values[i][j].reinit(history_fe.dofs_per_cell);
-               }
-       FullMatrix<double> qpoint_to_dof_matrix (history_fe.dofs_per_cell,
-                                                                                                                                                                        quadrature_formula.size());
-       FETools::compute_projection_from_quadrature_points_matrix
-                                               (history_fe,
-                                                quadrature_formula, quadrature_formula,
-                                                qpoint_to_dof_matrix);
-       typename DoFHandler<dim>::active_cell_iterator
-                       cell = dof_handler.begin_active(),
-                       endc = dof_handler.end(),
-                       dg_cell = history_dof_handler.begin_active();
-       for (; cell!=endc; ++cell, ++dg_cell)
-               if (cell->is_locally_owned())
-                       {
-                               PointHistory<dim> *local_quadrature_points_history
-                                               = reinterpret_cast<PointHistory<dim> *>(cell->user_pointer());
-                               Assert (local_quadrature_points_history >=
-                                                               &quadrature_point_history.front(),
-                                                               ExcInternalError());
-                               Assert (local_quadrature_points_history <
-                                                               &quadrature_point_history.back(),
-                                                               ExcInternalError());
-                               for (unsigned int i=0; i<dim; i++)
-                                       for (unsigned int j=0; j<dim; j++)
-                                       {
-                                               for (unsigned int q=0; q<quadrature_formula.size(); ++q)
-                                               {
-                                                       local_history_stress_values_at_qpoints[i][j](q)
-                                                               = local_quadrature_points_history[q].old_stress[i][j];
-
-                                                       local_history_strain_values_at_qpoints[i][j](q)
-                                                               = local_quadrature_points_history[q].old_strain[i][j];
-                                               }
-                                               qpoint_to_dof_matrix.vmult (local_history_stress_fe_values[i][j],
-                                                                                                                                                               local_history_stress_values_at_qpoints[i][j]);
-                                               dg_cell->set_dof_values (local_history_stress_fe_values[i][j],
-                                                                                                                                                history_stress_field[i][j]);
-
-                                               qpoint_to_dof_matrix.vmult (local_history_strain_fe_values[i][j],
-                                                                                                                                                               local_history_strain_values_at_qpoints[i][j]);
-                                               dg_cell->set_dof_values (local_history_strain_fe_values[i][j],
-                                                                                                                                                history_strain_field[i][j]);
-                                       }
-                       }
-
-
-       // ---------------------------------------------------------------
-       // Refine the mesh
+    // ---------------------------------------------------------------
+    // Make a field variable for history varibales to be able to
+    // transfer the data to the quadrature points of the new mesh
+    FE_DGQ<dim> history_fe (1);
+    DoFHandler<dim> history_dof_handler (triangulation);
+    history_dof_handler.distribute_dofs (history_fe);
+    std::vector< std::vector< Vector<double> > >
+    history_stress_field (dim, std::vector< Vector<double> >(dim)),
+                         local_history_stress_values_at_qpoints (dim, std::vector< Vector<double> >(dim)),
+                         local_history_stress_fe_values (dim, std::vector< Vector<double> >(dim));
+
+
+    std::vector< std::vector< Vector<double> > >
+    history_strain_field (dim, std::vector< Vector<double> >(dim)),
+                         local_history_strain_values_at_qpoints (dim, std::vector< Vector<double> >(dim)),
+                         local_history_strain_fe_values (dim, std::vector< Vector<double> >(dim));
+
+    for (unsigned int i=0; i<dim; i++)
+      for (unsigned int j=0; j<dim; j++)
+        {
+          history_stress_field[i][j].reinit(history_dof_handler.n_dofs());
+          local_history_stress_values_at_qpoints[i][j].reinit(quadrature_formula.size());
+          local_history_stress_fe_values[i][j].reinit(history_fe.dofs_per_cell);
+
+          history_strain_field[i][j].reinit(history_dof_handler.n_dofs());
+          local_history_strain_values_at_qpoints[i][j].reinit(quadrature_formula.size());
+          local_history_strain_fe_values[i][j].reinit(history_fe.dofs_per_cell);
+        }
+    FullMatrix<double> qpoint_to_dof_matrix (history_fe.dofs_per_cell,
+                                             quadrature_formula.size());
+    FETools::compute_projection_from_quadrature_points_matrix
+    (history_fe,
+     quadrature_formula, quadrature_formula,
+     qpoint_to_dof_matrix);
+    typename DoFHandler<dim>::active_cell_iterator
+    cell = dof_handler.begin_active(),
+    endc = dof_handler.end(),
+    dg_cell = history_dof_handler.begin_active();
+    for (; cell!=endc; ++cell, ++dg_cell)
+      if (cell->is_locally_owned())
+        {
+          PointHistory<dim> *local_quadrature_points_history
+            = reinterpret_cast<PointHistory<dim> *>(cell->user_pointer());
+          Assert (local_quadrature_points_history >=
+                  &quadrature_point_history.front(),
+                  ExcInternalError());
+          Assert (local_quadrature_points_history <
+                  &quadrature_point_history.back(),
+                  ExcInternalError());
+          for (unsigned int i=0; i<dim; i++)
+            for (unsigned int j=0; j<dim; j++)
+              {
+                for (unsigned int q=0; q<quadrature_formula.size(); ++q)
+                  {
+                    local_history_stress_values_at_qpoints[i][j](q)
+                      = local_quadrature_points_history[q].old_stress[i][j];
+
+                    local_history_strain_values_at_qpoints[i][j](q)
+                      = local_quadrature_points_history[q].old_strain[i][j];
+                  }
+                qpoint_to_dof_matrix.vmult (local_history_stress_fe_values[i][j],
+                                            local_history_stress_values_at_qpoints[i][j]);
+                dg_cell->set_dof_values (local_history_stress_fe_values[i][j],
+                                         history_stress_field[i][j]);
+
+                qpoint_to_dof_matrix.vmult (local_history_strain_fe_values[i][j],
+                                            local_history_strain_values_at_qpoints[i][j]);
+                dg_cell->set_dof_values (local_history_strain_fe_values[i][j],
+                                         history_strain_field[i][j]);
+              }
+        }
+
+
+    // ---------------------------------------------------------------
+    // Refine the mesh
     if (refinement_strategy == RefinementStrategy::refine_global)
       {
         for (typename Triangulation<dim>::active_cell_iterator
@@ -5475,10 +5534,10 @@ namespace ElastoPlastic
       }
     else
       {
-                               const double refine_fraction_cells = .3,
-                                                                                coarsen_fraction_cells = .03;
-//                             const double refine_fraction_cells = .1,
-//                                                                              coarsen_fraction_cells = .3;
+        const double refine_fraction_cells = .3,
+                     coarsen_fraction_cells = .03;
+//        const double refine_fraction_cells = .1,
+//                     coarsen_fraction_cells = .3;
 
         parallel::distributed::GridRefinement
         ::refine_and_coarsen_fixed_number(triangulation,
@@ -5489,40 +5548,40 @@ namespace ElastoPlastic
     triangulation.prepare_coarsening_and_refinement();
 
     parallel::distributed::SolutionTransfer<dim,
-                                       TrilinosWrappers::MPI::Vector> solution_transfer(dof_handler);
+             TrilinosWrappers::MPI::Vector> solution_transfer(dof_handler);
     solution_transfer.prepare_for_coarsening_and_refinement(solution);
 
 
     parallel::distributed::SolutionTransfer<dim,
-               TrilinosWrappers::MPI::Vector> incremental_displacement_transfer(dof_handler);
+             TrilinosWrappers::MPI::Vector> incremental_displacement_transfer(dof_handler);
     if (transfer_solution)
-       incremental_displacement_transfer.prepare_for_coarsening_and_refinement(incremental_displacement);
+      incremental_displacement_transfer.prepare_for_coarsening_and_refinement(incremental_displacement);
 
     SolutionTransfer<dim, Vector<double> > history_stress_field_transfer0(history_dof_handler),
-                                           history_stress_field_transfer1(history_dof_handler),
-                                           history_stress_field_transfer2(history_dof_handler);
+                     history_stress_field_transfer1(history_dof_handler),
+                     history_stress_field_transfer2(history_dof_handler);
     history_stress_field_transfer0.prepare_for_coarsening_and_refinement(history_stress_field[0]);
     if ( dim > 1)
-    {
-       history_stress_field_transfer1.prepare_for_coarsening_and_refinement(history_stress_field[1]);
-    }
+      {
+        history_stress_field_transfer1.prepare_for_coarsening_and_refinement(history_stress_field[1]);
+      }
     if ( dim == 3)
-    {
-       history_stress_field_transfer2.prepare_for_coarsening_and_refinement(history_stress_field[2]);
-    }
+      {
+        history_stress_field_transfer2.prepare_for_coarsening_and_refinement(history_stress_field[2]);
+      }
 
     SolutionTransfer<dim, Vector<double> > history_strain_field_transfer0(history_dof_handler),
-                                           history_strain_field_transfer1(history_dof_handler),
-                                           history_strain_field_transfer2(history_dof_handler);
+                     history_strain_field_transfer1(history_dof_handler),
+                     history_strain_field_transfer2(history_dof_handler);
     history_strain_field_transfer0.prepare_for_coarsening_and_refinement(history_strain_field[0]);
     if ( dim > 1)
-    {
-       history_strain_field_transfer1.prepare_for_coarsening_and_refinement(history_strain_field[1]);
-    }
+      {
+        history_strain_field_transfer1.prepare_for_coarsening_and_refinement(history_strain_field[1]);
+      }
     if ( dim == 3)
-    {
-       history_strain_field_transfer2.prepare_for_coarsening_and_refinement(history_strain_field[2]);
-    }
+      {
+        history_strain_field_transfer2.prepare_for_coarsening_and_refinement(history_strain_field[2]);
+      }
 
     triangulation.execute_coarsening_and_refinement();
     pcout << "    Number of active cells:       "
@@ -5553,20 +5612,20 @@ namespace ElastoPlastic
     std::vector< std::vector< Vector<double> > >
     distributed_history_stress_field (dim, std::vector< Vector<double> >(dim));
     for (unsigned int i=0; i<dim; i++)
-       for (unsigned int j=0; j<dim; j++)
-       {
-               distributed_history_stress_field[i][j].reinit(history_dof_handler.n_dofs());
-       }
+      for (unsigned int j=0; j<dim; j++)
+        {
+          distributed_history_stress_field[i][j].reinit(history_dof_handler.n_dofs());
+        }
 
     history_stress_field_transfer0.interpolate(history_stress_field[0], distributed_history_stress_field[0]);
-    if ( dim > 1)
-    {
-       history_stress_field_transfer1.interpolate(history_stress_field[1], distributed_history_stress_field[1]);
-    }
+    if ( dim > 1)
+      {
+        history_stress_field_transfer1.interpolate(history_stress_field[1], distributed_history_stress_field[1]);
+      }
     if ( dim == 3)
-    {
-       history_stress_field_transfer2.interpolate(history_stress_field[2], distributed_history_stress_field[2]);
-    }
+      {
+        history_stress_field_transfer2.interpolate(history_stress_field[2], distributed_history_stress_field[2]);
+      }
 
     history_stress_field = distributed_history_stress_field;
 
@@ -5574,20 +5633,20 @@ namespace ElastoPlastic
     std::vector< std::vector< Vector<double> > >
     distributed_history_strain_field (dim, std::vector< Vector<double> >(dim));
     for (unsigned int i=0; i<dim; i++)
-       for (unsigned int j=0; j<dim; j++)
-       {
-               distributed_history_strain_field[i][j].reinit(history_dof_handler.n_dofs());
-       }
+      for (unsigned int j=0; j<dim; j++)
+        {
+          distributed_history_strain_field[i][j].reinit(history_dof_handler.n_dofs());
+        }
 
     history_strain_field_transfer0.interpolate(history_strain_field[0], distributed_history_strain_field[0]);
     if ( dim > 1)
-    {
-       history_strain_field_transfer1.interpolate(history_strain_field[1], distributed_history_strain_field[1]);
-    }
+      {
+        history_strain_field_transfer1.interpolate(history_strain_field[1], distributed_history_strain_field[1]);
+      }
     if ( dim == 3)
-    {
-       history_strain_field_transfer2.interpolate(history_strain_field[2], distributed_history_strain_field[2]);
-    }
+      {
+        history_strain_field_transfer2.interpolate(history_strain_field[2], distributed_history_strain_field[2]);
+      }
 
     history_strain_field = distributed_history_strain_field;
 
@@ -5598,49 +5657,49 @@ namespace ElastoPlastic
     // new mesh. The following code will do that:
 
     FullMatrix<double> dof_to_qpoint_matrix (quadrature_formula.size(),
-                                                                                                                                                                history_fe.dofs_per_cell);
+                                             history_fe.dofs_per_cell);
     FETools::compute_interpolation_to_quadrature_points_matrix
-                                                       (history_fe,
-                                                       quadrature_formula,
-                                                       dof_to_qpoint_matrix);
+    (history_fe,
+     quadrature_formula,
+     dof_to_qpoint_matrix);
     cell = dof_handler.begin_active();
     endc = dof_handler.end();
     dg_cell = history_dof_handler.begin_active();
     for (; cell != endc; ++cell, ++dg_cell)
-       if (cell->is_locally_owned())
-                       {
-                               PointHistory<dim> *local_quadrature_points_history
-                                               = reinterpret_cast<PointHistory<dim> *>(cell->user_pointer());
-                               Assert (local_quadrature_points_history >=
-                                                               &quadrature_point_history.front(),
-                                                               ExcInternalError());
-                               Assert (local_quadrature_points_history <
-                                                               &quadrature_point_history.back(),
-                                                               ExcInternalError());
-                               for (unsigned int i=0; i<dim; i++)
-                                       for (unsigned int j=0; j<dim; j++)
-                                       {
-                                               dg_cell->get_dof_values (history_stress_field[i][j],
-                                                                                                                                                local_history_stress_fe_values[i][j]);
-                                               dof_to_qpoint_matrix.vmult (local_history_stress_values_at_qpoints[i][j],
-                                                                                                                                                               local_history_stress_fe_values[i][j]);
-
-                                               dg_cell->get_dof_values (history_strain_field[i][j],
-                                                                                                                                                local_history_strain_fe_values[i][j]);
-                                               dof_to_qpoint_matrix.vmult (local_history_strain_values_at_qpoints[i][j],
-                                                                                                                                                               local_history_strain_fe_values[i][j]);
-                                               for (unsigned int q=0; q<quadrature_formula.size(); ++q)
-                                               {
-                                                       local_quadrature_points_history[q].old_stress[i][j]
-                                                                                                = local_history_stress_values_at_qpoints[i][j](q);
-
-                                                       local_quadrature_points_history[q].old_strain[i][j]
-                                                                                                = local_history_strain_values_at_qpoints[i][j](q);
-                                               }
-                                       }
-
-
-                       }
+      if (cell->is_locally_owned())
+        {
+          PointHistory<dim> *local_quadrature_points_history
+            = reinterpret_cast<PointHistory<dim> *>(cell->user_pointer());
+          Assert (local_quadrature_points_history >=
+                  &quadrature_point_history.front(),
+                  ExcInternalError());
+          Assert (local_quadrature_points_history <
+                  &quadrature_point_history.back(),
+                  ExcInternalError());
+          for (unsigned int i=0; i<dim; i++)
+            for (unsigned int j=0; j<dim; j++)
+              {
+                dg_cell->get_dof_values (history_stress_field[i][j],
+                                         local_history_stress_fe_values[i][j]);
+                dof_to_qpoint_matrix.vmult (local_history_stress_values_at_qpoints[i][j],
+                                            local_history_stress_fe_values[i][j]);
+
+                dg_cell->get_dof_values (history_strain_field[i][j],
+                                         local_history_strain_fe_values[i][j]);
+                dof_to_qpoint_matrix.vmult (local_history_strain_values_at_qpoints[i][j],
+                                            local_history_strain_fe_values[i][j]);
+                for (unsigned int q=0; q<quadrature_formula.size(); ++q)
+                  {
+                    local_quadrature_points_history[q].old_stress[i][j]
+                      = local_history_stress_values_at_qpoints[i][j](q);
+
+                    local_quadrature_points_history[q].old_strain[i][j]
+                      = local_history_strain_values_at_qpoints[i][j](q);
+                  }
+              }
+
+
+        }
   }
 
   // @sect4{ElastoPlasticProblem::setup_quadrature_point_history}
@@ -5662,69 +5721,69 @@ namespace ElastoPlastic
   template <int dim>
   void ElastoPlasticProblem<dim>::setup_quadrature_point_history ()
   {
-       // What we need to do here is to first count how many quadrature points
-       // are within the responsibility of this processor. This, of course,
-       // equals the number of cells that belong to this processor times the
-       // number of quadrature points our quadrature formula has on each cell.
-       //
-       // For good measure, we also set all user pointers of all cells, whether
-       // ours of not, to the null pointer. This way, if we ever access the user
-       // pointer of a cell which we should not have accessed, a segmentation
-       // fault will let us know that this should not have happened:
-       unsigned int our_cells = 0;
-       for (typename Triangulation<dim>::active_cell_iterator
-                       cell = triangulation.begin_active();
-                       cell != triangulation.end(); ++cell)
-               if (cell->is_locally_owned())
-                       ++our_cells;
-
-       triangulation.clear_user_data();
-
-       // Next, allocate as many quadrature objects as we need. Since the
-       // <code>resize</code> function does not actually shrink the amount of
-       // allocated memory if the requested new size is smaller than the old
-       // size, we resort to a trick to first free all memory, and then
-       // reallocate it: we declare an empty vector as a temporary variable and
-       // then swap the contents of the old vector and this temporary
-       // variable. This makes sure that the
-       // <code>quadrature_point_history</code> is now really empty, and we can
-       // let the temporary variable that now holds the previous contents of the
-       // vector go out of scope and be destroyed. In the next step. we can then
-       // re-allocate as many elements as we need, with the vector
-       // default-initializing the <code>PointHistory</code> objects, which
-       // includes setting the stress variables to zero.
-       {
-               std::vector<PointHistory<dim> > tmp;
-               tmp.swap (quadrature_point_history);
-       }
-       quadrature_point_history.resize (our_cells *
-                                                                                                                                        quadrature_formula.size());
-
-       // Finally loop over all cells again and set the user pointers from the
-       // cells that belong to the present processor to point to the first
-       // quadrature point objects corresponding to this cell in the vector of
-       // such objects:
-       unsigned int history_index = 0;
-       for (typename Triangulation<dim>::active_cell_iterator
-                       cell = triangulation.begin_active();
-                       cell != triangulation.end(); ++cell)
-               if (cell->is_locally_owned())
-               {
-                       cell->set_user_pointer (&quadrature_point_history[history_index]);
-                       history_index += quadrature_formula.size();
-               }
-
-       // At the end, for good measure make sure that our count of elements was
-       // correct and that we have both used up all objects we allocated
-       // previously, and not point to any objects beyond the end of the
-       // vector. Such defensive programming strategies are always good checks to
-       // avoid accidental errors and to guard against future changes to this
-       // function that forget to update all uses of a variable at the same
-       // time. Recall that constructs using the <code>Assert</code> macro are
-       // optimized away in optimized mode, so do not affect the run time of
-       // optimized runs:
-       Assert (history_index == quadrature_point_history.size(),
-                                       ExcInternalError());
+    // What we need to do here is to first count how many quadrature points
+    // are within the responsibility of this processor. This, of course,
+    // equals the number of cells that belong to this processor times the
+    // number of quadrature points our quadrature formula has on each cell.
+    //
+    // For good measure, we also set all user pointers of all cells, whether
+    // ours of not, to the null pointer. This way, if we ever access the user
+    // pointer of a cell which we should not have accessed, a segmentation
+    // fault will let us know that this should not have happened:
+    unsigned int our_cells = 0;
+    for (typename Triangulation<dim>::active_cell_iterator
+         cell = triangulation.begin_active();
+         cell != triangulation.end(); ++cell)
+      if (cell->is_locally_owned())
+        ++our_cells;
+
+    triangulation.clear_user_data();
+
+    // Next, allocate as many quadrature objects as we need. Since the
+    // <code>resize</code> function does not actually shrink the amount of
+    // allocated memory if the requested new size is smaller than the old
+    // size, we resort to a trick to first free all memory, and then
+    // reallocate it: we declare an empty vector as a temporary variable and
+    // then swap the contents of the old vector and this temporary
+    // variable. This makes sure that the
+    // <code>quadrature_point_history</code> is now really empty, and we can
+    // let the temporary variable that now holds the previous contents of the
+    // vector go out of scope and be destroyed. In the next step. we can then
+    // re-allocate as many elements as we need, with the vector
+    // default-initializing the <code>PointHistory</code> objects, which
+    // includes setting the stress variables to zero.
+    {
+      std::vector<PointHistory<dim> > tmp;
+      tmp.swap (quadrature_point_history);
+    }
+    quadrature_point_history.resize (our_cells *
+                                     quadrature_formula.size());
+
+    // Finally loop over all cells again and set the user pointers from the
+    // cells that belong to the present processor to point to the first
+    // quadrature point objects corresponding to this cell in the vector of
+    // such objects:
+    unsigned int history_index = 0;
+    for (typename Triangulation<dim>::active_cell_iterator
+         cell = triangulation.begin_active();
+         cell != triangulation.end(); ++cell)
+      if (cell->is_locally_owned())
+        {
+          cell->set_user_pointer (&quadrature_point_history[history_index]);
+          history_index += quadrature_formula.size();
+        }
+
+    // At the end, for good measure make sure that our count of elements was
+    // correct and that we have both used up all objects we allocated
+    // previously, and not point to any objects beyond the end of the
+    // vector. Such defensive programming strategies are always good checks to
+    // avoid accidental errors and to guard against future changes to this
+    // function that forget to update all uses of a variable at the same
+    // time. Recall that constructs using the <code>Assert</code> macro are
+    // optimized away in optimized mode, so do not affect the run time of
+    // optimized runs:
+    Assert (history_index == quadrature_point_history.size(),
+            ExcInternalError());
   }
 
   // @sect4{ElastoPlasticProblem::update_quadrature_point_history}
@@ -5776,69 +5835,69 @@ namespace ElastoPlastic
   void ElastoPlasticProblem<dim>::
   update_quadrature_point_history ()
   {
-       // First, set up an <code>FEValues</code> object by which we will evaluate
-       // the displacements and the gradients thereof at the
-       // quadrature points, together with a vector that will hold this
-       // information:
-       FEValues<dim> fe_values (fe, quadrature_formula,
-                                                                                                        update_values | update_gradients |
-                                                                                                        update_quadrature_points);
-
-       const unsigned int n_q_points = quadrature_formula.size();
-
-       std::vector<SymmetricTensor<2, dim> > incremental_strain_tensor(n_q_points);
-       SymmetricTensor<4, dim> stress_strain_tensor;
-
-
-       // Then loop over all cells and do the job in the cells that belong to our
-       // subdomain:
-
-       typename DoFHandler<dim>::active_cell_iterator
-       cell = dof_handler.begin_active(),
-       endc = dof_handler.end();
-
-       const FEValuesExtractors::Vector displacement(0);
-
-       for (;  cell != endc; ++cell)
-               if (cell->is_locally_owned())
-               {
-                       // Next, get a pointer to the quadrature point history data local to
-                       // the present cell, and, as a defensive measure, make sure that
-                       // this pointer is within the bounds of the global array:
-                       PointHistory<dim> *local_quadrature_points_history
-                       = reinterpret_cast<PointHistory<dim> *>(cell->user_pointer());
-                       Assert (local_quadrature_points_history >=
-                                                       &quadrature_point_history.front(),
-                                                       ExcInternalError());
-                       Assert (local_quadrature_points_history <
-                                                       &quadrature_point_history.back(),
-                                                       ExcInternalError());
-
-                       // Then initialize the <code>FEValues</code> object on the present
-                       // cell, and extract the strains of the displacement at the
-                       // quadrature points
-                       fe_values.reinit (cell);
-                       fe_values[displacement].get_function_symmetric_gradients(incremental_displacement,
-                                                                                                                                                                                                                                                        incremental_strain_tensor);
-
-                       // Then loop over the quadrature points of this cell:
-                       for (unsigned int q=0; q<quadrature_formula.size(); ++q)
-                       {
-                               local_quadrature_points_history[q].old_strain +=
-                                                                                                                        incremental_strain_tensor[q];
-
-                               constitutive_law.get_stress_strain_tensor(local_quadrature_points_history[q].old_strain,
-                                                                                                                                                                                                       stress_strain_tensor);
-
-                               // The result of these operations is then written back into
-                               // the original place:
-                               local_quadrature_points_history[q].old_stress
-                                       = stress_strain_tensor *        local_quadrature_points_history[q].old_strain;
-
-                               local_quadrature_points_history[q].point
-                                       =       fe_values.get_quadrature_points ()[q];
-                       }
-               }
+    // First, set up an <code>FEValues</code> object by which we will evaluate
+    // the displacements and the gradients thereof at the
+    // quadrature points, together with a vector that will hold this
+    // information:
+    FEValues<dim> fe_values (fe, quadrature_formula,
+                             update_values | update_gradients |
+                             update_quadrature_points);
+
+    const unsigned int n_q_points = quadrature_formula.size();
+
+    std::vector<SymmetricTensor<2, dim> > incremental_strain_tensor(n_q_points);
+    SymmetricTensor<4, dim> stress_strain_tensor;
+
+
+    // Then loop over all cells and do the job in the cells that belong to our
+    // subdomain:
+
+    typename DoFHandler<dim>::active_cell_iterator
+    cell = dof_handler.begin_active(),
+    endc = dof_handler.end();
+
+    const FEValuesExtractors::Vector displacement(0);
+
+    for (;  cell != endc; ++cell)
+      if (cell->is_locally_owned())
+        {
+          // Next, get a pointer to the quadrature point history data local to
+          // the present cell, and, as a defensive measure, make sure that
+          // this pointer is within the bounds of the global array:
+          PointHistory<dim> *local_quadrature_points_history
+            = reinterpret_cast<PointHistory<dim> *>(cell->user_pointer());
+          Assert (local_quadrature_points_history >=
+                  &quadrature_point_history.front(),
+                  ExcInternalError());
+          Assert (local_quadrature_points_history <
+                  &quadrature_point_history.back(),
+                  ExcInternalError());
+
+          // Then initialize the <code>FEValues</code> object on the present
+          // cell, and extract the strains of the displacement at the
+          // quadrature points
+          fe_values.reinit (cell);
+          fe_values[displacement].get_function_symmetric_gradients(incremental_displacement,
+                                                                   incremental_strain_tensor);
+
+          // Then loop over the quadrature points of this cell:
+          for (unsigned int q=0; q<quadrature_formula.size(); ++q)
+            {
+              local_quadrature_points_history[q].old_strain +=
+                incremental_strain_tensor[q];
+
+              constitutive_law.get_stress_strain_tensor(local_quadrature_points_history[q].old_strain,
+                                                        stress_strain_tensor);
+
+              // The result of these operations is then written back into
+              // the original place:
+              local_quadrature_points_history[q].old_stress
+                = stress_strain_tensor *  local_quadrature_points_history[q].old_strain;
+
+              local_quadrature_points_history[q].point
+                = fe_values.get_quadrature_points ()[q];
+            }
+        }
   }
 
 
@@ -5924,25 +5983,25 @@ namespace ElastoPlastic
                              DataOut<dim>::type_dof_data, data_component_interpretation);
 
     //
-       std::vector<std::string> solution_names;
-
-       switch (dim)
-       {
-       case 1:
-               solution_names.push_back ("displacement");
-               break;
-       case 2:
-               solution_names.push_back ("x_displacement");
-               solution_names.push_back ("y_displacement");
-               break;
-       case 3:
-               solution_names.push_back ("x_displacement");
-               solution_names.push_back ("y_displacement");
-               solution_names.push_back ("z_displacement");
-               break;
-       default:
-               AssertThrow (false, ExcNotImplemented());
-       }
+    std::vector<std::string> solution_names;
+
+    switch (dim)
+      {
+      case 1:
+        solution_names.push_back ("displacement");
+        break;
+      case 2:
+        solution_names.push_back ("x_displacement");
+        solution_names.push_back ("y_displacement");
+        break;
+      case 3:
+        solution_names.push_back ("x_displacement");
+        solution_names.push_back ("y_displacement");
+        solution_names.push_back ("z_displacement");
+        break;
+      default:
+        AssertThrow (false, ExcNotImplemented());
+      }
 
     data_out.add_data_vector (solution, solution_names);
 
@@ -5953,1063 +6012,1066 @@ namespace ElastoPlastic
       subdomain(i) = triangulation.locally_owned_subdomain();
     data_out.add_data_vector(subdomain, "subdomain");
 
-    //
-    data_out.add_data_vector(fraction_of_plastic_q_points_per_cell,
-                             "fraction_of_plastic_q_points");
+    //
+    data_out.add_data_vector(fraction_of_plastic_q_points_per_cell,
+                             "fraction_of_plastic_q_points");
+
+    //
+    data_out.build_patches();
+
+    // In the remainder of the function, we generate one VTU file on
+    // every processor, indexed by the subdomain id of this processor.
+    // On the first processor, we then also create a <code>.pvtu</code>
+    // file that indexes <i>all</i> of the VTU files so that the entire
+    // set of output files can be read at once. These <code>.pvtu</code>
+    // are used by Paraview to describe an entire parallel computation's
+    // output files. We then do the same again for the competitor of
+    // Paraview, the Visit visualization program, by creating a matching
+    // <code>.visit</code> file.
+    const std::string filename =
+      (output_dir + filename_base + "-"
+       + Utilities::int_to_string(triangulation.locally_owned_subdomain(), 4));
+
+    std::ofstream output_vtu((filename + ".vtu").c_str());
+    data_out.write_vtu(output_vtu);
+    pcout << output_dir + filename_base << ".pvtu" << std::endl;
+
+
+    if (this_mpi_process == 0)
+      {
+        std::vector<std::string> filenames;
+        for (unsigned int i = 0; i < n_mpi_processes; ++i)
+          filenames.push_back(filename_base + "-" +
+                              Utilities::int_to_string(i, 4) +
+                              ".vtu");
+
+        std::ofstream pvtu_master_output((output_dir + filename_base + ".pvtu").c_str());
+        data_out.write_pvtu_record(pvtu_master_output, filenames);
+
+        std::ofstream visit_master_output((output_dir + filename_base + ".visit").c_str());
+        data_out.write_visit_record(visit_master_output, filenames);
+
+        // produce eps files for mesh illustration
+        std::ofstream output_eps((filename + ".eps").c_str());
+        GridOut grid_out;
+        grid_out.write_eps(triangulation, output_eps);
+      }
+
+    // Extrapolate the stresses from Gauss point to the nodes
+    SymmetricTensor<2, dim> stress_at_qpoint;
+
+    FE_DGQ<dim> history_fe (1);
+    DoFHandler<dim> history_dof_handler (triangulation);
+    history_dof_handler.distribute_dofs (history_fe);
+    std::vector< std::vector< Vector<double> > >
+    history_stress_field (dim, std::vector< Vector<double> >(dim)),
+                         local_history_stress_values_at_qpoints (dim, std::vector< Vector<double> >(dim)),
+                         local_history_stress_fe_values (dim, std::vector< Vector<double> >(dim));
+    for (unsigned int i=0; i<dim; i++)
+      for (unsigned int j=0; j<dim; j++)
+        {
+          history_stress_field[i][j].reinit(history_dof_handler.n_dofs());
+          local_history_stress_values_at_qpoints[i][j].reinit(quadrature_formula.size());
+          local_history_stress_fe_values[i][j].reinit(history_fe.dofs_per_cell);
+        }
+
+    Vector<double>  VM_stress_field (history_dof_handler.n_dofs()),
+           local_VM_stress_values_at_qpoints (quadrature_formula.size()),
+           local_VM_stress_fe_values (history_fe.dofs_per_cell);
+
+    FullMatrix<double> qpoint_to_dof_matrix (history_fe.dofs_per_cell,
+                                             quadrature_formula.size());
+    FETools::compute_projection_from_quadrature_points_matrix
+    (history_fe,
+     quadrature_formula, quadrature_formula,
+     qpoint_to_dof_matrix);
+
+    typename DoFHandler<dim>::active_cell_iterator
+    cell = dof_handler.begin_active(),
+    endc = dof_handler.end(),
+    dg_cell = history_dof_handler.begin_active();
+
+    const FEValuesExtractors::Vector displacement(0);
+
+    for (; cell!=endc; ++cell, ++dg_cell)
+      if (cell->is_locally_owned())
+        {
+          PointHistory<dim> *local_quadrature_points_history
+            = reinterpret_cast<PointHistory<dim> *>(cell->user_pointer());
+          Assert (local_quadrature_points_history >=
+                  &quadrature_point_history.front(),
+                  ExcInternalError());
+          Assert (local_quadrature_points_history <
+                  &quadrature_point_history.back(),
+                  ExcInternalError());
+
+          // Then loop over the quadrature points of this cell:
+          for (unsigned int q=0; q<quadrature_formula.size(); ++q)
+            {
+              stress_at_qpoint = local_quadrature_points_history[q].old_stress;
+
+              for (unsigned int i=0; i<dim; i++)
+                for (unsigned int j=i; j<dim; j++)
+                  {
+                    local_history_stress_values_at_qpoints[i][j](q) = stress_at_qpoint[i][j];
+                  }
+
+              local_VM_stress_values_at_qpoints(q) = Evaluation::get_von_Mises_stress(stress_at_qpoint);
+
+            }
+
+
+          for (unsigned int i=0; i<dim; i++)
+            for (unsigned int j=i; j<dim; j++)
+              {
+                qpoint_to_dof_matrix.vmult (local_history_stress_fe_values[i][j],
+                                            local_history_stress_values_at_qpoints[i][j]);
+                dg_cell->set_dof_values (local_history_stress_fe_values[i][j],
+                                         history_stress_field[i][j]);
+              }
+
+          qpoint_to_dof_matrix.vmult (local_VM_stress_fe_values,
+                                      local_VM_stress_values_at_qpoints);
+          dg_cell->set_dof_values (local_VM_stress_fe_values,
+                                   VM_stress_field);
+
+
+        }
+
+    // Save stresses on nodes by nodal averaging
+    // construct a DoFHandler object based on FE_Q with 1 degree of freedom
+    // in order to compute stresses on nodes (by applying nodal averaging)
+    // Therefore, each vertex has one degree of freedom
+    FE_Q<dim>          fe_1 (1);
+    DoFHandler<dim>    dof_handler_1 (triangulation);
+    dof_handler_1.distribute_dofs (fe_1);
+
+    AssertThrow(dof_handler_1.n_dofs() == triangulation.n_vertices(),
+                ExcDimensionMismatch(dof_handler_1.n_dofs(),triangulation.n_vertices()));
+
+    std::vector< std::vector< Vector<double> > >
+    history_stress_on_vertices (dim, std::vector< Vector<double> >(dim));
+    for (unsigned int i=0; i<dim; i++)
+      for (unsigned int j=0; j<dim; j++)
+        {
+          history_stress_on_vertices[i][j].reinit(dof_handler_1.n_dofs());
+        }
+
+    Vector<double>  VM_stress_on_vertices (dof_handler_1.n_dofs()),
+           counter_on_vertices (dof_handler_1.n_dofs());
+    VM_stress_on_vertices = 0;
+    counter_on_vertices = 0;
+
+    cell = dof_handler.begin_active();
+    dg_cell = history_dof_handler.begin_active();
+    typename DoFHandler<dim>::active_cell_iterator
+    cell_1 = dof_handler_1.begin_active();
+    for (; cell!=endc; ++cell, ++dg_cell, ++cell_1)
+      if (cell->is_locally_owned())
+        {
+          dg_cell->get_dof_values (VM_stress_field,
+                                   local_VM_stress_fe_values);
+
+          for (unsigned int i=0; i<dim; i++)
+            for (unsigned int j=0; j<dim; j++)
+              {
+                dg_cell->get_dof_values (history_stress_field[i][j],
+                                         local_history_stress_fe_values[i][j]);
+              }
+
+          for  (unsigned int v = 0; v < GeometryInfo<dim>::vertices_per_cell; ++v)
+            {
+              types::global_dof_index dof_1_vertex = cell_1->vertex_dof_index(v, 0);
+
+              // begin check
+              //            Point<dim> point1, point2;
+              //            point1 = cell_1->vertex(v);
+              //            point2 = dg_cell->vertex(v);
+              //            AssertThrow(point1.distance(point2) < cell->diameter()*1e-8, ExcInternalError());
+              // end check
+
+              counter_on_vertices (dof_1_vertex) += 1;
+
+              VM_stress_on_vertices (dof_1_vertex) += local_VM_stress_fe_values (v);
+
+              for (unsigned int i=0; i<dim; i++)
+                for (unsigned int j=0; j<dim; j++)
+                  {
+                    history_stress_on_vertices[i][j](dof_1_vertex) +=
+                      local_history_stress_fe_values[i][j](v);
+                  }
+
+            }
+        }
+
+    for (unsigned int id=0; id<dof_handler_1.n_dofs(); ++id)
+      {
+        VM_stress_on_vertices(id) /= counter_on_vertices(id);
+
+        for (unsigned int i=0; i<dim; i++)
+          for (unsigned int j=0; j<dim; j++)
+            {
+              history_stress_on_vertices[i][j](id) /= counter_on_vertices(id);
+            }
+      }
+
+    // Save figures of stresses
+    if (show_stresses)
+      {
+        {
+          DataOut<dim>  data_out;
+          data_out.attach_dof_handler (history_dof_handler);
+
+
+          data_out.add_data_vector (history_stress_field[0][0], "stress_xx");
+          data_out.add_data_vector (history_stress_field[1][1], "stress_yy");
+          data_out.add_data_vector (history_stress_field[0][1], "stress_xy");
+          data_out.add_data_vector (VM_stress_field, "Von_Mises_stress");
+
+          if (dim == 3)
+            {
+              data_out.add_data_vector (history_stress_field[0][2], "stress_xz");
+              data_out.add_data_vector (history_stress_field[1][2], "stress_yz");
+              data_out.add_data_vector (history_stress_field[2][2], "stress_zz");
+            }
+
+          data_out.build_patches ();
+
+          const std::string filename_base_stress = ("stress-" + filename_base);
+
+          const std::string filename =
+            (output_dir + filename_base_stress + "-"
+             + Utilities::int_to_string(triangulation.locally_owned_subdomain(), 4));
+
+          std::ofstream output_vtu((filename + ".vtu").c_str());
+          data_out.write_vtu(output_vtu);
+          pcout << output_dir + filename_base_stress << ".pvtu" << std::endl;
+
+          if (this_mpi_process == 0)
+            {
+              std::vector<std::string> filenames;
+              for (unsigned int i = 0; i < n_mpi_processes; ++i)
+                filenames.push_back(filename_base_stress + "-" +
+                                    Utilities::int_to_string(i, 4) +
+                                    ".vtu");
+
+              std::ofstream pvtu_master_output((output_dir + filename_base_stress + ".pvtu").c_str());
+              data_out.write_pvtu_record(pvtu_master_output, filenames);
+
+              std::ofstream visit_master_output((output_dir + filename_base_stress + ".visit").c_str());
+              data_out.write_visit_record(visit_master_output, filenames);
+            }
+
+
+        }
+
+        {
+          DataOut<dim>  data_out;
+          data_out.attach_dof_handler (dof_handler_1);
+
+
+          data_out.add_data_vector (history_stress_on_vertices[0][0], "stress_xx_averaged");
+          data_out.add_data_vector (history_stress_on_vertices[1][1], "stress_yy_averaged");
+          data_out.add_data_vector (history_stress_on_vertices[0][1], "stress_xy_averaged");
+          data_out.add_data_vector (VM_stress_on_vertices, "Von_Mises_stress_averaged");
+
+          if (dim == 3)
+            {
+              data_out.add_data_vector (history_stress_on_vertices[0][2], "stress_xz_averaged");
+              data_out.add_data_vector (history_stress_on_vertices[1][2], "stress_yz_averaged");
+              data_out.add_data_vector (history_stress_on_vertices[2][2], "stress_zz_averaged");
+            }
+
+          data_out.build_patches ();
+
+          const std::string filename_base_stress = ("averaged-stress-" + filename_base);
+
+          const std::string filename =
+            (output_dir + filename_base_stress + "-"
+             + Utilities::int_to_string(triangulation.locally_owned_subdomain(), 4));
+
+          std::ofstream output_vtu((filename + ".vtu").c_str());
+          data_out.write_vtu(output_vtu);
+          pcout << output_dir + filename_base_stress << ".pvtu" << std::endl;
+
+          if (this_mpi_process == 0)
+            {
+              std::vector<std::string> filenames;
+              for (unsigned int i = 0; i < n_mpi_processes; ++i)
+                filenames.push_back(filename_base_stress + "-" +
+                                    Utilities::int_to_string(i, 4) +
+                                    ".vtu");
+
+              std::ofstream pvtu_master_output((output_dir + filename_base_stress + ".pvtu").c_str());
+              data_out.write_pvtu_record(pvtu_master_output, filenames);
+
+              std::ofstream visit_master_output((output_dir + filename_base_stress + ".visit").c_str());
+              data_out.write_visit_record(visit_master_output, filenames);
+            }
+
+
+        }
+        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+      }
+
+    magnified_solution *= -1;
+    move_mesh(magnified_solution);
+
+    // Timoshenko beam
+    if (base_mesh == "Timoshenko beam")
+      {
+        const double length = .48,
+                     depth  = .12;
+
+        Point<dim> intersted_point(length, -depth/2);
+        Point<dim> vertex_displacement;
+        bool vertex_found = false;
+
+        for (typename DoFHandler<dim>::active_cell_iterator cell =
+               dof_handler.begin_active();
+             cell != dof_handler.end(); ++cell)
+          if (cell->is_locally_owned() && !vertex_found)
+            for (unsigned int v = 0; v < GeometryInfo<dim>::vertices_per_cell; ++v)
+              if ( std::fabs(cell->vertex(v)[0] - intersted_point[0])<1e-6 &&
+                   std::fabs(cell->vertex(v)[1] - intersted_point[1])<1e-6)
+                {
+                  vertex_found = true;
+
+                  for (unsigned int d = 0; d < dim; ++d)
+                    vertex_displacement[d] = solution(cell->vertex_dof_index(v, d));
 
-    //
-    data_out.build_patches();
+                  break;
+                }
 
-    // In the remainder of the function, we generate one VTU file on
-    // every processor, indexed by the subdomain id of this processor.
-    // On the first processor, we then also create a <code>.pvtu</code>
-    // file that indexes <i>all</i> of the VTU files so that the entire
-    // set of output files can be read at once. These <code>.pvtu</code>
-    // are used by Paraview to describe an entire parallel computation's
-    // output files. We then do the same again for the competitor of
-    // Paraview, the Visit visualization program, by creating a matching
-    // <code>.visit</code> file.
-    const std::string filename =
-      (output_dir + filename_base + "-"
-       + Utilities::int_to_string(triangulation.locally_owned_subdomain(), 4));
+        pcout << "   Number of active cells: "
+              << triangulation.n_global_active_cells() << std::endl
+              << "   Number of degrees of freedom: " << dof_handler.n_dofs()
+              << std::endl;
 
-    std::ofstream output_vtu((filename + ".vtu").c_str());
-    data_out.write_vtu(output_vtu);
-    pcout << output_dir + filename_base << ".pvtu" << std::endl;
+        AssertThrow(vertex_found, ExcInternalError());
+        std::cout << "Displacement at the point (" << intersted_point[0]
+                  << ", " << intersted_point[1] << ") is "
+                  << "(" << vertex_displacement[0]
+                  << ", " << vertex_displacement[1] << ").\n";
 
+        Vector<double> vertex_exact_displacement(dim);
+        EquationData::IncrementalBoundaryValues<dim> incremental_boundary_values(present_time, end_time);
+        incremental_boundary_values.vector_value (intersted_point, vertex_exact_displacement);
 
-    if (this_mpi_process == 0)
+        std::cout << "Exact displacement at the point (" << intersted_point[0]
+                  << ", " << intersted_point[1] << ") is "
+                  << "(" << vertex_exact_displacement[0]
+                  << ", " << vertex_exact_displacement[1] << ").\n\n";
+
+      }
+    else if (base_mesh == "Thick_tube_internal_pressure")
       {
-        std::vector<std::string> filenames;
-        for (unsigned int i = 0; i < n_mpi_processes; ++i)
-          filenames.push_back(filename_base + "-" +
-                              Utilities::int_to_string(i, 4) +
-                              ".vtu");
+        const double pressure (0.6*2.4e8),
+              inner_radius (.1);
+//      const double pressure (1.94e8),
+//                   inner_radius (.1);
 
-        std::ofstream pvtu_master_output((output_dir + filename_base + ".pvtu").c_str());
-        data_out.write_pvtu_record(pvtu_master_output, filenames);
 
-        std::ofstream visit_master_output((output_dir + filename_base + ".visit").c_str());
-        data_out.write_visit_record(visit_master_output, filenames);
+        // Plane stress
+//      const double mu (((e_modulus*(1+2*nu)) / (std::pow((1+nu),2))) / (2 * (1 + (nu / (1+nu)))));
+        // 3d and plane strain
+        const double mu (e_modulus / (2 * (1 + nu)));
 
-        // produce eps files for mesh illustration
-        std::ofstream output_eps((filename + ".eps").c_str());
-        GridOut grid_out;
-        grid_out.write_eps(triangulation, output_eps);
-      }
+        const Point<dim> point_A(inner_radius, 0.);
+        Vector<double>   disp_A(dim);
 
-    // Extrapolate the stresses from Gauss point to the nodes
-    SymmetricTensor<2, dim>    stress_at_qpoint;
+        // make a non-parallel copy of solution
+        Vector<double> copy_solution(solution);
 
-    FE_DGQ<dim> history_fe (1);
-    DoFHandler<dim> history_dof_handler (triangulation);
-    history_dof_handler.distribute_dofs (history_fe);
-    std::vector< std::vector< Vector<double> > >
-                       history_stress_field (dim, std::vector< Vector<double> >(dim)),
-                       local_history_stress_values_at_qpoints (dim, std::vector< Vector<double> >(dim)),
-                       local_history_stress_fe_values (dim, std::vector< Vector<double> >(dim));
-    for (unsigned int i=0; i<dim; i++)
-       for (unsigned int j=0; j<dim; j++)
-       {
-               history_stress_field[i][j].reinit(history_dof_handler.n_dofs());
-               local_history_stress_values_at_qpoints[i][j].reinit(quadrature_formula.size());
-               local_history_stress_fe_values[i][j].reinit(history_fe.dofs_per_cell);
-       }
+        typename Evaluation::PointValuesEvaluation<dim>::
+        PointValuesEvaluation point_values_evaluation(point_A);
 
-    Vector<double>     VM_stress_field (history_dof_handler.n_dofs()),
-                                                               local_VM_stress_values_at_qpoints (quadrature_formula.size()),
-                                                               local_VM_stress_fe_values (history_fe.dofs_per_cell);
+        point_values_evaluation.compute (dof_handler, copy_solution, disp_A);
 
-    FullMatrix<double> qpoint_to_dof_matrix (history_fe.dofs_per_cell,
-                                                                                                                                                                quadrature_formula.size());
-    FETools::compute_projection_from_quadrature_points_matrix
-                                       (history_fe,
-                                                       quadrature_formula, quadrature_formula,
-                                                       qpoint_to_dof_matrix);
+        table_results.add_value("time step", timestep_no);
+        table_results.add_value("Cells", triangulation.n_global_active_cells());
+        table_results.add_value("DoFs", dof_handler.n_dofs());
+        table_results.add_value("pressure/sigma_0", (pressure*present_time/end_time)/sigma_0);
+        table_results.add_value("4*mu*u_A/(sigma_0*a)", 4*mu*disp_A(0)/(sigma_0*inner_radius));
 
-    typename DoFHandler<dim>::active_cell_iterator
-    cell = dof_handler.begin_active(),
-    endc = dof_handler.end(),
-    dg_cell = history_dof_handler.begin_active();
+        // Compute stresses in the POLAR coordinates, 1- save it on Gauss points,
+        // 2- extrapolate them to nodes and taking their avarages (nodal avaraging)
+        AssertThrow (dim == 2, ExcNotImplemented());
 
-    const FEValuesExtractors::Vector displacement(0);
+        // we define a rotation matrix to be able to transform the stress
+        // from the Cartesian coordinate to the polar coordinate
+        Tensor<2, dim> rotation_matrix; // [cos sin; -sin cos]    , sigma_r = rot * sigma * rot^T
 
-    for (; cell!=endc; ++cell, ++dg_cell)
-       if (cell->is_locally_owned())
-       {
-               PointHistory<dim> *local_quadrature_points_history
-               = reinterpret_cast<PointHistory<dim> *>(cell->user_pointer());
-               Assert (local_quadrature_points_history >=
-                               &quadrature_point_history.front(),
-                               ExcInternalError());
-               Assert (local_quadrature_points_history <
-                               &quadrature_point_history.back(),
-                               ExcInternalError());
-
-               // Then loop over the quadrature points of this cell:
-               for (unsigned int q=0; q<quadrature_formula.size(); ++q)
-               {
-                       stress_at_qpoint = local_quadrature_points_history[q].old_stress;
-
-                       for (unsigned int i=0; i<dim; i++)
-                               for (unsigned int j=i; j<dim; j++)
-                               {
-                                       local_history_stress_values_at_qpoints[i][j](q) = stress_at_qpoint[i][j];
-                               }
-
-                       local_VM_stress_values_at_qpoints(q) = Evaluation::get_von_Mises_stress(stress_at_qpoint);
-
-               }
-
-
-               for (unsigned int i=0; i<dim; i++)
-                       for (unsigned int j=i; j<dim; j++)
-                       {
-                               qpoint_to_dof_matrix.vmult (local_history_stress_fe_values[i][j],
-                                               local_history_stress_values_at_qpoints[i][j]);
-                               dg_cell->set_dof_values (local_history_stress_fe_values[i][j],
-                                               history_stress_field[i][j]);
-                       }
-
-               qpoint_to_dof_matrix.vmult (local_VM_stress_fe_values,
-                               local_VM_stress_values_at_qpoints);
-               dg_cell->set_dof_values (local_VM_stress_fe_values,
-                               VM_stress_field);
-
-
-       }
+        FEValues<dim> fe_values (fe, quadrature_formula, update_quadrature_points |
+                                 update_values | update_gradients);
 
-    // Save stresses on nodes by nodal averaging
-    // construct a DoFHandler object based on FE_Q with 1 degree of freedom
-    // in order to compute stresses on nodes (by applying nodal averaging)
-    // Therefore, each vertex has one degree of freedom
-    FE_Q<dim>                                   fe_1 (1);
-    DoFHandler<dim>    dof_handler_1 (triangulation);
-    dof_handler_1.distribute_dofs (fe_1);
+        const unsigned int n_q_points = quadrature_formula.size();
 
-    AssertThrow(dof_handler_1.n_dofs() == triangulation.n_vertices(),
-               ExcDimensionMismatch(dof_handler_1.n_dofs(),triangulation.n_vertices()));
+        std::vector<SymmetricTensor<2, dim> > strain_tensor(n_q_points);
+        SymmetricTensor<4, dim> stress_strain_tensor;
+        Tensor<2, dim>  stress_at_qpoint;
 
-    std::vector< std::vector< Vector<double> > >
-    history_stress_on_vertices (dim, std::vector< Vector<double> >(dim));
-    for (unsigned int i=0; i<dim; i++)
-       for (unsigned int j=0; j<dim; j++)
-       {
-               history_stress_on_vertices[i][j].reinit(dof_handler_1.n_dofs());
-       }
+        FE_DGQ<dim> history_fe (1);
+        DoFHandler<dim> history_dof_handler (triangulation);
+        history_dof_handler.distribute_dofs (history_fe);
+        std::vector< std::vector< Vector<double> > >
+        history_stress_field (dim, std::vector< Vector<double> >(dim)),
+                             local_history_stress_values_at_qpoints (dim, std::vector< Vector<double> >(dim)),
+                             local_history_stress_fe_values (dim, std::vector< Vector<double> >(dim));
+        for (unsigned int i=0; i<dim; i++)
+          for (unsigned int j=0; j<dim; j++)
+            {
+              history_stress_field[i][j].reinit(history_dof_handler.n_dofs());
+              local_history_stress_values_at_qpoints[i][j].reinit(quadrature_formula.size());
+              local_history_stress_fe_values[i][j].reinit(history_fe.dofs_per_cell);
+            }
 
-    Vector<double>     VM_stress_on_vertices (dof_handler_1.n_dofs()),
-               counter_on_vertices (dof_handler_1.n_dofs());
-    VM_stress_on_vertices = 0;
-    counter_on_vertices = 0;
+        FullMatrix<double> qpoint_to_dof_matrix (history_fe.dofs_per_cell,
+                                                 quadrature_formula.size());
+        FETools::compute_projection_from_quadrature_points_matrix
+        (history_fe,
+         quadrature_formula, quadrature_formula,
+         qpoint_to_dof_matrix);
 
-    cell = dof_handler.begin_active();
-    dg_cell = history_dof_handler.begin_active();
-    typename DoFHandler<dim>::active_cell_iterator
-    cell_1 = dof_handler_1.begin_active();
-    for (; cell!=endc; ++cell, ++dg_cell, ++cell_1)
-       if (cell->is_locally_owned())
-       {
-               dg_cell->get_dof_values (VM_stress_field,
-                               local_VM_stress_fe_values);
-
-               for (unsigned int i=0; i<dim; i++)
-                       for (unsigned int j=0; j<dim; j++)
-                       {
-                               dg_cell->get_dof_values (history_stress_field[i][j],
-                                               local_history_stress_fe_values[i][j]);
-                       }
-
-               for  (unsigned int v = 0; v < GeometryInfo<dim>::vertices_per_cell; ++v)
-               {
-                       types::global_dof_index dof_1_vertex = cell_1->vertex_dof_index(v, 0);
-
-                       // begin check
-                       //                              Point<dim> point1, point2;
-                       //                              point1 = cell_1->vertex(v);
-                       //                              point2 = dg_cell->vertex(v);
-                       //                              AssertThrow(point1.distance(point2) < cell->diameter()*1e-8, ExcInternalError());
-                       // end check
-
-                       counter_on_vertices (dof_1_vertex) += 1;
-
-                       VM_stress_on_vertices (dof_1_vertex) += local_VM_stress_fe_values (v);
-
-                       for (unsigned int i=0; i<dim; i++)
-                               for (unsigned int j=0; j<dim; j++)
-                               {
-                                       history_stress_on_vertices[i][j](dof_1_vertex) +=
-                                                       local_history_stress_fe_values[i][j](v);
-                               }
-
-               }
-       }
+        typename DoFHandler<dim>::active_cell_iterator
+        cell = dof_handler.begin_active(),
+        endc = dof_handler.end(),
+        dg_cell = history_dof_handler.begin_active();
 
-    for (unsigned int id=0; id<dof_handler_1.n_dofs(); ++id)
-    {
-       VM_stress_on_vertices(id) /= counter_on_vertices(id);
+        const FEValuesExtractors::Vector displacement(0);
 
-       for (unsigned int i=0; i<dim; i++)
-               for (unsigned int j=0; j<dim; j++)
-               {
-                       history_stress_on_vertices[i][j](id) /= counter_on_vertices(id);
-               }
-    }
+        for (; cell!=endc; ++cell, ++dg_cell)
+          if (cell->is_locally_owned())
+            {
+              PointHistory<dim> *local_quadrature_points_history
+                = reinterpret_cast<PointHistory<dim> *>(cell->user_pointer());
+              Assert (local_quadrature_points_history >=
+                      &quadrature_point_history.front(),
+                      ExcInternalError());
+              Assert (local_quadrature_points_history <
+                      &quadrature_point_history.back(),
+                      ExcInternalError());
+
+              // Then loop over the quadrature points of this cell:
+              for (unsigned int q=0; q<quadrature_formula.size(); ++q)
+                {
+                  stress_at_qpoint = local_quadrature_points_history[q].old_stress;
 
-    // Save figures of stresses
-    if (show_stresses)
-    {
-       {
-                               DataOut<dim>    data_out;
-                               data_out.attach_dof_handler (history_dof_handler);
+                  // transform the stress from the Cartesian coordinate to the polar coordinate
+                  const Point<dim> point = local_quadrature_points_history[q].point;
+                  const double radius = point.norm ();
+                  const double theta = std::atan2(point(1),point(0));
 
+                  // rotation matrix
+                  rotation_matrix[0][0] = std::cos(theta);
+                  rotation_matrix[0][1] = std::sin(theta);
+                  rotation_matrix[1][0] = -std::sin(theta);
+                  rotation_matrix[1][1] = std::cos(theta);
 
-                               data_out.add_data_vector (history_stress_field[0][0], "stress_xx");
-                               data_out.add_data_vector (history_stress_field[1][1], "stress_yy");
-                               data_out.add_data_vector (history_stress_field[0][1], "stress_xy");
-                               data_out.add_data_vector (VM_stress_field, "Von_Mises_stress");
+                  // stress in polar coordinate
+                  stress_at_qpoint = rotation_matrix * stress_at_qpoint * transpose(rotation_matrix);
 
-                               if (dim == 3)
-                               {
-                                       data_out.add_data_vector (history_stress_field[0][2], "stress_xz");
-                                       data_out.add_data_vector (history_stress_field[1][2], "stress_yz");
-                                       data_out.add_data_vector (history_stress_field[2][2], "stress_zz");
-                               }
+                  for (unsigned int i=0; i<dim; i++)
+                    for (unsigned int j=i; j<dim; j++)
+                      {
+                        local_history_stress_values_at_qpoints[i][j](q) = stress_at_qpoint[i][j];
+                      }
 
-                               data_out.build_patches ();
+                }
 
-                               const std::string filename_base_stress = ("stress-" + filename_base);
 
-                               const std::string filename =
-                                               (output_dir + filename_base_stress + "-"
-                                                               + Utilities::int_to_string(triangulation.locally_owned_subdomain(), 4));
+              for (unsigned int i=0; i<dim; i++)
+                for (unsigned int j=i; j<dim; j++)
+                  {
+                    qpoint_to_dof_matrix.vmult (local_history_stress_fe_values[i][j],
+                                                local_history_stress_values_at_qpoints[i][j]);
+                    dg_cell->set_dof_values (local_history_stress_fe_values[i][j],
+                                             history_stress_field[i][j]);
+                  }
 
-                               std::ofstream output_vtu((filename + ".vtu").c_str());
-                               data_out.write_vtu(output_vtu);
-                               pcout << output_dir + filename_base_stress << ".pvtu" << std::endl;
+            }
 
-                               if (this_mpi_process == 0)
-                               {
-                                       std::vector<std::string> filenames;
-                                       for (unsigned int i = 0; i < n_mpi_processes; ++i)
-                                               filenames.push_back(filename_base_stress + "-" +
-                                                               Utilities::int_to_string(i, 4) +
-                                                               ".vtu");
+        {
+          DataOut<dim>  data_out;
+          data_out.attach_dof_handler (history_dof_handler);
 
-                                       std::ofstream pvtu_master_output((output_dir + filename_base_stress + ".pvtu").c_str());
-                                       data_out.write_pvtu_record(pvtu_master_output, filenames);
 
-                                       std::ofstream visit_master_output((output_dir + filename_base_stress + ".visit").c_str());
-                                       data_out.write_visit_record(visit_master_output, filenames);
-                               }
+          data_out.add_data_vector (history_stress_field[0][0], "stress_rr");
+          data_out.add_data_vector (history_stress_field[1][1], "stress_tt");
+          data_out.add_data_vector (history_stress_field[0][1], "stress_rt");
 
+          data_out.build_patches ();
 
-       }
+          const std::string filename_base_stress = ("stress-polar-" + filename_base);
 
-       {
-                               DataOut<dim>    data_out;
-                               data_out.attach_dof_handler (dof_handler_1);
+          const std::string filename =
+            (output_dir + filename_base_stress + "-"
+             + Utilities::int_to_string(triangulation.locally_owned_subdomain(), 4));
 
+          std::ofstream output_vtu((filename + ".vtu").c_str());
+          data_out.write_vtu(output_vtu);
+          pcout << output_dir + filename_base_stress << ".pvtu" << std::endl;
 
-                               data_out.add_data_vector (history_stress_on_vertices[0][0], "stress_xx_averaged");
-                               data_out.add_data_vector (history_stress_on_vertices[1][1], "stress_yy_averaged");
-                               data_out.add_data_vector (history_stress_on_vertices[0][1], "stress_xy_averaged");
-                               data_out.add_data_vector (VM_stress_on_vertices, "Von_Mises_stress_averaged");
+          if (this_mpi_process == 0)
+            {
+              std::vector<std::string> filenames;
+              for (unsigned int i = 0; i < n_mpi_processes; ++i)
+                filenames.push_back(filename_base_stress + "-" +
+                                    Utilities::int_to_string(i, 4) +
+                                    ".vtu");
 
-                               if (dim == 3)
-                               {
-                                       data_out.add_data_vector (history_stress_on_vertices[0][2], "stress_xz_averaged");
-                                       data_out.add_data_vector (history_stress_on_vertices[1][2], "stress_yz_averaged");
-                                       data_out.add_data_vector (history_stress_on_vertices[2][2], "stress_zz_averaged");
-                               }
+              std::ofstream pvtu_master_output((output_dir + filename_base_stress + ".pvtu").c_str());
+              data_out.write_pvtu_record(pvtu_master_output, filenames);
 
-                               data_out.build_patches ();
+              std::ofstream visit_master_output((output_dir + filename_base_stress + ".visit").c_str());
+              data_out.write_visit_record(visit_master_output, filenames);
+            }
 
-                               const std::string filename_base_stress = ("averaged-stress-" + filename_base);
 
-                               const std::string filename =
-                                               (output_dir + filename_base_stress + "-"
-                                                               + Utilities::int_to_string(triangulation.locally_owned_subdomain(), 4));
+        }
 
-                               std::ofstream output_vtu((filename + ".vtu").c_str());
-                               data_out.write_vtu(output_vtu);
-                               pcout << output_dir + filename_base_stress << ".pvtu" << std::endl;
+        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+        // construct a DoFHandler object based on FE_Q with 1 degree of freedom
+        // in order to compute stresses on nodes (by applying nodal averaging)
+        // Therefore, each vertex has one degree of freedom
+        FE_Q<dim>          fe_1 (1);
+        DoFHandler<dim>    dof_handler_1 (triangulation);
+        dof_handler_1.distribute_dofs (fe_1);
+
+        AssertThrow(dof_handler_1.n_dofs() == triangulation.n_vertices(),
+                    ExcDimensionMismatch(dof_handler_1.n_dofs(),triangulation.n_vertices()));
+
+        std::vector< std::vector< Vector<double> > >
+        history_stress_on_vertices (dim, std::vector< Vector<double> >(dim));
+        for (unsigned int i=0; i<dim; i++)
+          for (unsigned int j=0; j<dim; j++)
+            {
+              history_stress_on_vertices[i][j].reinit(dof_handler_1.n_dofs());
+            }
 
-                               if (this_mpi_process == 0)
-                               {
-                                       std::vector<std::string> filenames;
-                                       for (unsigned int i = 0; i < n_mpi_processes; ++i)
-                                               filenames.push_back(filename_base_stress + "-" +
-                                                               Utilities::int_to_string(i, 4) +
-                                                               ".vtu");
+        Vector<double>  counter_on_vertices (dof_handler_1.n_dofs());
+        counter_on_vertices = 0;
 
-                                       std::ofstream pvtu_master_output((output_dir + filename_base_stress + ".pvtu").c_str());
-                                       data_out.write_pvtu_record(pvtu_master_output, filenames);
+        cell = dof_handler.begin_active();
+        dg_cell = history_dof_handler.begin_active();
+        typename DoFHandler<dim>::active_cell_iterator
+        cell_1 = dof_handler_1.begin_active();
+        for (; cell!=endc; ++cell, ++dg_cell, ++cell_1)
+          if (cell->is_locally_owned())
+            {
 
-                                       std::ofstream visit_master_output((output_dir + filename_base_stress + ".visit").c_str());
-                                       data_out.write_visit_record(visit_master_output, filenames);
-                               }
+              for (unsigned int i=0; i<dim; i++)
+                for (unsigned int j=0; j<dim; j++)
+                  {
+                    dg_cell->get_dof_values (history_stress_field[i][j],
+                                             local_history_stress_fe_values[i][j]);
+                  }
 
+              for  (unsigned int v = 0; v < GeometryInfo<dim>::vertices_per_cell; ++v)
+                {
+                  types::global_dof_index dof_1_vertex = cell_1->vertex_dof_index(v, 0);
 
-       }
-                       // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+                  // begin check
+//            Point<dim> point1, point2;
+//            point1 = cell_1->vertex(v);
+//            point2 = dg_cell->vertex(v);
+//            AssertThrow(point1.distance(point2) < cell->diameter()*1e-8, ExcInternalError());
+                  // end check
 
-    }
+                  counter_on_vertices (dof_1_vertex) += 1;
 
-    magnified_solution *= -1;
-    move_mesh(magnified_solution);
+                  for (unsigned int i=0; i<dim; i++)
+                    for (unsigned int j=0; j<dim; j++)
+                      {
+                        history_stress_on_vertices[i][j](dof_1_vertex) +=
+                          local_history_stress_fe_values[i][j](v);
+                      }
 
-    // Timoshenko beam
-    if (base_mesh == "Timoshenko beam")
-    {
-       const double length = .48,
-                                                        depth  = .12;
-
-       Point<dim> intersted_point(length, -depth/2);
-       Point<dim> vertex_displacement;
-       bool vertex_found = false;
-
-      for (typename DoFHandler<dim>::active_cell_iterator cell =
-             dof_handler.begin_active();
-           cell != dof_handler.end(); ++cell)
-        if (cell->is_locally_owned() && !vertex_found)
-          for (unsigned int v = 0; v < GeometryInfo<dim>::vertices_per_cell; ++v)
-            if ( std::fabs(cell->vertex(v)[0] - intersted_point[0])<1e-6 &&
-                        std::fabs(cell->vertex(v)[1] - intersted_point[1])<1e-6)
-              {
-                       vertex_found = true;
+                }
+            }
 
-                for (unsigned int d = 0; d < dim; ++d)
-                  vertex_displacement[d] = solution(cell->vertex_dof_index(v, d));
+        for (unsigned int id=0; id<dof_handler_1.n_dofs(); ++id)
+          {
+            for (unsigned int i=0; i<dim; i++)
+              for (unsigned int j=0; j<dim; j++)
+                {
+                  history_stress_on_vertices[i][j](id) /= counter_on_vertices(id);
+                }
+          }
 
-                break;
-              }
 
-      pcout << "   Number of active cells: "
-            << triangulation.n_global_active_cells() << std::endl
-            << "   Number of degrees of freedom: " << dof_handler.n_dofs()
-            << std::endl;
+        {
+          DataOut<dim>  data_out;
+          data_out.attach_dof_handler (dof_handler_1);
 
-      AssertThrow(vertex_found, ExcInternalError());
-      std::cout << "Displacement at the point (" << intersted_point[0]
-                << ", " << intersted_point[1] << ") is "
-                << "(" << vertex_displacement[0]
-                << ", " << vertex_displacement[1] << ").\n";
 
-      Vector<double> vertex_exact_displacement(dim);
-      EquationData::IncrementalBoundaryValues<dim> incremental_boundary_values(present_time, end_time);
-      incremental_boundary_values.vector_value (intersted_point, vertex_exact_displacement);
+          data_out.add_data_vector (history_stress_on_vertices[0][0], "stress_rr_averaged");
+          data_out.add_data_vector (history_stress_on_vertices[1][1], "stress_tt_averaged");
+          data_out.add_data_vector (history_stress_on_vertices[0][1], "stress_rt_averaged");
 
-      std::cout << "Exact displacement at the point (" << intersted_point[0]
-                << ", " << intersted_point[1] << ") is "
-                << "(" << vertex_exact_displacement[0]
-                << ", " << vertex_exact_displacement[1] << ").\n\n";
+          data_out.build_patches ();
 
-    }else if (base_mesh == "Thick_tube_internal_pressure")
-    {
-       const double pressure (0.6*2.4e8),
-                                                        inner_radius (.1);
-//     const double pressure (1.94e8),
-//                                                      inner_radius (.1);
+          const std::string filename_base_stress = ("averaged-stress-polar-" + filename_base);
 
+          const std::string filename =
+            (output_dir + filename_base_stress + "-"
+             + Utilities::int_to_string(triangulation.locally_owned_subdomain(), 4));
 
-      // Plane stress
-//      const double mu (((e_modulus*(1+2*nu)) / (std::pow((1+nu),2))) / (2 * (1 + (nu / (1+nu)))));
-      // 3d and plane strain
-      const double mu (e_modulus / (2 * (1 + nu)));
-
-      const Point<dim> point_A(inner_radius, 0.);
-      Vector<double>    disp_A(dim);
-
-               // make a non-parallel copy of solution
-               Vector<double> copy_solution(solution);
-
-               typename Evaluation::PointValuesEvaluation<dim>::
-               PointValuesEvaluation point_values_evaluation(point_A);
-
-               point_values_evaluation.compute (dof_handler, copy_solution, disp_A);
-
-       table_results.add_value("time step", timestep_no);
-       table_results.add_value("Cells", triangulation.n_global_active_cells());
-       table_results.add_value("DoFs", dof_handler.n_dofs());
-       table_results.add_value("pressure/sigma_0", (pressure*present_time/end_time)/sigma_0);
-       table_results.add_value("4*mu*u_A/(sigma_0*a)", 4*mu*disp_A(0)/(sigma_0*inner_radius));
-
-       // Compute stresses in the POLAR coordinates, 1- save it on Gauss points,
-       // 2- extrapolate them to nodes and taking their avarages (nodal avaraging)
-       AssertThrow (dim == 2, ExcNotImplemented());
-
-       // we define a rotation matrix to be able to transform the stress
-       // from the Cartesian coordinate to the polar coordinate
-       Tensor<2, dim> rotation_matrix; // [cos sin; -sin cos]    , sigma_r = rot * sigma * rot^T
-
-       FEValues<dim> fe_values (fe, quadrature_formula, update_quadrature_points |
-                                                                                                        update_values | update_gradients);
-
-       const unsigned int n_q_points = quadrature_formula.size();
-
-       std::vector<SymmetricTensor<2, dim> > strain_tensor(n_q_points);
-       SymmetricTensor<4, dim> stress_strain_tensor;
-       Tensor<2, dim>  stress_at_qpoint;
-
-       FE_DGQ<dim> history_fe (1);
-       DoFHandler<dim> history_dof_handler (triangulation);
-       history_dof_handler.distribute_dofs (history_fe);
-       std::vector< std::vector< Vector<double> > >
-                                       history_stress_field (dim, std::vector< Vector<double> >(dim)),
-                                       local_history_stress_values_at_qpoints (dim, std::vector< Vector<double> >(dim)),
-                                       local_history_stress_fe_values (dim, std::vector< Vector<double> >(dim));
-       for (unsigned int i=0; i<dim; i++)
-               for (unsigned int j=0; j<dim; j++)
-               {
-                       history_stress_field[i][j].reinit(history_dof_handler.n_dofs());
-                       local_history_stress_values_at_qpoints[i][j].reinit(quadrature_formula.size());
-                       local_history_stress_fe_values[i][j].reinit(history_fe.dofs_per_cell);
-               }
-
-       FullMatrix<double> qpoint_to_dof_matrix (history_fe.dofs_per_cell,
-                                                                                                                                                                        quadrature_formula.size());
-       FETools::compute_projection_from_quadrature_points_matrix
-                                               (history_fe,
-                                                quadrature_formula, quadrature_formula,
-                                                qpoint_to_dof_matrix);
-
-       typename DoFHandler<dim>::active_cell_iterator
-                       cell = dof_handler.begin_active(),
-                       endc = dof_handler.end(),
-                       dg_cell = history_dof_handler.begin_active();
-
-       const FEValuesExtractors::Vector displacement(0);
-
-       for (; cell!=endc; ++cell, ++dg_cell)
-               if (cell->is_locally_owned())
-                       {
-                               PointHistory<dim> *local_quadrature_points_history
-                                               = reinterpret_cast<PointHistory<dim> *>(cell->user_pointer());
-                               Assert (local_quadrature_points_history >=
-                                                               &quadrature_point_history.front(),
-                                                               ExcInternalError());
-                               Assert (local_quadrature_points_history <
-                                                               &quadrature_point_history.back(),
-                                                               ExcInternalError());
-
-                       // Then loop over the quadrature points of this cell:
-                       for (unsigned int q=0; q<quadrature_formula.size(); ++q)
-                       {
-                               stress_at_qpoint = local_quadrature_points_history[q].old_stress;
-
-                               // transform the stress from the Cartesian coordinate to the polar coordinate
-                               const Point<dim> point = local_quadrature_points_history[q].point;
-                                               const double radius = point.norm ();
-                                               const double theta = std::atan2(point(1),point(0));
-
-                                               // rotation matrix
-                                               rotation_matrix[0][0] = std::cos(theta);
-                                               rotation_matrix[0][1] = std::sin(theta);
-                                               rotation_matrix[1][0] = -std::sin(theta);
-                                               rotation_matrix[1][1] = std::cos(theta);
-
-                                               // stress in polar coordinate
-                                               stress_at_qpoint = rotation_matrix * stress_at_qpoint * transpose(rotation_matrix);
-
-                       for (unsigned int i=0; i<dim; i++)
-                               for (unsigned int j=i; j<dim; j++)
-                               {
-                                       local_history_stress_values_at_qpoints[i][j](q) = stress_at_qpoint[i][j];
-                               }
-
-                       }
-
-
-               for (unsigned int i=0; i<dim; i++)
-                       for (unsigned int j=i; j<dim; j++)
-                       {
-                               qpoint_to_dof_matrix.vmult (local_history_stress_fe_values[i][j],
-                                                                                                                                               local_history_stress_values_at_qpoints[i][j]);
-                               dg_cell->set_dof_values (local_history_stress_fe_values[i][j],
-                                                                                                                                                        history_stress_field[i][j]);
-                       }
-
-                       }
-
-       {
-                               DataOut<dim>    data_out;
-                               data_out.attach_dof_handler (history_dof_handler);
-
-
-                               data_out.add_data_vector (history_stress_field[0][0], "stress_rr");
-                               data_out.add_data_vector (history_stress_field[1][1], "stress_tt");
-                               data_out.add_data_vector (history_stress_field[0][1], "stress_rt");
-
-                               data_out.build_patches ();
-
-                               const std::string filename_base_stress = ("stress-polar-" + filename_base);
-
-                               const std::string filename =
-                                               (output_dir + filename_base_stress + "-"
-                                                               + Utilities::int_to_string(triangulation.locally_owned_subdomain(), 4));
-
-                               std::ofstream output_vtu((filename + ".vtu").c_str());
-                               data_out.write_vtu(output_vtu);
-                               pcout << output_dir + filename_base_stress << ".pvtu" << std::endl;
-
-                               if (this_mpi_process == 0)
-                               {
-                                       std::vector<std::string> filenames;
-                                       for (unsigned int i = 0; i < n_mpi_processes; ++i)
-                                               filenames.push_back(filename_base_stress + "-" +
-                                                               Utilities::int_to_string(i, 4) +
-                                                               ".vtu");
-
-                                       std::ofstream pvtu_master_output((output_dir + filename_base_stress + ".pvtu").c_str());
-                                       data_out.write_pvtu_record(pvtu_master_output, filenames);
-
-                                       std::ofstream visit_master_output((output_dir + filename_base_stress + ".visit").c_str());
-                                       data_out.write_visit_record(visit_master_output, filenames);
-                               }
-
-
-       }
-
-                       // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-       // construct a DoFHandler object based on FE_Q with 1 degree of freedom
-       // in order to compute stresses on nodes (by applying nodal averaging)
-       // Therefore, each vertex has one degree of freedom
-       FE_Q<dim>                                        fe_1 (1);
-      DoFHandler<dim>    dof_handler_1 (triangulation);
-      dof_handler_1.distribute_dofs (fe_1);
-
-      AssertThrow(dof_handler_1.n_dofs() == triangulation.n_vertices(),
-                                               ExcDimensionMismatch(dof_handler_1.n_dofs(),triangulation.n_vertices()));
-
-       std::vector< std::vector< Vector<double> > >
-                                       history_stress_on_vertices (dim, std::vector< Vector<double> >(dim));
-       for (unsigned int i=0; i<dim; i++)
-               for (unsigned int j=0; j<dim; j++)
-               {
-                       history_stress_on_vertices[i][j].reinit(dof_handler_1.n_dofs());
-               }
+          std::ofstream output_vtu((filename + ".vtu").c_str());
+          data_out.write_vtu(output_vtu);
+          pcout << output_dir + filename_base_stress << ".pvtu" << std::endl;
 
-       Vector<double>  counter_on_vertices (dof_handler_1.n_dofs());
-                       counter_on_vertices = 0;
+          if (this_mpi_process == 0)
+            {
+              std::vector<std::string> filenames;
+              for (unsigned int i = 0; i < n_mpi_processes; ++i)
+                filenames.push_back(filename_base_stress + "-" +
+                                    Utilities::int_to_string(i, 4) +
+                                    ".vtu");
 
-                       cell = dof_handler.begin_active();
-                       dg_cell = history_dof_handler.begin_active();
-                       typename DoFHandler<dim>::active_cell_iterator
-                                       cell_1 = dof_handler_1.begin_active();
-       for (; cell!=endc; ++cell, ++dg_cell, ++cell_1)
-               if (cell->is_locally_owned())
-               {
-
-               for (unsigned int i=0; i<dim; i++)
-                       for (unsigned int j=0; j<dim; j++)
-                       {
-                               dg_cell->get_dof_values (history_stress_field[i][j],
-                                                                                                                                local_history_stress_fe_values[i][j]);
-                       }
-
-                       for  (unsigned int v = 0; v < GeometryInfo<dim>::vertices_per_cell; ++v)
-                       {
-                               types::global_dof_index dof_1_vertex = cell_1->vertex_dof_index(v, 0);
-
-                               // begin check
-//                             Point<dim> point1, point2;
-//                             point1 = cell_1->vertex(v);
-//                             point2 = dg_cell->vertex(v);
-//                             AssertThrow(point1.distance(point2) < cell->diameter()*1e-8, ExcInternalError());
-                               // end check
-
-                               counter_on_vertices (dof_1_vertex) += 1;
-
-               for (unsigned int i=0; i<dim; i++)
-                       for (unsigned int j=0; j<dim; j++)
-                       {
-                               history_stress_on_vertices[i][j](dof_1_vertex) +=
-                                               local_history_stress_fe_values[i][j](v);
-                       }
-
-                       }
-               }
-
-       for (unsigned int id=0; id<dof_handler_1.n_dofs(); ++id)
-       {
-       for (unsigned int i=0; i<dim; i++)
-               for (unsigned int j=0; j<dim; j++)
-               {
-                       history_stress_on_vertices[i][j](id) /= counter_on_vertices(id);
-               }
-       }
-
-
-       {
-                               DataOut<dim>    data_out;
-                               data_out.attach_dof_handler (dof_handler_1);
-
-
-                               data_out.add_data_vector (history_stress_on_vertices[0][0], "stress_rr_averaged");
-                               data_out.add_data_vector (history_stress_on_vertices[1][1], "stress_tt_averaged");
-                               data_out.add_data_vector (history_stress_on_vertices[0][1], "stress_rt_averaged");
-
-                               data_out.build_patches ();
-
-                               const std::string filename_base_stress = ("averaged-stress-polar-" + filename_base);
-
-                               const std::string filename =
-                                               (output_dir + filename_base_stress + "-"
-                                                               + Utilities::int_to_string(triangulation.locally_owned_subdomain(), 4));
-
-                               std::ofstream output_vtu((filename + ".vtu").c_str());
-                               data_out.write_vtu(output_vtu);
-                               pcout << output_dir + filename_base_stress << ".pvtu" << std::endl;
-
-                               if (this_mpi_process == 0)
-                               {
-                                       std::vector<std::string> filenames;
-                                       for (unsigned int i = 0; i < n_mpi_processes; ++i)
-                                               filenames.push_back(filename_base_stress + "-" +
-                                                               Utilities::int_to_string(i, 4) +
-                                                               ".vtu");
-
-                                       std::ofstream pvtu_master_output((output_dir + filename_base_stress + ".pvtu").c_str());
-                                       data_out.write_pvtu_record(pvtu_master_output, filenames);
-
-                                       std::ofstream visit_master_output((output_dir + filename_base_stress + ".visit").c_str());
-                                       data_out.write_visit_record(visit_master_output, filenames);
-                               }
-
-
-       }
-                       // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-       if ( std::abs( (present_time/end_time)*(pressure/sigma_0) - 0.6 ) <
-                                                                       .501*(present_timestep/end_time)*(pressure/sigma_0) )
-       {
-
-               // table_results_2: presenting the stress_rr and stress_tt on the nodes of bottom edge
-               const unsigned int face_id = 3;
-
-       std::vector<bool>       vertices_found (dof_handler_1.n_dofs(), false);
-
-       bool evaluation_face_found = false;
-
-       typename DoFHandler<dim>::active_cell_iterator
-       cell = dof_handler.begin_active(),
-       endc = dof_handler.end(),
-       cell_1 = dof_handler_1.begin_active();
-       for (; cell!=endc; ++cell, ++cell_1)
-               if (cell->is_locally_owned())
-               {
-                       for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
-                       {
-                               if (cell->face(face)->at_boundary()
-                                               &&
-                                               cell->face(face)->boundary_indicator() == face_id)
-                               {
-                                       if (!evaluation_face_found)
-                                       {
-                                               evaluation_face_found = true;
-                                       }
+              std::ofstream pvtu_master_output((output_dir + filename_base_stress + ".pvtu").c_str());
+              data_out.write_pvtu_record(pvtu_master_output, filenames);
 
+              std::ofstream visit_master_output((output_dir + filename_base_stress + ".visit").c_str());
+              data_out.write_visit_record(visit_master_output, filenames);
+            }
 
-                                       for (unsigned int v = 0; v < GeometryInfo<dim>::vertices_per_face; ++v)
-                                       {
-                                               types::global_dof_index dof_1_vertex =
-                                                               cell_1->face(face)->vertex_dof_index(v, 0);
-                                               if (!vertices_found[dof_1_vertex])
-                                               {
 
-                                                       const Point<dim> vertex_coordinate = cell_1->face(face)->vertex(v);
+        }
+        // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
-                                               table_results_2.add_value("x coordinate", vertex_coordinate[0]);
-                                               table_results_2.add_value("stress_rr", history_stress_on_vertices[0][0](dof_1_vertex));
-                                               table_results_2.add_value("stress_tt", history_stress_on_vertices[1][1](dof_1_vertex));
-                               table_results_2.add_value("pressure/sigma_0", (pressure*present_time/end_time)/sigma_0);
+        if ( std::abs( (present_time/end_time)*(pressure/sigma_0) - 0.6 ) <
+             .501*(present_timestep/end_time)*(pressure/sigma_0) )
+          {
 
-                                                                               vertices_found[dof_1_vertex] = true;
-                                               }
-                                       }
+            // table_results_2: presenting the stress_rr and stress_tt on the nodes of bottom edge
+            const unsigned int face_id = 3;
 
-                               }
-                       }
+            std::vector<bool> vertices_found (dof_handler_1.n_dofs(), false);
 
-               }
+            bool evaluation_face_found = false;
 
-       AssertThrow(evaluation_face_found, ExcInternalError());
+            typename DoFHandler<dim>::active_cell_iterator
+            cell = dof_handler.begin_active(),
+            endc = dof_handler.end(),
+            cell_1 = dof_handler_1.begin_active();
+            for (; cell!=endc; ++cell, ++cell_1)
+              if (cell->is_locally_owned())
+                {
+                  for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
+                    {
+                      if (cell->face(face)->at_boundary()
+                          &&
+                          cell->face(face)->boundary_indicator() == face_id)
+                        {
+                          if (!evaluation_face_found)
+                            {
+                              evaluation_face_found = true;
+                            }
+
+
+                          for (unsigned int v = 0; v < GeometryInfo<dim>::vertices_per_face; ++v)
+                            {
+                              types::global_dof_index dof_1_vertex =
+                                cell_1->face(face)->vertex_dof_index(v, 0);
+                              if (!vertices_found[dof_1_vertex])
+                                {
+
+                                  const Point<dim> vertex_coordinate = cell_1->face(face)->vertex(v);
+
+                                  table_results_2.add_value("x coordinate", vertex_coordinate[0]);
+                                  table_results_2.add_value("stress_rr", history_stress_on_vertices[0][0](dof_1_vertex));
+                                  table_results_2.add_value("stress_tt", history_stress_on_vertices[1][1](dof_1_vertex));
+                                  table_results_2.add_value("pressure/sigma_0", (pressure*present_time/end_time)/sigma_0);
+
+                                  vertices_found[dof_1_vertex] = true;
+                                }
+                            }
+
+                        }
+                    }
 
-       // table_results_3: presenting the mean stress_rr of the nodes on the inner radius
-       const unsigned int face_id_2 = 0;
+                }
 
-       Tensor<2, dim> stress_node,
-                                                                mean_stress_polar;
-       mean_stress_polar = 0;
+            AssertThrow(evaluation_face_found, ExcInternalError());
 
-       std::vector<bool>       vertices_found_2 (dof_handler_1.n_dofs(), false);
-       unsigned int no_vertices_found = 0;
+            // table_results_3: presenting the mean stress_rr of the nodes on the inner radius
+            const unsigned int face_id_2 = 0;
 
-       evaluation_face_found = false;
+            Tensor<2, dim> stress_node,
+                   mean_stress_polar;
+            mean_stress_polar = 0;
 
-       cell = dof_handler.begin_active(),
-       endc = dof_handler.end(),
-       cell_1 = dof_handler_1.begin_active();
-       for (; cell!=endc; ++cell, ++cell_1)
-               if (cell->is_locally_owned())
-               {
-                       for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
-                       {
-                               if (cell->face(face)->at_boundary()
-                                               &&
-                                               cell->face(face)->boundary_indicator() == face_id_2)
-                               {
-                                       if (!evaluation_face_found)
-                                       {
-                                               evaluation_face_found = true;
-                                       }
+            std::vector<bool> vertices_found_2 (dof_handler_1.n_dofs(), false);
+            unsigned int no_vertices_found = 0;
 
+            evaluation_face_found = false;
 
-                                       for (unsigned int v = 0; v < GeometryInfo<dim>::vertices_per_face; ++v)
-                                       {
-                                               types::global_dof_index dof_1_vertex =
-                                                               cell_1->face(face)->vertex_dof_index(v, 0);
-                                               if (!vertices_found_2[dof_1_vertex])
-                                               {
-                                                       for (unsigned int ir=0; ir<dim; ++ir)
-                                                               for (unsigned int ic=0; ic<dim; ++ic)
-                                                                       stress_node[ir][ic] = history_stress_on_vertices[ir][ic](dof_1_vertex);
+            cell = dof_handler.begin_active(),
+            endc = dof_handler.end(),
+            cell_1 = dof_handler_1.begin_active();
+            for (; cell!=endc; ++cell, ++cell_1)
+              if (cell->is_locally_owned())
+                {
+                  for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
+                    {
+                      if (cell->face(face)->at_boundary()
+                          &&
+                          cell->face(face)->boundary_indicator() == face_id_2)
+                        {
+                          if (!evaluation_face_found)
+                            {
+                              evaluation_face_found = true;
+                            }
+
+
+                          for (unsigned int v = 0; v < GeometryInfo<dim>::vertices_per_face; ++v)
+                            {
+                              types::global_dof_index dof_1_vertex =
+                                cell_1->face(face)->vertex_dof_index(v, 0);
+                              if (!vertices_found_2[dof_1_vertex])
+                                {
+                                  for (unsigned int ir=0; ir<dim; ++ir)
+                                    for (unsigned int ic=0; ic<dim; ++ic)
+                                      stress_node[ir][ic] = history_stress_on_vertices[ir][ic](dof_1_vertex);
+
+                                  mean_stress_polar += stress_node;
+
+                                  vertices_found_2[dof_1_vertex] = true;
+                                  ++no_vertices_found;
+                                }
+                            }
+
+                        }
+                    }
 
-                                                       mean_stress_polar += stress_node;
+                }
 
-                                                                               vertices_found_2[dof_1_vertex] = true;
-                                                                               ++no_vertices_found;
-                                               }
-                                       }
+            AssertThrow(evaluation_face_found, ExcInternalError());
 
-                               }
-                       }
-
-               }
+            mean_stress_polar /= no_vertices_found;
 
-       AssertThrow(evaluation_face_found, ExcInternalError());
-
-       mean_stress_polar /= no_vertices_found;
-
-       table_results_3.add_value("time step", timestep_no);
-               table_results_3.add_value("pressure/sigma_0", (pressure*present_time/end_time)/sigma_0);
-       table_results_3.add_value("Cells", triangulation.n_global_active_cells());
-       table_results_3.add_value("DoFs", dof_handler.n_dofs());
-                               table_results_3.add_value("radius", inner_radius);
-                               table_results_3.add_value("mean stress_rr", mean_stress_polar[0][0]);
-                               table_results_3.add_value("mean stress_tt", mean_stress_polar[1][1]);
+            table_results_3.add_value("time step", timestep_no);
+            table_results_3.add_value("pressure/sigma_0", (pressure*present_time/end_time)/sigma_0);
+            table_results_3.add_value("Cells", triangulation.n_global_active_cells());
+            table_results_3.add_value("DoFs", dof_handler.n_dofs());
+            table_results_3.add_value("radius", inner_radius);
+            table_results_3.add_value("mean stress_rr", mean_stress_polar[0][0]);
+            table_results_3.add_value("mean stress_tt", mean_stress_polar[1][1]);
 
 
-       }
+          }
 
 
-    }else if (base_mesh == "Perforated_strip_tension")
-    {
-       const double imposed_displacement (0.00055),
-                                                        inner_radius (0.05),
-                                                                        height (0.18);
+      }
+    else if (base_mesh == "Perforated_strip_tension")
+      {
+        const double imposed_displacement (0.00055),
+              inner_radius (0.05),
+              height (0.18);
 
-      // Plane stress
+        // Plane stress
 //      const double mu (((e_modulus*(1+2*nu)) / (std::pow((1+nu),2))) / (2 * (1 + (nu / (1+nu)))));
-      // 3d and plane strain
-      const double mu (e_modulus / (2 * (1 + nu)));
-
-      // table_results: Demonstrates the result of displacement at the top left corner versus imposed tension
-      /*
-      {
-       const Point<dim> point_C(0., height);
-       Vector<double>   disp_C(dim);
+        // 3d and plane strain
+        const double mu (e_modulus / (2 * (1 + nu)));
 
-       // make a non-parallel copy of solution
-       Vector<double> copy_solution(solution);
+        // table_results: Demonstrates the result of displacement at the top left corner versus imposed tension
+        /*
+        {
+          const Point<dim> point_C(0., height);
+          Vector<double>   disp_C(dim);
 
-       typename Evaluation::PointValuesEvaluation<dim>::
-       PointValuesEvaluation point_values_evaluation(point_C);
+          // make a non-parallel copy of solution
+          Vector<double> copy_solution(solution);
 
-       point_values_evaluation.compute (dof_handler, copy_solution, disp_C);
+          typename Evaluation::PointValuesEvaluation<dim>::
+          PointValuesEvaluation point_values_evaluation(point_C);
 
-       table_results.add_value("time step", timestep_no);
-       table_results.add_value("Cells", triangulation.n_global_active_cells());
-       table_results.add_value("DoFs", dof_handler.n_dofs());
-       table_results.add_value("4*mu*u_C/(sigma_0*r)", 4*mu*disp_C(1)/(sigma_0*inner_radius));
-      }
-      */
+          point_values_evaluation.compute (dof_handler, copy_solution, disp_C);
 
-      // compute average sigma_yy on the bottom edge
-       double stress_yy_av;
-       {
-               stress_yy_av = 0;
-               const unsigned int face_id = 1;
+          table_results.add_value("time step", timestep_no);
+          table_results.add_value("Cells", triangulation.n_global_active_cells());
+          table_results.add_value("DoFs", dof_handler.n_dofs());
+          table_results.add_value("4*mu*u_C/(sigma_0*r)", 4*mu*disp_C(1)/(sigma_0*inner_radius));
+        }
+        */
 
-       std::vector<bool>       vertices_found (dof_handler_1.n_dofs(), false);
-       unsigned int no_vertices_in_face = 0;
+        // compute average sigma_yy on the bottom edge
+        double stress_yy_av;
+        {
+          stress_yy_av = 0;
+          const unsigned int face_id = 1;
 
-       bool evaluation_face_found = false;
+          std::vector<bool> vertices_found (dof_handler_1.n_dofs(), false);
+          unsigned int no_vertices_in_face = 0;
 
-       typename DoFHandler<dim>::active_cell_iterator
-       cell = dof_handler.begin_active(),
-       endc = dof_handler.end(),
-       cell_1 = dof_handler_1.begin_active();
-       for (; cell!=endc; ++cell, ++cell_1)
-               if (cell->is_locally_owned())
-               {
-                       for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
-                       {
-                               if (cell->face(face)->at_boundary()
-                                               &&
-                                               cell->face(face)->boundary_indicator() == face_id)
-                               {
-                                       if (!evaluation_face_found)
-                                       {
-                                               evaluation_face_found = true;
-                                       }
+          bool evaluation_face_found = false;
 
+          typename DoFHandler<dim>::active_cell_iterator
+          cell = dof_handler.begin_active(),
+          endc = dof_handler.end(),
+          cell_1 = dof_handler_1.begin_active();
+          for (; cell!=endc; ++cell, ++cell_1)
+            if (cell->is_locally_owned())
+              {
+                for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
+                  {
+                    if (cell->face(face)->at_boundary()
+                        &&
+                        cell->face(face)->boundary_indicator() == face_id)
+                      {
+                        if (!evaluation_face_found)
+                          {
+                            evaluation_face_found = true;
+                          }
+
+
+                        for (unsigned int v = 0; v < GeometryInfo<dim>::vertices_per_face; ++v)
+                          {
+                            types::global_dof_index dof_1_vertex =
+                              cell_1->face(face)->vertex_dof_index(v, 0);
+                            if (!vertices_found[dof_1_vertex])
+                              {
+                                stress_yy_av += history_stress_on_vertices[1][1](dof_1_vertex);
+                                ++no_vertices_in_face;
+
+                                vertices_found[dof_1_vertex] = true;
+                              }
+                          }
+
+                      }
+                  }
 
-                                       for (unsigned int v = 0; v < GeometryInfo<dim>::vertices_per_face; ++v)
-                                       {
-                                               types::global_dof_index dof_1_vertex =
-                                                               cell_1->face(face)->vertex_dof_index(v, 0);
-                                               if (!vertices_found[dof_1_vertex])
-                                               {
-                                                       stress_yy_av += history_stress_on_vertices[1][1](dof_1_vertex);
-                                                       ++no_vertices_in_face;
+              }
 
-                                                                               vertices_found[dof_1_vertex] = true;
-                                               }
-                                       }
+          AssertThrow(evaluation_face_found, ExcInternalError());
 
-                               }
-                       }
+          stress_yy_av /= no_vertices_in_face;
 
-               }
+        }
 
-       AssertThrow(evaluation_face_found, ExcInternalError());
+        // table_results_2: Demonstrate the stress_yy on the nodes of bottom edge
 
-       stress_yy_av /= no_vertices_in_face;
+//      if ( std::abs( (stress_yy_av/sigma_0) - .91 ) < .2 )
+        if ( (timestep_no) % 19 == 0 )
+//      if ( true )
+          {
+            const unsigned int face_id = 1;
 
-       }
+            std::vector<bool> vertices_found (dof_handler_1.n_dofs(), false);
 
-      // table_results_2: Demonstrate the stress_yy on the nodes of bottom edge
+            bool evaluation_face_found = false;
 
-//      if ( std::abs( (stress_yy_av/sigma_0) - .91 ) < .2 )
-      if ( (timestep_no) % 19 == 0 )
-//     if ( true )
-      {
-               const unsigned int face_id = 1;
-
-       std::vector<bool>       vertices_found (dof_handler_1.n_dofs(), false);
-
-       bool evaluation_face_found = false;
-
-       typename DoFHandler<dim>::active_cell_iterator
-       cell = dof_handler.begin_active(),
-       endc = dof_handler.end(),
-       cell_1 = dof_handler_1.begin_active();
-       for (; cell!=endc; ++cell, ++cell_1)
-               if (cell->is_locally_owned())
-               {
-                       for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
-                       {
-                               if (cell->face(face)->at_boundary()
-                                               &&
-                                               cell->face(face)->boundary_indicator() == face_id)
-                               {
-                                       if (!evaluation_face_found)
-                                       {
-                                               evaluation_face_found = true;
-                                       }
-
-
-                                       for (unsigned int v = 0; v < GeometryInfo<dim>::vertices_per_face; ++v)
-                                       {
-                                               types::global_dof_index dof_1_vertex =
-                                                               cell_1->face(face)->vertex_dof_index(v, 0);
-
-                                               const Point<dim> vertex_coordinate = cell_1->face(face)->vertex(v);
-
-                                               if (!vertices_found[dof_1_vertex] && std::abs(vertex_coordinate[2])<1.e-8)
-                                               {
-                                                       table_results_2.add_value("x", vertex_coordinate[0]);
-                                               table_results_2.add_value("x/r", vertex_coordinate[0]/inner_radius);
-                                               table_results_2.add_value("stress_xx/sigma_0", history_stress_on_vertices[0][0](dof_1_vertex)/sigma_0);
-                                               table_results_2.add_value("stress_yy/sigma_0", history_stress_on_vertices[1][1](dof_1_vertex)/sigma_0);
-                               table_results_2.add_value("stress_yy_av/sigma_0", stress_yy_av/sigma_0);
-                       table_results_2.add_value("Imposed u_y", (imposed_displacement*present_time/end_time));
-
-                                                                               vertices_found[dof_1_vertex] = true;
-                                               }
-                                       }
-
-                               }
-                       }
-
-               }
-
-       AssertThrow(evaluation_face_found, ExcInternalError());
+            typename DoFHandler<dim>::active_cell_iterator
+            cell = dof_handler.begin_active(),
+            endc = dof_handler.end(),
+            cell_1 = dof_handler_1.begin_active();
+            for (; cell!=endc; ++cell, ++cell_1)
+              if (cell->is_locally_owned())
+                {
+                  for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
+                    {
+                      if (cell->face(face)->at_boundary()
+                          &&
+                          cell->face(face)->boundary_indicator() == face_id)
+                        {
+                          if (!evaluation_face_found)
+                            {
+                              evaluation_face_found = true;
+                            }
+
+
+                          for (unsigned int v = 0; v < GeometryInfo<dim>::vertices_per_face; ++v)
+                            {
+                              types::global_dof_index dof_1_vertex =
+                                cell_1->face(face)->vertex_dof_index(v, 0);
+
+                              const Point<dim> vertex_coordinate = cell_1->face(face)->vertex(v);
+
+                              if (!vertices_found[dof_1_vertex] && std::abs(vertex_coordinate[2])<1.e-8)
+                                {
+                                  table_results_2.add_value("x", vertex_coordinate[0]);
+                                  table_results_2.add_value("x/r", vertex_coordinate[0]/inner_radius);
+                                  table_results_2.add_value("stress_xx/sigma_0", history_stress_on_vertices[0][0](dof_1_vertex)/sigma_0);
+                                  table_results_2.add_value("stress_yy/sigma_0", history_stress_on_vertices[1][1](dof_1_vertex)/sigma_0);
+                                  table_results_2.add_value("stress_yy_av/sigma_0", stress_yy_av/sigma_0);
+                                  table_results_2.add_value("Imposed u_y", (imposed_displacement*present_time/end_time));
+
+                                  vertices_found[dof_1_vertex] = true;
+                                }
+                            }
+
+                        }
+                    }
 
-      }
+                }
 
-      // table_results_3: Demonstrate the Stress_mean (average tensile stress)
-      //  on the bottom edge versus epsilon_yy on the bottom left corner
-      {
-       double strain_yy_A;
+            AssertThrow(evaluation_face_found, ExcInternalError());
 
-       // compute strain_yy_A
-       // Since the point A is the node on the bottom left corner,
-       // we need to work just with one element
-       {
-               const Point<dim> point_A(inner_radius, 0, 0);
+          }
 
-          Vector<double>       local_strain_yy_values_at_qpoints (quadrature_formula.size()),
-                                                                       local_strain_yy_fe_values (history_fe.dofs_per_cell);
+        // table_results_3: Demonstrate the Stress_mean (average tensile stress)
+        //  on the bottom edge versus epsilon_yy on the bottom left corner
+        {
+          double strain_yy_A;
 
-          SymmetricTensor<2, dim> strain_at_qpoint;
+          // compute strain_yy_A
+          // Since the point A is the node on the bottom left corner,
+          // we need to work just with one element
+          {
+            const Point<dim> point_A(inner_radius, 0, 0);
 
-          typename DoFHandler<dim>::active_cell_iterator
-          cell = dof_handler.begin_active(),
-          endc = dof_handler.end(),
-          dg_cell = history_dof_handler.begin_active();
+            Vector<double>  local_strain_yy_values_at_qpoints (quadrature_formula.size()),
+                   local_strain_yy_fe_values (history_fe.dofs_per_cell);
 
-               bool cell_found = false;
+            SymmetricTensor<2, dim> strain_at_qpoint;
 
-          for (; cell!=endc; ++cell, ++dg_cell)
-               if (cell->is_locally_owned() && !cell_found)
-               {
-              for (unsigned int v = 0; v < GeometryInfo<dim>::vertices_per_cell; ++v)
-                if ( std::fabs(cell->vertex(v)[0] - point_A[0])<1e-6 &&
-                                std::fabs(cell->vertex(v)[1] - point_A[1])<1e-6 &&
-                                std::fabs(cell->vertex(v)[2] - point_A[2])<1e-6)
-                  {
-                                                                               PointHistory<dim> *local_quadrature_points_history
-                                                                               = reinterpret_cast<PointHistory<dim> *>(cell->user_pointer());
-                                                                               Assert (local_quadrature_points_history >=
-                                                                                               &quadrature_point_history.front(),
-                                                                                               ExcInternalError());
-                                                                               Assert (local_quadrature_points_history <
-                                                                                               &quadrature_point_history.back(),
-                                                                                               ExcInternalError());
+            typename DoFHandler<dim>::active_cell_iterator
+            cell = dof_handler.begin_active(),
+            endc = dof_handler.end(),
+            dg_cell = history_dof_handler.begin_active();
 
-                                                                               // Then loop over the quadrature points of this cell:
-                                                                               for (unsigned int q=0; q<quadrature_formula.size(); ++q)
-                                                                               {
-                                                                                       strain_at_qpoint = local_quadrature_points_history[q].old_strain;
+            bool cell_found = false;
 
-                                                                                       local_strain_yy_values_at_qpoints(q) = strain_at_qpoint[1][1];
-                                                                               }
+            for (; cell!=endc; ++cell, ++dg_cell)
+              if (cell->is_locally_owned() && !cell_found)
+                {
+                  for (unsigned int v = 0; v < GeometryInfo<dim>::vertices_per_cell; ++v)
+                    if ( std::fabs(cell->vertex(v)[0] - point_A[0])<1e-6 &&
+                         std::fabs(cell->vertex(v)[1] - point_A[1])<1e-6 &&
+                         std::fabs(cell->vertex(v)[2] - point_A[2])<1e-6)
+                      {
+                        PointHistory<dim> *local_quadrature_points_history
+                          = reinterpret_cast<PointHistory<dim> *>(cell->user_pointer());
+                        Assert (local_quadrature_points_history >=
+                                &quadrature_point_history.front(),
+                                ExcInternalError());
+                        Assert (local_quadrature_points_history <
+                                &quadrature_point_history.back(),
+                                ExcInternalError());
+
+                        // Then loop over the quadrature points of this cell:
+                        for (unsigned int q=0; q<quadrature_formula.size(); ++q)
+                          {
+                            strain_at_qpoint = local_quadrature_points_history[q].old_strain;
+
+                            local_strain_yy_values_at_qpoints(q) = strain_at_qpoint[1][1];
+                          }
+
+                        qpoint_to_dof_matrix.vmult (local_strain_yy_fe_values,
+                                                    local_strain_yy_values_at_qpoints);
+
+                        strain_yy_A = local_strain_yy_fe_values (v);
+
+                        cell_found = true;
+                        break;
+                      }
 
-                                                                               qpoint_to_dof_matrix.vmult (local_strain_yy_fe_values,
-                                                                                                                                                                                               local_strain_yy_values_at_qpoints);
+                }
 
-                                                               strain_yy_A = local_strain_yy_fe_values (v);
+          }
 
-                               cell_found = true;
-                    break;
-                  }
+          table_results_3.add_value("time step", timestep_no);
+          table_results_3.add_value("Cells", triangulation.n_global_active_cells());
+          table_results_3.add_value("DoFs", dof_handler.n_dofs());
+          table_results_3.add_value("Imposed u_y", (imposed_displacement*present_time/end_time));
+          table_results_3.add_value("mean_tensile_stress/sigma_0", stress_yy_av/sigma_0);
+          table_results_3.add_value("E*strain_yy-A/sigma_0", e_modulus*strain_yy_A/sigma_0);
 
-               }
+        }
 
-       }
 
-       table_results_3.add_value("time step", timestep_no);
-       table_results_3.add_value("Cells", triangulation.n_global_active_cells());
-       table_results_3.add_value("DoFs", dof_handler.n_dofs());
-       table_results_3.add_value("Imposed u_y", (imposed_displacement*present_time/end_time));
-       table_results_3.add_value("mean_tensile_stress/sigma_0", stress_yy_av/sigma_0);
-       table_results_3.add_value("E*strain_yy-A/sigma_0", e_modulus*strain_yy_A/sigma_0);
+        if (std::abs(present_time-end_time) < 1.e-7)
+          {
+            table_results_2.set_precision("Imposed u_y", 6);
+            table_results_3.set_precision("Imposed u_y", 6);
+          }
 
       }
+    else if (base_mesh == "Cantiliver_beam_3d")
+      {
+        const double pressure (6e6),
+              length (.7),
+              height (200e-3);
 
+        // table_results: Demonstrates the result of displacement at the top front point, Point A
+        {
+          // Quantity of interest:
+          // displacement at Point A (x=0, y=height/2, z=length)
 
-       if (std::abs(present_time-end_time) < 1.e-7)
-       {
-               table_results_2.set_precision("Imposed u_y", 6);
-               table_results_3.set_precision("Imposed u_y", 6);
-       }
+          const Point<dim> point_A(0, height/2, length);
+          Vector<double>   disp_A(dim);
 
-    }else if (base_mesh == "Cantiliver_beam_3d")
-    {
-       const double pressure (6e6),
-                                                        length (.7),
-                                                        height (200e-3);
+          // make a non-parallel copy of solution
+          Vector<double> copy_solution(solution);
 
-      // table_results: Demonstrates the result of displacement at the top front point, Point A
-      {
-                        // Quantity of interest:
-                        // displacement at Point A (x=0, y=height/2, z=length)
+          typename Evaluation::PointValuesEvaluation<dim>::
+          PointValuesEvaluation point_values_evaluation(point_A);
 
-               const Point<dim> point_A(0, height/2, length);
-       Vector<double>   disp_A(dim);
+          point_values_evaluation.compute (dof_handler, copy_solution, disp_A);
 
-       // make a non-parallel copy of solution
-       Vector<double> copy_solution(solution);
+          table_results.add_value("time step", timestep_no);
+          table_results.add_value("Cells", triangulation.n_global_active_cells());
+          table_results.add_value("DoFs", dof_handler.n_dofs());
+          table_results.add_value("pressure", pressure*present_time/end_time);
+          table_results.add_value("u_A", disp_A(1));
+        }
 
-       typename Evaluation::PointValuesEvaluation<dim>::
-       PointValuesEvaluation point_values_evaluation(point_A);
+        {
+          // demonstrate the location and maximum von-Mises stress in the
+          // specified domain close to the clamped face, z = 0
+          // top domain: height/2 - thickness_flange <= y <= height/2
+          //             0 <= z <= 2 * thickness_flange
+          // bottom domain: -height/2 <= y <= -height/2 + thickness_flange
+          //             0 <= z <= 2 * thickness_flange
 
-       point_values_evaluation.compute (dof_handler, copy_solution, disp_A);
+          double VM_stress_max (0);
+          Point<dim> point_max;
 
-       table_results.add_value("time step", timestep_no);
-       table_results.add_value("Cells", triangulation.n_global_active_cells());
-       table_results.add_value("DoFs", dof_handler.n_dofs());
-               table_results.add_value("pressure", pressure*present_time/end_time);
-       table_results.add_value("u_A", disp_A(1));
-      }
+          SymmetricTensor<2, dim> stress_at_qpoint;
 
-      {
-       // demonstrate the location and maximum von-Mises stress in the
-       // specified domain close to the clamped face, z = 0
-       // top domain: height/2 - thickness_flange <= y <= height/2
-       //             0 <= z <= 2 * thickness_flange
-       // bottom domain: -height/2 <= y <= -height/2 + thickness_flange
-       //             0 <= z <= 2 * thickness_flange
+          typename DoFHandler<dim>::active_cell_iterator
+          cell = dof_handler.begin_active(),
+          endc = dof_handler.end();
 
-       double VM_stress_max (0);
-       Point<dim> point_max;
+          const FEValuesExtractors::Vector displacement(0);
 
-       SymmetricTensor<2, dim> stress_at_qpoint;
+          for (; cell!=endc; ++cell)
+            if (cell->is_locally_owned())
+              {
+                PointHistory<dim> *local_quadrature_points_history
+                  = reinterpret_cast<PointHistory<dim> *>(cell->user_pointer());
+                Assert (local_quadrature_points_history >=
+                        &quadrature_point_history.front(),
+                        ExcInternalError());
+                Assert (local_quadrature_points_history <
+                        &quadrature_point_history.back(),
+                        ExcInternalError());
+
+                // Then loop over the quadrature points of this cell:
+                for (unsigned int q=0; q<quadrature_formula.size(); ++q)
+                  {
+                    stress_at_qpoint = local_quadrature_points_history[q].old_stress;
 
-        typename DoFHandler<dim>::active_cell_iterator
-        cell = dof_handler.begin_active(),
-        endc = dof_handler.end();
+                    const double VM_stress = Evaluation::get_von_Mises_stress(stress_at_qpoint);
+                    if (VM_stress > VM_stress_max)
+                      {
+                        VM_stress_max = VM_stress;
+                        point_max = local_quadrature_points_history[q].point;
+                      }
 
-        const FEValuesExtractors::Vector displacement(0);
+                  }
+              }
 
-        for (; cell!=endc; ++cell)
-               if (cell->is_locally_owned())
-               {
-                       PointHistory<dim> *local_quadrature_points_history
-                       = reinterpret_cast<PointHistory<dim> *>(cell->user_pointer());
-                       Assert (local_quadrature_points_history >=
-                                                       &quadrature_point_history.front(),
-                                                       ExcInternalError());
-                       Assert (local_quadrature_points_history <
-                                                       &quadrature_point_history.back(),
-                                                       ExcInternalError());
-
-                       // Then loop over the quadrature points of this cell:
-                       for (unsigned int q=0; q<quadrature_formula.size(); ++q)
-                       {
-                               stress_at_qpoint = local_quadrature_points_history[q].old_stress;
-
-                               const double VM_stress = Evaluation::get_von_Mises_stress(stress_at_qpoint);
-                               if (VM_stress > VM_stress_max)
-                               {
-                                       VM_stress_max = VM_stress;
-                                       point_max = local_quadrature_points_history[q].point;
-                               }
-
-                       }
-               }
-
-       table_results.add_value("maximum von_Mises stress", VM_stress_max);
-       table_results.add_value("x", point_max[0]);
-       table_results.add_value("y", point_max[1]);
-       table_results.add_value("z", point_max[2]);
+          table_results.add_value("maximum von_Mises stress", VM_stress_max);
+          table_results.add_value("x", point_max[0]);
+          table_results.add_value("y", point_max[1]);
+          table_results.add_value("z", point_max[2]);
 
-      }
+        }
 
-    }
+      }
 
 
   }
@@ -7029,148 +7091,149 @@ namespace ElastoPlastic
   void
   ElastoPlasticProblem<dim>::run ()
   {
-       computing_timer.reset();
-
-       present_time = 0;
-       present_timestep = 1;
-       end_time = 10;
-       timestep_no = 0;
-
-       make_grid();
-
-       // ----------------------------------------------------------------
-       //      base_mesh == "Thick_tube_internal_pressure"
-       /*
-       const Point<dim> center(0, 0);
-       const double inner_radius = .1,
-                       outer_radius = .2;
-
-       const HyperBallBoundary<dim> inner_boundary_description(center, inner_radius);
-       triangulation.set_boundary (0, inner_boundary_description);
-
-       const HyperBallBoundary<dim> outer_boundary_description(center, outer_radius);
-       triangulation.set_boundary (1, outer_boundary_description);
-       */
-       // ----------------------------------------------------------------
-       //      base_mesh == "Perforated_strip_tension"
-       /*
-       const double inner_radius = 0.05;
-
-       const CylinderBoundary<dim> inner_boundary_description(inner_radius, 2);
-       triangulation.set_boundary (10, inner_boundary_description);
-       */
-       // ----------------------------------------------------------------
-
-       setup_quadrature_point_history ();
-
-       while (present_time < end_time)
-       {
-               present_time += present_timestep;
-               ++timestep_no;
-
-               if (present_time > end_time)
-               {
-                       present_timestep -= (present_time - end_time);
-                       present_time = end_time;
-               }
-               pcout << std::endl;
-               pcout << "Time step " << timestep_no << " at time " << present_time
-                                       << std::endl;
-
-               relative_error = max_relative_error * 10;
-               current_refinement_cycle = 0;
-
-               setup_system();
-
-
-                       // ------------------------ Refinement based on the relative error -------------------------------
-
-               while (relative_error >= max_relative_error)
-               {
-                       solve_newton();
-                       compute_error();
-
-                               if ( (timestep_no > 1) && (current_refinement_cycle>0) && (relative_error >= max_relative_error) )
-                               {
-                                       pcout << "The relative error, " << relative_error
-                                                               << " , is still more than maximum relative error, "
-                                                               << max_relative_error << ", but we move to the next increment.\n";
-                                       relative_error = .1 * max_relative_error;
-                               }
-
-                       if (relative_error >= max_relative_error)
-                       {
-                               TimerOutput::Scope t(computing_timer, "Setup: refine mesh");
-                               ++current_refinement_cycle;
-                               refine_grid();
-                       }
-
-               }
-
-                       // ------------------------ Refinement based on the number of refinement --------------------------
-               /*
-               bool continue_loop = true;
-               while (continue_loop)
-               {
-                       solve_newton();
-                       compute_error();
-
-                       if ( (timestep_no == 1) && (current_refinement_cycle < 1) )
-                       {
-                               TimerOutput::Scope t(computing_timer, "Setup: refine mesh");
-                               ++current_refinement_cycle;
-                               refine_grid();
-                       }else
-                       {
-                               continue_loop = false;
-                       }
-
-               }
-               */
-
-                       // -------------------------------------------------------------------------------------------------
-
-               solution += incremental_displacement;
-
-               update_quadrature_point_history ();
-
-               output_results((std::string("solution-") +
-                                                                               Utilities::int_to_string(timestep_no, 4)).c_str());
-
-               computing_timer.print_summary();
-               computing_timer.reset();
-
-               Utilities::System::MemoryStats stats;
-               Utilities::System::get_memory_stats(stats);
-               pcout << "Peak virtual memory used, resident in kB: " << stats.VmSize << " "
-                                       << stats.VmRSS << std::endl;
-
-
-       if (std::abs(present_time-end_time) < 1.e-7)
-       {
-               const std::string filename = (output_dir + "Results");
-
-               std::ofstream output_txt((filename + ".txt").c_str());
-
-               pcout << std::endl;
-               table_results.write_text(output_txt);
-               pcout << std::endl;
-               table_results_2.write_text(output_txt);
-               pcout << std::endl;
-               table_results_3.write_text(output_txt);
-               pcout << std::endl;
-       }
-
-       }
-
-       if (base_mesh == "Thick_tube_internal_pressure")
-       {
-               triangulation.set_boundary (0);
-               triangulation.set_boundary (1);
-       }else if (base_mesh == "Perforated_strip_tension")
-       {
-               triangulation.set_boundary (10);
-       }
+    computing_timer.reset();
+
+    present_time = 0;
+    present_timestep = 1;
+    end_time = 10;
+    timestep_no = 0;
+
+    make_grid();
+
+    // ----------------------------------------------------------------
+    //    base_mesh == "Thick_tube_internal_pressure"
+    /*
+    const Point<dim> center(0, 0);
+    const double inner_radius = .1,
+        outer_radius = .2;
+
+    const HyperBallBoundary<dim> inner_boundary_description(center, inner_radius);
+    triangulation.set_boundary (0, inner_boundary_description);
+
+    const HyperBallBoundary<dim> outer_boundary_description(center, outer_radius);
+    triangulation.set_boundary (1, outer_boundary_description);
+    */
+    // ----------------------------------------------------------------
+    //    base_mesh == "Perforated_strip_tension"
+    /*
+    const double inner_radius = 0.05;
+
+    const CylinderBoundary<dim> inner_boundary_description(inner_radius, 2);
+    triangulation.set_boundary (10, inner_boundary_description);
+    */
+    // ----------------------------------------------------------------
+
+    setup_quadrature_point_history ();
+
+    while (present_time < end_time)
+      {
+        present_time += present_timestep;
+        ++timestep_no;
+
+        if (present_time > end_time)
+          {
+            present_timestep -= (present_time - end_time);
+            present_time = end_time;
+          }
+        pcout << std::endl;
+        pcout << "Time step " << timestep_no << " at time " << present_time
+              << std::endl;
+
+        relative_error = max_relative_error * 10;
+        current_refinement_cycle = 0;
+
+        setup_system();
+
+
+        // ------------------------ Refinement based on the relative error -------------------------------
+
+        while (relative_error >= max_relative_error)
+          {
+            solve_newton();
+            compute_error();
+
+            if ( (timestep_no > 1) && (current_refinement_cycle>0) && (relative_error >= max_relative_error) )
+              {
+                pcout << "The relative error, " << relative_error
+                      << " , is still more than maximum relative error, "
+                      << max_relative_error << ", but we move to the next increment.\n";
+                relative_error = .1 * max_relative_error;
+              }
+
+            if (relative_error >= max_relative_error)
+              {
+                TimerOutput::Scope t(computing_timer, "Setup: refine mesh");
+                ++current_refinement_cycle;
+                refine_grid();
+              }
+
+          }
+
+        // ------------------------ Refinement based on the number of refinement --------------------------
+        /*
+        bool continue_loop = true;
+        while (continue_loop)
+        {
+          solve_newton();
+          compute_error();
+
+          if ( (timestep_no == 1) && (current_refinement_cycle < 1) )
+          {
+            TimerOutput::Scope t(computing_timer, "Setup: refine mesh");
+            ++current_refinement_cycle;
+            refine_grid();
+          }else
+          {
+            continue_loop = false;
+          }
+
+        }
+        */
+
+        // -------------------------------------------------------------------------------------------------
+
+        solution += incremental_displacement;
+
+        update_quadrature_point_history ();
+
+        output_results((std::string("solution-") +
+                        Utilities::int_to_string(timestep_no, 4)).c_str());
+
+        computing_timer.print_summary();
+        computing_timer.reset();
+
+        Utilities::System::MemoryStats stats;
+        Utilities::System::get_memory_stats(stats);
+        pcout << "Peak virtual memory used, resident in kB: " << stats.VmSize << " "
+              << stats.VmRSS << std::endl;
+
+
+        if (std::abs(present_time-end_time) < 1.e-7)
+          {
+            const std::string filename = (output_dir + "Results");
+
+            std::ofstream output_txt((filename + ".txt").c_str());
+
+            pcout << std::endl;
+            table_results.write_text(output_txt);
+            pcout << std::endl;
+            table_results_2.write_text(output_txt);
+            pcout << std::endl;
+            table_results_3.write_text(output_txt);
+            pcout << std::endl;
+          }
+
+      }
+
+    if (base_mesh == "Thick_tube_internal_pressure")
+      {
+        triangulation.set_boundary (0);
+        triangulation.set_boundary (1);
+      }
+    else if (base_mesh == "Perforated_strip_tension")
+      {
+        triangulation.set_boundary (10);
+      }
 
   }
 }

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.