Merge new testsuite into branch_petsc_scalar_complex. Modify petsc_complex and slepc_...

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

diff --cc deal.II/source/lac/slepc_solver.cc
Simple merge

diff --cc tests/petsc/12.cc
index 2f7735bb8aa3ef0f50ed94e7fbc5b6b3daa8604c,a9954b0a8b0f5065e1d7b94c39a6bdadc4a7b9b7..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/12.cc
--- 2/tests/petsc/12.cc
+++ /dev/null
@@@ -1,95 -1,95 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("12/output");
 -  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 093f7a5d0d111f413d2853cf459784019eb96481,aa303d23af48174c0974573c25cba5b379ea4845..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/20.cc
--- 2/tests/petsc/20.cc
+++ /dev/null
@@@ -1,96 -1,96 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("20/output");
 -  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 025a0e739b5aeb4bdb856e44e9743ecc46e49c45,4b3602598b54049f01e0ee95215755d1549240e8..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/21.cc
--- 2/tests/petsc/21.cc
+++ /dev/null
@@@ -1,96 -1,96 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("21/output");
 -  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 ff3e68b321600a8797de112e50a9c951c6b51c6d,593c88d366a8a0178c8f00eae6aee5c2165e6850..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/22.cc
--- 2/tests/petsc/22.cc
+++ /dev/null
@@@ -1,91 -1,91 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("22/output");
 -  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 39cefff140964703297178959eb1b6536102d18d,747ba74d3e7f0cec213ee6fb429e0c6fadd835f8..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/23.cc
--- 2/tests/petsc/23.cc
+++ /dev/null
@@@ -1,98 -1,98 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("23/output");
 -  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 83d244116cf498e59cbe0ea6618c2558c941b6b6,dae86a02b1875950c7c6a848a442ab070ab95db3..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/24.cc
--- 2/tests/petsc/24.cc
+++ /dev/null
@@@ -1,90 -1,90 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("24/output");
 -  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 664daabe1363d74ad41fb4e371c8fa67362e37ed,82a30e4adb54d7e9904f1d98cbde23bda3a60375..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/25.cc
--- 2/tests/petsc/25.cc
+++ /dev/null
@@@ -1,88 -1,88 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("25/output");
 -  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 99808a0f6cefbfde45cf1ebfd6c4074935b740e9,2a26dfea28857842f6b809b3316269ed06407b45..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/26.cc
--- 2/tests/petsc/26.cc
+++ /dev/null
@@@ -1,87 -1,87 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("26/output");
 -  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 977b667fb5a296d08e081cff770eafdcda47a95a,ea407ff9385be3c4a3c9196bbea6aca0c451fdb8..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/27.cc
--- 2/tests/petsc/27.cc
+++ /dev/null
@@@ -1,92 -1,92 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("27/output");
 -  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 caae5310e110cf9c88e1b47af376c164f31f2642,278eb8fdfc2adbea65662ec60392490f336fc27b..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/28.cc
--- 2/tests/petsc/28.cc
+++ /dev/null
@@@ -1,94 -1,94 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("28/output");
 -  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 6735d469257b916467ab050b336a439ca2e3804a,f9d1b83dc665a36598e4bdfc6d0c641ba037e824..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/29.cc
--- 2/tests/petsc/29.cc
+++ /dev/null
@@@ -1,79 -1,79 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("29/output");
 -  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 d19042b55f4279bcbfb3fe39d8bb967d997225bd,368a4d9194570aba78ee46424f76f43c03399831..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/30.cc
--- 2/tests/petsc/30.cc
+++ /dev/null
@@@ -1,87 -1,87 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("30/output");
 -  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 999875a194ace089dd8768c6668f37905b0a4252,725303a2d008764195b963ba6cd0cbf552d1a5f3..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/31.cc
--- 2/tests/petsc/31.cc
+++ /dev/null
@@@ -1,89 -1,89 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("31/output");
 -  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 a00689f96a02e30877bd3d88628edae885c74f4d,1136971c1ff21bb8cbc7a9bf0b612345620d5f2b..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/32.cc
--- 2/tests/petsc/32.cc
+++ /dev/null
@@@ -1,89 -1,89 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("32/output");
 -  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 e10e8edee6d706d9f69716f82fd9ba03ef3e4635,7cdf00cdb28187d645a3967982009e0e19e12e2c..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/33.cc
--- 2/tests/petsc/33.cc
+++ /dev/null
@@@ -1,90 -1,90 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("33/output");
 -  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 b2c73c1027518c65841ae884ac6cabcea8c6d4c3,d2ce01c600ce4539aa69d02d493d847e1843663d..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/34.cc
--- 2/tests/petsc/34.cc
+++ /dev/null
@@@ -1,90 -1,90 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("34/output");
 -  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 650f0e522fa3829ef2b19b27b2f5cc61050b5e1b,bf0b6bcd51f763e7ef70af98a3ac8a86f06c7ce3..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/35.cc
--- 2/tests/petsc/35.cc
+++ /dev/null
@@@ -1,107 -1,107 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("35/output");
 -  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 ecee1fed235e200eaf2ea7fc445e510bdf9db976,a0eeea75eeedd80aeb0a5a99fc3a82d419f428f7..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/36.cc
--- 2/tests/petsc/36.cc
+++ /dev/null
@@@ -1,107 -1,107 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("36/output");
 -  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 d5168ca892127a47873384a7094e363f2ce419e4,ff11c6aabe25c70f43a0eaf55f5f7c5d69d18957..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/37.cc
--- 2/tests/petsc/37.cc
+++ /dev/null
@@@ -1,86 -1,86 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("37/output");
 -  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 c27730483d6fc9b2e70cfa3b71b434da518b363d,aacb319b3dec5a24283afcaf7afa58b5bebb91e9..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/38.cc
--- 2/tests/petsc/38.cc
+++ /dev/null
@@@ -1,95 -1,95 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("38/output");
 -  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 bcbb87c189ace2b7fb9ef56b1797c7ab1881c498,662e3334f289bc76403b685a7490d0165019f955..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/39.cc
--- 2/tests/petsc/39.cc
+++ /dev/null
@@@ -1,95 -1,95 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("39/output");
 -  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 197e3e2f1436a94495bd80468c3f164ebf7ceee9,1ea51675ae49d8d695a8fa634d10fa8ac1fcf201..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/40.cc
