]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Rewrite tests that used deprecated PETSc vectors. 4297/head
authorDavid Wells <wellsd2@rpi.edu>
Fri, 21 Apr 2017 19:41:22 +0000 (15:41 -0400)
committerDavid Wells <wellsd2@rpi.edu>
Mon, 1 May 2017 14:25:46 +0000 (10:25 -0400)
PETScWrappers::Vector and PETScWrappers::BlockVector were deprecated in
favor of PETScWrappers::MPI::Vector and PETScWrappers::MPI::BlockVector.

This involves removing all of the PETScWrappers::BlockMatrix tests,
since that class takes one of the deprecated vectors as an argument.

151 files changed:
tests/distributed_grids/solution_transfer_01.cc
tests/distributed_grids/solution_transfer_02.cc
tests/distributed_grids/solution_transfer_03.cc
tests/distributed_grids/solution_transfer_04.cc
tests/lac/linear_operator_09.cc
tests/lac/linear_operator_09.with_cxx11=on.with_petsc=on.output
tests/lac/linear_operator_09.with_cxx11=on.with_petsc=on.with_mpi=true.mpirun=2.output
tests/lac/linear_operator_09.with_cxx11=on.with_petsc=on.with_mpi=true.mpirun=4.output
tests/lac/vector_reinit_03.cc
tests/lac/vector_type_traits_is_serial_03.cc
tests/lac/vector_type_traits_is_serial_03.with_petsc=true.with_mpi=true.output
tests/mpi/fe_tools_extrapolate_02.cc
tests/mpi/interpolate_02.cc
tests/mpi/petsc_03.cc
tests/mpi/petsc_bug_ghost_vector_01.cc
tests/petsc/11.cc
tests/petsc/12.cc
tests/petsc/13.cc
tests/petsc/17.cc
tests/petsc/18.cc
tests/petsc/19.cc
tests/petsc/20.cc
tests/petsc/21.cc
tests/petsc/22.cc
tests/petsc/23.cc
tests/petsc/24.cc
tests/petsc/26.cc
tests/petsc/27.cc
tests/petsc/28.cc
tests/petsc/29.cc
tests/petsc/30.cc
tests/petsc/31.cc
tests/petsc/32.cc
tests/petsc/33.cc
tests/petsc/34.cc
tests/petsc/35.cc
tests/petsc/36.cc
tests/petsc/37.cc
tests/petsc/38.cc
tests/petsc/39.cc
tests/petsc/40.cc
tests/petsc/41.cc
tests/petsc/42.cc
tests/petsc/43.cc
tests/petsc/44.cc
tests/petsc/45.cc
tests/petsc/46.cc
tests/petsc/47.cc
tests/petsc/48.cc
tests/petsc/49.cc
tests/petsc/50.cc
tests/petsc/51.cc
tests/petsc/55.cc
tests/petsc/56.cc
tests/petsc/57.cc
tests/petsc/58.cc
tests/petsc/59.cc
tests/petsc/60.cc
tests/petsc/61.cc
tests/petsc/70.cc
tests/petsc/block_vector_iterator_01.cc
tests/petsc/block_vector_iterator_02.cc
tests/petsc/block_vector_iterator_03.cc
tests/petsc/block_vector_iterator_03.output
tests/petsc/deal_solver_01.cc
tests/petsc/deal_solver_01.output
tests/petsc/deal_solver_02.cc
tests/petsc/deal_solver_02.output
tests/petsc/deal_solver_03.cc
tests/petsc/deal_solver_03.output
tests/petsc/deal_solver_04.cc
tests/petsc/deal_solver_04.output
tests/petsc/deal_solver_05.cc
tests/petsc/deal_solver_05.output
tests/petsc/full_matrix_vector_01.cc
tests/petsc/full_matrix_vector_02.cc
tests/petsc/full_matrix_vector_03.cc
tests/petsc/full_matrix_vector_04.cc
tests/petsc/full_matrix_vector_05.cc
tests/petsc/full_matrix_vector_06.cc
tests/petsc/full_matrix_vector_07.cc
tests/petsc/reinit_preconditioner_02.cc
tests/petsc/reinit_preconditioner_02.with_mpi=true.output
tests/petsc/slowness_02.cc
tests/petsc/solver_01.cc
tests/petsc/solver_02.cc
tests/petsc/solver_03.cc
tests/petsc/solver_03_mf.cc
tests/petsc/solver_03_precondition_boomeramg.cc
tests/petsc/solver_03_precondition_boomeramg_symmetric.cc
tests/petsc/solver_03_precondition_eisenstat.cc
tests/petsc/solver_03_precondition_icc.cc
tests/petsc/solver_03_precondition_ilu.cc
tests/petsc/solver_03_precondition_lu.cc
tests/petsc/solver_03_precondition_parasails.cc
tests/petsc/solver_03_precondition_sor.cc
tests/petsc/solver_03_precondition_ssor.cc
tests/petsc/solver_04.cc
tests/petsc/solver_05.cc
tests/petsc/solver_06.cc
tests/petsc/solver_07.cc
tests/petsc/solver_08.cc
tests/petsc/solver_09.cc
tests/petsc/solver_10.cc
tests/petsc/solver_11.cc
tests/petsc/solver_12.cc
tests/petsc/solver_13.cc
tests/petsc/sparse_direct_mumps.cc
tests/petsc/sparse_matrix_01.cc
tests/petsc/sparse_matrix_02.cc
tests/petsc/sparse_matrix_vector_01.cc
tests/petsc/sparse_matrix_vector_02.cc
tests/petsc/sparse_matrix_vector_03.cc
tests/petsc/sparse_matrix_vector_04.cc
tests/petsc/sparse_matrix_vector_05.cc
tests/petsc/sparse_matrix_vector_06.cc
tests/petsc/sparse_matrix_vector_07.cc
tests/petsc/vector_assign_01.cc
tests/petsc/vector_assign_02.cc
tests/petsc/vector_equality_1.cc
tests/petsc/vector_equality_2.cc
tests/petsc/vector_equality_3.cc
tests/petsc/vector_equality_4.cc
tests/petsc/vector_print.cc
tests/petsc/vector_print.output
tests/petsc/vector_wrap_01.cc
tests/petsc_complex/11.cc
tests/petsc_complex/12.cc
tests/petsc_complex/13.cc
tests/petsc_complex/17.cc
tests/petsc_complex/18.cc
tests/petsc_complex/19.cc
tests/petsc_complex/20.cc
tests/petsc_complex/element_access_00.cc
tests/petsc_complex/solver_real_01.cc
tests/petsc_complex/solver_real_02.cc
tests/petsc_complex/solver_real_03.cc
tests/petsc_complex/solver_real_03_mf.cc
tests/petsc_complex/solver_real_04.cc
tests/petsc_complex/sparse_matrix_01.cc
tests/petsc_complex/vector_02.cc
tests/petsc_complex/vector_assign_01.cc
tests/petsc_complex/vector_assign_02.cc
tests/petsc_complex/vector_equality_1.cc
tests/petsc_complex/vector_equality_2.cc
tests/petsc_complex/vector_print.cc
tests/petsc_complex/vector_wrap_01.cc
tests/quick_tests/step-petsc.cc
tests/quick_tests/step-slepc.cc
tests/slepc/solve_01.cc
tests/slepc/solve_04.cc

index ce5348978c33d1efc14c4be698e204f25707f3a4..53958b9a6b766e7b1c609afdf8f22aed91bfca40 100644 (file)
@@ -31,7 +31,6 @@
 #include <deal.II/grid/grid_in.h>
 #include <deal.II/grid/intergrid_map.h>
 
-#include <deal.II/lac/petsc_vector.h>
 #include <deal.II/fe/fe_q.h>
 
 #include <fstream>
index 850525812ee7e61fd06f18ee8cf7d4f46c92406f..dcaef9d4dbf8807f75a608729da9f160a147f592 100644 (file)
@@ -31,7 +31,6 @@
 #include <deal.II/grid/grid_in.h>
 #include <deal.II/grid/intergrid_map.h>
 
-#include <deal.II/lac/petsc_vector.h>
 #include <deal.II/fe/fe_q.h>
 
 #include <deal.II/numerics/vector_tools.h>
index 921b6f8d0c4a9ec774b7ffb4914eef8bb8a854b2..36d211b5a5f84977c8164c45cb4e54f25643956f 100644 (file)
@@ -31,7 +31,6 @@
 #include <deal.II/grid/grid_in.h>
 #include <deal.II/grid/intergrid_map.h>
 
-#include <deal.II/lac/petsc_vector.h>
 #include <deal.II/fe/fe_q.h>
 
 #include <deal.II/numerics/vector_tools.h>
index 57ea37813080c9b087f5b59fb3352a10f4375192..3b5c2ccfaf3022564b6d710781f2746b0afffbf1 100644 (file)
@@ -31,7 +31,6 @@
 #include <deal.II/grid/grid_in.h>
 #include <deal.II/grid/intergrid_map.h>
 
-#include <deal.II/lac/petsc_vector.h>
 #include <deal.II/fe/fe_q.h>
 
 #include <fstream>
index e1d80fea5288cc0a13b40ca02ca94216a192c651..f9b5185c51f0829d00fd641a594b3f7eea6ab6c0 100644 (file)
 #include <deal.II/lac/linear_operator.h>
 
 // Vectors:
-#include <deal.II/lac/petsc_vector.h>
 #include <deal.II/lac/petsc_sparse_matrix.h>
 
 #include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/petsc_parallel_sparse_matrix.h>
 
 // Block Matrix and Vectors:
-#include <deal.II/lac/petsc_block_vector.h>
-#include <deal.II/lac/petsc_block_sparse_matrix.h>
-
 #include <deal.II/lac/petsc_parallel_block_vector.h>
 #include <deal.II/lac/petsc_parallel_block_sparse_matrix.h>
 
@@ -48,22 +44,6 @@ int main(int argc, char *argv[])
   initlog();
   deallog << std::setprecision(10);
 
-  {
-    PETScWrappers::SparseMatrix a(2,2,2);
-    for (unsigned int i = 0; i<2; ++i)
-      for (unsigned int j = 0; j<2; ++j)
-        a.add (i,j, 2);
-    a.compress (VectorOperation::add);
-
-    PETScWrappers::Vector v(2);
-    for (unsigned int i = 0; i<2; ++i)
-      v[i] = 1;
-    PETScWrappers::Vector u(v);
-    auto op_a  = linear_operator<PETScWrappers::Vector>(a);
-    op_a.vmult(u,v);
-    deallog << "SparseMatrix -> OK" << std::endl;
-  }
-
   {
     unsigned int np = Utilities::MPI::n_mpi_processes(MPI_COMM_WORLD);
     if (4%np==0 && np<=4)
@@ -86,12 +66,6 @@ int main(int argc, char *argv[])
     deallog << "SparseMatrix MPI -> OK" << std::endl;
   }
 
-  {
-    PETScWrappers::BlockSparseMatrix a;
-    auto op_a  = linear_operator<PETScWrappers::BlockVector>(a);
-    deallog << "BlockSparseMatrix -> OK" << std::endl;
-  }
-
   {
     PETScWrappers::MPI::BlockSparseMatrix a;
     auto op_a  = linear_operator<PETScWrappers::MPI::BlockVector>(a);
@@ -102,5 +76,3 @@ int main(int argc, char *argv[])
 
   return 0;
 }
-
-
index 441b883d6968e632eead022fd107d7e3942b151a..08d81f52f2af51552fe04b4d6e6e01a46f84df5b 100644 (file)
@@ -1,6 +1,4 @@
 
-DEAL::SparseMatrix -> OK
 DEAL::SparseMatrix MPI -> OK
-DEAL::BlockSparseMatrix -> OK
 DEAL::BlockSparseMatrix MPI -> OK
 DEAL::OK
index 441b883d6968e632eead022fd107d7e3942b151a..08d81f52f2af51552fe04b4d6e6e01a46f84df5b 100644 (file)
@@ -1,6 +1,4 @@
 
-DEAL::SparseMatrix -> OK
 DEAL::SparseMatrix MPI -> OK
-DEAL::BlockSparseMatrix -> OK
 DEAL::BlockSparseMatrix MPI -> OK
 DEAL::OK
index 441b883d6968e632eead022fd107d7e3942b151a..08d81f52f2af51552fe04b4d6e6e01a46f84df5b 100644 (file)
@@ -1,6 +1,4 @@
 
-DEAL::SparseMatrix -> OK
 DEAL::SparseMatrix MPI -> OK
-DEAL::BlockSparseMatrix -> OK
 DEAL::BlockSparseMatrix MPI -> OK
 DEAL::OK
index aa4bf8efe3c602fce172a847e4067113c17ed3a7..207894592da7202f8916f0507f06f0431f19ab2a 100644 (file)
@@ -21,7 +21,6 @@
 
 #include "../tests.h"
 #include <deal.II/base/mpi.h>
-#include <deal.II/lac/petsc_vector.h>
 #include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/vector_memory.h>
 
index 5b6536a708bf130e7a4e1367f60af52ef1de7c90..704b8d1317d30bd39f86d336ee3611aa29a78980 100644 (file)
@@ -18,8 +18,6 @@
 // check is_serial_vector type trait
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
-#include <deal.II/lac/petsc_block_vector.h>
 #include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/petsc_parallel_block_vector.h>
 #include <fstream>
 
 void test ()
 {
-  // make sure that is_serial_vector< dealii::PETScWrappers::Vector > is working
-  Assert (is_serial_vector< dealii::PETScWrappers::Vector >::value == true,
-          ExcInternalError());
-
-  deallog << is_serial_vector< dealii::PETScWrappers::Vector >::value << std::endl;
-
-  deallog << "OK" << std::endl << std::endl;
-
-  // make sure that is_serial_vector< dealii::PETScWrappers::BlockVector > is working
-  Assert (is_serial_vector< dealii::PETScWrappers::BlockVector >::value == true,
-          ExcInternalError());
-
-  deallog << is_serial_vector< dealii::PETScWrappers::BlockVector >::value << std::endl;
-
-  deallog << "OK" << std::endl << std::endl;
-
   // make sure that is_serial_vector< dealii::PETScWrappers::MPI::Vector > is working
   Assert (is_serial_vector< dealii::PETScWrappers::MPI::Vector >::value == false,
           ExcInternalError());
index dee23be6e70d93cc364f129656dcf3a7441e602e..fcf7cc7bea379ee53e602bd58baf4a119210e0e2 100644 (file)
@@ -1,10 +1,4 @@
 
-DEAL::1
-DEAL::OK
-DEAL::
-DEAL::1
-DEAL::OK
-DEAL::
 DEAL::0
 DEAL::OK
 DEAL::
index 12b64b667b008362b25649ec1643489e33cf2e6d..ca002c45d44a79ff669c6b716efead2061bf0c2e 100644 (file)
@@ -14,7 +14,7 @@
 // ---------------------------------------------------------------------
 
 
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include "fe_tools_extrapolate_common.h"
 
 // check FETools::extrapolate on distributed triangulations
@@ -64,4 +64,3 @@ int main (int argc, char **argv)
   CHECK_ALL(DGQ,1,DGQ,0);
   CHECK_ALL(DGQ,1,DGQ,1);
 }
-
index 271ca061fddf6103d73a2a372b75b9b9ce7e6d07..d97507bd30014dc857cb3b246ca105b240def95a 100644 (file)
@@ -17,8 +17,8 @@
 
 // Like _01 but with PETSc vectors. this program hangs at the time of writing
 // in much the same way solution_transfer_01 does because one processor has no
-// cells and all the others decide that PETScWrappers::Vector::compress is a
-// no-op when of course the one who does have cells doesn't think so
+// cells and all the others decide that PETScWrappers::MPI::Vector::compress
+// is a no-op when of course the one who does have cells doesn't think so
 
 
 #include "../tests.h"
index 138a703a963de158ba28154e246572b723791400..eabe97372dc5c28ea6e917319c1a7da6f54d73fb 100644 (file)
@@ -22,7 +22,6 @@
 
 #include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/petsc_parallel_block_vector.h>
-#include <deal.II/lac/petsc_vector.h>
 #include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/vector_memory.h>
 #include <deal.II/base/logstream.h>
@@ -50,8 +49,6 @@ void test()
 
   testit<PETScWrappers::MPI::Vector>();
   testit<PETScWrappers::MPI::BlockVector>();
