Remove deprecated serial Trilinos vectors from test suite

diff --git a/tests/gla/extract_subvector_to.cc b/tests/gla/extract_subvector_to.cc
index 6e00ea0569436c08e660f9ba470e124d310f79d6..590175601cefa0d2a25c4ee738607b3fa19c201e 100644 (file)
--- a/tests/gla/extract_subvector_to.cc
+++ b/tests/gla/extract_subvector_to.cc
@@ -85,8 +85,8 @@ int main (int argc, char **argv)
 
     {
       deallog.push("Trilinos");
-      TrilinosWrappers::Vector v;
-      v.reinit(17);
+      TrilinosWrappers::MPI::Vector v;
+      v.reinit(complete_index_set(17), MPI_COMM_WORLD);
       test (v);
       deallog.pop();
     }
@@ -116,11 +116,10 @@ int main (int argc, char **argv)
 
     {
       deallog.push("Trilinos");
-      TrilinosWrappers::BlockVector v;
-      v.reinit(3);
-      v.block(0).reinit(7);
-      v.block(1).reinit(5);
-      v.block(2).reinit(3);
+      TrilinosWrappers::MPI::BlockVector v(3);
+      v.block(0).reinit(complete_index_set(7));
+      v.block(1).reinit(complete_index_set(5));
+      v.block(2).reinit(complete_index_set(3));
       v.collect_sizes();
       test (v);
       deallog.pop();

diff --git a/tests/lac/block_linear_operator_05.cc b/tests/lac/block_linear_operator_05.cc
index dceab47d9639789b43277ffa141c52cf27c173dc..8e3e6dc0826c9f3188a4204b41c4496484fc1546 100644 (file)
--- a/tests/lac/block_linear_operator_05.cc
+++ b/tests/lac/block_linear_operator_05.cc
@@ -23,7 +23,7 @@
 #include <deal.II/lac/trilinos_block_sparse_matrix.h>
 #include <deal.II/lac/trilinos_sparse_matrix.h>
 #include <deal.II/lac/trilinos_vector.h>
-#include <deal.II/lac/trilinos_block_vector.h>
+#include <deal.II/lac/trilinos_parallel_block_vector.h>
 
 using namespace dealii;
 
@@ -37,18 +37,14 @@ int main(int argc, char *argv[])
   TrilinosWrappers::SparseMatrix a;
 
   auto op_a  = linear_operator<TrilinosWrappers::MPI::Vector>(a);
-  auto op_a2  = linear_operator<TrilinosWrappers::Vector>(a);
 
   TrilinosWrappers::BlockSparseMatrix b;
 
   auto op_b = linear_operator<TrilinosWrappers::MPI::BlockVector>(b);
-  auto op_b3 = linear_operator<TrilinosWrappers::BlockVector>(b);
 
   typedef LinearOperator<TrilinosWrappers::MPI::Vector,TrilinosWrappers::MPI::Vector> Op_MPI;
-  typedef LinearOperator<TrilinosWrappers::Vector,TrilinosWrappers::Vector> Op;
 
   auto op_c = block_diagonal_operator<2, TrilinosWrappers::MPI::BlockVector >(std::array<Op_MPI,2> ({{ op_a, op_a}}));
-  auto op_c2 = block_diagonal_operator<2, TrilinosWrappers::BlockVector >(std::array<Op,2> ({{ op_a2, op_a2}}));
 
   deallog << "OK" << std::endl;
 

diff --git a/tests/lac/linear_operator_04.cc b/tests/lac/linear_operator_04.cc
index eedca10cba49f4c481fd61ae9fe942681f3135a8..5696ce55ee20305a3e81133b4f88c5e739052232 100644 (file)
--- a/tests/lac/linear_operator_04.cc
+++ b/tests/lac/linear_operator_04.cc
@@ -36,12 +36,12 @@ int main(int argc, char *argv[])
   TrilinosWrappers::SparseMatrix a;
 
   auto op_a  = linear_operator<TrilinosWrappers::MPI::Vector>(a);
-  auto op_a2  = linear_operator<TrilinosWrappers::Vector>(a);
+  auto op_a2  = linear_operator<TrilinosWrappers::MPI::Vector>(a);
 
   TrilinosWrappers::BlockSparseMatrix b;
 
   auto op_b = linear_operator<TrilinosWrappers::MPI::BlockVector>(b);
-  auto op_b3 = linear_operator<TrilinosWrappers::BlockVector>(b);
+  auto op_b3 = linear_operator<TrilinosWrappers::MPI::BlockVector>(b);
 
   deallog << "OK" << std::endl;
 

diff --git a/tests/lac/linear_operator_10.cc b/tests/lac/linear_operator_10.cc
index 0f2998be40b744bbe04b8e2080f2cea184e460d8..813a9c088f5a37be80b8b2ef4e1f302a49d803ef 100644 (file)
--- a/tests/lac/linear_operator_10.cc
+++ b/tests/lac/linear_operator_10.cc
@@ -21,7 +21,7 @@
 #include <deal.II/lac/packaged_operation.h>
 
 #include <deal.II/lac/trilinos_block_sparse_matrix.h>
-#include <deal.II/lac/trilinos_block_vector.h>
+#include <deal.II/lac/trilinos_parallel_block_vector.h>
 #include <deal.II/lac/trilinos_precondition.h>
 #include <deal.II/lac/trilinos_solver.h>
 #include <deal.II/lac/trilinos_sparsity_pattern.h>
@@ -224,7 +224,7 @@ int main(int argc, char *argv[])
     sparsity_pattern.compress();
 
     TrilinosWrappers::SparseMatrix A (sparsity_pattern);
-    TrilinosWrappers::Vector b;
+    TrilinosWrappers::MPI::Vector b;
     b.reinit(A.locally_owned_domain_indices());
     TrilinosWrappers::MPI::Vector c;
     c.reinit(A.locally_owned_domain_indices());
@@ -365,7 +365,7 @@ int main(int argc, char *argv[])
     //   typedef TrilinosWrappers::SolverDirect SLVR;
     //   // test_solver<SLVR> (A, b);
     //
-    //   typedef dealii::TrilinosWrappers::Vector VectorType;
+    //   typedef dealii::TrilinosWrappers::MPI::Vector VectorType;
     //   typedef dealii::TrilinosWrappers::internal::LinearOperator::TrilinosPayload PayloadType;
     //   // TODO: Full template expansion required for composite operator. Can one prevent this?
     //   //       i.e. is 'const auto lo_A = linear_operator<VectorType>(A);' possible?
@@ -382,7 +382,7 @@ int main(int argc, char *argv[])
     //   // Singular operation
     //   {
     //     deallog.push("S_Op");
-    //     const TrilinosWrappers::Vector x_approx = lo_A_inv*b;
+    //     const TrilinosWrappers::MPI::Vector x_approx = lo_A_inv*b;
     //     print(x_approx);
     //     deallog.pop();
     //   }
@@ -390,7 +390,7 @@ int main(int argc, char *argv[])
     //   // Composite operation
     //   {
     //     deallog.push("C_Op");
-    //     const TrilinosWrappers::Vector x_approx = (lo_A_inv*lo_A*lo_A_inv)*b;
+    //     const TrilinosWrappers::MPI::Vector x_approx = (lo_A_inv*lo_A*lo_A_inv)*b;
     //     print(x_approx);
     //     deallog.pop();
     //   }

diff --git a/tests/lac/linear_operator_10a.cc b/tests/lac/linear_operator_10a.cc
index 132550237995d6f317de387edc313becd22da1d9..9f5a403bf71172d5ec1e221a581d10d64f01da4b 100644 (file)
--- a/tests/lac/linear_operator_10a.cc
+++ b/tests/lac/linear_operator_10a.cc
@@ -28,7 +28,7 @@
 #include <deal.II/lac/solver_richardson.h>
 
 #include <deal.II/lac/trilinos_block_sparse_matrix.h>
-#include <deal.II/lac/trilinos_block_vector.h>
+#include <deal.II/lac/trilinos_parallel_block_vector.h>
 #include <deal.II/lac/trilinos_precondition.h>
 #include <deal.II/lac/trilinos_sparsity_pattern.h>
 #include <deal.II/lac/trilinos_sparse_matrix.h>
@@ -230,8 +230,8 @@ int main(int argc, char *argv[])
     sparsity_pattern.compress();
 
     TrilinosWrappers::SparseMatrix A (sparsity_pattern);
-    TrilinosWrappers::Vector b;
-    b.reinit(A.domain_partitioner());
+    TrilinosWrappers::MPI::Vector b;
+    b.reinit(A.locally_owned_domain_indices());
     TrilinosWrappers::MPI::Vector c;
     c.reinit(A.locally_owned_domain_indices());
     for (unsigned int i=0; i < rc; ++i)
@@ -333,49 +333,49 @@ int main(int argc, char *argv[])
 
     {
       deallog.push("SolverBicgstab");
-      typedef SolverBicgstab<TrilinosWrappers::Vector> SLVR;
+      typedef SolverBicgstab<TrilinosWrappers::MPI::Vector> SLVR;
       test_solver<SLVR> (A, b);
       deallog.pop();
     }
 
     {
       deallog.push("SolverCG");
-      typedef SolverCG<TrilinosWrappers::Vector> SLVR;
+      typedef SolverCG<TrilinosWrappers::MPI::Vector> SLVR;
       test_solver<SLVR> (A, b);
       deallog.pop();
     }
 
     {
       deallog.push("SolverGMRES");
-      typedef SolverGMRES<TrilinosWrappers::Vector> SLVR;
+      typedef SolverGMRES<TrilinosWrappers::MPI::Vector> SLVR;
       test_solver<SLVR> (A, b);
       deallog.pop();
     }
 
     {
       deallog.push("SolverFGMRES");
-      typedef SolverFGMRES<TrilinosWrappers::Vector> SLVR;
+      typedef SolverFGMRES<TrilinosWrappers::MPI::Vector> SLVR;
       test_solver<SLVR> (A, b);
       deallog.pop();
     }
 
     {
       deallog.push("SolverMinRes");
-      typedef SolverMinRes<TrilinosWrappers::Vector> SLVR;
+      typedef SolverMinRes<TrilinosWrappers::MPI::Vector> SLVR;
       test_solver<SLVR> (A, b);
       deallog.pop();
     }
 
     {
       deallog.push("SolverQMRS");
-      typedef SolverQMRS<TrilinosWrappers::Vector> SLVR;
+      typedef SolverQMRS<TrilinosWrappers::MPI::Vector> SLVR;
       test_solver<SLVR> (A, b);
       deallog.pop();
     }
 
     {
       deallog.push("SolverRichardson");
-      typedef SolverRichardson<TrilinosWrappers::Vector> SLVR;
+      typedef SolverRichardson<TrilinosWrappers::MPI::Vector> SLVR;
       test_solver<SLVR> (A, b);
       deallog.pop();
     }

diff --git a/tests/lac/linear_operator_11.cc b/tests/lac/linear_operator_11.cc
index ac3803c76429a9116f4cb553fa0123cfaa19c2c4..2d92f4444ea594bad5f071bc3232f7368d0de1c1 100644 (file)
--- a/tests/lac/linear_operator_11.cc
+++ b/tests/lac/linear_operator_11.cc
@@ -62,8 +62,8 @@ private:
   ConstraintMatrix     constraints;
 
   TrilinosWrappers::SparseMatrix system_matrix;
-  TrilinosWrappers::Vector       solution;
-  TrilinosWrappers::Vector       system_rhs;
+  TrilinosWrappers::MPI::Vector       solution;
+  TrilinosWrappers::MPI::Vector       system_rhs;
 };
 
 
@@ -148,8 +148,8 @@ void Step4<dim>::setup_system ()
   DoFTools::make_sparsity_pattern (dof_handler, c_sparsity, constraints, false);
   system_matrix.reinit (c_sparsity);
 
-  solution.reinit (dof_handler.n_dofs());
-  system_rhs.reinit (dof_handler.n_dofs());
+  solution.reinit (complete_index_set(dof_handler.n_dofs()));
+  system_rhs.reinit (complete_index_set(dof_handler.n_dofs()));
 }
 
 
@@ -220,7 +220,7 @@ void Step4<dim>::solve ()
     deallog.pop();
   }
 