--- 2/tests/petsc/40.cc
+++ /dev/null
@@@ -1,100 -1,100 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("40/output");
 -  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 d873ec1e919b5d8468150d86662b039bb5b67af2,feca17d76569b37873b4c8a041599508f9d47ee9..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/41.cc
--- 2/tests/petsc/41.cc
+++ /dev/null
@@@ -1,95 -1,95 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("41/output");
 -  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 2d23c07633d1c2638173f7bffddbcade796c4f62,caf0d11fd62d135210a889d5a829ce543838b205..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/42.cc
--- 2/tests/petsc/42.cc
+++ /dev/null
@@@ -1,95 -1,95 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("42/output");
 -  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 c4d49ece4782accd2840d3a9e27d5d34c3f564c9,5675ffb3529756ace76aaf372753bacebd043e05..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/43.cc
--- 2/tests/petsc/43.cc
+++ /dev/null
@@@ -1,100 -1,100 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("43/output");
 -  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 263844e01212f2cb662eef8236ed805fda9fd71e,f53690ca539f65ff198ff93dcee828463a24805e..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/44.cc
--- 2/tests/petsc/44.cc
+++ /dev/null
@@@ -1,105 -1,105 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("44/output");
 -  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 fa9189a20365fe67e91077e5fae4c75888429640,c63f0f2787455ceab3ff745e631a92135ebad054..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/45.cc
--- 2/tests/petsc/45.cc
+++ /dev/null
@@@ -1,95 -1,95 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("45/output");
 -  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 ee89cbeda7915854917e2047ef3bc6f0cc8bcef0,c063b757214e4002cc0b9942d6f21d47c00cd646..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/46.cc
--- 2/tests/petsc/46.cc
+++ /dev/null
@@@ -1,95 -1,95 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("46/output");
 -  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 fad3ae044be74ca0eae9eae6553aae72c62a216f,d3065bf076f9cd71d8682b7477fbe2d9251298ae..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/47.cc
--- 2/tests/petsc/47.cc
+++ /dev/null
@@@ -1,100 -1,100 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("47/output");
 -  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 d7e6ea1ff1f43f4f9fbbd934772caff3f7c24cb0,cb99358075e7d4f3066703f477c96efc26069785..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/48.cc
--- 2/tests/petsc/48.cc
+++ /dev/null
@@@ -1,102 -1,102 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("48/output");
 -  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 48ec7229e678a794a673b0ccbc2afcdadb02131f,0797dc6c44dff44a731c98ec7258fc165dfb8224..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/49.cc
--- 2/tests/petsc/49.cc
+++ /dev/null
@@@ -1,91 -1,91 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("49/output");
 -  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 57449973fd9194a2c2e334008d4257fdf21a8a40,9d3e95d6b64a177e5b0b9d7ec129582f09079b14..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/50.cc
--- 2/tests/petsc/50.cc
+++ /dev/null
@@@ -1,107 -1,107 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("50/output");
 -  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 882019b01f67f3a4040cb3471125885da8e74277,f7b826b64f450d3324f1c93f19e59b92412e0c49..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/51.cc
--- 2/tests/petsc/51.cc
+++ /dev/null
@@@ -1,92 -1,92 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("51/output");
 -  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 84b539d51457b24f42bd1a78f51229ec21cd8cf1,3cf2e2e38d2ad487adc1dd0a279f52748b304f6b..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/52.cc
--- 2/tests/petsc/52.cc
+++ /dev/null
@@@ -1,102 -1,102 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("52/output");
 -  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 e1066837cf754c2229dc0a98f4d33fd5c573c1cc,a6dd4500678b2299671fa66d844b94d9e1167a3b..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/55.cc
--- 2/tests/petsc/55.cc
+++ /dev/null
@@@ -1,97 -1,97 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("55/output");
 -  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 fd4cbf5e464b1b50d4cb9dea9aa18e478bdd3a44,8183680678f626743c646f7bf8c1d89af7e0ddbb..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/56.cc
--- 2/tests/petsc/56.cc
+++ /dev/null
@@@ -1,97 -1,97 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("56/output");
 -  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 1ef259381b258699449e72f5c1ab6ac60148a4cf,4a20c3bfe8b7f6874a6a21737cd5454198e19304..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/57.cc
--- 2/tests/petsc/57.cc
+++ /dev/null
@@@ -1,95 -1,95 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("57/output");
 -  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 ecac29e16744cd58b30f3f020b7d23f4d31a83b3,5b195aeb5b170aafc1a11122bcbbb2bf3f462d70..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/58.cc
--- 2/tests/petsc/58.cc
+++ /dev/null
@@@ -1,97 -1,97 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("58/output");
 -  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 48ec4809962773bac0c71874b6a86113c0684a61,3bb270d0fcff038df67403b4dad6cbf198f32860..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/59.cc
--- 2/tests/petsc/59.cc
+++ /dev/null
@@@ -1,100 -1,100 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("59/output");
 -  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 2c75445db5f7a02b4d0a1a335d11102f921bfa36,77cba8303053b98888be071459d5e9d1f4ef3a1f..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/60.cc
--- 2/tests/petsc/60.cc
+++ /dev/null
@@@ -1,99 -1,99 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("60/output");
 -  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 9d56614645d7ca783e5b86f245babc3c01692c45,75547b0ebd3249c1285e5d46e3bfafd02d55bac8..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/61.cc
--- 2/tests/petsc/61.cc
+++ /dev/null
@@@ -1,104 -1,104 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("61/output");
 -  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 80cfef438014c6b0f52e4738be5268cf518cee67,c0530bdecbd9ced2b1b1b070167ab4f697e28a0e..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/62.cc
--- 2/tests/petsc/62.cc
+++ /dev/null
@@@ -1,85 -1,85 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("62/output");
 -  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 1416c91a57c914e0927d93a5700cca1dbc88bcd7,8b604a8309cd1a4b0163abfa3987f976322fe976..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/63.cc
--- 2/tests/petsc/63.cc
+++ /dev/null
@@@ -1,83 -1,83 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("63/output");
 -  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 a51fc99056a7a0eacdc748c56fae016de1e37d37,f3ac6984354db55024788600f4687687172ba052..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/64.cc