-  testit<PETScWrappers::Vector>();
-  testit<PETScWrappers::BlockVector>();
 
   if (myid==0)
     deallog << "done" << std::endl;
index c23a46dcb0d6e6626cd5bb6a0d38cf4a75269b88..80002224d6bf11f227803bfc1351bacab44a51cf 100644 (file)
@@ -63,7 +63,6 @@
 #include <deal.II/lac/constraint_matrix.h>
 #include <deal.II/lac/petsc_precondition.h>
 #include <deal.II/lac/petsc_solver.h>
-#include <deal.II/lac/petsc_vector.h>
 #include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/sparsity_tools.h>
index 9512866d811ce556d681ae4f3eb5b77cde48adc0..0c2cd26880b16e8c2ddc0b2204514c65957d25cb 100644 (file)
 
 
 
-// check PETScWrappers::Vector::size()
+// check PETScWrappers::MPI::Vector::size()
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   // set only certain elements of the vector
   for (unsigned int i=0; i<v.size(); i+=1+i)
@@ -48,8 +48,10 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        test (v);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        test(v);
       }
 
     }
index c52a58959c618426e7263de41878d8e4c3795950..7565aad3d3094efacb33dd3756ffef2cc35cc8ae 100644 (file)
 
 
 
-// check PETScWrappers::Vector::operator() in set-mode
+// check PETScWrappers::MPI::Vector::operator() in set-mode
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   // set only certain elements of the
   // vector. have a bit pattern of where we
@@ -61,8 +61,10 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        test (v);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        test(v);
       }
 
     }
index 8c5e0a163abf54b8a3e06f27113cbe73188428dd..cdde6e90e7d307ecbb9b4dddd3476c4b0368b825 100644 (file)
 
 
 
-// check PETScWrappers::Vector::operator() in add-mode
+// check PETScWrappers::MPI::Vector::operator() in add-mode
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   // set only certain elements of the
   // vector. have a bit pattern of where we
@@ -61,8 +61,10 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        test (v);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        test(v);
       }
 
     }
index e6cc1bd636776c8c7f691896fd929164d64de420..9c922f0ee7c2ae97b5d90f8220afacfe78bc81c4 100644 (file)
 
 
 
-// check PETScWrappers::Vector::l1_norm()
+// check PETScWrappers::MPI::Vector::l1_norm()
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   // set some elements of the vector
   double norm = 0;
@@ -53,7 +53,9 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
         test (v);
       }
 
index ca2931f1127f65e89764d30f54c3a7a8d462d122..f4761fb8a093e701cf34be27cc5c8a65e05aa2a1 100644 (file)
 
 
 
-// check PETScWrappers::Vector::l2_norm()
+// check PETScWrappers::MPI::Vector::l2_norm()
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   // set some elements of the vector
   PetscScalar norm = 0;
@@ -54,7 +54,9 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v (indices, MPI_COMM_WORLD);
         test (v);
       }
 
index a6d9eb5cd6f414ff38ba4b93abde054869a2d8ca..cab88f5e01576643bced3f58018faebae2a9d20d 100644 (file)
 
 
 
-// check PETScWrappers::Vector::linfty_norm()
+// check PETScWrappers::MPI::Vector::linfty_norm()
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   // set some elements of the vector
   double norm = 0;
@@ -53,7 +53,9 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
         test (v);
       }
 
index deb240579e9322d7503b787ad51e0d2d273dc054..d29fe6ac3d580d9740d85b746700f1423a73a2b7 100644 (file)
 
 
 
-// check PETScWrappers::Vector::operator *=
+// check PETScWrappers::MPI::Vector::operator *=
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   // set only certain elements of the
   // vector. have a bit pattern of where we
@@ -62,8 +62,10 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        test (v);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        test(v);
       }
 
     }
index 65c567dda127bb60f44e95eca4ec5284308abc57..4074dc89c64fbb4fbe1fc8f3c14c5347fcc4f2e3 100644 (file)
 
 
 
-// check PETScWrappers::Vector::operator /=
+// check PETScWrappers::MPI::Vector::operator /=
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   // set only certain elements of the
   // vector. have a bit pattern of where we
@@ -62,8 +62,10 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        test (v);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        test(v);
       }
 
     }
index 3073187e048360b29bcc9588bbd005953bf7d8a4..ec8fdbdf33ebfa42d08c41d2e24ece53796fdb3d 100644 (file)
 
 
 
-// check PETScWrappers::Vector::operator*(Vector) on two vectors that are
+// check PETScWrappers::MPI::Vector::operator*(Vector) on two vectors that are
 // orthogonal
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   // set only certain elements of each
   // vector, but disjoint sets of elements
@@ -56,9 +56,11 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        PETScWrappers::Vector w (100);
-        test (v,w);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w(indices, MPI_COMM_WORLD);
+        test(v, w);
       }
 
     }
index efb7ed6ee0562ace932cf8e31a7edbc7c6ca04d3..e294517ad84eed74ddb49d9090d51c3ab1e6af11 100644 (file)
 
 
 
-// check PETScWrappers::Vector::operator*(Vector) on two vectors that are
+// check PETScWrappers::MPI::Vector::operator*(Vector) on two vectors that are
 // not orthogonal
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   // set only certain elements of each
   // vector, and record the expected scalar
@@ -63,9 +63,11 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        PETScWrappers::Vector w (100);
-        test (v,w);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w(indices, MPI_COMM_WORLD);
+        test(v, w);
       }
 
     }
index 323d0b6bc7812604b4fff48c4602a7c74410b71a..7c87402ec48fec326ba7a777a0e0884970efa5a8 100644 (file)
 
 
 
-// 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
+// this test used to check for PETScWrappers::MPI::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 <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   // set some entries of the vector
   for (unsigned int i=0; i<v.size(); ++i)
@@ -56,8 +56,10 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        test (v);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        test(v);
       }
 
     }
index 093abae48ab092f3f73f75d4705c6d9b92cce2c3..cc8e8d07c64ad8b4dd61a6f3f9523928352790ce 100644 (file)
 
 
 
-// check PETScWrappers::Vector::operator = (PetscScalar) with setting to a
+// check PETScWrappers::MPI::Vector::operator = (PetscScalar) with setting to a
 // nonzero value
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   // set some entries of the vector
   for (unsigned int i=0; i<v.size(); ++i)
@@ -53,8 +53,10 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        test (v);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        test(v);
       }
 
     }
index 13f5ebd51bff7cbe0d0677dfd704d14e9ac4c411..75f8b0cfef57bf0ea762a422b94fde97cca7d69a 100644 (file)
 
 
 
-// check PETScWrappers::Vector::operator = (Vector)
+// check PETScWrappers::MPI::Vector::operator = (Vector)
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   // set some entries of the vector
   for (unsigned int i=0; i<v.size(); ++i)
@@ -33,7 +33,7 @@ void test (PETScWrappers::Vector &v)
   v.compress (VectorOperation::insert);
 
   // then copy it
-  PETScWrappers::Vector w (v.size());
+  PETScWrappers::MPI::Vector w (v.locally_owned_elements(), MPI_COMM_WORLD);
   w = v;
 
   // make sure they're equal
@@ -58,8 +58,10 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        test (v);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        test(v);
       }
 
     }
index 323305e188e3c05c057262055e709fb2c16cf389..c6302a8d926137dca8ed8f7b5f2d793f202f3086 100644 (file)
 
 
 
-// check PETScWrappers::Vector::operator = (Vector), except that we don't
+// check PETScWrappers::MPI::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 <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   // set some entries of the vector
   for (unsigned int i=0; i<v.size(); ++i)
@@ -35,7 +35,7 @@ void test (PETScWrappers::Vector &v)
 
   // then copy it to a vector of different
   // size
-  PETScWrappers::Vector w (1);
+  PETScWrappers::MPI::Vector w (MPI_COMM_WORLD, 1, 1);
   w = v;
 
   // make sure they're equal
@@ -60,8 +60,10 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        test (v);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        test(v);
       }
 
     }
index 9d5b3fb91922fb3864fee233139fb1dc55aae8c5..94c7f77e66fd53d169f5ccc47a4f7ed32fa5286d 100644 (file)
 
 
 
-// check PETScWrappers::Vector::reinit(fast)
+// check PETScWrappers::MPI::Vector::reinit(fast)
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
-  v.reinit (13, true);
+  v.reinit (MPI_COMM_WORLD, 13, 13, true);
 
   AssertThrow (v.size() == 13, ExcInternalError());
 
@@ -45,8 +45,10 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        test (v);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        test(v);
       }
 
     }
index 117a224c2c9696dd6b555edb024c252e5d7c6699..10ce6e0df1002ff20fba1fd97f95392a43b57e8f 100644 (file)
 
 
 
-// check PETScWrappers::Vector::reinit(!fast)
+// check PETScWrappers::MPI::Vector::reinit(!fast)
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   // set some entries of the vector
   for (unsigned int i=0; i<v.size(); ++i)
@@ -33,7 +33,7 @@ void test (PETScWrappers::Vector &v)
   v.compress (VectorOperation::insert);
 
   // then resize with setting to zero
-  v.reinit (13, false);
+  v.reinit (MPI_COMM_WORLD, 13, 13, false);
 
   AssertThrow (v.size() == 13, ExcInternalError());
   AssertThrow (v.l2_norm() == 0, ExcInternalError());
@@ -53,8 +53,10 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        test (v);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        test(v);
       }
 
     }
index 34e8bf2579b57f81c45dca1e902b48ede423635f..0bc07d56c3b490f3a8fe5f25d5b1cda2938b1332 100644 (file)
 
 
 
-// check PETScWrappers::Vector::l2_norm()
+// check PETScWrappers::MPI::Vector::l2_norm()
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   // set some elements of the vector
   PetscScalar norm = 0;
@@ -55,8 +55,10 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        test (v);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        test(v);
       }
 
     }
index 7887e08e88a32c9aeafa33111fb55da0b2d65a8e..296f347255973169ec75c43141e9c01b7935cb6d 100644 (file)
 
 
 
-// check PETScWrappers::Vector::mean_value()
+// check PETScWrappers::MPI::Vector::mean_value()
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   // set some elements of the vector
   PetscScalar sum = 0;
@@ -55,8 +55,10 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        test (v);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        test(v);
       }
 
     }
index bbcf9278059ae5d4ca3a26ed02d1928ef03445e2..90e81ae0c81cfbb9f703e546207d10b932dee9bb 100644 (file)
 
 
 
-// check PETScWrappers::Vector::lp_norm(3)
+// check PETScWrappers::MPI::Vector::lp_norm(3)
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   // set some elements of the vector
   PetscScalar sum = 0;
@@ -56,8 +56,10 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        test (v);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        test(v);
       }
 
     }
index 51dacab4f67a5437e0f0a69bed7af497c1f18e63..79f0c1a868734dc8454f7a257428bcb36e058758 100644 (file)
 
 
 
-// check PETScWrappers::Vector::all_zero
+// check PETScWrappers::MPI::Vector::all_zero
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   // set some elements of the vector
   double sum = 0;
@@ -56,8 +56,10 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        test (v);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        test(v);
       }
 
     }
index 1caf99193b8a53a3a97e4c955010d9610e5c0ccd..a50dc8be88e08e4148b055e713fc6c65dcd4b388 100644 (file)
 
 
 
-// check PETScWrappers::Vector::operator+=(Vector)
+// check PETScWrappers::MPI::Vector::operator+=(Vector)
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   // set only certain elements of each
   // vector
@@ -72,9 +72,11 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        PETScWrappers::Vector w (100);
-        test (v,w);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w(indices, MPI_COMM_WORLD);
+        test(v, w);
       }
 
     }
index 67340868947471de41be0f4a062e61d6377c1ff0..93a67ab5967d55be36c7c3390605effb2bafacf6 100644 (file)
 
 
 
-// check PETScWrappers::Vector::operator-=(Vector)
+// check PETScWrappers::MPI::Vector::operator-=(Vector)
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   // set only certain elements of each
   // vector
@@ -72,9 +72,11 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        PETScWrappers::Vector w (100);
-        test (v,w);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w(indices, MPI_COMM_WORLD);
+        test(v, w);
       }
 
     }
index 275f1cf5811b83a8df3cc6b39abb7be14eb23ae4..d5529e48108dc628adba2041af10b365258043d4 100644 (file)
 
 
 
-// check PETScWrappers::Vector::add (scalar)
+// check PETScWrappers::MPI::Vector::add (scalar)
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   for (unsigned int i=0; i<v.size(); ++i)
     v(i) = i;
@@ -52,8 +52,10 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        test (v);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        test(v);
       }
 
     }
index f2dad81f15d829b16a150f8ea1a22204093005fb..acd5d1e071c1f25e90247a8006c01af308244c97 100644 (file)
 
 
 
-// check PETScWrappers::Vector::add(Vector)
+// check PETScWrappers::MPI::Vector::add(Vector)
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   for (unsigned int i=0; i<v.size(); ++i)
     {
@@ -60,9 +60,11 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        PETScWrappers::Vector w (100);
-        test (v,w);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w(indices, MPI_COMM_WORLD);
+        test(v, w);
       }
 
     }
index 62a05a9c1588734f0267e8192a675321cfdaae92..fda36a2992ecdb25b53be1abfb9afa117db7486b 100644 (file)
 
 
 
-// check PETScWrappers::Vector::add(scalar, Vector)
+// check PETScWrappers::MPI::Vector::add(scalar, Vector)
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   for (unsigned int i=0; i<v.size(); ++i)
     {
@@ -60,9 +60,11 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        PETScWrappers::Vector w (100);
-        test (v,w);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w(indices, MPI_COMM_WORLD);
+        test(v, w);
       }
 
     }
index f9fbf991a1e6e7925fc3d1e5d4020f1966d74d16..c65eef6644b526ccbc60a44fce96199f118f029e 100644 (file)
 
 
 
-// check PETScWrappers::Vector::add(s,V,s,V)
+// check PETScWrappers::MPI::Vector::add(s,V,s,V)
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w,
-           PETScWrappers::Vector &x)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w,
+           PETScWrappers::MPI::Vector &x)
 {
   for (unsigned int i=0; i<v.size(); ++i)
     {
@@ -64,10 +64,12 @@ int main (int argc,char **argv)
     {
       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);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w(indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector x(indices, MPI_COMM_WORLD);
+        test(v, w, x);
       }
 
     }
index ef12456f58b5b9cdcc8b9e0c0d099520853ee8d0..73e9329e242505e19a41e0a0735dac53dceb83ac 100644 (file)
 
 
 
-// check PETScWrappers::Vector::sadd(s, Vector)
+// check PETScWrappers::MPI::Vector::sadd(s, Vector)
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   for (unsigned int i=0; i<v.size(); ++i)
     {
@@ -60,9 +60,11 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        PETScWrappers::Vector w (100);
-        test (v,w);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w(indices, MPI_COMM_WORLD);
+        test(v, w);
       }
 
     }
index 3118a998f6ed38041899a4c3a7ec4ed4eb9f2def..966747a129a6fa0bcc76e25635ba03beca6901f6 100644 (file)
 
 
 
-// check PETScWrappers::Vector::sadd(scalar, scalar, Vector)
+// check PETScWrappers::MPI::Vector::sadd(scalar, scalar, Vector)
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   for (unsigned int i=0; i<v.size(); ++i)
     {
@@ -60,9 +60,11 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        PETScWrappers::Vector w (100);
-        test (v,w);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w(indices, MPI_COMM_WORLD);
+        test(v, w);
       }
 
     }
index d0c964b54aa668c068de8380f5aa2a903d004190..620d860f9794f3239ea0e9fe1659d4a0bd39737f 100644 (file)
 
 
 