-  typedef TrilinosWrappers::Vector VectorType;
+  typedef TrilinosWrappers::MPI::Vector VectorType;
   VectorType output(solution);
   {
     deallog.push("Trilinos_CG_SSOR");

diff --git a/tests/lac/linear_operator_13.cc b/tests/lac/linear_operator_13.cc
index 51a7dade0ecbb7f72049677a4dbd1bf609d140d7..e034b0e77e1613d1c1ff4fc8e12c2425646c05ec 100644 (file)
--- a/tests/lac/linear_operator_13.cc
+++ b/tests/lac/linear_operator_13.cc
@@ -39,7 +39,7 @@
 #include <deal.II/grid/tria.h>
 
 #include <deal.II/lac/trilinos_block_sparse_matrix.h>
-#include <deal.II/lac/trilinos_block_vector.h>
+#include <deal.II/lac/trilinos_parallel_block_vector.h>
 #include <deal.II/lac/trilinos_precondition.h>
 #include <deal.II/lac/trilinos_solver.h>
 #include <deal.II/lac/trilinos_sparsity_pattern.h>
@@ -50,14 +50,14 @@ using namespace dealii;
 
 template<int dim>
 void build_matrix_vector(TrilinosWrappers::BlockSparseMatrix &matrix,
-                         TrilinosWrappers::BlockVector       &vector,
+                         TrilinosWrappers::MPI::BlockVector       &vector,
                          const FE_Q<dim>                     &fe_test,
                          const FE_Q<dim>                     &fe_trial)
 {
   deallog.push("build_matrix_vector");
 
   // Configure block system
-  std::vector<types::global_dof_index> dofs_per_block(2);
+  std::vector<types::global_dof_index> dofs_per_block (2);
   std::vector<unsigned int> block_component (2);
   block_component[0] = 0;
   block_component[1] = 1;
@@ -80,16 +80,19 @@ void build_matrix_vector(TrilinosWrappers::BlockSparseMatrix &matrix,
   DoFRenumbering::component_wise(dof_handler, block_component);
   DoFTools::count_dofs_per_block(dof_handler, dofs_per_block,
                                  block_component);
+  std::vector<IndexSet> partitioning(2);
+  partitioning[0] = complete_index_set(dofs_per_block[0]);
+  partitioning[1] = complete_index_set(dofs_per_block[1]);
 
   constraints.clear();
   constraints.close();
-  BlockDynamicSparsityPattern dsp (dofs_per_block,dofs_per_block);
+  BlockDynamicSparsityPattern dsp (partitioning);
   DoFTools::make_sparsity_pattern (dof_handler, dsp, constraints, false);
 
   matrix.clear();
   // vector.clear();
   matrix.reinit (dsp);
-  vector.reinit (dofs_per_block);
+  vector.reinit (partitioning);
 
   // Assemble system: Mass matrix and constrant RHS vector
   FEValues<dim> fe_values (fe, quadrature_formula,
@@ -136,11 +139,11 @@ void build_matrix_vector(TrilinosWrappers::BlockSparseMatrix &matrix,
 }
 
 void evaluate_ops (const TrilinosWrappers::BlockSparseMatrix &matrix,
-                   const TrilinosWrappers::BlockVector       &vector)
+                   const TrilinosWrappers::MPI::BlockVector       &vector)
 {
   const double tol = 1e-12;
   typedef dealii::TrilinosWrappers::SparseMatrix MatrixType;
-  typedef dealii::TrilinosWrappers::Vector       VectorType;
+  typedef dealii::TrilinosWrappers::MPI::Vector       VectorType;
   typedef dealii::TrilinosWrappers::internal::LinearOperator::TrilinosPayload PayloadType;
   typedef typename PayloadType::VectorType       PayloadVectorType;
   typedef dealii::types::global_dof_index        size_type;
@@ -440,7 +443,7 @@ int main(int argc, char *argv[])
   FE_Q<dim>            fe_trial  (1);
 
   TrilinosWrappers::BlockSparseMatrix A;
-  TrilinosWrappers::BlockVector       b;
+  TrilinosWrappers::MPI::BlockVector       b;
 
   deallog.push("Square");
   build_matrix_vector<dim>(A,b,fe_test_1,fe_trial);

diff --git a/tests/lac/linear_operator_14.cc b/tests/lac/linear_operator_14.cc
index faa3bc15a5937c947b595878ba6c38e9580f016b..4b9c3394e93b30f4dc4b05f4d89202ed6f90aaa3 100644 (file)
--- a/tests/lac/linear_operator_14.cc
+++ b/tests/lac/linear_operator_14.cc
@@ -41,7 +41,7 @@
 #include <deal.II/lac/sparsity_tools.h>
 
 #include <deal.II/lac/trilinos_block_sparse_matrix.h>
-#include <deal.II/lac/trilinos_block_vector.h>
+#include <deal.II/lac/trilinos_parallel_block_vector.h>
 #include <deal.II/lac/trilinos_precondition.h>
 #include <deal.II/lac/trilinos_solver.h>
 #include <deal.II/lac/trilinos_sparsity_pattern.h>

diff --git a/tests/lac/linear_operator_15.cc b/tests/lac/linear_operator_15.cc
index 3ce60dcfdab2a3605b312841b8ad45c71b3ffebf..600012a8cd2f8fe073dfdefe736fe5db40ecf0a2 100644 (file)
--- a/tests/lac/linear_operator_15.cc
+++ b/tests/lac/linear_operator_15.cc
@@ -69,18 +69,18 @@ int main (int argc, char *argv[])
     A.reinit(csp);
     testproblem.five_point(A);
 
-    TrilinosWrappers::Vector  f;
-    f.reinit(dim);
-    TrilinosWrappers::Vector  u;
-    u.reinit(dim);
+    TrilinosWrappers::MPI::Vector f;
+    f.reinit(complete_index_set(dim));
+    TrilinosWrappers::MPI::Vector u;
+    u.reinit(complete_index_set(dim));
 
     A.compress (VectorOperation::insert);
     f.compress (VectorOperation::insert);
     u.compress (VectorOperation::insert);
 
-    const auto lo_A = linear_operator<TrilinosWrappers::Vector>(A);
-    const auto lo_id_1 = identity_operator<TrilinosWrappers::Vector>(lo_A.reinit_range_vector);
-    const auto lo_id_2 = identity_operator<TrilinosWrappers::Vector>(lo_A);
+    const auto lo_A = linear_operator<TrilinosWrappers::MPI::Vector>(A);
+    const auto lo_id_1 = identity_operator<TrilinosWrappers::MPI::Vector>(lo_A.reinit_range_vector);
+    const auto lo_id_2 = identity_operator<TrilinosWrappers::MPI::Vector>(lo_A);
     const auto lo_A_plus_id_1 = lo_A + lo_id_1; // Not a good idea. See below.
     const auto lo_A_plus_id_2 = lo_A + lo_id_2;
 

diff --git a/tests/lac/linear_operator_16.cc b/tests/lac/linear_operator_16.cc
index ad39b238b81345c82d0b2c8cde7f5b328d953b6a..9aea734861dd874adc491ff0e092299ee7e6a1c2 100644 (file)
--- a/tests/lac/linear_operator_16.cc
+++ b/tests/lac/linear_operator_16.cc
@@ -69,16 +69,16 @@ int main (int argc, char *argv[])
     A.reinit(csp);
     testproblem.five_point(A);
 
-    TrilinosWrappers::Vector  f;
-    f.reinit(dim);
-    TrilinosWrappers::Vector  u;
-    u.reinit(dim);
+    TrilinosWrappers::MPI::Vector f;
+    f.reinit(complete_index_set(dim));
+    TrilinosWrappers::MPI::Vector u;
+    u.reinit(complete_index_set(dim));
 
     A.compress (VectorOperation::insert);
     f.compress (VectorOperation::insert);
     u.compress (VectorOperation::insert);
 
-    const auto lo_A = linear_operator<TrilinosWrappers::Vector>(A);
+    const auto lo_A = linear_operator<TrilinosWrappers::MPI::Vector>(A);
     const auto lo_null = null_operator(lo_A);
     const auto lo_A_plus_null = lo_A + lo_null;
 

diff --git a/tests/lac/schur_complement_04.cc b/tests/lac/schur_complement_04.cc
index 099c8729ec0f9a84594b4c7bebd4f801db015c0e..bcf964c4d18486310553ff0f17ed5cf67d851930 100644 (file)
--- a/tests/lac/schur_complement_04.cc
+++ b/tests/lac/schur_complement_04.cc
@@ -20,7 +20,7 @@
 
 #include <deal.II/lac/trilinos_sparsity_pattern.h>
 #include <deal.II/lac/trilinos_block_sparse_matrix.h>
-#include <deal.II/lac/trilinos_block_vector.h>
+#include <deal.II/lac/trilinos_parallel_block_vector.h>
 #include <deal.II/lac/trilinos_sparse_matrix.h>
 #include <deal.II/lac/trilinos_vector.h>
 #include <deal.II/lac/trilinos_precondition.h>
@@ -95,7 +95,7 @@ int main(int argc,char **argv)
        */
 
       const unsigned int rc=1;
-      typedef TrilinosWrappers::Vector VectorType;
+      typedef TrilinosWrappers::MPI::Vector VectorType;
 
       TrilinosWrappers::SparseMatrix A (rc,rc,rc);
       TrilinosWrappers::SparseMatrix B (rc,rc,rc);
@@ -103,9 +103,9 @@ int main(int argc,char **argv)
       TrilinosWrappers::SparseMatrix D (rc,rc,rc);
 
       VectorType y;
-      y.reinit(rc);
+      y.reinit(complete_index_set(rc));
       VectorType g;
-      g.reinit(rc);
+      g.reinit(complete_index_set(rc));
       for (unsigned int i=0; i < rc; ++i)
         {
           A.set(i,i, 1.0*(i+1));

diff --git a/tests/lac/vector_reinit_02.cc b/tests/lac/vector_reinit_02.cc
index fcb8aabaea88b2fe2386a478448febf88ed9c87b..6a2adaea33ee2350d12c67d8aafebb290ead2a05 100644 (file)
--- a/tests/lac/vector_reinit_02.cc
+++ b/tests/lac/vector_reinit_02.cc
@@ -103,6 +103,6 @@ int main (int argc, char **argv)
 
   initlog();
 
-  do_test<TrilinosWrappers::Vector>();
+  do_test<TrilinosWrappers::MPI::Vector>();
   do_test<TrilinosWrappers::MPI::Vector>();
 }

diff --git a/tests/lac/vector_type_traits_is_serial_02.cc b/tests/lac/vector_type_traits_is_serial_02.cc
index e263ef94d427702c1753c2761f031379c5aea285..ab3bcfede8814d2c1cb50d54c2840d584ab74f13 100644 (file)
--- a/tests/lac/vector_type_traits_is_serial_02.cc
+++ b/tests/lac/vector_type_traits_is_serial_02.cc
@@ -19,35 +19,25 @@
 
 #include "../tests.h"
 #include <deal.II/lac/trilinos_vector.h>
-#include <deal.II/lac/trilinos_block_vector.h>
+#include <deal.II/lac/trilinos_parallel_block_vector.h>
 #include <fstream>
 #include <iomanip>
 
 void test ()
 {
-  // make sure that is_serial_vector< dealii::TrilinosWrappers::Vector > is working
-  Assert (is_serial_vector< dealii::TrilinosWrappers::Vector >::value == true,
-          ExcInternalError());
-
+  // make sure that is_serial_vector< dealii::TrilinosWrappers::MPI::Vector > is working
   Assert (is_serial_vector< dealii::TrilinosWrappers::MPI::Vector >::value == false,
           ExcInternalError());
 
-  deallog << is_serial_vector< dealii::TrilinosWrappers::Vector >::value << std::endl;
-
   deallog << is_serial_vector< dealii::TrilinosWrappers::MPI::Vector >::value << std::endl;
 
   deallog << "OK" << std::endl << std::endl;
 
 
-  // make sure that dealii::TrilinosWrappers::BlockVector > is working
-  Assert (is_serial_vector< dealii::TrilinosWrappers::BlockVector >::value == true,
-          ExcInternalError());
-
+  // make sure that dealii::TrilinosWrappers::MPI::BlockVector > is working
   Assert (is_serial_vector< dealii::TrilinosWrappers::MPI::BlockVector >::value == false,
           ExcInternalError());
 
-  deallog << is_serial_vector< dealii::TrilinosWrappers::BlockVector >::value << std::endl;
-
   deallog << is_serial_vector< dealii::TrilinosWrappers::MPI::BlockVector >::value << std::endl;
 
   deallog << "OK" << std::endl;

diff --git a/tests/lac/vector_type_traits_is_serial_02.with_trilinos=true.with_mpi=true.output b/tests/lac/vector_type_traits_is_serial_02.with_trilinos=true.with_mpi=true.output
index 9536f3b0eb21d58e289aae24c5fce360ad9e71a5..fcf7cc7bea379ee53e602bd58baf4a119210e0e2 100644 (file)
--- a/tests/lac/vector_type_traits_is_serial_02.with_trilinos=true.with_mpi=true.output
+++ b/tests/lac/vector_type_traits_is_serial_02.with_trilinos=true.with_mpi=true.output
@@ -1,8 +1,6 @@
 
-DEAL::1
 DEAL::0
 DEAL::OK
 DEAL::
-DEAL::1
 DEAL::0
 DEAL::OK

diff --git a/tests/mpi/p4est_2d_constraintmatrix_03.cc b/tests/mpi/p4est_2d_constraintmatrix_03.cc
index c9f7c72771c327c0a65ac4650da1fe7ecd64bc4f..5745300b0876e3841f311101736d9d51a74e7fd8 100644 (file)
--- a/tests/mpi/p4est_2d_constraintmatrix_03.cc
+++ b/tests/mpi/p4est_2d_constraintmatrix_03.cc
@@ -198,9 +198,9 @@ void test()
   std::ofstream output (filename.c_str());
   data_out.write_deal_II_intermediate (output);
 
-  TrilinosWrappers::Vector x_dub;
-  x_dub.reinit(dof_set.size());
-  x_dub = x_rel;
+  TrilinosWrappers::MPI::Vector x_dub;
+  x_dub.reinit(complete_index_set(dof_set.size()));
+  x_dub.reinit(x_rel, false, true);
 
   if (myid==0)
     {

diff --git a/tests/mpi/p4est_3d_constraintmatrix_02.cc b/tests/mpi/p4est_3d_constraintmatrix_02.cc
index 8115593388e8afe7617f5ce57a34c3b415014c9a..5bfb9509252282da04d5b754a4791665907ad631 100644 (file)
--- a/tests/mpi/p4est_3d_constraintmatrix_02.cc
+++ b/tests/mpi/p4est_3d_constraintmatrix_02.cc
@@ -91,14 +91,9 @@ void test()
   cm.distribute(x);
   x_rel = x;
 
-  //x.print(std::cout);
-
-//  x_rel.print(std::cout);
-
-  TrilinosWrappers::Vector x_dub;
-  x_dub.reinit(dof_set.size());
-
-  x_dub = x_rel;
+  TrilinosWrappers::MPI::Vector x_dub;
+  x_dub.reinit(complete_index_set(dof_set.size()));
+  x_dub.reinit(x_rel, false, true);
 
   {
     std::stringstream out;

diff --git a/tests/mpi/p4est_3d_constraintmatrix_03.cc b/tests/mpi/p4est_3d_constraintmatrix_03.cc
index 0392005f1db408ea3c95eaeea18a54ef0ff4399b..f04d5ab5fabbb0db16d3432cf661fe7c5d0e15d9 100644 (file)
--- a/tests/mpi/p4est_3d_constraintmatrix_03.cc
+++ b/tests/mpi/p4est_3d_constraintmatrix_03.cc
@@ -38,7 +38,7 @@
 #include <deal.II/dofs/dof_accessor.h>
 #include <deal.II/grid/tria_boundary_lib.h>
 #include <deal.II/numerics/data_out.h>
-#include <deal.II/lac/trilinos_block_vector.h>
+#include <deal.II/lac/trilinos_parallel_block_vector.h>
 
 #include <deal.II/fe/fe_q.h>
 #include <deal.II/fe/fe_system.h>

diff --git a/tests/quick_tests/step-trilinos.cc b/tests/quick_tests/step-trilinos.cc
index cfa32a42d9f7e62e91c08e6a24aa8d7cdc14bc5a..aba3202584c08d4af030c17fc4fc493529cb64e4 100644 (file)
--- a/tests/quick_tests/step-trilinos.cc
+++ b/tests/quick_tests/step-trilinos.cc
@@ -61,7 +61,7 @@ private:
   DoFHandler<2>    dof_handler;\r
 \r
   TrilinosWrappers::SparseMatrix A;\r
-  TrilinosWrappers::Vector       b, x;\r
+  TrilinosWrappers::MPI::Vector  b, x;\r
   ConstraintMatrix            constraints;\r
 \r
   TableHandler output_table;\r
@@ -159,7 +159,7 @@ void LaplaceProblem::solve ()
   preconditioner.initialize (A);\r
   cg_solver.solve (A, x, b, preconditioner);\r
 \r
-  TrilinosWrappers::Vector res(x);\r
+  TrilinosWrappers::MPI::Vector res(x);\r
   A.residual(res,x,b);\r
   AssertThrow(res.l2_norm()<1e-3,\r
               ExcInternalError());\r

diff --git a/tests/trilinos/11.cc b/tests/trilinos/11.cc
index 2b6fc244a47c0cec69aeb1e601d2948259c36d0b..e78a9926d3444b3778b43ffcb3cff240bd9fa7df 100644 (file)
--- a/tests/trilinos/11.cc
+++ b/tests/trilinos/11.cc
@@ -24,7 +24,7 @@
 #include <iostream>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   // set only certain elements of the vector
   for (unsigned int i=0; i<v.size(); i+=1+i)
@@ -51,8 +51,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/12.cc b/tests/trilinos/12.cc
index bdc829011e295df0934e5f53952d8120f7f9f8ae..97cd0c89b6d9142ca6a5c13e6e45b27101902314 100644 (file)
--- a/tests/trilinos/12.cc
+++ b/tests/trilinos/12.cc
@@ -25,7 +25,7 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   // set only certain elements of the
   // vector. have a bit pattern of where we
@@ -64,8 +64,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/13.cc b/tests/trilinos/13.cc
index 6bf65b5ee6b9466fab350ff6e7e230480902dfe3..71c462b17986a1a1ab50814cadaab0dd8d389cd2 100644 (file)
--- a/tests/trilinos/13.cc
+++ b/tests/trilinos/13.cc
@@ -25,7 +25,7 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   // set only certain elements of the
   // vector. have a bit pattern of where we
@@ -64,8 +64,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/14.cc b/tests/trilinos/14.cc
index a29e3e93be38ffcba39c92f3ea83160e3eead514..8a7593427913432fa33a32f3b8b409efab6d9bcd 100644 (file)
--- a/tests/trilinos/14.cc
+++ b/tests/trilinos/14.cc
@@ -40,7 +40,7 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   // set only certain elements of the
   // vector. have a bit pattern of where we
@@ -83,8 +83,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/15.cc b/tests/trilinos/15.cc
index 940f492eca45c95ff0d8f3018c7fa15550baad32..43b5b206852bc12581c1cbcdea065a10fb195e67 100644 (file)
--- a/tests/trilinos/15.cc
+++ b/tests/trilinos/15.cc
@@ -42,7 +42,7 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   // set only certain elements of the
   // vector. have a bit pattern of where we
@@ -82,8 +82,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/16.cc b/tests/trilinos/16.cc
index 238aa92e9e30ff3d50275a4d8a14805261848ef9..8e3c5cd436d6588028c85e3fdab0e279f444b479 100644 (file)
--- a/tests/trilinos/16.cc
+++ b/tests/trilinos/16.cc
@@ -42,7 +42,7 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   // set only certain elements of the
   // vector. have a bit pattern of where we
@@ -83,8 +83,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/17.cc b/tests/trilinos/17.cc
index 03007ee4c4678019d592d93a27326c7934ab1edb..c2793945a4d0cab5e07d436443d6679a428fe968 100644 (file)
--- a/tests/trilinos/17.cc
+++ b/tests/trilinos/17.cc
@@ -25,7 +25,7 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   // set some elements of the vector
   double norm = 0;
@@ -56,8 +56,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/18.cc b/tests/trilinos/18.cc
index eddf0c3229f64a2034cb314d51975c1a400c22c3..3f100275a2e62274ce479301c87f696fd77de63d 100644 (file)
--- a/tests/trilinos/18.cc
+++ b/tests/trilinos/18.cc
@@ -25,7 +25,7 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   // set some elements of the vector
   TrilinosScalar norm = 0;
@@ -57,8 +57,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/19.cc b/tests/trilinos/19.cc
index 620adf865d5d8096f6b6da43f213a9764ea72019..102a4d7bf93198b6c4a8af79b9130fb54ee4688f 100644 (file)
--- a/tests/trilinos/19.cc
+++ b/tests/trilinos/19.cc
@@ -25,7 +25,7 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   // set some elements of the vector
   double norm = 0;
@@ -56,8 +56,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/20.cc b/tests/trilinos/20.cc
index 70dd6c64566e628319f8a21ef93262ec476f40e7..d59c74e3fb5ff3d862db4b5fe548ae8f560f5d43 100644 (file)
--- a/tests/trilinos/20.cc
+++ b/tests/trilinos/20.cc
@@ -25,7 +25,7 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   // set only certain elements of the
   // vector. have a bit pattern of where we
@@ -65,8 +65,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/21.cc b/tests/trilinos/21.cc
index e3e1d692502216844fe47c25e82162974ffedb1a..f136077837e7b1d98b8603513b90f0cbcdc3cd5a 100644 (file)
--- a/tests/trilinos/21.cc
+++ b/tests/trilinos/21.cc
@@ -25,7 +25,7 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   // set only certain elements of the
   // vector. have a bit pattern of where we
@@ -65,8 +65,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/22.cc b/tests/trilinos/22.cc
index c2602f41118ee7b1a90ab53fcda81defb6b60c48..df94b6c83dae0b754196f4a2ff719e982340bdc9 100644 (file)
--- a/tests/trilinos/22.cc
+++ b/tests/trilinos/22.cc
@@ -26,8 +26,8 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v,
-           TrilinosWrappers::Vector &w)
+void test (TrilinosWrappers::MPI::Vector &v,
+           TrilinosWrappers::MPI::Vector &w)
 {
   // set only certain elements of each
   // vector, but disjoint sets of elements
@@ -59,10 +59,10 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
-        TrilinosWrappers::Vector w;
-        w.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
+        TrilinosWrappers::MPI::Vector w;
+        w.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v,w);
       }
     }

diff --git a/tests/trilinos/23.cc b/tests/trilinos/23.cc
index 8bbfcaf943d065d06511cf6d81a26c3de9f76f7c..113cf16d1508e31388c0e41e82fc88f7af6be2dd 100644 (file)
--- a/tests/trilinos/23.cc
+++ b/tests/trilinos/23.cc
@@ -26,8 +26,8 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v,
-           TrilinosWrappers::Vector &w)
+void test (TrilinosWrappers::MPI::Vector &v,
+           TrilinosWrappers::MPI::Vector &w)
 {
   // set only certain elements of each
   // vector, and record the expected scalar
@@ -66,10 +66,10 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
-        TrilinosWrappers::Vector w;
-        w.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
+        TrilinosWrappers::MPI::Vector w;
+        w.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v,w);
       }
     }

diff --git a/tests/trilinos/24.cc b/tests/trilinos/24.cc
index 4a1fc3659bb7f3a55b6ad8fb44239200a3a214fc..d8876a3e56e865795f20c3ec94e3b15c785dfbf2 100644 (file)
--- a/tests/trilinos/24.cc
+++ b/tests/trilinos/24.cc
@@ -27,7 +27,7 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   // set some entries of the vector
   for (unsigned int i=0; i<v.size(); ++i)
@@ -59,8 +59,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/26.cc b/tests/trilinos/26.cc
index 9cf9acb560029d0a5f4e18e29e6fcfb7cdddf891..2ea7879fd072b6a434bee0ac5fa273b77d6d6ecf 100644 (file)
--- a/tests/trilinos/26.cc
+++ b/tests/trilinos/26.cc
@@ -26,7 +26,7 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   // set some entries of the vector
   for (unsigned int i=0; i<v.size(); ++i)
@@ -56,8 +56,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/27.cc b/tests/trilinos/27.cc
index 414197fe5589ec7cc99f65054165fcaf0afa9925..92b7410137cc843454a8cae4fa69df1dce95b460 100644 (file)
--- a/tests/trilinos/27.cc
+++ b/tests/trilinos/27.cc
@@ -25,7 +25,7 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   // set some entries of the vector
   for (unsigned int i=0; i<v.size(); ++i)
@@ -34,8 +34,8 @@ void test (TrilinosWrappers::Vector &v)
   v.compress (VectorOperation::insert);
 
   // then copy it
-  TrilinosWrappers::Vector w;
-  w.reinit(v.size());
+  TrilinosWrappers::MPI::Vector w;
+  w.reinit(complete_index_set(v.size()), MPI_COMM_WORLD);
   w = v;
 
   // make sure they're equal
@@ -62,8 +62,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/28.cc b/tests/trilinos/28.cc
index 2fcf5feac4ff221635db27d2a5996f50e100f4df..ce5b4bf096db15f5d465fecbff15a5f24df837fc 100644 (file)
--- a/tests/trilinos/28.cc
+++ b/tests/trilinos/28.cc
@@ -26,7 +26,7 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   // set some entries of the vector
   for (unsigned int i=0; i<v.size(); ++i)
@@ -36,8 +36,8 @@ void test (TrilinosWrappers::Vector &v)
 
   // then copy it to a vector of different
   // size
-  TrilinosWrappers::Vector w;
-  w.reinit(1);
+  TrilinosWrappers::MPI::Vector w;
+  w.reinit(complete_index_set(1), MPI_COMM_WORLD);
   w = v;
 
   // make sure they're equal
@@ -64,8 +64,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/29.cc b/tests/trilinos/29.cc
index 31a9a7b2817845c136a9a5bef22c2364495c4c49..983e447338a090d6edf73df54da0bb7827a2c9f9 100644 (file)
--- a/tests/trilinos/29.cc
+++ b/tests/trilinos/29.cc
@@ -25,9 +25,9 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
-  v.reinit (13);
+  v.reinit (complete_index_set(13), MPI_COMM_WORLD);
 
   AssertThrow (v.size() == 13, ExcInternalError());
 
@@ -48,8 +48,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/30.cc b/tests/trilinos/30.cc
index bc11b46186f5299ff9c8ba51b6433819313d738f..5561ff8f38ef4f861e236a5091f71cd06e42318a 100644 (file)
--- a/tests/trilinos/30.cc
+++ b/tests/trilinos/30.cc
@@ -25,7 +25,7 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   // set some entries of the vector
   for (unsigned int i=0; i<v.size(); ++i)
@@ -34,7 +34,7 @@ void test (TrilinosWrappers::Vector &v)
   v.compress (VectorOperation::insert);
 
   // then resize with setting to zero
-  v.reinit (13);
+  v.reinit (complete_index_set(13), MPI_COMM_WORLD);
 
   AssertThrow (v.size() == 13, ExcInternalError());
   AssertThrow (v.l2_norm() == 0, ExcInternalError());
@@ -56,8 +56,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/31.cc b/tests/trilinos/31.cc
index 35e767abbee37201cbe1c9e33aa182c599f30b71..6edd087aa43268679be02daa242ce517550caa67 100644 (file)
--- a/tests/trilinos/31.cc
+++ b/tests/trilinos/31.cc
@@ -25,7 +25,7 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   // set some elements of the vector
   TrilinosScalar norm = 0;
@@ -58,8 +58,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/32.cc b/tests/trilinos/32.cc
index dd720c444b07a6c1fc68c982c7e9e6662423e6af..78f045b32d972efb59ef4e4e7b2577da1282677b 100644 (file)
--- a/tests/trilinos/32.cc
+++ b/tests/trilinos/32.cc
@@ -25,7 +25,7 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   // set some elements of the vector
   TrilinosScalar sum = 0;
@@ -58,8 +58,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/33.cc b/tests/trilinos/33.cc
index 971b32a9bec802665e2e26d03d033086f62269f8..d931e452d33dbc74d156109b6be4d1e6d23e6553 100644 (file)
--- a/tests/trilinos/33.cc
+++ b/tests/trilinos/33.cc
@@ -25,7 +25,7 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   // set some elements of the vector
   TrilinosScalar sum = 0;
@@ -59,8 +59,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/34.cc b/tests/trilinos/34.cc
index 46e0e1f152af67b009cd370c68242c29d4137736..636aa93c79908e05c0a746790f8651d1c7dca1ab 100644 (file)
--- a/tests/trilinos/34.cc
+++ b/tests/trilinos/34.cc
@@ -25,7 +25,7 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   // set some elements of the vector
   double sum = 0;
@@ -59,8 +59,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/35.cc b/tests/trilinos/35.cc
index ebfa518a1569803d8736cf92b31ef0f56f4bbf30..b077dcfdb6393480e6a7f45b4cc55838590c2a99 100644 (file)
--- a/tests/trilinos/35.cc
+++ b/tests/trilinos/35.cc
@@ -25,8 +25,8 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v,
-           TrilinosWrappers::Vector &w)
+void test (TrilinosWrappers::MPI::Vector &v,
+           TrilinosWrappers::MPI::Vector &w)
 {
   // set only certain elements of each
   // vector
@@ -75,10 +75,10 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
-        TrilinosWrappers::Vector w;
-        w.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
+        TrilinosWrappers::MPI::Vector w;
+        w.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v,w);
       }
     }