--- 2/tests/petsc/64.cc
+++ /dev/null
@@@ -1,104 -1,104 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("64/output");
 -  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 cb6f453615f8c63b1f031c83c9a3d9539562f1a5,cf425c8b45305dcc884fa7658b4309bcc6d3bc50..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/65.cc
--- 2/tests/petsc/65.cc
+++ /dev/null
@@@ -1,81 -1,81 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("65/output");
 -  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 0dbdbdd23c0b340ada920cf14ecf01836a405af4,a921906e92465896b38226c2b86f4bb8e9b09198..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/66.cc
--- 2/tests/petsc/66.cc
+++ /dev/null
@@@ -1,139 -1,139 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("66/output");
 -  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 5b11211427f42a16e8d07654f296ece70bffba97,565371457858d8ea35a884ce329607199828333c..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/67.cc
--- 2/tests/petsc/67.cc
+++ /dev/null
@@@ -1,147 -1,147 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("67/output");
 -  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 9df4c16f069c755a8ed6e41a24e9351150280769,676a852245596a07f9e39380b98858f432389fde..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/68.cc
--- 2/tests/petsc/68.cc
+++ /dev/null
@@@ -1,143 -1,143 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("68/output");
 -  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 c7ad6487d9632c251ac6eb6d83773141b67e93d1,55e76a9394db800013484115ca14a610c337b767..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/69.cc
--- 2/tests/petsc/69.cc
+++ /dev/null
@@@ -1,151 -1,151 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("69/output");
 -  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 7cd3b8b7410edb524ec4f984edadd3f704613019,bc4132c6beb3aab39c7214670ad9e12a6a67e83d..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/70.cc
--- 2/tests/petsc/70.cc
+++ /dev/null
@@@ -1,40 -1,40 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("70/output");
 -  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 cfe7e2171b62d48efefe15e908fe2a2cf61fe464,e6fa61832a9872d5ed198be0a3f69398442b4d1c..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/block_vector_iterator_01.cc
--- 2/tests/petsc/block_vector_iterator_01.cc
+++ /dev/null
@@@ -1,121 -1,121 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("block_vector_iterator_01/output");
 -  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 32e94e2fe01efe24135752493aa091d52bb4fe07,117bc796969f71d5ab810e30134f016d24c8fe65..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/block_vector_iterator_02.cc
--- 2/tests/petsc/block_vector_iterator_02.cc
+++ /dev/null
@@@ -1,115 -1,115 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("block_vector_iterator_02/output");
 -  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 fb1e2a5ea821a9bd644c1f5333fdeea26197a099,8ed06ee6236807a4594d42f215fabc5c4ec7bab4..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/block_vector_iterator_03.cc
--- 2/tests/petsc/block_vector_iterator_03.cc
+++ /dev/null
@@@ -1,370 -1,370 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// 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("block_vector_iterator_03/output");
 -  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 8e7b050555d64e2e6d3f4d687207de30ac89c60a,1e73402ba099a573a096ca0aaf8d96935326bf34..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/deal_solver_01.cc
--- 2/tests/petsc/deal_solver_01.cc
+++ /dev/null
@@@ -1,101 -1,101 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("deal_solver_01/output");
 -  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 a3371240449ae039c551184e8a35fef6fa506947,46f04c6fa5c9db83ce89506f65aa7bd53adce8f6..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/deal_solver_02.cc
--- 2/tests/petsc/deal_solver_02.cc
+++ /dev/null
@@@ -1,103 -1,103 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("deal_solver_02/output");
 -  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 62abb6bd07130ef8e6bb2131f5e70cf1aee51199,831ebb38ec143238ce8497f220e18af9b34e261c..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/deal_solver_03.cc
--- 2/tests/petsc/deal_solver_03.cc
+++ /dev/null
@@@ -1,103 -1,103 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("deal_solver_03/output");
 -  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 be1c544a2c5b5317577da4de91e704cd7604c0ac,f4a88b8bc47e7d6e26106f177064da0cc93cecc9..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/deal_solver_04.cc
--- 2/tests/petsc/deal_solver_04.cc
+++ /dev/null
@@@ -1,102 -1,102 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("deal_solver_04/output");
 -  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 81b77f6e88ec249e76ad95837d08877b8f3dd90b,033b498db63ef2dd4726b17d11e7a71b2b46debb..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/deal_solver_05.cc
--- 2/tests/petsc/deal_solver_05.cc
+++ /dev/null
@@@ -1,101 -1,101 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("deal_solver_05/output");
 -  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 1658be2a3a74d068375018f79159be0bc6d9e657,6125db2d92906d8aec288d349dd735cac0df3fd3..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/full_matrix_01.cc
--- 2/tests/petsc/full_matrix_01.cc
+++ /dev/null
@@@ -1,97 -1,97 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("full_matrix_01/output");
 -  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 106c2befad51a2c3b6906fb148187eb23466cfd8,629ba76c6828078b52d5515046a14898a46b1023..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/full_matrix_02.cc
--- 2/tests/petsc/full_matrix_02.cc
+++ /dev/null
@@@ -1,97 -1,97 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("full_matrix_02/output");
 -  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 af8c8367353d67927be5b5c8aede853c0802a6ad,b5bfbe95ac0684baf465f7a48ec9b499da0ccd59..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/full_matrix_04.cc
--- 2/tests/petsc/full_matrix_04.cc
+++ /dev/null
@@@ -1,77 -1,77 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("full_matrix_04/output");
 -  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 592ffb17a129c88e022003b4976e53c6a2556e1b,36851aa8fcbba7619191fe3f1d13e1fc76d201b9..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/full_matrix_05.cc
--- 2/tests/petsc/full_matrix_05.cc
+++ /dev/null
@@@ -1,93 -1,93 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("full_matrix_05/output");
 -  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 c0938195717f8da7a5ed6e03310ff05108ded060,941c32f8fe831319641f9d96fa2fd324e2c77734..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/full_matrix_06.cc
--- 2/tests/petsc/full_matrix_06.cc
+++ /dev/null
@@@ -1,88 -1,88 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("full_matrix_06/output");
 -  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 d9382dd187c0c3bc58c3e54c73234beef9a14379,29d8e07e0cd4e37ca893464ee4cad1ac4ffb3c84..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/full_matrix_07.cc