-// check PETScWrappers::Vector::sadd(s,s,V,s,V)
+// check PETScWrappers::MPI::Vector::sadd(s,s,V,s,V)
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w,
-           PETScWrappers::Vector &x)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w,
+           PETScWrappers::MPI::Vector &x)
 {
   for (unsigned int i=0; i<v.size(); ++i)
     {
@@ -64,10 +64,12 @@ int main (int argc,char **argv)
     {
       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);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w(indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector x(indices, MPI_COMM_WORLD);
+        test(v, w, x);
       }
 
     }
index d05e0bbcd68b846a62e21518a6b036943ef35df5..5cf533ca4dfe8bb2e9fa59c5b91a129b47507c2d 100644 (file)
 
 
 
-// check PETScWrappers::Vector::sadd(s,s,V,s,V,s,V)
+// check PETScWrappers::MPI::Vector::sadd(s,s,V,s,V,s,V)
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w,
-           PETScWrappers::Vector &x,
-           PETScWrappers::Vector &y)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w,
+           PETScWrappers::MPI::Vector &x,
+           PETScWrappers::MPI::Vector &y)
 {
   for (unsigned int i=0; i<v.size(); ++i)
     {
@@ -68,11 +68,13 @@ int main (int argc,char **argv)
     {
       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);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w(indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector x(indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector y(indices, MPI_COMM_WORLD);
+        test(v, w, x, y);
       }
 
     }
index 458a6a7447387ff51198a648e0ec53141ed99319..ccb785a8c344dbe19d32f1db7dadca211a51dfe6 100644 (file)
 
 
 
-// check PETScWrappers::Vector::scale
+// check PETScWrappers::MPI::Vector::scale
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   for (unsigned int i=0; i<v.size(); ++i)
     {
@@ -60,9 +60,11 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        PETScWrappers::Vector w (100);
-        test (v,w);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w(indices, MPI_COMM_WORLD);
+        test(v, w);
       }
 
     }
index eb4f7c23d7f3fcf0fad508bc01131ecf9e1b9b1b..953f69f11c881f26d4cf567c8a2604390853634e 100644 (file)
 
 
 
-// check PETScWrappers::Vector::equ (s,V)
+// check PETScWrappers::MPI::Vector::equ (s,V)
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   for (unsigned int i=0; i<v.size(); ++i)
     {
@@ -60,9 +60,11 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        PETScWrappers::Vector w (100);
-        test (v,w);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w(indices, MPI_COMM_WORLD);
+        test(v, w);
       }
 
     }
index c54c8c44d09da8fcaaff1fb10224dcb22e5e332e..acd43a6b13e22ee7b21241ecb013f0afd9b93976 100644 (file)
 
 
 
-// check PETScWrappers::Vector::equ (s,V,s,V)
+// check PETScWrappers::MPI::Vector::equ (s,V,s,V)
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w,
-           PETScWrappers::Vector &x)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w,
+           PETScWrappers::MPI::Vector &x)
 {
   for (unsigned int i=0; i<v.size(); ++i)
     {
@@ -64,10 +64,12 @@ int main (int argc,char **argv)
     {
       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);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w(indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector x(indices, MPI_COMM_WORLD);
+        test(v, w, x);
       }
 
     }
index 62f23879bc758bf01e222ff0b882c49e984486b5..472e7dc3882c92adb319f9cc138d8c19ff243d52 100644 (file)
 
 
 
-// check PETScWrappers::Vector::ratio
+// check PETScWrappers::MPI::Vector::ratio
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w,
-           PETScWrappers::Vector &x)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w,
+           PETScWrappers::MPI::Vector &x)
 {
   for (unsigned int i=0; i<v.size(); ++i)
     {
@@ -66,10 +66,12 @@ int main (int argc,char **argv)
     {
       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);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w(indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector x(indices, MPI_COMM_WORLD);
+        test(v, w, x);
       }
 
     }
index 0a644dd16e5d3f12b51f922ba86775c47c9054ac..dee8762f4c7d0f18d0771b2b170f70baa3f4a8cb 100644 (file)
 
 
 
-// check PETScWrappers::Vector::operator = (Vector<PetscVector>)
+// check PETScWrappers::MPI::Vector::operator = (Vector<PetscVector>)
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   Vector<PetscScalar> w (v.size());
 
@@ -57,8 +57,10 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        test (v);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        test(v);
       }
 
     }
index a54671276851ae0116ededb7682e0cd9d0b0c0fc..7ff295656876c5c480a1d4be9d4e49f1b4083b89 100644 (file)
 
 
 
-// check PETScWrappers::Vector::operator = (Vector<T>) with T!=PetscScalar
+// check PETScWrappers::MPI::Vector::operator = (Vector<T>) with T!=PetscScalar
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   Vector<double> w (v.size());
   Vector<float>  x (v.size());
@@ -73,8 +73,10 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        test (v);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        test(v);
       }
 
     }
index cb62d3f06f0e774e3107c9188bf2a10b41f0159d..fea6331ad7324e769b925145af0bc55215da5078 100644 (file)
 
 
 
-// check copy constructor PETScWrappers::Vector::Vector(Vector)
+// check copy constructor PETScWrappers::MPI::Vector::Vector(Vector)
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   // set some entries of the vector
   for (unsigned int i=0; i<v.size(); ++i)
@@ -33,7 +33,7 @@ void test (PETScWrappers::Vector &v)
   v.compress (VectorOperation::insert);
 
   // then copy it
-  PETScWrappers::Vector w (v);
+  PETScWrappers::MPI::Vector w (v);
 
   // make sure they're equal
   deallog << v *w << ' ' << v.l2_norm() * w.l2_norm()
@@ -57,8 +57,10 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        test (v);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        test(v);
       }
 
     }
index bdfff1dde992411e97f198ac5473582b06dfb3a6..e02e8ea8ffb35e8fdf1f29c098f7a959e5cfe89b 100644 (file)
 
 
 
-// check PETScWrappers::Vector::operator() in set, and later in *= mode
+// check PETScWrappers::MPI::Vector::operator() in set, and later in *= mode
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   // set only certain elements of the
   // vector. have a bit pattern of where we
@@ -63,8 +63,10 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        test (v);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        test(v);
       }
 
     }
index 5a25b56c2f0a8b2817f754e8792365b039a3a044..22d0806e0826372713d49c28f9b24370c1c14824 100644 (file)
 
 
 
-// check PETScWrappers::Vector::operator() in set, and later in /= mode
+// check PETScWrappers::MPI::Vector::operator() in set, and later in /= mode
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   // set only certain elements of the
   // vector. have a bit pattern of where we
@@ -63,8 +63,10 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        test (v);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        test(v);
       }
 
     }
index 6984580593e4045d1b3be1f5da9739b4680a6e60..81bed3d3aebdb3b8a71662a234c15f16e9e73d14 100644 (file)
 
 
 
-// check PETScWrappers::Vector::is_non_zero
+// check PETScWrappers::MPI::Vector::is_non_zero
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   // set only certain elements of the
   // vector. they are all positive
@@ -61,8 +61,10 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        test (v);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        test(v);
       }
 
     }
index 59d045f26a3d379f88d0f744843c6bff12da1ac0..c1b8a099434118570d52d4ed71b36c1fe28e58a1 100644 (file)
 
 
 
-// check ::Vector (const PETScWrappers::Vector &) copy constructor
+// check ::Vector (const PETScWrappers::MPI::Vector &) copy constructor
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/vector.h>
 
 #include <fstream>
@@ -26,7 +26,7 @@
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   // set only certain elements of the
   // vector.
@@ -63,8 +63,10 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        test (v);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        test(v);
       }
 
     }
index e2f41182410c60456c53f5a5d260dd1fd0f72ea2..551d65c52932d420b54626755ab200f5da4d86ac 100644 (file)
 
 
 
-// check PETScWrappers::Vector (const ::Vector &) copy constructor
+// check PETScWrappers::MPI::Vector (const ::Vector &) copy constructor
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/vector.h>
 
 #include <fstream>
@@ -26,7 +26,7 @@
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   // set only certain elements of the
   // vector.
@@ -42,8 +42,8 @@ void test (PETScWrappers::Vector &v)
   Vector<double> w (v);
   Vector<float>  x (v);
 
-  PETScWrappers::Vector w1 (w);
-  PETScWrappers::Vector x1 (x);
+  PETScWrappers::MPI::Vector w1 (MPI_COMM_WORLD, w, w.size());
+  PETScWrappers::MPI::Vector x1 (MPI_COMM_WORLD, x, w.size());
 
   for (unsigned int i=0; i<v.size(); ++i)
     {
@@ -66,8 +66,10 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        test (v);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        test(v);
       }
 
     }
index f7889d1daaab33c800d8f8595b1c0f7fad1e09bf..84f341d718e17edeb1824dffd3d2ee8fb45c0a4a 100644 (file)
 
 
 
-// check ::Vector::operator = (const PETScWrappers::Vector &)
+// check ::Vector::operator = (const PETScWrappers::MPI::Vector &)
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/vector.h>
 
 #include <fstream>
@@ -26,7 +26,7 @@
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   // set only certain elements of the
   // vector.
@@ -65,8 +65,10 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        test (v);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        test(v);
       }
 
     }
index f0e1f1666206d9d8151fda9614b0d4bacdc50540..879ffabf4a4745129f7f14f27761e4dff9b53658 100644 (file)
 
 
 
-// check PETScWrappers::Vector::operator = (const ::Vector &)
+// check PETScWrappers::MPI::Vector::operator = (const ::Vector &)
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/vector.h>
 
 #include <fstream>
@@ -26,7 +26,7 @@
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   // set only certain elements of the
   // vector.
@@ -44,9 +44,9 @@ void test (PETScWrappers::Vector &v)
   Vector<float>  x;
   x=v;
 
-  PETScWrappers::Vector w1;
+  PETScWrappers::MPI::Vector w1(MPI_COMM_WORLD, v.size(), v.size());
   w1=w;
-  PETScWrappers::Vector x1;
+  PETScWrappers::MPI::Vector x1(MPI_COMM_WORLD, v.size(), v.size());
   x1=x;
 
   for (unsigned int i=0; i<v.size(); ++i)
@@ -70,8 +70,10 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        test (v);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v(indices, MPI_COMM_WORLD);
+        test(v);
       }
 
     }
index 7ec9d070fa124451f85ef6f833f1edc8ada6244f..f321b9601d7e31a332e9d06e9d252266c5efa64b 100644 (file)
@@ -19,7 +19,7 @@
 
 #include "../tests.h"
 #include <deal.II/base/logstream.h>
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 
 #include <fstream>
 