diff --git a/tests/trilinos/36.cc b/tests/trilinos/36.cc
index 3ca2e2f63408fc5f00acda2efff2becd797a1c1b..2dd9959c6ded2524a3ef13beb190597fe8eb2177 100644 (file)
--- a/tests/trilinos/36.cc
+++ b/tests/trilinos/36.cc
@@ -25,8 +25,8 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v,
-           TrilinosWrappers::Vector &w)
+void test (TrilinosWrappers::MPI::Vector &v,
+           TrilinosWrappers::MPI::Vector &w)
 {
   // set only certain elements of each
   // vector
@@ -75,10 +75,10 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
-        TrilinosWrappers::Vector w;
-        w.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
+        TrilinosWrappers::MPI::Vector w;
+        w.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v,w);
       }
     }

diff --git a/tests/trilinos/37.cc b/tests/trilinos/37.cc
index 1e0d1ed9e13eaae3eeb039af6527459e8e6b6025..dbcf99846b9a3c9d87d263973855828e8d6a6ceb 100644 (file)
--- a/tests/trilinos/37.cc
+++ b/tests/trilinos/37.cc
@@ -25,7 +25,7 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   for (unsigned int i=0; i<v.size(); ++i)
     v(i) = i;
@@ -55,8 +55,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/38.cc b/tests/trilinos/38.cc
index 777cd310716ce736526f7612b43625895c1c63a5..58337db9310c641a30d6b83d441ca70eb15dd44e 100644 (file)
--- a/tests/trilinos/38.cc
+++ b/tests/trilinos/38.cc
@@ -25,8 +25,8 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v,
-           TrilinosWrappers::Vector &w)
+void test (TrilinosWrappers::MPI::Vector &v,
+           TrilinosWrappers::MPI::Vector &w)
 {
   for (unsigned int i=0; i<v.size(); ++i)
     {
@@ -63,10 +63,10 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
-        TrilinosWrappers::Vector w;
-        w.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
+        TrilinosWrappers::MPI::Vector w;
+        w.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v,w);
       }
     }

