//---------------------------- trilinos_01.cc ---------------------------
-// check setting elements in a petsc matrix using
+// check setting elements in a trilinos matrix using
// TrilinosWrappers::SparseMatrix::set()
-#include "../tests.h"
-#include <lac/trilinos_sparse_matrix.h>
+#include "../tests.h"
+#include <base/utilities.h>
+#include <lac/trilinos_sparse_matrix.h>
#include <fstream>
#include <iostream>
m.set (i,j, i*j*.5+.5);
m.compress ();
-
+
// then make sure we retrieve the same ones
for (unsigned int i=0; i<m.m(); ++i)
for (unsigned int j=0; j<m.m(); ++j)
}
else
{
- Assert (m(i,j) == 0, ExcInternalError());
Assert (m.el(i,j) == 0, ExcInternalError());
}
std::ofstream logfile("01/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
try
{
// check setting elements in a petsc matrix using
// TrilinosWrappers::SparseMatrix::add()
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_sparse_matrix.h>
#include <fstream>
#include <iostream>
}
else
{
- Assert (m(i,j) == 0, ExcInternalError());
Assert (m.el(i,j) == 0, ExcInternalError());
}
std::ofstream logfile("02/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
try
{
// intermixed. this poses PETSc some problems, since one has to flush some
// buffer in between these two types of operations
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_sparse_matrix.h>
#include <fstream>
#include <iostream>
}
else
{
- Assert (m(i,j) == 0, ExcInternalError());
Assert (m.el(i,j) == 0, ExcInternalError());
}
std::ofstream logfile("03/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
try
{
// in contrast to trilinos_03, we set and add the same elements here twice, to
// get double the original value
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_sparse_matrix.h>
#include <fstream>
#include <iostream>
for (unsigned int j=0; j<m.m(); ++j)
if ((i+2*j+1) % 3 == 0)
m.set (i,j, i*j*.5+.5);
+
+ m.compress();
// then add the same elements again
for (unsigned int i=0; i<m.m(); ++i)
}
else
{
- Assert (m(i,j) == 0, ExcInternalError());
Assert (m.el(i,j) == 0, ExcInternalError());
}
std::ofstream logfile("03a/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
try
{
// in contrast to trilinos_03a, we set and add the same elements here twice, then
// overwrite them again to get the original value back
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_sparse_matrix.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("03b/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
try
{
// check querying matrix sizes
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_sparse_matrix.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("04/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check querying the number of nonzero elements in
// TrilinosWrappers::SparseMatrix
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_sparse_matrix.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("05/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::SparseMatrix::l1_norm
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_sparse_matrix.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("06/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::SparseMatrix::linfty_norm
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_sparse_matrix.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("07/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::SparseMatrix::frobenius_norm
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_sparse_matrix.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("08/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::SparseMatrix::operator *=
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_sparse_matrix.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("09/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::SparseMatrix::operator /=
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_sparse_matrix.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("10/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::size()
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("11/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::operator() in set-mode
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("12/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::operator() in add-mode
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("13/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::operator() in set/add-mode alternatingly
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("14/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::operator() in set/add-mode alternatingly, but
// writing to the same elements
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("15/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::operator() in set/add-mode alternatingly, but
// writing and overwriting the same elements
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("16/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::l1_norm()
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("17/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::l2_norm()
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("18/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::linfty_norm()
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("19/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::operator *=
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("20/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::operator /=
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("21/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::operator*(Vector) on two vectors that are
// orthogonal
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("22/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::operator*(Vector) on two vectors that are
// not orthogonal
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("23/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// function has since been removed, so we test for v=0 instead, although that
// may be covered by one of the other tests
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("24/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::operator = (TrilinosScalar) with setting to zero
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("25/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::operator = (TrilinosScalar) with setting to a
// nonzero value
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("26/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::operator = (Vector)
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("27/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::operator = (Vector), except that we don't
// resize the vector to be copied to beforehand
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("28/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::reinit(fast)
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("29/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::reinit(!fast)
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("30/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::l2_norm()
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("31/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::mean_value()
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("32/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::lp_norm(3)
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("33/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::all_zero
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("34/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::operator+=(Vector)
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("35/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::operator-=(Vector)
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("36/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::add (scalar)
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("37/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::add(Vector)
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("38/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::add(scalar, Vector)
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("39/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::add(s,V,s,V)
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("40/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::sadd(s, Vector)
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("41/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::sadd(scalar, scalar, Vector)
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("42/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::sadd(s,s,V,s,V)
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("43/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::sadd(s,s,V,s,V,s,V)
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("44/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::scale
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("45/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::equ (s,V)
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("46/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::equ (s,V,s,V)
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("47/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::ratio
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("48/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::operator = (Vector<PetscVector>)
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <lac/vector.h>
#include <fstream>
std::ofstream logfile("49/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::operator = (Vector<T>) with T!=TrilinosScalar
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <lac/vector.h>
#include <fstream>
std::ofstream logfile("50/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check copy constructor TrilinosWrappers::Vector::Vector(Vector)
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("51/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// TrilinosWrappers::SparseMatrix::set(). like trilinos_01, but use a different
// constructor for the sparse matrix
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_sparse_matrix.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("52/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::operator() in set, and later in add-mode
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("53/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::operator() in set, and later in -= mode
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("54/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::operator() in set, and later in *= mode
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("55/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::operator() in set, and later in /= mode
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("56/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::is_non_zero
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("57/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check ::Vector (const TrilinosWrappers::Vector &) copy constructor
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <lac/vector.h>
std::ofstream logfile("58/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector (const ::Vector &) copy constructor
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <lac/vector.h>
std::ofstream logfile("59/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check ::Vector::operator = (const TrilinosWrappers::Vector &)
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <lac/vector.h>
std::ofstream logfile("60/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::operator = (const ::Vector &)
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <lac/vector.h>
std::ofstream logfile("61/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::MatrixBase::clear ()
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_sparse_matrix.h>
#include <lac/vector.h>
std::ofstream logfile("62/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
//---------------------------- trilinos_63.cc ---------------------------
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_sparse_matrix.h>
#include <lac/vector.h>
std::ofstream logfile("63/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// TrilinosWrappers::MatrixBase::operator=
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_sparse_matrix.h>
#include <lac/trilinos_sparse_matrix.h>
#include <lac/vector.h>
std::ofstream logfile("64/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// This test used to fail after upgrading to petsc 2.2.1
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
std::ofstream logfile("65/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::MatrixBase::clear_row ()
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_sparse_matrix.h>
#include <lac/vector.h>
std::ofstream logfile("66/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::MatrixBase::clear_rows ()
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_sparse_matrix.h>
#include <lac/vector.h>
std::ofstream logfile("67/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::MatrixBase::clear_row () with used second argument
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_sparse_matrix.h>
#include <lac/vector.h>
std::ofstream logfile("68/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::MatrixBase::clear_rows () with used second argument
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_sparse_matrix.h>
#include <lac/vector.h>
std::ofstream logfile("69/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosScalar
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <base/logstream.h>
#include <lac/trilinos_vector.h>
std::ofstream logfile("70/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
if (typeid(TrilinosScalar)==typeid(double))
deallog << "double" << std::endl;
// make sure that block vector iterator allows reading and writing correctly
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_block_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("block_vector_iterator_01/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// like _01, except that we use operator[] instead of operator*
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_block_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("block_vector_iterator_02/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// this test is an adaptation of lac/block_vector_iterator for PETSc block
// vectors
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <base/logstream.h>
#include <lac/trilinos_block_vector.h>
#include <fstream>
logfile.precision(3);
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// test the CG solver using the Trilinos matrix and vector classes
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include "../lac/testmatrix.h"
#include <cmath>
#include <fstream>
logfile.precision(4);
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
{
SolverControl control(100, 1.e-3);
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include "../lac/testmatrix.h"
#include <cmath>
#include <fstream>
logfile.precision(4);
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
{
SolverControl control(100, 1.e-3);
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include "../lac/testmatrix.h"
#include <cmath>
#include <fstream>
logfile.precision(4);
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
{
SolverControl control(100, 1.e-3);
// test the MINRES solver using the Trilinos matrix and vector classes
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include "../lac/testmatrix.h"
#include <cmath>
#include <fstream>
logfile.precision(4);
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
{
SolverControl control(100, 1.e-3);
// test the QMRS solver using the Trilinos matrix and vector classes
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include "../lac/testmatrix.h"
#include <cmath>
#include <fstream>
logfile.precision(4);
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
{
SolverControl control(100, 1.e-3);
// test the Richardson solver using the Trilinos matrix and vector classes
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include "../lac/testmatrix.h"
#include <cmath>
#include <fstream>
logfile.precision(4);
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
{
const unsigned int size = 32;
// and with the option -log_info. All the output should say that no additional
// malloc calls have been performed
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_sparse_matrix.h>
#include <lac/compressed_sparsity_pattern.h>
#include <fstream>
std::ofstream logfile("sparse_matrix_01/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
//
// the tests build the 5-point stencil matrix for a uniform grid of size N*N
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/sparse_matrix.h>
#include <lac/vector.h>
#include <lac/trilinos_sparse_matrix.h>
//
// the tests build the 5-point stencil matrix for a uniform grid of size N*N
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/sparse_matrix.h>
#include <lac/trilinos_sparse_matrix.h>
#include <lac/trilinos_vector.h>
//
// the tests build the 5-point stencil matrix for a uniform grid of size N*N
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/sparse_matrix.h>
#include <lac/trilinos_sparse_matrix.h>
#include <lac/trilinos_vector.h>
// matrix in a consecutive fashion, but rather according to the order of
// degrees of freedom in the sequence of cells that we traverse
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/sparse_matrix.h>
#include <lac/trilinos_sparse_matrix.h>
#include <lac/trilinos_vector.h>
// test the Trilinos Richardson solver
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include "../lac/testmatrix.h"
#include <cmath>
#include <fstream>
logfile.precision(4);
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
{
SolverControl control(100, 1.e-3);
// test the Trilinos Chebychev solver
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include "../lac/testmatrix.h"
#include <cmath>
#include <fstream>
logfile.precision(4);
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
{
SolverControl control(100, 1.e-3);
// test the Trilinos CG solver
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include "../lac/testmatrix.h"
#include <cmath>
#include <fstream>
logfile.precision(4);
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
{
SolverControl control(100, 1.e-3);
// test the Trilinos BiCG solver
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include "../lac/testmatrix.h"
#include <cmath>
#include <fstream>
logfile.precision(4);
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
{
SolverControl control(100, 1.e-3);
// test the Trilinos GMRES solver
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include "../lac/testmatrix.h"
#include <cmath>
#include <fstream>
logfile.precision(4);
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
{
SolverControl control(100, 1.e-3);
// test the Trilinos Bicgstab solver
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include "../lac/testmatrix.h"
#include <cmath>
#include <fstream>
logfile.precision(4);
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
{
SolverControl control(100, 1.e-3);
// test the Trilinos CGS solver
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include "../lac/testmatrix.h"
#include <cmath>
#include <fstream>
logfile.precision(4);
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
{
SolverControl control(100, 1.e-3);
// test the Trilinos TFQMR solver
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include "../lac/testmatrix.h"
#include <cmath>
#include <fstream>
logfile.precision(4);
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
{
SolverControl control(100, 1.e-3);
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include "../lac/testmatrix.h"
#include <cmath>
#include <fstream>
logfile.precision(4);
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
{
SolverControl control(100, 1.e-3);
// test the Trilinos CR solver
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include "../lac/testmatrix.h"
#include <cmath>
#include <fstream>
logfile.precision(4);
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
{
SolverControl control(100, 1.e-3);
// test the Trilinos LSQR solver
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include "../lac/testmatrix.h"
#include <cmath>
#include <fstream>
logfile.precision(4);
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
{
SolverControl control(100, 1.e-3);
// test TrilinosWrappers::MatrixBase::const_iterator
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_sparse_matrix.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("sparse_matrix_iterator_01/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check SparseMatrix::vmult
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <lac/trilinos_sparse_matrix.h>
#include <fstream>
std::ofstream logfile("sparse_matrix_vector_01/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check SparseMatrix::Tvmult
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <lac/trilinos_sparse_matrix.h>
#include <fstream>
std::ofstream logfile("sparse_matrix_vector_02/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check SparseMatrix::vmult_add
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <lac/trilinos_sparse_matrix.h>
#include <fstream>
std::ofstream logfile("sparse_matrix_vector_03/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check SparseMatrix::Tvmult_add
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <lac/trilinos_sparse_matrix.h>
#include <fstream>
std::ofstream logfile("sparse_matrix_vector_04/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check SparseMatrix::matrix_scalar_product
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <lac/trilinos_sparse_matrix.h>
#include <fstream>
std::ofstream logfile("sparse_matrix_vector_05/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check SparseMatrix::matrix_norm_square
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <lac/trilinos_sparse_matrix.h>
#include <fstream>
std::ofstream logfile("sparse_matrix_vector_06/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check SparseMatrix::matrix_norm_square
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <lac/trilinos_sparse_matrix.h>
#include <fstream>
std::ofstream logfile("sparse_matrix_vector_07/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
//
// this was fixed 2004-04-05, and this test checks that it works
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("vector_assign_01/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// argument to the user-defined operator+=. This is not exciting, but since I
// wrote the test to make sure it works this way, let's keep it then...
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("vector_assign_02/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::operator==(TrilinosWrappers::Vector) for vectors that are not
// equal
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("vector_equality_1/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::operator==(TrilinosWrappers::Vector) for vectors that are
// equal
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("vector_equality_2/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::operator!=(TrilinosWrappers::Vector) for vectors that are not
// equal
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("vector_equality_3/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{
// check TrilinosWrappers::Vector::operator!=(TrilinosWrappers::Vector) for vectors that are
// equal
-#include "../tests.h"
+#include "../tests.h"
+#include <base/utilities.h>
#include <lac/trilinos_vector.h>
#include <fstream>
#include <iostream>
std::ofstream logfile("vector_equality_4/output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
+ deallog.threshold_double(1.e-10);
+
+ Utilities::System::MPI_InitFinalize mpi_initialization (argc, argv);
+
try
{