index 3b64026ea3ad01fbe69d8c75f156467888f3441e..1dd6735c9494e4264cf1efee42897ab94a4bd6f7 100644 (file)
 // make sure that block vector iterator allows reading and writing correctly
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_block_vector.h>
+#include <deal.II/lac/petsc_parallel_block_vector.h>
 #include <fstream>
 #include <iostream>
 
 
 void test ()
 {
-  PETScWrappers::BlockVector v(2,1);
+  PETScWrappers::MPI::BlockVector v(2, MPI_COMM_WORLD, 1, 1);
   v(0) = 1;
   v(1) = 2;
 
   // first check reading through a const
   // iterator
   {
-    PETScWrappers::BlockVector::const_iterator i=v.begin();
+    PETScWrappers::MPI::BlockVector::const_iterator i=v.begin();
     AssertThrow (*i == 1, ExcInternalError());
     ++i;
     AssertThrow (*i == 2, ExcInternalError());
@@ -41,8 +41,8 @@ void test ()
   // same, but create iterator in a different
   // way
   {
-    PETScWrappers::BlockVector::const_iterator
-    i=const_cast<const PETScWrappers::BlockVector &>(v).begin();
+    PETScWrappers::MPI::BlockVector::const_iterator
+    i=const_cast<const PETScWrappers::MPI::BlockVector &>(v).begin();
     AssertThrow (*i == 1, ExcInternalError());
     ++i;
     AssertThrow (*i == 2, ExcInternalError());
@@ -50,7 +50,7 @@ void test ()
 
   // read through a read-write iterator
   {
-    PETScWrappers::BlockVector::iterator i = v.begin();
+    PETScWrappers::MPI::BlockVector::iterator i = v.begin();
     AssertThrow (*i == 1, ExcInternalError());
     ++i;
     AssertThrow (*i == 2, ExcInternalError());
@@ -58,7 +58,7 @@ void test ()
 
   // write through a read-write iterator
   {
-    PETScWrappers::BlockVector::iterator i = v.begin();
+    PETScWrappers::MPI::BlockVector::iterator i = v.begin();
 
     *i = 2;
     ++i;
@@ -67,7 +67,7 @@ void test ()
 
   // and read again
   {
-    PETScWrappers::BlockVector::iterator i = v.begin();
+    PETScWrappers::MPI::BlockVector::iterator i = v.begin();
     AssertThrow (*i == 2, ExcInternalError());
     ++i;
     AssertThrow (*i == 3, ExcInternalError());
index c0a97d084bd38b3f72532f48b02d1f856ba0565b..c97f63485256dd19fe1bac1b1be0e388f16449fe 100644 (file)
 // like _01, except that we use operator[] instead of operator*
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_block_vector.h>
+#include <deal.II/lac/petsc_parallel_block_vector.h>
 #include <fstream>
 #include <iostream>
 
 
 void test ()
 {
-  PETScWrappers::BlockVector v(2,1);
+  PETScWrappers::MPI::BlockVector v(2, MPI_COMM_WORLD, 1, 1);
   v(0) = 1;
   v(1) = 2;
 
   // first check reading through a const
   // iterator
   {
-    PETScWrappers::BlockVector::const_iterator i=v.begin();
+    PETScWrappers::MPI::BlockVector::const_iterator i=v.begin();
     AssertThrow (i[0] == 1, ExcInternalError());
     AssertThrow (i[1] == 2, ExcInternalError());
   }
@@ -40,29 +40,29 @@ void test ()
   // same, but create iterator in a different
   // way
   {
-    PETScWrappers::BlockVector::const_iterator
-    i=const_cast<const PETScWrappers::BlockVector &>(v).begin();
+    PETScWrappers::MPI::BlockVector::const_iterator
+    i=const_cast<const PETScWrappers::MPI::BlockVector &>(v).begin();
     AssertThrow (i[0] == 1, ExcInternalError());
     AssertThrow (i[1] == 2, ExcInternalError());
   }
 
   // read through a read-write iterator
   {
-    PETScWrappers::BlockVector::iterator i = v.begin();
+    PETScWrappers::MPI::BlockVector::iterator i = v.begin();
     AssertThrow (i[0] == 1, ExcInternalError());
     AssertThrow (i[1] == 2, ExcInternalError());
   }
 
   // write through a read-write iterator
   {
-    PETScWrappers::BlockVector::iterator i = v.begin();
+    PETScWrappers::MPI::BlockVector::iterator i = v.begin();
     i[0] = 2;
     i[1] = 3;
   }
 
   // and read again
   {
-    PETScWrappers::BlockVector::iterator i = v.begin();
+    PETScWrappers::MPI::BlockVector::iterator i = v.begin();
     AssertThrow (i[0] == 2, ExcInternalError());
     AssertThrow (i[1] == 3, ExcInternalError());
   }
index 03b6cfb64bc97aefd5c6efe3b80dea6191983044..e7c9fe2e0b017bc4b359521fe434e2bb0a872847 100644 (file)
@@ -19,7 +19,7 @@
 
 #include "../tests.h"
 #include <deal.II/base/logstream.h>
-#include <deal.II/lac/petsc_block_vector.h>
+#include <deal.II/lac/petsc_parallel_block_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
@@ -29,8 +29,8 @@
 #include <cmath>
 
 template <typename number>
-bool operator == (const PETScWrappers::BlockVector &v1,
-                  const PETScWrappers::BlockVector &v2)
+bool operator == (const PETScWrappers::MPI::BlockVector &v1,
+                  const PETScWrappers::MPI::BlockVector &v2)
 {
   if (v1.size() != v2.size())
     return false;
@@ -53,8 +53,8 @@ void test ()
   // iterators
   if (true)
     {
-      PETScWrappers::BlockVector v1(ivector);
-      PETScWrappers::BlockVector v2(ivector);
+      PETScWrappers::MPI::BlockVector v1(ivector, MPI_COMM_WORLD, ivector);
+      PETScWrappers::MPI::BlockVector v2(ivector, MPI_COMM_WORLD, ivector);
 
       // initialize first vector with
       // simple loop
@@ -62,7 +62,7 @@ void test ()
         v1(i) = i;
       // initialize other vector
       // through iterators
-      PETScWrappers::BlockVector::iterator p2 = v2.begin();
+      PETScWrappers::MPI::BlockVector::iterator p2 = v2.begin();
       for (unsigned int i=0; i<v1.size(); ++i, ++p2)
         *p2 = i;
       Assert (p2==v2.end(), ExcInternalError());
@@ -71,36 +71,18 @@ void test ()
       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
+  // Check 2: loop forward and back
   // and check that things are the
   // same
   if (true)
     {
-      PETScWrappers::BlockVector v1(ivector);
+      PETScWrappers::MPI::BlockVector v1(ivector, MPI_COMM_WORLD, 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();
+      PETScWrappers::MPI::BlockVector::iterator p1 = v1.begin();
       for (unsigned int i=0; i<v1.size(); ++i, ++p1)
         AssertThrow (*p1 == i, ExcInternalError());
 
@@ -116,21 +98,21 @@ void test ()
 
       // if we came thus far,
       // everything is alright
-      deallog << "Check 3: true" << std::endl;
+      deallog << "Check 2: true" << std::endl;
     };
 
 
-  // Check 4: same, but this time
+  // Check 3: same, but this time
   // with const iterators
   if (true)
     {
-      PETScWrappers::BlockVector v1(ivector);
+      PETScWrappers::MPI::BlockVector v1(ivector, MPI_COMM_WORLD, 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();
+      PETScWrappers::MPI::BlockVector::const_iterator p1 = v1.begin();
       for (unsigned int i=0; i<v1.size(); ++i, ++p1)
         AssertThrow (*p1 == i, ExcInternalError());
 
@@ -150,14 +132,14 @@ void test ()
 
       // if we came thus far,
       // everything is alright
-      deallog << "Check 4: true" << std::endl;
+      deallog << "Check 3: true" << std::endl;
     };
 
-  // Checks 5-14: use some standard
+  // Checks 4-13: use some standard
   // algorithms
   if (true)
     {
-      PETScWrappers::BlockVector v1(ivector);
+      PETScWrappers::MPI::BlockVector v1(ivector, MPI_COMM_WORLD, ivector);
       // initialize first vector with
       // simple loop
       for (unsigned int i=0; i<v1.size(); ++i)
@@ -165,156 +147,76 @@ void test ()
 
       // check std::distance
       // algorithm
-      deallog << "Check 5: "
+      deallog << "Check 4: "
               << (std::distance (v1.begin(), v1.end()) ==
                   static_cast<signed int>(v1.size()) ?
                   "true" : "false")
               << std::endl;
 
       // check std::copy
-      PETScWrappers::BlockVector v2(ivector);
+      PETScWrappers::MPI::BlockVector v2(ivector, MPI_COMM_WORLD, ivector);
       std::copy (v1.begin(), v1.end(), v2.begin());
-      deallog << "Check 6: " << (v1 == v2 ? "true" : "false") << std::endl;
+      deallog << "Check 5: " << (v1 == v2 ? "true" : "false") << std::endl;
 
       // check std::transform
       std::transform (v1.begin(), v1.end(), v2.begin(),
                       std::bind (std::multiplies<double>(),
                                  std::placeholders::_1,
                                  2.0));
+      v2.compress(VectorOperation::insert);
       v2 *= 1./2.;
-      deallog << "Check 7: " << (v1 == v2 ? "true" : "false") << std::endl;
+      deallog << "Check 6: " << (v1 == v2 ? "true" : "false") << std::endl;
 
 
       // check operators +/-, +=/-=
-      deallog << "Check 8: "
+      deallog << "Check 7: "
               << (std::distance(v1.begin(), v1.begin()+3) == 3 ?
                   "true" : "false")
               << std::endl;
-      deallog << "Check 9: "
+      deallog << "Check 8: "
               << (std::distance(v1.end()-6, v1.end()) == 6 ?
                   "true" : "false")
               << std::endl;
-      deallog << "Check 10: "
+      deallog << "Check 9: "
               << (std::distance(v1.begin(), v1.end()) == (signed)v1.size() ?
                   "true" : "false")
               << std::endl;
-      deallog << "Check 11: "
+      deallog << "Check 10: "
               << (std::distance(v1.begin(), (v1.begin()+=7)) == 7 ?
                   "true" : "false")
               << std::endl;
-      deallog << "Check 12: "
+      deallog << "Check 11: "
               << (std::distance((v1.end()-=4), v1.end()) == 4 ?
                   "true" : "false")
               << std::endl;
 
       // check advance
-      PETScWrappers::BlockVector::iterator p2 = v1.begin();
+      PETScWrappers::MPI::BlockVector::iterator p2 = v1.begin();
       std::advance (p2, v1.size());
-      deallog << "Check 13: " << (p2 == v1.end() ? "true" : "false") << std::endl;
+      deallog << "Check 12: " << (p2 == v1.end() ? "true" : "false") << std::endl;
 
-      PETScWrappers::BlockVector::const_iterator p3 = v1.begin();
+      PETScWrappers::MPI::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;
+      deallog << "Check 13: " << (p3 == v1.end() ? "true" : "false") << std::endl;
     };
 
-  // Check 16: initialization through
-  // iterators. variant with one
-  // constant object
+  // Check 14: operator[]
   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);
+      PETScWrappers::MPI::BlockVector v1(ivector, MPI_COMM_WORLD, 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);
+          const PETScWrappers::MPI::BlockVector::iterator p = (v1.begin()+i);
           for (unsigned int j=0; j<v1.size(); ++j)
             AssertThrow (p[(signed)j-(signed)i] == j, ExcInternalError());
         };
 
       // if we came thus far,
       // everything is alright
-      deallog << "Check 19: true" << std::endl;
+      deallog << "Check 14: true" << std::endl;
     };
 }
 
@@ -366,4 +268,3 @@ int main (int argc,char **argv)
 
   return 0;
 }
-
index ca8a9d55a14311c63f8d45f4534c0c840a537854..f19f759048a198b6be05c6aeeb70a536abe0b6e2 100644 (file)
@@ -13,8 +13,3 @@ DEAL::Check 11: true
 DEAL::Check 12: true
 DEAL::Check 13: true
 DEAL::Check 14: true
-DEAL::Check 15: true
-DEAL::Check 16: true
-DEAL::Check 17: true
-DEAL::Check 18: true
-DEAL::Check 19: true
index 6a19b54a5b5970434f9e32a0aaee3f24e439fb32..6adf8cbfffd1b81776bbd769f0eb697f983ff7f0 100644 (file)
@@ -25,7 +25,7 @@
 #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_parallel_vector.h>
 #include <deal.II/lac/solver_control.h>
 #include <deal.II/lac/solver_cg.h>
 #include <deal.II/lac/solver_gmres.h>
@@ -86,15 +86,17 @@ int main(int argc, char **argv)
     testproblem.five_point(A);
     A.compress (VectorOperation::insert);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    IndexSet indices(dim);
+    indices.add_range(0, dim);
+    PETScWrappers::MPI::Vector  f(indices, MPI_COMM_WORLD);
+    PETScWrappers::MPI::Vector  u(indices, MPI_COMM_WORLD);
     f = 1.;
 
-    GrowingVectorMemory<PETScWrappers::Vector> mem;
-    SolverCG<PETScWrappers::Vector> solver(control,mem);
+    GrowingVectorMemory<PETScWrappers::MPI::Vector> mem;
+    SolverCG<PETScWrappers::MPI::Vector> solver(control,mem);
     PreconditionIdentity preconditioner;
     check_solve (solver, control, A,u,f, preconditioner);
   }
-  GrowingVectorMemory<PETScWrappers::Vector>::release_unused_memory ();
+  GrowingVectorMemory<PETScWrappers::MPI::Vector>::release_unused_memory ();
 
 }
index e5e3067846f9983f761697cfa5db14a0ee320def..ec2fa4d95759760afb4a19b4b0081359ef31e520 100644 (file)
@@ -1,6 +1,6 @@
 
 DEAL::Size 32 Unknowns 961
-DEAL::Solver type: N6dealii8SolverCGINS_13PETScWrappers6VectorEEE
+DEAL::Solver type: N6dealii8SolverCGINS_13PETScWrappers3MPI6VectorEEE
 DEAL:cg::Starting value 31.00
 DEAL:cg::Convergence step 43 value 0.0008189
 DEAL::Solver stopped after 43 iterations
index 30b0118ad35ef6b3851146fd9d8dbecf3fe6f268..542fcec35d0facbf4533a4be161eba9417a108ef 100644 (file)
@@ -26,7 +26,7 @@
 #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_parallel_vector.h>
 #include <deal.II/lac/solver_control.h>
 #include <deal.II/lac/solver_cg.h>
 #include <deal.II/lac/solver_gmres.h>
@@ -87,15 +87,17 @@ int main(int argc, char **argv)
     testproblem.five_point(A);
     A.compress (VectorOperation::insert);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    IndexSet indices(dim);
+    indices.add_range(0, dim);
+    PETScWrappers::MPI::Vector  f(indices, MPI_COMM_WORLD);
+    PETScWrappers::MPI::Vector  u(indices, MPI_COMM_WORLD);
     f = 1.;
 
-    GrowingVectorMemory<PETScWrappers::Vector> mem;
-    SolverBicgstab<PETScWrappers::Vector> solver(control,mem);
+    GrowingVectorMemory<PETScWrappers::MPI::Vector> mem;
+    SolverBicgstab<PETScWrappers::MPI::Vector> solver(control,mem);
     PreconditionIdentity preconditioner;
     check_solve (solver, control, A,u,f, preconditioner);
   }
-  GrowingVectorMemory<PETScWrappers::Vector>::release_unused_memory ();
+  GrowingVectorMemory<PETScWrappers::MPI::Vector>::release_unused_memory ();
 
 }
index 6df9529eefa5f4447f3d39576d6e43da55549af2..a1636f1c50004595f17e1951506a80ef6098ea7d 100644 (file)
@@ -1,4 +1,4 @@
 
 DEAL::Size 32 Unknowns 961
-DEAL::Solver type: N6dealii14SolverBicgstabINS_13PETScWrappers6VectorEEE
+DEAL::Solver type: N6dealii14SolverBicgstabINS_13PETScWrappers3MPI6VectorEEE
 DEAL::Solver stopped within 48 - 51 iterations
index f6155721710553bc3ad41509413398a8f2fe9e37..cf3d39054d389e3c439112b9bf7d4491e2997f38 100644 (file)
@@ -26,7 +26,7 @@
 #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_parallel_vector.h>
 #include <deal.II/lac/solver_control.h>
 #include <deal.II/lac/solver_cg.h>
 #include <deal.II/lac/solver_gmres.h>
@@ -87,16 +87,18 @@ int main(int argc, char **argv)
     PETScWrappers::SparseMatrix  A(dim, dim, 5);
     testproblem.five_point(A);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    IndexSet indices(dim);
+    indices.add_range(0, dim);
+    PETScWrappers::MPI::Vector  f(indices, MPI_COMM_WORLD);
+    PETScWrappers::MPI::Vector  u(indices, MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
 
-    GrowingVectorMemory<PETScWrappers::Vector> mem;
-    SolverGMRES<PETScWrappers::Vector> solver(control,mem);
+    GrowingVectorMemory<PETScWrappers::MPI::Vector> mem;
+    SolverGMRES<PETScWrappers::MPI::Vector> solver(control,mem);
     PreconditionIdentity preconditioner;
     check_solve (solver, control, A,u,f, preconditioner);
   }
-  GrowingVectorMemory<PETScWrappers::Vector>::release_unused_memory ();
+  GrowingVectorMemory<PETScWrappers::MPI::Vector>::release_unused_memory ();
 
 }
index eacf26cd0143cc96cd15c5c8027a1b549c21dfa7..e2bdb9c6b967fafcc0b827b3e21da77565576595 100644 (file)
@@ -1,6 +1,6 @@
 
 DEAL::Size 32 Unknowns 961
-DEAL::Solver type: N6dealii11SolverGMRESINS_13PETScWrappers6VectorEEE
+DEAL::Solver type: N6dealii11SolverGMRESINS_13PETScWrappers3MPI6VectorEEE
 DEAL:GMRES::Starting value 31.00
 DEAL:GMRES::Convergence step 75 value 0.0008096
 DEAL::Solver stopped after 75 iterations
index edb8d3aa79334113c1b24d908acfcda7d1b01d78..5a28f798854061ef507e33776a6da1b83a2cf2a8 100644 (file)
@@ -25,7 +25,7 @@
 #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_parallel_vector.h>
 #include <deal.II/lac/solver_control.h>
 #include <deal.II/lac/solver_cg.h>
 #include <deal.II/lac/solver_gmres.h>
@@ -86,16 +86,18 @@ int main(int argc, char **argv)
     PETScWrappers::SparseMatrix  A(dim, dim, 5);
     testproblem.five_point(A);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    IndexSet indices(dim);
+    indices.add_range(0, dim);
+    PETScWrappers::MPI::Vector  f(indices, MPI_COMM_WORLD);
+    PETScWrappers::MPI::Vector  u(indices, MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
 
-    GrowingVectorMemory<PETScWrappers::Vector> mem;
-    SolverMinRes<PETScWrappers::Vector> solver(control,mem);
+    GrowingVectorMemory<PETScWrappers::MPI::Vector> mem;
+    SolverMinRes<PETScWrappers::MPI::Vector> solver(control,mem);
     PreconditionIdentity preconditioner;
     check_solve (solver, control, A,u,f, preconditioner);
   }
-  GrowingVectorMemory<PETScWrappers::Vector>::release_unused_memory ();
+  GrowingVectorMemory<PETScWrappers::MPI::Vector>::release_unused_memory ();
 
 }
index 64f8f39f24edeaf4477e5e4a2d02cc12a7191cf2..cf60f86687ec0d2924de6b7f4dfd0b536b45137a 100644 (file)
@@ -1,6 +1,6 @@
 
 DEAL::Size 32 Unknowns 961
-DEAL::Solver type: N6dealii12SolverMinResINS_13PETScWrappers6VectorEEE
+DEAL::Solver type: N6dealii12SolverMinResINS_13PETScWrappers3MPI6VectorEEE
 DEAL:minres::Starting value 31.0000
 DEAL:minres::Convergence step 43 value 0.000691560
 DEAL::Solver stopped after 43 iterations
index 9d2515f2719e117309ab16d3a8faf7f332b48c5c..3da07e9a3b54f385b23907a14cc5dfa106eb2817 100644 (file)
@@ -25,7 +25,7 @@
 #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_parallel_vector.h>
 #include <deal.II/lac/solver_control.h>
 #include <deal.II/lac/solver_cg.h>
 #include <deal.II/lac/solver_gmres.h>
@@ -85,16 +85,18 @@ int main(int argc, char **argv)
     PETScWrappers::SparseMatrix  A(dim, dim, 5);
     testproblem.five_point(A);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    IndexSet indices(dim);
+    indices.add_range(0, dim);
+    PETScWrappers::MPI::Vector  f(indices, MPI_COMM_WORLD);
+    PETScWrappers::MPI::Vector  u(indices, MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
 
-    GrowingVectorMemory<PETScWrappers::Vector> mem;
-    SolverQMRS<PETScWrappers::Vector> solver(control,mem);
+    GrowingVectorMemory<PETScWrappers::MPI::Vector> mem;
+    SolverQMRS<PETScWrappers::MPI::Vector> solver(control,mem);
     PreconditionIdentity preconditioner;
     check_solve (solver, control, A,u,f, preconditioner);
   }
-  GrowingVectorMemory<PETScWrappers::Vector>::release_unused_memory ();
+  GrowingVectorMemory<PETScWrappers::MPI::Vector>::release_unused_memory ();
 
 }
index f2ac4fc4cbbd7a320583f034a16da844e381c9e8..a662db55b755b2794c2395ff8c6380af4ab2f0b4 100644 (file)
@@ -1,6 +1,6 @@
 
 DEAL::Size 32 Unknowns 961
-DEAL::Solver type: N6dealii10SolverQMRSINS_13PETScWrappers6VectorEEE
+DEAL::Solver type: N6dealii10SolverQMRSINS_13PETScWrappers3MPI6VectorEEE
 DEAL:QMRS::Starting value 31.0000
 DEAL:QMRS::Convergence step 46 value 0.000906349
 DEAL::Solver stopped after 46 iterations
index 8964a85d7f1379444166d4f52d9c3a34324d2352..ae53be91c2d7a78bb79051235078ae6a40038d88 100644 (file)
 // check FullMatrix::vmult
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/petsc_full_matrix.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   PETScWrappers::FullMatrix m(v.size(),v.size());
   for (unsigned int i=0; i<m.m(); ++i)