diff --git a/tests/trilinos/39.cc b/tests/trilinos/39.cc
index cae40a51ebfad419de0c1fdec45811186260f213..30a3ca69058e5967b8adf308ef2c1485e478dd6d 100644 (file)
--- a/tests/trilinos/39.cc
+++ b/tests/trilinos/39.cc
@@ -25,8 +25,8 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v,
-           TrilinosWrappers::Vector &w)
+void test (TrilinosWrappers::MPI::Vector &v,
+           TrilinosWrappers::MPI::Vector &w)
 {
   for (unsigned int i=0; i<v.size(); ++i)
     {
@@ -63,10 +63,10 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
-        TrilinosWrappers::Vector w;
-        w.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
+        TrilinosWrappers::MPI::Vector w;
+        w.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v,w);
       }
     }

diff --git a/tests/trilinos/40.cc b/tests/trilinos/40.cc
index 4f37f92591d7ab1dc223032aa0df0045cae54cea..d89615ef34218d169449725e3dc6034e55250e32 100644 (file)
--- a/tests/trilinos/40.cc
+++ b/tests/trilinos/40.cc
@@ -25,9 +25,9 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v,
-           TrilinosWrappers::Vector &w,
-           TrilinosWrappers::Vector &x)
+void test (TrilinosWrappers::MPI::Vector &v,
+           TrilinosWrappers::MPI::Vector &w,
+           TrilinosWrappers::MPI::Vector &x)
 {
   for (unsigned int i=0; i<v.size(); ++i)
     {
@@ -67,12 +67,12 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
-        TrilinosWrappers::Vector w;
-        w.reinit(100);
-        TrilinosWrappers::Vector x;
-        x.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
+        TrilinosWrappers::MPI::Vector w;
+        w.reinit(complete_index_set(100), MPI_COMM_WORLD);
+        TrilinosWrappers::MPI::Vector x;
+        x.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v,w,x);
       }
     }

diff --git a/tests/trilinos/41.cc b/tests/trilinos/41.cc
index 435dd7cdb1e1a44e541f2748f084223e367c775f..cdcbbd18e5e40500fd0b6cfa6411121adf3db498 100644 (file)
--- a/tests/trilinos/41.cc
+++ b/tests/trilinos/41.cc
@@ -25,8 +25,8 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v,
-           TrilinosWrappers::Vector &w)
+void test (TrilinosWrappers::MPI::Vector &v,
+           TrilinosWrappers::MPI::Vector &w)
 {
   for (unsigned int i=0; i<v.size(); ++i)
     {
@@ -63,10 +63,10 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
-        TrilinosWrappers::Vector w;
-        w.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
+        TrilinosWrappers::MPI::Vector w;
+        w.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v,w);
       }
     }

diff --git a/tests/trilinos/42.cc b/tests/trilinos/42.cc
index bfc50975da98e1f20e8ae95397b1054332b48497..40aa69d6adefbeb6b5059940dd2db81c36f76e38 100644 (file)
--- a/tests/trilinos/42.cc
+++ b/tests/trilinos/42.cc
@@ -25,8 +25,8 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v,
-           TrilinosWrappers::Vector &w)
+void test (TrilinosWrappers::MPI::Vector &v,
+           TrilinosWrappers::MPI::Vector &w)
 {
   for (unsigned int i=0; i<v.size(); ++i)
     {
@@ -63,10 +63,10 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
-        TrilinosWrappers::Vector w;
-        w.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
+        TrilinosWrappers::MPI::Vector w;
+        w.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v,w);
       }
     }

diff --git a/tests/trilinos/45.cc b/tests/trilinos/45.cc
index b78fcdd00ef64d659adc01acd89df73418a03dff..ba92a4ebb082a82e766f022a912126711a8a4026 100644 (file)
--- a/tests/trilinos/45.cc
+++ b/tests/trilinos/45.cc
@@ -25,8 +25,8 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v,
-           TrilinosWrappers::Vector &w)
+void test (TrilinosWrappers::MPI::Vector &v,
+           TrilinosWrappers::MPI::Vector &w)
 {
   for (unsigned int i=0; i<v.size(); ++i)
     {
@@ -63,10 +63,10 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
-        TrilinosWrappers::Vector w;
-        w.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
+        TrilinosWrappers::MPI::Vector w;
+        w.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v,w);
       }
     }

diff --git a/tests/trilinos/46.cc b/tests/trilinos/46.cc
index 85cff86f096cfcc0a1a167cc1a9ecae9a31fc212..3e4288d5ed811d5f4bfc920af89f32d27ab76282 100644 (file)
--- a/tests/trilinos/46.cc
+++ b/tests/trilinos/46.cc
@@ -25,8 +25,8 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v,
-           TrilinosWrappers::Vector &w)
+void test (TrilinosWrappers::MPI::Vector &v,
+           TrilinosWrappers::MPI::Vector &w)
 {
   for (unsigned int i=0; i<v.size(); ++i)
     {
@@ -63,10 +63,10 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
-        TrilinosWrappers::Vector w;
-        w.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
+        TrilinosWrappers::MPI::Vector w;
+        w.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v,w);
       }
     }

diff --git a/tests/trilinos/49.cc b/tests/trilinos/49.cc
index b4a0e2ca32f77314693c3489a7ccf7317ba1a671..af74a27e82eb0868d5722f4118e563b2c135cac2 100644 (file)
--- a/tests/trilinos/49.cc
+++ b/tests/trilinos/49.cc
@@ -26,7 +26,7 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   dealii::Vector<TrilinosScalar> w (v.size());
 
@@ -60,8 +60,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/49a.cc b/tests/trilinos/49a.cc
index 433417dfe9a31653da7cbc337ad13cb6e2080f2d..2b87c772960b42be2cb5cb04f2e6cb724aef0801 100644 (file)
--- a/tests/trilinos/49a.cc
+++ b/tests/trilinos/49a.cc
@@ -16,20 +16,20 @@
 
 
 // like 49, but do the test for
-//  TrilinosWrappers::BlockVector
+//  TrilinosWrappers::MPI::BlockVector
 //         ::operator = (dealii::BlockVector<TrilinosScalar>)
 // with block vectors instead of plain vectors
 
 #include "../tests.h"
 #include <deal.II/base/utilities.h>
-#include <deal.II/lac/trilinos_block_vector.h>
+#include <deal.II/lac/trilinos_parallel_block_vector.h>
 #include <deal.II/lac/block_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (TrilinosWrappers::BlockVector &v)
+void test (TrilinosWrappers::MPI::BlockVector &v)
 {
   std::vector<types::global_dof_index> sizes (2, 3);
   dealii::BlockVector<TrilinosScalar> w;
@@ -75,8 +75,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        std::vector<types::global_dof_index> sizes (2, 3);
-        TrilinosWrappers::BlockVector v;
+        std::vector<IndexSet> sizes (2, complete_index_set(3));
+        TrilinosWrappers::MPI::BlockVector v;
         v.reinit(sizes);
         test (v);
       }

diff --git a/tests/trilinos/49b.cc b/tests/trilinos/49b.cc
index a88abebc3389e9659f070096c5b0007bca0c5c36..df691cdcdfec08aca48946b31f5f54a0406f3943 100644 (file)
--- a/tests/trilinos/49b.cc
+++ b/tests/trilinos/49b.cc
@@ -22,7 +22,7 @@
 
 #include "../tests.h"
 #include <deal.II/base/utilities.h>
-#include <deal.II/lac/trilinos_block_vector.h>
+#include <deal.II/lac/trilinos_parallel_block_vector.h>
 #include <deal.II/lac/block_vector.h>
 #include <fstream>
 #include <iostream>
@@ -48,10 +48,7 @@ void test (TrilinosWrappers::MPI::BlockVector &v)
     }
 
   // now also check the reverse assignment
