Restore missing tree.

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

diff --cc tests/petsc/01.cc
index 0000000000000000000000000000000000000000,5f3cc2ad78e467f1dcf65fae0c4d9619abe42c41..56d64792505ca8c5dd01d474436073c7d43ad2ad
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,2dbcbcdb3b7bb4a163b6f67553dd9116e7164d16..49cbf67fca8e6e6969d43522bed1d60857de2e73
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,92315f09d536796c1ad638adfc0bbfc00175afae..f8dd745e7395f2db46f8d74e14f4563533911e5e
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,3991d6ecb0f665b46aa697b24aa88858c3512cea..4536b19b09f3b7b0f1d0aa719fd8b2de278e9536
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,3cf3ad8b11c598dc2c6db23ab31007c49e8b3b18..9bf02bd5ad3045add5e430d632ba9363a208e8f7
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,c0bbc2a97b08ef466226d39a43b8df00f2d3912c..1749ce421709ce765efeb331a4b4725e98e513d1
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,5a637d9bb330508cd18ecef1f286344ea6cec27c..3c5801c7a242912196debb8ee8936f1c015566c5
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,15050cd79539d006ed5f4013b24b950982310307..8f50ac83c4e3a9091ca466fa1d72086299335a2d
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,ee2dab657fd0769ed308ba7fed1f8291cf198787..b6f4e1a80148bda2dac4d7110ca03855cb913c38
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,9f99bdba542d8b06eddd1fc6febf65d0dcd0489a..ebcee72ce3e6d9421485528270daf7b45161c03e
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,a9954b0a8b0f5065e1d7b94c39a6bdadc4a7b9b7..53f58e2cea575e3a1ab751b3f1f809031d7bf15d
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,44be821ae33e87eb2f06e56b9c82adc3402a34f8..eac10a60f24b84f7d5e8314e06d962c97e6012c6
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,9501b1f042354759df83e13588afc135b5f73e86..71f750001fda2a29f60a78010dd939677de57f2d
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,3e3537cf30adad8d4be023c7de2c67a3286bda20..0d4487bf8b329ef8bac03eb523769ac773c0c8c2
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,6de9a94180aa02694076b250b5ac1de1ca10f67b..e69d50be6d5c3535da090ce7745f49fadb99c642
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,aa303d23af48174c0974573c25cba5b379ea4845..9dedc8cfe3ea6ac1e6cbca01cf3f669aabdeba09
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,4b3602598b54049f01e0ee95215755d1549240e8..f0d9775a044b66e6e89d3fae373d4a6377e29387
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,593c88d366a8a0178c8f00eae6aee5c2165e6850..7856efd3816d29f6efa2c77318d4dba1b46d713b
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,747ba74d3e7f0cec213ee6fb429e0c6fadd835f8..528737bf1323b3e11fb85d71e1b2ad8a600ada7f
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,dae86a02b1875950c7c6a848a442ab070ab95db3..386b394245b2a90ea55053a783e8d69db522a9d9
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,82a30e4adb54d7e9904f1d98cbde23bda3a60375..2d2aefb2a82b814f889787832f9799a8cd7cf3c6
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,2a26dfea28857842f6b809b3316269ed06407b45..cc7d3da409c2f9702b5320fa4c16087cde77382e
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,ea407ff9385be3c4a3c9196bbea6aca0c451fdb8..00c4df79e7e2948d8e6d34a18fd1389e4ad74a2c
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,278eb8fdfc2adbea65662ec60392490f336fc27b..e22e0cff3fb013421f2c365ebc26b3543f732148
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,f9d1b83dc665a36598e4bdfc6d0c641ba037e824..e1be0a1d238c88adb6b3a95fa3e97b5d99dfe154
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,368a4d9194570aba78ee46424f76f43c03399831..256ece53f1e4383969dadf9c85369a8cc4cb3e6a
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,725303a2d008764195b963ba6cd0cbf552d1a5f3..f06fe2960206dfeeff65c3cbe6e78ebb12a4c542
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,1136971c1ff21bb8cbc7a9bf0b612345620d5f2b..5ffcb10df5b8209c15cf5faa60f1fb1878ac74c8
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,7cdf00cdb28187d645a3967982009e0e19e12e2c..b38d57e5252b4c10c3d77f1c61f9b2bc13b64244
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,d2ce01c600ce4539aa69d02d493d847e1843663d..4d26ab53ffe9dc2709a1c3d50cc7b20938e3c884
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,bf0b6bcd51f763e7ef70af98a3ac8a86f06c7ce3..130d7dc7314454831c9e76454df7ee15d22a17af
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,a0eeea75eeedd80aeb0a5a99fc3a82d419f428f7..93ef5c84431f8753c7f090adf55c6ecfd219113c
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,ff11c6aabe25c70f43a0eaf55f5f7c5d69d18957..456812c2f24d58a08bd1d796e1fa473922464a0b
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,aacb319b3dec5a24283afcaf7afa58b5bebb91e9..487a19693bb43d14cef200a5ea99ef515ea4fe85
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,662e3334f289bc76403b685a7490d0165019f955..3ccee495441bf4146fba3dc7361f820e2b172e46
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,1ea51675ae49d8d695a8fa634d10fa8ac1fcf201..7198d5a5bf6f09d9a30f328085a6b0a6ce6f7d56
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,feca17d76569b37873b4c8a041599508f9d47ee9..0d228214693aada63406eae516613911012f05ef
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,caf0d11fd62d135210a889d5a829ce543838b205..e4f765cf943579c66464c52ade5734f3f755799e
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,5675ffb3529756ace76aaf372753bacebd043e05..ec7e7ccb9d02345a6120074f3856d0f58af654b6
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,f53690ca539f65ff198ff93dcee828463a24805e..0d805ab73b2f133404d1945d859e2842f848d3ac
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,c63f0f2787455ceab3ff745e631a92135ebad054..88bfadbdf46553b473dfe7586f9c5ad1726ea007
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,c063b757214e4002cc0b9942d6f21d47c00cd646..7d405e62ab76c7360aa659fb02b2c7007ba28667
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,d3065bf076f9cd71d8682b7477fbe2d9251298ae..3fc2bb17b708625c29e71a756a38cda086699ad6
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,cb99358075e7d4f3066703f477c96efc26069785..66a0fd5a498c5e75d4b92eed9d8b9b7183ec5068
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,0797dc6c44dff44a731c98ec7258fc165dfb8224..62ceb915ed95039465bd989bf214de5b6d0e5737
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,9d3e95d6b64a177e5b0b9d7ec129582f09079b14..7f168beec3bc98ba52460dd78a3d9ab88080bf46
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,f7b826b64f450d3324f1c93f19e59b92412e0c49..ca8e8087858d52c14f887ea10c030d16da01ee6c
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,3cf2e2e38d2ad487adc1dd0a279f52748b304f6b..2fbd03a45278a8c35c8895205dc2eb1acb2b76a4
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,a6dd4500678b2299671fa66d844b94d9e1167a3b..59edea4281994bc0233859f4403877df93c441e2
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,8183680678f626743c646f7bf8c1d89af7e0ddbb..687c1788bc2a035a6aa3f7871944b20ab920b94f
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,4a20c3bfe8b7f6874a6a21737cd5454198e19304..6f195ec46e49f2c9c5de258f915904501905e67b
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,5b195aeb5b170aafc1a11122bcbbb2bf3f462d70..0f79f0ed5b2e83083743f80cfd5097445a6a7b81
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,3bb270d0fcff038df67403b4dad6cbf198f32860..0105533787b56bca6d3b8123c347106b732f6a80
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,77cba8303053b98888be071459d5e9d1f4ef3a1f..8449c16fc6142d1cc4e1d024d137b1e745ac1279
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,75547b0ebd3249c1285e5d46e3bfafd02d55bac8..48dde01c8dca55c7c26ec03334b60b8a6d91325d
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,c0530bdecbd9ced2b1b1b070167ab4f697e28a0e..d144af6e9d3cc380f0253e0e7fa05495d7cb18fd
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,8b604a8309cd1a4b0163abfa3987f976322fe976..b425a356aaaf89d0638aa0b0248b8842bceca552
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,f3ac6984354db55024788600f4687687172ba052..b161c724abb2385cf1f7e51a7330dc2d4ade2bb0
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,cf425c8b45305dcc884fa7658b4309bcc6d3bc50..0cad0849116d3664530c2406e67734f1b10f441c
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,a921906e92465896b38226c2b86f4bb8e9b09198..4d0a9d550bf3a5e055000a1888e6c8bd1b7c5cdf
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,565371457858d8ea35a884ce329607199828333c..dc20cb9cf0b8ddfbb5ead2a83987a0cd8db6d3a5
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,676a852245596a07f9e39380b98858f432389fde..5e0d049a683ebd6af8abfad48e328fb8fc9dbf4d
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,55e76a9394db800013484115ca14a610c337b767..42a5fa0cba110088796d85f0f10f03c0d3d7d18c
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,bc4132c6beb3aab39c7214670ad9e12a6a67e83d..c2a353b39ee1382a99cfe58b2226582605f4e8ca
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,e6fa61832a9872d5ed198be0a3f69398442b4d1c..cfd8a87a66c014183095edc42514adbb8f31a59f
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,117bc796969f71d5ab810e30134f016d24c8fe65..79e5b7ef72f4c045dc177721012e7c1008941a2d
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,8ed06ee6236807a4594d42f215fabc5c4ec7bab4..efdf599c47d579b2bc24c7f54537995fea0d511a
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,1e73402ba099a573a096ca0aaf8d96935326bf34..a4ce2a41e2a3c3c04692b2b859f770805e853b05
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,46f04c6fa5c9db83ce89506f65aa7bd53adce8f6..4956cb16fc3c063b090d3ef03dd5207e6d6980a3
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,831ebb38ec143238ce8497f220e18af9b34e261c..186e4277796fe18d7a65770951b021e18d3370f1
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,f4a88b8bc47e7d6e26106f177064da0cc93cecc9..78354c3fbaf9faa5ebc800616f1dcdce0b60ae09
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,033b498db63ef2dd4726b17d11e7a71b2b46debb..4df0110708636f1a0801ccc6f2277e2096aeaeaf
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,6125db2d92906d8aec288d349dd735cac0df3fd3..6eef69a87be48fc24ba27eb2abbcbd740d8cae19
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,629ba76c6828078b52d5515046a14898a46b1023..a6300be938d6b759a156d56842fab98f51f6e872
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,b5bfbe95ac0684baf465f7a48ec9b499da0ccd59..e078e696aa40c29b75de62d37f93e13962234699
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,36851aa8fcbba7619191fe3f1d13e1fc76d201b9..f4566f42ade956a4704b9d0019a5166d94c403ac
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,941c32f8fe831319641f9d96fa2fd324e2c77734..1fdf53b9d7fd805bcd399124cd304eabd6cefb44
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,29d8e07e0cd4e37ca893464ee4cad1ac4ffb3c84..0202e44cd7a908277b60b2b3252196b72daa75ae
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,f3c6201ccb2856a46ab37918bcdc2bd9afa42390..f082cdb904f6e600226956c711e5d48ba6caeb4d
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,a7b0bb8a087d6855def9c858f2a90caa52bcdc97..5e6a4f9fce0676401ca240bd7a11d90fbea477de
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,203f39f0bc084bca476bc8b1f50b51c4805ec58f..dbb932b7457ec84af1b07298c65438aaab99c0a1
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,94d29eb3cf1f5a8bbb1055e7f245083f2755b15f..23e494eeca4f1f95c7eb34034a83c2757d113236
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,daabd4732884a60645a208cc2d668d0bf56087cb..efabc33eef13a3e17936ecbdc924b2f206ef0685
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,6bf332a6f1e60ef14af2b0ef5a6a81e74f432748..1e8edade61fe7cf6b895797a519fa4d9c5a9aae7
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,1309f3cb23c0b72c3fe1033db4d3f1c78feb3924..e1b0ccce6c6fb246ee16a59571ea231150850d60
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,4ed5c1b261d77c44fcb0f4a33daf761355ca44ab..c451842cc7871dcd20c1df87e3833d4d9ec61f1f
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,1d67d92f3d0d72baf04593e23137fd827b7ba8b4..0bc553a38095583e3ffb9a7a3f859ae14f87bf1a
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,5514768e607422688166e7d27819129635b623a7..34073abd13e1b48eed5be93b0d47ae1204d96a1b
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,4eead31ae6fdd6e092fec66528954c390a08bd57..8cf09746e66c1ed12e18df7b7b682b563665b3a4
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,fc1cfb4e94a1ff8543df784716d0ec5a11e95ff0..8ce30ee35235fa0549152c8fcfbc5b1e722ba7b4
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,6132e73afe1a78fc8d7e1e09410d70048daa9181..c7b46da1d788fbc3d400933486425560a53b098b
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,7290ec6caa47b9a65ed19b10c7f416996ab95a4f..38cd2ad60d933245b448b99f1e046fb2bc36986e
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,9611d27990e59c1652a3ad9d930b0fe3bb430fa8..cbfa5140726f4809880581ff57ab90722ddee7aa
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,d004153eb070c290660a6a12c9bec749b6ace608..4c3b7fc14255b845afe60242e38ab62ba79113d2
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,221ff387144049e392a972b7836b4bd14d9f5ff8..c48f0385553d791a461e04130d6b4622dbb49ba5
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,5c68a79f410d357fcbb7b907647352347f9e7046..88d6a130990f880d5314b5b214199fc9046b91da
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,baf08b9793dd6e8e553b699f6e010d079fff06ab..a4c0ba388e4ce796394057411652084a1be39ee2
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,57b908cc00a032b2e9d0ea260cc4713d19d164b2..5fbdca2b27c384ea6915ff891c0306a7d8e26843
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,84428afb5471348f983a73258ffcfcd6c9181689..abd162aeabb415e8350858ae4d8d3ef1a78d6935
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,8c452a78b1f31d8bfd6eeafbac5747b34c61e0eb..9063e66030ae7b8b3765d8b7ae8bfa1015dd43ef
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,73a442f1a55924dfe892ce58d59c23ce6f9bb499..24bca339eab8ac2727278a8804deb0ec41292e57
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,6551a25c05d1343141bafcafd43e7889c812a06e..767429cb030c0c400e2c1fd1280452a168aac384
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,6849d749796329577bc72e04a15066919b0640b9..80ce3747f751fa3b1b168067b4c50a2a56f36c43
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,faad508f0ac0f1c47896701acb8d204f6f0111b0..1dab2d8631734c3f522e932a683a10a5f96e6357
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,beabcf434abae689b25e36a8d33c4eddfa324d62..dcc93aa586ae5e6f90a00bf048edf39e4dcb1f03
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,05ffee26f7e076cf7688856038dbb5cafc9dd6ff..5b0ea95b2109b1e1c813a87ac9439e33f8e22ce1
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,f0700eebc51cde7973ccf66849d630f035a27993..af7be7a3ffa881e8f50455a33e5d2086587f48b9
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,67fd339d47eba2d62db1b24bab75107e5d646b3b..cf01bc3f1d5dbea3744e847b4ed7176b937d97d7
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,2d9819fba45f536d09d2a9a3d59ebed37b82938b..4db245a1b638d29bc6912db8d58751bfb3ce3906
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,15f6466e8cdb666e673cbefa4ba3b567b27f0f60..98561a2c5a9cad1bcf0dbf12c0c9516a9d57868d
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,e19bddaf0c37f758ab55db3e83253a87c11296cd..6500756f5098988e660f782834c8d294c18cf263
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,12d44a6ae2f123a9eb0e798f0d70e8385fd9cb1f..947b584db2c0c34b7e2becd280ef875fe858ab23
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,56b38ef60d7fb64428bc38a24fb160eaa8e5bcf1..fbad08211702783087065a5425bc62f58e353c92
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,3297bd8fe2176de9dfe39dda041781740a867dd2..3b52a48e3d3c406c9162acc6a4c6ade11253cd09
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,df81e7dbd2487ce565ba76f0349e29d49ae5e9ae..488b11300e424de2ee4c27c956e9cf418d175581
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,a7e585eb330d37e5f604f40d08a541644426e4ec..9fff4d6cea641bd04f42fb42f6edb039c0dcc983
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,79e44183a90999eddf4c38b125836451639fd5bc..f2d0ba07d872c9b83fe63f9611dfb7b42174b286
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,b28e88cafe33029c9368797b575133002a2df379..e77d2044f36f52260d6af0bd67d43fd1872b706e
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,01956e4e02b758617c231d772af1ffc2b92397b3..6a60135011523334c694afca099f3d4325c56633
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,b070cc721c6db33d764dde56fb1096ee08300fc9..bc6e0143cb92b111548f8a6cff2bab20a9738229
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,656249941890cf6a3acfadc6e081ffbaaec9dad0..9bf41c0d4d7dff8b2aa90c650bd8d1e3a078e09c
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,b127bb49eec24d957d03c43ce5a2e0845c453376..fdd1f3fa456640e545c4120a85167efe46bcd973
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,667d48d3c3b3846b09b40c2deadf5cd1e83d81b1..d496def18017d6a8a8c3440b94a1418c3c2ec925
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,357e719c5e7de5ccad57e8519e719c466f302d1e..ff830de07cba83c4c9879a0f006751a54c9cbbae
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,d17bad38c15a119df1c9eadec3b009f349ac3b8a..ddd751faa33b9e9f0181e187fb4afbcce3c1032a
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,59011500306eb73a2b046e8b7934817fc209bf1b..d0165843bf7d8aa71dbc2f92d9556893e8ca8554
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,45bd1b80c8ca7720a8ab490d892200494daca3af..b864c6ea3d86019e28b2b0abc7f2a1874ec995f4
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,952291ef8a3d482de1668c894ca524af664f7132..857e2630d5eda0330071f6a7e36e525e690c2f5a
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,606db985b0d7ae9059bbf6bb9f55909daed04266..af443190dce78f3e080de30cbe212fd371d0fe9d
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,a3c244545574e9d14ce2f36221bd8a2ad04f76c0..209f1d12681726c2c010cc310ab4408365d408b4
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,b7420225dee954980ae32d1520f4bbfa004a07b6..2086f7e168482b01ecea0c8fbf939efe3aa06e17
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,411a7e65fa24e673578a5d1a0988ddf4a17598ba..d691b4956150983c79807b6733d1ce3cadce390a
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,37d777356fd12ad54967f395a1c16f28edeeb7d8..dac5683aacdd188259c7c6d87fee45a44ad5e955
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,1c09eb3f36e624af33a8064380530735967b486d..8a3ceaad949f80e84a661ca8b5a527bfecafc739
mode 000000,100644..100644
--- /dev/null
--- 2/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 0000000000000000000000000000000000000000,55f829cf4904fda6fffe816d7eca5f872b034e54..2a24a1822e6ad4e9ba546bbfa6921de78ef9c7bb
mode 000000,100644..100644
--- /dev/null
--- 2/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;
+     };
+ }