--- 2/tests/petsc/full_matrix_07.cc
+++ /dev/null
@@@ -1,88 -1,88 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("full_matrix_07/output");
 -  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 1ba700b999f2b89210ee1a1100a74ac77fd51823,f3c6201ccb2856a46ab37918bcdc2bd9afa42390..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/full_matrix_08.cc
--- 2/tests/petsc/full_matrix_08.cc
+++ /dev/null
@@@ -1,93 -1,93 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("full_matrix_08/output");
 -  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 35550c937606b19883fea609d3b0c3ce79b8d12e,a7b0bb8a087d6855def9c858f2a90caa52bcdc97..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/full_matrix_09.cc
--- 2/tests/petsc/full_matrix_09.cc
+++ /dev/null
@@@ -1,100 -1,100 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("full_matrix_09/output");
 -  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 030ad097855d4ac5ea4e6dd6eaff28609d9e6517,203f39f0bc084bca476bc8b1f50b51c4805ec58f..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/full_matrix_10.cc
--- 2/tests/petsc/full_matrix_10.cc
+++ /dev/null
@@@ -1,100 -1,100 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("full_matrix_10/output");
 -  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 4e9d3191f8cc00432ebc383d1102bf5342b71c38,94d29eb3cf1f5a8bbb1055e7f245083f2755b15f..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/full_matrix_iterator_01.cc
--- 2/tests/petsc/full_matrix_iterator_01.cc
+++ /dev/null
@@@ -1,85 -1,85 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("full_matrix_iterator_01/output");
 -  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_02.cc
index eed9d91174445cec6679fb7419e4d314892d8590,6bf332a6f1e60ef14af2b0ef5a6a81e74f432748..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/full_matrix_vector_02.cc
--- 2/tests/petsc/full_matrix_vector_02.cc
+++ /dev/null
@@@ -1,104 -1,104 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("full_matrix_vector_02/output");
 -  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 ad3bfb5f94bd0d53f9d8c8a483d3527cdbcd43f9,1309f3cb23c0b72c3fe1033db4d3f1c78feb3924..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/full_matrix_vector_03.cc
--- 2/tests/petsc/full_matrix_vector_03.cc
+++ /dev/null
@@@ -1,107 -1,107 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("full_matrix_vector_03/output");
 -  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 478c2f820ebaa0028536b276f9869f249a1ea798,4ed5c1b261d77c44fcb0f4a33daf761355ca44ab..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/full_matrix_vector_04.cc
--- 2/tests/petsc/full_matrix_vector_04.cc
+++ /dev/null
@@@ -1,107 -1,107 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("full_matrix_vector_04/output");
 -  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 f8c0c8464edebf0cf094b341d6fd26298bb6fb75,1d67d92f3d0d72baf04593e23137fd827b7ba8b4..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/full_matrix_vector_05.cc
--- 2/tests/petsc/full_matrix_vector_05.cc
+++ /dev/null
@@@ -1,110 -1,110 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("full_matrix_vector_05/output");
 -  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 1a415ed0725f377708740965bcd63e2de5d09270,5514768e607422688166e7d27819129635b623a7..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/full_matrix_vector_06.cc
--- 2/tests/petsc/full_matrix_vector_06.cc
+++ /dev/null
@@@ -1,101 -1,101 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("full_matrix_vector_06/output");
 -  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 c1a6fcccdf9ca89a7d961db938d0b6c008e4f837,4eead31ae6fdd6e092fec66528954c390a08bd57..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/full_matrix_vector_07.cc
--- 2/tests/petsc/full_matrix_vector_07.cc
+++ /dev/null
@@@ -1,113 -1,113 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("full_matrix_vector_07/output");
 -  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 142d8bfe54a0a5dd14f79dfa0039327c9a1d181a,fc1cfb4e94a1ff8543df784716d0ec5a11e95ff0..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/parallel_sparse_matrix_01.cc
--- 2/tests/petsc/parallel_sparse_matrix_01.cc
+++ /dev/null
@@@ -1,159 -1,159 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("parallel_sparse_matrix_01/output");
 -  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 6132e73afe1a78fc8d7e1e09410d70048daa9181,6132e73afe1a78fc8d7e1e09410d70048daa9181..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/petsc_mf_testmatrix.h
--- 2/tests/petsc/petsc_mf_testmatrix.h
+++ /dev/null
@@@ -1,162 -1,162 +1,0 @@@
--// $Id$
--
--#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 2a8e0c3101a96200bb4dfd3cb76e311316ed6e7c,7290ec6caa47b9a65ed19b10c7f416996ab95a4f..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/slowness_01.cc
--- 2/tests/petsc/slowness_01.cc
+++ /dev/null
@@@ -1,149 -1,149 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// 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("slowness_01/output");
 -  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 46c03176cf747ccf02a3394824ff989a5ee07170,9611d27990e59c1652a3ad9d930b0fe3bb430fa8..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/slowness_02.cc
--- 2/tests/petsc/slowness_02.cc
+++ /dev/null
@@@ -1,120 -1,120 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// 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("slowness_02/output");
 -  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 5b75dd31320dc8dce5909f42309af4b5abb5a5c3,d004153eb070c290660a6a12c9bec749b6ace608..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/slowness_03.cc
--- 2/tests/petsc/slowness_03.cc
+++ /dev/null
@@@ -1,123 -1,123 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// 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("slowness_03/output");
 -  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 d5e0e3cd0c9cfbe4c452e6dc52cf054de720cdaf,221ff387144049e392a972b7836b4bd14d9f5ff8..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/slowness_04.cc
--- 2/tests/petsc/slowness_04.cc
+++ /dev/null
@@@ -1,154 -1,154 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// 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("slowness_04/output");
 -  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_03_precondition_boomeramg.cc
index 62f679ede7e3547f074a9a41f9383b89e5e622a3,8c452a78b1f31d8bfd6eeafbac5747b34c61e0eb..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/solver_03_precondition_boomeramg.cc
--- 2/tests/petsc/solver_03_precondition_boomeramg.cc
+++ /dev/null
@@@ -1,95 -1,95 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("solver_03_precondition_boomeramg/output");
 -  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 709f3e837d2293e4ad498283aa08d4fffbfdcb99,73a442f1a55924dfe892ce58d59c23ce6f9bb499..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/solver_03_precondition_boomeramg_symmetric.cc