-  w = 0;
-  TrilinosWrappers::BlockVector v_serial;
-  v_serial.reinit(v);
-  w = v_serial;
+  w = v;
   for (unsigned int i=0; i<v.size(); ++i)
     {
       AssertThrow (w(i) == i, ExcInternalError());

diff --git a/tests/trilinos/50.cc b/tests/trilinos/50.cc
index 9dfbb7094edd86dfdecbd30f07e99570621f72ba..087742db0f15bf23412ee438e01ebd50d64bf442 100644 (file)
--- a/tests/trilinos/50.cc
+++ b/tests/trilinos/50.cc
@@ -26,7 +26,7 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   Vector<double> w (v.size());
   Vector<float>  x (v.size());
@@ -76,8 +76,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/51.cc b/tests/trilinos/51.cc
index e2f8fcfc61d9125bb1a3f5040f5c5624df1867c8..9ffb719de8eb670c99d19fd0d59e295470657b57 100644 (file)
--- a/tests/trilinos/51.cc
+++ b/tests/trilinos/51.cc
@@ -25,7 +25,7 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   // set some entries of the vector
   for (unsigned int i=0; i<v.size(); ++i)
@@ -34,7 +34,7 @@ void test (TrilinosWrappers::Vector &v)
   v.compress (VectorOperation::insert);
 
   // then copy it
-  TrilinosWrappers::Vector w (v);
+  TrilinosWrappers::MPI::Vector w (v);
   w.compress (VectorOperation::insert);
 
   // make sure they're equal
@@ -61,8 +61,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/53.cc b/tests/trilinos/53.cc
index 184fd1f362e9ddfbbe4e7017782dc4aa36475954..02d638ae96ac38d9a20395a241bfcc1de7fce92b 100644 (file)
--- a/tests/trilinos/53.cc
+++ b/tests/trilinos/53.cc
@@ -25,7 +25,7 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   // set only certain elements of the
   // vector. have a bit pattern of where we
@@ -67,8 +67,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/54.cc b/tests/trilinos/54.cc
index 47d01b3d626e78eba7dbf8504981e59cddcfa48f..56bfb53c484bf06f16d18c28ce6ce9fb97695ce5 100644 (file)
--- a/tests/trilinos/54.cc
+++ b/tests/trilinos/54.cc
@@ -25,7 +25,7 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   // set only certain elements of the
   // vector. have a bit pattern of where we
@@ -67,8 +67,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/55.cc b/tests/trilinos/55.cc
index 2f4ce06a7c356d0e899fb7d6471f8e2bb5ba9c51..891be8b31f200976545aa31ccfe1ba8ba8042f88 100644 (file)
--- a/tests/trilinos/55.cc
+++ b/tests/trilinos/55.cc
@@ -25,7 +25,7 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   // set only certain elements of the
   // vector. have a bit pattern of where we
@@ -66,8 +66,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/56.cc b/tests/trilinos/56.cc
index da2adbcdb36f8eb66c5c780136f377b0af0bd152..0ec031edb09515963fbecd62a9bee5ed8b88507b 100644 (file)
--- a/tests/trilinos/56.cc
+++ b/tests/trilinos/56.cc
@@ -25,7 +25,7 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   // set only certain elements of the
   // vector. have a bit pattern of where we
@@ -66,8 +66,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/57.cc b/tests/trilinos/57.cc
index bbcc85f01c5b7e0441114abe734773da4036b383..058036557fe9cd51e7cb13cea95d078d176a3999 100644 (file)
--- a/tests/trilinos/57.cc
+++ b/tests/trilinos/57.cc
@@ -25,7 +25,7 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   // set only certain elements of the
   // vector. they are all positive
@@ -64,8 +64,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/58.cc b/tests/trilinos/58.cc
index cd1f84c369ff7a9ac349eb7f2bef4d979ecf840c..79021fd706abed8ed4cb798c8d13383b8c0f5386 100644 (file)
--- a/tests/trilinos/58.cc
+++ b/tests/trilinos/58.cc
@@ -15,7 +15,7 @@
 
 
 
-// check ::Vector (const TrilinosWrappers::Vector &) copy constructor
+// check ::Vector (const TrilinosWrappers::MPI::Vector &) copy constructor
 
 #include "../tests.h"
 #include <deal.II/base/utilities.h>
@@ -27,7 +27,7 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   // set only certain elements of the
   // vector.
@@ -66,8 +66,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/60.cc b/tests/trilinos/60.cc
index 100efa7c1207fd923b3f44de23dca2a81798fd42..65171f4b656c441bfad901d8e0a79b4a7e776352 100644 (file)
--- a/tests/trilinos/60.cc
+++ b/tests/trilinos/60.cc
@@ -15,7 +15,7 @@
 
 
 
-// check ::Vector::operator = (const TrilinosWrappers::Vector &)
+// check ::Vector::operator = (const TrilinosWrappers::MPI::Vector &)
 
 #include "../tests.h"
 #include <deal.II/base/utilities.h>
@@ -27,7 +27,7 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   // set only certain elements of the
   // vector.
@@ -68,8 +68,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/61.cc b/tests/trilinos/61.cc
index a3fc39bd2ab863dcd7c465f2662bbc8a046b8d9d..c714db808a42ea39601a5d6f0d21de1cc6ddc547 100644 (file)
--- a/tests/trilinos/61.cc
+++ b/tests/trilinos/61.cc
@@ -27,7 +27,7 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   // set only certain elements of the
   // vector.
@@ -45,11 +45,11 @@ void test (TrilinosWrappers::Vector &v)
   Vector<float>  x(v.size());
   x=v;
 
-  TrilinosWrappers::Vector w1;
-  w1.reinit(v.size());
+  TrilinosWrappers::MPI::Vector w1;
+  w1.reinit(complete_index_set(v.size()), MPI_COMM_WORLD);
   w1=w;
-  TrilinosWrappers::Vector x1;
-  x1.reinit(v.size());
+  TrilinosWrappers::MPI::Vector x1;
+  x1.reinit(complete_index_set(v.size()), MPI_COMM_WORLD);
   x1=x;
 
   for (unsigned int i=0; i<v.size(); ++i)
@@ -75,8 +75,8 @@ int main (int argc,char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/block_vector_iterator_01.cc b/tests/trilinos/block_vector_iterator_01.cc
index 10b63cd7cf8ba279e67f2433f2cce613b2309183..8f527ec69350be3089e951ea783bc6edcb39e521 100644 (file)
--- a/tests/trilinos/block_vector_iterator_01.cc
+++ b/tests/trilinos/block_vector_iterator_01.cc
@@ -19,17 +19,17 @@
 
 #include "../tests.h"
 #include <deal.II/base/utilities.h>
-#include <deal.II/lac/trilinos_block_vector.h>
+#include <deal.II/lac/trilinos_parallel_block_vector.h>
 #include <fstream>
 #include <iostream>
 
 
 void test ()
 {
-  TrilinosWrappers::BlockVector v;
+  TrilinosWrappers::MPI::BlockVector v;
   v.reinit(2);
   for (unsigned int i=0; i<v.n_blocks(); ++i)
-    v.block(i).reinit(1);
+    v.block(i).reinit(complete_index_set(1),MPI_COMM_WORLD);
   v.collect_sizes();
 
   v(0) = 1;
@@ -38,7 +38,7 @@ void test ()
   // first check reading through a const
   // iterator
   {
-    TrilinosWrappers::BlockVector::const_iterator i=v.begin();
+    TrilinosWrappers::MPI::BlockVector::const_iterator i=v.begin();
     AssertThrow (*i == 1, ExcInternalError());
     ++i;
     AssertThrow (*i == 2, ExcInternalError());
@@ -47,8 +47,8 @@ void test ()
   // same, but create iterator in a different
   // way
   {
-    TrilinosWrappers::BlockVector::const_iterator
-    i=const_cast<const TrilinosWrappers::BlockVector &>(v).begin();
+    TrilinosWrappers::MPI::BlockVector::const_iterator
+    i=const_cast<const TrilinosWrappers::MPI::BlockVector &>(v).begin();
     AssertThrow (*i == 1, ExcInternalError());
     ++i;
     AssertThrow (*i == 2, ExcInternalError());
@@ -56,7 +56,7 @@ void test ()
 
   // read through a read-write iterator
   {
-    TrilinosWrappers::BlockVector::iterator i = v.begin();
+    TrilinosWrappers::MPI::BlockVector::iterator i = v.begin();
     AssertThrow (*i == 1, ExcInternalError());
     ++i;
     AssertThrow (*i == 2, ExcInternalError());
@@ -64,7 +64,7 @@ void test ()
 
   // write through a read-write iterator
   {
-    TrilinosWrappers::BlockVector::iterator i = v.begin();
+    TrilinosWrappers::MPI::BlockVector::iterator i = v.begin();
 
     *i = 2;
     ++i;
@@ -73,7 +73,7 @@ void test ()
 
   // and read again
   {
-    TrilinosWrappers::BlockVector::iterator i = v.begin();
+    TrilinosWrappers::MPI::BlockVector::iterator i = v.begin();
     AssertThrow (*i == 2, ExcInternalError());
     ++i;
     AssertThrow (*i == 3, ExcInternalError());

diff --git a/tests/trilinos/block_vector_iterator_02.cc b/tests/trilinos/block_vector_iterator_02.cc
index 1ff7545eac72f20d5b0a01db1bc60b9f04a8d2c8..ae88f481f440ebaaad070707c1ed6a638c7c966a 100644 (file)
--- a/tests/trilinos/block_vector_iterator_02.cc
+++ b/tests/trilinos/block_vector_iterator_02.cc
@@ -19,17 +19,17 @@
 
 #include "../tests.h"
 #include <deal.II/base/utilities.h>
-#include <deal.II/lac/trilinos_block_vector.h>
+#include <deal.II/lac/trilinos_parallel_block_vector.h>
 #include <fstream>
 #include <iostream>
 
 
 void test ()
 {
-  TrilinosWrappers::BlockVector v;
+  TrilinosWrappers::MPI::BlockVector v;
   v.reinit(2);
   for (unsigned int i=0; i<v.n_blocks(); ++i)
-    v.block(i).reinit(1);
+    v.block(i).reinit(complete_index_set(1),MPI_COMM_WORLD);
   v.collect_sizes();
 
   v(0) = 1;
@@ -38,7 +38,7 @@ void test ()
   // first check reading through a const
   // iterator
   {
-    TrilinosWrappers::BlockVector::const_iterator i=v.begin();
+    TrilinosWrappers::MPI::BlockVector::const_iterator i=v.begin();
     AssertThrow (i[0] == 1, ExcInternalError());
     AssertThrow (i[1] == 2, ExcInternalError());
   }
@@ -46,29 +46,29 @@ void test ()
   // same, but create iterator in a different
   // way
   {
-    TrilinosWrappers::BlockVector::const_iterator
-    i=const_cast<const TrilinosWrappers::BlockVector &>(v).begin();
+    TrilinosWrappers::MPI::BlockVector::const_iterator
+    i=const_cast<const TrilinosWrappers::MPI::BlockVector &>(v).begin();
     AssertThrow (i[0] == 1, ExcInternalError());
     AssertThrow (i[1] == 2, ExcInternalError());
   }
 
   // read through a read-write iterator
   {
-    TrilinosWrappers::BlockVector::iterator i = v.begin();
+    TrilinosWrappers::MPI::BlockVector::iterator i = v.begin();
     AssertThrow (i[0] == 1, ExcInternalError());
     AssertThrow (i[1] == 2, ExcInternalError());
   }
 
   // write through a read-write iterator
   {
-    TrilinosWrappers::BlockVector::iterator i = v.begin();
+    TrilinosWrappers::MPI::BlockVector::iterator i = v.begin();
     i[0] = 2;
     i[1] = 3;
   }
 
   // and read again
   {
-    TrilinosWrappers::BlockVector::iterator i = v.begin();
+    TrilinosWrappers::MPI::BlockVector::iterator i = v.begin();
     AssertThrow (i[0] == 2, ExcInternalError());
     AssertThrow (i[1] == 3, ExcInternalError());
   }

diff --git a/tests/trilinos/block_vector_iterator_03.cc b/tests/trilinos/block_vector_iterator_03.cc
index 29e80db4e1ff4705f24cd3626e5f951e66330a76..635855301ad04005cf62bc88531704197626a48b 100644 (file)
--- a/tests/trilinos/block_vector_iterator_03.cc
+++ b/tests/trilinos/block_vector_iterator_03.cc
@@ -20,7 +20,7 @@
 #include "../tests.h"
 #include <deal.II/base/utilities.h>
 #include <deal.II/base/logstream.h>
-#include <deal.II/lac/trilinos_block_vector.h>
+#include <deal.II/lac/trilinos_parallel_block_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
@@ -30,8 +30,8 @@
 #include <cmath>
 
 template <typename number>
-bool operator == (const TrilinosWrappers::BlockVector &v1,
-                  const TrilinosWrappers::BlockVector &v2)
+bool operator == (const TrilinosWrappers::MPI::BlockVector &v1,
+                  const TrilinosWrappers::MPI::BlockVector &v2)
 {
   if (v1.size() != v2.size())
     return false;
@@ -44,19 +44,19 @@ bool operator == (const TrilinosWrappers::BlockVector &v1,
 
 void test ()
 {
-  std::vector<types::global_dof_index> ivector(4);
-  ivector[0] = 2;
-  ivector[1] = 4;
-  ivector[2] = 3;
-  ivector[3] = 5;
+  std::vector<IndexSet> ivector(4);
+  ivector[0] = complete_index_set(2);
+  ivector[1] = complete_index_set(4);
+  ivector[2] = complete_index_set(3);
+  ivector[3] = complete_index_set(5);
 
   // Check 1: initialization via
   // iterators
   if (true)
     {
-      TrilinosWrappers::BlockVector v1;
+      TrilinosWrappers::MPI::BlockVector v1;
       v1.reinit(ivector);
-      TrilinosWrappers::BlockVector v2;
+      TrilinosWrappers::MPI::BlockVector v2;
       v2.reinit(ivector);
 
       // initialize first vector with
@@ -65,7 +65,7 @@ void test ()
         v1(i) = i;
       // initialize other vector
       // through iterators
-      TrilinosWrappers::BlockVector::iterator p2 = v2.begin();
+      TrilinosWrappers::MPI::BlockVector::iterator p2 = v2.begin();
       for (unsigned int i=0; i<v1.size(); ++i, ++p2)
         *p2 = i;
       AssertThrow (p2==v2.end(), ExcInternalError());
@@ -79,14 +79,14 @@ void test ()
   // same
   if (true)
     {
-      TrilinosWrappers::BlockVector v1;
+      TrilinosWrappers::MPI::BlockVector v1;
       v1.reinit(ivector);
       // initialize first vector with
       // simple loop
       for (unsigned int i=0; i<v1.size(); ++i)
         v1(i) = i;
 
-      TrilinosWrappers::BlockVector::iterator p1 = v1.begin();
+      TrilinosWrappers::MPI::BlockVector::iterator p1 = v1.begin();
       for (unsigned int i=0; i<v1.size(); ++i, ++p1)
         AssertThrow (*p1 == i, ExcInternalError());
 
@@ -110,14 +110,14 @@ void test ()
   // with const iterators
   if (true)
     {
-      TrilinosWrappers::BlockVector v1;
+      TrilinosWrappers::MPI::BlockVector v1;
       v1.reinit(ivector);
       // initialize first vector with
       // simple loop
       for (unsigned int i=0; i<v1.size(); ++i)
         v1(i) = i;
 
-      TrilinosWrappers::BlockVector::const_iterator p1 = v1.begin();
+      TrilinosWrappers::MPI::BlockVector::const_iterator p1 = v1.begin();
       for (unsigned int i=0; i<v1.size(); ++i, ++p1)
         AssertThrow (*p1 == i, ExcInternalError());
 
@@ -144,7 +144,7 @@ void test ()
   // algorithms
   if (true)
     {
-      TrilinosWrappers::BlockVector v1;
+      TrilinosWrappers::MPI::BlockVector v1;
       v1.reinit(ivector);
       // initialize first vector with
       // simple loop
@@ -160,7 +160,7 @@ void test ()
               << std::endl;
 
       // check std::copy
-      TrilinosWrappers::BlockVector v2;
+      TrilinosWrappers::MPI::BlockVector v2;
       v2.reinit(ivector);
       std::copy (v1.begin(), v1.end(), v2.begin());
       deallog << "Check 6: " << (v1 == v2 ? "true" : "false") << std::endl;
@@ -197,11 +197,11 @@ void test ()
               << std::endl;
 
       // check advance
-      TrilinosWrappers::BlockVector::iterator p2 = v1.begin();
+      TrilinosWrappers::MPI::BlockVector::iterator p2 = v1.begin();
       std::advance (p2, v1.size());
       deallog << "Check 13: " << (p2 == v1.end() ? "true" : "false") << std::endl;
 
-      TrilinosWrappers::BlockVector::const_iterator p3 = v1.begin();
+      TrilinosWrappers::MPI::BlockVector::const_iterator p3 = v1.begin();
       std::advance (p3, v1.size());
       deallog << "Check 14: " << (p3 == v1.end() ? "true" : "false") << std::endl;
     };
@@ -209,14 +209,14 @@ void test ()
   // Check 15: operator[]
   if (true)
     {
-      TrilinosWrappers::BlockVector v1;
+      TrilinosWrappers::MPI::BlockVector v1;
       v1.reinit(ivector);
       for (unsigned int i=0; i<v1.size(); ++i)
         v1(i) = i;
 
       for (unsigned int i=0; i<v1.size(); ++i)
         {
-          const TrilinosWrappers::BlockVector::iterator p = (v1.begin()+i);
+          const TrilinosWrappers::MPI::BlockVector::iterator p = (v1.begin()+i);
           for (unsigned int j=0; j<v1.size(); ++j)
             AssertThrow (p[(signed)j-(signed)i] == j, ExcInternalError());
         };

diff --git a/tests/trilinos/deal_solver_01.cc b/tests/trilinos/deal_solver_01.cc
index d944d91830f124e73c614249eb84b205c3f37487..9d4630a8de92e3da631d625ff3e18a8a98a846fe 100644 (file)
--- a/tests/trilinos/deal_solver_01.cc
+++ b/tests/trilinos/deal_solver_01.cc
@@ -91,17 +91,17 @@ int main(int argc, char **argv)
     A.reinit(csp);
     testproblem.five_point(A);
 
-    TrilinosWrappers::Vector f;
-    f.reinit(dim);
-    TrilinosWrappers::Vector u;
-    u.reinit(dim);
+    TrilinosWrappers::MPI::Vector f;
+    f.reinit(complete_index_set(dim),MPI_COMM_WORLD);
+    TrilinosWrappers::MPI::Vector u;
+    u.reinit(complete_index_set(dim),MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
     f.compress (VectorOperation::insert);
     u.compress (VectorOperation::insert);
 
-    GrowingVectorMemory<TrilinosWrappers::Vector> mem;
-    SolverCG<TrilinosWrappers::Vector> solver(control, mem);
+    GrowingVectorMemory<TrilinosWrappers::MPI::Vector> mem;
+    SolverCG<TrilinosWrappers::MPI::Vector> solver(control, mem);
     PreconditionIdentity preconditioner;
     check_solve (solver, control, A,u,f, preconditioner);
   }

diff --git a/tests/trilinos/deal_solver_01.output b/tests/trilinos/deal_solver_01.output
index 2e7eaf8b3b02d5577103e091ccd6e888a9cda2f0..7e616e1e2f8c60a31618cf3ee85aa1da91186888 100644 (file)
--- a/tests/trilinos/deal_solver_01.output
+++ b/tests/trilinos/deal_solver_01.output
@@ -1,6 +1,6 @@
 
 DEAL::Size 32 Unknowns 961
-DEAL::Solver type: N6dealii8SolverCGINS_16TrilinosWrappers6VectorEEE
+DEAL::Solver type: N6dealii8SolverCGINS_16TrilinosWrappers3MPI6VectorEEE
 DEAL:cg::Starting value 31.0000
 DEAL:cg::Convergence step 43 value 0.000818932
 DEAL::Solver stopped after 43 iterations

diff --git a/tests/trilinos/deal_solver_02.cc b/tests/trilinos/deal_solver_02.cc
index 5c563aafcf9a8dde05907744cb82394fe2450fc3..7580bc1f58039cc3a3a9b7868e9bb6e8eef4ba95 100644 (file)
--- a/tests/trilinos/deal_solver_02.cc
+++ b/tests/trilinos/deal_solver_02.cc
@@ -92,17 +92,17 @@ int main(int argc, char **argv)
     A.reinit(csp);
     testproblem.five_point(A);
 
-    TrilinosWrappers::Vector f;
-    f.reinit(dim);
-    TrilinosWrappers::Vector u;
-    u.reinit(dim);
+    TrilinosWrappers::MPI::Vector f;
+    f.reinit(complete_index_set(dim),MPI_COMM_WORLD);
+    TrilinosWrappers::MPI::Vector u;
+    u.reinit(complete_index_set(dim),MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
     f.compress (VectorOperation::insert);
     u.compress (VectorOperation::insert);
 
-    GrowingVectorMemory<TrilinosWrappers::Vector> mem;
-    SolverBicgstab<TrilinosWrappers::Vector> solver(control,mem);
+    GrowingVectorMemory<TrilinosWrappers::MPI::Vector> mem;
+    SolverBicgstab<TrilinosWrappers::MPI::Vector> solver(control,mem);
     PreconditionIdentity preconditioner;
     check_solve (solver, control, A,u,f, preconditioner);
   }

diff --git a/tests/trilinos/deal_solver_02.output b/tests/trilinos/deal_solver_02.output
index adcf9c27a2885028d3009f3d791e96c25cfad1f1..02f985c1500f30980fe6d01a82bc46659ece6245 100644 (file)
--- a/tests/trilinos/deal_solver_02.output
+++ b/tests/trilinos/deal_solver_02.output
@@ -1,4 +1,4 @@
 
 DEAL::Size 32 Unknowns 961
-DEAL::Solver type: N6dealii14SolverBicgstabINS_16TrilinosWrappers6VectorEEE
+DEAL::Solver type: N6dealii14SolverBicgstabINS_16TrilinosWrappers3MPI6VectorEEE
 DEAL::Solver stopped within 49 - 51 iterations

diff --git a/tests/trilinos/deal_solver_03.cc b/tests/trilinos/deal_solver_03.cc
index 9095743b49db39e7ee1fe945b0409000b33e1b99..d45ae717e1c4b3386ecc9a9ef438d84ff1105f1d 100644 (file)
--- a/tests/trilinos/deal_solver_03.cc
+++ b/tests/trilinos/deal_solver_03.cc
@@ -93,17 +93,17 @@ int main(int argc, char **argv)
     A.reinit(csp);
     testproblem.five_point(A);
 
-    TrilinosWrappers::Vector f;
-    f.reinit(dim);
-    TrilinosWrappers::Vector u;
-    u.reinit(dim);
+    TrilinosWrappers::MPI::Vector f;
+    f.reinit(complete_index_set(dim),MPI_COMM_WORLD);
+    TrilinosWrappers::MPI::Vector u;
+    u.reinit(complete_index_set(dim),MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
     f.compress (VectorOperation::insert);
     u.compress (VectorOperation::insert);
 
-    GrowingVectorMemory<TrilinosWrappers::Vector> mem;
-    SolverGMRES<TrilinosWrappers::Vector> solver(control,mem);
+    GrowingVectorMemory<TrilinosWrappers::MPI::Vector> mem;
+    SolverGMRES<TrilinosWrappers::MPI::Vector> solver(control,mem);
     PreconditionIdentity preconditioner;
     check_solve (solver, control, A,u,f, preconditioner);
   }

diff --git a/tests/trilinos/deal_solver_03.output b/tests/trilinos/deal_solver_03.output
index 8dd71b155b1429dc615c13d375af30838365a096..91ead34128d9576304ca36c1f2ae96f4aa273bef 100644 (file)
--- a/tests/trilinos/deal_solver_03.output
+++ b/tests/trilinos/deal_solver_03.output
@@ -1,6 +1,6 @@
 
 DEAL::Size 32 Unknowns 961
-DEAL::Solver type: N6dealii11SolverGMRESINS_16TrilinosWrappers6VectorEEE
+DEAL::Solver type: N6dealii11SolverGMRESINS_16TrilinosWrappers3MPI6VectorEEE
 DEAL:GMRES::Starting value 31.0000
 DEAL:GMRES::Convergence step 75 value 0.000809583
 DEAL::Solver stopped after 75 iterations

diff --git a/tests/trilinos/deal_solver_04.cc b/tests/trilinos/deal_solver_04.cc
index e8e11ec79b892fd3e09f138c553b0ca0fdf603e0..f2d2de8ce292ea7435685b2c3e63e96b32816766 100644 (file)
--- a/tests/trilinos/deal_solver_04.cc
+++ b/tests/trilinos/deal_solver_04.cc
@@ -92,17 +92,17 @@ int main(int argc, char **argv)
     A.reinit(csp);
     testproblem.five_point(A);
 
-    TrilinosWrappers::Vector f;
-    f.reinit(dim);
-    TrilinosWrappers::Vector u;
-    u.reinit(dim);
+    TrilinosWrappers::MPI::Vector f;
+    f.reinit(complete_index_set(dim),MPI_COMM_WORLD);
+    TrilinosWrappers::MPI::Vector u;
+    u.reinit(complete_index_set(dim),MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
     f.compress (VectorOperation::insert);
     u.compress (VectorOperation::insert);
 
-    GrowingVectorMemory<TrilinosWrappers::Vector> mem;
-    SolverMinRes<TrilinosWrappers::Vector> solver(control,mem);
+    GrowingVectorMemory<TrilinosWrappers::MPI::Vector> mem;
+    SolverMinRes<TrilinosWrappers::MPI::Vector> solver(control,mem);
     PreconditionIdentity preconditioner;
     check_solve (solver, control, A,u,f, preconditioner);
   }

diff --git a/tests/trilinos/deal_solver_04.output b/tests/trilinos/deal_solver_04.output
index 3981b6c474fcd334f19294d70c1d377f7464ab94..8b6c8b7ce699997d613b55a4e650a36b47c7b68d 100644 (file)
--- a/tests/trilinos/deal_solver_04.output
+++ b/tests/trilinos/deal_solver_04.output
@@ -1,6 +1,6 @@
 
 DEAL::Size 32 Unknowns 961
-DEAL::Solver type: N6dealii12SolverMinResINS_16TrilinosWrappers6VectorEEE
+DEAL::Solver type: N6dealii12SolverMinResINS_16TrilinosWrappers3MPI6VectorEEE
 DEAL:minres::Starting value 31.0000
 DEAL:minres::Convergence step 43 value 0.000691560
 DEAL::Solver stopped after 43 iterations

diff --git a/tests/trilinos/deal_solver_05.cc b/tests/trilinos/deal_solver_05.cc
index f31d3cbb74df0b77ef58aef68d1a66d7dada40eb..fd7665f412a6914e0403a44c7fcc40e704143f74 100644 (file)
--- a/tests/trilinos/deal_solver_05.cc
+++ b/tests/trilinos/deal_solver_05.cc
@@ -91,17 +91,17 @@ int main(int argc, char **argv)
     A.reinit(csp);
     testproblem.five_point(A);
 
-    TrilinosWrappers::Vector f;
-    f.reinit(dim);
-    TrilinosWrappers::Vector u;
-    u.reinit(dim);
+    TrilinosWrappers::MPI::Vector f;
+    f.reinit(complete_index_set(dim),MPI_COMM_WORLD);
+    TrilinosWrappers::MPI::Vector u;
+    u.reinit(complete_index_set(dim),MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
     f.compress (VectorOperation::insert);
     u.compress (VectorOperation::insert);
 
-    GrowingVectorMemory<TrilinosWrappers::Vector> mem;
-    SolverQMRS<TrilinosWrappers::Vector> solver(control,mem);
+    GrowingVectorMemory<TrilinosWrappers::MPI::Vector> mem;
+    SolverQMRS<TrilinosWrappers::MPI::Vector> solver(control,mem);
     PreconditionIdentity preconditioner;
     check_solve (solver, control, A,u,f, preconditioner);
   }

diff --git a/tests/trilinos/deal_solver_05.output b/tests/trilinos/deal_solver_05.output
index 426f6ca330a8ae005c85dedf937fdf09c58c8326..f79f420b327025cbb2a6ba27df15905e3e9f25c4 100644 (file)
--- a/tests/trilinos/deal_solver_05.output
+++ b/tests/trilinos/deal_solver_05.output
@@ -1,6 +1,6 @@
 
 DEAL::Size 32 Unknowns 961
-DEAL::Solver type: N6dealii10SolverQMRSINS_16TrilinosWrappers6VectorEEE
+DEAL::Solver type: N6dealii10SolverQMRSINS_16TrilinosWrappers3MPI6VectorEEE
 DEAL:QMRS::Starting value 31.0000
 DEAL:QMRS::Convergence step 46 value 0.000906349
 DEAL::Solver stopped after 46 iterations

diff --git a/tests/trilinos/deal_solver_06.cc b/tests/trilinos/deal_solver_06.cc
index 6d6a9598256834fa53cb26d0945eefd4ee6f9259..bcc6c7caa296ea85aee682a3a4fcab3bf962b1e8 100644 (file)
--- a/tests/trilinos/deal_solver_06.cc
+++ b/tests/trilinos/deal_solver_06.cc
@@ -89,18 +89,18 @@ int main(int argc, char **argv)
     A.reinit(csp);
     testproblem.five_point(A);
 
-    TrilinosWrappers::Vector f;
-    f.reinit(dim);
-    TrilinosWrappers::Vector u;
-    u.reinit(dim);
+    TrilinosWrappers::MPI::Vector f;
+    f.reinit(complete_index_set(dim),MPI_COMM_WORLD);
+    TrilinosWrappers::MPI::Vector u;
+    u.reinit(complete_index_set(dim),MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
     f.compress (VectorOperation::insert);
     u.compress (VectorOperation::insert);
 
-    GrowingVectorMemory<TrilinosWrappers::Vector> mem;
-    SolverRichardson<TrilinosWrappers::Vector>::AdditionalData data (/*omega=*/0.1);
-    SolverRichardson<TrilinosWrappers::Vector> solver(control, mem, data);
+    GrowingVectorMemory<TrilinosWrappers::MPI::Vector> mem;
+    SolverRichardson<TrilinosWrappers::MPI::Vector>::AdditionalData data (/*omega=*/0.1);
+    SolverRichardson<TrilinosWrappers::MPI::Vector> solver(control, mem, data);
     PreconditionIdentity preconditioner;
     check_solve (solver, control, A,u,f, preconditioner);
   }

diff --git a/tests/trilinos/deal_solver_06.output b/tests/trilinos/deal_solver_06.output
index f7b0bc1e0eb83f51790c501659123547f8d24739..ca294f124fe4003a3d512e77eb6f38e1371c030c 100644 (file)
--- a/tests/trilinos/deal_solver_06.output
+++ b/tests/trilinos/deal_solver_06.output
@@ -1,6 +1,6 @@
 
 DEAL::Size 32 Unknowns 961
-DEAL::Solver type: N6dealii16SolverRichardsonINS_16TrilinosWrappers6VectorEEE
+DEAL::Solver type: N6dealii16SolverRichardsonINS_16TrilinosWrappers3MPI6VectorEEE
 DEAL:Richardson::Starting value 31.00
 DEAL:Richardson::Convergence step 5271 value 0.0009996
 DEAL::Solver stopped after 5271 iterations

diff --git a/tests/trilinos/slowness_02.cc b/tests/trilinos/slowness_02.cc
index b07475608e056e22861730d8aea302dab408332e..fc25d72f2394db7470ee6de4d4587344c97e85cb 100644 (file)
--- a/tests/trilinos/slowness_02.cc
+++ b/tests/trilinos/slowness_02.cc
@@ -69,10 +69,10 @@ void test ()
   // then do a single matrix-vector
   // multiplication with subsequent formation
   // of the matrix norm
-  TrilinosWrappers::Vector v1;
-  v1.reinit(N*N);
-  TrilinosWrappers::Vector v2;
-  v2.reinit(N*N);
+  TrilinosWrappers::MPI::Vector v1;
+  v1.reinit(complete_index_set(N*N), MPI_COMM_WORLD);
+  TrilinosWrappers::MPI::Vector v2;
+  v2.reinit(complete_index_set(N*N), MPI_COMM_WORLD);
   for (unsigned int i=0; i<N*N; ++i)
     v1(i) = i;
   matrix.vmult (v2, v1);

diff --git a/tests/trilinos/solver_03.cc b/tests/trilinos/solver_03.cc
index 11e990b31245d1d9f807ec63b8acc883c40110c3..56c747f0930dccaa6ea39f1f66106baaa53cd158 100644 (file)
--- a/tests/trilinos/solver_03.cc
+++ b/tests/trilinos/solver_03.cc
@@ -86,10 +86,10 @@ int main(int argc, char **argv)
     A.reinit(csp);
     testproblem.five_point(A);
 
-    TrilinosWrappers::Vector f;
-    f.reinit(dim);
-    TrilinosWrappers::Vector u;
-    u.reinit(dim);
+    TrilinosWrappers::MPI::Vector f;
+    f.reinit(complete_index_set(dim),MPI_COMM_WORLD);
+    TrilinosWrappers::MPI::Vector u;
+    u.reinit(complete_index_set(dim),MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
     f.compress (VectorOperation::insert);

diff --git a/tests/trilinos/solver_05.cc b/tests/trilinos/solver_05.cc
index ba422f4934d1c2e6c0ecf80c8ef53d73890cd896..54916f3ca5a470c2f4e777f08bc5b3460f0be839 100644 (file)
--- a/tests/trilinos/solver_05.cc
+++ b/tests/trilinos/solver_05.cc
@@ -86,10 +86,10 @@ int main(int argc, char **argv)
     A.reinit(csp);
     testproblem.five_point(A);
 
-    TrilinosWrappers::Vector f;
-    f.reinit(dim);
-    TrilinosWrappers::Vector u;
-    u.reinit(dim);
+    TrilinosWrappers::MPI::Vector f;
+    f.reinit(complete_index_set(dim),MPI_COMM_WORLD);
+    TrilinosWrappers::MPI::Vector u;
+    u.reinit(complete_index_set(dim),MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
     f.compress (VectorOperation::insert);

diff --git a/tests/trilinos/solver_07.cc b/tests/trilinos/solver_07.cc
index 1e717ed87fd9f5a663c9e56d2f7de6833957e421..d57a0fb3c4996bd64dd581422bf798995354d45f 100644 (file)
--- a/tests/trilinos/solver_07.cc
+++ b/tests/trilinos/solver_07.cc
@@ -85,10 +85,10 @@ int main(int argc, char **argv)
     A.reinit(csp);
     testproblem.five_point(A);
 
-    TrilinosWrappers::Vector f;
-    f.reinit(dim);
-    TrilinosWrappers::Vector u;
-    u.reinit(dim);
+    TrilinosWrappers::MPI::Vector f;
+    f.reinit(complete_index_set(dim),MPI_COMM_WORLD);
+    TrilinosWrappers::MPI::Vector u;
+    u.reinit(complete_index_set(dim),MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
     f.compress (VectorOperation::insert);

diff --git a/tests/trilinos/solver_control_01.cc b/tests/trilinos/solver_control_01.cc
index 6aad6ef261ca8c5b82b65505a3a221b7631d6125..6242b9537bdc616ed6f0883e12abcb42d0608766 100644 (file)
--- a/tests/trilinos/solver_control_01.cc
+++ b/tests/trilinos/solver_control_01.cc
@@ -88,10 +88,10 @@ int main(int argc, char **argv)
     A.reinit(csp);
     testproblem.five_point(A);
 
-    TrilinosWrappers::Vector f;
-    f.reinit(dim);
-    TrilinosWrappers::Vector u;
-    u.reinit(dim);
+    TrilinosWrappers::MPI::Vector f;
+    f.reinit(complete_index_set(dim),MPI_COMM_WORLD);
+    TrilinosWrappers::MPI::Vector u;
+    u.reinit(complete_index_set(dim),MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
     f.compress (VectorOperation::insert);

diff --git a/tests/trilinos/solver_control_02.cc b/tests/trilinos/solver_control_02.cc
index 4c26b676eb43f1882a633e53fe0d9bf1c271e748..1c832fe0ef89fc64b5c1dc3992ab8bd8de38396f 100644 (file)
--- a/tests/trilinos/solver_control_02.cc
+++ b/tests/trilinos/solver_control_02.cc
@@ -88,10 +88,10 @@ int main(int argc, char **argv)
     A.reinit(csp);
     testproblem.five_point(A);
 
-    TrilinosWrappers::Vector f;
-    f.reinit(dim);
-    TrilinosWrappers::Vector u;
-    u.reinit(dim);
+    TrilinosWrappers::MPI::Vector f;
+    f.reinit(complete_index_set(dim),MPI_COMM_WORLD);
+    TrilinosWrappers::MPI::Vector u;
+    u.reinit(complete_index_set(dim),MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
     f.compress (VectorOperation::insert);

diff --git a/tests/trilinos/solver_control_03.cc b/tests/trilinos/solver_control_03.cc
index 0e2d9921c560b9dabd49999e457a2ea62a15f229..7c527fe15a156dbe77c17694e03265f05641e50e 100644 (file)
--- a/tests/trilinos/solver_control_03.cc
+++ b/tests/trilinos/solver_control_03.cc
@@ -88,10 +88,10 @@ int main(int argc, char **argv)
     A.reinit(csp);
     testproblem.five_point(A);
 
-    TrilinosWrappers::Vector f;
-    f.reinit(dim);
-    TrilinosWrappers::Vector u;
-    u.reinit(dim);
+    TrilinosWrappers::MPI::Vector f;
+    f.reinit(complete_index_set(dim),MPI_COMM_WORLD);
+    TrilinosWrappers::MPI::Vector u;
+    u.reinit(complete_index_set(dim),MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
     f.compress (VectorOperation::insert);

diff --git a/tests/trilinos/solver_control_04.cc b/tests/trilinos/solver_control_04.cc
index 05ca980cec9ee073c71240e91fabd1bd508daf3b..33f9e10d4b0cf70555aa62894535a366408524fd 100644 (file)
--- a/tests/trilinos/solver_control_04.cc
+++ b/tests/trilinos/solver_control_04.cc
@@ -57,12 +57,12 @@ int main(int argc, char **argv)
     A.reinit(csp);
     testproblem.five_point(A);
 
-    TrilinosWrappers::Vector f;
-    f.reinit(dim);
-    TrilinosWrappers::Vector u1;
-    u1.reinit(dim);
-    TrilinosWrappers::Vector u2;
-    u2.reinit(dim);
+    TrilinosWrappers::MPI::Vector f;
+    f.reinit(complete_index_set(dim),MPI_COMM_WORLD);
+    TrilinosWrappers::MPI::Vector u1;
+    u1.reinit(complete_index_set(dim),MPI_COMM_WORLD);
+    TrilinosWrappers::MPI::Vector u2;
+    u2.reinit(complete_index_set(dim),MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
     f.compress (VectorOperation::insert);
@@ -75,7 +75,7 @@ int main(int argc, char **argv)
     SolverControl solver_control(2000, 1.e-3);
     TrilinosWrappers::SolverCG solver(solver_control);
 
-    const auto lo_A = linear_operator<TrilinosWrappers::Vector>(A);
+    const auto lo_A = linear_operator<TrilinosWrappers::MPI::Vector>(A);
     const auto lo_A_inv = inverse_operator(lo_A,
                                            solver,
                                            preconditioner);

diff --git a/tests/trilinos/solver_control_05.cc b/tests/trilinos/solver_control_05.cc
index 310ebba605de590eed9465a101a9ec8d75bb121b..dd5b242bdfe7594f301110c541efbedb16617fe3 100644 (file)
--- a/tests/trilinos/solver_control_05.cc
+++ b/tests/trilinos/solver_control_05.cc
@@ -60,12 +60,12 @@ int main(int argc, char **argv)
     for (unsigned int row=0; row<dim; row++)
       A.set(row,row, 2.0*(row+1));
 
-    TrilinosWrappers::Vector f;
-    f.reinit(dim);
-    TrilinosWrappers::Vector u1;
-    u1.reinit(dim);
-    TrilinosWrappers::Vector u2;
-    u2.reinit(dim);
+    TrilinosWrappers::MPI::Vector f;
+    f.reinit(complete_index_set(dim),MPI_COMM_WORLD);
+    TrilinosWrappers::MPI::Vector u1;
+    u1.reinit(complete_index_set(dim),MPI_COMM_WORLD);
+    TrilinosWrappers::MPI::Vector u2;
+    u2.reinit(complete_index_set(dim),MPI_COMM_WORLD);
     f = 1.;
     A.compress (VectorOperation::insert);
     f.compress (VectorOperation::insert);
@@ -78,7 +78,7 @@ int main(int argc, char **argv)
     SolverControl solver_control(2000, 1.e-3);
     TrilinosWrappers::SolverCG solver(solver_control);
 
-    const auto lo_A = linear_operator<TrilinosWrappers::Vector>(A);
+    const auto lo_A = linear_operator<TrilinosWrappers::MPI::Vector>(A);
     const auto lo_A_inv = inverse_operator(lo_A,
                                            solver,
                                            preconditioner);

diff --git a/tests/trilinos/sparse_matrix_vector_01.cc b/tests/trilinos/sparse_matrix_vector_01.cc
index cb222d0874c7ee6b733d83bf0a2a7783c331e810..186e6b592aa3caaec112d5b0fe009050e106c6a1 100644 (file)
--- a/tests/trilinos/sparse_matrix_vector_01.cc
+++ b/tests/trilinos/sparse_matrix_vector_01.cc
@@ -26,8 +26,8 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v,
-           TrilinosWrappers::Vector &w)
+void test (TrilinosWrappers::MPI::Vector &v,
+           TrilinosWrappers::MPI::Vector &w)
 {
   TrilinosWrappers::SparseMatrix m(v.size(),v.size(),v.size());
   for (unsigned int i=0; i<m.m(); ++i)
@@ -72,10 +72,10 @@ int main (int argc, char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
-        TrilinosWrappers::Vector w;
-        w.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
+        TrilinosWrappers::MPI::Vector w;
+        w.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v,w);
       }
     }

diff --git a/tests/trilinos/sparse_matrix_vector_02.cc b/tests/trilinos/sparse_matrix_vector_02.cc
index cc962553e0b35b5db87aa1ded37e40de22e71dc4..6a105cc749883818dc572677d66d7bf870c9b95a 100644 (file)
--- a/tests/trilinos/sparse_matrix_vector_02.cc
+++ b/tests/trilinos/sparse_matrix_vector_02.cc
@@ -26,8 +26,8 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v,
-           TrilinosWrappers::Vector &w)
+void test (TrilinosWrappers::MPI::Vector &v,
+           TrilinosWrappers::MPI::Vector &w)
 {
   TrilinosWrappers::SparseMatrix m(v.size(),v.size(),v.size());
   for (unsigned int i=0; i<m.m(); ++i)
@@ -72,10 +72,10 @@ int main (int argc, char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
-        TrilinosWrappers::Vector w;
-        w.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
+        TrilinosWrappers::MPI::Vector w;
+        w.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v,w);
       }
     }

diff --git a/tests/trilinos/sparse_matrix_vector_03.cc b/tests/trilinos/sparse_matrix_vector_03.cc
index b8c3704b4c711af4cacecf6577a1d080197d17c9..928e0a145047dc6d6dbd5201951ab0be760d605a 100644 (file)
--- a/tests/trilinos/sparse_matrix_vector_03.cc
+++ b/tests/trilinos/sparse_matrix_vector_03.cc
@@ -26,8 +26,8 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v,
-           TrilinosWrappers::Vector &w)
+void test (TrilinosWrappers::MPI::Vector &v,
+           TrilinosWrappers::MPI::Vector &w)
 {
   TrilinosWrappers::SparseMatrix m(v.size(),v.size(),v.size());
   for (unsigned int i=0; i<m.m(); ++i)
@@ -75,10 +75,10 @@ int main (int argc, char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
-        TrilinosWrappers::Vector w;
-        w.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
+        TrilinosWrappers::MPI::Vector w;
+        w.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v,w);
       }
     }

diff --git a/tests/trilinos/sparse_matrix_vector_04.cc b/tests/trilinos/sparse_matrix_vector_04.cc
index fe77fd32170aea79960ebb7878fb739f96fc6209..e925def217051097fd4ad27cb91892be918e46bb 100644 (file)
--- a/tests/trilinos/sparse_matrix_vector_04.cc
+++ b/tests/trilinos/sparse_matrix_vector_04.cc
@@ -26,8 +26,8 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v,
-           TrilinosWrappers::Vector &w)
+void test (TrilinosWrappers::MPI::Vector &v,
+           TrilinosWrappers::MPI::Vector &w)
 {
   TrilinosWrappers::SparseMatrix m(v.size(),v.size(),v.size());
   for (unsigned int i=0; i<m.m(); ++i)
@@ -74,10 +74,10 @@ int main (int argc, char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
-        TrilinosWrappers::Vector w;
-        w.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
+        TrilinosWrappers::MPI::Vector w;
+        w.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v,w);
       }
     }

diff --git a/tests/trilinos/sparse_matrix_vector_05.cc b/tests/trilinos/sparse_matrix_vector_05.cc
index cf3f866a7b4152ff568027dbeaf42486d28070b4..b4fd08fc191115f17a65d6b095cb1659c8ef69ab 100644 (file)
--- a/tests/trilinos/sparse_matrix_vector_05.cc
+++ b/tests/trilinos/sparse_matrix_vector_05.cc
@@ -26,8 +26,8 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v,
-           TrilinosWrappers::Vector &w)
+void test (TrilinosWrappers::MPI::Vector &v,
+           TrilinosWrappers::MPI::Vector &w)
 {
   TrilinosWrappers::SparseMatrix m(v.size(),v.size(),v.size());
   for (unsigned int i=0; i<m.m(); ++i)
@@ -78,10 +78,10 @@ int main (int argc, char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
-        TrilinosWrappers::Vector w;
-        w.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
+        TrilinosWrappers::MPI::Vector w;
+        w.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v,w);
       }
     }

diff --git a/tests/trilinos/sparse_matrix_vector_06.cc b/tests/trilinos/sparse_matrix_vector_06.cc
index 295a793ce87f7c11237e3c6d2b816cc394151c0a..d20ba33284b231823cc0592523fbbf1cf93593de 100644 (file)
--- a/tests/trilinos/sparse_matrix_vector_06.cc
+++ b/tests/trilinos/sparse_matrix_vector_06.cc
@@ -26,7 +26,7 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v)
+void test (TrilinosWrappers::MPI::Vector &v)
 {
   TrilinosWrappers::SparseMatrix m(v.size(),v.size(),v.size());
   for (unsigned int i=0; i<m.m(); ++i)
@@ -70,8 +70,8 @@ int main (int argc, char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(30);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(30), MPI_COMM_WORLD);
         test (v);
       }
     }

diff --git a/tests/trilinos/sparse_matrix_vector_07.cc b/tests/trilinos/sparse_matrix_vector_07.cc
index 441eeb5c8d2e09ba6e1eaeb5f1c457f3f049f82a..d51f13456b633d24788e0bd89b85c1aaab70d94d 100644 (file)
--- a/tests/trilinos/sparse_matrix_vector_07.cc
+++ b/tests/trilinos/sparse_matrix_vector_07.cc
@@ -26,9 +26,9 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v,
-           TrilinosWrappers::Vector &w,
-           TrilinosWrappers::Vector &x)
+void test (TrilinosWrappers::MPI::Vector &v,
+           TrilinosWrappers::MPI::Vector &w,
+           TrilinosWrappers::MPI::Vector &x)
 {
   TrilinosWrappers::SparseMatrix m(v.size(),v.size(),v.size());
   for (unsigned int i=0; i<m.m(); ++i)
@@ -80,12 +80,12 @@ int main (int argc, char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
-        TrilinosWrappers::Vector w;
-        w.reinit(100);
-        TrilinosWrappers::Vector x;
-        x.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
+        TrilinosWrappers::MPI::Vector w;
+        w.reinit(complete_index_set(100), MPI_COMM_WORLD);
+        TrilinosWrappers::MPI::Vector x;
+        x.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v,w,x);
       }
     }

diff --git a/tests/trilinos/vector_assign_01.cc b/tests/trilinos/vector_assign_01.cc
index 7ad06b816e23ca7fd9df822d6ae848916353bc0b..8d08da744c9164f88559584564e41b70e856b5e5 100644 (file)
--- a/tests/trilinos/vector_assign_01.cc
+++ b/tests/trilinos/vector_assign_01.cc
@@ -31,8 +31,8 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v,
-           TrilinosWrappers::Vector &w)
+void test (TrilinosWrappers::MPI::Vector &v,
+           TrilinosWrappers::MPI::Vector &w)
 {
   // set the first vector
   for (unsigned int i=0; i<v.size(); ++i)
@@ -62,10 +62,10 @@ int main (int argc, char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
-        TrilinosWrappers::Vector w;
-        w.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
+        TrilinosWrappers::MPI::Vector w;
+        w.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v,w);
       }
     }

diff --git a/tests/trilinos/vector_assign_02.cc b/tests/trilinos/vector_assign_02.cc
index 7409afa47a30dc00f704f57706524535051a0235..b32204073306ca21e77dc72804ec1ea462c1ed30 100644 (file)
--- a/tests/trilinos/vector_assign_02.cc
+++ b/tests/trilinos/vector_assign_02.cc
@@ -30,8 +30,8 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v,
-           TrilinosWrappers::Vector &w)
+void test (TrilinosWrappers::MPI::Vector &v,
+           TrilinosWrappers::MPI::Vector &w)
 {
   // set the first vector
   for (unsigned int i=0; i<v.size(); ++i)
@@ -61,10 +61,10 @@ int main (int argc, char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
-        TrilinosWrappers::Vector w;
-        w.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
+        TrilinosWrappers::MPI::Vector w;
+        w.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v,w);
       }
     }

diff --git a/tests/trilinos/vector_equality_1.cc b/tests/trilinos/vector_equality_1.cc
index 2dda42d42fe5a3e1438c5937b4f22c3f4b3a3d49..e529cd849b6a58268d5be87904efd995ac7df04a 100644 (file)
--- a/tests/trilinos/vector_equality_1.cc
+++ b/tests/trilinos/vector_equality_1.cc
@@ -26,8 +26,8 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v,
-           TrilinosWrappers::Vector &w)
+void test (TrilinosWrappers::MPI::Vector &v,
+           TrilinosWrappers::MPI::Vector &w)
 {
   // set only certain elements of each
   // vector
@@ -57,10 +57,10 @@ int main (int argc, char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
-        TrilinosWrappers::Vector w;
-        w.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
+        TrilinosWrappers::MPI::Vector w;
+        w.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v,w);
       }
     }

diff --git a/tests/trilinos/vector_equality_2.cc b/tests/trilinos/vector_equality_2.cc
index 230e723d640902325f8260a74604b12f62a180f2..22eeb5e62da5ed5bc69286e340f10ab10dbb1474 100644 (file)
--- a/tests/trilinos/vector_equality_2.cc
+++ b/tests/trilinos/vector_equality_2.cc
@@ -26,8 +26,8 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v,
-           TrilinosWrappers::Vector &w)
+void test (TrilinosWrappers::MPI::Vector &v,
+           TrilinosWrappers::MPI::Vector &w)
 {
   // set only certain elements of each
   // vector
@@ -59,10 +59,10 @@ int main (int argc, char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
-        TrilinosWrappers::Vector w;
-        w.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
+        TrilinosWrappers::MPI::Vector w;
+        w.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v,w);
       }
     }

diff --git a/tests/trilinos/vector_equality_3.cc b/tests/trilinos/vector_equality_3.cc
index 2449fb7995b6998d51d84b08cd54826698f8f6cc..b171380be0d4a843fd220647a65a3adfc70993de 100644 (file)
--- a/tests/trilinos/vector_equality_3.cc
+++ b/tests/trilinos/vector_equality_3.cc
@@ -26,8 +26,8 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v,
-           TrilinosWrappers::Vector &w)
+void test (TrilinosWrappers::MPI::Vector &v,
+           TrilinosWrappers::MPI::Vector &w)
 {
   // set only certain elements of each
   // vector
@@ -57,10 +57,10 @@ int main (int argc, char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
-        TrilinosWrappers::Vector w;
-        w.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
+        TrilinosWrappers::MPI::Vector w;
+        w.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v,w);
       }
     }

