From: young <young@0785d39b-7218-0410-832d-ea1e28bc413d>
Date: Sun, 20 Oct 2013 23:23:20 +0000 (+0000)
Subject: Restore missing tree.
X-Git-Url: https://gitweb.dealii.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=6fd1f6107b6793f18684a7d259cd120e652ab530;p=dealii-svn.git

Restore missing tree.

git-svn-id: https://svn.dealii.org/branches/branch_petscscalar_complex@31364 0785d39b-7218-0410-832d-ea1e28bc413d
---

6fd1f6107b6793f18684a7d259cd120e652ab530
diff --cc tests/petsc/01.cc
index 0000000000,5f3cc2ad78..56d6479250
mode 000000,100644..100644
--- a/tests/petsc/01.cc
+++ b/tests/petsc/01.cc
@@@ -1,0 -1,97 +1,97 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 01.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check setting elements in a petsc matrix using
+ // PETScWrappers::SparseMatrix::set()
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ 
+ 
+ void test (PETScWrappers::SparseMatrix &m)
+ {
+   // first set a few entries
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       if ((i+2*j+1) % 3 == 0)
+         m.set (i,j, i*j*.5+.5);
+ 
+   m.compress ();
+ 
+   // then make sure we retrieve the same ones
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       if ((i+2*j+1) % 3 == 0)
+         {
+           Assert (m(i,j) == i*j*.5+.5, ExcInternalError());
+           Assert (m.el(i,j) == i*j*.5+.5, ExcInternalError());
+         }
+       else
+         {
+           Assert (m(i,j) == 0, ExcInternalError());
+           Assert (m.el(i,j) == 0, ExcInternalError());
+         }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::SparseMatrix m (5,5,3);
+         test (m);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/02.cc
index 0000000000,2dbcbcdb3b..49cbf67fca
mode 000000,100644..100644
--- a/tests/petsc/02.cc
+++ b/tests/petsc/02.cc
@@@ -1,0 -1,97 +1,97 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 02.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check setting elements in a petsc matrix using
+ // PETScWrappers::SparseMatrix::add()
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ 
+ 
+ void test (PETScWrappers::SparseMatrix &m)
+ {
+   // first set a few entries
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       if ((i+2*j+1) % 3 == 0)
+         m.add (i,j, i*j*.5+.5);
+ 
+   m.compress ();
+ 
+   // then make sure we retrieve the same ones
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       if ((i+2*j+1) % 3 == 0)
+         {
+           Assert (m(i,j) == i*j*.5+.5, ExcInternalError());
+           Assert (m.el(i,j) == i*j*.5+.5, ExcInternalError());
+         }
+       else
+         {
+           Assert (m(i,j) == 0, ExcInternalError());
+           Assert (m.el(i,j) == 0, ExcInternalError());
+         }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::SparseMatrix m (5,5,3);
+         test (m);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/04.cc
index 0000000000,92315f09d5..f8dd745e73
mode 000000,100644..100644
--- a/tests/petsc/04.cc
+++ b/tests/petsc/04.cc
@@@ -1,0 -1,77 +1,77 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 04.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check querying matrix sizes
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ 
+ 
+ void test (PETScWrappers::SparseMatrix &m)
+ {
+   Assert (m.m() == 5, ExcInternalError());
+   Assert (m.n() == 5, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::SparseMatrix m (5,5,3);
+         test (m);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/05.cc
index 0000000000,3991d6ecb0..4536b19b09
mode 000000,100644..100644
--- a/tests/petsc/05.cc
+++ b/tests/petsc/05.cc
@@@ -1,0 -1,92 +1,92 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 05.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check querying the number of nonzero elements in
+ // PETScWrappers::SparseMatrix
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ 
+ 
+ void test (PETScWrappers::SparseMatrix &m)
+ {
+   // first set a few entries. count how many
+   // entries we have
+   unsigned int counter = 0;
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       if ((i+2*j+1) % 3 == 0)
+         {
+           m.set (i,j, i*j*.5+.5);
+           ++counter;
+         }
+ 
+   m.compress ();
+ 
+   deallog << m.n_nonzero_elements() << std::endl;
+   Assert (m.n_nonzero_elements() == counter,
+           ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::SparseMatrix m (5,5,3);
+         test (m);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/06.cc
index 0000000000,3cf3ad8b11..9bf02bd5ad
mode 000000,100644..100644
--- a/tests/petsc/06.cc
+++ b/tests/petsc/06.cc
@@@ -1,0 -1,88 +1,88 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 06.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::SparseMatrix::l1_norm
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ 
+ 
+ void test (PETScWrappers::SparseMatrix &m)
+ {
+   // first set a few entries. count how many
+   // entries we have
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       if ((i+2*j+1) % 3 == 0)
+         m.set (i,j, i*j*.5+.5);
+ 
+   m.compress ();
+ 
+   // compare against the exact value of the
+   // l1-norm (max col-sum)
+   deallog << m.l1_norm() << std::endl;
+   Assert (m.l1_norm() == 7, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::SparseMatrix m (5,5,3);
+         test (m);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/07.cc
index 0000000000,c0bbc2a97b..1749ce4217
mode 000000,100644..100644
--- a/tests/petsc/07.cc
+++ b/tests/petsc/07.cc
@@@ -1,0 -1,88 +1,88 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 07.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::SparseMatrix::linfty_norm
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ 
+ 
+ void test (PETScWrappers::SparseMatrix &m)
+ {
+   // first set a few entries. count how many
+   // entries we have
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       if ((i+2*j+1) % 3 == 0)
+         m.set (i,j, i*j*.5+.5);
+ 
+   m.compress ();
+ 
+   // compare against the exact value of the
+   // linfty-norm (max row-sum)
+   deallog << m.linfty_norm() << std::endl;
+   Assert (m.linfty_norm() == 8.5, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::SparseMatrix m (5,5,3);
+         test (m);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/08.cc
index 0000000000,5a637d9bb3..3c5801c7a2
mode 000000,100644..100644
--- a/tests/petsc/08.cc
+++ b/tests/petsc/08.cc
@@@ -1,0 -1,93 +1,93 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 08.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::SparseMatrix::frobenius_norm
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ 
+ 
+ void test (PETScWrappers::SparseMatrix &m)
+ {
+   // first set a few entries. count how many
+   // entries we have
+   PetscScalar norm = 0;
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       if ((i+2*j+1) % 3 == 0)
+         {
+           m.set (i,j, i*j*.5+.5);
+           norm += (i*j*.5+.5)*(i*j*.5+.5);
+         }
+   norm = std::sqrt(norm);
+ 
+   m.compress ();
+ 
+   // compare against the exact value of the
+   // l2-norm (max row-sum)
+   deallog << m.frobenius_norm() << std::endl;
+   Assert (m.frobenius_norm() == norm, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::SparseMatrix m (5,5,3);
+         test (m);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/09.cc
index 0000000000,15050cd795..8f50ac83c4
mode 000000,100644..100644
--- a/tests/petsc/09.cc
+++ b/tests/petsc/09.cc
@@@ -1,0 -1,100 +1,100 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 09.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::SparseMatrix::operator *=
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ 
+ 
+ void test (PETScWrappers::SparseMatrix &m)
+ {
+   // first set a few entries
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       if ((i+2*j+1) % 3 == 0)
+         m.set (i,j, i*j*.5+.5);
+ 
+   m.compress ();
+ 
+   // then multiply everything by 1.25 and
+   // make sure we retrieve the values we
+   // expect
+   m *= 1.25;
+ 
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       if ((i+2*j+1) % 3 == 0)
+         {
+           Assert (m(i,j) == (i*j*.5+.5)*1.25, ExcInternalError());
+           Assert (m.el(i,j) == (i*j*.5+.5)*1.25, ExcInternalError());
+         }
+       else
+         {
+           Assert (m(i,j) == 0, ExcInternalError());
+           Assert (m.el(i,j) == 0, ExcInternalError());
+         }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::SparseMatrix m (5,5,3);
+         test (m);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/10.cc
index 0000000000,ee2dab657f..b6f4e1a801
mode 000000,100644..100644
--- a/tests/petsc/10.cc
+++ b/tests/petsc/10.cc
@@@ -1,0 -1,100 +1,100 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 10.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::SparseMatrix::operator /=
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ 
+ 
+ void test (PETScWrappers::SparseMatrix &m)
+ {
+   // first set a few entries
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       if ((i+2*j+1) % 3 == 0)
+         m.set (i,j, i*j*.5+.5);
+ 
+   m.compress ();
+ 
+   // then divide everything by 4/3 and
+   // make sure we retrieve the values we
+   // expect
+   m /= 4./3.;
+ 
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       if ((i+2*j+1) % 3 == 0)
+         {
+           Assert (m(i,j) == (i*j*.5+.5)/4*3, ExcInternalError());
+           Assert (m.el(i,j) == (i*j*.5+.5)/4*3, ExcInternalError());
+         }
+       else
+         {
+           Assert (m(i,j) == 0, ExcInternalError());
+           Assert (m.el(i,j) == 0, ExcInternalError());
+         }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::SparseMatrix m (5,5,3);
+         test (m);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/11.cc
index 0000000000,9f99bdba54..ebcee72ce3
mode 000000,100644..100644
--- a/tests/petsc/11.cc
+++ b/tests/petsc/11.cc
@@@ -1,0 -1,82 +1,82 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 11.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::size()
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ 
+ 
+ void test (PETScWrappers::Vector &v)
+ {
+   // set only certain elements of the vector
+   for (unsigned int i=0; i<v.size(); i+=1+i)
+     v(i) = i;
+ 
+   v.compress ();
+ 
+   Assert (v.size() == 100, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/12.cc
index 0000000000,a9954b0a8b..53f58e2cea
mode 000000,100644..100644
--- a/tests/petsc/12.cc
+++ b/tests/petsc/12.cc
@@@ -1,0 -1,95 +1,95 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 12.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::operator() in set-mode
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v)
+ {
+   // set only certain elements of the
+   // vector. have a bit pattern of where we
+   // actually wrote elements to
+   std::vector<bool> pattern (v.size(), false);
+   for (unsigned int i=0; i<v.size(); i+=1+i)
+     {
+       v(i) = i;
+       pattern[i] = true;
+     }
+ 
+   v.compress ();
+ 
+   // check that they are ok, and this time
+   // all of them
+   for (unsigned int i=0; i<v.size(); ++i)
+     Assert ( ( (pattern[i] == true) && (v(i) == i) )
+              ||
+              ( (pattern[i] == false) && (v(i) == 0) ),
+              ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/13.cc
index 0000000000,44be821ae3..eac10a60f2
mode 000000,100644..100644
--- a/tests/petsc/13.cc
+++ b/tests/petsc/13.cc
@@@ -1,0 -1,95 +1,95 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 13.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::operator() in add-mode
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v)
+ {
+   // set only certain elements of the
+   // vector. have a bit pattern of where we
+   // actually wrote elements to
+   std::vector<bool> pattern (v.size(), false);
+   for (unsigned int i=0; i<v.size(); i+=1+i)
+     {
+       v(i) += i;
+       pattern[i] = true;
+     }
+ 
+   v.compress ();
+ 
+   // check that they are ok, and this time
+   // all of them
+   for (unsigned int i=0; i<v.size(); ++i)
+     Assert ( ( (pattern[i] == true) && (v(i) == i) )
+              ||
+              ( (pattern[i] == false) && (v(i) == 0) ),
+              ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/17.cc
index 0000000000,9501b1f042..71f750001f
mode 000000,100644..100644
--- a/tests/petsc/17.cc
+++ b/tests/petsc/17.cc
@@@ -1,0 -1,87 +1,87 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 17.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::l1_norm()
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v)
+ {
+   // set some elements of the vector
+   double norm = 0;
+   for (unsigned int i=0; i<v.size(); i+=1+i)
+     {
+       v(i) = i;
+       norm += std::fabs(1.*i);
+     }
+   v.compress ();
+ 
+   // then check the norm
+   Assert (v.l1_norm() == norm, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/18.cc
index 0000000000,3e3537cf30..0d4487bf8b
mode 000000,100644..100644
--- a/tests/petsc/18.cc
+++ b/tests/petsc/18.cc
@@@ -1,0 -1,88 +1,88 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 18.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::l2_norm()
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v)
+ {
+   // set some elements of the vector
+   PetscScalar norm = 0;
+   for (unsigned int i=0; i<v.size(); i+=1+i)
+     {
+       v(i) = i;
+       norm += std::fabs(1.*i)*std::fabs(1.*i);
+     }
+   v.compress ();
+ 
+   // then check the norm
+   const double eps=typeid(PetscScalar)==typeid(double) ? 1e-14 : 1e-5;
+   Assert (fabs(v.l2_norm()-std::sqrt(norm))<eps, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/19.cc
index 0000000000,6de9a94180..e69d50be6d
mode 000000,100644..100644
--- a/tests/petsc/19.cc
+++ b/tests/petsc/19.cc
@@@ -1,0 -1,87 +1,87 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 19.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::linfty_norm()
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v)
+ {
+   // set some elements of the vector
+   double norm = 0;
+   for (unsigned int i=0; i<v.size(); i+=1+i)
+     {
+       v(i) = i;
+       norm = std::max(norm,fabs(i));
+     }
+   v.compress ();
+ 
+   // then check the norm
+   Assert (v.linfty_norm() == norm, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/20.cc
index 0000000000,aa303d23af..9dedc8cfe3
mode 000000,100644..100644
--- a/tests/petsc/20.cc
+++ b/tests/petsc/20.cc
@@@ -1,0 -1,96 +1,96 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 20.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::operator *=
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v)
+ {
+   // set only certain elements of the
+   // vector. have a bit pattern of where we
+   // actually wrote elements to
+   std::vector<bool> pattern (v.size(), false);
+   for (unsigned int i=0; i<v.size(); i+=1+i)
+     {
+       v(i) = i;
+       pattern[i] = true;
+     }
+   v.compress ();
+ 
+   // multiply v with 5/4
+   v *= 5./4.;
+ 
+   // check that the entries are ok
+   for (unsigned int i=0; i<v.size(); ++i)
+     Assert ( ( (pattern[i] == true) && (v(i) == i*5./4.) )
+              ||
+              ( (pattern[i] == false) && (v(i) == 0) ),
+              ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/21.cc
index 0000000000,4b3602598b..f0d9775a04
mode 000000,100644..100644
--- a/tests/petsc/21.cc
+++ b/tests/petsc/21.cc
@@@ -1,0 -1,96 +1,96 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 21.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::operator /=
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v)
+ {
+   // set only certain elements of the
+   // vector. have a bit pattern of where we
+   // actually wrote elements to
+   std::vector<bool> pattern (v.size(), false);
+   for (unsigned int i=0; i<v.size(); i+=1+i)
+     {
+       v(i) = i;
+       pattern[i] = true;
+     }
+   v.compress ();
+ 
+   // multiply v with 3/4
+   v /= 4./3.;
+ 
+   // check that the entries are ok
+   for (unsigned int i=0; i<v.size(); ++i)
+     Assert ( ( (pattern[i] == true) && (v(i) == i*3./4.) )
+              ||
+              ( (pattern[i] == false) && (v(i) == 0) ),
+              ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/22.cc
index 0000000000,593c88d366..7856efd381
mode 000000,100644..100644
--- a/tests/petsc/22.cc
+++ b/tests/petsc/22.cc
@@@ -1,0 -1,91 +1,91 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 22.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::operator*(Vector) on two vectors that are
+ // orthogonal
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w)
+ {
+   // set only certain elements of each
+   // vector, but disjoint sets of elements
+   for (unsigned int i=0; i<v.size(); ++i)
+     if (i%3 == 0)
+       v(i) = i;
+     else
+       w(i) = i;
+   v.compress ();
+   w.compress ();
+ 
+   // make sure the scalar product is zero
+   Assert (v*w == 0, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         test (v,w);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/23.cc
index 0000000000,747ba74d3e..528737bf13
mode 000000,100644..100644
--- a/tests/petsc/23.cc
+++ b/tests/petsc/23.cc
@@@ -1,0 -1,98 +1,98 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 23.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::operator*(Vector) on two vectors that are
+ // not orthogonal
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w)
+ {
+   // set only certain elements of each
+   // vector, and record the expected scalar
+   // product
+   double product = 0;
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       v(i) = i;
+       if (i%3 == 0)
+         {
+           w(i) = i+1.;
+           product += i*(i+1);
+         }
+     }
+ 
+   v.compress ();
+   w.compress ();
+ 
+   // make sure the scalar product is zero
+   Assert (v*w == product, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         test (v,w);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/24.cc
index 0000000000,dae86a02b1..386b394245
mode 000000,100644..100644
--- a/tests/petsc/24.cc
+++ b/tests/petsc/24.cc
@@@ -1,0 -1,90 +1,90 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 24.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // this test used to check for PETScWrappers::Vector::clear(). However, this
+ // function has since been removed, so we test for v=0 instead, although that
+ // may be covered by one of the other tests
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v)
+ {
+   // set some entries of the vector
+   for (unsigned int i=0; i<v.size(); ++i)
+     if (i%3 == 0)
+       v(i) = i+1.;
+   v.compress ();
+ 
+   // then clear it again and make sure the
+   // vector is really empty
+   const unsigned int sz = v.size();
+   v = 0;
+   Assert (v.size() == sz, ExcInternalError());
+   Assert (v.l2_norm() == 0, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/25.cc
index 0000000000,82a30e4adb..2d2aefb2a8
mode 000000,100644..100644
--- a/tests/petsc/25.cc
+++ b/tests/petsc/25.cc
@@@ -1,0 -1,88 +1,88 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 25.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::operator = (PetscScalar) with setting to zero
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v)
+ {
+   // set some entries of the vector
+   for (unsigned int i=0; i<v.size(); ++i)
+     if (i%3 == 0)
+       v(i) = i+1.;
+   v.compress ();
+ 
+   // then clear it again and make sure the
+   // vector is really empty
+   const unsigned int sz = v.size();
+   v = 0;
+   Assert (v.size() == sz, ExcInternalError());
+   Assert (v.l2_norm() == 0, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/26.cc
index 0000000000,2a26dfea28..cc7d3da409
mode 000000,100644..100644
--- a/tests/petsc/26.cc
+++ b/tests/petsc/26.cc
@@@ -1,0 -1,87 +1,87 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 26.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::operator = (PetscScalar) with setting to a
+ // nonzero value
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v)
+ {
+   // set some entries of the vector
+   for (unsigned int i=0; i<v.size(); ++i)
+     if (i%3 == 0)
+       v(i) = i+1.;
+   v.compress ();
+ 
+   const unsigned int sz = v.size();
+   v = 2;
+   Assert (v.size() == sz, ExcInternalError());
+   Assert (v.l2_norm() == std::sqrt(4.*sz), ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/27.cc
index 0000000000,ea407ff938..00c4df79e7
mode 000000,100644..100644
--- a/tests/petsc/27.cc
+++ b/tests/petsc/27.cc
@@@ -1,0 -1,92 +1,92 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 27.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::operator = (Vector)
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v)
+ {
+   // set some entries of the vector
+   for (unsigned int i=0; i<v.size(); ++i)
+     if (i%3 == 0)
+       v(i) = i+1.;
+   v.compress ();
+ 
+   // then copy it
+   PETScWrappers::Vector w (v.size());
+   w = v;
+ 
+   // make sure they're equal
+   deallog << v *w << ' ' << v.l2_norm() * w.l2_norm()
+           << ' ' << v *w - v.l2_norm() * w.l2_norm() << std::endl;
+   const double eps=typeid(PetscScalar)==typeid(double) ? 1e-14 : 1e-5;
+   Assert (std::fabs(v*w - v.l2_norm() * w.l2_norm()) < eps*(v*w),
+           ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/28.cc
index 0000000000,278eb8fdfc..e22e0cff3f
mode 000000,100644..100644
--- a/tests/petsc/28.cc
+++ b/tests/petsc/28.cc
@@@ -1,0 -1,94 +1,94 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 28.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::operator = (Vector), except that we don't
+ // resize the vector to be copied to beforehand
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v)
+ {
+   // set some entries of the vector
+   for (unsigned int i=0; i<v.size(); ++i)
+     if (i%3 == 0)
+       v(i) = i+1.;
+   v.compress ();
+ 
+   // then copy it to a vector of different
+   // size
+   PETScWrappers::Vector w (1);
+   w = v;
+ 
+   // make sure they're equal
+   deallog << v *w << ' ' << v.l2_norm() * w.l2_norm()
+           << ' ' << v *w - v.l2_norm() * w.l2_norm() << std::endl;
+   const double eps=typeid(PetscScalar)==typeid(double) ? 1e-14 : 1e-5;
+   Assert (std::fabs(v*w - v.l2_norm() * w.l2_norm()) < eps*(v*w),
+           ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/29.cc
index 0000000000,f9d1b83dc6..e1be0a1d23
mode 000000,100644..100644
--- a/tests/petsc/29.cc
+++ b/tests/petsc/29.cc
@@@ -1,0 -1,79 +1,79 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 29.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::reinit(fast)
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v)
+ {
+   v.reinit (13, true);
+ 
+   Assert (v.size() == 13, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/30.cc
index 0000000000,368a4d9194..256ece53f1
mode 000000,100644..100644
--- a/tests/petsc/30.cc
+++ b/tests/petsc/30.cc
@@@ -1,0 -1,87 +1,87 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 30.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::reinit(!fast)
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v)
+ {
+   // set some entries of the vector
+   for (unsigned int i=0; i<v.size(); ++i)
+     if (i%3 == 0)
+       v(i) = i+1.;
+   v.compress ();
+ 
+   // then resize with setting to zero
+   v.reinit (13, false);
+ 
+   Assert (v.size() == 13, ExcInternalError());
+   Assert (v.l2_norm() == 0, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/31.cc
index 0000000000,725303a2d0..f06fe29602
mode 000000,100644..100644
--- a/tests/petsc/31.cc
+++ b/tests/petsc/31.cc
@@@ -1,0 -1,89 +1,89 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 31.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::l2_norm()
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v)
+ {
+   // set some elements of the vector
+   PetscScalar norm = 0;
+   for (unsigned int i=0; i<v.size(); i+=1+i)
+     {
+       v(i) = i;
+       norm += std::fabs(1.*i)*std::fabs(1.*i);
+     }
+   v.compress ();
+ 
+   // then check the norm
+   const double eps=typeid(PetscScalar)==typeid(double) ? 1e-14 : 1e-5;
+   Assert (std::fabs(v.norm_sqr() - norm) < eps*norm,
+           ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/32.cc
index 0000000000,1136971c1f..5ffcb10df5
mode 000000,100644..100644
--- a/tests/petsc/32.cc
+++ b/tests/petsc/32.cc
@@@ -1,0 -1,89 +1,89 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 32.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::mean_value()
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v)
+ {
+   // set some elements of the vector
+   PetscScalar sum = 0;
+   for (unsigned int i=0; i<v.size(); i+=1+i)
+     {
+       v(i) = i;
+       sum += i;
+     }
+   v.compress ();
+ 
+   // then check the norm
+   const double eps=typeid(PetscScalar)==typeid(double) ? 1e-14 : 1e-5;
+   Assert (std::fabs(v.mean_value() - sum/v.size()) < eps*sum/v.size(),
+           ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/33.cc
index 0000000000,7cdf00cdb2..b38d57e525
mode 000000,100644..100644
--- a/tests/petsc/33.cc
+++ b/tests/petsc/33.cc
@@@ -1,0 -1,90 +1,90 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 33.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::lp_norm(3)
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v)
+ {
+   // set some elements of the vector
+   PetscScalar sum = 0;
+   for (unsigned int i=0; i<v.size(); i+=1+i)
+     {
+       v(i) = i;
+       sum += i*i*i;
+     }
+   v.compress ();
+ 
+   // then check the norm
+   const double eps=typeid(PetscScalar)==typeid(double) ? 1e-14 : 1e-5;
+   const double true_value=std::pow(sum, static_cast<PetscScalar> (1./3.));
+   Assert (std::fabs(v.lp_norm(3) - true_value) < eps*true_value,
+           ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/34.cc
index 0000000000,d2ce01c600..4d26ab53ff
mode 000000,100644..100644
--- a/tests/petsc/34.cc
+++ b/tests/petsc/34.cc
@@@ -1,0 -1,90 +1,90 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 34.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::all_zero
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v)
+ {
+   // set some elements of the vector
+   double sum = 0;
+   for (unsigned int i=0; i<v.size(); i+=1+i)
+     {
+       v(i) = i;
+       sum += i*i*i;
+     }
+   v.compress ();
+ 
+   // set them to zero again
+   v = 0;
+ 
+   // then check all_zero
+   Assert (v.all_zero() == true, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/35.cc
index 0000000000,bf0b6bcd51..130d7dc731
mode 000000,100644..100644
--- a/tests/petsc/35.cc
+++ b/tests/petsc/35.cc
@@@ -1,0 -1,107 +1,107 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 35.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::operator+=(Vector)
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w)
+ {
+   // set only certain elements of each
+   // vector
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       v(i) = i;
+       if (i%3 == 0)
+         w(i) = i+1.;
+     }
+ 
+   v.compress ();
+   w.compress ();
+ 
+   v += w;
+ 
+   // make sure we get the expected result
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       if (i%3 == 0)
+         {
+           Assert (w(i) == i+1., ExcInternalError());
+           Assert (v(i) == i+i+1., ExcInternalError());
+         }
+       else
+         {
+           Assert (w(i) == 0, ExcInternalError());
+           Assert (v(i) == i, ExcInternalError());
+         }
+     }
+ 
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         test (v,w);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/36.cc
index 0000000000,a0eeea75ee..93ef5c8443
mode 000000,100644..100644
--- a/tests/petsc/36.cc
+++ b/tests/petsc/36.cc
@@@ -1,0 -1,107 +1,107 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 36.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::operator-=(Vector)
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w)
+ {
+   // set only certain elements of each
+   // vector
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       v(i) = i;
+       if (i%3 == 0)
+         w(i) = i+1.;
+     }
+ 
+   v.compress ();
+   w.compress ();
+ 
+   v -= w;
+ 
+   // make sure we get the expected result
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       if (i%3 == 0)
+         {
+           Assert (w(i) == i+1., ExcInternalError());
+           Assert (v(i) == i-(i+1.), ExcInternalError());
+         }
+       else
+         {
+           Assert (w(i) == 0, ExcInternalError());
+           Assert (v(i) == i, ExcInternalError());
+         }
+     }
+ 
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         test (v,w);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/37.cc
index 0000000000,ff11c6aabe..456812c2f2
mode 000000,100644..100644
--- a/tests/petsc/37.cc
+++ b/tests/petsc/37.cc
@@@ -1,0 -1,86 +1,86 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 37.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::add (scalar)
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v)
+ {
+   for (unsigned int i=0; i<v.size(); ++i)
+     v(i) = i;
+ 
+   v.compress ();
+ 
+   v.add (1.);
+ 
+   // make sure we get the expected result
+   for (unsigned int i=0; i<v.size(); ++i)
+     Assert (v(i) == i+1., ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/38.cc
index 0000000000,aacb319b3d..487a19693b
mode 000000,100644..100644
--- a/tests/petsc/38.cc
+++ b/tests/petsc/38.cc
@@@ -1,0 -1,95 +1,95 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 38.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::add(Vector)
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w)
+ {
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       v(i) = i;
+       w(i) = i+1.;
+     }
+ 
+   v.compress ();
+   w.compress ();
+ 
+   v.add (w);
+ 
+   // make sure we get the expected result
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       Assert (w(i) == i+1., ExcInternalError());
+       Assert (v(i) == i+(i+1.), ExcInternalError());
+     }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         test (v,w);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/39.cc
index 0000000000,662e3334f2..3ccee49544
mode 000000,100644..100644
--- a/tests/petsc/39.cc
+++ b/tests/petsc/39.cc
@@@ -1,0 -1,95 +1,95 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 39.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::add(scalar, Vector)
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w)
+ {
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       v(i) = i;
+       w(i) = i+1.;
+     }
+ 
+   v.compress ();
+   w.compress ();
+ 
+   v.add (2, w);
+ 
+   // make sure we get the expected result
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       Assert (w(i) == i+1., ExcInternalError());
+       Assert (v(i) == i+2*(i+1.), ExcInternalError());
+     }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         test (v,w);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/40.cc
index 0000000000,1ea51675ae..7198d5a5bf
mode 000000,100644..100644
--- a/tests/petsc/40.cc
+++ b/tests/petsc/40.cc
@@@ -1,0 -1,100 +1,100 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 40.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::add(s,V,s,V)
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w,
+            PETScWrappers::Vector &x)
+ {
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       v(i) = i;
+       w(i) = i+1.;
+       x(i) = i+2.;
+     }
+ 
+   v.compress ();
+   w.compress ();
+   x.compress ();
+ 
+   v.add (2, w, 3, x);
+ 
+   // make sure we get the expected result
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       Assert (w(i) == i+1., ExcInternalError());
+       Assert (x(i) == i+2., ExcInternalError());
+       Assert (v(i) == i+2*(i+1.)+3*(i+2.), ExcInternalError());
+     }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         PETScWrappers::Vector x (100);
+         test (v,w,x);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/41.cc
index 0000000000,feca17d765..0d22821469
mode 000000,100644..100644
--- a/tests/petsc/41.cc
+++ b/tests/petsc/41.cc
@@@ -1,0 -1,95 +1,95 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 41.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::sadd(s, Vector)
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w)
+ {
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       v(i) = i;
+       w(i) = i+1.;
+     }
+ 
+   v.compress ();
+   w.compress ();
+ 
+   v.sadd (2, w);
+ 
+   // make sure we get the expected result
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       Assert (w(i) == i+1., ExcInternalError());
+       Assert (v(i) == 2*i+(i+1.), ExcInternalError());
+     }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         test (v,w);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/42.cc
index 0000000000,caf0d11fd6..e4f765cf94
mode 000000,100644..100644
--- a/tests/petsc/42.cc
+++ b/tests/petsc/42.cc
@@@ -1,0 -1,95 +1,95 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 42.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::sadd(scalar, scalar, Vector)
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w)
+ {
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       v(i) = i;
+       w(i) = i+1.;
+     }
+ 
+   v.compress ();
+   w.compress ();
+ 
+   v.sadd (3, 2, w);
+ 
+   // make sure we get the expected result
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       Assert (w(i) == i+1., ExcInternalError());
+       Assert (v(i) == 3*i+2*(i+1.), ExcInternalError());
+     }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         test (v,w);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/43.cc
index 0000000000,5675ffb352..ec7e7ccb9d
mode 000000,100644..100644
--- a/tests/petsc/43.cc
+++ b/tests/petsc/43.cc
@@@ -1,0 -1,100 +1,100 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 43.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::sadd(s,s,V,s,V)
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w,
+            PETScWrappers::Vector &x)
+ {
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       v(i) = i;
+       w(i) = i+1.;
+       x(i) = i+2.;
+     }
+ 
+   v.compress ();
+   w.compress ();
+   x.compress ();
+ 
+   v.sadd (1.5, 2, w, 3, x);
+ 
+   // make sure we get the expected result
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       Assert (w(i) == i+1., ExcInternalError());
+       Assert (x(i) == i+2., ExcInternalError());
+       Assert (v(i) == 1.5*i+2*(i+1.)+3*(i+2.), ExcInternalError());
+     }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         PETScWrappers::Vector x (100);
+         test (v,w,x);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/44.cc
index 0000000000,f53690ca53..0d805ab73b
mode 000000,100644..100644
--- a/tests/petsc/44.cc
+++ b/tests/petsc/44.cc
@@@ -1,0 -1,105 +1,105 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 44.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::sadd(s,s,V,s,V,s,V)
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w,
+            PETScWrappers::Vector &x,
+            PETScWrappers::Vector &y)
+ {
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       v(i) = i;
+       w(i) = i+1.;
+       x(i) = i+2.;
+       y(i) = i+3.;
+     }
+ 
+   v.compress ();
+   w.compress ();
+   x.compress ();
+   y.compress ();
+ 
+   v.sadd (1.5, 2, w, 3, x, 4, y);
+ 
+   // make sure we get the expected result
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       Assert (w(i) == i+1., ExcInternalError());
+       Assert (x(i) == i+2., ExcInternalError());
+       Assert (y(i) == i+3., ExcInternalError());
+       Assert (v(i) == 1.5*i+2*(i+1.)+3*(i+2.)+4*(i+3), ExcInternalError());
+     }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         PETScWrappers::Vector x (100);
+         PETScWrappers::Vector y (100);
+         test (v,w,x,y);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/45.cc
index 0000000000,c63f0f2787..88bfadbdf4
mode 000000,100644..100644
--- a/tests/petsc/45.cc
+++ b/tests/petsc/45.cc
@@@ -1,0 -1,95 +1,95 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 45.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::scale
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w)
+ {
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       v(i) = i;
+       w(i) = i+1.;
+     }
+ 
+   v.compress ();
+   w.compress ();
+ 
+   v.scale (w);
+ 
+   // make sure we get the expected result
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       Assert (w(i) == i+1., ExcInternalError());
+       Assert (v(i) == i*(i+1.), ExcInternalError());
+     }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         test (v,w);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/46.cc
index 0000000000,c063b75721..7d405e62ab
mode 000000,100644..100644
--- a/tests/petsc/46.cc
+++ b/tests/petsc/46.cc
@@@ -1,0 -1,95 +1,95 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 46.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::equ (s,V)
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w)
+ {
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       v(i) = i;
+       w(i) = i+1.;
+     }
+ 
+   v.compress ();
+   w.compress ();
+ 
+   v.equ (2, w);
+ 
+   // make sure we get the expected result
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       Assert (w(i) == i+1., ExcInternalError());
+       Assert (v(i) == 2*(i+1.), ExcInternalError());
+     }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         test (v,w);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/47.cc
index 0000000000,d3065bf076..3fc2bb17b7
mode 000000,100644..100644
--- a/tests/petsc/47.cc
+++ b/tests/petsc/47.cc
@@@ -1,0 -1,100 +1,100 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 47.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::equ (s,V,s,V)
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w,
+            PETScWrappers::Vector &x)
+ {
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       v(i) = i;
+       w(i) = i+1.;
+       x(i) = i+2.;
+     }
+ 
+   v.compress ();
+   w.compress ();
+   x.compress ();
+ 
+   v.equ (2, w, 3, x);
+ 
+   // make sure we get the expected result
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       Assert (w(i) == i+1., ExcInternalError());
+       Assert (x(i) == i+2., ExcInternalError());
+       Assert (v(i) == 2*(i+1.)+3*(i+2.), ExcInternalError());
+     }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         PETScWrappers::Vector x (100);
+         test (v,w,x);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/48.cc
index 0000000000,cb99358075..66a0fd5a49
mode 000000,100644..100644
--- a/tests/petsc/48.cc
+++ b/tests/petsc/48.cc
@@@ -1,0 -1,102 +1,102 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 48.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::ratio
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w,
+            PETScWrappers::Vector &x)
+ {
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       v(i) = i;
+       w(i) = i+1.;
+       x(i) = i+2.;
+     }
+ 
+   v.compress ();
+   w.compress ();
+   x.compress ();
+ 
+   v.ratio (w, x);
+ 
+   // make sure we get the expected result
+   const double eps=typeid(PetscScalar)==typeid(double) ? 1e-14 : 1e-5;
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       Assert (w(i) == i+1., ExcInternalError());
+       Assert (x(i) == i+2., ExcInternalError());
+       Assert (std::fabs(v(i) - (i+1.)/(i+2.)) < eps*v(i),
+               ExcInternalError());
+     }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         PETScWrappers::Vector x (100);
+         test (v,w,x);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/49.cc
index 0000000000,0797dc6c44..62ceb915ed
mode 000000,100644..100644
--- a/tests/petsc/49.cc
+++ b/tests/petsc/49.cc
@@@ -1,0 -1,91 +1,91 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 49.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::operator = (Vector<PetscVector>)
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v)
+ {
+   Vector<PetscScalar> w (v.size());
+ 
+   for (unsigned int i=0; i<w.size(); ++i)
+     w(i) = i;
+ 
+   v = w;
+ 
+ 
+   // make sure we get the expected result
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       Assert (w(i) == i, ExcInternalError());
+       Assert (v(i) == i, ExcInternalError());
+     }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/50.cc
index 0000000000,9d3e95d6b6..7f168beec3
mode 000000,100644..100644
--- a/tests/petsc/50.cc
+++ b/tests/petsc/50.cc
@@@ -1,0 -1,107 +1,107 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 50.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::operator = (Vector<T>) with T!=PetscScalar
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v)
+ {
+   Vector<double> w (v.size());
+   Vector<float>  x (v.size());
+ 
+   for (unsigned int i=0; i<w.size(); ++i)
+     {
+       w(i) = i;
+       x(i) = i+1;
+     }
+ 
+   // first copy from w and make sure we get
+   // the expected result. then copy from x
+   // and do the same. in at least one of the
+   // two cases, the template argument to
+   // Vector<T> must be different from
+   // PetscScalar
+   v = w;
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       Assert (w(i) == i, ExcInternalError());
+       Assert (v(i) == i, ExcInternalError());
+       Assert (x(i) == i+1, ExcInternalError());
+     }
+ 
+   v = x;
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       Assert (w(i) == i, ExcInternalError());
+       Assert (v(i) == i+1, ExcInternalError());
+       Assert (x(i) == i+1, ExcInternalError());
+     }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/51.cc
index 0000000000,f7b826b64f..ca8e808785
mode 000000,100644..100644
--- a/tests/petsc/51.cc
+++ b/tests/petsc/51.cc
@@@ -1,0 -1,92 +1,92 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 51.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check copy constructor PETScWrappers::Vector::Vector(Vector)
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v)
+ {
+   // set some entries of the vector
+   for (unsigned int i=0; i<v.size(); ++i)
+     if (i%3 == 0)
+       v(i) = i+1.;
+   v.compress ();
+ 
+   // then copy it
+   PETScWrappers::Vector w (v);
+   w.compress ();
+ 
+   // make sure they're equal
+   deallog << v *w << ' ' << v.l2_norm() * w.l2_norm()
+           << ' ' << v *w - v.l2_norm() * w.l2_norm() << std::endl;
+   const double eps=typeid(PetscScalar)==typeid(double) ? 1e-14 : 1e-5;
+   Assert (std::fabs(v*w - v.l2_norm() * w.l2_norm()) < eps*(v*w),
+           ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/52.cc
index 0000000000,3cf2e2e38d..2fbd03a452
mode 000000,100644..100644
--- a/tests/petsc/52.cc
+++ b/tests/petsc/52.cc
@@@ -1,0 -1,102 +1,102 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 52.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check setting elements in a petsc matrix using
+ // PETScWrappers::SparseMatrix::set(). like petsc_01, but use a different
+ // constructor for the sparse matrix
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ 
+ 
+ void test (PETScWrappers::SparseMatrix &m)
+ {
+   // first set a few entries
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       if ((i+2*j+1) % 3 == 0)
+         m.set (i,j, i*j*.5+.5);
+ 
+   m.compress ();
+ 
+   // then make sure we retrieve the same ones
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       if ((i+2*j+1) % 3 == 0)
+         {
+           Assert (m(i,j) == i*j*.5+.5, ExcInternalError());
+           Assert (m.el(i,j) == i*j*.5+.5, ExcInternalError());
+         }
+       else
+         {
+           Assert (m(i,j) == 0, ExcInternalError());
+           Assert (m.el(i,j) == 0, ExcInternalError());
+         }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         typedef PETScWrappers::SparseMatrix::size_type size_type;
+ 
+         std::vector<size_type> row_lengths (5, 3U);
+         row_lengths.back() = 2;
+         PETScWrappers::SparseMatrix m (5,5,row_lengths);
+         test (m);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/55.cc
index 0000000000,a6dd450067..59edea4281
mode 000000,100644..100644
--- a/tests/petsc/55.cc
+++ b/tests/petsc/55.cc
@@@ -1,0 -1,97 +1,97 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 55.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::operator() in set, and later in *= mode
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v)
+ {
+   // set only certain elements of the
+   // vector. have a bit pattern of where we
+   // actually wrote elements to
+   std::vector<bool> pattern (v.size(), false);
+   for (unsigned int i=0; i<v.size(); i+=1+i)
+     {
+       v(i) = i;
+       pattern[i] = true;
+     }
+   for (unsigned int i=0; i<v.size(); i+=1+i)
+     v(i) *= 2;
+ 
+   v.compress ();
+ 
+   // check that they are ok, and this time
+   // all of them
+   for (unsigned int i=0; i<v.size(); ++i)
+     Assert ( ( (pattern[i] == true) && (v(i) == 2*i) )
+              ||
+              ( (pattern[i] == false) && (v(i) == 0) ),
+              ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/56.cc
index 0000000000,8183680678..687c1788bc
mode 000000,100644..100644
--- a/tests/petsc/56.cc
+++ b/tests/petsc/56.cc
@@@ -1,0 -1,97 +1,97 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 56.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::operator() in set, and later in /= mode
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v)
+ {
+   // set only certain elements of the
+   // vector. have a bit pattern of where we
+   // actually wrote elements to
+   std::vector<bool> pattern (v.size(), false);
+   for (unsigned int i=0; i<v.size(); i+=1+i)
+     {
+       v(i) = 2*i;
+       pattern[i] = true;
+     }
+   for (unsigned int i=0; i<v.size(); i+=1+i)
+     v(i) /= 2;
+ 
+   v.compress ();
+ 
+   // check that they are ok, and this time
+   // all of them
+   for (unsigned int i=0; i<v.size(); ++i)
+     Assert ( ( (pattern[i] == true) && (v(i) == i) )
+              ||
+              ( (pattern[i] == false) && (v(i) == 0) ),
+              ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/57.cc
index 0000000000,4a20c3bfe8..6f195ec46e
mode 000000,100644..100644
--- a/tests/petsc/57.cc
+++ b/tests/petsc/57.cc
@@@ -1,0 -1,95 +1,95 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 57.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::is_non_zero
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v)
+ {
+   // set only certain elements of the
+   // vector. they are all positive
+   std::vector<bool> pattern (v.size(), false);
+   for (unsigned int i=0; i<v.size(); i+=1+i)
+     {
+       v(i) += i;
+       pattern[i] = true;
+     }
+ 
+   v.compress ();
+ 
+   // check that the vector is really
+   // non-negative
+   Assert (v.is_non_negative() == true, ExcInternalError());
+ 
+   // then set a single element to a negative
+   // value and check again
+   v(v.size()/2) = -1;
+   Assert (v.is_non_negative() == false, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/58.cc
index 0000000000,5b195aeb5b..0f79f0ed5b
mode 000000,100644..100644
--- a/tests/petsc/58.cc
+++ b/tests/petsc/58.cc
@@@ -1,0 -1,97 +1,97 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 58.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check ::Vector (const PETScWrappers::Vector &) copy constructor
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/vector.h>
+ 
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v)
+ {
+   // set only certain elements of the
+   // vector.
+   std::vector<bool> pattern (v.size(), false);
+   for (unsigned int i=0; i<v.size(); i+=1+i)
+     {
+       v(i) += i;
+       pattern[i] = true;
+     }
+ 
+   v.compress ();
+ 
+   Vector<double> w (v);
+   Vector<float>  x (v);
+ 
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       Assert (v(i) == w(i), ExcInternalError());
+       Assert (v(i) == x(i), ExcInternalError());
+     }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/59.cc
index 0000000000,3bb270d0fc..0105533787
mode 000000,100644..100644
--- a/tests/petsc/59.cc
+++ b/tests/petsc/59.cc
@@@ -1,0 -1,100 +1,100 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 59.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector (const ::Vector &) copy constructor
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/vector.h>
+ 
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v)
+ {
+   // set only certain elements of the
+   // vector.
+   std::vector<bool> pattern (v.size(), false);
+   for (unsigned int i=0; i<v.size(); i+=1+i)
+     {
+       v(i) += i;
+       pattern[i] = true;
+     }
+ 
+   v.compress ();
+ 
+   Vector<double> w (v);
+   Vector<float>  x (v);
+ 
+   PETScWrappers::Vector w1 (w);
+   PETScWrappers::Vector x1 (x);
+ 
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       Assert (w1(i) == w(i), ExcInternalError());
+       Assert (x1(i) == x(i), ExcInternalError());
+     }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/60.cc
index 0000000000,77cba83030..8449c16fc6
mode 000000,100644..100644
--- a/tests/petsc/60.cc
+++ b/tests/petsc/60.cc
@@@ -1,0 -1,99 +1,99 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 60.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check ::Vector::operator = (const PETScWrappers::Vector &)
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/vector.h>
+ 
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v)
+ {
+   // set only certain elements of the
+   // vector.
+   std::vector<bool> pattern (v.size(), false);
+   for (unsigned int i=0; i<v.size(); i+=1+i)
+     {
+       v(i) += i;
+       pattern[i] = true;
+     }
+ 
+   v.compress ();
+ 
+   Vector<double> w;
+   w=v;
+   Vector<float>  x;
+   x=v;
+ 
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       Assert (v(i) == w(i), ExcInternalError());
+       Assert (v(i) == x(i), ExcInternalError());
+     }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/61.cc
index 0000000000,75547b0ebd..48dde01c8d
mode 000000,100644..100644
--- a/tests/petsc/61.cc
+++ b/tests/petsc/61.cc
@@@ -1,0 -1,104 +1,104 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 61.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::operator = (const ::Vector &)
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/vector.h>
+ 
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v)
+ {
+   // set only certain elements of the
+   // vector.
+   std::vector<bool> pattern (v.size(), false);
+   for (unsigned int i=0; i<v.size(); i+=1+i)
+     {
+       v(i) += i;
+       pattern[i] = true;
+     }
+ 
+   v.compress ();
+ 
+   Vector<double> w;
+   w=v;
+   Vector<float>  x;
+   x=v;
+ 
+   PETScWrappers::Vector w1;
+   w1=w;
+   PETScWrappers::Vector x1;
+   x1=x;
+ 
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       Assert (w1(i) == w(i), ExcInternalError());
+       Assert (x1(i) == x(i), ExcInternalError());
+     }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/62.cc
index 0000000000,c0530bdecb..d144af6e9d
mode 000000,100644..100644
--- a/tests/petsc/62.cc
+++ b/tests/petsc/62.cc
@@@ -1,0 -1,85 +1,85 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 62.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::MatrixBase::clear ()
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/vector.h>
+ 
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::MatrixBase &m)
+ {
+   Assert (m.m() != 0, ExcInternalError());
+   Assert (m.n() != 0, ExcInternalError());
+ 
+   m.clear ();
+ 
+   Assert (m.m() == 0, ExcInternalError());
+   Assert (m.n() == 0, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::SparseMatrix v (100,100,5);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/63.cc
index 0000000000,8b604a8309..b425a356aa
mode 000000,100644..100644
--- a/tests/petsc/63.cc
+++ b/tests/petsc/63.cc
@@@ -1,0 -1,83 +1,83 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 63.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/vector.h>
+ 
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::MatrixBase &m)
+ {
+   Assert (m.m() == 100, ExcInternalError());
+   Assert (m.n() == 100, ExcInternalError());
+ 
+   m = 0;
+ 
+   Assert (m.m() == 100, ExcInternalError());
+   Assert (m.n() == 100, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::SparseMatrix v (100,100,5);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/64.cc
index 0000000000,f3ac698435..b161c724ab
mode 000000,100644..100644
--- a/tests/petsc/64.cc
+++ b/tests/petsc/64.cc
@@@ -1,0 -1,104 +1,104 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 64.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // This test should be run on multiple processors. note that this test also
+ // started to fail with the upgrade to petsc 2.2.1 which required a fix in
+ // PETScWrappers::MatrixBase::operator=
+ 
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/petsc_parallel_sparse_matrix.h>
+ #include <deal.II/lac/vector.h>
+ 
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ template<typename MatrixType>
+ void test (MatrixType &m)
+ {
+   m.add(0,0,1);
+   m = 0;
+   m.compress();
+ 
+   Assert(fabs(m.frobenius_norm())<1e-15, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         const unsigned int n_dofs=420;
+         // check
+         // PETScWrappers::SparseMatrix
+         PETScWrappers::SparseMatrix
+         v1 (n_dofs, n_dofs, 5);
+         test (v1);
+ 
+         // check
+         // PETScWrappers::MPI::SparseMatrix
+         MPI_Comm mpi_communicator (MPI_COMM_WORLD);
+         int n_jobs=1;
+         MPI_Comm_size (mpi_communicator, &n_jobs);
+         const unsigned int n_mpi_processes=static_cast<unsigned int>(n_jobs);
+         Assert(n_dofs%n_mpi_processes==0, ExcInternalError());
+         const unsigned int n_local_dofs=n_dofs/n_mpi_processes;
+         PETScWrappers::MPI::SparseMatrix
+         v2 (mpi_communicator, n_dofs, n_dofs, n_local_dofs, n_local_dofs, 5);
+         test (v2);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/65.cc
index 0000000000,cf425c8b45..0cad084911
mode 000000,100644..100644
--- a/tests/petsc/65.cc
+++ b/tests/petsc/65.cc
@@@ -1,0 -1,81 +1,81 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 65.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // This test used to fail after upgrading to petsc 2.2.1
+ 
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_parallel_vector.h>
+ 
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test ()
+ {
+   PETScWrappers::MPI::Vector v(PETSC_COMM_WORLD, 100, 100);
+   v(0) = 1;
+   v.compress(VectorOperation::insert);
+   v = 0;
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         test ();
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/66.cc
index 0000000000,a921906e92..4d0a9d550b
mode 000000,100644..100644
--- a/tests/petsc/66.cc
+++ b/tests/petsc/66.cc
@@@ -1,0 -1,139 +1,139 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 66.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::MatrixBase::clear_row ()
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/vector.h>
+ 
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::MatrixBase &m)
+ {
+   Assert (m.m() != 0, ExcInternalError());
+   Assert (m.n() != 0, ExcInternalError());
+ 
+   // build a tri-diagonal pattern
+   double norm_sqr = 0;
+   unsigned int nnz = 0;
+   const unsigned int N = m.m();
+   for (unsigned int i=0; i<N; ++i)
+     {
+       if (i>=5)
+         {
+           const double s = rand();
+           m.add (i,i-5, s);
+           norm_sqr += s*s;
+           ++nnz;
+         }
+ 
+       if (i<N-5)
+         {
+           const double s = rand();
+           m.add (i,i+5, s);
+           norm_sqr += s*s;
+           ++nnz;
+         }
+ 
+       const double s = rand();
+       m.add (i,i,s);
+       norm_sqr += s*s;
+       ++nnz;
+     }
+   m.compress ();
+ 
+   deallog << m.frobenius_norm() << ' ' << std::sqrt (norm_sqr)
+           << std::endl;
+   deallog << m.n_nonzero_elements() << ' ' << nnz << std::endl;
+ 
+   Assert (std::fabs (m.frobenius_norm() - std::sqrt(norm_sqr))
+           < std::fabs (std::sqrt (norm_sqr)),
+           ExcInternalError());
+   Assert (m.n_nonzero_elements()-nnz == 0, ExcInternalError());
+ 
+   // now remove the entries of row N/2
+   for (unsigned int i=0; i<N; ++i)
+     {
+       const double s = m.el(N/2,i);
+       norm_sqr -= s*s;
+     }
+   m.clear_row (N/2);
+ 
+   deallog << m.frobenius_norm() << ' ' << std::sqrt (norm_sqr)
+           << std::endl;
+   deallog << m.n_nonzero_elements() << ' ' << nnz << std::endl;
+ 
+   Assert (std::fabs (m.frobenius_norm() - std::sqrt(norm_sqr))
+           < std::fabs (std::sqrt (norm_sqr)),
+           ExcInternalError());
+ 
+   // make sure that zeroing out rows does at
+   // least not add new nonzero entries (it
+   // may remove some, though)
+   Assert (m.n_nonzero_elements() <= nnz, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::SparseMatrix v (14,14,3);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/67.cc
index 0000000000,5653714578..dc20cb9cf0
mode 000000,100644..100644
--- a/tests/petsc/67.cc
+++ b/tests/petsc/67.cc
@@@ -1,0 -1,147 +1,147 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 67.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::MatrixBase::clear_rows ()
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/vector.h>
+ 
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::MatrixBase &m)
+ {
+   typedef PETScWrappers::MatrixBase::size_type size_type;
+ 
+   Assert (m.m() != 0, ExcInternalError());
+   Assert (m.n() != 0, ExcInternalError());
+ 
+   // build a tri-diagonal pattern
+   double norm_sqr = 0;
+   unsigned int nnz = 0;
+   const size_type N = m.m();
+   for (size_type i=0; i<N; ++i)
+     {
+       if (i>=5)
+         {
+           const double s = rand();
+           m.add (i,i-5, s);
+           norm_sqr += s*s;
+           ++nnz;
+         }
+ 
+       if (i<N-5)
+         {
+           const double s = rand();
+           m.add (i,i+5, s);
+           norm_sqr += s*s;
+           ++nnz;
+         }
+ 
+       const double s = rand();
+       m.add (i,i,s);
+       norm_sqr += s*s;
+       ++nnz;
+     }
+   m.compress ();
+ 
+   deallog << m.frobenius_norm() << ' ' << std::sqrt (norm_sqr)
+           << std::endl;
+   deallog << m.n_nonzero_elements() << ' ' << nnz << std::endl;
+ 
+   Assert (std::fabs (m.frobenius_norm() - std::sqrt(norm_sqr))
+           < std::fabs (std::sqrt (norm_sqr)),
+           ExcInternalError());
+   Assert (m.n_nonzero_elements()-nnz == 0, ExcInternalError());
+ 
+   // now remove the entries of rows N/2 and N/3
+   for (size_type i=0; i<N; ++i)
+     {
+       const double s = m.el(N/2,i);
+       norm_sqr -= s*s;
+     }
+   for (size_type i=0; i<N; ++i)
+     {
+       const double s = m.el(N/3,i);
+       norm_sqr -= s*s;
+     }
+   const size_type rows[2] = { N/3, N/2 };
+   m.clear_rows (std::vector<size_type>(&rows[0], &rows[2]));
+ 
+   deallog << m.frobenius_norm() << ' ' << std::sqrt (norm_sqr)
+           << std::endl;
+   deallog << m.n_nonzero_elements() << ' ' << nnz << std::endl;
+ 
+   Assert (std::fabs (m.frobenius_norm() - std::sqrt(norm_sqr))
+           < std::fabs (std::sqrt (norm_sqr)),
+           ExcInternalError());
+ 
+   // make sure that zeroing out rows does at
+   // least not add new nonzero entries (it
+   // may remove some, though)
+   Assert (m.n_nonzero_elements() <= nnz, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::SparseMatrix v (14,14,3);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/68.cc
index 0000000000,676a852245..5e0d049a68
mode 000000,100644..100644
--- a/tests/petsc/68.cc
+++ b/tests/petsc/68.cc
@@@ -1,0 -1,143 +1,143 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 68.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::MatrixBase::clear_row () with used second argument
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/vector.h>
+ 
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::MatrixBase &m)
+ {
+   Assert (m.m() != 0, ExcInternalError());
+   Assert (m.n() != 0, ExcInternalError());
+ 
+   // build a tri-diagonal pattern
+   double norm_sqr = 0;
+   unsigned int nnz = 0;
+   const unsigned int N = m.m();
+   for (unsigned int i=0; i<N; ++i)
+     {
+       if (i>=5)
+         {
+           const double s = rand();
+           m.add (i,i-5, s);
+           norm_sqr += s*s;
+           ++nnz;
+         }
+ 
+       if (i<N-5)
+         {
+           const double s = rand();
+           m.add (i,i+5, s);
+           norm_sqr += s*s;
+           ++nnz;
+         }
+ 
+       const double s = rand();
+       m.add (i,i,s);
+       norm_sqr += s*s;
+       ++nnz;
+     }
+   m.compress ();
+ 
+   deallog << m.frobenius_norm() << ' ' << std::sqrt (norm_sqr)
+           << std::endl;
+   deallog << m.n_nonzero_elements() << ' ' << nnz << std::endl;
+ 
+   Assert (std::fabs (m.frobenius_norm() - std::sqrt(norm_sqr))
+           < std::fabs (std::sqrt (norm_sqr)),
+           ExcInternalError());
+   Assert (m.n_nonzero_elements()-nnz == 0, ExcInternalError());
+ 
+   // now remove the entries of row N/2. set
+   // diagonal entries to rnd
+   const double rnd = rand();
+   for (unsigned int i=0; i<N; ++i)
+     {
+       const double s = m.el(N/2,i);
+       norm_sqr -= s*s;
+     }
+   norm_sqr += rnd*rnd;
+ 
+   m.clear_row (N/2, rnd);
+ 
+   deallog << m.frobenius_norm() << ' ' << std::sqrt (norm_sqr)
+           << std::endl;
+   deallog << m.n_nonzero_elements() << ' ' << nnz << std::endl;
+ 
+   Assert (std::fabs (m.frobenius_norm() - std::sqrt(norm_sqr))
+           < std::fabs (std::sqrt (norm_sqr)),
+           ExcInternalError());
+ 
+   // make sure that zeroing out rows does at
+   // least not add new nonzero entries (it
+   // may remove some, though)
+   Assert (m.n_nonzero_elements() <= nnz, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::SparseMatrix v (14,14,3);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/69.cc
index 0000000000,55e76a9394..42a5fa0cba
mode 000000,100644..100644
--- a/tests/petsc/69.cc
+++ b/tests/petsc/69.cc
@@@ -1,0 -1,151 +1,151 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 69.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::MatrixBase::clear_rows () with used second argument
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/vector.h>
+ 
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::MatrixBase &m)
+ {
+   Assert (m.m() != 0, ExcInternalError());
+   Assert (m.n() != 0, ExcInternalError());
+ 
+   typedef PETScWrappers::MatrixBase::size_type size_type;
+ 
+   // build a tri-diagonal pattern
+   double norm_sqr = 0;
+   unsigned int nnz = 0;
+   const size_type N = m.m();
+   for (size_type i=0; i<N; ++i)
+     {
+       if (i>=5)
+         {
+           const double s = rand();
+           m.add (i,i-5, s);
+           norm_sqr += s*s;
+           ++nnz;
+         }
+ 
+       if (i<N-5)
+         {
+           const double s = rand();
+           m.add (i,i+5, s);
+           norm_sqr += s*s;
+           ++nnz;
+         }
+ 
+       const double s = rand();
+       m.add (i,i,s);
+       norm_sqr += s*s;
+       ++nnz;
+     }
+   m.compress ();
+ 
+   deallog << m.frobenius_norm() << ' ' << std::sqrt (norm_sqr)
+           << std::endl;
+   deallog << m.n_nonzero_elements() << ' ' << nnz << std::endl;
+ 
+   Assert (std::fabs (m.frobenius_norm() - std::sqrt(norm_sqr))
+           < std::fabs (std::sqrt (norm_sqr)),
+           ExcInternalError());
+   Assert (m.n_nonzero_elements()-nnz == 0, ExcInternalError());
+ 
+   // now remove the entries of rows N/2 and
+   // N/3. set diagonal entries to rnd
+   const double rnd = rand();
+   for (size_type i=0; i<N; ++i)
+     {
+       const double s = m.el(N/2,i);
+       norm_sqr -= s*s;
+     }
+   for (size_type i=0; i<N; ++i)
+     {
+       const double s = m.el(N/3,i);
+       norm_sqr -= s*s;
+     }
+   norm_sqr += 2*rnd*rnd;
+ 
+   const size_type rows[2] = { N/3, N/2 };
+   m.clear_rows (std::vector<size_type>(&rows[0], &rows[2]), rnd);
+ 
+   deallog << m.frobenius_norm() << ' ' << std::sqrt (norm_sqr)
+           << std::endl;
+   deallog << m.n_nonzero_elements() << ' ' << nnz << std::endl;
+ 
+   Assert (std::fabs (m.frobenius_norm() - std::sqrt(norm_sqr))
+           < std::fabs (std::sqrt (norm_sqr)),
+           ExcInternalError());
+ 
+   // make sure that zeroing out rows does at
+   // least not add new nonzero entries (it
+   // may remove some, though)
+   Assert (m.n_nonzero_elements() <= nnz, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::SparseMatrix v (14,14,3);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/70.cc
index 0000000000,bc4132c6be..c2a353b39e
mode 000000,100644..100644
--- a/tests/petsc/70.cc
+++ b/tests/petsc/70.cc
@@@ -1,0 -1,40 +1,40 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: 70.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PetscScalar
+ 
+ #include "../tests.h"
+ #include <deal.II/base/logstream.h>
+ #include <deal.II/lac/petsc_vector.h>
+ 
+ #include <fstream>
+ 
+ int main ()
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   if (typeid(PetscScalar)==typeid(double))
+     deallog << "double" << std::endl;
+   else if (typeid(PetscScalar)==typeid(float))
+     deallog << "float" << std::endl;
+   else
+     Assert(false, ExcNotImplemented());
+ }
diff --cc tests/petsc/block_vector_iterator_01.cc
index 0000000000,e6fa61832a..cfd8a87a66
mode 000000,100644..100644
--- a/tests/petsc/block_vector_iterator_01.cc
+++ b/tests/petsc/block_vector_iterator_01.cc
@@@ -1,0 -1,121 +1,121 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: block_vector_iterator_01.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // make sure that block vector iterator allows reading and writing correctly
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_block_vector.h>
+ #include <fstream>
+ #include <iostream>
+ 
+ 
+ void test ()
+ {
+   PETScWrappers::BlockVector v(2,1);
+   v(0) = 1;
+   v(1) = 2;
+ 
+   // first check reading through a const
+   // iterator
+   {
+     PETScWrappers::BlockVector::const_iterator i=v.begin();
+     Assert (*i == 1, ExcInternalError());
+     ++i;
+     Assert (*i == 2, ExcInternalError());
+   }
+ 
+   // same, but create iterator in a different
+   // way
+   {
+     PETScWrappers::BlockVector::const_iterator
+     i=const_cast<const PETScWrappers::BlockVector &>(v).begin();
+     Assert (*i == 1, ExcInternalError());
+     ++i;
+     Assert (*i == 2, ExcInternalError());
+   }
+ 
+   // read through a read-write iterator
+   {
+     PETScWrappers::BlockVector::iterator i = v.begin();
+     Assert (*i == 1, ExcInternalError());
+     ++i;
+     Assert (*i == 2, ExcInternalError());
+   }
+ 
+   // write through a read-write iterator
+   {
+     PETScWrappers::BlockVector::iterator i = v.begin();
+ 
+     *i = 2;
+     ++i;
+     *i = 3;
+   }
+ 
+   // and read again
+   {
+     PETScWrappers::BlockVector::iterator i = v.begin();
+     Assert (*i == 2, ExcInternalError());
+     ++i;
+     Assert (*i == 3, ExcInternalError());
+   }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         test ();
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/block_vector_iterator_02.cc
index 0000000000,117bc79696..79e5b7ef72
mode 000000,100644..100644
--- a/tests/petsc/block_vector_iterator_02.cc
+++ b/tests/petsc/block_vector_iterator_02.cc
@@@ -1,0 -1,115 +1,115 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: block_vector_iterator_02.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // like _01, except that we use operator[] instead of operator*
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_block_vector.h>
+ #include <fstream>
+ #include <iostream>
+ 
+ 
+ void test ()
+ {
+   PETScWrappers::BlockVector v(2,1);
+   v(0) = 1;
+   v(1) = 2;
+ 
+   // first check reading through a const
+   // iterator
+   {
+     PETScWrappers::BlockVector::const_iterator i=v.begin();
+     Assert (i[0] == 1, ExcInternalError());
+     Assert (i[1] == 2, ExcInternalError());
+   }
+ 
+   // same, but create iterator in a different
+   // way
+   {
+     PETScWrappers::BlockVector::const_iterator
+     i=const_cast<const PETScWrappers::BlockVector &>(v).begin();
+     Assert (i[0] == 1, ExcInternalError());
+     Assert (i[1] == 2, ExcInternalError());
+   }
+ 
+   // read through a read-write iterator
+   {
+     PETScWrappers::BlockVector::iterator i = v.begin();
+     Assert (i[0] == 1, ExcInternalError());
+     Assert (i[1] == 2, ExcInternalError());
+   }
+ 
+   // write through a read-write iterator
+   {
+     PETScWrappers::BlockVector::iterator i = v.begin();
+     i[0] = 2;
+     i[1] = 3;
+   }
+ 
+   // and read again
+   {
+     PETScWrappers::BlockVector::iterator i = v.begin();
+     Assert (i[0] == 2, ExcInternalError());
+     Assert (i[1] == 3, ExcInternalError());
+   }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         test ();
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/block_vector_iterator_03.cc
index 0000000000,8ed06ee623..efdf599c47
mode 000000,100644..100644
--- a/tests/petsc/block_vector_iterator_03.cc
+++ b/tests/petsc/block_vector_iterator_03.cc
@@@ -1,0 -1,370 +1,370 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: block_vector_iterator_03.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2000 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ // this test is an adaptation of lac/block_vector_iterator for PETSc block
+ // vectors
+ 
+ #include "../tests.h"
+ #include <deal.II/base/logstream.h>
+ #include <deal.II/lac/petsc_block_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ #include <algorithm>
+ #include <numeric>
+ #include <utility>
+ #include <cmath>
+ 
+ template <typename number>
+ bool operator == (const PETScWrappers::BlockVector &v1,
+                   const PETScWrappers::BlockVector &v2)
+ {
+   if (v1.size() != v2.size())
+     return false;
+   for (unsigned int i=0; i<v1.size(); ++i)
+     if (v1(i) != v2(i))
+       return false;
+   return true;
+ }
+ 
+ 
+ void test ()
+ {
+   std::vector<types::global_dof_index> ivector(4);
+   ivector[0] = 2;
+   ivector[1] = 4;
+   ivector[2] = 3;
+   ivector[3] = 5;
+ 
+   // Check 1: initialization via
+   // iterators
+   if (true)
+     {
+       PETScWrappers::BlockVector v1(ivector);
+       PETScWrappers::BlockVector v2(ivector);
+ 
+       // initialize first vector with
+       // simple loop
+       for (unsigned int i=0; i<v1.size(); ++i)
+         v1(i) = i;
+       // initialize other vector
+       // through iterators
+       PETScWrappers::BlockVector::iterator p2 = v2.begin();
+       for (unsigned int i=0; i<v1.size(); ++i, ++p2)
+         *p2 = i;
+       Assert (p2==v2.end(), ExcInternalError());
+ 
+       // check that the two vectors are equal
+       deallog << "Check 1: " << (v1==v2 ? "true" : "false") << std::endl;
+     };
+ 
+   // Check 1: initialization via
+   // iterators
+   if (true)
+     {
+       PETScWrappers::BlockVector v1(ivector);
+ 
+       // initialize first vector with
+       // simple loop
+       for (unsigned int i=0; i<v1.size(); ++i)
+         v1(i) = i;
+       // initialize other vector
+       // through iterators into first
+       // vector
+       PETScWrappers::BlockVector v2(ivector, v1.begin(), v1.end());
+       // check that the two vectors are equal
+       deallog << "Check 2: " << (v1==v2 ? "true" : "false") << std::endl;
+     };
+ 
+   // Check 3: loop forward and back
+   // and check that things are the
+   // same
+   if (true)
+     {
+       PETScWrappers::BlockVector v1(ivector);
+       // initialize first vector with
+       // simple loop
+       for (unsigned int i=0; i<v1.size(); ++i)
+         v1(i) = i;
+ 
+       PETScWrappers::BlockVector::iterator p1 = v1.begin();
+       for (unsigned int i=0; i<v1.size(); ++i, ++p1)
+         Assert (*p1 == i, ExcInternalError());
+ 
+       Assert (p1 == v1.end(), ExcInternalError());
+ 
+       // move back into allowable
+       // region
+       --p1;
+ 
+       // check backwards
+       for (unsigned int i=0; i<v1.size(); ++i, --p1)
+         Assert (*p1 == v1.size()-i-1, ExcInternalError());
+ 
+       // if we came thus far,
+       // everything is alright
+       deallog << "Check 3: true" << std::endl;
+     };
+ 
+ 
+   // Check 4: same, but this time
+   // with const iterators
+   if (true)
+     {
+       PETScWrappers::BlockVector v1(ivector);
+       // initialize first vector with
+       // simple loop
+       for (unsigned int i=0; i<v1.size(); ++i)
+         v1(i) = i;
+ 
+       PETScWrappers::BlockVector::const_iterator p1 = v1.begin();
+       for (unsigned int i=0; i<v1.size(); ++i, ++p1)
+         Assert (*p1 == i, ExcInternalError());
+ 
+       Assert (p1 == v1.end(), ExcInternalError());
+ 
+       // move back into allowable
+       // region
+       --p1;
+ 
+       // check backwards
+       for (unsigned int i=0; i<v1.size(); ++i, --p1)
+         {
+           const double val = *p1;
+           const double ref = v1.size()-i-1;
+           Assert (val==ref, ExcInternalError());
+         };
+ 
+       // if we came thus far,
+       // everything is alright
+       deallog << "Check 4: true" << std::endl;
+     };
+ 
+   // Checks 5-14: use some standard
+   // algorithms
+   if (true)
+     {
+       PETScWrappers::BlockVector v1(ivector);
+       // initialize first vector with
+       // simple loop
+       for (unsigned int i=0; i<v1.size(); ++i)
+         v1(i) = i;
+ 
+       // check std::distance
+       // algorithm
+       deallog << "Check 5: "
+               << (std::distance (v1.begin(), v1.end()) ==
+                   static_cast<signed int>(v1.size()) ?
+                   "true" : "false")
+               << std::endl;
+ 
+       // check std::copy
+       PETScWrappers::BlockVector v2(ivector);
+       std::copy (v1.begin(), v1.end(), v2.begin());
+       deallog << "Check 6: " << (v1 == v2 ? "true" : "false") << std::endl;
+ 
+       // check std::transform
+       std::transform (v1.begin(), v1.end(), v2.begin(),
+                       std::bind2nd (std::multiplies<double>(),
+                                     2.0));
+       v2 *= 1./2.;
+       deallog << "Check 7: " << (v1 == v2 ? "true" : "false") << std::endl;
+ 
+ 
+       // check operators +/-, +=/-=
+       deallog << "Check 8: "
+               << (std::distance(v1.begin(), v1.begin()+3) == 3 ?
+                   "true" : "false")
+               << std::endl;
+       deallog << "Check 9: "
+               << (std::distance(v1.end()-6, v1.end()) == 6 ?
+                   "true" : "false")
+               << std::endl;
+       deallog << "Check 10: "
+               << (std::distance(v1.begin(), v1.end()) == (signed)v1.size() ?
+                   "true" : "false")
+               << std::endl;
+       deallog << "Check 11: "
+               << (std::distance(v1.begin(), (v1.begin()+=7)) == 7 ?
+                   "true" : "false")
+               << std::endl;
+       deallog << "Check 12: "
+               << (std::distance((v1.end()-=4), v1.end()) == 4 ?
+                   "true" : "false")
+               << std::endl;
+ 
+       // check advance
+       PETScWrappers::BlockVector::iterator p2 = v1.begin();
+       std::advance (p2, v1.size());
+       deallog << "Check 13: " << (p2 == v1.end() ? "true" : "false") << std::endl;
+ 
+       PETScWrappers::BlockVector::const_iterator p3 = v1.begin();
+       std::advance (p3, v1.size());
+       deallog << "Check 14: " << (p3 == v1.end() ? "true" : "false") << std::endl;
+     };
+ 
+   // Check 15: initialization through
+   // iterators
+   if (true)
+     {
+       PETScWrappers::BlockVector v1(ivector);
+       // initialize first vector with
+       // simple loop
+       for (unsigned int i=0; i<v1.size(); ++i)
+         v1(i) = i;
+ 
+       // initialize a normal vector
+       // from it
+       Vector<double> v2(v1.begin(), v1.end());
+ 
+       // and reverse way
+       PETScWrappers::BlockVector v3(ivector, v2.begin(), v2.end());
+       deallog << "Check 15: " << (v1==v3 ? "true" : "false") << std::endl;
+     };
+ 
+   // Check 16: initialization through
+   // iterators. variant with one
+   // constant object
+   if (true)
+     {
+       PETScWrappers::BlockVector v1(ivector);
+       // initialize first vector with
+       // simple loop
+       for (unsigned int i=0; i<v1.size(); ++i)
+         v1(i) = i;
+ 
+       // initialize a normal vector
+       // from it
+       const Vector<double> v2(v1.begin(), v1.end());
+ 
+       // and reverse way
+       PETScWrappers::BlockVector v3(ivector, v2.begin(), v2.end());
+       deallog << "Check 16: " << (v1==v3 ? "true" : "false") << std::endl;
+     };
+ 
+   // Check 17: initialization through
+   // iterators. variant with two
+   // constant object
+   if (true)
+     {
+       PETScWrappers::BlockVector v1(ivector);
+       // initialize first vector with
+       // simple loop
+       for (unsigned int i=0; i<v1.size(); ++i)
+         v1(i) = i;
+ 
+       // initialize a normal vector
+       // from it
+       const Vector<double> v2(v1.begin(), v1.end());
+ 
+       // and reverse way
+       const PETScWrappers::BlockVector v3(ivector, v2.begin(), v2.end());
+       deallog << "Check 17: " << (v1==v3 ? "true" : "false") << std::endl;
+     };
+ 
+   // Check 18: initialization through
+   // iterators. variant with three
+   // constant object
+   if (true)
+     {
+       PETScWrappers::BlockVector v0(ivector);
+       // initialize first vector with
+       // simple loop
+       for (unsigned int i=0; i<v0.size(); ++i)
+         v0(i) = i;
+ 
+       const PETScWrappers::BlockVector v1 = v0;
+ 
+       // initialize a normal vector
+       // from it
+       const Vector<double> v2(v1.begin(), v1.end());
+ 
+       // and reverse way
+       const PETScWrappers::BlockVector v3(ivector, v2.begin(), v2.end());
+       deallog << "Check 18: " << (v1==v3 ? "true" : "false") << std::endl;
+     };
+ 
+   // Check 19: operator[]
+   if (true)
+     {
+       PETScWrappers::BlockVector v1(ivector);
+       for (unsigned int i=0; i<v1.size(); ++i)
+         v1(i) = i;
+ 
+       for (unsigned int i=0; i<v1.size(); ++i)
+         {
+           const PETScWrappers::BlockVector::iterator p = (v1.begin()+i);
+           for (unsigned int j=0; j<v1.size(); ++j)
+             Assert (p[(signed)j-(signed)i] == j, ExcInternalError());
+         };
+ 
+       // if we came thus far,
+       // everything is alright
+       deallog << "Check 19: true" << std::endl;
+     };
+ }
+ 
+ 
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   logfile.setf(std::ios::fixed);
+   logfile.precision(3);
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         test ();
+       }
+ 
+     }
+   catch (std::exception &e)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << e.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       // abort
+       return 2;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       // abort
+       return 3;
+     };
+ 
+ 
+   return 0;
+ }
+ 
diff --cc tests/petsc/deal_solver_01.cc
index 0000000000,1e73402ba0..a4ce2a41e2
mode 000000,100644..100644
--- a/tests/petsc/deal_solver_01.cc
+++ b/tests/petsc/deal_solver_01.cc
@@@ -1,0 -1,101 +1,101 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: deal_solver_01.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ // test the CG solver using the PETSc matrix and vector classes
+ 
+ 
+ #include "../tests.h"
+ #include "../lac/testmatrix.h"
+ #include <cmath>
+ #include <fstream>
+ #include <iostream>
+ #include <iomanip>
+ #include <deal.II/base/logstream.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/solver_control.h>
+ #include <deal.II/lac/solver_cg.h>
+ #include <deal.II/lac/solver_gmres.h>
+ #include <deal.II/lac/solver_bicgstab.h>
+ #include <deal.II/lac/solver_richardson.h>
+ #include <deal.II/lac/solver_qmrs.h>
+ #include <deal.II/lac/precondition.h>
+ #include <deal.II/lac/vector_memory.h>
+ #include <typeinfo>
+ 
+ template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+ void
+ check_solve( SOLVER &solver, const MATRIX &A,
+              VECTOR &u, VECTOR &f, const PRECONDITION &P)
+ {
+   deallog << "Solver type: " << typeid(solver).name() << std::endl;
+ 
+   u = 0.;
+   f = 1.;
+   try
+     {
+       solver.solve(A,u,f,P);
+     }
+   catch (std::exception &e)
+     {
+       deallog << e.what() << std::endl;
+       abort ();
+     }
+ 
+   deallog << "Solver stopped after " << solver.control().last_step()
+           << " iterations" << std::endl;
+ }
+ 
+ 
+ int main(int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog << std::setprecision(4);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+   {
+     SolverControl control(100, 1.e-3);
+ 
+     const unsigned int size = 32;
+     unsigned int dim = (size-1)*(size-1);
+ 
+     deallog << "Size " << size << " Unknowns " << dim << std::endl;
+ 
+     // Make matrix
+     FDMatrix testproblem(size, size);
+     PETScWrappers::SparseMatrix  A(dim, dim, 5);
+     testproblem.five_point(A);
+ 
+     PETScWrappers::Vector  f(dim);
+     PETScWrappers::Vector  u(dim);
+     f = 1.;
+     A.compress ();
+     f.compress ();
+     u.compress ();
+ 
+     GrowingVectorMemory<PETScWrappers::Vector> mem;
+     SolverCG<PETScWrappers::Vector> solver(control,mem);
+     PreconditionIdentity preconditioner;
+     check_solve (solver, A,u,f, preconditioner);
+   }
+   GrowingVectorMemory<PETScWrappers::Vector>::release_unused_memory ();
+ 
+ }
+ 
diff --cc tests/petsc/deal_solver_02.cc
index 0000000000,46f04c6fa5..4956cb16fc
mode 000000,100644..100644
--- a/tests/petsc/deal_solver_02.cc
+++ b/tests/petsc/deal_solver_02.cc
@@@ -1,0 -1,103 +1,103 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: deal_solver_02.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ // test the BiCGStab solver using the PETSc matrix and vector classes
+ 
+ 
+ 
+ #include "../tests.h"
+ #include "../lac/testmatrix.h"
+ #include <cmath>
+ #include <fstream>
+ #include <iostream>
+ #include <iomanip>
+ #include <deal.II/base/logstream.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/solver_control.h>
+ #include <deal.II/lac/solver_cg.h>
+ #include <deal.II/lac/solver_gmres.h>
+ #include <deal.II/lac/solver_bicgstab.h>
+ #include <deal.II/lac/solver_richardson.h>
+ #include <deal.II/lac/solver_qmrs.h>
+ #include <deal.II/lac/solver.h>
+ #include <deal.II/lac/precondition.h>
+ #include <deal.II/lac/vector_memory.h>
+ #include <typeinfo>
+ 
+ template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+ void
+ check_solve( SOLVER &solver, const MATRIX &A,
+              VECTOR &u, VECTOR &f, const PRECONDITION &P)
+ {
+   deallog << "Solver type: " << typeid(solver).name() << std::endl;
+ 
+   u = 0.;
+   f = 1.;
+   try
+     {
+       solver.solve(A,u,f,P);
+     }
+   catch (std::exception &e)
+     {
+       deallog << e.what() << std::endl;
+       abort ();
+     }
+ 
+   deallog << "Solver stopped after " << solver.control().last_step()
+           << " iterations" << std::endl;
+ }
+ 
+ 
+ int main(int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog << std::setprecision(4);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+   {
+     SolverControl control(100, 1.e-10);
+ 
+     const unsigned int size = 32;
+     unsigned int dim = (size-1)*(size-1);
+ 
+     deallog << "Size " << size << " Unknowns " << dim << std::endl;
+ 
+     // Make matrix
+     FDMatrix testproblem(size, size);
+     PETScWrappers::SparseMatrix  A(dim, dim, 5);
+     testproblem.five_point(A);
+ 
+     PETScWrappers::Vector  f(dim);
+     PETScWrappers::Vector  u(dim);
+     f = 1.;
+     A.compress ();
+     f.compress ();
+     u.compress ();
+ 
+     GrowingVectorMemory<PETScWrappers::Vector> mem;
+     SolverBicgstab<PETScWrappers::Vector> solver(control,mem);
+     PreconditionIdentity preconditioner;
+     check_solve (solver, A,u,f, preconditioner);
+   }
+   GrowingVectorMemory<PETScWrappers::Vector>::release_unused_memory ();
+ 
+ }
+ 
diff --cc tests/petsc/deal_solver_03.cc
index 0000000000,831ebb38ec..186e427779
mode 000000,100644..100644
--- a/tests/petsc/deal_solver_03.cc
+++ b/tests/petsc/deal_solver_03.cc
@@@ -1,0 -1,103 +1,103 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: deal_solver_03.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ // test the GMRES solver using the PETSc matrix and vector classes
+ 
+ 
+ 
+ #include "../tests.h"
+ #include "../lac/testmatrix.h"
+ #include <cmath>
+ #include <fstream>
+ #include <iostream>
+ #include <iomanip>
+ #include <deal.II/base/logstream.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/solver_control.h>
+ #include <deal.II/lac/solver_cg.h>
+ #include <deal.II/lac/solver_gmres.h>
+ #include <deal.II/lac/solver_bicgstab.h>
+ #include <deal.II/lac/solver_richardson.h>
+ #include <deal.II/lac/solver_qmrs.h>
+ #include <deal.II/lac/solver.h>
+ #include <deal.II/lac/precondition.h>
+ #include <deal.II/lac/vector_memory.h>
+ #include <typeinfo>
+ 
+ template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+ void
+ check_solve( SOLVER &solver, const MATRIX &A,
+              VECTOR &u, VECTOR &f, const PRECONDITION &P)
+ {
+   deallog << "Solver type: " << typeid(solver).name() << std::endl;
+ 
+   u = 0.;
+   f = 1.;
+   try
+     {
+       solver.solve(A,u,f,P);
+     }
+   catch (std::exception &e)
+     {
+       deallog << e.what() << std::endl;
+       abort ();
+     }
+ 
+   deallog << "Solver stopped after " << solver.control().last_step()
+           << " iterations" << std::endl;
+ }
+ 
+ 
+ int main(int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog << std::setprecision(4);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+   {
+     SolverControl control(100, 1.e-3);
+ 
+     const unsigned int size = 32;
+     unsigned int dim = (size-1)*(size-1);
+ 
+     deallog << "Size " << size << " Unknowns " << dim << std::endl;
+ 
+     // Make matrix
+     FDMatrix testproblem(size, size);
+     PETScWrappers::SparseMatrix  A(dim, dim, 5);
+     testproblem.five_point(A);
+ 
+     PETScWrappers::Vector  f(dim);
+     PETScWrappers::Vector  u(dim);
+     f = 1.;
+     A.compress ();
+     f.compress ();
+     u.compress ();
+ 
+     GrowingVectorMemory<PETScWrappers::Vector> mem;
+     SolverGMRES<PETScWrappers::Vector> solver(control,mem);
+     PreconditionIdentity preconditioner;
+     check_solve (solver, A,u,f, preconditioner);
+   }
+   GrowingVectorMemory<PETScWrappers::Vector>::release_unused_memory ();
+ 
+ }
+ 
diff --cc tests/petsc/deal_solver_04.cc
index 0000000000,f4a88b8bc4..78354c3fba
mode 000000,100644..100644
--- a/tests/petsc/deal_solver_04.cc
+++ b/tests/petsc/deal_solver_04.cc
@@@ -1,0 -1,102 +1,102 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: deal_solver_04.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ // test the MINRES solver using the PETSc matrix and vector classes
+ 
+ 
+ #include "../tests.h"
+ #include "../lac/testmatrix.h"
+ #include <cmath>
+ #include <fstream>
+ #include <iostream>
+ #include <iomanip>
+ #include <deal.II/base/logstream.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/solver_control.h>
+ #include <deal.II/lac/solver_cg.h>
+ #include <deal.II/lac/solver_gmres.h>
+ #include <deal.II/lac/solver_bicgstab.h>
+ #include <deal.II/lac/solver_richardson.h>
+ #include <deal.II/lac/solver_qmrs.h>
+ #include <deal.II/lac/solver_minres.h>
+ #include <deal.II/lac/precondition.h>
+ #include <deal.II/lac/vector_memory.h>
+ #include <typeinfo>
+ 
+ template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+ void
+ check_solve( SOLVER &solver, const MATRIX &A,
+              VECTOR &u, VECTOR &f, const PRECONDITION &P)
+ {
+   deallog << "Solver type: " << typeid(solver).name() << std::endl;
+ 
+   u = 0.;
+   f = 1.;
+   try
+     {
+       solver.solve(A,u,f,P);
+     }
+   catch (std::exception &e)
+     {
+       deallog << e.what() << std::endl;
+       abort ();
+     }
+ 
+   deallog << "Solver stopped after " << solver.control().last_step()
+           << " iterations" << std::endl;
+ }
+ 
+ 
+ int main(int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   logfile.precision(4);
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+   {
+     SolverControl control(100, 1.e-3);
+ 
+     const unsigned int size = 32;
+     unsigned int dim = (size-1)*(size-1);
+ 
+     deallog << "Size " << size << " Unknowns " << dim << std::endl;
+ 
+     // Make matrix
+     FDMatrix testproblem(size, size);
+     PETScWrappers::SparseMatrix  A(dim, dim, 5);
+     testproblem.five_point(A);
+ 
+     PETScWrappers::Vector  f(dim);
+     PETScWrappers::Vector  u(dim);
+     f = 1.;
+     A.compress ();
+     f.compress ();
+     u.compress ();
+ 
+     GrowingVectorMemory<PETScWrappers::Vector> mem;
+     SolverMinRes<PETScWrappers::Vector> solver(control,mem);
+     PreconditionIdentity preconditioner;
+     check_solve (solver, A,u,f, preconditioner);
+   }
+   GrowingVectorMemory<PETScWrappers::Vector>::release_unused_memory ();
+ 
+ }
+ 
diff --cc tests/petsc/deal_solver_05.cc
index 0000000000,033b498db6..4df0110708
mode 000000,100644..100644
--- a/tests/petsc/deal_solver_05.cc
+++ b/tests/petsc/deal_solver_05.cc
@@@ -1,0 -1,101 +1,101 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: deal_solver_05.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ // test the QMRS solver using the PETSc matrix and vector classes
+ 
+ 
+ #include "../tests.h"
+ #include "../lac/testmatrix.h"
+ #include <cmath>
+ #include <fstream>
+ #include <iostream>
+ #include <iomanip>
+ #include <deal.II/base/logstream.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/solver_control.h>
+ #include <deal.II/lac/solver_cg.h>
+ #include <deal.II/lac/solver_gmres.h>
+ #include <deal.II/lac/solver_bicgstab.h>
+ #include <deal.II/lac/solver_richardson.h>
+ #include <deal.II/lac/solver_qmrs.h>
+ #include <deal.II/lac/precondition.h>
+ #include <deal.II/lac/vector_memory.h>
+ #include <typeinfo>
+ 
+ template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+ void
+ check_solve( SOLVER &solver, const MATRIX &A,
+              VECTOR &u, VECTOR &f, const PRECONDITION &P)
+ {
+   deallog << "Solver type: " << typeid(solver).name() << std::endl;
+ 
+   u = 0.;
+   f = 1.;
+   try
+     {
+       solver.solve(A,u,f,P);
+     }
+   catch (std::exception &e)
+     {
+       deallog << e.what() << std::endl;
+       abort ();
+     }
+ 
+   deallog << "Solver stopped after " << solver.control().last_step()
+           << " iterations" << std::endl;
+ }
+ 
+ 
+ int main(int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   logfile.precision(4);
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+   {
+     SolverControl control(100, 1.e-3);
+ 
+     const unsigned int size = 32;
+     unsigned int dim = (size-1)*(size-1);
+ 
+     deallog << "Size " << size << " Unknowns " << dim << std::endl;
+ 
+     // Make matrix
+     FDMatrix testproblem(size, size);
+     PETScWrappers::SparseMatrix  A(dim, dim, 5);
+     testproblem.five_point(A);
+ 
+     PETScWrappers::Vector  f(dim);
+     PETScWrappers::Vector  u(dim);
+     f = 1.;
+     A.compress ();
+     f.compress ();
+     u.compress ();
+ 
+     GrowingVectorMemory<PETScWrappers::Vector> mem;
+     SolverQMRS<PETScWrappers::Vector> solver(control,mem);
+     PreconditionIdentity preconditioner;
+     check_solve (solver, A,u,f, preconditioner);
+   }
+   GrowingVectorMemory<PETScWrappers::Vector>::release_unused_memory ();
+ 
+ }
+ 
diff --cc tests/petsc/full_matrix_01.cc
index 0000000000,6125db2d92..6eef69a87b
mode 000000,100644..100644
--- a/tests/petsc/full_matrix_01.cc
+++ b/tests/petsc/full_matrix_01.cc
@@@ -1,0 -1,97 +1,97 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: full_matrix_01.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check setting elements in a petsc matrix using
+ // PETScWrappers::FullMatrix::set()
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_full_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ 
+ 
+ void test (PETScWrappers::FullMatrix &m)
+ {
+   // first set a few entries
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       if ((i+2*j+1) % 3 == 0)
+         m.set (i,j, i*j*.5+.5);
+ 
+   m.compress ();
+ 
+   // then make sure we retrieve the same ones
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       if ((i+2*j+1) % 3 == 0)
+         {
+           Assert (m(i,j) == i*j*.5+.5, ExcInternalError());
+           Assert (m.el(i,j) == i*j*.5+.5, ExcInternalError());
+         }
+       else
+         {
+           Assert (m(i,j) == 0, ExcInternalError());
+           Assert (m.el(i,j) == 0, ExcInternalError());
+         }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::FullMatrix m (5,5);
+         test (m);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/full_matrix_02.cc
index 0000000000,629ba76c68..a6300be938
mode 000000,100644..100644
--- a/tests/petsc/full_matrix_02.cc
+++ b/tests/petsc/full_matrix_02.cc
@@@ -1,0 -1,97 +1,97 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: full_matrix_02.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check setting elements in a petsc matrix using
+ // PETScWrappers::FullMatrix::add()
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_full_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ 
+ 
+ void test (PETScWrappers::FullMatrix &m)
+ {
+   // first set a few entries
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       if ((i+2*j+1) % 3 == 0)
+         m.add (i,j, i*j*.5+.5);
+ 
+   m.compress ();
+ 
+   // then make sure we retrieve the same ones
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       if ((i+2*j+1) % 3 == 0)
+         {
+           Assert (m(i,j) == i*j*.5+.5, ExcInternalError());
+           Assert (m.el(i,j) == i*j*.5+.5, ExcInternalError());
+         }
+       else
+         {
+           Assert (m(i,j) == 0, ExcInternalError());
+           Assert (m.el(i,j) == 0, ExcInternalError());
+         }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::FullMatrix m (5,5);
+         test (m);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/full_matrix_04.cc
index 0000000000,b5bfbe95ac..e078e696aa
mode 000000,100644..100644
--- a/tests/petsc/full_matrix_04.cc
+++ b/tests/petsc/full_matrix_04.cc
@@@ -1,0 -1,77 +1,77 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: full_matrix_04.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check querying matrix sizes
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_full_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ 
+ 
+ void test (PETScWrappers::FullMatrix &m)
+ {
+   Assert (m.m() == 5, ExcInternalError());
+   Assert (m.n() == 5, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::FullMatrix m (5,5);
+         test (m);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/full_matrix_05.cc
index 0000000000,36851aa8fc..f4566f42ad
mode 000000,100644..100644
--- a/tests/petsc/full_matrix_05.cc
+++ b/tests/petsc/full_matrix_05.cc
@@@ -1,0 -1,93 +1,93 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: full_matrix_05.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check querying the number of nonzero elements in
+ // PETScWrappers::FullMatrix
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_full_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ 
+ 
+ void test (PETScWrappers::FullMatrix &m)
+ {
+   // first set a few entries. count how many
+   // entries we have
+   unsigned int counter = 0;
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       if ((i+2*j+1) % 3 == 0)
+         {
+           m.set (i,j, i*j*.5+.5);
+           ++counter;
+         }
+ 
+   m.compress ();
+ 
+   // check n_nonzero_elements then
+   // output a dummy number.
+   deallog << counter << std::endl;
+   Assert (m.m() * m.m(), ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::FullMatrix m (5,5);
+         test (m);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/full_matrix_06.cc
index 0000000000,941c32f8fe..1fdf53b9d7
mode 000000,100644..100644
--- a/tests/petsc/full_matrix_06.cc
+++ b/tests/petsc/full_matrix_06.cc
@@@ -1,0 -1,88 +1,88 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: full_matrix_06.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::FullMatrix::l1_norm
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_full_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ 
+ 
+ void test (PETScWrappers::FullMatrix &m)
+ {
+   // first set a few entries. count how many
+   // entries we have
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       if ((i+2*j+1) % 3 == 0)
+         m.set (i,j, i*j*.5+.5);
+ 
+   m.compress ();
+ 
+   // compare against the exact value of the
+   // l1-norm (max col-sum)
+   deallog << m.l1_norm() << std::endl;
+   Assert (m.l1_norm() == 7, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::FullMatrix m (5,5);
+         test (m);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/full_matrix_07.cc
index 0000000000,29d8e07e0c..0202e44cd7
mode 000000,100644..100644
--- a/tests/petsc/full_matrix_07.cc
+++ b/tests/petsc/full_matrix_07.cc
@@@ -1,0 -1,88 +1,88 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: full_matrix_07.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::FullMatrix::linfty_norm
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_full_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ 
+ 
+ void test (PETScWrappers::FullMatrix &m)
+ {
+   // first set a few entries. count how many
+   // entries we have
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       if ((i+2*j+1) % 3 == 0)
+         m.set (i,j, i*j*.5+.5);
+ 
+   m.compress ();
+ 
+   // compare against the exact value of the
+   // linfty-norm (max row-sum)
+   deallog << m.linfty_norm() << std::endl;
+   Assert (m.linfty_norm() == 8.5, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::FullMatrix m (5,5);
+         test (m);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/full_matrix_08.cc
index 0000000000,f3c6201ccb..f082cdb904
mode 000000,100644..100644
--- a/tests/petsc/full_matrix_08.cc
+++ b/tests/petsc/full_matrix_08.cc
@@@ -1,0 -1,93 +1,93 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: full_matrix_08.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::FullMatrix::frobenius_norm
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_full_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ 
+ 
+ void test (PETScWrappers::FullMatrix &m)
+ {
+   // first set a few entries. count how many
+   // entries we have
+   PetscScalar norm = 0;
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       if ((i+2*j+1) % 3 == 0)
+         {
+           m.set (i,j, i*j*.5+.5);
+           norm += (i*j*.5+.5)*(i*j*.5+.5);
+         }
+   norm = std::sqrt(norm);
+ 
+   m.compress ();
+ 
+   // compare against the exact value of the
+   // l2-norm (max row-sum)
+   deallog << m.frobenius_norm() << std::endl;
+   Assert (m.frobenius_norm() == norm, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::FullMatrix m (5,5);
+         test (m);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/full_matrix_09.cc
index 0000000000,a7b0bb8a08..5e6a4f9fce
mode 000000,100644..100644
--- a/tests/petsc/full_matrix_09.cc
+++ b/tests/petsc/full_matrix_09.cc
@@@ -1,0 -1,100 +1,100 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: full_matrix_09.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::FullMatrix::operator *=
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_full_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ 
+ 
+ void test (PETScWrappers::FullMatrix &m)
+ {
+   // first set a few entries
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       if ((i+2*j+1) % 3 == 0)
+         m.set (i,j, i*j*.5+.5);
+ 
+   m.compress ();
+ 
+   // then multiply everything by 1.25 and
+   // make sure we retrieve the values we
+   // expect
+   m *= 1.25;
+ 
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       if ((i+2*j+1) % 3 == 0)
+         {
+           Assert (m(i,j) == (i*j*.5+.5)*1.25, ExcInternalError());
+           Assert (m.el(i,j) == (i*j*.5+.5)*1.25, ExcInternalError());
+         }
+       else
+         {
+           Assert (m(i,j) == 0, ExcInternalError());
+           Assert (m.el(i,j) == 0, ExcInternalError());
+         }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::FullMatrix m (5,5);
+         test (m);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/full_matrix_10.cc
index 0000000000,203f39f0bc..dbb932b745
mode 000000,100644..100644
--- a/tests/petsc/full_matrix_10.cc
+++ b/tests/petsc/full_matrix_10.cc
@@@ -1,0 -1,100 +1,100 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: full_matrix_10.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::FullMatrix::operator /=
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_full_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ 
+ 
+ void test (PETScWrappers::FullMatrix &m)
+ {
+   // first set a few entries
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       if ((i+2*j+1) % 3 == 0)
+         m.set (i,j, i*j*.5+.5);
+ 
+   m.compress ();
+ 
+   // then divide everything by 4/3 and
+   // make sure we retrieve the values we
+   // expect
+   m /= 4./3.;
+ 
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       if ((i+2*j+1) % 3 == 0)
+         {
+           Assert (m(i,j) == (i*j*.5+.5)/4*3, ExcInternalError());
+           Assert (m.el(i,j) == (i*j*.5+.5)/4*3, ExcInternalError());
+         }
+       else
+         {
+           Assert (m(i,j) == 0, ExcInternalError());
+           Assert (m.el(i,j) == 0, ExcInternalError());
+         }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::FullMatrix m (5,5);
+         test (m);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/full_matrix_iterator_01.cc
index 0000000000,94d29eb3cf..23e494eeca
mode 000000,100644..100644
--- a/tests/petsc/full_matrix_iterator_01.cc
+++ b/tests/petsc/full_matrix_iterator_01.cc
@@@ -1,0 -1,85 +1,85 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: full_matrix_iterator_01.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // test PETScWrappers::MatrixBase::const_iterator
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_full_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ 
+ 
+ void test ()
+ {
+   PETScWrappers::FullMatrix m(5,5);
+   m.set (0,0,1);
+   m.set (1,1,2);
+   m.set (1,2,3);
+   m.compress ();
+   PETScWrappers::FullMatrix::const_iterator i = m.begin();
+   deallog << i->row() << ' ' << i->column() << ' ' << i->value() << std::endl;
+   ++i;
+   deallog << i->row() << ' ' << i->column() << ' ' << i->value() << std::endl;
+   i++;
+   deallog << i->row() << ' ' << i->column() << ' ' << i->value() << std::endl;
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         test ();
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/full_matrix_vector_01.cc
index 0000000000,daabd47328..efabc33eef
mode 000000,100644..100644
--- a/tests/petsc/full_matrix_vector_01.cc
+++ b/tests/petsc/full_matrix_vector_01.cc
@@@ -1,0 -1,104 +1,104 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: full_matrix_vector_01.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check FullMatrix::vmult
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_full_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w)
+ {
+   PETScWrappers::FullMatrix m(v.size(),v.size());
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       m.set (i,j, i+2*j);
+ 
+   for (unsigned int i=0; i<v.size(); ++i)
+     v(i) = i;
+ 
+   m.compress ();
+   v.compress ();
+   w.compress ();
+ 
+   // w:=Mv
+   m.vmult (w,v);
+ 
+   // make sure we get the expected result
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       Assert (v(i) == i, ExcInternalError());
+ 
+       double result = 0;
+       for (unsigned int j=0; j<m.m(); ++j)
+         result += (i+2*j)*j;
+       Assert (w(i) == result, ExcInternalError());
+     }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         test (v,w);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/full_matrix_vector_02.cc
index 0000000000,6bf332a6f1..1e8edade61
mode 000000,100644..100644
--- a/tests/petsc/full_matrix_vector_02.cc
+++ b/tests/petsc/full_matrix_vector_02.cc
@@@ -1,0 -1,104 +1,104 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: full_matrix_vector_02.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check FullMatrix::Tvmult
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_full_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w)
+ {
+   PETScWrappers::FullMatrix m(v.size(),v.size());
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       m.set (i,j, i+2*j);
+ 
+   for (unsigned int i=0; i<v.size(); ++i)
+     v(i) = i;
+ 
+   m.compress ();
+   v.compress ();
+   w.compress ();
+ 
+   // w:=Mv
+   m.Tvmult (w,v);
+ 
+   // make sure we get the expected result
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       Assert (v(i) == i, ExcInternalError());
+ 
+       double result = 0;
+       for (unsigned int j=0; j<m.m(); ++j)
+         result += (j+2*i)*j;
+       Assert (w(i) == result, ExcInternalError());
+     }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         test (v,w);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/full_matrix_vector_03.cc
index 0000000000,1309f3cb23..e1b0ccce6c
mode 000000,100644..100644
--- a/tests/petsc/full_matrix_vector_03.cc
+++ b/tests/petsc/full_matrix_vector_03.cc
@@@ -1,0 -1,107 +1,107 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: full_matrix_vector_03.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check FullMatrix::vmult_add
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_full_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w)
+ {
+   PETScWrappers::FullMatrix m(v.size(),v.size());
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       m.set (i,j, i+2*j);
+ 
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       v(i) = i;
+       w(i) = i;
+     }
+ 
+   m.compress ();
+   v.compress ();
+   w.compress ();
+ 
+   // w:=Mv
+   m.vmult_add (w,v);
+ 
+   // make sure we get the expected result
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       Assert (v(i) == i, ExcInternalError());
+ 
+       double result = 0;
+       for (unsigned int j=0; j<m.m(); ++j)
+         result += (i+2*j)*j;
+       Assert (w(i) == i+result, ExcInternalError());
+     }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         test (v,w);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/full_matrix_vector_04.cc
index 0000000000,4ed5c1b261..c451842cc7
mode 000000,100644..100644
--- a/tests/petsc/full_matrix_vector_04.cc
+++ b/tests/petsc/full_matrix_vector_04.cc
@@@ -1,0 -1,107 +1,107 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: full_matrix_vector_04.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check FullMatrix::Tvmult_add
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_full_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w)
+ {
+   PETScWrappers::FullMatrix m(v.size(),v.size());
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       m.set (i,j, i+2*j);
+ 
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       v(i) = i;
+       w(i) = i;
+     }
+ 
+   m.compress ();
+   v.compress ();
+   w.compress ();
+ 
+   // w:=Mv
+   m.Tvmult_add (w,v);
+ 
+   // make sure we get the expected result
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       Assert (v(i) == i, ExcInternalError());
+ 
+       double result = 0;
+       for (unsigned int j=0; j<m.m(); ++j)
+         result += (j+2*i)*j;
+       Assert (w(i) == i+result, ExcInternalError());
+     }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         test (v,w);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/full_matrix_vector_05.cc
index 0000000000,1d67d92f3d..0bc553a380
mode 000000,100644..100644
--- a/tests/petsc/full_matrix_vector_05.cc
+++ b/tests/petsc/full_matrix_vector_05.cc
@@@ -1,0 -1,110 +1,110 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: full_matrix_vector_05.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check FullMatrix::matrix_scalar_product
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_full_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w)
+ {
+   PETScWrappers::FullMatrix m(v.size(),v.size());
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       m.set (i,j, i+2*j);
+ 
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       v(i) = i;
+       w(i) = i+1;
+     }
+ 
+   m.compress ();
+   v.compress ();
+   w.compress ();
+ 
+   // <w,Mv>
+   const PetscScalar s = m.matrix_scalar_product (w,v);
+ 
+   // make sure we get the expected result
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       Assert (v(i) == i, ExcInternalError());
+       Assert (w(i) == i+1, ExcInternalError());
+     }
+ 
+   PetscScalar result = 0;
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       result += (i+2*j)*j*(i+1);
+ 
+   Assert (s == result, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         test (v,w);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/full_matrix_vector_06.cc
index 0000000000,5514768e60..34073abd13
mode 000000,100644..100644
--- a/tests/petsc/full_matrix_vector_06.cc
+++ b/tests/petsc/full_matrix_vector_06.cc
@@@ -1,0 -1,101 +1,101 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: full_matrix_vector_06.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check FullMatrix::matrix_norm_square
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_full_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v)
+ {
+   PETScWrappers::FullMatrix m(v.size(),v.size());
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       m.set (i,j, i+2*j);
+ 
+   for (unsigned int i=0; i<v.size(); ++i)
+     v(i) = i;
+ 
+   m.compress ();
+   v.compress ();
+ 
+   // <w,Mv>
+   const PetscScalar s = m.matrix_norm_square (v);
+ 
+   // make sure we get the expected result
+   for (unsigned int i=0; i<v.size(); ++i)
+     Assert (v(i) == i, ExcInternalError());
+ 
+   PetscScalar result = 0;
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       result += (i+2*j)*j*i;
+ 
+   Assert (s == result, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (30);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/full_matrix_vector_07.cc
index 0000000000,4eead31ae6..8cf09746e6
mode 000000,100644..100644
--- a/tests/petsc/full_matrix_vector_07.cc
+++ b/tests/petsc/full_matrix_vector_07.cc
@@@ -1,0 -1,113 +1,113 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: full_matrix_vector_07.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check FullMatrix::matrix_norm_square
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_full_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w,
+            PETScWrappers::Vector &x)
+ {
+   PETScWrappers::FullMatrix m(v.size(),v.size());
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       m.set (i,j, i+2*j);
+ 
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       v(i) = i;
+       w(i) = i+1;
+     }
+ 
+   m.compress ();
+   v.compress ();
+   w.compress ();
+ 
+   // x=w-Mv
+   const double s = m.residual (x, v, w);
+ 
+   // make sure we get the expected result
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       Assert (v(i) == i, ExcInternalError());
+       Assert (w(i) == i+1, ExcInternalError());
+ 
+       double result = i+1;
+       for (unsigned int j=0; j<m.m(); ++j)
+         result -= (i+2*j)*j;
+ 
+       Assert (x(i) == result, ExcInternalError());
+     }
+ 
+   Assert (s == x.l2_norm(), ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         PETScWrappers::Vector x (100);
+         test (v,w,x);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/parallel_sparse_matrix_01.cc
index 0000000000,fc1cfb4e94..8ce30ee352
mode 000000,100644..100644
--- a/tests/petsc/parallel_sparse_matrix_01.cc
+++ b/tests/petsc/parallel_sparse_matrix_01.cc
@@@ -1,0 -1,159 +1,159 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: parallel_sparse_matrix_01.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // PETScWrappers::MPI::SparseMatrix::reinit(CompressedSparsityPattern) should
+ // create a matrix that, when filled with elements that match the sparsity
+ // pattern, doesn't require any more memory allocation any more. This is
+ // tricky to get right, though, and took a while until it worked.
+ //
+ // the test itself can only check this when run in parallel, but we can add it
+ // anyway to the testsuite. in order to check that the library actually does
+ // what it is supposed to do, run this program with more than one MPI process
+ // and with the option -log_info. All the output should say that no additional
+ // malloc calls have been performed
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_parallel_sparse_matrix.h>
+ #include <deal.II/lac/compressed_sparsity_pattern.h>
+ #include <fstream>
+ #include <cstdlib>
+ 
+ 
+ unsigned int
+ get_n_mpi_processes ()
+ {
+   int n_jobs;
+   MPI_Comm_size (MPI_COMM_WORLD, &n_jobs);
+ 
+   return n_jobs;
+ }
+ 
+ 
+ 
+ unsigned int
+ get_this_mpi_process ()
+ {
+   int rank;
+   MPI_Comm_rank (MPI_COMM_WORLD, &rank);
+ 
+   return rank;
+ }
+ 
+ 
+ void test ()
+ {
+   typedef PETScWrappers::MPI::SparseMatrix::size_type size_type;
+ 
+   // create a parallel matrix where the first
+   // process has 10 rows, the second one 20,
+   // the third one 30, and so on
+   unsigned int N = 0;
+   std::vector<size_type> local_rows_per_process (get_n_mpi_processes());
+   std::vector<size_type> start_row (get_n_mpi_processes());
+   for (unsigned int i=0; i<get_n_mpi_processes(); ++i)
+     {
+       N += (i+1)*10;
+       local_rows_per_process[i] = (i+1)*10;
+       start_row[i] += i*10;
+     }
+ 
+   // here is a sparsity pattern for which we
+   // used to allocate additional memory for 2
+   // processes. note that only one of the
+   // four blocks uses Inodes
+   CompressedSparsityPattern csp (N,N);
+   for (unsigned int i=0; i<N; ++i)
+     for (unsigned int j=0; j<N; ++j)
+       {
+         csp.add (i,i);
+         if (i+local_rows_per_process.back() < N)
+           csp.add (i,i+local_rows_per_process.back());
+         if (i > local_rows_per_process.back())
+           csp.add (i,i-local_rows_per_process.back());
+       }
+ 
+   // here is a sparsity pattern for which no
+   // Inodes are used, but it doesn't allocate
+   // additional memory
+ //   for (unsigned int bi=0; bi<get_n_mpi_processes(); ++bi)
+ //     for (unsigned int bj=0; bj<get_n_mpi_processes(); ++bj)
+ //       for (unsigned int i=0; i<local_rows_per_process[bi]; ++i)
+ //         for (unsigned int k=0; k<6; ++k)
+ //           csp.add (start_row[bi] + i,
+ //                    start_row[bj] + (i+2*k) % local_rows_per_process[bj]);
+ 
+ 
+ 
+   // now create a matrix with this sparsity
+   // pattern
+   PETScWrappers::MPI::SparseMatrix m;
+   m.reinit (MPI_COMM_WORLD, csp, local_rows_per_process,
+             local_rows_per_process, get_this_mpi_process());
+ 
+   // no write into the exact same matrix
+   // entries as have been created by the
+   // sparsity pattern above
+   for (unsigned int i=0; i<N; ++i)
+     for (unsigned int j=0; j<csp.row_length(i); ++j)
+       m.add (i, csp.column_number(i,j), 1.);
+ 
+   m.compress ();
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       test ();
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/petsc_mf_testmatrix.h
index 0000000000,6132e73afe..c7b46da1d7
mode 000000,100644..100644
--- a/tests/petsc/petsc_mf_testmatrix.h
+++ b/tests/petsc/petsc_mf_testmatrix.h
@@@ -1,0 -1,162 +1,162 @@@
 -// $Id$
++// $Id: petsc_mf_testmatrix.h 30045 2013-07-18 19:18:00Z maier $
+ 
+ #include "../tests.h"
+ #include <deal.II/base/exceptions.h>
+ #include <iostream>
+ #include <deal.II/lac/petsc_matrix_free.h>
+ #include <deal.II/lac/vector.h>
+ 
+ // A variant of the tests/lac/testmatrix.h file that uses the PETSc
+ // matrix free interface
+ 
+ 
+ /**
+  * Finite difference PETSc matrix-free object on uniform grid.
+  * Generator for simple 5-point discretization of Laplace problem.
+  */
+ 
+ class PetscFDMatrix : public dealii::PETScWrappers::MatrixFree
+ {
+ public:
+   /**
+    * Constructor specifying grid resolution.
+    */
+   PetscFDMatrix(unsigned int size, unsigned int dim);
+ 
+   /**
+    * Matrix-vector multiplication:
+    * let <i>dst = M*src</i> with
+    * <i>M</i> being this matrix.
+    *
+    * Source and destination must
+    * not be the same vector.
+    */
+   void vmult (dealii::PETScWrappers::VectorBase       &dst,
+               const dealii::PETScWrappers::VectorBase &src) const;
+ 
+   /**
+    * Matrix-vector multiplication: let
+    * <i>dst = M<sup>T</sup>*src</i> with
+    * <i>M</i> being this matrix. This
+    * function does the same as @p vmult()
+    * but takes the transposed matrix.
+    *
+    * Source and destination must
+    * not be the same vector.
+    */
+   void Tvmult (dealii::PETScWrappers::VectorBase       &dst,
+                const dealii::PETScWrappers::VectorBase &src) const;
+ 
+   /**
+    * Adding Matrix-vector
+    * multiplication. Add
+    * <i>M*src</i> on <i>dst</i>
+    * with <i>M</i> being this
+    * matrix.
+    *
+    * Source and destination must
+    * not be the same vector.
+    */
+   void vmult_add (dealii::PETScWrappers::VectorBase       &dst,
+                   const dealii::PETScWrappers::VectorBase &src) const;
+ 
+   /**
+    * Adding Matrix-vector
+    * multiplication. Add
+    * <i>M<sup>T</sup>*src</i> to
+    * <i>dst</i> with <i>M</i> being
+    * this matrix. This function
+    * does the same as @p vmult_add()
+    * but takes the transposed
+    * matrix.
+    *
+    * Source and destination must
+    * not be the same vector.
+    */
+   void Tvmult_add (dealii::PETScWrappers::VectorBase       &dst,
+                    const dealii::PETScWrappers::VectorBase &src) const;
+ 
+ private:
+   /**
+    * Number of gridpoints in x-direction.
+    */
+   unsigned int nx;
+ 
+   /**
+    * Number of gridpoints in y-direction.
+    */
+   unsigned int ny;
+ };
+ 
+ 
+ // --------------- inline and template functions -----------------
+ 
+ inline
+ PetscFDMatrix::PetscFDMatrix(unsigned int size, unsigned int dim)
+   : PETScWrappers::MatrixFree (dim, dim, dim, dim),
+     nx (size), ny (size)
+ {}
+ 
+ 
+ 
+ inline
+ void
+ PetscFDMatrix::vmult_add (dealii::PETScWrappers::VectorBase       &dst,
+                           const dealii::PETScWrappers::VectorBase &src) const
+ {
+   for (unsigned int i=0; i<=ny-2; i++)
+     {
+       for (unsigned int j=0; j<=nx-2; j++)
+         {
+           // Number of the row to be entered
+           unsigned int row = j+(nx-1)*i;
+ 
+           dst(row) += 4. * src(row);              // A.set(row, row, 4.);
+ 
+           if (j>0)
+             {
+               dst(row-1) += -1. * src(row);       // A.set(row-1, row, -1.);
+               dst(row) += -1. * src(row-1);       // A.set(row, row-1, -1.);
+             }
+           if (i>0)
+             {
+               dst(row-(nx-1)) += -1. * src(row);  // A.set(row-(nx-1), row, -1.);
+               dst(row) += -1. * src(row-(nx-1));  // A.set(row, row-(nx-1), -1.);
+             }
+         }
+     }
+ }
+ 
+ 
+ 
+ inline
+ void
+ PetscFDMatrix::vmult (dealii::PETScWrappers::VectorBase       &dst,
+                       const dealii::PETScWrappers::VectorBase &src) const
+ {
+   dst = 0;
+   vmult_add (dst, src);
+ }
+ 
+ 
+ 
+ inline
+ void
+ PetscFDMatrix::Tvmult (dealii::PETScWrappers::VectorBase       &dst,
+                        const dealii::PETScWrappers::VectorBase &src) const
+ {
+   dst = 0;
+   vmult_add (dst, src);
+ }
+ 
+ 
+ 
+ inline
+ void
+ PetscFDMatrix::Tvmult_add (dealii::PETScWrappers::VectorBase       &dst,
+                            const dealii::PETScWrappers::VectorBase &src) const
+ {
+   vmult_add (dst, src);
+ }
+ 
+ 
diff --cc tests/petsc/slowness_01.cc
index 0000000000,7290ec6caa..38cd2ad60d
mode 000000,100644..100644
--- a/tests/petsc/slowness_01.cc
+++ b/tests/petsc/slowness_01.cc
@@@ -1,0 -1,149 +1,149 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: slowness_01.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2005 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // this is part of a whole suite of tests that checks the relative speed of
+ // using PETSc for sparse matrices as compared to the speed of our own
+ // library. the tests therefore may not all actually use PETSc, but they are
+ // meant to compare it
+ //
+ // the tests build the 5-point stencil matrix for a uniform grid of size N*N
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/sparse_matrix.h>
+ #include <deal.II/lac/vector.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ 
+ 
+ void test ()
+ {
+   const unsigned int N = 200;
+ 
+   // first build the sparsity pattern
+   SparsityPattern sparsity (N*N, N*N, 5);
+   for (unsigned int i=0; i<N; i++)
+     for (unsigned int j=0; j<N; j++)
+       {
+         const unsigned int global = i*N+j;
+         sparsity.add(global, global);
+         if (j>0)
+           {
+             sparsity.add(global-1, global);
+             sparsity.add(global, global-1);
+           }
+         if (j<N-1)
+           {
+             sparsity.add(global+1, global);
+             sparsity.add(global, global+1);
+           }
+         if (i>0)
+           {
+             sparsity.add(global-N, global);
+             sparsity.add(global, global-N);
+           }
+         if (i<N-1)
+           {
+             sparsity.add(global+N, global);
+             sparsity.add(global, global+N);
+           }
+       }
+   sparsity.compress();
+ 
+ 
+   // next build the sparse matrix itself
+   SparseMatrix<double> matrix (sparsity);
+   for (unsigned int i=0; i<N; i++)
+     for (unsigned int j=0; j<N; j++)
+       {
+         const unsigned int global = i*N+j;
+         matrix.add(global, global, 4);
+         if (j>0)
+           {
+             matrix.add(global-1, global, -1);
+             matrix.add(global, global-1, -1);
+           }
+         if (j<N-1)
+           {
+             matrix.add(global+1, global, -1);
+             matrix.add(global, global+1, -1);
+           }
+         if (i>0)
+           {
+             matrix.add(global-N, global, -1);
+             matrix.add(global, global-N, -1);
+           }
+         if (i<N-1)
+           {
+             matrix.add(global+N, global, -1);
+             matrix.add(global, global+N, -1);
+           }
+       }
+ 
+   // then do a single matrix-vector
+   // multiplication with subsequent formation
+   // of the matrix norm
+   Vector<double> v1(N*N), v2(N*N);
+   for (unsigned int i=0; i<N*N; ++i)
+     v1(i) = i;
+   matrix.vmult (v2, v1);
+ 
+   deallog << v1 *v2 << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         test ();
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/slowness_02.cc
index 0000000000,9611d27990..cbfa514072
mode 000000,100644..100644
--- a/tests/petsc/slowness_02.cc
+++ b/tests/petsc/slowness_02.cc
@@@ -1,0 -1,120 +1,120 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: slowness_02.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2005 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // this is part of a whole suite of tests that checks the relative speed of
+ // using PETSc for sparse matrices as compared to the speed of our own
+ // library. the tests therefore may not all actually use PETSc, but they are
+ // meant to compare it
+ //
+ // the tests build the 5-point stencil matrix for a uniform grid of size N*N
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/sparse_matrix.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ 
+ 
+ void test ()
+ {
+   const unsigned int N = 200;
+ 
+   // build the sparse matrix
+   PETScWrappers::SparseMatrix matrix (N*N, N*N, 5);
+   for (unsigned int i=0; i<N; i++)
+     for (unsigned int j=0; j<N; j++)
+       {
+         const unsigned int global = i*N+j;
+         matrix.add(global, global, 4);
+         if (j>0)
+           {
+             matrix.add(global-1, global, -1);
+             matrix.add(global, global-1, -1);
+           }
+         if (j<N-1)
+           {
+             matrix.add(global+1, global, -1);
+             matrix.add(global, global+1, -1);
+           }
+         if (i>0)
+           {
+             matrix.add(global-N, global, -1);
+             matrix.add(global, global-N, -1);
+           }
+         if (i<N-1)
+           {
+             matrix.add(global+N, global, -1);
+             matrix.add(global, global+N, -1);
+           }
+       }
+   matrix.compress ();
+ 
+ 
+   // then do a single matrix-vector
+   // multiplication with subsequent formation
+   // of the matrix norm
+   PETScWrappers::Vector v1(N*N), v2(N*N);
+   for (unsigned int i=0; i<N*N; ++i)
+     v1(i) = i;
+   matrix.vmult (v2, v1);
+ 
+   deallog << v1 *v2 << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         test ();
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/slowness_03.cc
index 0000000000,d004153eb0..4c3b7fc142
mode 000000,100644..100644
--- a/tests/petsc/slowness_03.cc
+++ b/tests/petsc/slowness_03.cc
@@@ -1,0 -1,123 +1,123 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: slowness_03.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2005 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // this is part of a whole suite of tests that checks the relative speed of
+ // using PETSc for sparse matrices as compared to the speed of our own
+ // library. the tests therefore may not all actually use PETSc, but they are
+ // meant to compare it
+ //
+ // the tests build the 5-point stencil matrix for a uniform grid of size N*N
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/sparse_matrix.h>
+ #include <deal.II/lac/petsc_parallel_sparse_matrix.h>
+ #include <deal.II/lac/petsc_parallel_vector.h>
+ #include <fstream>
+ #include <iostream>
+ 
+ 
+ void test ()
+ {
+   const unsigned int N = 200;
+ 
+   // build the sparse matrix
+   PETScWrappers::MPI::SparseMatrix matrix (PETSC_COMM_WORLD,
+                                            N*N, N*N,
+                                            N*N, N*N,
+                                            5);
+   for (unsigned int i=0; i<N; i++)
+     for (unsigned int j=0; j<N; j++)
+       {
+         const unsigned int global = i*N+j;
+         matrix.add(global, global, 4);
+         if (j>0)
+           {
+             matrix.add(global-1, global, -1);
+             matrix.add(global, global-1, -1);
+           }
+         if (j<N-1)
+           {
+             matrix.add(global+1, global, -1);
+             matrix.add(global, global+1, -1);
+           }
+         if (i>0)
+           {
+             matrix.add(global-N, global, -1);
+             matrix.add(global, global-N, -1);
+           }
+         if (i<N-1)
+           {
+             matrix.add(global+N, global, -1);
+             matrix.add(global, global+N, -1);
+           }
+       }
+   matrix.compress ();
+ 
+   // then do a single matrix-vector
+   // multiplication with subsequent formation
+   // of the matrix norm
+   PETScWrappers::MPI::Vector v1(PETSC_COMM_WORLD, N*N, N*N);
+   PETScWrappers::MPI::Vector v2(PETSC_COMM_WORLD, N*N, N*N);
+   for (unsigned int i=0; i<N*N; ++i)
+     v1(i) = i;
+   matrix.vmult (v2, v1);
+ 
+   deallog << v1 *v2 << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         test ();
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/slowness_04.cc
index 0000000000,221ff38714..c48f038555
mode 000000,100644..100644
--- a/tests/petsc/slowness_04.cc
+++ b/tests/petsc/slowness_04.cc
@@@ -1,0 -1,154 +1,154 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: slowness_04.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2005 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // this is part of a whole suite of tests that checks the relative speed of
+ // using PETSc for sparse matrices as compared to the speed of our own
+ // library. the tests therefore may not all actually use PETSc, but they are
+ // meant to compare it
+ //
+ // the tests build the 5-point stencil matrix for a uniform grid of size N*N
+ //
+ // this test does the same as the _03 test, except that it does not allocate
+ // the entries in consecutive order, but in pseudo-random order. the reason is
+ // that in usual finite element programs, we do not write to the elements of a
+ // matrix in a consecutive fashion, but rather according to the order of
+ // degrees of freedom in the sequence of cells that we traverse
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/sparse_matrix.h>
+ #include <deal.II/lac/petsc_parallel_sparse_matrix.h>
+ #include <deal.II/lac/petsc_parallel_vector.h>
+ #include <fstream>
+ #include <iostream>
+ 
+ 
+ void test ()
+ {
+   const unsigned int N = 200;
+ 
+   // first find a random permutation of the
+   // indices
+   std::vector<unsigned int> permutation (N);
+   {
+     std::vector<unsigned int> unused_indices (N);
+     for (unsigned int i=0; i<N; i++)
+       unused_indices[i] = i;
+ 
+     for (unsigned int i=0; i<N; i++)
+       {
+         // pick a random element among the
+         // unused indices
+         const unsigned int k = rand() % (N-i);
+         permutation[i] = unused_indices[k];
+ 
+         // then swap this used element to the
+         // end where we won't consider it any
+         // more
+         std::swap (unused_indices[k], unused_indices[N-i-1]);
+       }
+   }
+ 
+   // build the sparse matrix
+   PETScWrappers::MPI::SparseMatrix matrix (PETSC_COMM_WORLD,
+                                            N*N, N*N,
+                                            N*N, N*N,
+                                            5);
+   for (unsigned int i_=0; i_<N; i_++)
+     for (unsigned int j_=0; j_<N; j_++)
+       {
+         const unsigned int i=permutation[i_];
+         const unsigned int j=permutation[j_];
+ 
+         const unsigned int global = i*N+j;
+         matrix.add(global, global, rand());
+         if (j>0)
+           {
+             matrix.add(global-1, global, rand());
+             matrix.add(global, global-1, rand());
+           }
+         if (j<N-1)
+           {
+             matrix.add(global+1, global, rand());
+             matrix.add(global, global+1, rand());
+           }
+         if (i>0)
+           {
+             matrix.add(global-N, global, rand());
+             matrix.add(global, global-N, rand());
+           }
+         if (i<N-1)
+           {
+             matrix.add(global+N, global, rand());
+             matrix.add(global, global+N, rand());
+           }
+       }
+   matrix.compress ();
+ 
+   // then do a single matrix-vector
+   // multiplication with subsequent formation
+   // of the matrix norm
+   PETScWrappers::MPI::Vector v1(PETSC_COMM_WORLD, N*N, N*N);
+   PETScWrappers::MPI::Vector v2(PETSC_COMM_WORLD, N*N, N*N);
+   for (unsigned int i=0; i<N*N; ++i)
+     v1(i) = i;
+   matrix.vmult (v2, v1);
+ 
+   deallog << v1 *v2 << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         test ();
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/solver_01.cc
index 0000000000,5c68a79f41..88d6a13099
mode 000000,100644..100644
--- a/tests/petsc/solver_01.cc
+++ b/tests/petsc/solver_01.cc
@@@ -1,0 -1,93 +1,93 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: solver_01.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ // test the PETSc Richardson solver
+ 
+ 
+ #include "../tests.h"
+ #include "../lac/testmatrix.h"
+ #include <cmath>
+ #include <fstream>
+ #include <iostream>
+ #include <iomanip>
+ #include <deal.II/base/logstream.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_solver.h>
+ #include <deal.II/lac/petsc_precondition.h>
+ #include <deal.II/lac/vector_memory.h>
+ #include <typeinfo>
+ 
+ template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+ void
+ check_solve( SOLVER &solver, const MATRIX &A,
+              VECTOR &u, VECTOR &f, const PRECONDITION &P)
+ {
+   deallog << "Solver type: " << typeid(solver).name() << std::endl;
+ 
+   u = 0.;
+   f = 1.;
+   try
+     {
+       solver.solve(A,u,f,P);
+     }
+   catch (dealii::SolverControl::NoConvergence &e)
+     {
+       deallog << "Exception: " << e.get_exc_name() << std::endl;
+     }
+ 
+   deallog << "Solver stopped after " << solver.control().last_step()
+           << " iterations" << std::endl;
+ }
+ 
+ 
+ int main(int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog << std::setprecision(4);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+   {
+     SolverControl control(100, 1.e-3);
+ 
+     const unsigned int size = 32;
+     unsigned int dim = (size-1)*(size-1);
+ 
+     deallog << "Size " << size << " Unknowns " << dim << std::endl;
+ 
+     // Make matrix
+     FDMatrix testproblem(size, size);
+     PETScWrappers::SparseMatrix  A(dim, dim, 5);
+     testproblem.five_point(A);
+ 
+     PETScWrappers::Vector  f(dim);
+     PETScWrappers::Vector  u(dim);
+     f = 1.;
+     A.compress ();
+     f.compress ();
+     u.compress ();
+ 
+     PETScWrappers::SolverRichardson solver(control);
+     PETScWrappers::PreconditionJacobi preconditioner(A);
+     check_solve (solver, A,u,f, preconditioner);
+   }
+ 
+ }
+ 
diff --cc tests/petsc/solver_02.cc
index 0000000000,baf08b9793..a4c0ba388e
mode 000000,100644..100644
--- a/tests/petsc/solver_02.cc
+++ b/tests/petsc/solver_02.cc
@@@ -1,0 -1,93 +1,93 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: solver_02.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ // test the PETSc Chebychev solver
+ 
+ 
+ #include "../tests.h"
+ #include "../lac/testmatrix.h"
+ #include <cmath>
+ #include <fstream>
+ #include <iostream>
+ #include <iomanip>
+ #include <deal.II/base/logstream.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_solver.h>
+ #include <deal.II/lac/petsc_precondition.h>
+ #include <deal.II/lac/vector_memory.h>
+ #include <typeinfo>
+ 
+ template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+ void
+ check_solve( SOLVER &solver, const MATRIX &A,
+              VECTOR &u, VECTOR &f, const PRECONDITION &P)
+ {
+   deallog << "Solver type: " << typeid(solver).name() << std::endl;
+ 
+   u = 0.;
+   f = 1.;
+   try
+     {
+       solver.solve(A,u,f,P);
+     }
+   catch (dealii::SolverControl::NoConvergence &e)
+     {
+       deallog << "Exception: " << e.get_exc_name() << std::endl;
+     }
+ 
+   deallog << "Solver stopped after " << solver.control().last_step()
+           << " iterations" << std::endl;
+ }
+ 
+ 
+ int main(int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog << std::setprecision(4);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+   {
+     SolverControl control(100, 1.e-3);
+ 
+     const unsigned int size = 32;
+     unsigned int dim = (size-1)*(size-1);
+ 
+     deallog << "Size " << size << " Unknowns " << dim << std::endl;
+ 
+     // Make matrix
+     FDMatrix testproblem(size, size);
+     PETScWrappers::SparseMatrix  A(dim, dim, 5);
+     testproblem.five_point(A);
+ 
+     PETScWrappers::Vector  f(dim);
+     PETScWrappers::Vector  u(dim);
+     f = 1.;
+     A.compress ();
+     f.compress ();
+     u.compress ();
+ 
+     PETScWrappers::SolverChebychev solver(control);
+     PETScWrappers::PreconditionJacobi preconditioner(A);
+     check_solve (solver, A,u,f, preconditioner);
+   }
+ 
+ }
+ 
diff --cc tests/petsc/solver_03.cc
index 0000000000,57b908cc00..5fbdca2b27
mode 000000,100644..100644
--- a/tests/petsc/solver_03.cc
+++ b/tests/petsc/solver_03.cc
@@@ -1,0 -1,94 +1,94 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: solver_03.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ // test the PETSc CG solver
+ 
+ 
+ #include "../tests.h"
+ #include "../lac/testmatrix.h"
+ #include <cmath>
+ #include <fstream>
+ #include <iostream>
+ #include <iomanip>
+ #include <deal.II/base/logstream.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_solver.h>
+ #include <deal.II/lac/petsc_precondition.h>
+ #include <deal.II/lac/vector_memory.h>
+ #include <typeinfo>
+ 
+ template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+ void
+ check_solve( SOLVER &solver, const MATRIX &A,
+              VECTOR &u, VECTOR &f, const PRECONDITION &P)
+ {
+   deallog << "Solver type: " << typeid(solver).name() << std::endl;
+ 
+   u = 0.;
+   f = 1.;
+   try
+     {
+       solver.solve(A,u,f,P);
+     }
+   catch (std::exception &e)
+     {
+       deallog << e.what() << std::endl;
+       abort ();
+     }
+ 
+   deallog << "Solver stopped after " << solver.control().last_step()
+           << " iterations" << std::endl;
+ }
+ 
+ 
+ int main(int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog << std::setprecision(4);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+   {
+     SolverControl control(100, 1.e-3);
+ 
+     const unsigned int size = 32;
+     unsigned int dim = (size-1)*(size-1);
+ 
+     deallog << "Size " << size << " Unknowns " << dim << std::endl;
+ 
+     // Make matrix
+     FDMatrix testproblem(size, size);
+     PETScWrappers::SparseMatrix  A(dim, dim, 5);
+     testproblem.five_point(A);
+ 
+     PETScWrappers::Vector  f(dim);
+     PETScWrappers::Vector  u(dim);
+     f = 1.;
+     A.compress ();
+     f.compress ();
+     u.compress ();
+ 
+     PETScWrappers::SolverCG solver(control);
+     PETScWrappers::PreconditionJacobi preconditioner(A);
+     check_solve (solver, A,u,f, preconditioner);
+   }
+ 
+ }
+ 
diff --cc tests/petsc/solver_03_mf.cc
index 0000000000,84428afb54..abd162aeab
mode 000000,100644..100644
--- a/tests/petsc/solver_03_mf.cc
+++ b/tests/petsc/solver_03_mf.cc
@@@ -1,0 -1,92 +1,92 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: solver_03_mf.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ // test the PETSc CG solver with PETSc MatrixFree class
+ 
+ 
+ #include "../tests.h"
+ #include "petsc_mf_testmatrix.h"
+ #include <cmath>
+ #include <fstream>
+ #include <iostream>
+ #include <iomanip>
+ #include <deal.II/base/logstream.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_solver.h>
+ #include <deal.II/lac/petsc_precondition.h>
+ #include <deal.II/lac/vector_memory.h>
+ #include <typeinfo>
+ 
+ template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+ void
+ check_solve( SOLVER &solver, const MATRIX &A,
+              VECTOR &u, VECTOR &f, const PRECONDITION &P)
+ {
+   deallog << "Solver type: " << typeid(solver).name() << std::endl;
+ 
+   u = 0.;
+   f = 1.;
+   try
+     {
+       solver.solve(A,u,f,P);
+     }
+   catch (std::exception &e)
+     {
+       std::cout << e.what() << std::endl;
+       deallog << e.what() << std::endl;
+       abort ();
+     }
+ 
+   deallog << "Solver stopped after " << solver.control().last_step()
+           << " iterations" << std::endl;
+ }
+ 
+ 
+ int main(int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog << std::setprecision(4);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+   {
+     SolverControl control(100, 1.e-3);
+ 
+     const unsigned int size = 32;
+     unsigned int dim = (size-1)*(size-1);
+ 
+     deallog << "Size " << size << " Unknowns " << dim << std::endl;
+ 
+     PetscFDMatrix  A(size, dim);
+ 
+     PETScWrappers::Vector  f(dim);
+     PETScWrappers::Vector  u(dim);
+     f = 1.;
+     A.compress ();
+     f.compress ();
+     u.compress ();
+ 
+     PETScWrappers::SolverCG solver(control);
+     PETScWrappers::PreconditionNone preconditioner(A);
+     check_solve (solver, A,u,f, preconditioner);
+   }
+ 
+ }
+ 
diff --cc tests/petsc/solver_03_precondition_boomeramg.cc
index 0000000000,8c452a78b1..9063e66030
mode 000000,100644..100644
--- a/tests/petsc/solver_03_precondition_boomeramg.cc
+++ b/tests/petsc/solver_03_precondition_boomeramg.cc
@@@ -1,0 -1,95 +1,95 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: solver_03_precondition_boomeramg.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ // test the PETSc CG solver with the PreconditionBoomerAMG
+ // preconditioner
+ 
+ 
+ #include "../tests.h"
+ #include "../lac/testmatrix.h"
+ #include <cmath>
+ #include <fstream>
+ #include <iostream>
+ #include <iomanip>
+ #include <deal.II/base/logstream.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_solver.h>
+ #include <deal.II/lac/petsc_precondition.h>
+ #include <deal.II/lac/vector_memory.h>
+ #include <typeinfo>
+ 
+ template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+ void
+ check_solve( SOLVER &solver, const MATRIX &A,
+              VECTOR &u, VECTOR &f, const PRECONDITION &P)
+ {
+   deallog << "Solver type: " << typeid(solver).name() << std::endl;
+ 
+   u = 0.;
+   f = 1.;
+   try
+     {
+       solver.solve(A,u,f,P);
+     }
+   catch (std::exception &e)
+     {
+       deallog << e.what() << std::endl;
+       abort ();
+     }
+ 
+   deallog << "Solver stopped after " << solver.control().last_step()
+           << " iterations" << std::endl;
+ }
+ 
+ 
+ int main(int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog << std::setprecision(4);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+   {
+     SolverControl control(100, 1.e-3);
+ 
+     const unsigned int size = 32;
+     unsigned int dim = (size-1)*(size-1);
+ 
+     deallog << "Size " << size << " Unknowns " << dim << std::endl;
+ 
+     // Make matrix
+     FDMatrix testproblem(size, size);
+     PETScWrappers::SparseMatrix  A(dim, dim, 5);
+     testproblem.five_point(A);
+ 
+     PETScWrappers::Vector  f(dim);
+     PETScWrappers::Vector  u(dim);
+     f = 1.;
+     A.compress ();
+     f.compress ();
+     u.compress ();
+ 
+     PETScWrappers::SolverCG solver(control);
+     PETScWrappers::PreconditionBoomerAMG preconditioner(A);
+     check_solve (solver, A,u,f, preconditioner);
+   }
+ 
+ }
+ 
diff --cc tests/petsc/solver_03_precondition_boomeramg_symmetric.cc
index 0000000000,73a442f1a5..24bca339ea
mode 000000,100644..100644
--- a/tests/petsc/solver_03_precondition_boomeramg_symmetric.cc
+++ b/tests/petsc/solver_03_precondition_boomeramg_symmetric.cc
@@@ -1,0 -1,96 +1,96 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: solver_03_precondition_boomeramg_symmetric.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ // test the PETSc CG solver with the PreconditionBoomerAMG
+ // preconditioner. allow the preconditioner to exploit symmetry of the
+ // matrix
+ 
+ 
+ #include "../tests.h"
+ #include "../lac/testmatrix.h"
+ #include <cmath>
+ #include <fstream>
+ #include <iostream>
+ #include <iomanip>
+ #include <deal.II/base/logstream.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_solver.h>
+ #include <deal.II/lac/petsc_precondition.h>
+ #include <deal.II/lac/vector_memory.h>
+ #include <typeinfo>
+ 
+ template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+ void
+ check_solve( SOLVER &solver, const MATRIX &A,
+              VECTOR &u, VECTOR &f, const PRECONDITION &P)
+ {
+   deallog << "Solver type: " << typeid(solver).name() << std::endl;
+ 
+   u = 0.;
+   f = 1.;
+   try
+     {
+       solver.solve(A,u,f,P);
+     }
+   catch (std::exception &e)
+     {
+       deallog << e.what() << std::endl;
+       abort ();
+     }
+ 
+   deallog << "Solver stopped after " << solver.control().last_step()
+           << " iterations" << std::endl;
+ }
+ 
+ 
+ int main(int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog << std::setprecision(4);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+   {
+     SolverControl control(100, 1.e-3);
+ 
+     const unsigned int size = 32;
+     unsigned int dim = (size-1)*(size-1);
+ 
+     deallog << "Size " << size << " Unknowns " << dim << std::endl;
+ 
+     // Make matrix
+     FDMatrix testproblem(size, size);
+     PETScWrappers::SparseMatrix  A(dim, dim, 5);
+     testproblem.five_point(A);
+ 
+     PETScWrappers::Vector  f(dim);
+     PETScWrappers::Vector  u(dim);
+     f = 1.;
+     A.compress ();
+     f.compress ();
+     u.compress ();
+ 
+     PETScWrappers::SolverCG solver(control);
+     PETScWrappers::PreconditionBoomerAMG preconditioner(A, true);
+     check_solve (solver, A,u,f, preconditioner);
+   }
+ 
+ }
+ 
diff --cc tests/petsc/solver_03_precondition_eisenstat.cc
index 0000000000,6551a25c05..767429cb03
mode 000000,100644..100644
--- a/tests/petsc/solver_03_precondition_eisenstat.cc
+++ b/tests/petsc/solver_03_precondition_eisenstat.cc
@@@ -1,0 -1,94 +1,94 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: solver_03_precondition_eisenstat.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ // test the PETSc CG solver
+ 
+ 
+ #include "../tests.h"
+ #include "../lac/testmatrix.h"
+ #include <cmath>
+ #include <fstream>
+ #include <iostream>
+ #include <iomanip>
+ #include <deal.II/base/logstream.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_solver.h>
+ #include <deal.II/lac/petsc_precondition.h>
+ #include <deal.II/lac/vector_memory.h>
+ #include <typeinfo>
+ 
+ template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+ void
+ check_solve( SOLVER &solver, const MATRIX &A,
+              VECTOR &u, VECTOR &f, const PRECONDITION &P)
+ {
+   deallog << "Solver type: " << typeid(solver).name() << std::endl;
+ 
+   u = 0.;
+   f = 1.;
+   try
+     {
+       solver.solve(A,u,f,P);
+     }
+   catch (std::exception &e)
+     {
+       deallog << e.what() << std::endl;
+       abort ();
+     }
+ 
+   deallog << "Solver stopped after " << solver.control().last_step()
+           << " iterations" << std::endl;
+ }
+ 
+ 
+ int main(int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog << std::setprecision(4);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+   {
+     SolverControl control(100, 1.e-3);
+ 
+     const unsigned int size = 32;
+     unsigned int dim = (size-1)*(size-1);
+ 
+     deallog << "Size " << size << " Unknowns " << dim << std::endl;
+ 
+     // Make matrix
+     FDMatrix testproblem(size, size);
+     PETScWrappers::SparseMatrix  A(dim, dim, 5);
+     testproblem.five_point(A);
+ 
+     PETScWrappers::Vector  f(dim);
+     PETScWrappers::Vector  u(dim);
+     f = 1.;
+     A.compress ();
+     f.compress ();
+     u.compress ();
+ 
+     PETScWrappers::SolverCG solver(control);
+     PETScWrappers::PreconditionEisenstat preconditioner(A);
+     check_solve (solver, A,u,f, preconditioner);
+   }
+ 
+ }
+ 
diff --cc tests/petsc/solver_03_precondition_icc.cc
index 0000000000,6849d74979..80ce3747f7
mode 000000,100644..100644
--- a/tests/petsc/solver_03_precondition_icc.cc
+++ b/tests/petsc/solver_03_precondition_icc.cc
@@@ -1,0 -1,94 +1,94 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: solver_03_precondition_icc.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ // test the PETSc CG solver
+ 
+ 
+ #include "../tests.h"
+ #include "../lac/testmatrix.h"
+ #include <cmath>
+ #include <fstream>
+ #include <iostream>
+ #include <iomanip>
+ #include <deal.II/base/logstream.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_solver.h>
+ #include <deal.II/lac/petsc_precondition.h>
+ #include <deal.II/lac/vector_memory.h>
+ #include <typeinfo>
+ 
+ template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+ void
+ check_solve( SOLVER &solver, const MATRIX &A,
+              VECTOR &u, VECTOR &f, const PRECONDITION &P)
+ {
+   deallog << "Solver type: " << typeid(solver).name() << std::endl;
+ 
+   u = 0.;
+   f = 1.;
+   try
+     {
+       solver.solve(A,u,f,P);
+     }
+   catch (std::exception &e)
+     {
+       deallog << e.what() << std::endl;
+       abort ();
+     }
+ 
+   deallog << "Solver stopped after " << solver.control().last_step()
+           << " iterations" << std::endl;
+ }
+ 
+ 
+ int main(int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog << std::setprecision(4);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+   {
+     SolverControl control(100, 1.e-3);
+ 
+     const unsigned int size = 32;
+     unsigned int dim = (size-1)*(size-1);
+ 
+     deallog << "Size " << size << " Unknowns " << dim << std::endl;
+ 
+     // Make matrix
+     FDMatrix testproblem(size, size);
+     PETScWrappers::SparseMatrix  A(dim, dim, 5);
+     testproblem.five_point(A);
+ 
+     PETScWrappers::Vector  f(dim);
+     PETScWrappers::Vector  u(dim);
+     f = 1.;
+     A.compress ();
+     f.compress ();
+     u.compress ();
+ 
+     PETScWrappers::SolverCG solver(control);
+     PETScWrappers::PreconditionICC preconditioner(A);
+     check_solve (solver, A,u,f, preconditioner);
+   }
+ 
+ }
+ 
diff --cc tests/petsc/solver_03_precondition_ilu.cc
index 0000000000,faad508f0a..1dab2d8631
mode 000000,100644..100644
--- a/tests/petsc/solver_03_precondition_ilu.cc
+++ b/tests/petsc/solver_03_precondition_ilu.cc
@@@ -1,0 -1,94 +1,94 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: solver_03_precondition_ilu.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ // test the PETSc CG solver
+ 
+ 
+ #include "../tests.h"
+ #include "../lac/testmatrix.h"
+ #include <cmath>
+ #include <fstream>
+ #include <iostream>
+ #include <iomanip>
+ #include <deal.II/base/logstream.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_solver.h>
+ #include <deal.II/lac/petsc_precondition.h>
+ #include <deal.II/lac/vector_memory.h>
+ #include <typeinfo>
+ 
+ template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+ void
+ check_solve( SOLVER &solver, const MATRIX &A,
+              VECTOR &u, VECTOR &f, const PRECONDITION &P)
+ {
+   deallog << "Solver type: " << typeid(solver).name() << std::endl;
+ 
+   u = 0.;
+   f = 1.;
+   try
+     {
+       solver.solve(A,u,f,P);
+     }
+   catch (std::exception &e)
+     {
+       deallog << e.what() << std::endl;
+       abort ();
+     }
+ 
+   deallog << "Solver stopped after " << solver.control().last_step()
+           << " iterations" << std::endl;
+ }
+ 
+ 
+ int main(int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog << std::setprecision(4);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+   {
+     SolverControl control(100, 1.e-3);
+ 
+     const unsigned int size = 32;
+     unsigned int dim = (size-1)*(size-1);
+ 
+     deallog << "Size " << size << " Unknowns " << dim << std::endl;
+ 
+     // Make matrix
+     FDMatrix testproblem(size, size);
+     PETScWrappers::SparseMatrix  A(dim, dim, 5);
+     testproblem.five_point(A);
+ 
+     PETScWrappers::Vector  f(dim);
+     PETScWrappers::Vector  u(dim);
+     f = 1.;
+     A.compress ();
+     f.compress ();
+     u.compress ();
+ 
+     PETScWrappers::SolverCG solver(control);
+     PETScWrappers::PreconditionILU preconditioner(A);
+     check_solve (solver, A,u,f, preconditioner);
+   }
+ 
+ }
+ 
diff --cc tests/petsc/solver_03_precondition_lu.cc
index 0000000000,beabcf434a..dcc93aa586
mode 000000,100644..100644
--- a/tests/petsc/solver_03_precondition_lu.cc
+++ b/tests/petsc/solver_03_precondition_lu.cc
@@@ -1,0 -1,101 +1,101 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: solver_03_precondition_lu.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ // test the PETSc CG solver with the PreconditionLU
+ // preconditioner. This should converge in exactly one iteration
+ 
+ 
+ #include "../tests.h"
+ #include "../lac/testmatrix.h"
+ #include <cmath>
+ #include <fstream>
+ #include <iostream>
+ #include <iomanip>
+ #include <deal.II/base/logstream.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_solver.h>
+ #include <deal.II/lac/petsc_precondition.h>
+ #include <deal.II/lac/vector_memory.h>
+ #include <typeinfo>
+ 
+ template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+ void
+ check_solve( SOLVER &solver, const MATRIX &A,
+              VECTOR &u, VECTOR &f, const PRECONDITION &P)
+ {
+   deallog << "Solver type: " << typeid(solver).name() << std::endl;
+ 
+   u = 0.;
+   f = 1.;
+   try
+     {
+       solver.solve(A,u,f,P);
+     }
+   catch (std::exception &e)
+     {
+       deallog << e.what() << std::endl;
+       abort ();
+     }
+ 
+   deallog << "Solver stopped after " << solver.control().last_step()
+           << " iterations" << std::endl;
+ 
+   // we use a direct solver as a
+   // preconditioner. this should
+   // converge in one step!
+   Assert (solver.control().last_step() == 1,
+           ExcInternalError());
+ }
+ 
+ 
+ int main(int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog << std::setprecision(4);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+   {
+     SolverControl control(100, 1.e-3);
+ 
+     const unsigned int size = 32;
+     unsigned int dim = (size-1)*(size-1);
+ 
+     deallog << "Size " << size << " Unknowns " << dim << std::endl;
+ 
+     // Make matrix
+     FDMatrix testproblem(size, size);
+     PETScWrappers::SparseMatrix  A(dim, dim, 5);
+     testproblem.five_point(A);
+ 
+     PETScWrappers::Vector  f(dim);
+     PETScWrappers::Vector  u(dim);
+     f = 1.;
+     A.compress ();
+     f.compress ();
+     u.compress ();
+ 
+     PETScWrappers::SolverCG solver(control);
+     PETScWrappers::PreconditionLU preconditioner(A);
+     check_solve (solver, A,u,f, preconditioner);
+   }
+ 
+ }
+ 
diff --cc tests/petsc/solver_03_precondition_parasails.cc
index 0000000000,05ffee26f7..5b0ea95b21
mode 000000,100644..100644
--- a/tests/petsc/solver_03_precondition_parasails.cc
+++ b/tests/petsc/solver_03_precondition_parasails.cc
@@@ -1,0 -1,94 +1,94 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: solver_03_precondition_parasails.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ // test the PETSc CG solver
+ 
+ 
+ #include "../tests.h"
+ #include "../lac/testmatrix.h"
+ #include <cmath>
+ #include <fstream>
+ #include <iostream>
+ #include <iomanip>
+ #include <deal.II/base/logstream.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_solver.h>
+ #include <deal.II/lac/petsc_precondition.h>
+ #include <deal.II/lac/vector_memory.h>
+ #include <typeinfo>
+ 
+ template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+ void
+ check_solve( SOLVER &solver, const MATRIX &A,
+              VECTOR &u, VECTOR &f, const PRECONDITION &P)
+ {
+   deallog << "Solver type: " << typeid(solver).name() << std::endl;
+ 
+   u = 0.;
+   f = 1.;
+   try
+     {
+       solver.solve(A,u,f,P);
+     }
+   catch (std::exception &e)
+     {
+       deallog << e.what() << std::endl;
+       abort ();
+     }
+ 
+   deallog << "Solver stopped after " << solver.control().last_step()
+           << " iterations" << std::endl;
+ }
+ 
+ 
+ int main(int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog << std::setprecision(4);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+   {
+     SolverControl control(100, 1.e-3);
+ 
+     const unsigned int size = 32;
+     unsigned int dim = (size-1)*(size-1);
+ 
+     deallog << "Size " << size << " Unknowns " << dim << std::endl;
+ 
+     // Make matrix
+     FDMatrix testproblem(size, size);
+     PETScWrappers::SparseMatrix  A(dim, dim, 5);
+     testproblem.five_point(A);
+ 
+     PETScWrappers::Vector  f(dim);
+     PETScWrappers::Vector  u(dim);
+     f = 1.;
+     A.compress ();
+     f.compress ();
+     u.compress ();
+ 
+     PETScWrappers::SolverCG solver(control);
+     PETScWrappers::PreconditionParaSails preconditioner(A);
+     check_solve (solver, A,u,f, preconditioner);
+   }
+ 
+ }
+ 
diff --cc tests/petsc/solver_03_precondition_sor.cc
index 0000000000,f0700eebc5..af7be7a3ff
mode 000000,100644..100644
--- a/tests/petsc/solver_03_precondition_sor.cc
+++ b/tests/petsc/solver_03_precondition_sor.cc
@@@ -1,0 -1,94 +1,94 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: solver_03_precondition_sor.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ // test the PETSc CG solver
+ 
+ 
+ #include "../tests.h"
+ #include "../lac/testmatrix.h"
+ #include <cmath>
+ #include <fstream>
+ #include <iostream>
+ #include <iomanip>
+ #include <deal.II/base/logstream.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_solver.h>
+ #include <deal.II/lac/petsc_precondition.h>
+ #include <deal.II/lac/vector_memory.h>
+ #include <typeinfo>
+ 
+ template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+ void
+ check_solve( SOLVER &solver, const MATRIX &A,
+              VECTOR &u, VECTOR &f, const PRECONDITION &P)
+ {
+   deallog << "Solver type: " << typeid(solver).name() << std::endl;
+ 
+   u = 0.;
+   f = 1.;
+   try
+     {
+       solver.solve(A,u,f,P);
+     }
+   catch (std::exception &e)
+     {
+       deallog << e.what() << std::endl;
+       abort ();
+     }
+ 
+   deallog << "Solver stopped after " << solver.control().last_step()
+           << " iterations" << std::endl;
+ }
+ 
+ 
+ int main(int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog << std::setprecision(4);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+   {
+     SolverControl control(100, 1.e-3);
+ 
+     const unsigned int size = 32;
+     unsigned int dim = (size-1)*(size-1);
+ 
+     deallog << "Size " << size << " Unknowns " << dim << std::endl;
+ 
+     // Make matrix
+     FDMatrix testproblem(size, size);
+     PETScWrappers::SparseMatrix  A(dim, dim, 5);
+     testproblem.five_point(A);
+ 
+     PETScWrappers::Vector  f(dim);
+     PETScWrappers::Vector  u(dim);
+     f = 1.;
+     A.compress ();
+     f.compress ();
+     u.compress ();
+ 
+     PETScWrappers::SolverCG solver(control);
+     PETScWrappers::PreconditionSOR preconditioner(A);
+     check_solve (solver, A,u,f, preconditioner);
+   }
+ 
+ }
+ 
diff --cc tests/petsc/solver_03_precondition_ssor.cc
index 0000000000,67fd339d47..cf01bc3f1d
mode 000000,100644..100644
--- a/tests/petsc/solver_03_precondition_ssor.cc
+++ b/tests/petsc/solver_03_precondition_ssor.cc
@@@ -1,0 -1,94 +1,94 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: solver_03_precondition_ssor.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ // test the PETSc CG solver
+ 
+ 
+ #include "../tests.h"
+ #include "../lac/testmatrix.h"
+ #include <cmath>
+ #include <fstream>
+ #include <iostream>
+ #include <iomanip>
+ #include <deal.II/base/logstream.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_solver.h>
+ #include <deal.II/lac/petsc_precondition.h>
+ #include <deal.II/lac/vector_memory.h>
+ #include <typeinfo>
+ 
+ template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+ void
+ check_solve( SOLVER &solver, const MATRIX &A,
+              VECTOR &u, VECTOR &f, const PRECONDITION &P)
+ {
+   deallog << "Solver type: " << typeid(solver).name() << std::endl;
+ 
+   u = 0.;
+   f = 1.;
+   try
+     {
+       solver.solve(A,u,f,P);
+     }
+   catch (std::exception &e)
+     {
+       deallog << e.what() << std::endl;
+       abort ();
+     }
+ 
+   deallog << "Solver stopped after " << solver.control().last_step()
+           << " iterations" << std::endl;
+ }
+ 
+ 
+ int main(int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog << std::setprecision(4);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+   {
+     SolverControl control(100, 1.e-3);
+ 
+     const unsigned int size = 32;
+     unsigned int dim = (size-1)*(size-1);
+ 
+     deallog << "Size " << size << " Unknowns " << dim << std::endl;
+ 
+     // Make matrix
+     FDMatrix testproblem(size, size);
+     PETScWrappers::SparseMatrix  A(dim, dim, 5);
+     testproblem.five_point(A);
+ 
+     PETScWrappers::Vector  f(dim);
+     PETScWrappers::Vector  u(dim);
+     f = 1.;
+     A.compress ();
+     f.compress ();
+     u.compress ();
+ 
+     PETScWrappers::SolverCG solver(control);
+     PETScWrappers::PreconditionSSOR preconditioner(A);
+     check_solve (solver, A,u,f, preconditioner);
+   }
+ 
+ }
+ 
diff --cc tests/petsc/solver_04.cc
index 0000000000,2d9819fba4..4db245a1b6
mode 000000,100644..100644
--- a/tests/petsc/solver_04.cc
+++ b/tests/petsc/solver_04.cc
@@@ -1,0 -1,94 +1,94 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: solver_04.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ // test the PETSc BiCG solver
+ 
+ 
+ #include "../tests.h"
+ #include "../lac/testmatrix.h"
+ #include <cmath>
+ #include <fstream>
+ #include <iostream>
+ #include <iomanip>
+ #include <deal.II/base/logstream.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_solver.h>
+ #include <deal.II/lac/petsc_precondition.h>
+ #include <deal.II/lac/vector_memory.h>
+ #include <typeinfo>
+ 
+ template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+ void
+ check_solve( SOLVER &solver, const MATRIX &A,
+              VECTOR &u, VECTOR &f, const PRECONDITION &P)
+ {
+   deallog << "Solver type: " << typeid(solver).name() << std::endl;
+ 
+   u = 0.;
+   f = 1.;
+   try
+     {
+       solver.solve(A,u,f,P);
+     }
+   catch (std::exception &e)
+     {
+       deallog << e.what() << std::endl;
+       abort ();
+     }
+ 
+   deallog << "Solver stopped after " << solver.control().last_step()
+           << " iterations" << std::endl;
+ }
+ 
+ 
+ int main(int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog << std::setprecision(4);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+   {
+     SolverControl control(100, 1.e-3);
+ 
+     const unsigned int size = 32;
+     unsigned int dim = (size-1)*(size-1);
+ 
+     deallog << "Size " << size << " Unknowns " << dim << std::endl;
+ 
+     // Make matrix
+     FDMatrix testproblem(size, size);
+     PETScWrappers::SparseMatrix  A(dim, dim, 5);
+     testproblem.five_point(A);
+ 
+     PETScWrappers::Vector  f(dim);
+     PETScWrappers::Vector  u(dim);
+     f = 1.;
+     A.compress ();
+     f.compress ();
+     u.compress ();
+ 
+     PETScWrappers::SolverBiCG solver(control);
+     PETScWrappers::PreconditionJacobi preconditioner(A);
+     check_solve (solver, A,u,f, preconditioner);
+   }
+ 
+ }
+ 
diff --cc tests/petsc/solver_05.cc
index 0000000000,15f6466e8c..98561a2c5a
mode 000000,100644..100644
--- a/tests/petsc/solver_05.cc
+++ b/tests/petsc/solver_05.cc
@@@ -1,0 -1,94 +1,94 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: solver_05.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ // test the PETSc GMRES solver
+ 
+ 
+ #include "../tests.h"
+ #include "../lac/testmatrix.h"
+ #include <cmath>
+ #include <fstream>
+ #include <iostream>
+ #include <iomanip>
+ #include <deal.II/base/logstream.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_solver.h>
+ #include <deal.II/lac/petsc_precondition.h>
+ #include <deal.II/lac/vector_memory.h>
+ #include <typeinfo>
+ 
+ template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+ void
+ check_solve( SOLVER &solver, const MATRIX &A,
+              VECTOR &u, VECTOR &f, const PRECONDITION &P)
+ {
+   deallog << "Solver type: " << typeid(solver).name() << std::endl;
+ 
+   u = 0.;
+   f = 1.;
+   try
+     {
+       solver.solve(A,u,f,P);
+     }
+   catch (std::exception &e)
+     {
+       deallog << e.what() << std::endl;
+       abort ();
+     }
+ 
+   deallog << "Solver stopped after " << solver.control().last_step()
+           << " iterations" << std::endl;
+ }
+ 
+ 
+ int main(int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog << std::setprecision(4);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+   {
+     SolverControl control(100, 1.e-3);
+ 
+     const unsigned int size = 32;
+     unsigned int dim = (size-1)*(size-1);
+ 
+     deallog << "Size " << size << " Unknowns " << dim << std::endl;
+ 
+     // Make matrix
+     FDMatrix testproblem(size, size);
+     PETScWrappers::SparseMatrix  A(dim, dim, 5);
+     testproblem.five_point(A);
+ 
+     PETScWrappers::Vector  f(dim);
+     PETScWrappers::Vector  u(dim);
+     f = 1.;
+     A.compress ();
+     f.compress ();
+     u.compress ();
+ 
+     PETScWrappers::SolverGMRES solver(control);
+     PETScWrappers::PreconditionJacobi preconditioner(A);
+     check_solve (solver, A,u,f, preconditioner);
+   }
+ 
+ }
+ 
diff --cc tests/petsc/solver_06.cc
index 0000000000,e19bddaf0c..6500756f50
mode 000000,100644..100644
--- a/tests/petsc/solver_06.cc
+++ b/tests/petsc/solver_06.cc
@@@ -1,0 -1,94 +1,94 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: solver_06.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ // test the PETSc Bicgstab solver
+ 
+ 
+ #include "../tests.h"
+ #include "../lac/testmatrix.h"
+ #include <cmath>
+ #include <fstream>
+ #include <iostream>
+ #include <iomanip>
+ #include <deal.II/base/logstream.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_solver.h>
+ #include <deal.II/lac/petsc_precondition.h>
+ #include <deal.II/lac/vector_memory.h>
+ #include <typeinfo>
+ 
+ template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+ void
+ check_solve( SOLVER &solver, const MATRIX &A,
+              VECTOR &u, VECTOR &f, const PRECONDITION &P)
+ {
+   deallog << "Solver type: " << typeid(solver).name() << std::endl;
+ 
+   u = 0.;
+   f = 1.;
+   try
+     {
+       solver.solve(A,u,f,P);
+     }
+   catch (std::exception &e)
+     {
+       deallog << e.what() << std::endl;
+       abort ();
+     }
+ 
+   deallog << "Solver stopped after " << solver.control().last_step()
+           << " iterations" << std::endl;
+ }
+ 
+ 
+ int main(int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog << std::setprecision(4);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+   {
+     SolverControl control(100, 1.e-3);
+ 
+     const unsigned int size = 32;
+     unsigned int dim = (size-1)*(size-1);
+ 
+     deallog << "Size " << size << " Unknowns " << dim << std::endl;
+ 
+     // Make matrix
+     FDMatrix testproblem(size, size);
+     PETScWrappers::SparseMatrix  A(dim, dim, 5);
+     testproblem.five_point(A);
+ 
+     PETScWrappers::Vector  f(dim);
+     PETScWrappers::Vector  u(dim);
+     f = 1.;
+     A.compress ();
+     f.compress ();
+     u.compress ();
+ 
+     PETScWrappers::SolverBicgstab solver(control);
+     PETScWrappers::PreconditionJacobi preconditioner(A);
+     check_solve (solver, A,u,f, preconditioner);
+   }
+ 
+ }
+ 
diff --cc tests/petsc/solver_07.cc
index 0000000000,12d44a6ae2..947b584db2
mode 000000,100644..100644
--- a/tests/petsc/solver_07.cc
+++ b/tests/petsc/solver_07.cc
@@@ -1,0 -1,94 +1,94 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: solver_07.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ // test the PETSc CGS solver
+ 
+ 
+ #include "../tests.h"
+ #include "../lac/testmatrix.h"
+ #include <cmath>
+ #include <fstream>
+ #include <iostream>
+ #include <iomanip>
+ #include <deal.II/base/logstream.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_solver.h>
+ #include <deal.II/lac/petsc_precondition.h>
+ #include <deal.II/lac/vector_memory.h>
+ #include <typeinfo>
+ 
+ template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+ void
+ check_solve( SOLVER &solver, const MATRIX &A,
+              VECTOR &u, VECTOR &f, const PRECONDITION &P)
+ {
+   deallog << "Solver type: " << typeid(solver).name() << std::endl;
+ 
+   u = 0.;
+   f = 1.;
+   try
+     {
+       solver.solve(A,u,f,P);
+     }
+   catch (std::exception &e)
+     {
+       deallog << e.what() << std::endl;
+       abort ();
+     }
+ 
+   deallog << "Solver stopped after " << solver.control().last_step()
+           << " iterations" << std::endl;
+ }
+ 
+ 
+ int main(int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog << std::setprecision(4);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+   {
+     SolverControl control(100, 1.e-3);
+ 
+     const unsigned int size = 32;
+     unsigned int dim = (size-1)*(size-1);
+ 
+     deallog << "Size " << size << " Unknowns " << dim << std::endl;
+ 
+     // Make matrix
+     FDMatrix testproblem(size, size);
+     PETScWrappers::SparseMatrix  A(dim, dim, 5);
+     testproblem.five_point(A);
+ 
+     PETScWrappers::Vector  f(dim);
+     PETScWrappers::Vector  u(dim);
+     f = 1.;
+     A.compress ();
+     f.compress ();
+     u.compress ();
+ 
+     PETScWrappers::SolverCGS solver(control);
+     PETScWrappers::PreconditionJacobi preconditioner(A);
+     check_solve (solver, A,u,f, preconditioner);
+   }
+ 
+ }
+ 
diff --cc tests/petsc/solver_08.cc
index 0000000000,56b38ef60d..fbad082117
mode 000000,100644..100644
--- a/tests/petsc/solver_08.cc
+++ b/tests/petsc/solver_08.cc
@@@ -1,0 -1,94 +1,94 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: solver_08.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ // test the PETSc TFQMR solver
+ 
+ 
+ #include "../tests.h"
+ #include "../lac/testmatrix.h"
+ #include <cmath>
+ #include <fstream>
+ #include <iostream>
+ #include <iomanip>
+ #include <deal.II/base/logstream.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_solver.h>
+ #include <deal.II/lac/petsc_precondition.h>
+ #include <deal.II/lac/vector_memory.h>
+ #include <typeinfo>
+ 
+ template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+ void
+ check_solve( SOLVER &solver, const MATRIX &A,
+              VECTOR &u, VECTOR &f, const PRECONDITION &P)
+ {
+   deallog << "Solver type: " << typeid(solver).name() << std::endl;
+ 
+   u = 0.;
+   f = 1.;
+   try
+     {
+       solver.solve(A,u,f,P);
+     }
+   catch (std::exception &e)
+     {
+       deallog << e.what() << std::endl;
+       abort ();
+     }
+ 
+   deallog << "Solver stopped after " << solver.control().last_step()
+           << " iterations" << std::endl;
+ }
+ 
+ 
+ int main(int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog << std::setprecision(4);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+   {
+     SolverControl control(100, 1.e-3);
+ 
+     const unsigned int size = 32;
+     unsigned int dim = (size-1)*(size-1);
+ 
+     deallog << "Size " << size << " Unknowns " << dim << std::endl;
+ 
+     // Make matrix
+     FDMatrix testproblem(size, size);
+     PETScWrappers::SparseMatrix  A(dim, dim, 5);
+     testproblem.five_point(A);
+ 
+     PETScWrappers::Vector  f(dim);
+     PETScWrappers::Vector  u(dim);
+     f = 1.;
+     A.compress ();
+     f.compress ();
+     u.compress ();
+ 
+     PETScWrappers::SolverTFQMR solver(control);
+     PETScWrappers::PreconditionJacobi preconditioner(A);
+     check_solve (solver, A,u,f, preconditioner);
+   }
+ 
+ }
+ 
diff --cc tests/petsc/solver_09.cc
index 0000000000,3297bd8fe2..3b52a48e3d
mode 000000,100644..100644
--- a/tests/petsc/solver_09.cc
+++ b/tests/petsc/solver_09.cc
@@@ -1,0 -1,98 +1,98 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: solver_09.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ // test the PETSc TCQMR solver
+ //
+ // note that this test fails on PETSc 2.1.6 due to a bug in the TCQMR
+ // implementation. this is reported and should be fixed soonish
+ 
+ 
+ 
+ #include "../tests.h"
+ #include "../lac/testmatrix.h"
+ #include <cmath>
+ #include <fstream>
+ #include <iostream>
+ #include <iomanip>
+ #include <deal.II/base/logstream.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_solver.h>
+ #include <deal.II/lac/petsc_precondition.h>
+ #include <deal.II/lac/vector_memory.h>
+ #include <typeinfo>
+ 
+ template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+ void
+ check_solve( SOLVER &solver, const MATRIX &A,
+              VECTOR &u, VECTOR &f, const PRECONDITION &P)
+ {
+   deallog << "Solver type: " << typeid(solver).name() << std::endl;
+ 
+   u = 0.;
+   f = 1.;
+   try
+     {
+       solver.solve(A,u,f,P);
+     }
+   catch (std::exception &e)
+     {
+       deallog << e.what() << std::endl;
+       abort ();
+     }
+ 
+   deallog << "Solver stopped after " << solver.control().last_step()
+           << " iterations" << std::endl;
+ }
+ 
+ 
+ int main(int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog << std::setprecision(4);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+   {
+     SolverControl control(100, 1.e-3);
+ 
+     const unsigned int size = 32;
+     unsigned int dim = (size-1)*(size-1);
+ 
+     deallog << "Size " << size << " Unknowns " << dim << std::endl;
+ 
+     // Make matrix
+     FDMatrix testproblem(size, size);
+     PETScWrappers::SparseMatrix  A(dim, dim, 5);
+     testproblem.five_point(A);
+ 
+     PETScWrappers::Vector  f(dim);
+     PETScWrappers::Vector  u(dim);
+     f = 1.;
+     A.compress ();
+     f.compress ();
+     u.compress ();
+ 
+     PETScWrappers::SolverTCQMR solver(control);
+     PETScWrappers::PreconditionJacobi preconditioner(A);
+     check_solve (solver, A,u,f, preconditioner);
+   }
+ 
+ }
+ 
diff --cc tests/petsc/solver_10.cc
index 0000000000,df81e7dbd2..488b11300e
mode 000000,100644..100644
--- a/tests/petsc/solver_10.cc
+++ b/tests/petsc/solver_10.cc
@@@ -1,0 -1,94 +1,94 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: solver_10.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ // test the PETSc CR solver
+ 
+ 
+ #include "../tests.h"
+ #include "../lac/testmatrix.h"
+ #include <cmath>
+ #include <fstream>
+ #include <iostream>
+ #include <iomanip>
+ #include <deal.II/base/logstream.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_solver.h>
+ #include <deal.II/lac/petsc_precondition.h>
+ #include <deal.II/lac/vector_memory.h>
+ #include <typeinfo>
+ 
+ template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+ void
+ check_solve( SOLVER &solver, const MATRIX &A,
+              VECTOR &u, VECTOR &f, const PRECONDITION &P)
+ {
+   deallog << "Solver type: " << typeid(solver).name() << std::endl;
+ 
+   u = 0.;
+   f = 1.;
+   try
+     {
+       solver.solve(A,u,f,P);
+     }
+   catch (std::exception &e)
+     {
+       deallog << e.what() << std::endl;
+       abort ();
+     }
+ 
+   deallog << "Solver stopped after " << solver.control().last_step()
+           << " iterations" << std::endl;
+ }
+ 
+ 
+ int main(int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog << std::setprecision(4);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+   {
+     SolverControl control(100, 1.e-3);
+ 
+     const unsigned int size = 32;
+     unsigned int dim = (size-1)*(size-1);
+ 
+     deallog << "Size " << size << " Unknowns " << dim << std::endl;
+ 
+     // Make matrix
+     FDMatrix testproblem(size, size);
+     PETScWrappers::SparseMatrix  A(dim, dim, 5);
+     testproblem.five_point(A);
+ 
+     PETScWrappers::Vector  f(dim);
+     PETScWrappers::Vector  u(dim);
+     f = 1.;
+     A.compress ();
+     f.compress ();
+     u.compress ();
+ 
+     PETScWrappers::SolverCR solver(control);
+     PETScWrappers::PreconditionJacobi preconditioner(A);
+     check_solve (solver, A,u,f, preconditioner);
+   }
+ 
+ }
+ 
diff --cc tests/petsc/solver_11.cc
index 0000000000,a7e585eb33..9fff4d6cea
mode 000000,100644..100644
--- a/tests/petsc/solver_11.cc
+++ b/tests/petsc/solver_11.cc
@@@ -1,0 -1,95 +1,95 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: solver_11.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ // test the PETSc LSQR solver
+ 
+ 
+ #include "../tests.h"
+ #include "../lac/testmatrix.h"
+ #include <cmath>
+ #include <fstream>
+ #include <iostream>
+ #include <iomanip>
+ #include <deal.II/base/logstream.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_solver.h>
+ #include <deal.II/lac/petsc_precondition.h>
+ #include <deal.II/lac/vector_memory.h>
+ #include <typeinfo>
+ 
+ template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+ void
+ check_solve( SOLVER &solver, const MATRIX &A,
+              VECTOR &u, VECTOR &f, const PRECONDITION &P)
+ {
+   deallog << "Solver type: " << typeid(solver).name() << std::endl;
+ 
+   u = 0.;
+   f = 1.;
+   try
+     {
+       solver.solve(A,u,f,P);
+     }
+   catch (dealii::SolverControl::NoConvergence &e)
+     {
+       // just like for Richardson: expect to
+       // get here, don't abort the program
+       deallog << "Catched exception dealii::SolverControl::NoConvergence" << std::endl;
+     }
+ 
+   deallog << "Solver stopped after " << solver.control().last_step()
+           << " iterations" << std::endl;
+ }
+ 
+ 
+ int main(int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog << std::setprecision(4);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+   {
+     SolverControl control(100, 1.e-3);
+ 
+     const unsigned int size = 32;
+     unsigned int dim = (size-1)*(size-1);
+ 
+     deallog << "Size " << size << " Unknowns " << dim << std::endl;
+ 
+     // Make matrix
+     FDMatrix testproblem(size, size);
+     PETScWrappers::SparseMatrix  A(dim, dim, 5);
+     testproblem.five_point(A);
+ 
+     PETScWrappers::Vector  f(dim);
+     PETScWrappers::Vector  u(dim);
+     f = 1.;
+     A.compress ();
+     f.compress ();
+     u.compress ();
+ 
+     PETScWrappers::SolverLSQR solver(control);
+     PETScWrappers::PreconditionJacobi preconditioner(A);
+     check_solve (solver, A,u,f, preconditioner);
+   }
+ 
+ }
+ 
diff --cc tests/petsc/solver_12.cc
index 0000000000,79e44183a9..f2d0ba07d8
mode 000000,100644..100644
--- a/tests/petsc/solver_12.cc
+++ b/tests/petsc/solver_12.cc
@@@ -1,0 -1,91 +1,91 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: solver_12.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ // test the PETSc PreOnly solver
+ 
+ 
+ #include "../tests.h"
+ #include "../lac/testmatrix.h"
+ #include <cmath>
+ #include <fstream>
+ #include <iostream>
+ #include <iomanip>
+ #include <deal.II/base/logstream.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_solver.h>
+ #include <deal.II/lac/petsc_precondition.h>
+ #include <deal.II/lac/vector_memory.h>
+ #include <typeinfo>
+ 
+ template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+ void
+ check_solve( SOLVER &solver, const MATRIX &A,
+              VECTOR &u, VECTOR &f, const PRECONDITION &P)
+ {
+   deallog << "Solver type: " << typeid(solver).name() << std::endl;
+ 
+   u = 0.;
+   f = 1.;
+ 
+   solver.solve(A,u,f,P);
+ 
+   deallog << "Solver stopped after " << solver.control().last_step()
+           << " iterations" << std::endl;
+ }
+ 
+ 
+ int main(int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog << std::setprecision(4);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+   {
+     SolverControl control(100, 1.e-3);
+ 
+     const unsigned int size = 32;
+     unsigned int dim = (size-1)*(size-1);
+ 
+     deallog << "Size " << size << " Unknowns " << dim << std::endl;
+ 
+     // Make matrix
+     FDMatrix testproblem(size, size);
+     PETScWrappers::SparseMatrix  A(dim, dim, 5);
+     testproblem.five_point(A);
+ 
+     PETScWrappers::Vector  f(dim);
+     PETScWrappers::Vector  u(dim);
+     f = 1.;
+     A.compress ();
+     f.compress ();
+     u.compress ();
+ 
+     PETScWrappers::SolverPreOnly solver(control);
+ 
+     PETScWrappers::PreconditionJacobi preconditioner(A);
+     check_solve (solver, A,u,f, preconditioner);
+ 
+     //run twice because this errored out at some point
+     check_solve (solver, A,u,f, preconditioner);
+   }
+ 
+ }
+ 
diff --cc tests/petsc/solver_13.cc
index 0000000000,b28e88cafe..e77d2044f3
mode 000000,100644..100644
--- a/tests/petsc/solver_13.cc
+++ b/tests/petsc/solver_13.cc
@@@ -1,0 -1,100 +1,100 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: solver_13.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ // test the PETScWrapper::Precondition*::vmult
+ 
+ 
+ #include "../tests.h"
+ #include "../lac/testmatrix.h"
+ #include <cmath>
+ #include <fstream>
+ #include <iostream>
+ #include <iomanip>
+ #include <deal.II/base/logstream.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_solver.h>
+ #include <deal.II/lac/petsc_precondition.h>
+ #include <deal.II/lac/vector_memory.h>
+ #include <typeinfo>
+ 
+ template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+ void
+ check_solve( SOLVER &solver, const MATRIX &A,
+              VECTOR &u, VECTOR &f, const PRECONDITION &P)
+ {
+   deallog << "Solver type: " << typeid(solver).name() << std::endl;
+ 
+   solver.solve(A,u,f,P);
+ 
+   deallog << "Solver stopped after " << solver.control().last_step()
+           << " iterations" << std::endl;
+ }
+ 
+ 
+ int main(int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog << std::setprecision(4);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+   {
+     SolverControl control(100, 1.e-3);
+ 
+     const unsigned int size = 32;
+     unsigned int dim = (size-1)*(size-1);
+ 
+     deallog << "Size " << size << " Unknowns " << dim << std::endl;
+ 
+     // Make matrix
+     FDMatrix testproblem(size, size);
+     PETScWrappers::SparseMatrix  A(dim, dim, 5);
+     testproblem.five_point(A);
+ 
+     PETScWrappers::Vector  f(dim);
+     PETScWrappers::Vector  u(dim);
+     u = 0.;
+     f = 1.;
+     A.compress ();
+     f.compress ();
+     u.compress ();
+     PETScWrappers::Vector t=u;
+ 
+     PETScWrappers::SolverPreOnly solver(control);
+ 
+     PETScWrappers::PreconditionJacobi preconditioner(A);
+ 
+     check_solve (solver, A,u,f, preconditioner);
+ 
+     deallog << u.l2_norm() << std::endl;
+ 
+     check_solve (solver, A,t,u, preconditioner);
+ 
+     deallog << t.l2_norm() << std::endl;
+ 
+     u = 0;
+     preconditioner.vmult(u, f);
+     deallog << u.l2_norm() << std::endl;
+     preconditioner.vmult(t, u);
+     deallog << t.l2_norm() << std::endl;
+   }
+ 
+ }
+ 
diff --cc tests/petsc/sparse_direct_mumps.cc
index 0000000000,01956e4e02..6a60135011
mode 000000,100644..100644
--- a/tests/petsc/sparse_direct_mumps.cc
+++ b/tests/petsc/sparse_direct_mumps.cc
@@@ -1,0 -1,98 +1,98 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: sparse_direct_mumps.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ // test the PETSc SparseDirectMumps solver
+ 
+ 
+ #include "../tests.h"
+ #include "../lac/testmatrix.h"
+ #include <cmath>
+ #include <fstream>
+ #include <iostream>
+ #include <iomanip>
+ #include <deal.II/base/logstream.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_solver.h>
+ #include <deal.II/lac/petsc_precondition.h>
+ #include <deal.II/lac/vector_memory.h>
+ #include <typeinfo>
+ 
+ template<class SOLVER, class MATRIX, class VECTOR, class PRECONDITION>
+ void
+ check_solve( SOLVER &solver, const MATRIX &A,
+              VECTOR &u, VECTOR &f, const PRECONDITION &P)
+ {
+   deallog << "Solver type: " << typeid(solver).name() << std::endl;
+ 
+   u = 0.;
+   f = 1.;
+   try
+     {
+       solver.solve(A,u,f,P);
+     }
+   catch (std::exception &e)
+     {
+       deallog << e.what() << std::endl;
+       abort ();
+     }
+ 
+   deallog << "Solver stopped after " << solver.control().last_step()
+           << " iterations" << std::endl;
+ }
+ 
+ 
+ int main(int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog << std::setprecision(4);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+   {
+     const unsigned int size = 32;
+     unsigned int dim = (size-1)*(size-1);
+ 
+     deallog << "Size " << size << " Unknowns " << dim << std::endl;
+ 
+     // Make matrix
+     FDMatrix testproblem(size, size);
+     PETScWrappers::SparseMatrix  A(dim, dim, 5);
+     testproblem.five_point(A);
+ 
+     PETScWrappers::Vector  f(dim);
+     PETScWrappers::Vector  u(dim);
+     u = 0.;
+     f = 1.;
+     A.compress ();
+     f.compress ();
+     u.compress ();
+ 
+     SolverControl cn;
+     PETScWrappers::SparseDirectMUMPS solver(cn);
+ //    solver.set_symmetric_mode(true);
+     solver.solve(A,u,f);
+ 
+     PETScWrappers::Vector  tmp(dim);
+     deallog << "residual = " << A.residual (tmp, u, f)
+             << std::endl;
+   }
+ 
+ }
+ 
diff --cc tests/petsc/sparse_matrix_iterator_01.cc
index 0000000000,b070cc721c..bc6e0143cb
mode 000000,100644..100644
--- a/tests/petsc/sparse_matrix_iterator_01.cc
+++ b/tests/petsc/sparse_matrix_iterator_01.cc
@@@ -1,0 -1,85 +1,85 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: sparse_matrix_iterator_01.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // test PETScWrappers::MatrixBase::const_iterator
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ 
+ 
+ void test ()
+ {
+   PETScWrappers::SparseMatrix m(5,5,5);
+   m.set (0,0,1);
+   m.set (1,1,2);
+   m.set (1,2,3);
+   m.compress ();
+   PETScWrappers::SparseMatrix::const_iterator i = m.begin();
+   deallog << i->row() << ' ' << i->column() << ' ' << i->value() << std::endl;
+   ++i;
+   deallog << i->row() << ' ' << i->column() << ' ' << i->value() << std::endl;
+   i++;
+   deallog << i->row() << ' ' << i->column() << ' ' << i->value() << std::endl;
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc,char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         test ();
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/sparse_matrix_vector_01.cc
index 0000000000,6562499418..9bf41c0d4d
mode 000000,100644..100644
--- a/tests/petsc/sparse_matrix_vector_01.cc
+++ b/tests/petsc/sparse_matrix_vector_01.cc
@@@ -1,0 -1,104 +1,104 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: sparse_matrix_vector_01.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check SparseMatrix::vmult
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w)
+ {
+   PETScWrappers::SparseMatrix m(v.size(),v.size(),v.size());
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       m.set (i,j, i+2*j);
+ 
+   for (unsigned int i=0; i<v.size(); ++i)
+     v(i) = i;
+ 
+   m.compress ();
+   v.compress ();
+   w.compress ();
+ 
+   // w:=Mv
+   m.vmult (w,v);
+ 
+   // make sure we get the expected result
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       Assert (v(i) == i, ExcInternalError());
+ 
+       double result = 0;
+       for (unsigned int j=0; j<m.m(); ++j)
+         result += (i+2*j)*j;
+       Assert (w(i) == result, ExcInternalError());
+     }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         test (v,w);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/sparse_matrix_vector_02.cc
index 0000000000,b127bb49ee..fdd1f3fa45
mode 000000,100644..100644
--- a/tests/petsc/sparse_matrix_vector_02.cc
+++ b/tests/petsc/sparse_matrix_vector_02.cc
@@@ -1,0 -1,104 +1,104 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: sparse_matrix_vector_02.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check SparseMatrix::Tvmult
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w)
+ {
+   PETScWrappers::SparseMatrix m(v.size(),v.size(),v.size());
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       m.set (i,j, i+2*j);
+ 
+   for (unsigned int i=0; i<v.size(); ++i)
+     v(i) = i;
+ 
+   m.compress ();
+   v.compress ();
+   w.compress ();
+ 
+   // w:=Mv
+   m.Tvmult (w,v);
+ 
+   // make sure we get the expected result
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       Assert (v(i) == i, ExcInternalError());
+ 
+       double result = 0;
+       for (unsigned int j=0; j<m.m(); ++j)
+         result += (j+2*i)*j;
+       Assert (w(i) == result, ExcInternalError());
+     }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         test (v,w);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/sparse_matrix_vector_03.cc
index 0000000000,667d48d3c3..d496def180
mode 000000,100644..100644
--- a/tests/petsc/sparse_matrix_vector_03.cc
+++ b/tests/petsc/sparse_matrix_vector_03.cc
@@@ -1,0 -1,107 +1,107 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: sparse_matrix_vector_03.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check SparseMatrix::vmult_add
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w)
+ {
+   PETScWrappers::SparseMatrix m(v.size(),v.size(),v.size());
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       m.set (i,j, i+2*j);
+ 
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       v(i) = i;
+       w(i) = i;
+     }
+ 
+   m.compress ();
+   v.compress ();
+   w.compress ();
+ 
+   // w:=Mv
+   m.vmult_add (w,v);
+ 
+   // make sure we get the expected result
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       Assert (v(i) == i, ExcInternalError());
+ 
+       double result = 0;
+       for (unsigned int j=0; j<m.m(); ++j)
+         result += (i+2*j)*j;
+       Assert (w(i) == i+result, ExcInternalError());
+     }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         test (v,w);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/sparse_matrix_vector_04.cc
index 0000000000,357e719c5e..ff830de07c
mode 000000,100644..100644
--- a/tests/petsc/sparse_matrix_vector_04.cc
+++ b/tests/petsc/sparse_matrix_vector_04.cc
@@@ -1,0 -1,107 +1,107 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: sparse_matrix_vector_04.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check SparseMatrix::Tvmult_add
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w)
+ {
+   PETScWrappers::SparseMatrix m(v.size(),v.size(),v.size());
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       m.set (i,j, i+2*j);
+ 
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       v(i) = i;
+       w(i) = i;
+     }
+ 
+   m.compress ();
+   v.compress ();
+   w.compress ();
+ 
+   // w:=Mv
+   m.Tvmult_add (w,v);
+ 
+   // make sure we get the expected result
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       Assert (v(i) == i, ExcInternalError());
+ 
+       double result = 0;
+       for (unsigned int j=0; j<m.m(); ++j)
+         result += (j+2*i)*j;
+       Assert (w(i) == i+result, ExcInternalError());
+     }
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         test (v,w);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/sparse_matrix_vector_05.cc
index 0000000000,d17bad38c1..ddd751faa3
mode 000000,100644..100644
--- a/tests/petsc/sparse_matrix_vector_05.cc
+++ b/tests/petsc/sparse_matrix_vector_05.cc
@@@ -1,0 -1,110 +1,110 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: sparse_matrix_vector_05.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check SparseMatrix::matrix_scalar_product
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w)
+ {
+   PETScWrappers::SparseMatrix m(v.size(),v.size(),v.size());
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       m.set (i,j, i+2*j);
+ 
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       v(i) = i;
+       w(i) = i+1;
+     }
+ 
+   m.compress ();
+   v.compress ();
+   w.compress ();
+ 
+   // <w,Mv>
+   const PetscScalar s = m.matrix_scalar_product (w,v);
+ 
+   // make sure we get the expected result
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       Assert (v(i) == i, ExcInternalError());
+       Assert (w(i) == i+1, ExcInternalError());
+     }
+ 
+   PetscScalar result = 0;
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       result += (i+2*j)*j*(i+1);
+ 
+   Assert (s == result, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         test (v,w);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/sparse_matrix_vector_06.cc
index 0000000000,5901150030..d0165843bf
mode 000000,100644..100644
--- a/tests/petsc/sparse_matrix_vector_06.cc
+++ b/tests/petsc/sparse_matrix_vector_06.cc
@@@ -1,0 -1,101 +1,101 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: sparse_matrix_vector_06.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check SparseMatrix::matrix_norm_square
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v)
+ {
+   PETScWrappers::SparseMatrix m(v.size(),v.size(),v.size());
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       m.set (i,j, i+2*j);
+ 
+   for (unsigned int i=0; i<v.size(); ++i)
+     v(i) = i;
+ 
+   m.compress ();
+   v.compress ();
+ 
+   // <w,Mv>
+   const PetscScalar s = m.matrix_norm_square (v);
+ 
+   // make sure we get the expected result
+   for (unsigned int i=0; i<v.size(); ++i)
+     Assert (v(i) == i, ExcInternalError());
+ 
+   PetscScalar result = 0;
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       result += (i+2*j)*j*i;
+ 
+   Assert (s == result, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (30);
+         test (v);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/sparse_matrix_vector_07.cc
index 0000000000,45bd1b80c8..b864c6ea3d
mode 000000,100644..100644
--- a/tests/petsc/sparse_matrix_vector_07.cc
+++ b/tests/petsc/sparse_matrix_vector_07.cc
@@@ -1,0 -1,113 +1,113 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: sparse_matrix_vector_07.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check SparseMatrix::matrix_norm_square
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <deal.II/lac/petsc_sparse_matrix.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w,
+            PETScWrappers::Vector &x)
+ {
+   PETScWrappers::SparseMatrix m(v.size(),v.size(),v.size());
+   for (unsigned int i=0; i<m.m(); ++i)
+     for (unsigned int j=0; j<m.m(); ++j)
+       m.set (i,j, i+2*j);
+ 
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       v(i) = i;
+       w(i) = i+1;
+     }
+ 
+   m.compress ();
+   v.compress ();
+   w.compress ();
+ 
+   // x=w-Mv
+   const double s = m.residual (x, v, w);
+ 
+   // make sure we get the expected result
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       Assert (v(i) == i, ExcInternalError());
+       Assert (w(i) == i+1, ExcInternalError());
+ 
+       double result = i+1;
+       for (unsigned int j=0; j<m.m(); ++j)
+         result -= (i+2*j)*j;
+ 
+       Assert (x(i) == result, ExcInternalError());
+     }
+ 
+   Assert (s == x.l2_norm(), ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         PETScWrappers::Vector x (100);
+         test (v,w,x);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/vector_assign_01.cc
index 0000000000,952291ef8a..857e2630d5
mode 000000,100644..100644
--- a/tests/petsc/vector_assign_01.cc
+++ b/tests/petsc/vector_assign_01.cc
@@@ -1,0 -1,94 +1,94 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: vector_assign_01.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // when calling PETScWrappers::Vector::operator() (), the return type is a
+ // reference object, not a reference to the actual element. this leads to the
+ // funny situation that an assignment like v2(i)=v1(i) isn't really what it
+ // looks like: it tries to copy the reference objects, not the values they
+ // point to, as one would expect
+ //
+ // this was fixed 2004-04-05, and this test checks that it works
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w)
+ {
+   // set the first vector
+   for (unsigned int i=0; i<v.size(); ++i)
+     v(i) = i;
+ 
+   // copy elements by reference
+   for (unsigned int i=0; i<v.size(); ++i)
+     w(i) = v(i);
+ 
+   // check that they're equal
+   Assert (v==w, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         test (v,w);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/vector_assign_02.cc
index 0000000000,606db985b0..af443190dc
mode 000000,100644..100644
--- a/tests/petsc/vector_assign_02.cc
+++ b/tests/petsc/vector_assign_02.cc
@@@ -1,0 -1,93 +1,93 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: vector_assign_02.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // this is equivalent to the petsc_vector_assign_01 test, except that we use
+ // operator+= instead of operator=. Now, this does not present a problem,
+ // since the compiler does not automatically generate a version of this
+ // operator, but simply performs the conversion to PetscScalar, i.e. the
+ // argument to the user-defined operator+=. This is not exciting, but since I
+ // wrote the test to make sure it works this way, let's keep it then...
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w)
+ {
+   // set the first vector
+   for (unsigned int i=0; i<v.size(); ++i)
+     v(i) = i;
+ 
+   // add elements by reference
+   for (unsigned int i=0; i<v.size(); ++i)
+     w(i) += v(i);
+ 
+   // check that they're equal
+   Assert (v==w, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         test (v,w);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/vector_equality_1.cc
index 0000000000,a3c2445455..209f1d1268
mode 000000,100644..100644
--- a/tests/petsc/vector_equality_1.cc
+++ b/tests/petsc/vector_equality_1.cc
@@@ -1,0 -1,89 +1,89 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: vector_equality_1.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::operator==(PETScWrappers::Vector) for vectors that are not
+ // equal
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w)
+ {
+   // set only certain elements of each
+   // vector
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       v(i) = i;
+       if (i%3 == 0)
+         w(i) = i+1.;
+     }
+ 
+   Assert (!(v==w), ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         test (v,w);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/vector_equality_2.cc
index 0000000000,b7420225de..2086f7e168
mode 000000,100644..100644
--- a/tests/petsc/vector_equality_2.cc
+++ b/tests/petsc/vector_equality_2.cc
@@@ -1,0 -1,91 +1,91 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: vector_equality_2.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::operator==(PETScWrappers::Vector) for vectors that are
+ // equal
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w)
+ {
+   // set only certain elements of each
+   // vector
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       v(i) = i;
+       if (i%3 == 0)
+         w(i) = i+1.;
+     }
+   // but then copy elements and make sure the
+   // vectors are actually equal
+   v = w;
+   Assert (v==w, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         test (v,w);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/vector_equality_3.cc
index 0000000000,411a7e65fa..d691b49561
mode 000000,100644..100644
--- a/tests/petsc/vector_equality_3.cc
+++ b/tests/petsc/vector_equality_3.cc
@@@ -1,0 -1,89 +1,89 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: vector_equality_3.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::operator!=(PETScWrappers::Vector) for vectors that are not
+ // equal
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w)
+ {
+   // set only certain elements of each
+   // vector
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       v(i) = i;
+       if (i%3 == 0)
+         w(i) = i+1.;
+     }
+ 
+   Assert (v!=w, ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         test (v,w);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/vector_equality_4.cc
index 0000000000,37d777356f..dac5683aac
mode 000000,100644..100644
--- a/tests/petsc/vector_equality_4.cc
+++ b/tests/petsc/vector_equality_4.cc
@@@ -1,0 -1,91 +1,91 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: vector_equality_4.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // check PETScWrappers::Vector::operator!=(PETScWrappers::Vector) for vectors that are
+ // equal
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w)
+ {
+   // set only certain elements of each
+   // vector
+   for (unsigned int i=0; i<v.size(); ++i)
+     {
+       v(i) = i;
+       if (i%3 == 0)
+         w(i) = i+1.;
+     }
+   // but then copy elements and make sure the
+   // vectors are actually equal
+   v = w;
+   Assert (! (v!=w), ExcInternalError());
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (100);
+         PETScWrappers::Vector w (100);
+         test (v,w);
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/vector_print.cc
index 0000000000,1c09eb3f36..8a3ceaad94
mode 000000,100644..100644
--- a/tests/petsc/vector_print.cc
+++ b/tests/petsc/vector_print.cc
@@@ -1,0 -1,83 +1,83 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: vector_print.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // verify that VectorBase::print uses the precision parameter correctly and
+ // restores the previous value of the stream precision
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ int main (int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       {
+         PETScWrappers::Vector v (5);
+         for (unsigned int i=0; i<v.size(); ++i)
+           v(i) = i*1.2345678901234567;
+ 
+         // print with old precision
+         deallog << numbers::PI << std::endl;
+ 
+         // print with prescribed precision
+         deallog << "across=false" << std::endl;
+         v.print (logfile, 10, true, false);
+ 
+         deallog << "across=true" << std::endl;
+         v.print (logfile, 10, true, true);
+ 
+         // print once more. should be the old precision again
+         deallog << numbers::PI << std::endl;
+       }
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }
diff --cc tests/petsc/vector_wrap_01.cc
index 0000000000,55f829cf49..2a24a1822e
mode 000000,100644..100644
--- a/tests/petsc/vector_wrap_01.cc
+++ b/tests/petsc/vector_wrap_01.cc
@@@ -1,0 -1,103 +1,103 @@@
+ // ---------------------------------------------------------------------
 -// $Id$
++// $Id: vector_wrap_01.cc 31349 2013-10-20 19:07:06Z maier $
+ //
+ // Copyright (C) 2004 - 2013 by the deal.II authors
+ //
+ // This file is part of the deal.II library.
+ //
+ // The deal.II library is free software; you can use it, redistribute
+ // it, and/or modify it under the terms of the GNU Lesser General
+ // Public License as published by the Free Software Foundation; either
+ // version 2.1 of the License, or (at your option) any later version.
+ // The full text of the license can be found in the file LICENSE at
+ // the top level of the deal.II distribution.
+ //
+ // ---------------------------------------------------------------------
+ 
+ 
+ 
+ // Test the constructor PETScWrappers::Vector(const Vec &) that takes an
+ // existing PETSc vector.
+ 
+ #include "../tests.h"
+ #include <deal.II/lac/petsc_vector.h>
+ #include <fstream>
+ #include <iostream>
+ #include <vector>
+ 
+ 
+ void test (PETScWrappers::Vector &v,
+            PETScWrappers::Vector &w)
+ {
+   // set the first vector
+   for (unsigned int i=0; i<v.size(); ++i)
+     v(i) = i;
+ 
+   // copy elements by reference
+   for (unsigned int i=0; i<v.size(); ++i)
+     w(i) = v(i);
+ 
+   // check that they're equal
+   Assert (v==w, ExcInternalError());
+ 
+   v=w;
+ 
+   deallog << "OK" << std::endl;
+ }
+ 
+ 
+ 
+ int main (int argc, char **argv)
+ {
+   std::ofstream logfile("output");
+   deallog.attach(logfile);
+   deallog.depth_console(0);
+   deallog.threshold_double(1.e-10);
+ 
+   try
+     {
+       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
+       Vec vpetsc;
+       int ierr = VecCreateSeq (PETSC_COMM_SELF, 100, &vpetsc);
+       AssertThrow (ierr == 0, ExcPETScError(ierr));
+       {
+         PETScWrappers::Vector v (vpetsc);
+         PETScWrappers::Vector w (100);
+         test (v,w);
+       }
+ 
+ #if DEAL_II_PETSC_VERSION_LT(3,2,0)
+       ierr = VecDestroy (vpetsc);
+ #else
+       ierr = VecDestroy (&vpetsc);
+ #endif
+ 
+       AssertThrow (ierr == 0, ExcPETScError(ierr));
+ 
+ 
+     }
+   catch (std::exception &exc)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Exception on processing: " << std::endl
+                 << exc.what() << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+ 
+       return 1;
+     }
+   catch (...)
+     {
+       std::cerr << std::endl << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       std::cerr << "Unknown exception!" << std::endl
+                 << "Aborting!" << std::endl
+                 << "----------------------------------------------------"
+                 << std::endl;
+       return 1;
+     };
+ }