--- 2/tests/petsc/solver_03_precondition_boomeramg_symmetric.cc
+++ /dev/null
@@@ -1,96 -1,96 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("solver_03_precondition_boomeramg_symmetric/output");
 -  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 03e98e0ad41e057bcafb2155b0c72ddce781e25e,6551a25c05d1343141bafcafd43e7889c812a06e..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/solver_03_precondition_eisenstat.cc
--- 2/tests/petsc/solver_03_precondition_eisenstat.cc
+++ /dev/null
@@@ -1,94 -1,94 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("solver_03_precondition_eisenstat/output");
 -  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 c5916bc3afccfe8160a3530262708838f7b7bd24,6849d749796329577bc72e04a15066919b0640b9..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/solver_03_precondition_icc.cc
--- 2/tests/petsc/solver_03_precondition_icc.cc
+++ /dev/null
@@@ -1,94 -1,94 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("solver_03_precondition_icc/output");
 -  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 53edb1a149dd37ad223c8d0adcd8202844a117a8,faad508f0ac0f1c47896701acb8d204f6f0111b0..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/solver_03_precondition_ilu.cc
--- 2/tests/petsc/solver_03_precondition_ilu.cc
+++ /dev/null
@@@ -1,94 -1,94 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("solver_03_precondition_ilu/output");
 -  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 f0fafbb3b36fa86cb6684ff94a54d9ea5f5d34a9,beabcf434abae689b25e36a8d33c4eddfa324d62..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/solver_03_precondition_lu.cc
--- 2/tests/petsc/solver_03_precondition_lu.cc
+++ /dev/null
@@@ -1,101 -1,101 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("solver_03_precondition_lu/output");
 -  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 2bc0ad648c5a7d3d3e66efb99efdea9dfef2429c,05ffee26f7e076cf7688856038dbb5cafc9dd6ff..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/solver_03_precondition_parasails.cc
--- 2/tests/petsc/solver_03_precondition_parasails.cc
+++ /dev/null
@@@ -1,94 -1,94 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("solver_03_precondition_parasails/output");
 -  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 c2e0b8b9843f67d6d0f144ee81a2fb9e8e8e22c0,f0700eebc51cde7973ccf66849d630f035a27993..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/solver_03_precondition_sor.cc
--- 2/tests/petsc/solver_03_precondition_sor.cc
+++ /dev/null
@@@ -1,94 -1,94 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("solver_03_precondition_sor/output");
 -  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 59f7be8880516b72d590365a8931143d51329962,67fd339d47eba2d62db1b24bab75107e5d646b3b..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/solver_03_precondition_ssor.cc
--- 2/tests/petsc/solver_03_precondition_ssor.cc
+++ /dev/null
@@@ -1,94 -1,94 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("solver_03_precondition_ssor/output");
 -  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_05.cc
index 591d86af172c3c8f1d5af9119619aed17048a8fa,15f6466e8cdb666e673cbefa4ba3b567b27f0f60..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/solver_05.cc
--- 2/tests/petsc/solver_05.cc
+++ /dev/null
@@@ -1,94 -1,94 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("solver_05/output");
 -  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 df97600cc7c53d525a3fa30b4ffc998af6028725,e19bddaf0c37f758ab55db3e83253a87c11296cd..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/solver_06.cc
--- 2/tests/petsc/solver_06.cc
+++ /dev/null
@@@ -1,94 -1,94 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("solver_06/output");
 -  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 007d238ab2e490a0fe227ac3ab2374d033a63980,12d44a6ae2f123a9eb0e798f0d70e8385fd9cb1f..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/solver_07.cc
--- 2/tests/petsc/solver_07.cc
+++ /dev/null
@@@ -1,94 -1,94 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("solver_07/output");
 -  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 8f2c12fa8b1bbfc67eccca964e61afa03be3e502,56b38ef60d7fb64428bc38a24fb160eaa8e5bcf1..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/solver_08.cc
--- 2/tests/petsc/solver_08.cc
+++ /dev/null
@@@ -1,94 -1,94 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("solver_08/output");
 -  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 67ab1e62b49f28f6c264ab633fda31a539e21819,3297bd8fe2176de9dfe39dda041781740a867dd2..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/solver_09.cc
--- 2/tests/petsc/solver_09.cc
+++ /dev/null
@@@ -1,98 -1,98 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("solver_09/output");
 -  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 4fdb4c05c3b220214451b402860ac578bbe272bc,df81e7dbd2487ce565ba76f0349e29d49ae5e9ae..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/solver_10.cc
--- 2/tests/petsc/solver_10.cc
+++ /dev/null
@@@ -1,94 -1,94 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("solver_10/output");
 -  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 c2bc733ad93f134467e1958f8915eb2f667b1826,a7e585eb330d37e5f604f40d08a541644426e4ec..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/solver_11.cc
--- 2/tests/petsc/solver_11.cc
+++ /dev/null
@@@ -1,95 -1,95 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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 (std::exception &e)
 -  catch (dealii::SolverControl::NoConvergence &e)