diff --git a/tests/trilinos/vector_equality_4.cc b/tests/trilinos/vector_equality_4.cc
index 65cbb17ffe8dd5863d35ca7704a2aeb2de472d09..b69301036a3b663062cd7e57f3327c1d40fec6e9 100644 (file)
--- a/tests/trilinos/vector_equality_4.cc
+++ b/tests/trilinos/vector_equality_4.cc
@@ -26,8 +26,8 @@
 #include <vector>
 
 
-void test (TrilinosWrappers::Vector &v,
-           TrilinosWrappers::Vector &w)
+void test (TrilinosWrappers::MPI::Vector &v,
+           TrilinosWrappers::MPI::Vector &w)
 {
   // set only certain elements of each
   // vector
@@ -59,10 +59,10 @@ int main (int argc, char **argv)
   try
     {
       {
-        TrilinosWrappers::Vector v;
-        v.reinit(100);
-        TrilinosWrappers::Vector w;
-        w.reinit(100);
+        TrilinosWrappers::MPI::Vector v;
+        v.reinit(complete_index_set(100), MPI_COMM_WORLD);
+        TrilinosWrappers::MPI::Vector w;
+        w.reinit(complete_index_set(100), MPI_COMM_WORLD);
         test (v,w);
       }
     }

diff --git a/tests/trilinos/vector_reference_01.cc b/tests/trilinos/vector_reference_01.cc
index 21c5ef463bdef34ae5ada2d5979553b06c212a6b..196e518dc4efa45e29d2672b64dec7733df142cf 100644 (file)
--- a/tests/trilinos/vector_reference_01.cc
+++ b/tests/trilinos/vector_reference_01.cc
@@ -29,8 +29,8 @@
 
 void test ()
 {
-  TrilinosWrappers::Vector v;
-  v.reinit(3);
+  TrilinosWrappers::MPI::Vector v;
+  v.reinit(complete_index_set(3), MPI_COMM_WORLD);
   v(0) = 0;
   v(1) = 1;
   v(2) = 2;

diff --git a/tests/trilinos/vector_swap_01.cc b/tests/trilinos/vector_swap_01.cc
index 1b4f1e512c424cd67943950e1cae950790310345..1c175f1532e46d93c69bfe05fd435d14e00f7a81 100644 (file)
--- a/tests/trilinos/vector_swap_01.cc
+++ b/tests/trilinos/vector_swap_01.cc
@@ -26,7 +26,7 @@
 #include <iostream>
 #include <vector>
 
-void print(TrilinosWrappers::Vector &v)
+void print(TrilinosWrappers::MPI::Vector &v)
 {
   deallog << "size= " << v.size()
           << " el(0)= " << v(0)
@@ -36,12 +36,12 @@ void print(TrilinosWrappers::Vector &v)
 
 void test ()
 {
-  TrilinosWrappers::Vector v;
-  v.reinit(5);
+  TrilinosWrappers::MPI::Vector v;
+  v.reinit(complete_index_set(5), MPI_COMM_WORLD);
   for (unsigned int i=0; i<v.size(); ++i)
     v(i) = 1;
-  TrilinosWrappers::Vector w;
-  w.reinit(9);
+  TrilinosWrappers::MPI::Vector w;
+  w.reinit(complete_index_set(9), MPI_COMM_WORLD);
   for (unsigned int i=0; i<w.size(); ++i)
     w(i) = 2;