From 027dd5243bd72cf52a0720319c347fc0afef4e18 Mon Sep 17 00:00:00 2001 From: Wolfgang Bangerth Date: Wed, 14 Feb 2024 11:02:51 -0700 Subject: [PATCH] Add Tpetra tests that are already working. --- tests/trilinos_tpetra/10.cc | 105 ++ tests/trilinos_tpetra/10.output | 2 + tests/trilinos_tpetra/11.cc | 88 ++ tests/trilinos_tpetra/11.output | 2 + tests/trilinos_tpetra/12.cc | 100 ++ tests/trilinos_tpetra/12.output | 2 + tests/trilinos_tpetra/13.cc | 100 ++ tests/trilinos_tpetra/13.output | 2 + tests/trilinos_tpetra/14.cc | 118 +++ tests/trilinos_tpetra/14.output | 2 + tests/trilinos_tpetra/15.cc | 118 +++ tests/trilinos_tpetra/15.output | 2 + tests/trilinos_tpetra/16.cc | 119 +++ tests/trilinos_tpetra/16.output | 2 + tests/trilinos_tpetra/17.cc | 93 ++ tests/trilinos_tpetra/17.output | 2 + tests/trilinos_tpetra/18.cc | 94 ++ tests/trilinos_tpetra/18.output | 2 + tests/trilinos_tpetra/19.cc | 93 ++ tests/trilinos_tpetra/19.output | 2 + tests/trilinos_tpetra/20.cc | 101 ++ tests/trilinos_tpetra/20.output | 2 + tests/trilinos_tpetra/21.cc | 101 ++ tests/trilinos_tpetra/21.output | 2 + tests/trilinos_tpetra/22.cc | 98 ++ tests/trilinos_tpetra/22.output | 2 + tests/trilinos_tpetra/23.cc | 105 ++ tests/trilinos_tpetra/23.output | 2 + tests/trilinos_tpetra/24.cc | 97 ++ tests/trilinos_tpetra/24.output | 2 + tests/trilinos_tpetra/27.cc | 99 ++ tests/trilinos_tpetra/27.output | 3 + tests/trilinos_tpetra/28.cc | 101 ++ tests/trilinos_tpetra/28.output | 3 + tests/trilinos_tpetra/29.cc | 85 ++ tests/trilinos_tpetra/29.output | 2 + tests/trilinos_tpetra/30.cc | 93 ++ tests/trilinos_tpetra/30.output | 2 + tests/trilinos_tpetra/31.cc | 94 ++ tests/trilinos_tpetra/31.output | 2 + tests/trilinos_tpetra/32.cc | 95 ++ tests/trilinos_tpetra/32.output | 2 + tests/trilinos_tpetra/34.cc | 96 ++ tests/trilinos_tpetra/34.output | 2 + tests/trilinos_tpetra/35.cc | 114 +++ tests/trilinos_tpetra/35.output | 2 + tests/trilinos_tpetra/36.cc | 114 +++ tests/trilinos_tpetra/36.output | 2 + tests/trilinos_tpetra/37.cc | 92 ++ tests/trilinos_tpetra/37.output | 2 + tests/trilinos_tpetra/39.cc | 102 ++ tests/trilinos_tpetra/39.output | 2 + tests/trilinos_tpetra/40.cc | 108 ++ tests/trilinos_tpetra/40.output | 2 + tests/trilinos_tpetra/42.cc | 103 ++ tests/trilinos_tpetra/42.output | 2 + tests/trilinos_tpetra/45.cc | 102 ++ tests/trilinos_tpetra/45.output | 2 + tests/trilinos_tpetra/46.cc | 102 ++ tests/trilinos_tpetra/46.output | 2 + tests/trilinos_tpetra/51.cc | 99 ++ tests/trilinos_tpetra/51.output | 3 + tests/trilinos_tpetra/52.cc | 107 ++ tests/trilinos_tpetra/52.output | 2 + tests/trilinos_tpetra/53.cc | 104 ++ tests/trilinos_tpetra/53.output | 2 + tests/trilinos_tpetra/54.cc | 104 ++ tests/trilinos_tpetra/54.output | 2 + tests/trilinos_tpetra/55.cc | 103 ++ tests/trilinos_tpetra/55.output | 2 + tests/trilinos_tpetra/56.cc | 103 ++ tests/trilinos_tpetra/56.output | 2 + tests/trilinos_tpetra/63.cc | 87 ++ tests/trilinos_tpetra/63.output | 2 + tests/trilinos_tpetra/70.cc | 42 + tests/trilinos_tpetra/70.output | 2 + tests/trilinos_tpetra/index_set_01.cc | 68 ++ .../index_set_01.mpirun=3.output | 2 + .../parallel_sparse_matrix_01.cc | 146 +++ .../parallel_sparse_matrix_01.output | 2 + tests/trilinos_tpetra/slowness_01.cc | 155 +++ tests/trilinos_tpetra/slowness_01.output | 2 + tests/trilinos_tpetra/slowness_02.cc | 129 +++ tests/trilinos_tpetra/slowness_02.output | 2 + tests/trilinos_tpetra/slowness_03.cc | 130 +++ tests/trilinos_tpetra/slowness_03.output | 2 + tests/trilinos_tpetra/slowness_04.cc | 160 +++ tests/trilinos_tpetra/slowness_04.output | 2 + .../sparse_matrix_vector_01.cc | 113 +++ .../sparse_matrix_vector_01.output | 2 + .../sparse_matrix_vector_02.cc | 113 +++ .../sparse_matrix_vector_02.output | 2 + .../sparse_matrix_vector_03.cc | 116 +++ .../sparse_matrix_vector_03.output | 2 + .../sparse_matrix_vector_04.cc | 115 +++ .../sparse_matrix_vector_04.output | 2 + .../sparse_matrix_vector_14.cc | 128 +++ ...tor_14.with_trilinos_with_tpetra=on.output | 2 + .../sparse_matrix_vector_15.cc | 127 +++ ...tor_15.with_trilinos_with_tpetra=on.output | 2 + tests/trilinos_tpetra/sparsity_pattern_01.cc | 33 + .../sparsity_pattern_01.output | 199 ++++ tests/trilinos_tpetra/sparsity_pattern_02.cc | 33 + ...pattern_02.with_p4est=true.mpirun=1.output | 927 ++++++++++++++++++ tests/trilinos_tpetra/sparsity_pattern_03.cc | 34 + .../sparsity_pattern_03.output | 927 ++++++++++++++++++ .../trilinos_tpetra/sparsity_pattern_common.h | 89 ++ tests/trilinos_tpetra/tpetra_vector_01.cc | 229 +++++ ...irun=2.with_trilinos_with_tpetra=on.output | 2 + tests/trilinos_tpetra/tpetra_vector_02.cc | 223 +++++ ...irun=2.with_trilinos_with_tpetra=on.output | 2 + tests/trilinos_tpetra/tpetra_vector_03.cc | 103 ++ ...on.with_complex_values=off.mpirun=2.output | 70 ++ ...on.with_complex_values=off.mpirun=4.output | 146 +++ ...=on.with_complex_values=on.mpirun=2.output | 70 ++ ...=on.with_complex_values=on.mpirun=4.output | 146 +++ tests/trilinos_tpetra/vector_reference_01.cc | 75 ++ .../vector_reference_01.output | 4 + tests/trilinos_tpetra/vector_reinit.cc | 79 ++ ...tor_reinit.with_p4est=true.mpirun=3.output | 2 + tests/trilinos_tpetra/vector_swap_01.cc | 112 +++ tests/trilinos_tpetra/vector_swap_01.output | 7 + 122 files changed, 8894 insertions(+) create mode 100644 tests/trilinos_tpetra/10.cc create mode 100644 tests/trilinos_tpetra/10.output create mode 100644 tests/trilinos_tpetra/11.cc create mode 100644 tests/trilinos_tpetra/11.output create mode 100644 tests/trilinos_tpetra/12.cc create mode 100644 tests/trilinos_tpetra/12.output create mode 100644 tests/trilinos_tpetra/13.cc create mode 100644 tests/trilinos_tpetra/13.output create mode 100644 tests/trilinos_tpetra/14.cc create mode 100644 tests/trilinos_tpetra/14.output create mode 100644 tests/trilinos_tpetra/15.cc create mode 100644 tests/trilinos_tpetra/15.output create mode 100644 tests/trilinos_tpetra/16.cc create mode 100644 tests/trilinos_tpetra/16.output create mode 100644 tests/trilinos_tpetra/17.cc create mode 100644 tests/trilinos_tpetra/17.output create mode 100644 tests/trilinos_tpetra/18.cc create mode 100644 tests/trilinos_tpetra/18.output create mode 100644 tests/trilinos_tpetra/19.cc create mode 100644 tests/trilinos_tpetra/19.output create mode 100644 tests/trilinos_tpetra/20.cc create mode 100644 tests/trilinos_tpetra/20.output create mode 100644 tests/trilinos_tpetra/21.cc create mode 100644 tests/trilinos_tpetra/21.output create mode 100644 tests/trilinos_tpetra/22.cc create mode 100644 tests/trilinos_tpetra/22.output create mode 100644 tests/trilinos_tpetra/23.cc create mode 100644 tests/trilinos_tpetra/23.output create mode 100644 tests/trilinos_tpetra/24.cc create mode 100644 tests/trilinos_tpetra/24.output create mode 100644 tests/trilinos_tpetra/27.cc create mode 100644 tests/trilinos_tpetra/27.output create mode 100644 tests/trilinos_tpetra/28.cc create mode 100644 tests/trilinos_tpetra/28.output create mode 100644 tests/trilinos_tpetra/29.cc create mode 100644 tests/trilinos_tpetra/29.output create mode 100644 tests/trilinos_tpetra/30.cc create mode 100644 tests/trilinos_tpetra/30.output create mode 100644 tests/trilinos_tpetra/31.cc create mode 100644 tests/trilinos_tpetra/31.output create mode 100644 tests/trilinos_tpetra/32.cc create mode 100644 tests/trilinos_tpetra/32.output create mode 100644 tests/trilinos_tpetra/34.cc create mode 100644 tests/trilinos_tpetra/34.output create mode 100644 tests/trilinos_tpetra/35.cc create mode 100644 tests/trilinos_tpetra/35.output create mode 100644 tests/trilinos_tpetra/36.cc create mode 100644 tests/trilinos_tpetra/36.output create mode 100644 tests/trilinos_tpetra/37.cc create mode 100644 tests/trilinos_tpetra/37.output create mode 100644 tests/trilinos_tpetra/39.cc create mode 100644 tests/trilinos_tpetra/39.output create mode 100644 tests/trilinos_tpetra/40.cc create mode 100644 tests/trilinos_tpetra/40.output create mode 100644 tests/trilinos_tpetra/42.cc create mode 100644 tests/trilinos_tpetra/42.output create mode 100644 tests/trilinos_tpetra/45.cc create mode 100644 tests/trilinos_tpetra/45.output create mode 100644 tests/trilinos_tpetra/46.cc create mode 100644 tests/trilinos_tpetra/46.output create mode 100644 tests/trilinos_tpetra/51.cc create mode 100644 tests/trilinos_tpetra/51.output create mode 100644 tests/trilinos_tpetra/52.cc create mode 100644 tests/trilinos_tpetra/52.output create mode 100644 tests/trilinos_tpetra/53.cc create mode 100644 tests/trilinos_tpetra/53.output create mode 100644 tests/trilinos_tpetra/54.cc create mode 100644 tests/trilinos_tpetra/54.output create mode 100644 tests/trilinos_tpetra/55.cc create mode 100644 tests/trilinos_tpetra/55.output create mode 100644 tests/trilinos_tpetra/56.cc create mode 100644 tests/trilinos_tpetra/56.output create mode 100644 tests/trilinos_tpetra/63.cc create mode 100644 tests/trilinos_tpetra/63.output create mode 100644 tests/trilinos_tpetra/70.cc create mode 100644 tests/trilinos_tpetra/70.output create mode 100644 tests/trilinos_tpetra/index_set_01.cc create mode 100644 tests/trilinos_tpetra/index_set_01.mpirun=3.output create mode 100644 tests/trilinos_tpetra/parallel_sparse_matrix_01.cc create mode 100644 tests/trilinos_tpetra/parallel_sparse_matrix_01.output create mode 100644 tests/trilinos_tpetra/slowness_01.cc create mode 100644 tests/trilinos_tpetra/slowness_01.output create mode 100644 tests/trilinos_tpetra/slowness_02.cc create mode 100644 tests/trilinos_tpetra/slowness_02.output create mode 100644 tests/trilinos_tpetra/slowness_03.cc create mode 100644 tests/trilinos_tpetra/slowness_03.output create mode 100644 tests/trilinos_tpetra/slowness_04.cc create mode 100644 tests/trilinos_tpetra/slowness_04.output create mode 100644 tests/trilinos_tpetra/sparse_matrix_vector_01.cc create mode 100644 tests/trilinos_tpetra/sparse_matrix_vector_01.output create mode 100644 tests/trilinos_tpetra/sparse_matrix_vector_02.cc create mode 100644 tests/trilinos_tpetra/sparse_matrix_vector_02.output create mode 100644 tests/trilinos_tpetra/sparse_matrix_vector_03.cc create mode 100644 tests/trilinos_tpetra/sparse_matrix_vector_03.output create mode 100644 tests/trilinos_tpetra/sparse_matrix_vector_04.cc create mode 100644 tests/trilinos_tpetra/sparse_matrix_vector_04.output create mode 100644 tests/trilinos_tpetra/sparse_matrix_vector_14.cc create mode 100644 tests/trilinos_tpetra/sparse_matrix_vector_14.with_trilinos_with_tpetra=on.output create mode 100644 tests/trilinos_tpetra/sparse_matrix_vector_15.cc create mode 100644 tests/trilinos_tpetra/sparse_matrix_vector_15.with_trilinos_with_tpetra=on.output create mode 100644 tests/trilinos_tpetra/sparsity_pattern_01.cc create mode 100644 tests/trilinos_tpetra/sparsity_pattern_01.output create mode 100644 tests/trilinos_tpetra/sparsity_pattern_02.cc create mode 100644 tests/trilinos_tpetra/sparsity_pattern_02.with_p4est=true.mpirun=1.output create mode 100644 tests/trilinos_tpetra/sparsity_pattern_03.cc create mode 100644 tests/trilinos_tpetra/sparsity_pattern_03.output create mode 100644 tests/trilinos_tpetra/sparsity_pattern_common.h create mode 100644 tests/trilinos_tpetra/tpetra_vector_01.cc create mode 100644 tests/trilinos_tpetra/tpetra_vector_01.mpirun=2.with_trilinos_with_tpetra=on.output create mode 100644 tests/trilinos_tpetra/tpetra_vector_02.cc create mode 100644 tests/trilinos_tpetra/tpetra_vector_02.mpirun=2.with_trilinos_with_tpetra=on.output create mode 100644 tests/trilinos_tpetra/tpetra_vector_03.cc create mode 100644 tests/trilinos_tpetra/tpetra_vector_03.with_trilinos_with_tpetra=on.with_complex_values=off.mpirun=2.output create mode 100644 tests/trilinos_tpetra/tpetra_vector_03.with_trilinos_with_tpetra=on.with_complex_values=off.mpirun=4.output create mode 100644 tests/trilinos_tpetra/tpetra_vector_03.with_trilinos_with_tpetra=on.with_complex_values=on.mpirun=2.output create mode 100644 tests/trilinos_tpetra/tpetra_vector_03.with_trilinos_with_tpetra=on.with_complex_values=on.mpirun=4.output create mode 100644 tests/trilinos_tpetra/vector_reference_01.cc create mode 100644 tests/trilinos_tpetra/vector_reference_01.output create mode 100644 tests/trilinos_tpetra/vector_reinit.cc create mode 100644 tests/trilinos_tpetra/vector_reinit.with_p4est=true.mpirun=3.output create mode 100644 tests/trilinos_tpetra/vector_swap_01.cc create mode 100644 tests/trilinos_tpetra/vector_swap_01.output diff --git a/tests/trilinos_tpetra/10.cc b/tests/trilinos_tpetra/10.cc new file mode 100644 index 0000000000..7993dfb7f3 --- /dev/null +++ b/tests/trilinos_tpetra/10.cc @@ -0,0 +1,105 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::SparseMatrix::operator /= + +#include + +#include + +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::SparseMatrix &m) +{ + // first set a few entries + for (unsigned int i = 0; i < m.m(); ++i) + for (unsigned int j = 0; j < m.m(); ++j) + if ((i + 2 * j + 1) % 3 == 0) + m.set(i, j, i * j * .5 + .5); + + m.compress(VectorOperation::insert); + + // then divide everything by 4/3 and + // make sure we retrieve the values we + // expect + m /= 4. / 3.; + + for (unsigned int i = 0; i < m.m(); ++i) + for (unsigned int j = 0; j < m.m(); ++j) + if ((i + 2 * j + 1) % 3 == 0) + { + AssertThrow(m(i, j) == (i * j * .5 + .5) / 4 * 3, ExcInternalError()); + AssertThrow(m.el(i, j) == (i * j * .5 + .5) / 4 * 3, + ExcInternalError()); + } + else + { + AssertThrow(m.el(i, j) == 0, ExcInternalError()); + } + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::SparseMatrix m(5U, 5U, 3U); + test(m); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/10.output b/tests/trilinos_tpetra/10.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/10.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/11.cc b/tests/trilinos_tpetra/11.cc new file mode 100644 index 0000000000..b7812837d4 --- /dev/null +++ b/tests/trilinos_tpetra/11.cc @@ -0,0 +1,88 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::Vector::size() + +#include + +#include + +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v) +{ + // set only certain elements of the vector + for (unsigned int i = 0; i < v.size(); i += 1 + i) + v(i) = i; + + v.compress(VectorOperation::insert); + + AssertThrow(v.size() == 100, ExcInternalError()); + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/11.output b/tests/trilinos_tpetra/11.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/11.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/12.cc b/tests/trilinos_tpetra/12.cc new file mode 100644 index 0000000000..5f03a77242 --- /dev/null +++ b/tests/trilinos_tpetra/12.cc @@ -0,0 +1,100 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::Vector::operator() in set-mode + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v) +{ + // set only certain elements of the + // vector. have a bit pattern of where we + // actually wrote elements to + std::vector pattern(v.size(), false); + for (unsigned int i = 0; i < v.size(); i += 1 + i) + { + v(i) = i; + pattern[i] = true; + } + + v.compress(VectorOperation::insert); + + // check that they are ok, and this time + // all of them + for (unsigned int i = 0; i < v.size(); ++i) + AssertThrow((((pattern[i] == true) && (v(i) == i)) || + ((pattern[i] == false) && (v(i) == 0))), + ExcInternalError()); + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/12.output b/tests/trilinos_tpetra/12.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/12.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/13.cc b/tests/trilinos_tpetra/13.cc new file mode 100644 index 0000000000..15bfbcc572 --- /dev/null +++ b/tests/trilinos_tpetra/13.cc @@ -0,0 +1,100 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::Vector::operator() in add-mode + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v) +{ + // set only certain elements of the + // vector. have a bit pattern of where we + // actually wrote elements to + std::vector pattern(v.size(), false); + for (unsigned int i = 0; i < v.size(); i += 1 + i) + { + v(i) += i; + pattern[i] = true; + } + + v.compress(VectorOperation::add); + + // check that they are ok, and this time + // all of them + for (unsigned int i = 0; i < v.size(); ++i) + AssertThrow((((pattern[i] == true) && (v(i) == i)) || + ((pattern[i] == false) && (v(i) == 0))), + ExcInternalError()); + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/13.output b/tests/trilinos_tpetra/13.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/13.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/14.cc b/tests/trilinos_tpetra/14.cc new file mode 100644 index 0000000000..7707caf3fd --- /dev/null +++ b/tests/trilinos_tpetra/14.cc @@ -0,0 +1,118 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::Vector::operator() in +// set/add-mode alternatingly. this test doesn't really make sense any more -- +// at least one a single processor. on multiple processors, one has to call +// compress() and it used to be that we had code that called compress() either +// with VectorOperation::insert or VectorOperation::add automatically whenever +// we switched from one kind of operation to the other. this is no longer the +// case -- the user has to select which operation herself. on the other hand, as +// long as we're working on a single processor, it doesn't matter +// anyway. +// +// so the test doesn't make much sense any more for the original +// purpose, but it's still worth keeping it around just to test that +// set and write operations on a single processor go right through to +// the stored data, rather than ending up in separate caches that only +// get flushed when the right kind of compress() function is called. + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v) +{ + // set only certain elements of the + // vector. have a bit pattern of where we + // actually wrote elements to + std::vector pattern(v.size(), false); + bool flag = false; + for (unsigned int i = 0; i < v.size(); i += 1 + i) + { + if (flag == true) + v(i) += i; + else + v(i) = i; + flag = !flag; + + pattern[i] = true; + } + + // check that they are ok, and this time + // all of them + for (unsigned int i = 0; i < v.size(); ++i) + AssertThrow((((pattern[i] == true) && (v(i) == i)) || + ((pattern[i] == false) && (v(i) == 0))), + ExcInternalError()); + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/14.output b/tests/trilinos_tpetra/14.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/14.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/15.cc b/tests/trilinos_tpetra/15.cc new file mode 100644 index 0000000000..2f7275eece --- /dev/null +++ b/tests/trilinos_tpetra/15.cc @@ -0,0 +1,118 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::Vector::operator() in +// set/add-mode alternatingly, but writing to the same elements +// +// this test doesn't really make sense any more -- at least one a +// single processor. on multiple processors, one has to call +// compress() and it used to be that we had code that called +// compress() either with VectorOperation::insert or +// VectorOperation::add automatically whenever we switched from one +// kind of operation to the other. this is no longer the case -- the +// user has to select which operation herself. on the other hand, as +// long as we're working on a single processor, it doesn't matter +// anyway. +// +// so the test doesn't make much sense any more for the original +// purpose, but it's still worth keeping it around just to test that +// set and write operations on a single processor go right through to +// the stored data, rather than ending up in separate caches that only +// get flushed when the right kind of compress() function is called. + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v) +{ + // set only certain elements of the + // vector. have a bit pattern of where we + // actually wrote elements to + std::vector pattern(v.size(), false); + for (unsigned int i = 0; i < v.size(); i += 1 + i) + { + v(i) = i; + pattern[i] = true; + } + v.compress(VectorOperation::insert); + for (unsigned int i = 0; i < v.size(); i += 1 + i) + v(i) += i; + + // check that they are ok, and this time + // all of them + for (unsigned int i = 0; i < v.size(); ++i) + AssertThrow((((pattern[i] == true) && (v(i) == 2 * i)) || + ((pattern[i] == false) && (v(i) == 0))), + ExcInternalError()); + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/15.output b/tests/trilinos_tpetra/15.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/15.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/16.cc b/tests/trilinos_tpetra/16.cc new file mode 100644 index 0000000000..8a66154686 --- /dev/null +++ b/tests/trilinos_tpetra/16.cc @@ -0,0 +1,119 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::Vector::operator() in +// set/add-mode alternatingly, but writing and overwriting the same elements +// +// this test doesn't really make sense any more -- at least one a +// single processor. on multiple processors, one has to call +// compress() and it used to be that we had code that called +// compress() either with VectorOperation::insert or +// VectorOperation::add automatically whenever we switched from one +// kind of operation to the other. this is no longer the case -- the +// user has to select which operation herself. on the other hand, as +// long as we're working on a single processor, it doesn't matter +// anyway. +// +// so the test doesn't make much sense any more for the original +// purpose, but it's still worth keeping it around just to test that +// set and write operations on a single processor go right through to +// the stored data, rather than ending up in separate caches that only +// get flushed when the right kind of compress() function is called. + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v) +{ + // set only certain elements of the + // vector. have a bit pattern of where we + // actually wrote elements to + std::vector pattern(v.size(), false); + for (unsigned int i = 0; i < v.size(); i += 1 + i) + { + v(i) = i; + pattern[i] = true; + } + for (unsigned int i = 0; i < v.size(); i += 1 + i) + v(i) += i; + for (unsigned int i = 0; i < v.size(); i += 1 + i) + v(i) = i; + + // check that they are ok, and this time + // all of them + for (unsigned int i = 0; i < v.size(); ++i) + AssertThrow((((pattern[i] == true) && (v(i) == i)) || + ((pattern[i] == false) && (v(i) == 0))), + ExcInternalError()); + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/16.output b/tests/trilinos_tpetra/16.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/16.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/17.cc b/tests/trilinos_tpetra/17.cc new file mode 100644 index 0000000000..c7df4fe252 --- /dev/null +++ b/tests/trilinos_tpetra/17.cc @@ -0,0 +1,93 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::Vector::l1_norm() + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v) +{ + // set some elements of the vector + double norm = 0; + for (unsigned int i = 0; i < v.size(); i += 1 + i) + { + v(i) = i; + norm += std::fabs(1. * i); + } + v.compress(VectorOperation::insert); + + // then check the norm + AssertThrow(v.l1_norm() == norm, ExcInternalError()); + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/17.output b/tests/trilinos_tpetra/17.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/17.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/18.cc b/tests/trilinos_tpetra/18.cc new file mode 100644 index 0000000000..d3a58a9b00 --- /dev/null +++ b/tests/trilinos_tpetra/18.cc @@ -0,0 +1,94 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::Vector::l2_norm() + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v) +{ + // set some elements of the vector + TrilinosScalar norm = 0; + for (unsigned int i = 0; i < v.size(); i += 1 + i) + { + v(i) = i; + norm += std::fabs(1. * i) * std::fabs(1. * i); + } + v.compress(VectorOperation::insert); + + // then check the norm + const double eps = typeid(TrilinosScalar) == typeid(double) ? 1e-14 : 1e-5; + AssertThrow(fabs(v.l2_norm() - std::sqrt(norm)) < eps, ExcInternalError()); + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/18.output b/tests/trilinos_tpetra/18.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/18.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/19.cc b/tests/trilinos_tpetra/19.cc new file mode 100644 index 0000000000..cd971997c7 --- /dev/null +++ b/tests/trilinos_tpetra/19.cc @@ -0,0 +1,93 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::Vector::linfty_norm() + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v) +{ + // set some elements of the vector + double norm = 0; + for (unsigned int i = 0; i < v.size(); i += 1 + i) + { + v(i) = i; + norm = std::max(norm, fabs(i)); + } + v.compress(VectorOperation::insert); + + // then check the norm + AssertThrow(v.linfty_norm() == norm, ExcInternalError()); + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/19.output b/tests/trilinos_tpetra/19.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/19.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/20.cc b/tests/trilinos_tpetra/20.cc new file mode 100644 index 0000000000..27968f9fe1 --- /dev/null +++ b/tests/trilinos_tpetra/20.cc @@ -0,0 +1,101 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::Vector::operator *= + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v) +{ + // set only certain elements of the + // vector. have a bit pattern of where we + // actually wrote elements to + std::vector pattern(v.size(), false); + for (unsigned int i = 0; i < v.size(); i += 1 + i) + { + v(i) = i; + pattern[i] = true; + } + v.compress(VectorOperation::insert); + + // multiply v with 5/4 + v *= 5. / 4.; + + // check that the entries are ok + for (unsigned int i = 0; i < v.size(); ++i) + AssertThrow((((pattern[i] == true) && (v(i) == i * 5. / 4.)) || + ((pattern[i] == false) && (v(i) == 0))), + ExcInternalError()); + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/20.output b/tests/trilinos_tpetra/20.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/20.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/21.cc b/tests/trilinos_tpetra/21.cc new file mode 100644 index 0000000000..4defc6c13b --- /dev/null +++ b/tests/trilinos_tpetra/21.cc @@ -0,0 +1,101 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::Vector::operator /= + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v) +{ + // set only certain elements of the + // vector. have a bit pattern of where we + // actually wrote elements to + std::vector pattern(v.size(), false); + for (unsigned int i = 0; i < v.size(); i += 1 + i) + { + v(i) = i; + pattern[i] = true; + } + v.compress(VectorOperation::insert); + + // multiply v with 3/4 + v /= 4. / 3.; + + // check that the entries are ok + for (unsigned int i = 0; i < v.size(); ++i) + AssertThrow((((pattern[i] == true) && (v(i) == i * 3. / 4.)) || + ((pattern[i] == false) && (v(i) == 0))), + ExcInternalError()); + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/21.output b/tests/trilinos_tpetra/21.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/21.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/22.cc b/tests/trilinos_tpetra/22.cc new file mode 100644 index 0000000000..6ae4d9b51c --- /dev/null +++ b/tests/trilinos_tpetra/22.cc @@ -0,0 +1,98 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::Vector::operator*(Vector) on two +// vectors that are orthogonal + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v, + LinearAlgebra::TpetraWrappers::Vector &w) +{ + // set only certain elements of each + // vector, but disjoint sets of elements + for (unsigned int i = 0; i < v.size(); ++i) + if (i % 3 == 0) + v(i) = i; + else + w(i) = i; + v.compress(VectorOperation::insert); + w.compress(VectorOperation::insert); + + // make sure the scalar product is zero + AssertThrow(v * w == 0, ExcInternalError()); + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + LinearAlgebra::TpetraWrappers::Vector w; + w.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v, w); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/22.output b/tests/trilinos_tpetra/22.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/22.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/23.cc b/tests/trilinos_tpetra/23.cc new file mode 100644 index 0000000000..6cdefb2688 --- /dev/null +++ b/tests/trilinos_tpetra/23.cc @@ -0,0 +1,105 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::Vector::operator*(Vector) on two +// vectors that are not orthogonal + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v, + LinearAlgebra::TpetraWrappers::Vector &w) +{ + // set only certain elements of each + // vector, and record the expected scalar + // product + double product = 0; + for (unsigned int i = 0; i < v.size(); ++i) + { + v(i) = i; + if (i % 3 == 0) + { + w(i) = i + 1.; + product += i * (i + 1); + } + } + + v.compress(VectorOperation::insert); + w.compress(VectorOperation::insert); + + // make sure the scalar product is zero + AssertThrow(v * w == product, ExcInternalError()); + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + LinearAlgebra::TpetraWrappers::Vector w; + w.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v, w); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/23.output b/tests/trilinos_tpetra/23.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/23.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/24.cc b/tests/trilinos_tpetra/24.cc new file mode 100644 index 0000000000..3c655c8015 --- /dev/null +++ b/tests/trilinos_tpetra/24.cc @@ -0,0 +1,97 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// this test used to check for +// LinearAlgebra::TpetraWrappers::Vector::clear(). However, this +// function has since been removed, so we test for v=0 instead, although that +// may be covered by one of the other tests + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v) +{ + // set some entries of the vector + for (unsigned int i = 0; i < v.size(); ++i) + if (i % 3 == 0) + v(i) = i + 1.; + v.compress(VectorOperation::insert); + + // then clear it again and make sure the + // vector is really empty + const unsigned int sz = v.size(); + v = 0; + AssertThrow(v.size() == sz, ExcInternalError()); + AssertThrow(v.l2_norm() == 0, ExcInternalError()); + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/24.output b/tests/trilinos_tpetra/24.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/24.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/27.cc b/tests/trilinos_tpetra/27.cc new file mode 100644 index 0000000000..b5462b97ac --- /dev/null +++ b/tests/trilinos_tpetra/27.cc @@ -0,0 +1,99 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::Vector::operator = (Vector) + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v) +{ + // set some entries of the vector + for (unsigned int i = 0; i < v.size(); ++i) + if (i % 3 == 0) + v(i) = i + 1.; + v.compress(VectorOperation::insert); + + // then copy it + LinearAlgebra::TpetraWrappers::Vector w; + w.reinit(complete_index_set(v.size()), MPI_COMM_WORLD); + w = v; + + // make sure they're equal + deallog << v * w << ' ' << v.l2_norm() * w.l2_norm() << ' ' + << v * w - v.l2_norm() * w.l2_norm() << std::endl; + const double eps = typeid(TrilinosScalar) == typeid(double) ? 1e-14 : 1e-5; + Assert(std::fabs(v * w - v.l2_norm() * w.l2_norm()) < eps * (v * w), + ExcInternalError()); + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/27.output b/tests/trilinos_tpetra/27.output new file mode 100644 index 0000000000..8c7039a8d1 --- /dev/null +++ b/tests/trilinos_tpetra/27.output @@ -0,0 +1,3 @@ + +DEAL::116161. 116161. 0 +DEAL::OK diff --git a/tests/trilinos_tpetra/28.cc b/tests/trilinos_tpetra/28.cc new file mode 100644 index 0000000000..13a19488eb --- /dev/null +++ b/tests/trilinos_tpetra/28.cc @@ -0,0 +1,101 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::Vector::operator = (Vector), +// except that we don't resize the vector to be copied to beforehand + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v) +{ + // set some entries of the vector + for (unsigned int i = 0; i < v.size(); ++i) + if (i % 3 == 0) + v(i) = i + 1.; + v.compress(VectorOperation::insert); + + // then copy it to a vector of different + // size + LinearAlgebra::TpetraWrappers::Vector w; + w.reinit(complete_index_set(1), MPI_COMM_WORLD); + w = v; + + // make sure they're equal + deallog << v * w << ' ' << v.l2_norm() * w.l2_norm() << ' ' + << v * w - v.l2_norm() * w.l2_norm() << std::endl; + const double eps = typeid(TrilinosScalar) == typeid(double) ? 1e-14 : 1e-5; + Assert(std::fabs(v * w - v.l2_norm() * w.l2_norm()) < eps * (v * w), + ExcInternalError()); + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/28.output b/tests/trilinos_tpetra/28.output new file mode 100644 index 0000000000..8c7039a8d1 --- /dev/null +++ b/tests/trilinos_tpetra/28.output @@ -0,0 +1,3 @@ + +DEAL::116161. 116161. 0 +DEAL::OK diff --git a/tests/trilinos_tpetra/29.cc b/tests/trilinos_tpetra/29.cc new file mode 100644 index 0000000000..6d7730afb7 --- /dev/null +++ b/tests/trilinos_tpetra/29.cc @@ -0,0 +1,85 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::Vector::reinit(fast) + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v) +{ + v.reinit(complete_index_set(13), MPI_COMM_WORLD); + + AssertThrow(v.size() == 13, ExcInternalError()); + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/29.output b/tests/trilinos_tpetra/29.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/29.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/30.cc b/tests/trilinos_tpetra/30.cc new file mode 100644 index 0000000000..9dce37dd37 --- /dev/null +++ b/tests/trilinos_tpetra/30.cc @@ -0,0 +1,93 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::Vector::reinit(!fast) + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v) +{ + // set some entries of the vector + for (unsigned int i = 0; i < v.size(); ++i) + if (i % 3 == 0) + v(i) = i + 1.; + v.compress(VectorOperation::insert); + + // then resize with setting to zero + v.reinit(complete_index_set(13), MPI_COMM_WORLD); + + AssertThrow(v.size() == 13, ExcInternalError()); + AssertThrow(v.l2_norm() == 0, ExcInternalError()); + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/30.output b/tests/trilinos_tpetra/30.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/30.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/31.cc b/tests/trilinos_tpetra/31.cc new file mode 100644 index 0000000000..037fd32fda --- /dev/null +++ b/tests/trilinos_tpetra/31.cc @@ -0,0 +1,94 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::Vector::l2_norm() + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v) +{ + // set some elements of the vector + TrilinosScalar norm = 0; + for (unsigned int i = 0; i < v.size(); i += 1 + i) + { + v(i) = i; + norm += std::fabs(1. * i) * std::fabs(1. * i); + } + v.compress(VectorOperation::insert); + + // then check the norm + const double eps = typeid(TrilinosScalar) == typeid(double) ? 1e-14 : 1e-5; + AssertThrow(std::fabs(v.norm_sqr() - norm) < eps * norm, ExcInternalError()); + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/31.output b/tests/trilinos_tpetra/31.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/31.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/32.cc b/tests/trilinos_tpetra/32.cc new file mode 100644 index 0000000000..7c1164764c --- /dev/null +++ b/tests/trilinos_tpetra/32.cc @@ -0,0 +1,95 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::Vector::mean_value() + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v) +{ + // set some elements of the vector + TrilinosScalar sum = 0; + for (unsigned int i = 0; i < v.size(); i += 1 + i) + { + v(i) = i; + sum += i; + } + v.compress(VectorOperation::insert); + + // then check the norm + const double eps = typeid(TrilinosScalar) == typeid(double) ? 1e-14 : 1e-5; + AssertThrow(std::fabs(v.mean_value() - sum / v.size()) < eps * sum / v.size(), + ExcInternalError()); + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/32.output b/tests/trilinos_tpetra/32.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/32.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/34.cc b/tests/trilinos_tpetra/34.cc new file mode 100644 index 0000000000..c9e92621b2 --- /dev/null +++ b/tests/trilinos_tpetra/34.cc @@ -0,0 +1,96 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::Vector::all_zero + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v) +{ + // set some elements of the vector + double sum = 0; + for (unsigned int i = 0; i < v.size(); i += 1 + i) + { + v(i) = i; + sum += i * i * i; + } + v.compress(VectorOperation::insert); + + // set them to zero again + v = 0; + + // then check all_zero + AssertThrow(v.all_zero() == true, ExcInternalError()); + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/34.output b/tests/trilinos_tpetra/34.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/34.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/35.cc b/tests/trilinos_tpetra/35.cc new file mode 100644 index 0000000000..6c3392e769 --- /dev/null +++ b/tests/trilinos_tpetra/35.cc @@ -0,0 +1,114 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::Vector::operator+=(Vector) + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v, + LinearAlgebra::TpetraWrappers::Vector &w) +{ + // set only certain elements of each + // vector + for (unsigned int i = 0; i < v.size(); ++i) + { + v(i) = i; + if (i % 3 == 0) + w(i) = i + 1.; + } + + v.compress(VectorOperation::insert); + w.compress(VectorOperation::insert); + + v += w; + + // make sure we get the expected result + for (unsigned int i = 0; i < v.size(); ++i) + { + if (i % 3 == 0) + { + AssertThrow(w(i) == i + 1., ExcInternalError()); + AssertThrow(v(i) == i + i + 1., ExcInternalError()); + } + else + { + AssertThrow(w(i) == 0, ExcInternalError()); + AssertThrow(v(i) == i, ExcInternalError()); + } + } + + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + LinearAlgebra::TpetraWrappers::Vector w; + w.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v, w); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/35.output b/tests/trilinos_tpetra/35.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/35.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/36.cc b/tests/trilinos_tpetra/36.cc new file mode 100644 index 0000000000..d1d79429b1 --- /dev/null +++ b/tests/trilinos_tpetra/36.cc @@ -0,0 +1,114 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::Vector::operator-=(Vector) + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v, + LinearAlgebra::TpetraWrappers::Vector &w) +{ + // set only certain elements of each + // vector + for (unsigned int i = 0; i < v.size(); ++i) + { + v(i) = i; + if (i % 3 == 0) + w(i) = i + 1.; + } + + v.compress(VectorOperation::insert); + w.compress(VectorOperation::insert); + + v -= w; + + // make sure we get the expected result + for (unsigned int i = 0; i < v.size(); ++i) + { + if (i % 3 == 0) + { + AssertThrow(w(i) == i + 1., ExcInternalError()); + AssertThrow(v(i) == i - (i + 1.), ExcInternalError()); + } + else + { + AssertThrow(w(i) == 0, ExcInternalError()); + AssertThrow(v(i) == i, ExcInternalError()); + } + } + + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + LinearAlgebra::TpetraWrappers::Vector w; + w.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v, w); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/36.output b/tests/trilinos_tpetra/36.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/36.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/37.cc b/tests/trilinos_tpetra/37.cc new file mode 100644 index 0000000000..bf4b758f35 --- /dev/null +++ b/tests/trilinos_tpetra/37.cc @@ -0,0 +1,92 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::Vector::add (scalar) + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v) +{ + for (unsigned int i = 0; i < v.size(); ++i) + v(i) = i; + + v.compress(VectorOperation::insert); + + v.add(1.); + + // make sure we get the expected result + for (unsigned int i = 0; i < v.size(); ++i) + AssertThrow(v(i) == i + 1., ExcInternalError()); + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/37.output b/tests/trilinos_tpetra/37.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/37.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/39.cc b/tests/trilinos_tpetra/39.cc new file mode 100644 index 0000000000..b898cc4b33 --- /dev/null +++ b/tests/trilinos_tpetra/39.cc @@ -0,0 +1,102 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::Vector::add(scalar, Vector) + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v, + LinearAlgebra::TpetraWrappers::Vector &w) +{ + for (unsigned int i = 0; i < v.size(); ++i) + { + v(i) = i; + w(i) = i + 1.; + } + + v.compress(VectorOperation::insert); + w.compress(VectorOperation::insert); + + v.add(2, w); + + // make sure we get the expected result + for (unsigned int i = 0; i < v.size(); ++i) + { + AssertThrow(w(i) == i + 1., ExcInternalError()); + AssertThrow(v(i) == i + 2 * (i + 1.), ExcInternalError()); + } + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + LinearAlgebra::TpetraWrappers::Vector w; + w.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v, w); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/39.output b/tests/trilinos_tpetra/39.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/39.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/40.cc b/tests/trilinos_tpetra/40.cc new file mode 100644 index 0000000000..c5ffb5c218 --- /dev/null +++ b/tests/trilinos_tpetra/40.cc @@ -0,0 +1,108 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::Vector::add(s,V,s,V) + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v, + LinearAlgebra::TpetraWrappers::Vector &w, + LinearAlgebra::TpetraWrappers::Vector &x) +{ + for (unsigned int i = 0; i < v.size(); ++i) + { + v(i) = i; + w(i) = i + 1.; + x(i) = i + 2.; + } + + v.compress(VectorOperation::insert); + w.compress(VectorOperation::insert); + x.compress(VectorOperation::insert); + + v.add(2, w, 3, x); + + // make sure we get the expected result + for (unsigned int i = 0; i < v.size(); ++i) + { + AssertThrow(w(i) == i + 1., ExcInternalError()); + AssertThrow(x(i) == i + 2., ExcInternalError()); + AssertThrow(v(i) == i + 2 * (i + 1.) + 3 * (i + 2.), ExcInternalError()); + } + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + LinearAlgebra::TpetraWrappers::Vector w; + w.reinit(complete_index_set(100), MPI_COMM_WORLD); + LinearAlgebra::TpetraWrappers::Vector x; + x.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v, w, x); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/40.output b/tests/trilinos_tpetra/40.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/40.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/42.cc b/tests/trilinos_tpetra/42.cc new file mode 100644 index 0000000000..217b450f1d --- /dev/null +++ b/tests/trilinos_tpetra/42.cc @@ -0,0 +1,103 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::Vector::sadd(scalar, scalar, +// Vector) + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v, + LinearAlgebra::TpetraWrappers::Vector &w) +{ + for (unsigned int i = 0; i < v.size(); ++i) + { + v(i) = i; + w(i) = i + 1.; + } + + v.compress(VectorOperation::insert); + w.compress(VectorOperation::insert); + + v.sadd(3, 2, w); + + // make sure we get the expected result + for (unsigned int i = 0; i < v.size(); ++i) + { + AssertThrow(w(i) == i + 1., ExcInternalError()); + AssertThrow(v(i) == 3 * i + 2 * (i + 1.), ExcInternalError()); + } + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + LinearAlgebra::TpetraWrappers::Vector w; + w.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v, w); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/42.output b/tests/trilinos_tpetra/42.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/42.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/45.cc b/tests/trilinos_tpetra/45.cc new file mode 100644 index 0000000000..d75942f464 --- /dev/null +++ b/tests/trilinos_tpetra/45.cc @@ -0,0 +1,102 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::Vector::scale + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v, + LinearAlgebra::TpetraWrappers::Vector &w) +{ + for (unsigned int i = 0; i < v.size(); ++i) + { + v(i) = i; + w(i) = i + 1.; + } + + v.compress(VectorOperation::insert); + w.compress(VectorOperation::insert); + + v.scale(w); + + // make sure we get the expected result + for (unsigned int i = 0; i < v.size(); ++i) + { + AssertThrow(w(i) == i + 1., ExcInternalError()); + AssertThrow(v(i) == i * (i + 1.), ExcInternalError()); + } + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + LinearAlgebra::TpetraWrappers::Vector w; + w.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v, w); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/45.output b/tests/trilinos_tpetra/45.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/45.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/46.cc b/tests/trilinos_tpetra/46.cc new file mode 100644 index 0000000000..842b08b71f --- /dev/null +++ b/tests/trilinos_tpetra/46.cc @@ -0,0 +1,102 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::Vector::equ (s,V) + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v, + LinearAlgebra::TpetraWrappers::Vector &w) +{ + for (unsigned int i = 0; i < v.size(); ++i) + { + v(i) = i; + w(i) = i + 1.; + } + + v.compress(VectorOperation::insert); + w.compress(VectorOperation::insert); + + v.equ(2, w); + + // make sure we get the expected result + for (unsigned int i = 0; i < v.size(); ++i) + { + AssertThrow(w(i) == i + 1., ExcInternalError()); + AssertThrow(v(i) == 2 * (i + 1.), ExcInternalError()); + } + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + LinearAlgebra::TpetraWrappers::Vector w; + w.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v, w); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/46.output b/tests/trilinos_tpetra/46.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/46.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/51.cc b/tests/trilinos_tpetra/51.cc new file mode 100644 index 0000000000..0f7dbfcca4 --- /dev/null +++ b/tests/trilinos_tpetra/51.cc @@ -0,0 +1,99 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check copy constructor +// LinearAlgebra::TpetraWrappers::Vector::Vector(Vector) + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v) +{ + // set some entries of the vector + for (unsigned int i = 0; i < v.size(); ++i) + if (i % 3 == 0) + v(i) = i + 1.; + v.compress(VectorOperation::insert); + + // then copy it + LinearAlgebra::TpetraWrappers::Vector w(v); + w.compress(VectorOperation::insert); + + // make sure they're equal + deallog << v * w << ' ' << v.l2_norm() * w.l2_norm() << ' ' + << v * w - v.l2_norm() * w.l2_norm() << std::endl; + const double eps = typeid(TrilinosScalar) == typeid(double) ? 1e-14 : 1e-5; + Assert(std::fabs(v * w - v.l2_norm() * w.l2_norm()) < eps * (v * w), + ExcInternalError()); + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/51.output b/tests/trilinos_tpetra/51.output new file mode 100644 index 0000000000..8c7039a8d1 --- /dev/null +++ b/tests/trilinos_tpetra/51.output @@ -0,0 +1,3 @@ + +DEAL::116161. 116161. 0 +DEAL::OK diff --git a/tests/trilinos_tpetra/52.cc b/tests/trilinos_tpetra/52.cc new file mode 100644 index 0000000000..ae5ca24728 --- /dev/null +++ b/tests/trilinos_tpetra/52.cc @@ -0,0 +1,107 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check setting elements in a petsc matrix using +// LinearAlgebra::TpetraWrappers::SparseMatrix::set(). like trilinos_01, +// but use a different constructor for the sparse matrix + +#include + +#include + +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::SparseMatrix &m) +{ + // first set a few entries + for (unsigned int i = 0; i < m.m(); ++i) + for (unsigned int j = 0; j < m.m(); ++j) + if ((i + 2 * j + 1) % 3 == 0) + m.set(i, j, i * j * .5 + .5); + + m.compress(VectorOperation::insert); + + // then make sure we retrieve the same ones + for (unsigned int i = 0; i < m.m(); ++i) + for (unsigned int j = 0; j < m.m(); ++j) + if ((i + 2 * j + 1) % 3 == 0) + { + AssertThrow(m(i, j) == i * j * .5 + .5, ExcInternalError()); + AssertThrow(m.el(i, j) == i * j * .5 + .5, ExcInternalError()); + } + else + { + AssertThrow(m.el(i, j) == 0, ExcInternalError()); + } + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + std::vector row_lengths(5, 3U); + row_lengths.back() = 2; + LinearAlgebra::TpetraWrappers::SparseMatrix m( + static_cast(5U), + static_cast(5U), + row_lengths); + test(m); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/52.output b/tests/trilinos_tpetra/52.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/52.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/53.cc b/tests/trilinos_tpetra/53.cc new file mode 100644 index 0000000000..455e6e0e17 --- /dev/null +++ b/tests/trilinos_tpetra/53.cc @@ -0,0 +1,104 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::Vector::operator() in set, and +// later in add-mode + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v) +{ + // set only certain elements of the + // vector. have a bit pattern of where we + // actually wrote elements to + std::vector pattern(v.size(), false); + for (unsigned int i = 0; i < v.size(); i += 1 + i) + { + v(i) = i; + pattern[i] = true; + } + v.compress(VectorOperation::insert); + for (unsigned int i = 0; i < v.size(); i += 1 + i) + v(i) += i; + + v.compress(VectorOperation::add); + + // check that they are ok, and this time + // all of them + for (unsigned int i = 0; i < v.size(); ++i) + AssertThrow((((pattern[i] == true) && (v(i) == 2 * i)) || + ((pattern[i] == false) && (v(i) == 0))), + ExcInternalError()); + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/53.output b/tests/trilinos_tpetra/53.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/53.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/54.cc b/tests/trilinos_tpetra/54.cc new file mode 100644 index 0000000000..cdd117b46e --- /dev/null +++ b/tests/trilinos_tpetra/54.cc @@ -0,0 +1,104 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::Vector::operator() in set, and +// later in -= mode + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v) +{ + // set only certain elements of the + // vector. have a bit pattern of where we + // actually wrote elements to + std::vector pattern(v.size(), false); + for (unsigned int i = 0; i < v.size(); i += 1 + i) + { + v(i) = 2 * i; + pattern[i] = true; + } + v.compress(VectorOperation::insert); + for (unsigned int i = 0; i < v.size(); i += 1 + i) + v(i) -= i; + + v.compress(VectorOperation::add); + + // check that they are ok, and this time + // all of them + for (unsigned int i = 0; i < v.size(); ++i) + AssertThrow((((pattern[i] == true) && (v(i) == i)) || + ((pattern[i] == false) && (v(i) == 0))), + ExcInternalError()); + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/54.output b/tests/trilinos_tpetra/54.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/54.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/55.cc b/tests/trilinos_tpetra/55.cc new file mode 100644 index 0000000000..69aeb7b5f9 --- /dev/null +++ b/tests/trilinos_tpetra/55.cc @@ -0,0 +1,103 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::Vector::operator() in set, and +// later in *= mode + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v) +{ + // set only certain elements of the + // vector. have a bit pattern of where we + // actually wrote elements to + std::vector pattern(v.size(), false); + for (unsigned int i = 0; i < v.size(); i += 1 + i) + { + v(i) = i; + pattern[i] = true; + } + for (unsigned int i = 0; i < v.size(); i += 1 + i) + v(i) *= 2; + + v.compress(VectorOperation::insert); + + // check that they are ok, and this time + // all of them + for (unsigned int i = 0; i < v.size(); ++i) + AssertThrow((((pattern[i] == true) && (v(i) == 2 * i)) || + ((pattern[i] == false) && (v(i) == 0))), + ExcInternalError()); + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/55.output b/tests/trilinos_tpetra/55.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/55.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/56.cc b/tests/trilinos_tpetra/56.cc new file mode 100644 index 0000000000..ef4bc94db7 --- /dev/null +++ b/tests/trilinos_tpetra/56.cc @@ -0,0 +1,103 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::Vector::operator() in set, and +// later in /= mode + +#include + +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v) +{ + // set only certain elements of the + // vector. have a bit pattern of where we + // actually wrote elements to + std::vector pattern(v.size(), false); + for (unsigned int i = 0; i < v.size(); i += 1 + i) + { + v(i) = 2 * i; + pattern[i] = true; + } + for (unsigned int i = 0; i < v.size(); i += 1 + i) + v(i) /= 2; + + v.compress(VectorOperation::insert); + + // check that they are ok, and this time + // all of them + for (unsigned int i = 0; i < v.size(); ++i) + AssertThrow((((pattern[i] == true) && (v(i) == i)) || + ((pattern[i] == false) && (v(i) == 0))), + ExcInternalError()); + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/56.output b/tests/trilinos_tpetra/56.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/56.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/63.cc b/tests/trilinos_tpetra/63.cc new file mode 100644 index 0000000000..52f0eca2dc --- /dev/null +++ b/tests/trilinos_tpetra/63.cc @@ -0,0 +1,87 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +#include + +#include +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::SparseMatrix &m) +{ + AssertThrow(m.m() == 100, ExcInternalError()); + AssertThrow(m.n() == 100, ExcInternalError()); + + m = 0; + + AssertThrow(m.m() == 100, ExcInternalError()); + AssertThrow(m.n() == 100, ExcInternalError()); + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::SparseMatrix v(100U, 100U, 5U); + test(v); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/63.output b/tests/trilinos_tpetra/63.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/63.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/70.cc b/tests/trilinos_tpetra/70.cc new file mode 100644 index 0000000000..6c11559eeb --- /dev/null +++ b/tests/trilinos_tpetra/70.cc @@ -0,0 +1,42 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check TrilinosScalar + +#include + +#include + +#include "../tests.h" + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + if (typeid(TrilinosScalar) == typeid(double)) + deallog << "double" << std::endl; + else if (typeid(TrilinosScalar) == typeid(float)) + deallog << "float" << std::endl; + else + DEAL_II_NOT_IMPLEMENTED(); +} diff --git a/tests/trilinos_tpetra/70.output b/tests/trilinos_tpetra/70.output new file mode 100644 index 0000000000..04c108ac22 --- /dev/null +++ b/tests/trilinos_tpetra/70.output @@ -0,0 +1,2 @@ + +DEAL::double diff --git a/tests/trilinos_tpetra/index_set_01.cc b/tests/trilinos_tpetra/index_set_01.cc new file mode 100644 index 0000000000..64fbed0898 --- /dev/null +++ b/tests/trilinos_tpetra/index_set_01.cc @@ -0,0 +1,68 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2016 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check that make_trilinos_map always uses the same constructor all the +// processor. If we don't the code will hang like reported on the mailing list +// by Nicola Giuliani. + +#include +#include + +#include + +#include "../tests.h" + + + +void +test() +{ + IndexSet my_set; + my_set.set_size(654); + int this_mpi_process, n_mpi_processes; + n_mpi_processes = Utilities::MPI::n_mpi_processes(MPI_COMM_WORLD); + this_mpi_process = Utilities::MPI::this_mpi_process(MPI_COMM_WORLD); + if (this_mpi_process == 0) + { + my_set.add_range(0, 86); + } + else if (this_mpi_process == 1) + { + my_set.add_range(86, 400); + my_set.add_range(529, 654); + } + else + { + my_set.add_range(400, 529); + } + my_set.compress(); + my_set.make_tpetra_map(MPI_COMM_WORLD, false); +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + test(); + + deallog << "OK" << std::endl; +} diff --git a/tests/trilinos_tpetra/index_set_01.mpirun=3.output b/tests/trilinos_tpetra/index_set_01.mpirun=3.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/index_set_01.mpirun=3.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/parallel_sparse_matrix_01.cc b/tests/trilinos_tpetra/parallel_sparse_matrix_01.cc new file mode 100644 index 0000000000..de39f89844 --- /dev/null +++ b/tests/trilinos_tpetra/parallel_sparse_matrix_01.cc @@ -0,0 +1,146 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2022 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// LinearAlgebra::TpetraWrappers::SparseMatrix::reinit(DynamicSparsityPattern) +// should create a matrix that, when filled with elements that match the +// sparsity pattern, doesn't require any more memory allocation any more. This +// is tricky to get right, though, and took a while until it worked. +// +// the test itself can only check this when run in parallel, but we can add it +// anyway to the testsuite. in order to check that the library actually does +// what it is supposed to do, run this program with more than one MPI process +// and with the option -log_info. All the output should say that no additional +// malloc calls have been performed + +#include +#include + +#include +#include + +#include "../tests.h" + + +void +test() +{ + // create a parallel matrix where the first + // process has 10 rows, the second one 20, + // the third one 30, and so on + unsigned int N = 0; + std::vector local_rows_per_process( + Utilities::Trilinos::get_n_mpi_processes( + Utilities::Trilinos::comm_world())); + std::vector start_row(Utilities::Trilinos::get_n_mpi_processes( + Utilities::Trilinos::comm_world())); + for (unsigned int i = 0; i < Utilities::Trilinos::get_n_mpi_processes( + Utilities::Trilinos::comm_world()); + ++i) + { + N += (i + 1) * 10; + local_rows_per_process[i] = (i + 1) * 10; + start_row[i] += i * 10; + } + + // here is a sparsity pattern for which we + // used to allocate additional memory for 2 + // processes. note that only one of the + // four blocks uses Inodes + DynamicSparsityPattern csp(N, N); + for (unsigned int i = 0; i < N; ++i) + for (unsigned int j = 0; j < N; ++j) + { + csp.add(i, i); + if (i + local_rows_per_process.back() < N) + csp.add(i, i + local_rows_per_process.back()); + if (i > local_rows_per_process.back()) + csp.add(i, i - local_rows_per_process.back()); + } + + // here is a sparsity pattern for which no + // Inodes are used, but it doesn't allocate + // additional memory + // for (unsigned int bi=0; bi m; + m.reinit(locally_owned_dofs, locally_owned_dofs, csp, MPI_COMM_WORLD); + // now write into the exact same matrix + // entries as have been created by the + // sparsity pattern above + for (unsigned int i = 0; i < N; ++i) + for (unsigned int j = 0; j < csp.row_length(i); ++j) + m.add(i, csp.column_number(i, j), 1.); + + m.compress(VectorOperation::add); + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + test(); + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/parallel_sparse_matrix_01.output b/tests/trilinos_tpetra/parallel_sparse_matrix_01.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/parallel_sparse_matrix_01.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/slowness_01.cc b/tests/trilinos_tpetra/slowness_01.cc new file mode 100644 index 0000000000..5a1d4533e8 --- /dev/null +++ b/tests/trilinos_tpetra/slowness_01.cc @@ -0,0 +1,155 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2005 - 2021 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// this is part of a whole suite of tests that checks the relative speed of +// using Trilinos for sparse matrices as compared to the speed of our own +// library. the tests therefore may not all actually use Trilinos, but they are +// meant to compare it +// +// the tests build the 5-point stencil matrix for a uniform grid of size N*N + +#include + +#include +#include +#include + +#include + +#include "../tests.h" + + +void +test() +{ + const unsigned int N = 200; + + // first build the sparsity pattern + SparsityPattern sparsity(N * N, N * N, 5); + for (unsigned int i = 0; i < N; ++i) + for (unsigned int j = 0; j < N; ++j) + { + const unsigned int global = i * N + j; + sparsity.add(global, global); + if (j > 0) + { + sparsity.add(global - 1, global); + sparsity.add(global, global - 1); + } + if (j < N - 1) + { + sparsity.add(global + 1, global); + sparsity.add(global, global + 1); + } + if (i > 0) + { + sparsity.add(global - N, global); + sparsity.add(global, global - N); + } + if (i < N - 1) + { + sparsity.add(global + N, global); + sparsity.add(global, global + N); + } + } + sparsity.compress(); + + + // next build the sparse matrix itself + SparseMatrix matrix(sparsity); + for (unsigned int i = 0; i < N; ++i) + for (unsigned int j = 0; j < N; ++j) + { + const unsigned int global = i * N + j; + matrix.add(global, global, 4); + if (j > 0) + { + matrix.add(global - 1, global, -1); + matrix.add(global, global - 1, -1); + } + if (j < N - 1) + { + matrix.add(global + 1, global, -1); + matrix.add(global, global + 1, -1); + } + if (i > 0) + { + matrix.add(global - N, global, -1); + matrix.add(global, global - N, -1); + } + if (i < N - 1) + { + matrix.add(global + N, global, -1); + matrix.add(global, global + N, -1); + } + } + + // then do a single matrix-vector + // multiplication with subsequent formation + // of the matrix norm + Vector v1(N * N), v2(N * N); + for (unsigned int i = 0; i < N * N; ++i) + v1(i) = i; + matrix.vmult(v2, v1); + + deallog << v1 * v2 << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + try + { + { + test(); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; + return 0; +} diff --git a/tests/trilinos_tpetra/slowness_01.output b/tests/trilinos_tpetra/slowness_01.output new file mode 100644 index 0000000000..0d89007eb8 --- /dev/null +++ b/tests/trilinos_tpetra/slowness_01.output @@ -0,0 +1,2 @@ + +DEAL::-8.42635e+13 diff --git a/tests/trilinos_tpetra/slowness_02.cc b/tests/trilinos_tpetra/slowness_02.cc new file mode 100644 index 0000000000..ea1329b6c6 --- /dev/null +++ b/tests/trilinos_tpetra/slowness_02.cc @@ -0,0 +1,129 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2005 - 2021 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// this is part of a whole suite of tests that checks the relative speed of +// using Trilinos for sparse matrices as compared to the speed of our own +// library. the tests therefore may not all actually use Trilinos, but they are +// meant to compare it +// +// the tests build the 5-point stencil matrix for a uniform grid of size N*N + +#include + +#include +#include +#include + +#include + +#include "../tests.h" + + +void +test() +{ + const unsigned int N = 200; + + // build the sparse matrix + LinearAlgebra::TpetraWrappers::SparseMatrix matrix(N * N, N * N, 5U); + for (unsigned int i = 0; i < N; ++i) + for (unsigned int j = 0; j < N; ++j) + { + const unsigned int global = i * N + j; + matrix.set(global, global, 4); + if (j > 0) + { + matrix.set(global - 1, global, -1); + matrix.set(global, global - 1, -1); + } + if (j < N - 1) + { + matrix.set(global + 1, global, -1); + matrix.set(global, global + 1, -1); + } + if (i > 0) + { + matrix.set(global - N, global, -1); + matrix.set(global, global - N, -1); + } + if (i < N - 1) + { + matrix.set(global + N, global, -1); + matrix.set(global, global + N, -1); + } + } + matrix.compress(VectorOperation::insert); + + + // then do a single matrix-vector + // multiplication with subsequent formation + // of the matrix norm + LinearAlgebra::TpetraWrappers::Vector v1; + v1.reinit(complete_index_set(N * N), MPI_COMM_WORLD); + LinearAlgebra::TpetraWrappers::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); + + deallog << v1 * v2 << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + try + { + { + test(); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; + return 0; +} diff --git a/tests/trilinos_tpetra/slowness_02.output b/tests/trilinos_tpetra/slowness_02.output new file mode 100644 index 0000000000..0d89007eb8 --- /dev/null +++ b/tests/trilinos_tpetra/slowness_02.output @@ -0,0 +1,2 @@ + +DEAL::-8.42635e+13 diff --git a/tests/trilinos_tpetra/slowness_03.cc b/tests/trilinos_tpetra/slowness_03.cc new file mode 100644 index 0000000000..b01298f240 --- /dev/null +++ b/tests/trilinos_tpetra/slowness_03.cc @@ -0,0 +1,130 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2005 - 2021 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// this is part of a whole suite of tests that checks the relative speed of +// using Trilinos for sparse matrices as compared to the speed of our own +// library. the tests therefore may not all actually use Trilinos, but they are +// meant to compare it +// +// the tests build the 5-point stencil matrix for a uniform grid of size N*N + +#include + +#include +#include +#include + +#include + +#include "../tests.h" + + +void +test() +{ + const unsigned int N = 200; + + // build the sparse matrix + IndexSet indices = complete_index_set(N * N); + LinearAlgebra::TpetraWrappers::SparseMatrix matrix(indices, + MPI_COMM_WORLD, + 5); + for (unsigned int i = 0; i < N; ++i) + for (unsigned int j = 0; j < N; ++j) + { + const unsigned int global = i * N + j; + matrix.set(global, global, 4); + if (j > 0) + { + matrix.set(global - 1, global, -1); + matrix.set(global, global - 1, -1); + } + if (j < N - 1) + { + matrix.set(global + 1, global, -1); + matrix.set(global, global + 1, -1); + } + if (i > 0) + { + matrix.set(global - N, global, -1); + matrix.set(global, global - N, -1); + } + if (i < N - 1) + { + matrix.set(global + N, global, -1); + matrix.set(global, global + N, -1); + } + } + matrix.compress(VectorOperation::insert); + + // then do a single matrix-vector + // multiplication with subsequent formation + // of the matrix norm + LinearAlgebra::TpetraWrappers::Vector v1(indices, MPI_COMM_WORLD); + LinearAlgebra::TpetraWrappers::Vector v2(indices, MPI_COMM_WORLD); + for (unsigned int i = 0; i < N * N; ++i) + v1(i) = i; + matrix.vmult(v2, v1); + + deallog << v1 * v2 << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + try + { + { + test(); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; + + return 0; +} diff --git a/tests/trilinos_tpetra/slowness_03.output b/tests/trilinos_tpetra/slowness_03.output new file mode 100644 index 0000000000..0d89007eb8 --- /dev/null +++ b/tests/trilinos_tpetra/slowness_03.output @@ -0,0 +1,2 @@ + +DEAL::-8.42635e+13 diff --git a/tests/trilinos_tpetra/slowness_04.cc b/tests/trilinos_tpetra/slowness_04.cc new file mode 100644 index 0000000000..de84fbf63a --- /dev/null +++ b/tests/trilinos_tpetra/slowness_04.cc @@ -0,0 +1,160 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2005 - 2021 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// this is part of a whole suite of tests that checks the relative speed of +// using Trilinos for sparse matrices as compared to the speed of our own +// library. the tests therefore may not all actually use Trilinos, but they are +// meant to compare it +// +// the tests build the 5-point stencil matrix for a uniform grid of size N*N +// +// this test does the same as the _03 test, except that it does not allocate +// the entries in consecutive order, but in pseudo-random order. the reason is +// that in usual finite element programs, we do not write to the elements of a +// matrix in a consecutive fashion, but rather according to the order of +// degrees of freedom in the sequence of cells that we traverse + +#include + +#include +#include +#include + +#include + +#include "../tests.h" + + +void +test() +{ + const unsigned int N = 200; + + // first find a random permutation of the + // indices + std::vector permutation(N); + { + std::vector unused_indices(N); + for (unsigned int i = 0; i < N; ++i) + unused_indices[i] = i; + + for (unsigned int i = 0; i < N; ++i) + { + // pick a random element among the + // unused indices + const unsigned int k = Testing::rand() % (N - i); + permutation[i] = unused_indices[k]; + + // then swap this used element to the + // end where we won't consider it any + // more + std::swap(unused_indices[k], unused_indices[N - i - 1]); + } + } + + // build the sparse matrix + IndexSet indices = complete_index_set(N * N); + LinearAlgebra::TpetraWrappers::SparseMatrix matrix(indices, + MPI_COMM_WORLD, + 5); + for (unsigned int i_ = 0; i_ < N; ++i_) + for (unsigned int j_ = 0; j_ < N; ++j_) + { + const unsigned int i = permutation[i_]; + const unsigned int j = permutation[j_]; + + const unsigned int global = i * N + j; + matrix.set(global, global, Testing::rand()); + if (j > 0) + { + matrix.set(global - 1, global, Testing::rand()); + matrix.set(global, global - 1, Testing::rand()); + } + if (j < N - 1) + { + matrix.set(global + 1, global, Testing::rand()); + matrix.set(global, global + 1, Testing::rand()); + } + if (i > 0) + { + matrix.set(global - N, global, Testing::rand()); + matrix.set(global, global - N, Testing::rand()); + } + if (i < N - 1) + { + matrix.set(global + N, global, Testing::rand()); + matrix.set(global, global + N, Testing::rand()); + } + } + matrix.compress(VectorOperation::insert); + + // then do a single matrix-vector + // multiplication with subsequent formation + // of the matrix norm + LinearAlgebra::TpetraWrappers::Vector v1(indices, MPI_COMM_WORLD); + LinearAlgebra::TpetraWrappers::Vector v2(indices, MPI_COMM_WORLD); + for (unsigned int i = 0; i < N * N; ++i) + v1(i) = i; + matrix.vmult(v2, v1); + + deallog << v1 * v2 << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + try + { + { + test(); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; + return 0; +} diff --git a/tests/trilinos_tpetra/slowness_04.output b/tests/trilinos_tpetra/slowness_04.output new file mode 100644 index 0000000000..0528791e54 --- /dev/null +++ b/tests/trilinos_tpetra/slowness_04.output @@ -0,0 +1,2 @@ + +DEAL::2.04928e+23 diff --git a/tests/trilinos_tpetra/sparse_matrix_vector_01.cc b/tests/trilinos_tpetra/sparse_matrix_vector_01.cc new file mode 100644 index 0000000000..f4c3dc4894 --- /dev/null +++ b/tests/trilinos_tpetra/sparse_matrix_vector_01.cc @@ -0,0 +1,113 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check SparseMatrix::vmult + +#include + +#include +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v, + LinearAlgebra::TpetraWrappers::Vector &w) +{ + LinearAlgebra::TpetraWrappers::SparseMatrix m(v.size(), + v.size(), + v.size()); + for (unsigned int i = 0; i < m.m(); ++i) + for (unsigned int j = 0; j < m.m(); ++j) + m.set(i, j, i + 2 * j); + + for (unsigned int i = 0; i < v.size(); ++i) + v(i) = i; + + m.compress(VectorOperation::insert); + v.compress(VectorOperation::insert); + w.compress(VectorOperation::insert); + + // w:=Mv + m.vmult(w, v); + + // make sure we get the expected result + for (unsigned int i = 0; i < v.size(); ++i) + { + AssertThrow(v(i) == i, ExcInternalError()); + + double result = 0; + for (unsigned int j = 0; j < m.m(); ++j) + result += (i + 2 * j) * j; + AssertThrow(w(i) == result, ExcInternalError()); + } + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + LinearAlgebra::TpetraWrappers::Vector w; + w.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v, w); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/sparse_matrix_vector_01.output b/tests/trilinos_tpetra/sparse_matrix_vector_01.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/sparse_matrix_vector_01.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/sparse_matrix_vector_02.cc b/tests/trilinos_tpetra/sparse_matrix_vector_02.cc new file mode 100644 index 0000000000..6cf9c602d9 --- /dev/null +++ b/tests/trilinos_tpetra/sparse_matrix_vector_02.cc @@ -0,0 +1,113 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check SparseMatrix::Tvmult + +#include + +#include +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v, + LinearAlgebra::TpetraWrappers::Vector &w) +{ + LinearAlgebra::TpetraWrappers::SparseMatrix m(v.size(), + v.size(), + v.size()); + for (unsigned int i = 0; i < m.m(); ++i) + for (unsigned int j = 0; j < m.m(); ++j) + m.set(i, j, i + 2 * j); + + for (unsigned int i = 0; i < v.size(); ++i) + v(i) = i; + + m.compress(VectorOperation::insert); + v.compress(VectorOperation::insert); + w.compress(VectorOperation::insert); + + // w:=Mv + m.Tvmult(w, v); + + // make sure we get the expected result + for (unsigned int i = 0; i < v.size(); ++i) + { + AssertThrow(v(i) == i, ExcInternalError()); + + double result = 0; + for (unsigned int j = 0; j < m.m(); ++j) + result += (j + 2 * i) * j; + AssertThrow(w(i) == result, ExcInternalError()); + } + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + LinearAlgebra::TpetraWrappers::Vector w; + w.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v, w); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/sparse_matrix_vector_02.output b/tests/trilinos_tpetra/sparse_matrix_vector_02.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/sparse_matrix_vector_02.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/sparse_matrix_vector_03.cc b/tests/trilinos_tpetra/sparse_matrix_vector_03.cc new file mode 100644 index 0000000000..fdcfd2594b --- /dev/null +++ b/tests/trilinos_tpetra/sparse_matrix_vector_03.cc @@ -0,0 +1,116 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check SparseMatrix::vmult_add + +#include + +#include +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v, + LinearAlgebra::TpetraWrappers::Vector &w) +{ + LinearAlgebra::TpetraWrappers::SparseMatrix m(v.size(), + v.size(), + v.size()); + for (unsigned int i = 0; i < m.m(); ++i) + for (unsigned int j = 0; j < m.m(); ++j) + m.set(i, j, i + 2 * j); + + for (unsigned int i = 0; i < v.size(); ++i) + { + v(i) = i; + w(i) = i; + } + + m.compress(VectorOperation::insert); + v.compress(VectorOperation::insert); + w.compress(VectorOperation::insert); + + // w:=Mv + m.vmult_add(w, v); + + // make sure we get the expected result + for (unsigned int i = 0; i < v.size(); ++i) + { + AssertThrow(v(i) == i, ExcInternalError()); + + double result = 0; + for (unsigned int j = 0; j < m.m(); ++j) + result += (i + 2 * j) * j; + AssertThrow(w(i) == i + result, ExcInternalError()); + } + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + LinearAlgebra::TpetraWrappers::Vector w; + w.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v, w); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/sparse_matrix_vector_03.output b/tests/trilinos_tpetra/sparse_matrix_vector_03.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/sparse_matrix_vector_03.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/sparse_matrix_vector_04.cc b/tests/trilinos_tpetra/sparse_matrix_vector_04.cc new file mode 100644 index 0000000000..5caad37ec1 --- /dev/null +++ b/tests/trilinos_tpetra/sparse_matrix_vector_04.cc @@ -0,0 +1,115 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check SparseMatrix::Tvmult_add + +#include + +#include +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v, + LinearAlgebra::TpetraWrappers::Vector &w) +{ + LinearAlgebra::TpetraWrappers::SparseMatrix m(v.size(), + v.size(), + v.size()); + for (unsigned int i = 0; i < m.m(); ++i) + for (unsigned int j = 0; j < m.m(); ++j) + m.set(i, j, i + 2 * j); + + for (unsigned int i = 0; i < v.size(); ++i) + { + v(i) = i; + w(i) = i; + } + + m.compress(VectorOperation::insert); + v.compress(VectorOperation::insert); + w.compress(VectorOperation::insert); + // w:=Mv + m.Tvmult_add(w, v); + + // make sure we get the expected result + for (unsigned int i = 0; i < v.size(); ++i) + { + AssertThrow(v(i) == i, ExcInternalError()); + + double result = 0; + for (unsigned int j = 0; j < m.m(); ++j) + result += (j + 2 * i) * j; + AssertThrow(w(i) == i + result, ExcInternalError()); + } + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(100), MPI_COMM_WORLD); + LinearAlgebra::TpetraWrappers::Vector w; + w.reinit(complete_index_set(100), MPI_COMM_WORLD); + test(v, w); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/sparse_matrix_vector_04.output b/tests/trilinos_tpetra/sparse_matrix_vector_04.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/sparse_matrix_vector_04.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/sparse_matrix_vector_14.cc b/tests/trilinos_tpetra/sparse_matrix_vector_14.cc new file mode 100644 index 0000000000..6521c965fd --- /dev/null +++ b/tests/trilinos_tpetra/sparse_matrix_vector_14.cc @@ -0,0 +1,128 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2013 - 2023 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check SparseMatrix::vmult, vmult_add with +// LinearAlgebra::TpetraWrappers::Vector + +#include + +#include +#include +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v, + LinearAlgebra::TpetraWrappers::Vector &w) +{ + LinearAlgebra::ReadWriteVector read_write_v(v.size()); + LinearAlgebra::ReadWriteVector read_write_w(w.size()); + + LinearAlgebra::TpetraWrappers::SparseMatrix m(w.size(), + v.size(), + v.size()); + for (unsigned int i = 0; i < m.m(); ++i) + for (unsigned int j = 0; j < m.n(); ++j) + m.set(i, j, i + 2 * j); + + for (unsigned int i = 0; i < v.size(); ++i) + read_write_v(i) = i; + + m.compress(VectorOperation::insert); + v.import_elements(read_write_v, VectorOperation::insert); + + // w:=Mv + m.vmult(w, v); + + // make sure we get the expected result + read_write_w.import_elements(w, VectorOperation::insert); + for (unsigned int i = 0; i < m.m(); ++i) + { + double result = 0; + for (unsigned int j = 0; j < m.n(); ++j) + result += (i + 2 * j) * j; + AssertThrow(read_write_w(i) == result, ExcInternalError()); + } + + m.vmult_add(w, v); + + // make sure we get the expected result + read_write_w.import_elements(w, VectorOperation::insert); + for (unsigned int i = 0; i < m.m(); ++i) + { + double result = 0; + for (unsigned int j = 0; j < m.n(); ++j) + result += (i + 2 * j) * j; + AssertThrow(read_write_w(i) == result + result, ExcInternalError()); + } + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v(complete_index_set(100), + MPI_COMM_SELF); + LinearAlgebra::TpetraWrappers::Vector w(complete_index_set(95), + MPI_COMM_SELF); + test(v, w); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/sparse_matrix_vector_14.with_trilinos_with_tpetra=on.output b/tests/trilinos_tpetra/sparse_matrix_vector_14.with_trilinos_with_tpetra=on.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/sparse_matrix_vector_14.with_trilinos_with_tpetra=on.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/sparse_matrix_vector_15.cc b/tests/trilinos_tpetra/sparse_matrix_vector_15.cc new file mode 100644 index 0000000000..50e9e73526 --- /dev/null +++ b/tests/trilinos_tpetra/sparse_matrix_vector_15.cc @@ -0,0 +1,127 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2013 - 2023 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check SparseMatrix::Tvmult, Tvmult_add with +// LinearAlgebra::TpetraWrappers::Vector + +#include + +#include +#include +#include + +#include +#include + +#include "../tests.h" + + +void +test(LinearAlgebra::TpetraWrappers::Vector &v, + LinearAlgebra::TpetraWrappers::Vector &w) +{ + LinearAlgebra::ReadWriteVector read_write_v(v.size()); + LinearAlgebra::ReadWriteVector read_write_w(w.size()); + + LinearAlgebra::TpetraWrappers::SparseMatrix m(v.size(), + w.size(), + w.size()); + for (unsigned int i = 0; i < m.m(); ++i) + for (unsigned int j = 0; j < m.n(); ++j) + m.set(i, j, i + 2 * j); + + for (unsigned int i = 0; i < v.size(); ++i) + read_write_v(i) = i; + + m.compress(VectorOperation::insert); + v.import_elements(read_write_v, VectorOperation::insert); + + // w:=Mv + m.Tvmult(w, v); + + // make sure we get the expected result + read_write_w.import_elements(w, VectorOperation::insert); + for (unsigned int i = 0; i < m.n(); ++i) + { + double result = 0; + for (unsigned int j = 0; j < m.m(); ++j) + result += (j + 2 * i) * j; + AssertThrow(read_write_w(i) == result, ExcInternalError()); + } + + m.Tvmult_add(w, v); + // make sure we get the expected result + read_write_w.import_elements(w, VectorOperation::insert); + for (unsigned int i = 0; i < m.n(); ++i) + { + double result = 0; + for (unsigned int j = 0; j < m.m(); ++j) + result += (j + 2 * i) * j; + AssertThrow(read_write_w(i) == result + result, ExcInternalError()); + } + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + { + LinearAlgebra::TpetraWrappers::Vector v(complete_index_set(95), + MPI_COMM_SELF); + LinearAlgebra::TpetraWrappers::Vector w(complete_index_set(100), + MPI_COMM_SELF); + test(v, w); + } + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/sparse_matrix_vector_15.with_trilinos_with_tpetra=on.output b/tests/trilinos_tpetra/sparse_matrix_vector_15.with_trilinos_with_tpetra=on.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/sparse_matrix_vector_15.with_trilinos_with_tpetra=on.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/sparsity_pattern_01.cc b/tests/trilinos_tpetra/sparsity_pattern_01.cc new file mode 100644 index 0000000000..1ae5144849 --- /dev/null +++ b/tests/trilinos_tpetra/sparsity_pattern_01.cc @@ -0,0 +1,33 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2008 - 2020 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::SparsityPattern::row_length + +#include + +#include "sparsity_pattern_common.h" + +int +main(int argc, char **argv) +{ + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + initlog(); + deallog << std::setprecision(3) << std::fixed; + + row_length(); +} diff --git a/tests/trilinos_tpetra/sparsity_pattern_01.output b/tests/trilinos_tpetra/sparsity_pattern_01.output new file mode 100644 index 0000000000..57a525d757 --- /dev/null +++ b/tests/trilinos_tpetra/sparsity_pattern_01.output @@ -0,0 +1,199 @@ + +DEAL::196 196 14 924 +DEAL::3 +DEAL::4 +DEAL::4 +DEAL::4 +DEAL::4 +DEAL::4 +DEAL::4 +DEAL::4 +DEAL::4 +DEAL::4 +DEAL::4 +DEAL::4 +DEAL::4 +DEAL::3 +DEAL::4 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::4 +DEAL::4 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::4 +DEAL::4 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::4 +DEAL::4 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::4 +DEAL::4 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::4 +DEAL::4 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::4 +DEAL::4 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::4 +DEAL::4 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::4 +DEAL::4 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::4 +DEAL::4 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::4 +DEAL::4 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::4 +DEAL::4 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::5 +DEAL::4 +DEAL::3 +DEAL::4 +DEAL::4 +DEAL::4 +DEAL::4 +DEAL::4 +DEAL::4 +DEAL::4 +DEAL::4 +DEAL::4 +DEAL::4 +DEAL::4 +DEAL::4 +DEAL::3 +DEAL::OK diff --git a/tests/trilinos_tpetra/sparsity_pattern_02.cc b/tests/trilinos_tpetra/sparsity_pattern_02.cc new file mode 100644 index 0000000000..a866047e86 --- /dev/null +++ b/tests/trilinos_tpetra/sparsity_pattern_02.cc @@ -0,0 +1,33 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2008 - 2020 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::SparsityPattern::print_gnuplot + +#include + +#include "sparsity_pattern_common.h" + +int +main(int argc, char **argv) +{ + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + initlog(); + deallog << std::setprecision(3) << std::fixed; + + print_gnuplot(); +} diff --git a/tests/trilinos_tpetra/sparsity_pattern_02.with_p4est=true.mpirun=1.output b/tests/trilinos_tpetra/sparsity_pattern_02.with_p4est=true.mpirun=1.output new file mode 100644 index 0000000000..f5212b6939 --- /dev/null +++ b/tests/trilinos_tpetra/sparsity_pattern_02.with_p4est=true.mpirun=1.output @@ -0,0 +1,927 @@ + +DEAL::196 196 14 924 +0 0 +1 0 +14 0 +0 -1 +1 -1 +2 -1 +15 -1 +1 -2 +2 -2 +3 -2 +16 -2 +2 -3 +3 -3 +4 -3 +17 -3 +3 -4 +4 -4 +5 -4 +18 -4 +4 -5 +5 -5 +6 -5 +19 -5 +5 -6 +6 -6 +7 -6 +20 -6 +6 -7 +7 -7 +8 -7 +21 -7 +7 -8 +8 -8 +9 -8 +22 -8 +8 -9 +9 -9 +10 -9 +23 -9 +9 -10 +10 -10 +11 -10 +24 -10 +10 -11 +11 -11 +12 -11 +25 -11 +11 -12 +12 -12 +13 -12 +26 -12 +12 -13 +13 -13 +27 -13 +0 -14 +14 -14 +15 -14 +28 -14 +1 -15 +14 -15 +15 -15 +16 -15 +29 -15 +2 -16 +15 -16 +16 -16 +17 -16 +30 -16 +3 -17 +16 -17 +17 -17 +18 -17 +31 -17 +4 -18 +17 -18 +18 -18 +19 -18 +32 -18 +5 -19 +18 -19 +19 -19 +20 -19 +33 -19 +6 -20 +19 -20 +20 -20 +21 -20 +34 -20 +7 -21 +20 -21 +21 -21 +22 -21 +35 -21 +8 -22 +21 -22 +22 -22 +23 -22 +36 -22 +9 -23 +22 -23 +23 -23 +24 -23 +37 -23 +10 -24 +23 -24 +24 -24 +25 -24 +38 -24 +11 -25 +24 -25 +25 -25 +26 -25 +39 -25 +12 -26 +25 -26 +26 -26 +27 -26 +40 -26 +13 -27 +26 -27 +27 -27 +41 -27 +14 -28 +28 -28 +29 -28 +42 -28 +15 -29 +28 -29 +29 -29 +30 -29 +43 -29 +16 -30 +29 -30 +30 -30 +31 -30 +44 -30 +17 -31 +30 -31 +31 -31 +32 -31 +45 -31 +18 -32 +31 -32 +32 -32 +33 -32 +46 -32 +19 -33 +32 -33 +33 -33 +34 -33 +47 -33 +20 -34 +33 -34 +34 -34 +35 -34 +48 -34 +21 -35 +34 -35 +35 -35 +36 -35 +49 -35 +22 -36 +35 -36 +36 -36 +37 -36 +50 -36 +23 -37 +36 -37 +37 -37 +38 -37 +51 -37 +24 -38 +37 -38 +38 -38 +39 -38 +52 -38 +25 -39 +38 -39 +39 -39 +40 -39 +53 -39 +26 -40 +39 -40 +40 -40 +41 -40 +54 -40 +27 -41 +40 -41 +41 -41 +55 -41 +28 -42 +42 -42 +43 -42 +56 -42 +29 -43 +42 -43 +43 -43 +44 -43 +57 -43 +30 -44 +43 -44 +44 -44 +45 -44 +58 -44 +31 -45 +44 -45 +45 -45 +46 -45 +59 -45 +32 -46 +45 -46 +46 -46 +47 -46 +60 -46 +33 -47 +46 -47 +47 -47 +48 -47 +61 -47 +34 -48 +47 -48 +48 -48 +49 -48 +62 -48 +35 -49 +48 -49 +49 -49 +50 -49 +63 -49 +36 -50 +49 -50 +50 -50 +51 -50 +64 -50 +37 -51 +50 -51 +51 -51 +52 -51 +65 -51 +38 -52 +51 -52 +52 -52 +53 -52 +66 -52 +39 -53 +52 -53 +53 -53 +54 -53 +67 -53 +40 -54 +53 -54 +54 -54 +55 -54 +68 -54 +41 -55 +54 -55 +55 -55 +69 -55 +42 -56 +56 -56 +57 -56 +70 -56 +43 -57 +56 -57 +57 -57 +58 -57 +71 -57 +44 -58 +57 -58 +58 -58 +59 -58 +72 -58 +45 -59 +58 -59 +59 -59 +60 -59 +73 -59 +46 -60 +59 -60 +60 -60 +61 -60 +74 -60 +47 -61 +60 -61 +61 -61 +62 -61 +75 -61 +48 -62 +61 -62 +62 -62 +63 -62 +76 -62 +49 -63 +62 -63 +63 -63 +64 -63 +77 -63 +50 -64 +63 -64 +64 -64 +65 -64 +78 -64 +51 -65 +64 -65 +65 -65 +66 -65 +79 -65 +52 -66 +65 -66 +66 -66 +67 -66 +80 -66 +53 -67 +66 -67 +67 -67 +68 -67 +81 -67 +54 -68 +67 -68 +68 -68 +69 -68 +82 -68 +55 -69 +68 -69 +69 -69 +83 -69 +56 -70 +70 -70 +71 -70 +84 -70 +57 -71 +70 -71 +71 -71 +72 -71 +85 -71 +58 -72 +71 -72 +72 -72 +73 -72 +86 -72 +59 -73 +72 -73 +73 -73 +74 -73 +87 -73 +60 -74 +73 -74 +74 -74 +75 -74 +88 -74 +61 -75 +74 -75 +75 -75 +76 -75 +89 -75 +62 -76 +75 -76 +76 -76 +77 -76 +90 -76 +63 -77 +76 -77 +77 -77 +78 -77 +91 -77 +64 -78 +77 -78 +78 -78 +79 -78 +92 -78 +65 -79 +78 -79 +79 -79 +80 -79 +93 -79 +66 -80 +79 -80 +80 -80 +81 -80 +94 -80 +67 -81 +80 -81 +81 -81 +82 -81 +95 -81 +68 -82 +81 -82 +82 -82 +83 -82 +96 -82 +69 -83 +82 -83 +83 -83 +97 -83 +70 -84 +84 -84 +85 -84 +98 -84 +71 -85 +84 -85 +85 -85 +86 -85 +99 -85 +72 -86 +85 -86 +86 -86 +87 -86 +100 -86 +73 -87 +86 -87 +87 -87 +88 -87 +101 -87 +74 -88 +87 -88 +88 -88 +89 -88 +102 -88 +75 -89 +88 -89 +89 -89 +90 -89 +103 -89 +76 -90 +89 -90 +90 -90 +91 -90 +104 -90 +77 -91 +90 -91 +91 -91 +92 -91 +105 -91 +78 -92 +91 -92 +92 -92 +93 -92 +106 -92 +79 -93 +92 -93 +93 -93 +94 -93 +107 -93 +80 -94 +93 -94 +94 -94 +95 -94 +108 -94 +81 -95 +94 -95 +95 -95 +96 -95 +109 -95 +82 -96 +95 -96 +96 -96 +97 -96 +110 -96 +83 -97 +96 -97 +97 -97 +111 -97 +84 -98 +98 -98 +99 -98 +112 -98 +85 -99 +98 -99 +99 -99 +100 -99 +113 -99 +86 -100 +99 -100 +100 -100 +101 -100 +114 -100 +87 -101 +100 -101 +101 -101 +102 -101 +115 -101 +88 -102 +101 -102 +102 -102 +103 -102 +116 -102 +89 -103 +102 -103 +103 -103 +104 -103 +117 -103 +90 -104 +103 -104 +104 -104 +105 -104 +118 -104 +91 -105 +104 -105 +105 -105 +106 -105 +119 -105 +92 -106 +105 -106 +106 -106 +107 -106 +120 -106 +93 -107 +106 -107 +107 -107 +108 -107 +121 -107 +94 -108 +107 -108 +108 -108 +109 -108 +122 -108 +95 -109 +108 -109 +109 -109 +110 -109 +123 -109 +96 -110 +109 -110 +110 -110 +111 -110 +124 -110 +97 -111 +110 -111 +111 -111 +125 -111 +98 -112 +112 -112 +113 -112 +126 -112 +99 -113 +112 -113 +113 -113 +114 -113 +127 -113 +100 -114 +113 -114 +114 -114 +115 -114 +128 -114 +101 -115 +114 -115 +115 -115 +116 -115 +129 -115 +102 -116 +115 -116 +116 -116 +117 -116 +130 -116 +103 -117 +116 -117 +117 -117 +118 -117 +131 -117 +104 -118 +117 -118 +118 -118 +119 -118 +132 -118 +105 -119 +118 -119 +119 -119 +120 -119 +133 -119 +106 -120 +119 -120 +120 -120 +121 -120 +134 -120 +107 -121 +120 -121 +121 -121 +122 -121 +135 -121 +108 -122 +121 -122 +122 -122 +123 -122 +136 -122 +109 -123 +122 -123 +123 -123 +124 -123 +137 -123 +110 -124 +123 -124 +124 -124 +125 -124 +138 -124 +111 -125 +124 -125 +125 -125 +139 -125 +112 -126 +126 -126 +127 -126 +140 -126 +113 -127 +126 -127 +127 -127 +128 -127 +141 -127 +114 -128 +127 -128 +128 -128 +129 -128 +142 -128 +115 -129 +128 -129 +129 -129 +130 -129 +143 -129 +116 -130 +129 -130 +130 -130 +131 -130 +144 -130 +117 -131 +130 -131 +131 -131 +132 -131 +145 -131 +118 -132 +131 -132 +132 -132 +133 -132 +146 -132 +119 -133 +132 -133 +133 -133 +134 -133 +147 -133 +120 -134 +133 -134 +134 -134 +135 -134 +148 -134 +121 -135 +134 -135 +135 -135 +136 -135 +149 -135 +122 -136 +135 -136 +136 -136 +137 -136 +150 -136 +123 -137 +136 -137 +137 -137 +138 -137 +151 -137 +124 -138 +137 -138 +138 -138 +139 -138 +152 -138 +125 -139 +138 -139 +139 -139 +153 -139 +126 -140 +140 -140 +141 -140 +154 -140 +127 -141 +140 -141 +141 -141 +142 -141 +155 -141 +128 -142 +141 -142 +142 -142 +143 -142 +156 -142 +129 -143 +142 -143 +143 -143 +144 -143 +157 -143 +130 -144 +143 -144 +144 -144 +145 -144 +158 -144 +131 -145 +144 -145 +145 -145 +146 -145 +159 -145 +132 -146 +145 -146 +146 -146 +147 -146 +160 -146 +133 -147 +146 -147 +147 -147 +148 -147 +161 -147 +134 -148 +147 -148 +148 -148 +149 -148 +162 -148 +135 -149 +148 -149 +149 -149 +150 -149 +163 -149 +136 -150 +149 -150 +150 -150 +151 -150 +164 -150 +137 -151 +150 -151 +151 -151 +152 -151 +165 -151 +138 -152 +151 -152 +152 -152 +153 -152 +166 -152 +139 -153 +152 -153 +153 -153 +167 -153 +140 -154 +154 -154 +155 -154 +168 -154 +141 -155 +154 -155 +155 -155 +156 -155 +169 -155 +142 -156 +155 -156 +156 -156 +157 -156 +170 -156 +143 -157 +156 -157 +157 -157 +158 -157 +171 -157 +144 -158 +157 -158 +158 -158 +159 -158 +172 -158 +145 -159 +158 -159 +159 -159 +160 -159 +173 -159 +146 -160 +159 -160 +160 -160 +161 -160 +174 -160 +147 -161 +160 -161 +161 -161 +162 -161 +175 -161 +148 -162 +161 -162 +162 -162 +163 -162 +176 -162 +149 -163 +162 -163 +163 -163 +164 -163 +177 -163 +150 -164 +163 -164 +164 -164 +165 -164 +178 -164 +151 -165 +164 -165 +165 -165 +166 -165 +179 -165 +152 -166 +165 -166 +166 -166 +167 -166 +180 -166 +153 -167 +166 -167 +167 -167 +181 -167 +154 -168 +168 -168 +169 -168 +182 -168 +155 -169 +168 -169 +169 -169 +170 -169 +183 -169 +156 -170 +169 -170 +170 -170 +171 -170 +184 -170 +157 -171 +170 -171 +171 -171 +172 -171 +185 -171 +158 -172 +171 -172 +172 -172 +173 -172 +186 -172 +159 -173 +172 -173 +173 -173 +174 -173 +187 -173 +160 -174 +173 -174 +174 -174 +175 -174 +188 -174 +161 -175 +174 -175 +175 -175 +176 -175 +189 -175 +162 -176 +175 -176 +176 -176 +177 -176 +190 -176 +163 -177 +176 -177 +177 -177 +178 -177 +191 -177 +164 -178 +177 -178 +178 -178 +179 -178 +192 -178 +165 -179 +178 -179 +179 -179 +180 -179 +193 -179 +166 -180 +179 -180 +180 -180 +181 -180 +194 -180 +167 -181 +180 -181 +181 -181 +195 -181 +168 -182 +182 -182 +183 -182 +169 -183 +182 -183 +183 -183 +184 -183 +170 -184 +183 -184 +184 -184 +185 -184 +171 -185 +184 -185 +185 -185 +186 -185 +172 -186 +185 -186 +186 -186 +187 -186 +173 -187 +186 -187 +187 -187 +188 -187 +174 -188 +187 -188 +188 -188 +189 -188 +175 -189 +188 -189 +189 -189 +190 -189 +176 -190 +189 -190 +190 -190 +191 -190 +177 -191 +190 -191 +191 -191 +192 -191 +178 -192 +191 -192 +192 -192 +193 -192 +179 -193 +192 -193 +193 -193 +194 -193 +180 -194 +193 -194 +194 -194 +195 -194 +181 -195 +194 -195 +195 -195 +DEAL::OK diff --git a/tests/trilinos_tpetra/sparsity_pattern_03.cc b/tests/trilinos_tpetra/sparsity_pattern_03.cc new file mode 100644 index 0000000000..3093923215 --- /dev/null +++ b/tests/trilinos_tpetra/sparsity_pattern_03.cc @@ -0,0 +1,34 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2008 - 2020 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check LinearAlgebra::TpetraWrappers::SparsityPattern::print + +#include + +#include "sparsity_pattern_common.h" + +int +main(int argc, char **argv) +{ + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + initlog(); + deallog << std::setprecision(3) << std::fixed; + + print(); +} diff --git a/tests/trilinos_tpetra/sparsity_pattern_03.output b/tests/trilinos_tpetra/sparsity_pattern_03.output new file mode 100644 index 0000000000..ea17470d08 --- /dev/null +++ b/tests/trilinos_tpetra/sparsity_pattern_03.output @@ -0,0 +1,927 @@ + +DEAL::196 196 14 924 +(0,0) +(0,1) +(0,14) +(1,0) +(1,1) +(1,2) +(1,15) +(2,1) +(2,2) +(2,3) +(2,16) +(3,2) +(3,3) +(3,4) +(3,17) +(4,3) +(4,4) +(4,5) +(4,18) +(5,4) +(5,5) +(5,6) +(5,19) +(6,5) +(6,6) +(6,7) +(6,20) +(7,6) +(7,7) +(7,8) +(7,21) +(8,7) +(8,8) +(8,9) +(8,22) +(9,8) +(9,9) +(9,10) +(9,23) +(10,9) +(10,10) +(10,11) +(10,24) +(11,10) +(11,11) +(11,12) +(11,25) +(12,11) +(12,12) +(12,13) +(12,26) +(13,12) +(13,13) +(13,27) +(14,0) +(14,14) +(14,15) +(14,28) +(15,1) +(15,14) +(15,15) +(15,16) +(15,29) +(16,2) +(16,15) +(16,16) +(16,17) +(16,30) +(17,3) +(17,16) +(17,17) +(17,18) +(17,31) +(18,4) +(18,17) +(18,18) +(18,19) +(18,32) +(19,5) +(19,18) +(19,19) +(19,20) +(19,33) +(20,6) +(20,19) +(20,20) +(20,21) +(20,34) +(21,7) +(21,20) +(21,21) +(21,22) +(21,35) +(22,8) +(22,21) +(22,22) +(22,23) +(22,36) +(23,9) +(23,22) +(23,23) +(23,24) +(23,37) +(24,10) +(24,23) +(24,24) +(24,25) +(24,38) +(25,11) +(25,24) +(25,25) +(25,26) +(25,39) +(26,12) +(26,25) +(26,26) +(26,27) +(26,40) +(27,13) +(27,26) +(27,27) +(27,41) +(28,14) +(28,28) +(28,29) +(28,42) +(29,15) +(29,28) +(29,29) +(29,30) +(29,43) +(30,16) +(30,29) +(30,30) +(30,31) +(30,44) +(31,17) +(31,30) +(31,31) +(31,32) +(31,45) +(32,18) +(32,31) +(32,32) +(32,33) +(32,46) +(33,19) +(33,32) +(33,33) +(33,34) +(33,47) +(34,20) +(34,33) +(34,34) +(34,35) +(34,48) +(35,21) +(35,34) +(35,35) +(35,36) +(35,49) +(36,22) +(36,35) +(36,36) +(36,37) +(36,50) +(37,23) +(37,36) +(37,37) +(37,38) +(37,51) +(38,24) +(38,37) +(38,38) +(38,39) +(38,52) +(39,25) +(39,38) +(39,39) +(39,40) +(39,53) +(40,26) +(40,39) +(40,40) +(40,41) +(40,54) +(41,27) +(41,40) +(41,41) +(41,55) +(42,28) +(42,42) +(42,43) +(42,56) +(43,29) +(43,42) +(43,43) +(43,44) +(43,57) +(44,30) +(44,43) +(44,44) +(44,45) +(44,58) +(45,31) +(45,44) +(45,45) +(45,46) +(45,59) +(46,32) +(46,45) +(46,46) +(46,47) +(46,60) +(47,33) +(47,46) +(47,47) +(47,48) +(47,61) +(48,34) +(48,47) +(48,48) +(48,49) +(48,62) +(49,35) +(49,48) +(49,49) +(49,50) +(49,63) +(50,36) +(50,49) +(50,50) +(50,51) +(50,64) +(51,37) +(51,50) +(51,51) +(51,52) +(51,65) +(52,38) +(52,51) +(52,52) +(52,53) +(52,66) +(53,39) +(53,52) +(53,53) +(53,54) +(53,67) +(54,40) +(54,53) +(54,54) +(54,55) +(54,68) +(55,41) +(55,54) +(55,55) +(55,69) +(56,42) +(56,56) +(56,57) +(56,70) +(57,43) +(57,56) +(57,57) +(57,58) +(57,71) +(58,44) +(58,57) +(58,58) +(58,59) +(58,72) +(59,45) +(59,58) +(59,59) +(59,60) +(59,73) +(60,46) +(60,59) +(60,60) +(60,61) +(60,74) +(61,47) +(61,60) +(61,61) +(61,62) +(61,75) +(62,48) +(62,61) +(62,62) +(62,63) +(62,76) +(63,49) +(63,62) +(63,63) +(63,64) +(63,77) +(64,50) +(64,63) +(64,64) +(64,65) +(64,78) +(65,51) +(65,64) +(65,65) +(65,66) +(65,79) +(66,52) +(66,65) +(66,66) +(66,67) +(66,80) +(67,53) +(67,66) +(67,67) +(67,68) +(67,81) +(68,54) +(68,67) +(68,68) +(68,69) +(68,82) +(69,55) +(69,68) +(69,69) +(69,83) +(70,56) +(70,70) +(70,71) +(70,84) +(71,57) +(71,70) +(71,71) +(71,72) +(71,85) +(72,58) +(72,71) +(72,72) +(72,73) +(72,86) +(73,59) +(73,72) +(73,73) +(73,74) +(73,87) +(74,60) +(74,73) +(74,74) +(74,75) +(74,88) +(75,61) +(75,74) +(75,75) +(75,76) +(75,89) +(76,62) +(76,75) +(76,76) +(76,77) +(76,90) +(77,63) +(77,76) +(77,77) +(77,78) +(77,91) +(78,64) +(78,77) +(78,78) +(78,79) +(78,92) +(79,65) +(79,78) +(79,79) +(79,80) +(79,93) +(80,66) +(80,79) +(80,80) +(80,81) +(80,94) +(81,67) +(81,80) +(81,81) +(81,82) +(81,95) +(82,68) +(82,81) +(82,82) +(82,83) +(82,96) +(83,69) +(83,82) +(83,83) +(83,97) +(84,70) +(84,84) +(84,85) +(84,98) +(85,71) +(85,84) +(85,85) +(85,86) +(85,99) +(86,72) +(86,85) +(86,86) +(86,87) +(86,100) +(87,73) +(87,86) +(87,87) +(87,88) +(87,101) +(88,74) +(88,87) +(88,88) +(88,89) +(88,102) +(89,75) +(89,88) +(89,89) +(89,90) +(89,103) +(90,76) +(90,89) +(90,90) +(90,91) +(90,104) +(91,77) +(91,90) +(91,91) +(91,92) +(91,105) +(92,78) +(92,91) +(92,92) +(92,93) +(92,106) +(93,79) +(93,92) +(93,93) +(93,94) +(93,107) +(94,80) +(94,93) +(94,94) +(94,95) +(94,108) +(95,81) +(95,94) +(95,95) +(95,96) +(95,109) +(96,82) +(96,95) +(96,96) +(96,97) +(96,110) +(97,83) +(97,96) +(97,97) +(97,111) +(98,84) +(98,98) +(98,99) +(98,112) +(99,85) +(99,98) +(99,99) +(99,100) +(99,113) +(100,86) +(100,99) +(100,100) +(100,101) +(100,114) +(101,87) +(101,100) +(101,101) +(101,102) +(101,115) +(102,88) +(102,101) +(102,102) +(102,103) +(102,116) +(103,89) +(103,102) +(103,103) +(103,104) +(103,117) +(104,90) +(104,103) +(104,104) +(104,105) +(104,118) +(105,91) +(105,104) +(105,105) +(105,106) +(105,119) +(106,92) +(106,105) +(106,106) +(106,107) +(106,120) +(107,93) +(107,106) +(107,107) +(107,108) +(107,121) +(108,94) +(108,107) +(108,108) +(108,109) +(108,122) +(109,95) +(109,108) +(109,109) +(109,110) +(109,123) +(110,96) +(110,109) +(110,110) +(110,111) +(110,124) +(111,97) +(111,110) +(111,111) +(111,125) +(112,98) +(112,112) +(112,113) +(112,126) +(113,99) +(113,112) +(113,113) +(113,114) +(113,127) +(114,100) +(114,113) +(114,114) +(114,115) +(114,128) +(115,101) +(115,114) +(115,115) +(115,116) +(115,129) +(116,102) +(116,115) +(116,116) +(116,117) +(116,130) +(117,103) +(117,116) +(117,117) +(117,118) +(117,131) +(118,104) +(118,117) +(118,118) +(118,119) +(118,132) +(119,105) +(119,118) +(119,119) +(119,120) +(119,133) +(120,106) +(120,119) +(120,120) +(120,121) +(120,134) +(121,107) +(121,120) +(121,121) +(121,122) +(121,135) +(122,108) +(122,121) +(122,122) +(122,123) +(122,136) +(123,109) +(123,122) +(123,123) +(123,124) +(123,137) +(124,110) +(124,123) +(124,124) +(124,125) +(124,138) +(125,111) +(125,124) +(125,125) +(125,139) +(126,112) +(126,126) +(126,127) +(126,140) +(127,113) +(127,126) +(127,127) +(127,128) +(127,141) +(128,114) +(128,127) +(128,128) +(128,129) +(128,142) +(129,115) +(129,128) +(129,129) +(129,130) +(129,143) +(130,116) +(130,129) +(130,130) +(130,131) +(130,144) +(131,117) +(131,130) +(131,131) +(131,132) +(131,145) +(132,118) +(132,131) +(132,132) +(132,133) +(132,146) +(133,119) +(133,132) +(133,133) +(133,134) +(133,147) +(134,120) +(134,133) +(134,134) +(134,135) +(134,148) +(135,121) +(135,134) +(135,135) +(135,136) +(135,149) +(136,122) +(136,135) +(136,136) +(136,137) +(136,150) +(137,123) +(137,136) +(137,137) +(137,138) +(137,151) +(138,124) +(138,137) +(138,138) +(138,139) +(138,152) +(139,125) +(139,138) +(139,139) +(139,153) +(140,126) +(140,140) +(140,141) +(140,154) +(141,127) +(141,140) +(141,141) +(141,142) +(141,155) +(142,128) +(142,141) +(142,142) +(142,143) +(142,156) +(143,129) +(143,142) +(143,143) +(143,144) +(143,157) +(144,130) +(144,143) +(144,144) +(144,145) +(144,158) +(145,131) +(145,144) +(145,145) +(145,146) +(145,159) +(146,132) +(146,145) +(146,146) +(146,147) +(146,160) +(147,133) +(147,146) +(147,147) +(147,148) +(147,161) +(148,134) +(148,147) +(148,148) +(148,149) +(148,162) +(149,135) +(149,148) +(149,149) +(149,150) +(149,163) +(150,136) +(150,149) +(150,150) +(150,151) +(150,164) +(151,137) +(151,150) +(151,151) +(151,152) +(151,165) +(152,138) +(152,151) +(152,152) +(152,153) +(152,166) +(153,139) +(153,152) +(153,153) +(153,167) +(154,140) +(154,154) +(154,155) +(154,168) +(155,141) +(155,154) +(155,155) +(155,156) +(155,169) +(156,142) +(156,155) +(156,156) +(156,157) +(156,170) +(157,143) +(157,156) +(157,157) +(157,158) +(157,171) +(158,144) +(158,157) +(158,158) +(158,159) +(158,172) +(159,145) +(159,158) +(159,159) +(159,160) +(159,173) +(160,146) +(160,159) +(160,160) +(160,161) +(160,174) +(161,147) +(161,160) +(161,161) +(161,162) +(161,175) +(162,148) +(162,161) +(162,162) +(162,163) +(162,176) +(163,149) +(163,162) +(163,163) +(163,164) +(163,177) +(164,150) +(164,163) +(164,164) +(164,165) +(164,178) +(165,151) +(165,164) +(165,165) +(165,166) +(165,179) +(166,152) +(166,165) +(166,166) +(166,167) +(166,180) +(167,153) +(167,166) +(167,167) +(167,181) +(168,154) +(168,168) +(168,169) +(168,182) +(169,155) +(169,168) +(169,169) +(169,170) +(169,183) +(170,156) +(170,169) +(170,170) +(170,171) +(170,184) +(171,157) +(171,170) +(171,171) +(171,172) +(171,185) +(172,158) +(172,171) +(172,172) +(172,173) +(172,186) +(173,159) +(173,172) +(173,173) +(173,174) +(173,187) +(174,160) +(174,173) +(174,174) +(174,175) +(174,188) +(175,161) +(175,174) +(175,175) +(175,176) +(175,189) +(176,162) +(176,175) +(176,176) +(176,177) +(176,190) +(177,163) +(177,176) +(177,177) +(177,178) +(177,191) +(178,164) +(178,177) +(178,178) +(178,179) +(178,192) +(179,165) +(179,178) +(179,179) +(179,180) +(179,193) +(180,166) +(180,179) +(180,180) +(180,181) +(180,194) +(181,167) +(181,180) +(181,181) +(181,195) +(182,168) +(182,182) +(182,183) +(183,169) +(183,182) +(183,183) +(183,184) +(184,170) +(184,183) +(184,184) +(184,185) +(185,171) +(185,184) +(185,185) +(185,186) +(186,172) +(186,185) +(186,186) +(186,187) +(187,173) +(187,186) +(187,187) +(187,188) +(188,174) +(188,187) +(188,188) +(188,189) +(189,175) +(189,188) +(189,189) +(189,190) +(190,176) +(190,189) +(190,190) +(190,191) +(191,177) +(191,190) +(191,191) +(191,192) +(192,178) +(192,191) +(192,192) +(192,193) +(193,179) +(193,192) +(193,193) +(193,194) +(194,180) +(194,193) +(194,194) +(194,195) +(195,181) +(195,194) +(195,195) +DEAL::OK diff --git a/tests/trilinos_tpetra/sparsity_pattern_common.h b/tests/trilinos_tpetra/sparsity_pattern_common.h new file mode 100644 index 0000000000..bfc4cd8726 --- /dev/null +++ b/tests/trilinos_tpetra/sparsity_pattern_common.h @@ -0,0 +1,89 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2008 - 2020 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// check + +#include + +#include "../tests.h" + +#include "../testmatrix.h" + +const unsigned int N = 15; + + +// reinitialize sparsity patterns for 5-point star +void +do_reinit(TrilinosWrappers::SparsityPattern &sp) +{ + sp.reinit((N - 1) * (N - 1), (N - 1) * (N - 1)); +} + + + +void +build_sparsity(TrilinosWrappers::SparsityPattern &sparsity_pattern) +{ + // generate usual 5-point sparsity pattern + do_reinit(sparsity_pattern); + FDMatrix(N, N).five_point_structure(sparsity_pattern); + sparsity_pattern.compress(); + + deallog << sparsity_pattern.n_rows() << " " << sparsity_pattern.n_cols() + << " " << sparsity_pattern.bandwidth() << " " + << sparsity_pattern.n_nonzero_elements() << std::endl; +} + + + +void +row_length() +{ + TrilinosWrappers::SparsityPattern sparsity_pattern; + build_sparsity(sparsity_pattern); + + for (unsigned int i = 0; i < sparsity_pattern.n_rows(); ++i) + deallog << sparsity_pattern.row_length(i) << std::endl; + + deallog << "OK" << std::endl; +} + + + +void +print_gnuplot() +{ + TrilinosWrappers::SparsityPattern sparsity_pattern; + build_sparsity(sparsity_pattern); + + sparsity_pattern.print_gnuplot(deallog.get_file_stream()); + + deallog << "OK" << std::endl; +} + + + +void +print() +{ + TrilinosWrappers::SparsityPattern sparsity_pattern; + build_sparsity(sparsity_pattern); + + sparsity_pattern.print(deallog.get_file_stream()); + + deallog << "OK" << std::endl; +} diff --git a/tests/trilinos_tpetra/tpetra_vector_01.cc b/tests/trilinos_tpetra/tpetra_vector_01.cc new file mode 100644 index 0000000000..c1bda82066 --- /dev/null +++ b/tests/trilinos_tpetra/tpetra_vector_01.cc @@ -0,0 +1,229 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2018 - 2023 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + +#include + +#include +#include + +#include +#include + +#include "../tests.h" + +// Check LinearAlgebra::TpetraWrappers::Vector assignment and import + +template +void +test() +{ + IndexSet parallel_partitioner_1(10); + IndexSet parallel_partitioner_2(10); + unsigned int rank = Utilities::MPI::this_mpi_process(MPI_COMM_WORLD); + if (rank == 0) + { + parallel_partitioner_1.add_range(0, 5); + parallel_partitioner_2.add_range(0, 3); + } + else + { + parallel_partitioner_1.add_range(5, 10); + parallel_partitioner_2.add_range(3, 10); + } + parallel_partitioner_1.compress(); + parallel_partitioner_2.compress(); + LinearAlgebra::TpetraWrappers::Vector a; + LinearAlgebra::TpetraWrappers::Vector b(parallel_partitioner_1, + MPI_COMM_WORLD); + LinearAlgebra::TpetraWrappers::Vector c(b); + + AssertThrow(a.size() == 0, ExcMessage("Vector has the wrong size.")); + AssertThrow(b.size() == 10, ExcMessage("Vector has the wrong size.")); + AssertThrow(c.size() == 10, ExcMessage("Vector has the wrong size.")); + + a.reinit(parallel_partitioner_2, MPI_COMM_WORLD); + AssertThrow(a.size() == 10, ExcMessage("Vector has the wrong size.")); + + AssertThrow(parallel_partitioner_1 == b.locally_owned_elements(), + ExcMessage("IndexSet has been modified.")); + AssertThrow(parallel_partitioner_2 == a.locally_owned_elements(), + ExcMessage("IndexSet has been modified.")); + + IndexSet read_write_index_set(10); + if (rank == 0) + read_write_index_set.add_range(0, 6); + else + read_write_index_set.add_range(4, 10); + read_write_index_set.compress(); + + LinearAlgebra::ReadWriteVector read_write_1(read_write_index_set); + LinearAlgebra::ReadWriteVector read_write_2(read_write_index_set); + LinearAlgebra::ReadWriteVector read_write_3(read_write_index_set); + if (rank == 0) + { + for (unsigned int i = 0; i < 6; ++i) + { + read_write_1[i] = i; + read_write_2[i] = 5. + i; + } + } + else + { + for (unsigned int i = 4; i < 10; ++i) + { + read_write_1[i] = i; + read_write_2[i] = 5. + i; + } + } + + a.import_elements(read_write_2, VectorOperation::insert); + AssertThrow(a.size() == 10, ExcMessage("Vector has the wrong size.")); + + read_write_3.import_elements(a, VectorOperation::insert); + if (rank == 0) + { + for (unsigned int i = 0; i < 6; ++i) + { + AssertThrow(read_write_2[i] == read_write_3[i], + ExcMessage("Vector a has been modified.")); + } + } + else + { + for (unsigned int i = 4; i < 10; ++i) + AssertThrow(read_write_2[i] == read_write_3[i], + ExcMessage("Vector a has been modified.")); + } + + b.import_elements(read_write_1, VectorOperation::insert); + AssertThrow(b.size() == 10, ExcMessage("Vector has the wrong size.")); + + read_write_3.import_elements(b, VectorOperation::insert); + if (rank == 0) + { + for (unsigned int i = 0; i < 6; ++i) + AssertThrow(read_write_1[i] == read_write_3[i], + ExcMessage("Vector b has been modified.")); + } + else + { + for (unsigned int i = 4; i < 10; ++i) + AssertThrow(read_write_1[i] == read_write_3[i], + ExcMessage("Vector b has been modified.")); + } + + c.import_elements(read_write_2, VectorOperation::insert); + AssertThrow(c.size() == 10, ExcMessage("Vector has the wrong size.")); + + read_write_3.import_elements(c, VectorOperation::insert); + if (rank == 0) + { + for (unsigned int i = 0; i < 6; ++i) + AssertThrow(read_write_2[i] == read_write_3[i], + ExcMessage("Vector c has been modified.")); + } + else + { + for (unsigned int i = 4; i < 10; ++i) + AssertThrow(read_write_2[i] == read_write_3[i], + ExcMessage("Vector c has been modified.")); + } + + a *= 2; + read_write_3.import_elements(a, VectorOperation::insert); + if (rank == 0) + { + for (unsigned int i = 0; i < 6; ++i) + AssertThrow(Number(2.) * read_write_2[i] == read_write_3[i], + ExcMessage("Problem in operator *=.")); + } + else + { + for (unsigned int i = 4; i < 10; ++i) + AssertThrow(Number(2.) * read_write_2[i] == read_write_3[i], + ExcMessage("Problem in operator *=.")); + } + + c /= 2.; + read_write_3.import_elements(c, VectorOperation::insert); + if (rank == 0) + { + for (unsigned int i = 0; i < 6; ++i) + AssertThrow(Number(0.5) * read_write_2[i] == read_write_3[i], + ExcMessage("Problem in operator /=.")); + } + else + { + for (unsigned int i = 4; i < 10; ++i) + AssertThrow(Number(0.5) * read_write_2[i] == read_write_3[i], + ExcMessage("Problem in operator /=.")); + } + + b += a; + read_write_3.import_elements(b, VectorOperation::insert); + if (rank == 0) + { + for (unsigned int i = 0; i < 6; ++i) + AssertThrow(Number(2.) * read_write_2[i] + read_write_1[i] == + read_write_3[i], + ExcMessage("Problem in operator +=.")); + } + else + { + for (unsigned int i = 4; i < 10; ++i) + AssertThrow(Number(2.) * read_write_2[i] + read_write_1[i] == + read_write_3[i], + ExcMessage("Problem in operator +=.")); + } + + b -= c; + read_write_3.import_elements(b, VectorOperation::insert); + if (rank == 0) + { + for (unsigned int i = 0; i < 6; ++i) + AssertThrow(Number(1.5) * read_write_2[i] + read_write_1[i] == + read_write_3[i], + ExcMessage("Problem in operator -=.")); + } + else + { + for (unsigned int i = 4; i < 10; ++i) + AssertThrow(Number(1.5) * read_write_2[i] + read_write_1[i] == + read_write_3[i], + ExcMessage("Problem in operator -=.")); + } + + b.import_elements(read_write_1, VectorOperation::insert); + c.import_elements(read_write_1, VectorOperation::insert); + const Number val = b * c; + AssertThrow(val == Number(285.), ExcMessage("Problem in operator *.")); +} + + +int +main(int argc, char **argv) +{ + initlog(); + deallog.depth_console(0); + + Utilities::MPI::MPI_InitFinalize mpi_init(argc, argv, 1); + + test(); + + deallog << "OK" << std::endl; + + return 0; +} diff --git a/tests/trilinos_tpetra/tpetra_vector_01.mpirun=2.with_trilinos_with_tpetra=on.output b/tests/trilinos_tpetra/tpetra_vector_01.mpirun=2.with_trilinos_with_tpetra=on.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/tpetra_vector_01.mpirun=2.with_trilinos_with_tpetra=on.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/tpetra_vector_02.cc b/tests/trilinos_tpetra/tpetra_vector_02.cc new file mode 100644 index 0000000000..99cd52ad15 --- /dev/null +++ b/tests/trilinos_tpetra/tpetra_vector_02.cc @@ -0,0 +1,223 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2018 - 2023 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + +#include + +#include +#include + +#include +#include + +#include "../tests.h" + +// Check LinearAlgebra::TpetraWrappers::Vector add and sadd. + +template +void +test() +{ + IndexSet parallel_partitioner_1(10); + IndexSet parallel_partitioner_2(10); + unsigned int rank = Utilities::MPI::this_mpi_process(MPI_COMM_WORLD); + if (rank == 0) + { + parallel_partitioner_1.add_range(0, 5); + parallel_partitioner_2.add_range(0, 3); + } + else + { + parallel_partitioner_1.add_range(5, 10); + parallel_partitioner_2.add_range(3, 10); + } + parallel_partitioner_1.compress(); + parallel_partitioner_2.compress(); + LinearAlgebra::TpetraWrappers::Vector a(parallel_partitioner_1, + MPI_COMM_WORLD); + LinearAlgebra::TpetraWrappers::Vector b(parallel_partitioner_1, + MPI_COMM_WORLD); + LinearAlgebra::TpetraWrappers::Vector c(parallel_partitioner_2, + MPI_COMM_WORLD); + + IndexSet read_write_index_set(10); + if (rank == 0) + read_write_index_set.add_range(0, 5); + else + read_write_index_set.add_range(5, 10); + read_write_index_set.compress(); + + LinearAlgebra::ReadWriteVector read_write_1(read_write_index_set); + LinearAlgebra::ReadWriteVector read_write_2(read_write_index_set); + LinearAlgebra::ReadWriteVector read_write_3(read_write_index_set); + if (rank == 0) + { + for (unsigned int i = 0; i < 5; ++i) + { + read_write_1[i] = i; + read_write_2[i] = 5. + i; + } + } + else + { + for (unsigned int i = 5; i < 10; ++i) + { + read_write_1[i] = i; + read_write_2[i] = 5. + i; + } + } + + a.import_elements(read_write_1, VectorOperation::insert); + b.import_elements(read_write_2, VectorOperation::insert); + c.import_elements(read_write_2, VectorOperation::insert); + + a.add(1.); + read_write_3.import_elements(a, VectorOperation::insert); + if (rank == 0) + { + for (unsigned int i = 0; i < 5; ++i) + AssertThrow(Number(1.) + read_write_1[i] == read_write_3[i], + ExcMessage("Problem in add(scalar).")); + } + else + { + for (unsigned int i = 5; i < 10; ++i) + AssertThrow(Number(1.) + read_write_1[i] == read_write_3[i], + ExcMessage("Problem in add(scalar).")); + } + + a.add(2., b); + read_write_3.import_elements(a, VectorOperation::insert); + if (rank == 0) + { + for (unsigned int i = 0; i < 5; ++i) + AssertThrow(Number(1.) + read_write_1[i] + + Number(2.) * read_write_2[i] == + read_write_3[i], + ExcMessage("Problem in add(scalar,Vector).")); + } + else + { + for (unsigned int i = 5; i < 10; ++i) + AssertThrow(Number(1.) + read_write_1[i] + + Number(2.) * read_write_2[i] == + read_write_3[i], + ExcMessage("Problem in add(scalar,Vector).")); + } + + + LinearAlgebra::TpetraWrappers::Vector d(a); + a.add(2., b, 3., d); + read_write_3.import_elements(a, VectorOperation::insert); + if (rank == 0) + { + for (unsigned int i = 0; i < 5; ++i) + AssertThrow(Number(4.) + Number(4.) * read_write_1[i] + + Number(10.) * read_write_2[i] == + read_write_3[i], + ExcMessage("Problem in add(scalar,Vector,scalar,Vector).")); + } + else + { + for (unsigned int i = 5; i < 10; ++i) + AssertThrow(Number(4.) + Number(4.) * read_write_1[i] + + Number(10.) * read_write_2[i] == + read_write_3[i], + ExcMessage("Problem in add(scalar,Vector,scalar,Vector).")); + } + + + a.import_elements(read_write_1, VectorOperation::insert); + a.sadd(3., 2., c); + read_write_3.import_elements(a, VectorOperation::insert); + if (rank == 0) + { + for (unsigned int i = 0; i < 5; ++i) + AssertThrow(Number(3.) * read_write_1[i] + + Number(2.) * read_write_2[i] == + read_write_3[i], + ExcMessage("Problem in sadd(scalar,scalar,Vector).")); + } + else + { + for (unsigned int i = 5; i < 10; ++i) + AssertThrow(Number(3.) * read_write_1[i] + + Number(2.) * read_write_2[i] == + read_write_3[i], + ExcMessage("Problem in sadd(scalar,scalar,Vector).")); + } + + + a.import_elements(read_write_1, VectorOperation::insert); + a.scale(b); + read_write_3.import_elements(a, VectorOperation::insert); + if (rank == 0) + { + for (unsigned int i = 0; i < 5; ++i) + AssertThrow(read_write_1[i] * read_write_2[i] == read_write_3[i], + ExcMessage("Problem in scale.")); + } + else + { + for (unsigned int i = 5; i < 10; ++i) + AssertThrow(read_write_1[i] * read_write_2[i] == read_write_3[i], + ExcMessage("Problem in scale.")); + } + + + a.equ(2., c); + read_write_3.import_elements(a, VectorOperation::insert); + if (rank == 0) + { + for (unsigned int i = 0; i < 5; ++i) + AssertThrow(Number(2.) * read_write_2[i] == read_write_3[i], + ExcMessage("Problem in scale.")); + } + else + { + for (unsigned int i = 5; i < 10; ++i) + AssertThrow((Number)2. * read_write_2[i] == read_write_3[i], + ExcMessage("Problem in equ.")); + } + + + AssertThrow(b.l1_norm() == 95., ExcMessage("Problem in l1_norm.")); + + const double eps = 1e-6; + AssertThrow(std::fabs(b.l2_norm() - 31.3847096) < eps, + ExcMessage("Problem in l2_norm")); + + AssertThrow(b.linfty_norm() == 14., ExcMessage("Problem in linfty_norm.")); + + a.import_elements(read_write_1, VectorOperation::insert); + const Number val = a.add_and_dot(2., a, b); + AssertThrow(val == Number(1530.), ExcMessage("Problem in add_and_dot")); +} + + +int +main(int argc, char **argv) +{ + initlog(); + deallog.depth_console(0); + + Utilities::MPI::MPI_InitFinalize mpi_init(argc, argv, 1); + + test(); + + deallog << "OK" << std::endl; + + return 0; +} diff --git a/tests/trilinos_tpetra/tpetra_vector_02.mpirun=2.with_trilinos_with_tpetra=on.output b/tests/trilinos_tpetra/tpetra_vector_02.mpirun=2.with_trilinos_with_tpetra=on.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/tpetra_vector_02.mpirun=2.with_trilinos_with_tpetra=on.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/tpetra_vector_03.cc b/tests/trilinos_tpetra/tpetra_vector_03.cc new file mode 100644 index 0000000000..519a727d4e --- /dev/null +++ b/tests/trilinos_tpetra/tpetra_vector_03.cc @@ -0,0 +1,103 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2018 - 2023 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + +// Check LinearAlgebra::TpetraWrappers::Vector::import +// for VectorOperation::add and check LinearAlgebra::ReadWriteVector +// for VectorOperation::add/min/max. + +#include +#include + +#include +#include + +#include +#include + +#include "../tests.h" + +template +void +test() +{ + unsigned int my_id = Utilities::MPI::this_mpi_process(MPI_COMM_WORLD); + unsigned int n_procs = Utilities::MPI::n_mpi_processes(MPI_COMM_WORLD); + + IndexSet locally_owned(n_procs * 2); + locally_owned.add_range(my_id * 2, my_id * 2 + 2); + locally_owned.compress(); + + LinearAlgebra::TpetraWrappers::Vector v(locally_owned, + MPI_COMM_WORLD); + + IndexSet workaround_set(n_procs * 2); + unsigned int my_first_index = (my_id * 2 + 2) % (n_procs * 2); + unsigned int my_second_index = my_id * 2 + 1; + workaround_set.add_index(my_first_index); + workaround_set.add_index(my_second_index); + workaround_set.add_index(0); + workaround_set.compress(); + LinearAlgebra::ReadWriteVector rw_vector(workaround_set); + + rw_vector(my_first_index) = my_id + 10; + rw_vector(my_second_index) = my_id + 100; + rw_vector(0) = 1.; + // rw_vector(2) = 1.; + v.import_elements(rw_vector, VectorOperation::add); + deallog << "Tpetra first import add:" << std::endl; + v.print(deallog.get_file_stream()); + rw_vector.print(deallog.get_file_stream()); + + rw_vector(my_first_index) = my_id + 20; + rw_vector(my_second_index) = my_id + 200; + rw_vector(0) = 2.; + // rw_vector(2) = 3.; + v.import_elements(rw_vector, VectorOperation::add); + deallog << "Tpetra second import add:" << std::endl; + v.print(deallog.get_file_stream()); + rw_vector.print(deallog.get_file_stream()); + + rw_vector.import_elements(v, VectorOperation::add); + deallog << "ReadWrite import add:" << std::endl; + rw_vector.print(deallog.get_file_stream()); + + rw_vector(my_first_index) = my_id + 100; + rw_vector(my_second_index) = 1; + rw_vector(0) = 4.; + // rw_vector(2) = 3.; + rw_vector.import_elements(v, VectorOperation::min); + deallog << "ReadWrite import min:" << std::endl; + rw_vector.print(deallog.get_file_stream()); + + rw_vector(my_first_index) = my_id + 100; + rw_vector(my_second_index) = 1; + rw_vector(0) = 4.; + // rw_vector(2) = 3.; + rw_vector.import_elements(v, VectorOperation::max); + deallog << "ReadWrite import max:" << std::endl; + rw_vector.print(deallog.get_file_stream()); +} + + + +int +main(int argc, char **argv) +{ + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + MPILogInitAll log; + test(); +} diff --git a/tests/trilinos_tpetra/tpetra_vector_03.with_trilinos_with_tpetra=on.with_complex_values=off.mpirun=2.output b/tests/trilinos_tpetra/tpetra_vector_03.with_trilinos_with_tpetra=on.with_complex_values=off.mpirun=2.output new file mode 100644 index 0000000000..ba921e5ad6 --- /dev/null +++ b/tests/trilinos_tpetra/tpetra_vector_03.with_trilinos_with_tpetra=on.with_complex_values=off.mpirun=2.output @@ -0,0 +1,70 @@ + +DEAL:0::Tpetra first import add: +size:4 locally_owned_size:2 : +[0]: 2.000e+00 +[1]: 1.000e+02 +IndexSet: {[0,2]} + +[0]: 1.000e+00 +[1]: 1.000e+02 +[2]: 1.000e+01 +DEAL:0::Tpetra second import add: +size:4 locally_owned_size:2 : +[0]: 4.000e+00 +[1]: 2.000e+02 +IndexSet: {[0,2]} + +[0]: 2.000e+00 +[1]: 2.000e+02 +[2]: 2.000e+01 +DEAL:0::ReadWrite import add: +IndexSet: {[0,2]} + +[0]: 6.000e+00 +[1]: 4.000e+02 +[2]: 5.000e+01 +DEAL:0::ReadWrite import min: +IndexSet: {[0,2]} + +[0]: 4.000e+00 +[1]: 1.000e+00 +[2]: 3.000e+01 +DEAL:0::ReadWrite import max: +IndexSet: {[0,2]} + +[0]: 4.000e+00 +[1]: 2.000e+02 +[2]: 1.000e+02 + +DEAL:1::Tpetra first import add: +size:4 locally_owned_size:2 : +[2]: 1.000e+01 +[3]: 1.010e+02 +IndexSet: {0, 3} + +[0]: 1.000e+00 +[3]: 1.010e+02 +DEAL:1::Tpetra second import add: +size:4 locally_owned_size:2 : +[2]: 3.000e+01 +[3]: 2.010e+02 +IndexSet: {0, 3} + +[0]: 2.000e+00 +[3]: 2.010e+02 +DEAL:1::ReadWrite import add: +IndexSet: {0, 3} + +[0]: 6.000e+00 +[3]: 4.020e+02 +DEAL:1::ReadWrite import min: +IndexSet: {0, 3} + +[0]: 4.000e+00 +[3]: 1.000e+00 +DEAL:1::ReadWrite import max: +IndexSet: {0, 3} + +[0]: 4.000e+00 +[3]: 2.010e+02 + diff --git a/tests/trilinos_tpetra/tpetra_vector_03.with_trilinos_with_tpetra=on.with_complex_values=off.mpirun=4.output b/tests/trilinos_tpetra/tpetra_vector_03.with_trilinos_with_tpetra=on.with_complex_values=off.mpirun=4.output new file mode 100644 index 0000000000..f643d65be1 --- /dev/null +++ b/tests/trilinos_tpetra/tpetra_vector_03.with_trilinos_with_tpetra=on.with_complex_values=off.mpirun=4.output @@ -0,0 +1,146 @@ + +DEAL:0::Tpetra first import add: +size:8 locally_owned_size:2 : +[0]: 4.000e+00 +[1]: 1.000e+02 +IndexSet: {[0,2]} + +[0]: 1.000e+00 +[1]: 1.000e+02 +[2]: 1.000e+01 +DEAL:0::Tpetra second import add: +size:8 locally_owned_size:2 : +[0]: 8.000e+00 +[1]: 2.000e+02 +IndexSet: {[0,2]} + +[0]: 2.000e+00 +[1]: 2.000e+02 +[2]: 2.000e+01 +DEAL:0::ReadWrite import add: +IndexSet: {[0,2]} + +[0]: 1.000e+01 +[1]: 4.000e+02 +[2]: 5.000e+01 +DEAL:0::ReadWrite import min: +IndexSet: {[0,2]} + +[0]: 4.000e+00 +[1]: 1.000e+00 +[2]: 3.000e+01 +DEAL:0::ReadWrite import max: +IndexSet: {[0,2]} + +[0]: 8.000e+00 +[1]: 2.000e+02 +[2]: 1.000e+02 + +DEAL:1::Tpetra first import add: +size:8 locally_owned_size:2 : +[2]: 1.000e+01 +[3]: 1.010e+02 +IndexSet: {0, [3,4]} + +[0]: 1.000e+00 +[3]: 1.010e+02 +[4]: 1.100e+01 +DEAL:1::Tpetra second import add: +size:8 locally_owned_size:2 : +[2]: 3.000e+01 +[3]: 2.010e+02 +IndexSet: {0, [3,4]} + +[0]: 2.000e+00 +[3]: 2.010e+02 +[4]: 2.100e+01 +DEAL:1::ReadWrite import add: +IndexSet: {0, [3,4]} + +[0]: 1.000e+01 +[3]: 4.020e+02 +[4]: 5.300e+01 +DEAL:1::ReadWrite import min: +IndexSet: {0, [3,4]} + +[0]: 4.000e+00 +[3]: 1.000e+00 +[4]: 3.200e+01 +DEAL:1::ReadWrite import max: +IndexSet: {0, [3,4]} + +[0]: 8.000e+00 +[3]: 2.010e+02 +[4]: 1.010e+02 + + +DEAL:2::Tpetra first import add: +size:8 locally_owned_size:2 : +[4]: 1.100e+01 +[5]: 1.020e+02 +IndexSet: {0, [5,6]} + +[0]: 1.000e+00 +[5]: 1.020e+02 +[6]: 1.200e+01 +DEAL:2::Tpetra second import add: +size:8 locally_owned_size:2 : +[4]: 3.200e+01 +[5]: 2.020e+02 +IndexSet: {0, [5,6]} + +[0]: 2.000e+00 +[5]: 2.020e+02 +[6]: 2.200e+01 +DEAL:2::ReadWrite import add: +IndexSet: {0, [5,6]} + +[0]: 1.000e+01 +[5]: 4.040e+02 +[6]: 5.600e+01 +DEAL:2::ReadWrite import min: +IndexSet: {0, [5,6]} + +[0]: 4.000e+00 +[5]: 1.000e+00 +[6]: 3.400e+01 +DEAL:2::ReadWrite import max: +IndexSet: {0, [5,6]} + +[0]: 8.000e+00 +[5]: 2.020e+02 +[6]: 1.020e+02 + + +DEAL:3::Tpetra first import add: +size:8 locally_owned_size:2 : +[6]: 1.200e+01 +[7]: 1.030e+02 +IndexSet: {0, 7} + +[0]: 1.000e+00 +[7]: 1.030e+02 +DEAL:3::Tpetra second import add: +size:8 locally_owned_size:2 : +[6]: 3.400e+01 +[7]: 2.030e+02 +IndexSet: {0, 7} + +[0]: 2.000e+00 +[7]: 2.030e+02 +DEAL:3::ReadWrite import add: +IndexSet: {0, 7} + +[0]: 1.000e+01 +[7]: 4.060e+02 +DEAL:3::ReadWrite import min: +IndexSet: {0, 7} + +[0]: 4.000e+00 +[7]: 1.000e+00 +DEAL:3::ReadWrite import max: +IndexSet: {0, 7} + +[0]: 8.000e+00 +[7]: 2.030e+02 + diff --git a/tests/trilinos_tpetra/tpetra_vector_03.with_trilinos_with_tpetra=on.with_complex_values=on.mpirun=2.output b/tests/trilinos_tpetra/tpetra_vector_03.with_trilinos_with_tpetra=on.with_complex_values=on.mpirun=2.output new file mode 100644 index 0000000000..ba921e5ad6 --- /dev/null +++ b/tests/trilinos_tpetra/tpetra_vector_03.with_trilinos_with_tpetra=on.with_complex_values=on.mpirun=2.output @@ -0,0 +1,70 @@ + +DEAL:0::Tpetra first import add: +size:4 locally_owned_size:2 : +[0]: 2.000e+00 +[1]: 1.000e+02 +IndexSet: {[0,2]} + +[0]: 1.000e+00 +[1]: 1.000e+02 +[2]: 1.000e+01 +DEAL:0::Tpetra second import add: +size:4 locally_owned_size:2 : +[0]: 4.000e+00 +[1]: 2.000e+02 +IndexSet: {[0,2]} + +[0]: 2.000e+00 +[1]: 2.000e+02 +[2]: 2.000e+01 +DEAL:0::ReadWrite import add: +IndexSet: {[0,2]} + +[0]: 6.000e+00 +[1]: 4.000e+02 +[2]: 5.000e+01 +DEAL:0::ReadWrite import min: +IndexSet: {[0,2]} + +[0]: 4.000e+00 +[1]: 1.000e+00 +[2]: 3.000e+01 +DEAL:0::ReadWrite import max: +IndexSet: {[0,2]} + +[0]: 4.000e+00 +[1]: 2.000e+02 +[2]: 1.000e+02 + +DEAL:1::Tpetra first import add: +size:4 locally_owned_size:2 : +[2]: 1.000e+01 +[3]: 1.010e+02 +IndexSet: {0, 3} + +[0]: 1.000e+00 +[3]: 1.010e+02 +DEAL:1::Tpetra second import add: +size:4 locally_owned_size:2 : +[2]: 3.000e+01 +[3]: 2.010e+02 +IndexSet: {0, 3} + +[0]: 2.000e+00 +[3]: 2.010e+02 +DEAL:1::ReadWrite import add: +IndexSet: {0, 3} + +[0]: 6.000e+00 +[3]: 4.020e+02 +DEAL:1::ReadWrite import min: +IndexSet: {0, 3} + +[0]: 4.000e+00 +[3]: 1.000e+00 +DEAL:1::ReadWrite import max: +IndexSet: {0, 3} + +[0]: 4.000e+00 +[3]: 2.010e+02 + diff --git a/tests/trilinos_tpetra/tpetra_vector_03.with_trilinos_with_tpetra=on.with_complex_values=on.mpirun=4.output b/tests/trilinos_tpetra/tpetra_vector_03.with_trilinos_with_tpetra=on.with_complex_values=on.mpirun=4.output new file mode 100644 index 0000000000..f643d65be1 --- /dev/null +++ b/tests/trilinos_tpetra/tpetra_vector_03.with_trilinos_with_tpetra=on.with_complex_values=on.mpirun=4.output @@ -0,0 +1,146 @@ + +DEAL:0::Tpetra first import add: +size:8 locally_owned_size:2 : +[0]: 4.000e+00 +[1]: 1.000e+02 +IndexSet: {[0,2]} + +[0]: 1.000e+00 +[1]: 1.000e+02 +[2]: 1.000e+01 +DEAL:0::Tpetra second import add: +size:8 locally_owned_size:2 : +[0]: 8.000e+00 +[1]: 2.000e+02 +IndexSet: {[0,2]} + +[0]: 2.000e+00 +[1]: 2.000e+02 +[2]: 2.000e+01 +DEAL:0::ReadWrite import add: +IndexSet: {[0,2]} + +[0]: 1.000e+01 +[1]: 4.000e+02 +[2]: 5.000e+01 +DEAL:0::ReadWrite import min: +IndexSet: {[0,2]} + +[0]: 4.000e+00 +[1]: 1.000e+00 +[2]: 3.000e+01 +DEAL:0::ReadWrite import max: +IndexSet: {[0,2]} + +[0]: 8.000e+00 +[1]: 2.000e+02 +[2]: 1.000e+02 + +DEAL:1::Tpetra first import add: +size:8 locally_owned_size:2 : +[2]: 1.000e+01 +[3]: 1.010e+02 +IndexSet: {0, [3,4]} + +[0]: 1.000e+00 +[3]: 1.010e+02 +[4]: 1.100e+01 +DEAL:1::Tpetra second import add: +size:8 locally_owned_size:2 : +[2]: 3.000e+01 +[3]: 2.010e+02 +IndexSet: {0, [3,4]} + +[0]: 2.000e+00 +[3]: 2.010e+02 +[4]: 2.100e+01 +DEAL:1::ReadWrite import add: +IndexSet: {0, [3,4]} + +[0]: 1.000e+01 +[3]: 4.020e+02 +[4]: 5.300e+01 +DEAL:1::ReadWrite import min: +IndexSet: {0, [3,4]} + +[0]: 4.000e+00 +[3]: 1.000e+00 +[4]: 3.200e+01 +DEAL:1::ReadWrite import max: +IndexSet: {0, [3,4]} + +[0]: 8.000e+00 +[3]: 2.010e+02 +[4]: 1.010e+02 + + +DEAL:2::Tpetra first import add: +size:8 locally_owned_size:2 : +[4]: 1.100e+01 +[5]: 1.020e+02 +IndexSet: {0, [5,6]} + +[0]: 1.000e+00 +[5]: 1.020e+02 +[6]: 1.200e+01 +DEAL:2::Tpetra second import add: +size:8 locally_owned_size:2 : +[4]: 3.200e+01 +[5]: 2.020e+02 +IndexSet: {0, [5,6]} + +[0]: 2.000e+00 +[5]: 2.020e+02 +[6]: 2.200e+01 +DEAL:2::ReadWrite import add: +IndexSet: {0, [5,6]} + +[0]: 1.000e+01 +[5]: 4.040e+02 +[6]: 5.600e+01 +DEAL:2::ReadWrite import min: +IndexSet: {0, [5,6]} + +[0]: 4.000e+00 +[5]: 1.000e+00 +[6]: 3.400e+01 +DEAL:2::ReadWrite import max: +IndexSet: {0, [5,6]} + +[0]: 8.000e+00 +[5]: 2.020e+02 +[6]: 1.020e+02 + + +DEAL:3::Tpetra first import add: +size:8 locally_owned_size:2 : +[6]: 1.200e+01 +[7]: 1.030e+02 +IndexSet: {0, 7} + +[0]: 1.000e+00 +[7]: 1.030e+02 +DEAL:3::Tpetra second import add: +size:8 locally_owned_size:2 : +[6]: 3.400e+01 +[7]: 2.030e+02 +IndexSet: {0, 7} + +[0]: 2.000e+00 +[7]: 2.030e+02 +DEAL:3::ReadWrite import add: +IndexSet: {0, 7} + +[0]: 1.000e+01 +[7]: 4.060e+02 +DEAL:3::ReadWrite import min: +IndexSet: {0, 7} + +[0]: 4.000e+00 +[7]: 1.000e+00 +DEAL:3::ReadWrite import max: +IndexSet: {0, 7} + +[0]: 8.000e+00 +[7]: 2.030e+02 + diff --git a/tests/trilinos_tpetra/vector_reference_01.cc b/tests/trilinos_tpetra/vector_reference_01.cc new file mode 100644 index 0000000000..e7925a1b67 --- /dev/null +++ b/tests/trilinos_tpetra/vector_reference_01.cc @@ -0,0 +1,75 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2017 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + + +// LinearAlgebra::TpetraWrappers::internal::VectorReference had its non-const +// copy operator return a const reference. That was non-intuitive but, because +// of the particular semantics of copying vector reference objects, made no +// difference. Either way, we now check these semantics. + +#include + +#include + +#include + +#include "../tests.h" + + +void +test() +{ + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(3), MPI_COMM_WORLD); + v(0) = 0; + v(1) = 1; + v(2) = 2; + + LinearAlgebra::TpetraWrappers::internal::VectorReference a(v(0)); + LinearAlgebra::TpetraWrappers::internal::VectorReference b(v(1)); + LinearAlgebra::TpetraWrappers::internal::VectorReference c(v(2)); + + // Copy the VectorReference objects. Note that operator= for these + // objects does not copy the *content* of the reference object, but + // rather assigns the value of the vector element referenced on the + // right to the vector element referenced on the left. + // So the applied operations result in the following actions: + // 1. We first assign c to point to where a points (c points to entry 0) + // 2. We next assign c to point to where b points (c points to entry 1) + // 3. Lastly, we assign b to point to where a points (b points to entry 0) + (c = a) = b; + b = a; + + deallog << static_cast(a) + << std::endl; // should point to v(0) + deallog << static_cast(b) + << std::endl; // should point to v(0) + deallog << static_cast(c) + << std::endl; // should point to v(1) +} + + + +int +main(int argc, char **argv) +{ + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + initlog(); + ; + + test(); +} diff --git a/tests/trilinos_tpetra/vector_reference_01.output b/tests/trilinos_tpetra/vector_reference_01.output new file mode 100644 index 0000000000..440392e8db --- /dev/null +++ b/tests/trilinos_tpetra/vector_reference_01.output @@ -0,0 +1,4 @@ + +DEAL::0.00000 +DEAL::0.00000 +DEAL::1.00000 diff --git a/tests/trilinos_tpetra/vector_reinit.cc b/tests/trilinos_tpetra/vector_reinit.cc new file mode 100644 index 0000000000..a9b2d84945 --- /dev/null +++ b/tests/trilinos_tpetra/vector_reinit.cc @@ -0,0 +1,79 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2020 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + +// run LinearAlgebra::TpetraWrappers::Vector.renit() in MPI environment +// to test IndexSet::make_trilinos_map(), which contained an MPI-related bug. +// Namely, a Fortran type MPI_LOGICAL was used instead of MPI_INT. + + +#include + +#include +#include + +#include +#include + +#include + +#include + +#include + +#include "../tests.h" + + +static const unsigned int dim = 2; + +void +test() +{ + MPI_Comm mpi_communicator(MPI_COMM_WORLD); + + parallel::distributed::Triangulation tria( + mpi_communicator, + typename Triangulation::MeshSmoothing( + Triangulation::smoothing_on_refinement | + Triangulation::smoothing_on_coarsening)); + + GridGenerator::hyper_cube(tria, -1, 0); + tria.refine_global(2); + + const unsigned int poly_degree = 1; + FE_Q fe(poly_degree); + + DoFHandler dof_handler(tria); + dof_handler.distribute_dofs(fe); + + IndexSet locally_owned_dofs = dof_handler.locally_owned_dofs(); + + LinearAlgebra::TpetraWrappers::Vector vector_Re; + vector_Re.reinit(locally_owned_dofs, mpi_communicator); + + deallog << "OK" << std::endl; +} + + +int +main(int argc, char *argv[]) +{ + initlog(); + deallog.depth_console(0); + + Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1); + { + test(); + } +} diff --git a/tests/trilinos_tpetra/vector_reinit.with_p4est=true.mpirun=3.output b/tests/trilinos_tpetra/vector_reinit.with_p4est=true.mpirun=3.output new file mode 100644 index 0000000000..0fd8fc12f0 --- /dev/null +++ b/tests/trilinos_tpetra/vector_reinit.with_p4est=true.mpirun=3.output @@ -0,0 +1,2 @@ + +DEAL::OK diff --git a/tests/trilinos_tpetra/vector_swap_01.cc b/tests/trilinos_tpetra/vector_swap_01.cc new file mode 100644 index 0000000000..012f350dc5 --- /dev/null +++ b/tests/trilinos_tpetra/vector_swap_01.cc @@ -0,0 +1,112 @@ +// --------------------------------------------------------------------- +// +// Copyright (C) 2004 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// The deal.II library is free software; you can use it, redistribute +// it, and/or modify it under the terms of the GNU Lesser General +// Public License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// The full text of the license can be found in the file LICENSE.md at +// the top level directory of deal.II. +// +// --------------------------------------------------------------------- + + +/* + test ::Vector::swap() (fixed in r 25668) + */ + + +#include + +#include + +#include +#include + +#include "../tests.h" + +void +print(LinearAlgebra::TpetraWrappers::Vector &v) +{ + deallog << "size= " << v.size() << " el(0)= " << v(0) + << " l2norm()= " << v.l2_norm() << std::endl; +} + + +void +test() +{ + LinearAlgebra::TpetraWrappers::Vector v; + v.reinit(complete_index_set(5), MPI_COMM_WORLD); + for (unsigned int i = 0; i < v.size(); ++i) + v(i) = 1; + LinearAlgebra::TpetraWrappers::Vector w; + w.reinit(complete_index_set(9), MPI_COMM_WORLD); + for (unsigned int i = 0; i < w.size(); ++i) + w(i) = 2; + + + deallog << "v: "; + print(v); + deallog << "w: "; + print(w); + + deallog << "**swap**" << std::endl; + + swap(v, w); + + deallog << "v: "; + print(v); + deallog << "w: "; + print(w); + + Assert(v.size() == 9, ExcInternalError()); + + deallog << "OK" << std::endl; +} + + + +int +main(int argc, char **argv) +{ + initlog(); + + Utilities::MPI::MPI_InitFinalize mpi_initialization( + argc, argv, testing_max_num_threads()); + + + try + { + test(); + } + catch (const std::exception &exc) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Exception on processing: " << std::endl + << exc.what() << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + + return 1; + } + catch (...) + { + std::cerr << std::endl + << std::endl + << "----------------------------------------------------" + << std::endl; + std::cerr << "Unknown exception!" << std::endl + << "Aborting!" << std::endl + << "----------------------------------------------------" + << std::endl; + return 1; + }; +} diff --git a/tests/trilinos_tpetra/vector_swap_01.output b/tests/trilinos_tpetra/vector_swap_01.output new file mode 100644 index 0000000000..e0224540da --- /dev/null +++ b/tests/trilinos_tpetra/vector_swap_01.output @@ -0,0 +1,7 @@ + +DEAL::v: size= 5 el(0)= 1.00000 l2norm()= 2.23607 +DEAL::w: size= 9 el(0)= 2.00000 l2norm()= 6.00000 +DEAL::**swap** +DEAL::v: size= 9 el(0)= 2.00000 l2norm()= 6.00000 +DEAL::w: size= 5 el(0)= 1.00000 l2norm()= 2.23607 +DEAL::OK -- 2.39.5