--    {
-       deallog << e.what() << std::endl;
--      // 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("solver_11/output");
 -  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 6a99ee2ced903a6180cb721e0db1ec396fdbd636,79e44183a90999eddf4c38b125836451639fd5bc..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/solver_12.cc
--- 2/tests/petsc/solver_12.cc
+++ /dev/null
@@@ -1,91 -1,91 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("solver_12/output");
 -  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 449383562682d07d037dad2878954d0dd0bf03cf,b28e88cafe33029c9368797b575133002a2df379..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/solver_13.cc
--- 2/tests/petsc/solver_13.cc
+++ /dev/null
@@@ -1,100 -1,100 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("solver_13/output");
 -  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 d6e6fcb7289df3930c8582a55b64671232303eda,01956e4e02b758617c231d772af1ffc2b92397b3..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/sparse_direct_mumps.cc
--- 2/tests/petsc/sparse_direct_mumps.cc
+++ /dev/null
@@@ -1,98 -1,98 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("sparse_direct_mumps/output");
 -  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 ccb85230d2180079b1e9827f9bdb7e6df27a066a,b070cc721c6db33d764dde56fb1096ee08300fc9..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/sparse_matrix_iterator_01.cc
--- 2/tests/petsc/sparse_matrix_iterator_01.cc
+++ /dev/null
@@@ -1,85 -1,85 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("sparse_matrix_iterator_01/output");
 -  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 89d38a30f5405a9bf46bf7317f64dbecbdabe45a,656249941890cf6a3acfadc6e081ffbaaec9dad0..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/sparse_matrix_vector_01.cc
--- 2/tests/petsc/sparse_matrix_vector_01.cc
+++ /dev/null
@@@ -1,104 -1,104 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("sparse_matrix_vector_01/output");
 -  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 3a5de57a12f9bbfd4fd55a4fe77103380b0ed066,b127bb49eec24d957d03c43ce5a2e0845c453376..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/sparse_matrix_vector_02.cc
--- 2/tests/petsc/sparse_matrix_vector_02.cc
+++ /dev/null
@@@ -1,104 -1,104 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("sparse_matrix_vector_02/output");
 -  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 2fd2fb4f8574ccd6a3c65e429d23fe26d1a13d5e,667d48d3c3b3846b09b40c2deadf5cd1e83d81b1..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/sparse_matrix_vector_03.cc
--- 2/tests/petsc/sparse_matrix_vector_03.cc
+++ /dev/null
@@@ -1,107 -1,107 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("sparse_matrix_vector_03/output");
 -  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 2f8dd26a35063b5a1c190d5737cd016880d83db1,59011500306eb73a2b046e8b7934817fc209bf1b..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/sparse_matrix_vector_06.cc
--- 2/tests/petsc/sparse_matrix_vector_06.cc
+++ /dev/null
@@@ -1,101 -1,101 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("sparse_matrix_vector_06/output");
 -  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/vector_equality_3.cc
index 05e740b506a2f1e549c505b9c5d226aa065f79d2,411a7e65fa24e673578a5d1a0988ddf4a17598ba..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/vector_equality_3.cc
--- 2/tests/petsc/vector_equality_3.cc
+++ /dev/null
@@@ -1,89 -1,89 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("vector_equality_3/output");
 -  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 41368c64507ccc3babdad1c3cd318c3019b90c74,37d777356fd12ad54967f395a1c16f28edeeb7d8..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/tests/petsc/vector_equality_4.cc
--- 2/tests/petsc/vector_equality_4.cc
+++ /dev/null
@@@ -1,91 -1,91 +1,0 @@@
--// ---------------------------------------------------------------------
--// $Id$
--//
--// Copyright (C) 2004 - 2013 by the deal.II authors
--//
--// This file is part of the deal.II library.
--//
--// The deal.II library is free software; you can use it, redistribute
--// it, and/or modify it under the terms of the GNU Lesser General
--// Public License as published by the Free Software Foundation; either
--// version 2.1 of the License, or (at your option) any 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("vector_equality_4/output");
 -  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_complex/00.cc
index 26253d5c850b537496ed70dbdc803106ba8f82dc,0000000000000000000000000000000000000000..26253d5c850b537496ed70dbdc803106ba8f82dc
mode 100644,000000..100644
--- 1/tests/petsc_scalar_complex/00.cc
--- /dev/null
+++ b/tests/petsc_complex/00.cc

diff --cc tests/petsc_complex/00.output
index 8fc890b1ae75786c24ac78025af907d07a6798d9,0000000000000000000000000000000000000000..8fc890b1ae75786c24ac78025af907d07a6798d9
mode 100644,000000..100644
--- 1/tests/petsc_scalar_complex/00/cmp/generic
--- /dev/null
+++ b/tests/petsc_complex/00.output

diff --cc tests/petsc_complex/01.cc
Simple merge

diff --cc tests/petsc_complex/01.output
index d2ebc395354403d9198704387063b51933b6c8f6,0000000000000000000000000000000000000000..d2ebc395354403d9198704387063b51933b6c8f6
mode 100644,000000..100644
--- 1/tests/petsc_scalar_complex/01/cmp/generic
--- /dev/null
+++ b/tests/petsc_complex/01.output

diff --cc tests/petsc_complex/02.cc
Simple merge

diff --cc tests/petsc_complex/02.output
index d2ebc395354403d9198704387063b51933b6c8f6,0000000000000000000000000000000000000000..d2ebc395354403d9198704387063b51933b6c8f6
mode 100644,000000..100644
--- 1/tests/petsc_scalar_complex/01/cmp/generic
--- /dev/null
+++ b/tests/petsc_complex/02.output

diff --cc tests/petsc_complex/04.cc
Simple merge

diff --cc tests/petsc_complex/04.output
Simple merge

diff --cc tests/petsc_complex/05.cc
Simple merge

diff --cc tests/petsc_complex/05.output
index 8d69c4efd89becb7cf12243c478a166df9cafed1,0000000000000000000000000000000000000000..8d69c4efd89becb7cf12243c478a166df9cafed1
mode 100644,000000..100644
--- 1/tests/petsc_scalar_complex/05/cmp/generic
--- /dev/null
+++ b/tests/petsc_complex/05.output

diff --cc tests/petsc_complex/06.cc
Simple merge

diff --cc tests/petsc_complex/06.output
index e183811702e266a730b52040f08b0803ff696111,0000000000000000000000000000000000000000..e183811702e266a730b52040f08b0803ff696111
mode 100644,000000..100644
--- 1/tests/petsc_scalar_complex/06/cmp/generic
--- /dev/null
+++ b/tests/petsc_complex/06.output

diff --cc tests/petsc_complex/07.cc
Simple merge

diff --cc tests/petsc_complex/07.output
index 3f88f563768e6ffd133b276d50aaea4e31f86a7b,0000000000000000000000000000000000000000..3f88f563768e6ffd133b276d50aaea4e31f86a7b
mode 100644,000000..100644
--- 1/tests/petsc_scalar_complex/07/cmp/generic
--- /dev/null
+++ b/tests/petsc_complex/07.output

diff --cc tests/petsc_complex/08.cc
Simple merge

diff --cc tests/petsc_complex/08.output
index 35c2568f44c0b65e6f60f80cfbb35b73b2798fc2,0000000000000000000000000000000000000000..35c2568f44c0b65e6f60f80cfbb35b73b2798fc2
mode 100644,000000..100644
--- 1/tests/petsc_scalar_complex/08/cmp/generic
--- /dev/null
+++ b/tests/petsc_complex/08.output

diff --cc tests/petsc_complex/09.cc
Simple merge

diff --cc tests/petsc_complex/09.output
index d2ebc395354403d9198704387063b51933b6c8f6,0000000000000000000000000000000000000000..d2ebc395354403d9198704387063b51933b6c8f6
mode 100644,000000..100644
--- 1/tests/petsc_scalar_complex/01/cmp/generic
--- /dev/null
+++ b/tests/petsc_complex/09.output

diff --cc tests/petsc_complex/10.cc
Simple merge

diff --cc tests/petsc_complex/10.output
index d2ebc395354403d9198704387063b51933b6c8f6,0000000000000000000000000000000000000000..d2ebc395354403d9198704387063b51933b6c8f6
mode 100644,000000..100644
--- 1/tests/petsc_scalar_complex/01/cmp/generic
--- /dev/null
+++ b/tests/petsc_complex/10.output

diff --cc tests/petsc_complex/11.cc
Simple merge

diff --cc tests/petsc_complex/11.output
index d2ebc395354403d9198704387063b51933b6c8f6,0000000000000000000000000000000000000000..d2ebc395354403d9198704387063b51933b6c8f6
mode 100644,000000..100644
--- 1/tests/petsc_scalar_complex/01/cmp/generic
--- /dev/null
+++ b/tests/petsc_complex/11.output

diff --cc tests/petsc_complex/12.cc
index bac771e974e5997926e442f278488c681fb2c67d,0000000000000000000000000000000000000000..bac771e974e5997926e442f278488c681fb2c67d
mode 100644,000000..100644
--- 1/tests/petsc_scalar_complex/12.cc
--- /dev/null
+++ b/tests/petsc_complex/12.cc

diff --cc tests/petsc_complex/12.output
index d2ebc395354403d9198704387063b51933b6c8f6,0000000000000000000000000000000000000000..d2ebc395354403d9198704387063b51933b6c8f6
mode 100644,000000..100644
--- 1/tests/petsc_scalar_complex/01/cmp/generic
--- /dev/null
+++ b/tests/petsc_complex/12.output

diff --cc tests/petsc_complex/13.cc
Simple merge

diff --cc tests/petsc_complex/13.output
Simple merge

diff --cc tests/petsc_complex/17.cc
Simple merge

diff --cc tests/petsc_complex/17.output
Simple merge

diff --cc tests/petsc_complex/18.cc
Simple merge

diff --cc tests/petsc_complex/18.output
Simple merge

diff --cc tests/petsc_complex/19.cc
Simple merge

diff --cc tests/petsc_complex/19.output
Simple merge

diff --cc tests/petsc_complex/CMakeLists.txt
index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..dcca0f909d08a637d1659abc4276b9c3dd482716
new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/tests/petsc_complex/CMakeLists.txt
@@@ -1,0 -1,0 +1,1 @@@
++ADD_CUSTOM_TARGET(foobar)

diff --cc tests/petsc_complex/Makefile
index 3dc8d027c42b014c4afbf0236f5af67f4a9320bd,0000000000000000000000000000000000000000..3dc8d027c42b014c4afbf0236f5af67f4a9320bd
mode 100644,000000..100644
--- 1/tests/a-framework/Makefile
--- /dev/null
+++ b/tests/petsc_complex/Makefile

diff --cc tests/petsc_complex/README
index a8db28d288f201303e57c3e3ba5b42e3361dcfd0,0000000000000000000000000000000000000000..a8db28d288f201303e57c3e3ba5b42e3361dcfd0
mode 100644,000000..100644
--- 1/tests/petsc_scalar_complex/README
--- /dev/null
+++ b/tests/petsc_complex/README

diff --cc tests/petsc_complex/element_access_00.cc
Simple merge

diff --cc tests/petsc_complex/element_access_00.output
index 60ff416e00ecd0061e32e5af474ef193aa8e768e,0000000000000000000000000000000000000000..60ff416e00ecd0061e32e5af474ef193aa8e768e
mode 100644,000000..100644
--- 1/tests/petsc_scalar_complex/element_access_00/cmp/generic
--- /dev/null
+++ b/tests/petsc_complex/element_access_00.output

diff --cc tests/petsc_complex/element_access_01.cc
Simple merge

diff --cc tests/petsc_complex/element_access_01.output
index faa08188011b0128379f96bb6b9397c1c306b181,0000000000000000000000000000000000000000..faa08188011b0128379f96bb6b9397c1c306b181
mode 100644,000000..100644
--- 1/tests/petsc_scalar_complex/element_access_01/cmp/generic
--- /dev/null
+++ b/tests/petsc_complex/element_access_01.output

diff --cc tests/petsc_complex/element_access_02.cc
index 89e1210aff0eed8c41208f5c76758b20242d3581,0000000000000000000000000000000000000000..89e1210aff0eed8c41208f5c76758b20242d3581
mode 100644,000000..100644
--- 1/tests/petsc_scalar_complex/element_access_02.cc
--- /dev/null
+++ b/tests/petsc_complex/element_access_02.cc

diff --cc tests/petsc_complex/element_access_02.output
index 8681f0457f83b7097d9473ca3f212bea9bd8a99b,0000000000000000000000000000000000000000..8681f0457f83b7097d9473ca3f212bea9bd8a99b
mode 100644,000000..100644
--- 1/tests/petsc_scalar_complex/element_access_02/cmp/generic
--- /dev/null
+++ b/tests/petsc_complex/element_access_02.output

diff --cc tests/petsc_complex/element_access_03.cc
Simple merge

diff --cc tests/petsc_complex/element_access_03.output
index 2195d3d620e7828a4c7ab4366666e78cb787fab3,0000000000000000000000000000000000000000..2195d3d620e7828a4c7ab4366666e78cb787fab3
mode 100644,000000..100644
--- 1/tests/petsc_scalar_complex/element_access_03/cmp/generic
--- /dev/null
+++ b/tests/petsc_complex/element_access_03.output

diff --cc tests/petsc_complex/solver_real_01.cc
Simple merge

diff --cc tests/petsc_complex/solver_real_01.output
Simple merge

diff --cc tests/petsc_complex/solver_real_02.cc
Simple merge

diff --cc tests/petsc_complex/solver_real_02.output
Simple merge

diff --cc tests/petsc_complex/solver_real_03.cc
Simple merge

diff --cc tests/petsc_complex/solver_real_03.output
Simple merge

diff --cc tests/petsc_complex/solver_real_03_mf.cc
Simple merge

diff --cc tests/petsc_complex/solver_real_03_mf.output
Simple merge

diff --cc tests/petsc_complex/solver_real_04.cc
Simple merge

diff --cc tests/petsc_complex/solver_real_04.output
Simple merge

diff --cc tests/petsc_complex/sparse_matrix_01.cc
Simple merge

diff --cc tests/petsc_complex/sparse_matrix_01.output
index 0fac50fa1c8344a19b06b91548624833097e8530,0000000000000000000000000000000000000000..0fac50fa1c8344a19b06b91548624833097e8530
mode 100644,000000..100644
--- 1/tests/petsc_scalar_complex/sparse_matrix_01/cmp/generic
--- /dev/null
+++ b/tests/petsc_complex/sparse_matrix_01.output

diff --cc tests/petsc_complex/sparse_matrix_02.cc
index 1efa9745ccbd96df30dfd3abdd8cfdbf9c40069b,0000000000000000000000000000000000000000..1efa9745ccbd96df30dfd3abdd8cfdbf9c40069b
mode 100644,000000..100644
--- 1/tests/petsc_scalar_complex/sparse_matrix_02.cc
--- /dev/null
+++ b/tests/petsc_complex/sparse_matrix_02.cc

diff --cc tests/petsc_complex/sparse_matrix_02.output
index 53836596d054c398e709b451911580f543986ce9,0000000000000000000000000000000000000000..53836596d054c398e709b451911580f543986ce9
mode 100644,000000..100644
--- 1/tests/petsc_scalar_complex/sparse_matrix_02/cmp/generic
--- /dev/null
+++ b/tests/petsc_complex/sparse_matrix_02.output

diff --cc tests/petsc_complex/vector_02.cc
index 474a58f5b292779eb853f55f4685ddbd185b5758,0000000000000000000000000000000000000000..474a58f5b292779eb853f55f4685ddbd185b5758
mode 100644,000000..100644
--- 1/tests/petsc_scalar_complex/vector_02.cc
--- /dev/null
+++ b/tests/petsc_complex/vector_02.cc

diff --cc tests/petsc_complex/vector_02.output
index d20636e80bd1e8b6bbb4e3c068f25618e581f5e3,0000000000000000000000000000000000000000..d20636e80bd1e8b6bbb4e3c068f25618e581f5e3
mode 100644,000000..100644
--- 1/tests/petsc_scalar_complex/vector_02/cmp/generic
--- /dev/null
+++ b/tests/petsc_complex/vector_02.output

diff --cc tests/petsc_complex/vector_assign_01.cc
Simple merge

diff --cc tests/petsc_complex/vector_assign_01.output
Simple merge

diff --cc tests/petsc_complex/vector_assign_02.cc
Simple merge

diff --cc tests/petsc_complex/vector_assign_02.output
index 790c6e937102c3be8602a70eb7a7861d796635df,0000000000000000000000000000000000000000..790c6e937102c3be8602a70eb7a7861d796635df
mode 100644,000000..100644
--- 1/tests/petsc_scalar_complex/vector_assign_02/cmp/generic
--- /dev/null
+++ b/tests/petsc_complex/vector_assign_02.output

diff --cc tests/petsc_complex/vector_equality_1.cc
Simple merge

diff --cc tests/petsc_complex/vector_equality_1.output
index 8b5a3a1343ac82e1a230bffaec44f1431964310c,0000000000000000000000000000000000000000..8b5a3a1343ac82e1a230bffaec44f1431964310c
mode 100644,000000..100644
--- 1/tests/petsc_scalar_complex/vector_equality_1/cmp/generic
--- /dev/null
+++ b/tests/petsc_complex/vector_equality_1.output

diff --cc tests/petsc_complex/vector_equality_2.cc
Simple merge

diff --cc tests/petsc_complex/vector_equality_2.output
index fe71e404f7a6390e5459ead47eb8d397dde657f9,0000000000000000000000000000000000000000..fe71e404f7a6390e5459ead47eb8d397dde657f9
mode 100644,000000..100644
--- 1/tests/petsc_scalar_complex/vector_equality_2/cmp/generic
--- /dev/null
+++ b/tests/petsc_complex/vector_equality_2.output

diff --cc tests/petsc_complex/vector_equality_5.cc
Simple merge

diff --cc tests/petsc_complex/vector_equality_5.output
index d2ebc395354403d9198704387063b51933b6c8f6,0000000000000000000000000000000000000000..d2ebc395354403d9198704387063b51933b6c8f6
mode 100644,000000..100644
--- 1/tests/petsc_scalar_complex/01/cmp/generic
--- /dev/null
+++ b/tests/petsc_complex/vector_equality_5.output

diff --cc tests/petsc_complex/vector_print.cc
Simple merge

diff --cc tests/petsc_complex/vector_print.output
index cdcb15a691f40c20fdb6eae06052a963651ba2e5,0000000000000000000000000000000000000000..cdcb15a691f40c20fdb6eae06052a963651ba2e5
mode 100644,000000..100644
--- 1/tests/petsc_scalar_complex/vector_print/cmp/generic
--- /dev/null
+++ b/tests/petsc_complex/vector_print.output

diff --cc tests/petsc_complex/vector_wrap_01.cc
Simple merge

diff --cc tests/petsc_complex/vector_wrap_01.output
Simple merge

diff --cc tests/slepc_complex/00.cc
Simple merge

diff --cc tests/slepc_complex/00.output
index 10a07daa2765fedd4252fbac9719dcf4b0439fa4,0000000000000000000000000000000000000000..10a07daa2765fedd4252fbac9719dcf4b0439fa4
mode 100644,000000..100644
--- 1/tests/slepc_scalar_complex/00/cmp/generic
--- /dev/null
+++ b/tests/slepc_complex/00.output

diff --cc tests/slepc_complex/CMakeLists.txt
index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..dcca0f909d08a637d1659abc4276b9c3dd482716
new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/tests/slepc_complex/CMakeLists.txt
@@@ -1,0 -1,0 +1,1 @@@
++ADD_CUSTOM_TARGET(foobar)