@@ -68,8 +68,10 @@ int main (int argc, char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        PETScWrappers::Vector w (100);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v (indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w (indices, MPI_COMM_WORLD);
         test (v,w);
       }
 
index 57109308f1b4034bb3513dabefc886a04a14f06c..5ba10e528d8b2b7762e13371a9996692ed17b71e 100644 (file)
 // check FullMatrix::Tvmult
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/petsc_full_matrix.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   PETScWrappers::FullMatrix m(v.size(),v.size());
   for (unsigned int i=0; i<m.m(); ++i)
@@ -68,8 +68,10 @@ int main (int argc, char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        PETScWrappers::Vector w (100);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v (indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w (indices, MPI_COMM_WORLD);
         test (v,w);
       }
 
index 4daef8582aef5cffe2d241f7e8d700948ae11b96..d7965b19bfb33af1a72317d36c7fa123de2899e7 100644 (file)
 // check FullMatrix::vmult_add
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/petsc_full_matrix.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   PETScWrappers::FullMatrix m(v.size(),v.size());
   for (unsigned int i=0; i<m.m(); ++i)
@@ -72,8 +72,10 @@ int main (int argc, char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        PETScWrappers::Vector w (100);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v (indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w (indices, MPI_COMM_WORLD);
         test (v,w);
       }
 
index 10795e4f6748ec448b4dcc05707a02cd3d9f8d7d..3418fb4fc5939804057bd0c40624fa72a5dc7cd1 100644 (file)
 // check FullMatrix::Tvmult_add
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/petsc_full_matrix.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   PETScWrappers::FullMatrix m(v.size(),v.size());
   for (unsigned int i=0; i<m.m(); ++i)
@@ -72,8 +72,10 @@ int main (int argc, char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        PETScWrappers::Vector w (100);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v (indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w (indices, MPI_COMM_WORLD);
         test (v,w);
       }
 
index 699b958f7d897aa5d5b36ac475d757e02a3d8352..ee98e3f99a3809c048440bc6beb0e82597658fd7 100644 (file)
 // check FullMatrix::matrix_scalar_product
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/petsc_full_matrix.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   PETScWrappers::FullMatrix m(v.size(),v.size());
   for (unsigned int i=0; i<m.m(); ++i)
@@ -75,8 +75,10 @@ int main (int argc, char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        PETScWrappers::Vector w (100);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v (indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w (indices, MPI_COMM_WORLD);
         test (v,w);
       }
 
index e7b81384f1273232c74567fad9f8637c80aa59b8..7af80e469a20d11bf70b08cb359815bec9c883f6 100644 (file)
 // check FullMatrix::matrix_norm_square
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/petsc_full_matrix.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   PETScWrappers::FullMatrix m(v.size(),v.size());
   for (unsigned int i=0; i<m.m(); ++i)
@@ -67,7 +67,9 @@ int main (int argc, char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (30);
+        IndexSet indices(30);
+        indices.add_range(0, 30);
+        PETScWrappers::MPI::Vector v (indices, MPI_COMM_WORLD);
         test (v);
       }
 
index 69059716d47751a24e0b09471e08cd2265b89488..967abb8e64e3d419f8e406f66ac7e22567543011 100644 (file)
 // check FullMatrix::matrix_norm_square
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_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)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w,
+           PETScWrappers::MPI::Vector &x)
 {
   PETScWrappers::FullMatrix m(v.size(),v.size());
   for (unsigned int i=0; i<m.m(); ++i)
@@ -77,9 +77,11 @@ int main (int argc, char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        PETScWrappers::Vector w (100);
-        PETScWrappers::Vector x (100);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v (indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w (indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector x (indices, MPI_COMM_WORLD);
         test (v,w,x);
       }
 
index e95089a04372d04d034fff55a602ee829100fc97..da3085302e9b21817bd3cc050120499326b6d11c 100644 (file)
@@ -20,7 +20,7 @@
 #include "../tests.h"
 #include <deal.II/lac/dynamic_sparsity_pattern.h>
 #include <deal.II/lac/petsc_sparse_matrix.h>
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/petsc_precondition.h>
 #include <deal.II/base/index_set.h>
 #include <fstream>
@@ -50,9 +50,11 @@ void test ()
   mat.compress(VectorOperation::insert);
 
   {
-    PETScWrappers::Vector src, dst;
-    src.reinit(5);
-    dst.reinit(5);
+    IndexSet indices(5);
+    indices.add_range(0, 5);
+    PETScWrappers::MPI::Vector src, dst;
+    src.reinit(indices, MPI_COMM_WORLD);
+    dst.reinit(indices, MPI_COMM_WORLD);
     src(0) = 1.0;
     src(1) = 2.0;
     src.compress(VectorOperation::insert);
index 93db3a623601403e882cae62361ec8ed5729ffa3..7ee36d29de208f1a7dc1aa67e6804fac7ae7f450 100644 (file)
@@ -1,31 +1,31 @@
 
-1.000e+00 6.667e-01 0.000e+00 0.000e+00 0.000e+00 
-5.000e-01 6.667e-01 0.000e+00 0.000e+00 0.000e+00 
+[Proc0 0-4] 1.000e+00 6.667e-01 0.000e+00 0.000e+00 0.000e+00
+[Proc0 0-4] 5.000e-01 6.667e-01 0.000e+00 0.000e+00 0.000e+00
 DEAL:0::OK
-9.365e-01 6.355e-01 0.000e+00 0.000e+00 0.000e+00 
-4.674e-01 6.511e-01 0.000e+00 0.000e+00 0.000e+00 
+[Proc0 0-4] 9.365e-01 6.355e-01 0.000e+00 0.000e+00 0.000e+00
+[Proc0 0-4] 4.674e-01 6.511e-01 0.000e+00 0.000e+00 0.000e+00
 DEAL:0::OK
-9.365e-01 6.355e-01 0.000e+00 0.000e+00 0.000e+00 
-4.674e-01 6.511e-01 0.000e+00 0.000e+00 0.000e+00 
+[Proc0 0-4] 9.365e-01 6.355e-01 0.000e+00 0.000e+00 0.000e+00
+[Proc0 0-4] 4.674e-01 6.511e-01 0.000e+00 0.000e+00 0.000e+00
 DEAL:0::OK
-9.365e-01 6.355e-01 0.000e+00 0.000e+00 0.000e+00 
-4.674e-01 6.511e-01 0.000e+00 0.000e+00 0.000e+00 
+[Proc0 0-4] 9.365e-01 6.355e-01 0.000e+00 0.000e+00 0.000e+00
+[Proc0 0-4] 4.674e-01 6.511e-01 0.000e+00 0.000e+00 0.000e+00
 DEAL:0::OK
-9.365e-01 6.355e-01 0.000e+00 0.000e+00 0.000e+00 
-4.674e-01 6.511e-01 0.000e+00 0.000e+00 0.000e+00 
+[Proc0 0-4] 9.365e-01 6.355e-01 0.000e+00 0.000e+00 0.000e+00
+[Proc0 0-4] 4.674e-01 6.511e-01 0.000e+00 0.000e+00 0.000e+00
 DEAL:0::OK
-9.365e-01 6.355e-01 0.000e+00 0.000e+00 0.000e+00 
-4.674e-01 6.511e-01 0.000e+00 0.000e+00 0.000e+00 
+[Proc0 0-4] 9.365e-01 6.355e-01 0.000e+00 0.000e+00 0.000e+00
+[Proc0 0-4] 4.674e-01 6.511e-01 0.000e+00 0.000e+00 0.000e+00
 DEAL:0::OK
-9.365e-01 6.355e-01 0.000e+00 0.000e+00 0.000e+00 
-4.674e-01 6.511e-01 0.000e+00 0.000e+00 0.000e+00 
+[Proc0 0-4] 9.365e-01 6.355e-01 0.000e+00 0.000e+00 0.000e+00
+[Proc0 0-4] 4.674e-01 6.511e-01 0.000e+00 0.000e+00 0.000e+00
 DEAL:0::OK
-9.367e-01 6.333e-01 0.000e+00 0.000e+00 0.000e+00 
-4.675e-01 6.500e-01 0.000e+00 0.000e+00 0.000e+00 
+[Proc0 0-4] 9.367e-01 6.333e-01 0.000e+00 0.000e+00 0.000e+00
+[Proc0 0-4] 4.675e-01 6.500e-01 0.000e+00 0.000e+00 0.000e+00
 DEAL:0::OK
-1.000e+00 6.667e-01 0.000e+00 0.000e+00 0.000e+00 
-5.000e-01 6.667e-01 0.000e+00 0.000e+00 0.000e+00 
+[Proc0 0-4] 1.000e+00 6.667e-01 0.000e+00 0.000e+00 0.000e+00
+[Proc0 0-4] 5.000e-01 6.667e-01 0.000e+00 0.000e+00 0.000e+00
 DEAL:0::OK
-1.000e+00 2.000e+00 0.000e+00 0.000e+00 0.000e+00 
-1.000e+00 2.000e+00 0.000e+00 0.000e+00 0.000e+00 
+[Proc0 0-4] 1.000e+00 2.000e+00 0.000e+00 0.000e+00 0.000e+00
+[Proc0 0-4] 1.000e+00 2.000e+00 0.000e+00 0.000e+00 0.000e+00
 DEAL:0::OK
index 23ae5b6a69e2aee6293ae5e51a9f3bcbf30bebad..1e561d07ea30e86a32bb40773e2e6f2a82ab5820 100644 (file)
@@ -25,7 +25,7 @@
 #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 <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 
@@ -68,7 +68,10 @@ void test ()
   // then do a single matrix-vector
   // multiplication with subsequent formation
   // of the matrix norm
-  PETScWrappers::Vector v1(N*N), v2(N*N);
+  IndexSet indices(N*N);
+  indices.add_range(0, N*N);
+  PETScWrappers::MPI::Vector v1(indices, MPI_COMM_WORLD),
+                v2(indices, MPI_COMM_WORLD);
   for (unsigned int i=0; i<N*N; ++i)
     v1(i) = i;
   matrix.vmult (v2, v1);
index 823035fc36222944703e8bc09c189ac83b00eee3..612c47c8c620ce1359f7d976933ed53b73870065 100644 (file)
@@ -19,7 +19,7 @@
 #include "../testmatrix.h"
 
 #include <deal.II/lac/petsc_sparse_matrix.h>
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/petsc_solver.h>
 #include <deal.II/lac/petsc_precondition.h>
 
@@ -39,8 +39,10 @@ int main(int argc, char **argv)
     PETScWrappers::SparseMatrix  A(dim, dim, 5);
     testproblem.five_point(A);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    IndexSet indices(dim);
+    indices.add_range(0, dim);
+    PETScWrappers::MPI::Vector  f(indices, MPI_COMM_WORLD);
+    PETScWrappers::MPI::Vector  u(indices, MPI_COMM_WORLD);
 
     f = 1.;
     u = 0.;
index 7c393efd1e3891dcd5c1ac6d657d45f6744dfe07..e9526dc8ffc03aff56bd186e81ae1243fbf253f3 100644 (file)
@@ -19,7 +19,7 @@
 #include "../testmatrix.h"
 
 #include <deal.II/lac/petsc_sparse_matrix.h>
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/petsc_solver.h>
 #include <deal.II/lac/petsc_precondition.h>
 
@@ -39,8 +39,10 @@ int main(int argc, char **argv)
     PETScWrappers::SparseMatrix  A(dim, dim, 5);
     testproblem.five_point(A);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    IndexSet indices(dim);
+    indices.add_range(0, dim);
+    PETScWrappers::MPI::Vector  f(indices, MPI_COMM_WORLD);
+    PETScWrappers::MPI::Vector  u(indices, MPI_COMM_WORLD);
 
     f = 1.;
     u = 0.;
index c5689853c8a92c44711fa2453f91b0e6e3343833..b8c95eded8819cf744dfdd6e7cf3ef2c77d3099f 100644 (file)
@@ -25,7 +25,7 @@
 #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_parallel_vector.h>
 #include <deal.II/lac/petsc_solver.h>
 #include <deal.II/lac/petsc_precondition.h>
 #include <deal.II/lac/vector_memory.h>
@@ -80,8 +80,10 @@ int main(int argc, char **argv)
     PETScWrappers::SparseMatrix  A(dim, dim, 5);
     testproblem.five_point(A);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    IndexSet indices(dim);
+    indices.add_range(0, dim);
+    PETScWrappers::MPI::Vector  f(indices, MPI_COMM_WORLD);
+    PETScWrappers::MPI::Vector  u(indices, MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
 
index f282cc68207d9456290afb4c1eeabda419887e7a..acaad95256a030910b5c2e76274fb0ab03b1bfee 100644 (file)
@@ -25,7 +25,7 @@
 #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_parallel_vector.h>
 #include <deal.II/lac/petsc_solver.h>
 #include <deal.II/lac/petsc_precondition.h>
 #include <deal.II/lac/vector_memory.h>
@@ -78,8 +78,10 @@ int main(int argc, char **argv)
 
     PetscFDMatrix  A(size, dim);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    IndexSet indices(dim);
+    indices.add_range(0, dim);
+    PETScWrappers::MPI::Vector  f(indices, MPI_COMM_WORLD);
+    PETScWrappers::MPI::Vector  u(indices, MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
 
index 5891232a54c3142e86cb7576adb756e92ff8c3ac..b9002f6af71c00ef5ca0db38427adbc34191b024 100644 (file)
@@ -26,7 +26,7 @@
 #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_parallel_vector.h>
 #include <deal.II/lac/petsc_solver.h>
 #include <deal.II/lac/petsc_precondition.h>
 #include <deal.II/lac/vector_memory.h>
@@ -81,8 +81,10 @@ int main(int argc, char **argv)
     PETScWrappers::SparseMatrix  A(dim, dim, 5);
     testproblem.five_point(A);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    IndexSet indices(dim);
+    indices.add_range(0, dim);
+    PETScWrappers::MPI::Vector  f(indices, MPI_COMM_WORLD);
+    PETScWrappers::MPI::Vector  u(indices, MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
 
index 7c978e9bfbfead83e620bac7e8ebab731d50faea..4fd859f533f98195c3261e5fe6820e74e2d342ea 100644 (file)
@@ -27,7 +27,7 @@
 #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_parallel_vector.h>
 #include <deal.II/lac/petsc_solver.h>
 #include <deal.II/lac/petsc_precondition.h>
 #include <deal.II/lac/vector_memory.h>
@@ -82,8 +82,10 @@ int main(int argc, char **argv)
     PETScWrappers::SparseMatrix  A(dim, dim, 5);
     testproblem.five_point(A);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    IndexSet indices(dim);
+    indices.add_range(0, dim);
+    PETScWrappers::MPI::Vector  f(indices, MPI_COMM_WORLD);
+    PETScWrappers::MPI::Vector  u(indices, MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
 
index c234939647f85fd35709f1e6aa440758f4b9b5ba..7b3fb5c2bf281f9e5aa65ca72a5beb26156b1425 100644 (file)
@@ -25,7 +25,7 @@
 #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_parallel_vector.h>
 #include <deal.II/lac/petsc_solver.h>
 #include <deal.II/lac/petsc_precondition.h>
 #include <deal.II/lac/vector_memory.h>
@@ -80,8 +80,10 @@ int main(int argc, char **argv)
     PETScWrappers::SparseMatrix  A(dim, dim, 5);
     testproblem.five_point(A);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    IndexSet indices(dim);
+    indices.add_range(0, dim);
+    PETScWrappers::MPI::Vector  f(indices, MPI_COMM_WORLD);
+    PETScWrappers::MPI::Vector  u(indices, MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
 
index ee5c4ff3222b036c9296901f4117803fc3c0db73..90454d679170ce041fcd2aa1f076f063a527b23a 100644 (file)
@@ -25,7 +25,7 @@
 #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_parallel_vector.h>
 #include <deal.II/lac/petsc_solver.h>
 #include <deal.II/lac/petsc_precondition.h>
 #include <deal.II/lac/vector_memory.h>
@@ -80,8 +80,10 @@ int main(int argc, char **argv)
     PETScWrappers::SparseMatrix  A(dim, dim, 5);
     testproblem.five_point(A);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    IndexSet indices(dim);
+    indices.add_range(0, dim);
+    PETScWrappers::MPI::Vector  f(indices, MPI_COMM_WORLD);
+    PETScWrappers::MPI::Vector  u(indices, MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
 
index 9497ab7a1fed5456f724e0ca3a33e412d7f67a24..a88f91a59a1fb6d12b81c875d734a98de0a97d6b 100644 (file)
@@ -25,7 +25,7 @@
 #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_parallel_vector.h>
 #include <deal.II/lac/petsc_solver.h>
 #include <deal.II/lac/petsc_precondition.h>
 #include <deal.II/lac/vector_memory.h>
@@ -80,8 +80,10 @@ int main(int argc, char **argv)
     PETScWrappers::SparseMatrix  A(dim, dim, 5);
     testproblem.five_point(A);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    IndexSet indices(dim);
+    indices.add_range(0, dim);
+    PETScWrappers::MPI::Vector  f(indices, MPI_COMM_WORLD);
+    PETScWrappers::MPI::Vector  u(indices, MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
     f.compress (VectorOperation::insert);
index 764b6ce78e40f8f608d946e37a0a7994c22dade2..65f14b6a9d962a8f8c05b9744882661caacac203 100644 (file)
@@ -26,7 +26,7 @@
 #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_parallel_vector.h>
 #include <deal.II/lac/petsc_solver.h>
 #include <deal.II/lac/petsc_precondition.h>
 #include <deal.II/lac/vector_memory.h>
@@ -87,8 +87,10 @@ int main(int argc, char **argv)
     PETScWrappers::SparseMatrix  A(dim, dim, 5);
     testproblem.five_point(A);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    IndexSet indices(dim);
+    indices.add_range(0, dim);
+    PETScWrappers::MPI::Vector  f(indices, MPI_COMM_WORLD);
+    PETScWrappers::MPI::Vector  u(indices, MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
 
index 4604acad3ff0b0c23c1898faa85c2905829c7a61..87b7c5f2453c5055e9f403882ecfb99958258d1f 100644 (file)
@@ -25,7 +25,7 @@
 #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_parallel_vector.h>
 #include <deal.II/lac/petsc_solver.h>
 #include <deal.II/lac/petsc_precondition.h>
 #include <deal.II/lac/vector_memory.h>
@@ -80,8 +80,10 @@ int main(int argc, char **argv)
     PETScWrappers::SparseMatrix  A(dim, dim, 5);
     testproblem.five_point(A);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    IndexSet indices(dim);
+    indices.add_range(0, dim);
+    PETScWrappers::MPI::Vector  f(indices, MPI_COMM_WORLD);
+    PETScWrappers::MPI::Vector  u(indices, MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
 
index 1ca85af1279b01f0e2946504593b2554c0522fce..843d599dd88d580f17110a66e7c1b6aba00701e6 100644 (file)
@@ -25,7 +25,7 @@
 #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_parallel_vector.h>
 #include <deal.II/lac/petsc_solver.h>
 #include <deal.II/lac/petsc_precondition.h>
 #include <deal.II/lac/vector_memory.h>
@@ -80,8 +80,10 @@ int main(int argc, char **argv)
     PETScWrappers::SparseMatrix  A(dim, dim, 5);
     testproblem.five_point(A);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    IndexSet indices(dim);
+    indices.add_range(0, dim);
+    PETScWrappers::MPI::Vector  f(indices, MPI_COMM_WORLD);
+    PETScWrappers::MPI::Vector  u(indices, MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
 
index 5a4c8d2685f2e196ebc13d7b8b8d066791a0bd59..5b675359968492807171a059cacc7bb27ee4e917 100644 (file)
@@ -25,7 +25,7 @@
 #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_parallel_vector.h>
 #include <deal.II/lac/petsc_solver.h>
 #include <deal.II/lac/petsc_precondition.h>
 #include <deal.II/lac/vector_memory.h>
@@ -80,8 +80,10 @@ int main(int argc, char **argv)
     PETScWrappers::SparseMatrix  A(dim, dim, 5);
     testproblem.five_point(A);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    IndexSet indices(dim);
+    indices.add_range(0, dim);
+    PETScWrappers::MPI::Vector  f(indices, MPI_COMM_WORLD);
+    PETScWrappers::MPI::Vector  u(indices, MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
 
index 017adc6759d356abe86eee8aba5875fbe9d7a580..5e380e855adee5c5a48964196c316b8122431571 100644 (file)
@@ -25,7 +25,7 @@
 #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_parallel_vector.h>
 #include <deal.II/lac/petsc_solver.h>
 #include <deal.II/lac/petsc_precondition.h>
 #include <deal.II/lac/vector_memory.h>
@@ -80,8 +80,10 @@ int main(int argc, char **argv)
     PETScWrappers::SparseMatrix  A(dim, dim, 5);
     testproblem.five_point(A);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    IndexSet indices(dim);
+    indices.add_range(0, dim);
+    PETScWrappers::MPI::Vector  f(indices, MPI_COMM_WORLD);
+    PETScWrappers::MPI::Vector  u(indices, MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
 
index 8ab29f5e165909881f31a909c8efeaf281fb89a1..a643de0d31aa72bbbbf5103a08b6f7e218e04160 100644 (file)
@@ -25,7 +25,7 @@
 #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_parallel_vector.h>
 #include <deal.II/lac/petsc_solver.h>
 #include <deal.II/lac/petsc_precondition.h>
 #include <deal.II/lac/vector_memory.h>
@@ -80,8 +80,10 @@ int main(int argc, char **argv)
     PETScWrappers::SparseMatrix  A(dim, dim, 5);
     testproblem.five_point(A);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    IndexSet indices(dim);
+    indices.add_range(0, dim);
+    PETScWrappers::MPI::Vector  f(indices, MPI_COMM_WORLD);
+    PETScWrappers::MPI::Vector  u(indices, MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
 
index 20aa032485e593b7c2eef26ffbac8855384bebea..f885cb6ae999680d2862545eb0ab82fd190a84ff 100644 (file)
@@ -25,7 +25,7 @@
 #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_parallel_vector.h>
 #include <deal.II/lac/petsc_solver.h>
 #include <deal.II/lac/petsc_precondition.h>
 #include <deal.II/lac/vector_memory.h>
@@ -83,8 +83,10 @@ int main(int argc, char **argv)
     PETScWrappers::SparseMatrix  A(dim, dim, 5);
     testproblem.five_point(A);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    IndexSet indices(dim);
+    indices.add_range(0, dim);
+    PETScWrappers::MPI::Vector  f(indices, MPI_COMM_WORLD);
+    PETScWrappers::MPI::Vector  u(indices, MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
 
index 93bcfe4c5fb99095271a7b9d5976ba25a63bd918..ee69eaa066e7d63017de3261cd9dd2339ada6cc4 100644 (file)
@@ -25,7 +25,7 @@
 #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_parallel_vector.h>
 #include <deal.II/lac/petsc_solver.h>
 #include <deal.II/lac/petsc_precondition.h>
 #include <deal.II/lac/vector_memory.h>
@@ -80,8 +80,10 @@ int main(int argc, char **argv)
     PETScWrappers::SparseMatrix  A(dim, dim, 5);
     testproblem.five_point(A);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    IndexSet indices(dim);
+    indices.add_range(0, dim);
+    PETScWrappers::MPI::Vector  f(indices, MPI_COMM_WORLD);
+    PETScWrappers::MPI::Vector  u(indices, MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
 
index da9dece9d3b9024e7516d85ffdf7a3e3f6a65a7b..2ccc0e3025cc78fd186f9c1902630b20f5f1f0e8 100644 (file)
@@ -25,7 +25,7 @@
 #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_parallel_vector.h>
 #include <deal.II/lac/petsc_solver.h>
 #include <deal.II/lac/petsc_precondition.h>
 #include <deal.II/lac/vector_memory.h>
@@ -80,8 +80,10 @@ int main(int argc, char **argv)
     PETScWrappers::SparseMatrix  A(dim, dim, 5);
     testproblem.five_point(A);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    IndexSet indices(dim);
+    indices.add_range(0, dim);
+    PETScWrappers::MPI::Vector  f(indices, MPI_COMM_WORLD);
+    PETScWrappers::MPI::Vector  u(indices, MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
 
index 5da9fea56cec6eee610c34750893c3c1f362c06a..ce88c6874098a82bb464f0da4b1092b899565275 100644 (file)
@@ -29,7 +29,7 @@
 #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_parallel_vector.h>
 #include <deal.II/lac/petsc_solver.h>
 #include <deal.II/lac/petsc_precondition.h>
 #include <deal.II/lac/vector_memory.h>
@@ -84,8 +84,10 @@ int main(int argc, char **argv)
     PETScWrappers::SparseMatrix  A(dim, dim, 5);
     testproblem.five_point(A);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    IndexSet indices(dim);
+    indices.add_range(0, dim);
+    PETScWrappers::MPI::Vector  f(indices, MPI_COMM_WORLD);
+    PETScWrappers::MPI::Vector  u(indices, MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
 
index c92bf27906760942c3254fed85f01bbe79163aec..977c01375bc2a6fcc991d341754be8a0cfcad72f 100644 (file)
@@ -25,7 +25,7 @@
 #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_parallel_vector.h>
 #include <deal.II/lac/petsc_solver.h>
 #include <deal.II/lac/petsc_precondition.h>
 #include <deal.II/lac/vector_memory.h>
@@ -80,8 +80,10 @@ int main(int argc, char **argv)
     PETScWrappers::SparseMatrix  A(dim, dim, 5);
     testproblem.five_point(A);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    IndexSet indices(dim);
+    indices.add_range(0, dim);
+    PETScWrappers::MPI::Vector  f(indices, MPI_COMM_WORLD);
+    PETScWrappers::MPI::Vector  u(indices, MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
 
index 2554bc781bd52832c558c84db5ad20cbf64f61a0..9f9bc857016ab054146a52e808a257d468da61fa 100644 (file)
@@ -20,7 +20,7 @@
 
 #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_parallel_vector.h>
 #include <deal.II/lac/petsc_solver.h>
 #include <deal.II/lac/petsc_precondition.h>
 
@@ -40,8 +40,10 @@ int main(int argc, char **argv)
     PETScWrappers::SparseMatrix  A(dim, dim, 5);
     testproblem.five_point(A);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    IndexSet indices(dim);
+    indices.add_range(0, dim);
+    PETScWrappers::MPI::Vector  f(indices, MPI_COMM_WORLD);
+    PETScWrappers::MPI::Vector  u(indices, MPI_COMM_WORLD);
 
     f = 1.;
     u = 0.;
index 045d4a6b56fdc09abc03cabc34be1175d0dbbd34..a560ff74f722d3244db54643994ac9b97533783f 100644 (file)
@@ -25,7 +25,7 @@
 #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_parallel_vector.h>
 #include <deal.II/lac/petsc_solver.h>
 #include <deal.II/lac/petsc_precondition.h>
 #include <deal.II/lac/vector_memory.h>
@@ -73,8 +73,10 @@ int main(int argc, char **argv)
     PETScWrappers::SparseMatrix  A(dim, dim, 5);
     testproblem.five_point(A);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    IndexSet indices(dim);
+    indices.add_range(0, dim);
+    PETScWrappers::MPI::Vector  f(indices, MPI_COMM_WORLD);
+    PETScWrappers::MPI::Vector  u(indices, MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
 
index 6779b7a89f8e6ea94cea01fe28a0eb85d5e2a931..947417fab622ebe5401e08964da08f74ecd7728e 100644 (file)
@@ -25,7 +25,7 @@
 #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_parallel_vector.h>
 #include <deal.II/lac/petsc_solver.h>
 #include <deal.II/lac/petsc_precondition.h>
 #include <deal.II/lac/vector_memory.h>
@@ -70,12 +70,14 @@ int main(int argc, char **argv)
     PETScWrappers::SparseMatrix  A(dim, dim, 5);
     testproblem.five_point(A);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    IndexSet indices(dim);
+    indices.add_range(0, dim);
+    PETScWrappers::MPI::Vector  f(indices, MPI_COMM_WORLD);
+    PETScWrappers::MPI::Vector  u(indices, MPI_COMM_WORLD);
     u = 0.;
     f = 1.;
     A.compress (VectorOperation::insert);
-    PETScWrappers::Vector t=u;
+    PETScWrappers::MPI::Vector t=u;
 
     PETScWrappers::SolverPreOnly solver(control);
 
index f6e2d04d7cd847f489604d18d96edacc6bb1e1f1..217e4d72915c0d1fa8414de0966d3337e99fbbfb 100644 (file)
@@ -25,7 +25,7 @@
 #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_parallel_vector.h>
 #include <deal.II/lac/petsc_solver.h>
 #include <deal.II/lac/petsc_precondition.h>
 #include <deal.II/lac/vector_memory.h>
@@ -52,8 +52,10 @@ int main(int argc, char **argv)
     PETScWrappers::SparseMatrix  A(dim, dim, 5);
     testproblem.five_point(A);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    IndexSet indices(dim);
+    indices.add_range(0, dim);
+    PETScWrappers::MPI::Vector  f(indices, MPI_COMM_WORLD);
+    PETScWrappers::MPI::Vector  u(indices, MPI_COMM_WORLD);
     u = 0.;
     f = 1.;
     A.compress (VectorOperation::insert);
@@ -63,10 +65,9 @@ int main(int argc, char **argv)
 //    solver.set_symmetric_mode(true);
     solver.solve(A,u,f);
 
-    PETScWrappers::Vector  tmp(dim);
+    PETScWrappers::MPI::Vector  tmp(dim);
     deallog << "residual = " << A.residual (tmp, u, f)
             << std::endl;
   }
 
 }
-
index 94d567d13fdaff53b048cbe598feb3768bdda10b..e291496a86105a77bc6aaabda770385c8cc2c513 100644 (file)
@@ -18,7 +18,6 @@
 // check SparseMatrix::add(other, factor)
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
 #include <deal.II/lac/petsc_sparse_matrix.h>
 #include <fstream>
 #include <iostream>
index 2054876d80bf2ba9f9d97a33dfd2c02019e6c3bb..4b36f9939e32df79688d957fcae9dc25a499c85e 100644 (file)
@@ -19,7 +19,6 @@
 // now forbidden
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
 #include <deal.II/lac/petsc_sparse_matrix.h>
 #include <fstream>
 #include <iostream>
index 7c69060bb27960736e4d9c7bcace7ce8f5d027c9..64e4843099673b2d3cf88d1bbc97e82bcbd370c5 100644 (file)
 // check SparseMatrix::vmult
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/petsc_sparse_matrix.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   PETScWrappers::SparseMatrix m(v.size(),v.size(),v.size());
   for (unsigned int i=0; i<m.m(); ++i)
@@ -68,8 +68,10 @@ int main (int argc, char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        PETScWrappers::Vector w (100);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v (indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w (indices, MPI_COMM_WORLD);
         test (v,w);
       }
 
index 0b04265c00824c6adaf75634770ccc297ba5dbff..85f15916ce83427d8c7778aee14fa2bb1b523d78 100644 (file)
 // check SparseMatrix::Tvmult
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/petsc_sparse_matrix.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   PETScWrappers::SparseMatrix m(v.size(),v.size(),v.size());
   for (unsigned int i=0; i<m.m(); ++i)
@@ -68,8 +68,10 @@ int main (int argc, char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        PETScWrappers::Vector w (100);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v (indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w (indices, MPI_COMM_WORLD);
         test (v,w);
       }
 
index 8905a182cfc8b151be77950914861c0383a92f05..5b1e8fbfeece91ab9281424301c4c3057f2edcdd 100644 (file)
 // check SparseMatrix::vmult_add
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/petsc_sparse_matrix.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   PETScWrappers::SparseMatrix m(v.size(),v.size(),v.size());
   for (unsigned int i=0; i<m.m(); ++i)
@@ -72,8 +72,10 @@ int main (int argc, char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        PETScWrappers::Vector w (100);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v (indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w (indices, MPI_COMM_WORLD);
         test (v,w);
       }
 
index a34340e28cc3e5f1bcbee197061878bc8bee18a9..cb36393483f7fcfbb511676655edd1334e3bd0af 100644 (file)
 // check SparseMatrix::Tvmult_add
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/petsc_sparse_matrix.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   PETScWrappers::SparseMatrix m(v.size(),v.size(),v.size());
   for (unsigned int i=0; i<m.m(); ++i)
@@ -72,8 +72,10 @@ int main (int argc, char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        PETScWrappers::Vector w (100);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v (indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w (indices, MPI_COMM_WORLD);
         test (v,w);
       }
 
index 0a94ce401bf2d427d3e9737be8b2fa60a195de5b..a3a283612d53b397abe2132c20513623f69fe76c 100644 (file)
 // check SparseMatrix::matrix_scalar_product
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/petsc_sparse_matrix.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   PETScWrappers::SparseMatrix m(v.size(),v.size(),v.size());
   for (unsigned int i=0; i<m.m(); ++i)
@@ -75,8 +75,10 @@ int main (int argc, char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        PETScWrappers::Vector w (100);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v (indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w (indices, MPI_COMM_WORLD);
         test (v,w);
       }
 
index 92702a6622629f3b08011e428eb20807b7885eb8..d7816eb361e09f58f8d1a5ba2a381dc91bf144eb 100644 (file)
 // check SparseMatrix::matrix_norm_square
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/petsc_sparse_matrix.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   PETScWrappers::SparseMatrix m(v.size(),v.size(),v.size());
   for (unsigned int i=0; i<m.m(); ++i)
@@ -67,7 +67,9 @@ int main (int argc, char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (30);
+        IndexSet indices(30);
+        indices.add_range(0, 30);
+        PETScWrappers::MPI::Vector v (indices, MPI_COMM_WORLD);
         test (v);
       }
 
index 4919a3b843ed087a91ae156d49cd8e79bceab260..1a9856ae47db7671ea27bb39c0bd4b88c4ca39c1 100644 (file)
 // check SparseMatrix::matrix_norm_square
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/petsc_sparse_matrix.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w,
-           PETScWrappers::Vector &x)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w,
+           PETScWrappers::MPI::Vector &x)
 {
   PETScWrappers::SparseMatrix m(v.size(),v.size(),v.size());
   for (unsigned int i=0; i<m.m(); ++i)
@@ -77,9 +77,11 @@ int main (int argc, char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        PETScWrappers::Vector w (100);
-        PETScWrappers::Vector x (100);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v (indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w (indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector x (indices, MPI_COMM_WORLD);
         test (v,w,x);
       }
 
index c39aef1bdb3b94650183fbc339eab0ecbfe68a2f..7a085939fc26cc260468b21d38e82e026e1fd722 100644 (file)
@@ -15,7 +15,7 @@
 
 
 
-// when calling PETScWrappers::Vector::operator() (), the return type is a
+// when calling PETScWrappers::MPI::Vector::operator() (), the return type is a
 // reference object, not a reference to the actual element. this leads to the
 // funny situation that an assignment like v2(i)=v1(i) isn't really what it
 // looks like: it tries to copy the reference objects, not the values they
 // this was fixed 2004-04-05, and this test checks that it works
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   // set the first vector
   for (unsigned int i=0; i<v.size(); ++i)
@@ -59,8 +59,10 @@ int main (int argc, char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        PETScWrappers::Vector w (100);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v (indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w (indices, MPI_COMM_WORLD);
         test (v,w);
       }
 
index b6eb1f20e1ca8f76a63ef5c96dbb779250cb1e4c..dc5a9719ae4a4aee1439dbc12c7a97da35a7ee97 100644 (file)
@@ -15,7 +15,7 @@
 
 
 
-// this is equivalent to the petsc_vector_assign_01 test, except that we use
+// this is equivalent to the petsc vector_assign_01 test, except that we use
 // operator+= instead of operator=. Now, this does not present a problem,
 // since the compiler does not automatically generate a version of this
 // operator, but simply performs the conversion to PetscScalar, i.e. the
 // wrote the test to make sure it works this way, let's keep it then...
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   // set the first vector
   for (unsigned int i=0; i<v.size(); ++i)
@@ -58,8 +58,10 @@ int main (int argc, char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        PETScWrappers::Vector w (100);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v (indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w (indices, MPI_COMM_WORLD);
         test (v,w);
       }
 
index 7f1d2138369234db318f630b548350808f608406..624e38cce71ca5cf4fe7404cc3a6bc049e2c833b 100644 (file)
 
 
 
-// check PETScWrappers::Vector::operator==(PETScWrappers::Vector) for vectors that are not
-// equal
+// check PETScWrappers::MPI::Vector::operator==(PETScWrappers::MPI::Vector)
+// for vectors that are not equal
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   // set only certain elements of each
   // vector
@@ -54,8 +54,10 @@ int main (int argc, char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        PETScWrappers::Vector w (100);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v (indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w (indices, MPI_COMM_WORLD);
         test (v,w);
       }
 
index 1163f4115b57e4a5a90b2996422a8c06eb1b90c5..ad10dfff9a3d0a13b865fd953d5c322c411408b0 100644 (file)
 
 
 
-// check PETScWrappers::Vector::operator==(PETScWrappers::Vector) for vectors that are
-// equal
+// check PETScWrappers::MPI::Vector::operator==(PETScWrappers::MPI::Vector)
+// for vectors that are equal
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   // set only certain elements of each
   // vector
@@ -36,6 +36,8 @@ void test (PETScWrappers::Vector &v,
       if (i%3 == 0)
         w(i) = i+1.;
     }
+  v.compress(VectorOperation::insert);
+  w.compress(VectorOperation::insert);
   // but then copy elements and make sure the
   // vectors are actually equal
   v = w;
@@ -56,8 +58,10 @@ int main (int argc, char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        PETScWrappers::Vector w (100);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v (indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w (indices, MPI_COMM_WORLD);
         test (v,w);
       }
 
index 7cf514045eafc424f0d1f50cd078e727ab0eadf1..86077fb9624c2d933ee85bb40e76de9d502b53f4 100644 (file)
 
 
 
-// check PETScWrappers::Vector::operator!=(PETScWrappers::Vector) for vectors that are not
-// equal
+// check PETScWrappers::MPI::Vector::operator!=(PETScWrappers::MPI::Vector)
+// for vectors that are not equal
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   // set only certain elements of each
   // vector
@@ -54,8 +54,10 @@ int main (int argc, char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        PETScWrappers::Vector w (100);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v (indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w (indices, MPI_COMM_WORLD);
         test (v,w);
       }
 
index 8e0f1ff17cfed24b643b179db3c7ba0abf1dd3f4..492d4f83ff2f4bc29289bb3102ceb7b8e2e16d19 100644 (file)
 
 
 
-// check PETScWrappers::Vector::operator!=(PETScWrappers::Vector) for vectors that are
-// equal
+// check PETScWrappers::MPI::Vector::operator!=(PETScWrappers::MPI::Vector)
+// for vectors that are equal
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   // set only certain elements of each
   // vector
@@ -38,6 +38,8 @@ void test (PETScWrappers::Vector &v,
     }
   // but then copy elements and make sure the
   // vectors are actually equal
+  v.compress(VectorOperation::insert);
+  w.compress(VectorOperation::insert);
   v = w;
   AssertThrow (! (v!=w), ExcInternalError());
 
@@ -56,8 +58,10 @@ int main (int argc, char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        PETScWrappers::Vector w (100);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v (indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w (indices, MPI_COMM_WORLD);
         test (v,w);
       }
 
index f4d971b837058f0aabca5daba4be6977fef8afff..d7e3e1b9d8e50d087cdf6ac8ac117211c0197092 100644 (file)
@@ -19,7 +19,7 @@
 // restores the previous value of the stream precision
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
@@ -35,7 +35,9 @@ int main (int argc, char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
       {
-        PETScWrappers::Vector v (5);
+        IndexSet indices(5);
+        indices.add_range(0, 5);
+        PETScWrappers::MPI::Vector v (indices, MPI_COMM_WORLD);
         for (unsigned int i=0; i<v.size(); ++i)
           v(i) = i*1.2345678901234567;
 
index c7ed048e82d608ae49de9f52565df1a410e28366..dd47d283f4c713cca5b0991710c6176afc87250e 100644 (file)
@@ -1,6 +1,7 @@
 
 DEAL::3.14159
 DEAL::across=false
+[Proc 0 0-4]
 0.0000000000e+00
 1.2345678901e+00
 2.4691357802e+00
@@ -8,5 +9,5 @@ DEAL::across=false
 4.9382715605e+00
 
 DEAL::across=true
-0.0000000000e+00 1.2345678901e+00 2.4691357802e+00 3.7037036704e+00 4.9382715605e+00 
+[Proc0 0-4] 0.0000000000e+00 1.2345678901e+00 2.4691357802e+00 3.7037036704e+00 4.9382715605e+00
 DEAL::3.14159
index 74ef028d6fbeefa9bb0f056afff9b89af1a04b7d..0bd8749689f1161f70163fb1768ae819b01d981c 100644 (file)
 
 
 
-// Test the constructor PETScWrappers::Vector(const Vec &) that takes an
+// Test the constructor PETScWrappers::MPI::Vector(const Vec &) that takes an
 // existing PETSc vector.
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   // set the first vector
   for (unsigned int i=0; i<v.size(); ++i)
@@ -39,6 +39,8 @@ void test (PETScWrappers::Vector &v,
   // check that they're equal
   Assert (v==w, ExcInternalError());
 
+  v.compress(VectorOperation::insert);
+  w.compress(VectorOperation::insert);
   v=w;
 
   deallog << "OK" << std::endl;
@@ -59,8 +61,10 @@ int main (int argc, char **argv)
       int ierr = VecCreateSeq (PETSC_COMM_SELF, 100, &vpetsc);
       AssertThrow (ierr == 0, ExcPETScError(ierr));
       {
-        PETScWrappers::Vector v (vpetsc);
-        PETScWrappers::Vector w (100);
+        IndexSet indices(100);
+        indices.add_range(0, 100);
+        PETScWrappers::MPI::Vector v (indices, MPI_COMM_WORLD);
+        PETScWrappers::MPI::Vector w (indices, MPI_COMM_WORLD);
         test (v,w);
       }
 
index 10dd0c889612e362164414d20614403ae4cdab08..a34cb641707c4479e0dc36804d46405085dc45b2 100644 (file)
 
 
 
-// check PETScWrappers::Vector::size()
+// check PETScWrappers::MPI::Vector::size()
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   // set only certain elements of the vector
   for (unsigned int k=0; k<v.size(); k+=1+k)
@@ -48,7 +48,7 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
       {
-        PETScWrappers::Vector v(100);
+        PETScWrappers::MPI::Vector v(MPI_COMM_WORLD, 100, 100);
         test (v);
       }
     }
index 98e3ac348a3f4ea3dc1cca9c32e99b40293d4491..4f660f58596a8e36e36fe35112ad00ab6664a22d 100644 (file)
 
 
 
-// check PETScWrappers::Vector::operator() in set-mode
+// check PETScWrappers::MPI::Vector::operator() in set-mode
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   deallog << "Complex test" << std::endl;
 
@@ -65,7 +65,7 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
       {
-        PETScWrappers::Vector v(100);
+        PETScWrappers::MPI::Vector v(MPI_COMM_WORLD, 100, 100);
         test (v);
       }
     }
index 514a3c624afd0f732a0c66997f852d6ffd8fffd4..69fdc2fc09f6e280cac157ef673ef43955861bd3 100644 (file)
 
 
 
-// check PETScWrappers::Vector::operator() in add-mode
+// check PETScWrappers::MPI::Vector::operator() in add-mode
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   // set only certain elements of the vector. have a bit pattern of
   // where we actually wrote elements to
@@ -60,7 +60,7 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
+        PETScWrappers::MPI::Vector v (MPI_COMM_WORLD, 100, 100);
         test (v);
       }
 
index b7313f0559e67e4b481028a93147d023caf9b440..dba4c2e5235690a5d9f4c15368e2408039b7a0c6 100644 (file)
 
 
 
-// check PETScWrappers::Vector::l1_norm()
+// check PETScWrappers::MPI::Vector::l1_norm()
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   // set some elements of the vector
   double norm = 0;
@@ -58,7 +58,7 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
+        PETScWrappers::MPI::Vector v (MPI_COMM_WORLD, 100, 100);
         test (v);
       }
     }
index a8388f34a1f294150b72566eb8b5de66053ae6f5..73931dc364d3f747ef908a2a29896bb98ee752f0 100644 (file)
 
 
 
-// check PETScWrappers::Vector::l2_norm()
+// check PETScWrappers::MPI::Vector::l2_norm()
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   // set some elements of the vector
   double norm = 0;
@@ -59,7 +59,7 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
+        PETScWrappers::MPI::Vector v (MPI_COMM_WORLD, 100, 100);
         test (v);
       }
     }
index dfa1a9487daa7f8db9d57c0832f9a9ef27f06fdb..082d7fb567a0a844aec67a5a162f17f527ddb474 100644 (file)
 
 
 
-// check PETScWrappers::Vector::linfty_norm()
+// check PETScWrappers::MPI::Vector::linfty_norm()
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v)
+void test (PETScWrappers::MPI::Vector &v)
 {
   // set some elements of the vector
   double norm = 0;
@@ -55,7 +55,7 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
+        PETScWrappers::MPI::Vector v (MPI_COMM_WORLD, 100, 100);
         test (v);
       }
 
index 697194861cab6b931ec90468c676e2e428cf6556..00824187874e1a6f151c6977ba411a91b92ce722 100644 (file)
 
 
 
-// check PETScWrappers::Vector::operator*(Vector) on two vectors that are
+// check PETScWrappers::MPI::Vector::operator*(Vector) on two vectors that are
 // not orthogonal
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   // set only certain elements of each
   // vector, and record the expected scalar
@@ -66,8 +66,8 @@ int main (int argc,char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        PETScWrappers::Vector w (100);
+        PETScWrappers::MPI::Vector v (MPI_COMM_WORLD, 100, 100);
+        PETScWrappers::MPI::Vector w (MPI_COMM_WORLD, 100, 100);
         test (v,w);
       }
 
index 738a1d37fe41677c3a71bba8164678c14bf138c7..71ad3d2837f53ca2c6719a1b75c1252bb0c7aeb3 100644 (file)
@@ -16,7 +16,7 @@
 
 // deal.II includes
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 
 #include <fstream>
 #include <iostream>
@@ -29,7 +29,7 @@
 // on vector
 
 // vector elements
-void test_vector (PETScWrappers::Vector &v)
+void test_vector (PETScWrappers::MPI::Vector &v)
 {
   deallog << "Check vector access" << std::endl;
 
@@ -67,7 +67,7 @@ int main (int argc, char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
       {
-        PETScWrappers::Vector v (5);
+        PETScWrappers::MPI::Vector v (MPI_COMM_WORLD, 5, 5);
         test_vector (v);
 
         deallog << "vector:" << std::endl;
@@ -105,5 +105,3 @@ int main (int argc, char **argv)
 
   return 0;
 }
-
-
index 89aea7028e47c954369cd2ab1500542421914415..88357f3e4947c03d8d20ac0c2d723a8fba3fea76 100644 (file)
@@ -24,7 +24,7 @@
 #include <deal.II/lac/petsc_precondition.h>
 #include <deal.II/lac/petsc_solver.h>
 #include <deal.II/lac/petsc_sparse_matrix.h>
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 
 int main(int argc, char **argv)
 {
@@ -42,8 +42,8 @@ int main(int argc, char **argv)
     PETScWrappers::SparseMatrix  A(dim, dim, 5);
     testproblem.five_point(A);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    PETScWrappers::MPI::Vector  f(MPI_COMM_WORLD, dim, dim);
+    PETScWrappers::MPI::Vector  u(MPI_COMM_WORLD, dim, dim);
 
     f = 1.;
     u = 0.;
index 91f932dc2a984adfaaeecdedde3ba5a3fdb62c41..40df1cc48933c6580cdac418cf98dbbad1970cbb 100644 (file)
@@ -24,7 +24,7 @@
 #include <deal.II/lac/petsc_precondition.h>
 #include <deal.II/lac/petsc_solver.h>
 #include <deal.II/lac/petsc_sparse_matrix.h>
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 
 int main(int argc, char **argv)
 {
@@ -42,8 +42,8 @@ int main(int argc, char **argv)
     PETScWrappers::SparseMatrix  A(dim, dim, 5);
     testproblem.five_point(A);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    PETScWrappers::MPI::Vector  f(MPI_COMM_WORLD, dim, dim);
+    PETScWrappers::MPI::Vector  u(MPI_COMM_WORLD, dim, dim);
 
     f = 1.;
     u = 0.;
index 026a7fa2c7a800237819d774005612da8ae680f5..ba5fac2e857689583fc57084d6bae09fffd50e74 100644 (file)
@@ -26,7 +26,7 @@
 #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_parallel_vector.h>
 #include <deal.II/lac/petsc_solver.h>
 #include <deal.II/lac/petsc_precondition.h>
 #include <deal.II/lac/vector_memory.h>
@@ -78,8 +78,8 @@ int main(int argc, char **argv)
     PETScWrappers::SparseMatrix  A(dim, dim, 5);
     testproblem.five_point(A);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    PETScWrappers::MPI::Vector  f(MPI_COMM_WORLD, dim, dim);
+    PETScWrappers::MPI::Vector  u(MPI_COMM_WORLD, dim, dim);
     f = 1.;
     A.compress (VectorOperation::insert);
     f.compress (VectorOperation::insert);
@@ -91,4 +91,3 @@ int main(int argc, char **argv)
   }
 
 }
-
index 1bea00f78fbe6567e2224a691ab52751cab7ad33..72ae42e3f4e7548f59f4415aefa7eda9fb1cbf2f 100644 (file)
@@ -38,7 +38,7 @@
 #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_parallel_vector.h>
 #include <deal.II/lac/petsc_solver.h>
 #include <deal.II/lac/petsc_precondition.h>
 #include <deal.II/lac/vector_memory.h>
@@ -88,8 +88,8 @@ int main(int argc, char **argv)
 
     PetscFDMatrix  A(size, dim);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    PETScWrappers::MPI::Vector  f(MPI_COMM_WORLD, dim, dim);
+    PETScWrappers::MPI::Vector  u(MPI_COMM_WORLD, dim, dim);
     f = 1.;
     A.compress (VectorOperation::insert);
     f.compress (VectorOperation::insert);
@@ -101,4 +101,3 @@ int main(int argc, char **argv)
   }
 
 }
-
index 0f6b6c9db502faf6b3d5f31d07ca5374e6728273..4040f017e5971a02bf6062143d8db47d588d642c 100644 (file)
@@ -26,7 +26,7 @@
 #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_parallel_vector.h>
 #include <deal.II/lac/petsc_solver.h>
 #include <deal.II/lac/petsc_precondition.h>
 #include <deal.II/lac/vector_memory.h>
@@ -78,8 +78,8 @@ int main(int argc, char **argv)
     PETScWrappers::SparseMatrix  A(dim, dim, 5);
     testproblem.five_point(A);
 
-    PETScWrappers::Vector  f(dim);
-    PETScWrappers::Vector  u(dim);
+    PETScWrappers::MPI::Vector  f(MPI_COMM_WORLD, dim, dim);
+    PETScWrappers::MPI::Vector  u(MPI_COMM_WORLD, dim, dim);
     f = 1.;
     A.compress (VectorOperation::insert);
     f.compress (VectorOperation::insert);
@@ -91,4 +91,3 @@ int main(int argc, char **argv)
   }
 
 }
-
index 46f783f61d0b024921fc18635f689d1c3626ca57..e88671259a1ce2dc108081b3be7020d8f0a22993 100644 (file)
@@ -17,7 +17,6 @@
 // check SparseMatrix::add(other, factor)
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
 #include <deal.II/lac/petsc_sparse_matrix.h>
 #include <fstream>
 #include <iostream>
index 58289afa0350d2fd3378a6bcd5836698a0e9b139..91327212a36e379533e8ba9d85779c84c29f0344 100644 (file)
@@ -18,7 +18,7 @@
 // check assignment of elements in Vector
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/vector.h>
 #include <fstream>
 #include <iostream>
 void test ()
 {
   const unsigned int s = 10;
-  PETScWrappers::Vector v(s);
+  PETScWrappers::MPI::Vector  v(MPI_COMM_WORLD, s, s);
   for (unsigned int k=0; k<v.size(); ++k)
     v(k) = k;
 
   v.compress (VectorOperation::insert);
 
-  PETScWrappers::Vector v2(s);
+  PETScWrappers::MPI::Vector v2(MPI_COMM_WORLD, s, s);
   for (int k=0; k<v2.size(); ++k)
     v2(k) = PetscScalar (k,-k);
 
index 7ad9d1b47b4eeee877a945d3a866cb2c18531b19..2df049d4b55127889e5993bcb6e684d946e83e6c 100644 (file)
 
 // See notes in petsc/vector_assign_01.cc
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   // set the first vector
   for (unsigned int k=0; k<v.size(); ++k)
@@ -52,8 +52,8 @@ int main (int argc, char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
       {
-        PETScWrappers::Vector v (100);
-        PETScWrappers::Vector w (100);
+        PETScWrappers::MPI::Vector v (MPI_COMM_WORLD, 100, 100);
+        PETScWrappers::MPI::Vector w (MPI_COMM_WORLD, 100, 100);
         test (v,w);
       }
 
index 411e9bc3a8c61a14e1cad9fb71913e8b595a64b4..6fe53a155a848181af765253e0e8cf6e9cbc3b23 100644 (file)
 
 
 
-// this is equivalent to the petsc_vector_assign_01 test, except that we use
+// this is equivalent to the petsc_parallel_vector_assign_01 test, except that we use
 // operator+= instead of operator=. This is also not exciting...
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   // set the first vector
   for (unsigned int k=0; k<v.size(); ++k)
@@ -54,8 +54,8 @@ int main (int argc, char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
       {
-        PETScWrappers::Vector v (20);
-        PETScWrappers::Vector w (20);
+        PETScWrappers::MPI::Vector v (MPI_COMM_WORLD, 20, 20);
+        PETScWrappers::MPI::Vector w (MPI_COMM_WORLD, 20, 20);
         test (v,w);
 
         // Some output
index 52d69eac94288188268e07322f2af2938544733e..d4bb40c066854410202716c1c8af7aeb6433526c 100644 (file)
 
 
 
-// check PETScWrappers::Vector::operator==(PETScWrappers::Vector) for vectors that are not
-// equal
+// check PETScWrappers::MPI::Vector::operator==(PETScWrappers::MPI::Vector)
+// for vectors that are not equal
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   // set only certain elements of each vector
   for (unsigned int k=0; k<v.size(); ++k)
@@ -54,8 +54,8 @@ int main (int argc, char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
       {
-        PETScWrappers::Vector v (20);
-        PETScWrappers::Vector w (20);
+        PETScWrappers::MPI::Vector v (MPI_COMM_WORLD, 20, 20);
+        PETScWrappers::MPI::Vector w (MPI_COMM_WORLD, 20, 20);
         test (v,w);
 
         // SOme output
index 7d7f78feaec614c9aca0758ab8fd8af26feb10a9..73c076422466efce31ccb6e069a0c93ba4707fee 100644 (file)
 
 
 
-// check PETScWrappers::Vector::operator==(PETScWrappers::Vector) for vectors that are
-// equal
+// check PETScWrappers::MPI::Vector::operator==(PETScWrappers::MPI::Vector)
+// for vectors that are equal
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   // set only certain elements of each vector
   for (unsigned int k=0; k<v.size(); ++k)
@@ -56,8 +56,8 @@ int main (int argc, char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
       {
-        PETScWrappers::Vector v (20);
-        PETScWrappers::Vector w (20);
+        PETScWrappers::MPI::Vector v (MPI_COMM_WORLD, 20, 20);
+        PETScWrappers::MPI::Vector w (MPI_COMM_WORLD, 20, 20);
         test (v,w);
 
         // Output
index 071fa8b79af2021131a4d4246eac92b1e198be58..5727579fb1f275969e91325ba8890ae920a75a4a 100644 (file)
@@ -19,7 +19,7 @@
 // restores the previous value of the stream precision
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
@@ -36,7 +36,7 @@ int main (int argc, char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
       {
-        PETScWrappers::Vector v (5);
+        PETScWrappers::MPI::Vector v (MPI_COMM_WORLD, 5, 5);
         for (unsigned int k=0; k<v.size(); ++k)
           v(k) = PetscScalar (k*1.2345678901234567,2.*k*1.2345678901234567);
 
index eed237c52df19e2e80d324175134943b0251363e..d74a0a51ec1af198e0be929c1cbfb9c7cff64ba0 100644 (file)
 // See comments in tests/petsc/vector_wrap_01.cc
 
 #include "../tests.h"
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (PETScWrappers::Vector &v,
-           PETScWrappers::Vector &w)
+void test (PETScWrappers::MPI::Vector &v,
+           PETScWrappers::MPI::Vector &w)
 {
   // set the first vector
   for (unsigned int k=0; k<v.size(); ++k)
@@ -61,8 +61,8 @@ int main (int argc, char **argv)
       int ierr = VecCreateSeq (PETSC_COMM_SELF, 100, &vpetsc);
       AssertThrow (ierr == 0, ExcPETScError(ierr));
       {
-        PETScWrappers::Vector v (vpetsc);
-        PETScWrappers::Vector w (100);
+        PETScWrappers::MPI::Vector v (vpetsc);
+        PETScWrappers::MPI::Vector w (PETSC_COMM_SELF, 100, 100);
         test (v,w);
       }
 
index ba0a892153d75e8274cebe9fc006f94c589085c7..8f2ab83139d348d7065f22f805e58ddc721ceac0 100644 (file)
@@ -33,7 +33,7 @@
 #include <deal.II/numerics/data_out.h>\r
 #include <deal.II/lac/full_matrix.h>\r
 #include <deal.II/lac/petsc_sparse_matrix.h>\r
-#include <deal.II/lac/petsc_vector.h>\r
+#include <deal.II/lac/petsc_parallel_vector.h>\r
 #include <deal.II/lac/petsc_solver.h>\r
 #include <deal.II/lac/petsc_precondition.h>\r
 \r
@@ -60,7 +60,7 @@ private:
   DoFHandler<2>    dof_handler;\r
 \r
   PETScWrappers::SparseMatrix A;\r
-  PETScWrappers::Vector       b, x;\r
+  PETScWrappers::MPI::Vector  b, x;\r
   ConstraintMatrix            constraints;\r
 \r
   TableHandler output_table;\r
@@ -82,8 +82,8 @@ void LaplaceProblem::setup_system ()
 \r
   A.reinit (dof_handler.n_dofs(), dof_handler.n_dofs(),\r
             dof_handler.max_couplings_between_dofs());\r
-  b.reinit (dof_handler.n_dofs());\r
-  x.reinit (dof_handler.n_dofs());\r
+  b.reinit (MPI_COMM_WORLD, dof_handler.n_dofs(), dof_handler.n_dofs());\r
+  x.reinit (MPI_COMM_WORLD, dof_handler.n_dofs(), dof_handler.n_dofs());\r
 \r
   // some output\r
   output_table.add_value ("cells", triangulation.n_active_cells());\r
@@ -155,7 +155,7 @@ void LaplaceProblem::solve ()
   PETScWrappers::PreconditionBlockJacobi preconditioner (A);\r
   cg_solver.solve (A, x, b, preconditioner);\r
 \r
-  PETScWrappers::Vector res(x);\r
+  PETScWrappers::MPI::Vector res(x);\r
   A.residual(res,x,b);\r
   AssertThrow(res.l2_norm()<1e-3,\r
               ExcInternalError());\r
index 4d74cea00e18bc5baceff0e80bd8719186cf2c9c..376379ff261ffcadabbeaa372cd7dec6596fb91c 100644 (file)
@@ -33,7 +33,7 @@
 #include <deal.II/numerics/data_out.h>\r
 #include <deal.II/lac/full_matrix.h>\r
 #include <deal.II/lac/petsc_sparse_matrix.h>\r
-#include <deal.II/lac/petsc_vector.h>\r
+#include <deal.II/lac/petsc_parallel_vector.h>\r
 #include <deal.II/lac/slepc_solver.h>\r
 \r
 #include <fstream>\r
@@ -58,10 +58,10 @@ private:
   FE_Q<2>          fe;\r
   DoFHandler<2>    dof_handler;\r
 \r
-  PETScWrappers::SparseMatrix        A, B;\r
-  std::vector<PETScWrappers::Vector> x;\r
-  std::vector<double>                lambda;\r
-  ConstraintMatrix                   constraints;\r
+  PETScWrappers::SparseMatrix             A, B;\r
+  std::vector<PETScWrappers::MPI::Vector> x;\r
+  std::vector<double>                     lambda;\r
+  ConstraintMatrix                        constraints;\r
 \r
   TableHandler output_table;\r
 };\r
@@ -86,7 +86,7 @@ void LaplaceEigenspectrumProblem::setup_system ()
             dof_handler.max_couplings_between_dofs());\r
 \r
   x.resize (1);\r
-  x[0].reinit (dof_handler.n_dofs ());\r
+  x[0].reinit (MPI_COMM_WORLD, dof_handler.n_dofs(), dof_handler.n_dofs());\r
   lambda.resize (1);\r
   lambda[0] = 0.;\r
 \r
@@ -161,7 +161,7 @@ void LaplaceEigenspectrumProblem::solve ()
 \r
   {\r
     const double precision = 1e-7;\r
-    PETScWrappers::Vector Ax(x[0]), Bx(x[0]);\r
+    PETScWrappers::MPI::Vector Ax(x[0]), Bx(x[0]);\r
     for (unsigned int i=0; i < x.size(); ++i)\r
       {\r
         B.vmult(Bx,x[i]);\r
index 11fd8294ab96f52443b9361175574eda60bd5256..75d5fcc58978f75af69269d2be182ce3a2587de3 100644 (file)
@@ -29,7 +29,7 @@
 #include <deal.II/base/logstream.h>
 #include <deal.II/lac/petsc_compatibility.h>
 #include <deal.II/lac/petsc_sparse_matrix.h>
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/petsc_solver.h>
 #include <deal.II/lac/slepc_solver.h>
 #include <deal.II/lac/petsc_precondition.h>
@@ -54,6 +54,9 @@ check_solve( SolverType &solver,
         for (unsigned int j=0; j<u[i].size(); ++j)
           u[i][j] = static_cast<double>(Testing::rand())/static_cast<double>(RAND_MAX);
 
+      for (auto &vector : u)
+        vector.compress(VectorOperation::insert);
+
       solver.set_initial_space(u);
 
       solver.solve(A,B,v,u,v.size());
@@ -107,8 +110,8 @@ int main(int argc, char **argv)
     diagonal.diag(B);
     B.compress (VectorOperation::insert);
 
-    std::vector<PETScWrappers::Vector>  u(n_eigenvalues,
-                                          PETScWrappers::Vector(dim));
+    std::vector<PETScWrappers::MPI::Vector>
+    u(n_eigenvalues, PETScWrappers::MPI::Vector(MPI_COMM_WORLD, dim, dim));
     std::vector<PetscScalar> v(n_eigenvalues);
 
     PETScWrappers::set_option_value("-st_ksp_type","cg");
@@ -151,4 +154,3 @@ int main(int argc, char **argv)
   }
 
 }
-
index 542a3389ade7eae1cc20727d1d114239a87d2ad6..03c27a416a27abeef1c2b9d01cda0019c57a1154 100644 (file)
@@ -29,7 +29,7 @@
 #include <deal.II/base/logstream.h>
 #include <deal.II/lac/petsc_compatibility.h>
 #include <deal.II/lac/petsc_sparse_matrix.h>
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/petsc_solver.h>
 #include <deal.II/lac/slepc_solver.h>
 #include <deal.II/lac/petsc_precondition.h>
@@ -55,6 +55,9 @@ check_solve( SolverType &solver,
         for (unsigned int j=0; j<u[i].size(); ++j)
           u[i][j] = static_cast<double>(Testing::rand())/static_cast<double>(RAND_MAX);
 
+      for (auto &vector : u)
+        vector.compress(VectorOperation::insert);
+
       solver.set_initial_space(u);
       // solve
       solver.solve(A,v,u,v.size());
@@ -136,8 +139,8 @@ int main(int argc, char **argv)
     testproblem.three_point(A);
     A.compress (VectorOperation::insert);
 
-    std::vector<PETScWrappers::Vector>  u(n_eigenvalues,
-                                          PETScWrappers::Vector(dim));
+    std::vector<PETScWrappers::MPI::Vector>
+    u(n_eigenvalues, PETScWrappers::MPI::Vector(MPI_COMM_WORLD, dim, dim));
     std::vector<PetscScalar> v(n_eigenvalues);
 
     {

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.