PetscMatrixTest Class Reference

Inheritance diagram for PetscMatrixTest:

Public Member Functions
	PetscMatrixTest ()
	CPPUNIT_TEST_SUITE (PetscMatrixTest)
SPARSEMATRIXTEST	CPPUNIT_TEST (testPetscBinaryRead)
	CPPUNIT_TEST (testPetscBinaryWrite)
	CPPUNIT_TEST (testPetscCopyFromHash)
	CPPUNIT_TEST_SUITE_END ()
void	testPetscBinaryRead ()
void	testPetscBinaryWrite ()
void	testPetscHDF5Write ()
void	testPetscCopyFromHash ()
void	setUp ()
void	tearDown ()
void	setValues ()
void	testValues ()
void	testGetAndSet ()
void	testReadMatlab (const std::string &filename)
void	testReadMatlab1 ()
void	testReadMatlab2 ()
void	testReadMatlab4 ()
void	testReadHDF5 ()
void	testWriteAndRead ()
void	testClone ()

Protected Attributes
std::string	libmesh_suite_name
libMesh::Parallel::Communicator *	my_comm
std::unique_ptr< PetscMatrix< Number > >	matrix
libMesh::numeric_index_type	nonsquare
libMesh::numeric_index_type	local_m
libMesh::numeric_index_type	local_n
libMesh::numeric_index_type	global_m
libMesh::numeric_index_type	global_n
const libMesh::Real	_tolerance

Detailed Description

Definition at line 11 of file petsc_matrix_test.C.

Constructor & Destructor Documentation

PetscMatrixTest()

PetscMatrixTest::PetscMatrixTest ( )

inline

Definition at line 14 of file petsc_matrix_test.C.

References libMesh::PerfLog::summarized_logs_enabled(), and unitlog.

                    :
    SparseMatrixTest<PetscMatrix<Number>>() {
    if (unitlog->summarized_logs_enabled())
      this->libmesh_suite_name = "SparseMatrixTest";
    else
      this->libmesh_suite_name = "PetscMatrixTest";
  }

Member Function Documentation

CPPUNIT_TEST() [1/3]

SPARSEMATRIXTEST PetscMatrixTest::CPPUNIT_TEST

(

testPetscBinaryRead

)

CPPUNIT_TEST() [2/3]

PetscMatrixTest::CPPUNIT_TEST

(

testPetscBinaryWrite

)

CPPUNIT_TEST() [3/3]

PetscMatrixTest::CPPUNIT_TEST

(

testPetscCopyFromHash

)

CPPUNIT_TEST_SUITE()

PetscMatrixTest::CPPUNIT_TEST_SUITE

(

PetscMatrixTest

)

CPPUNIT_TEST_SUITE_END()

PetscMatrixTest::CPPUNIT_TEST_SUITE_END

(

)

setUp()

void SparseMatrixTest< PetscMatrix< Number > >::setUp ( )

inlineinherited

Definition at line 38 of file sparse_matrix_test.h.

  {
    // By default we'll use the whole communicator in parallel;
    // Serial-only NumericVector subclasses will need to override
    // this and set something else first.
    if (!my_comm)
      my_comm = TestCommWorld;

    matrix = std::make_unique<DerivedClass>(*my_comm);

    // Use the same even partitioning that we'll auto-deduce in matrix
    // read, to make it easier to test parallel reads

    global_m = global_n = my_comm->size() * 5.75 - 1;
    if (nonsquare)
      global_n *= 1.3;

    libMesh::dof_id_type
      row_start =     my_comm->rank() * global_m / my_comm->size(),
      row_stop  = (my_comm->rank()+1) * global_m / my_comm->size();
    libMesh::dof_id_type
      col_start =     my_comm->rank() * global_n / my_comm->size(),
      col_stop  = (my_comm->rank()+1) * global_n / my_comm->size();

    local_m = row_stop - row_start;
    local_n = col_stop - col_start;

    // Let's just play around with locally dense blocks for now
    matrix->init(global_m,
                 global_n,
                 local_m,
                 local_n,
                 /*nnz=*/local_n,
                 /*noz=*/5);
  }

setValues()

void SparseMatrixTest< PetscMatrix< Number > >::setValues ( )

inlineinherited

Definition at line 78 of file sparse_matrix_test.h.

  {
    std::vector<libMesh::numeric_index_type> rows(local_m);
    std::iota(rows.begin(), rows.end(), matrix->row_start());
    std::vector<libMesh::numeric_index_type> cols(local_n);
    std::iota(cols.begin(), cols.end(), matrix->col_start());

    libMesh::DenseMatrix<libMesh::Number> local(local_m, local_n);

    for (auto i : libMesh::make_range(local_m))
      for (auto j : libMesh::make_range(local_n))
        local(i, j) = (i + 1) * (j + 1) * (my_comm->rank() + 1);

    matrix->zero();

    matrix->add_matrix(local, rows, cols);
    matrix->close();
  }

tearDown()

void SparseMatrixTest< PetscMatrix< Number > >::tearDown ( )

inlineinherited

Definition at line 75 of file sparse_matrix_test.h.

{}

testClone()

void SparseMatrixTest< PetscMatrix< Number > >::testClone ( )

inlineinherited

Definition at line 244 of file sparse_matrix_test.h.

  {
    LOG_UNIT_TEST;

    setValues();

    // Matrix must be closed before it can be cloned.
    matrix->close();

    {
      // Create copy, test that it can go out of scope
      auto copy = matrix->clone();

      // Check that matrices have the same local/global sizes
      CPPUNIT_ASSERT_EQUAL(copy->m(), matrix->m());
      CPPUNIT_ASSERT_EQUAL(copy->n(), matrix->n());
      CPPUNIT_ASSERT_EQUAL(copy->local_m(), matrix->local_m());
      CPPUNIT_ASSERT_EQUAL(copy->row_start(), matrix->row_start());
      CPPUNIT_ASSERT_EQUAL(copy->row_stop(), matrix->row_stop());

      // Check that copy has same values as original
      LIBMESH_ASSERT_FP_EQUAL(copy->l1_norm(), matrix->l1_norm(), _tolerance);
      CPPUNIT_ASSERT(relative_fuzzy_equals(*matrix, *copy));
      copy->scale(2);
      CPPUNIT_ASSERT(!relative_fuzzy_equals(*matrix, *copy));
    }

    {
      // Create zero copy
      auto zero_copy = matrix->zero_clone();

      // Check that matrices have the same local/global sizes
      CPPUNIT_ASSERT_EQUAL(zero_copy->m(), matrix->m());
      CPPUNIT_ASSERT_EQUAL(zero_copy->n(), matrix->n());
      CPPUNIT_ASSERT_EQUAL(zero_copy->local_m(), matrix->local_m());
      CPPUNIT_ASSERT_EQUAL(zero_copy->row_start(), matrix->row_start());
      CPPUNIT_ASSERT_EQUAL(zero_copy->row_stop(), matrix->row_stop());

      // Check that zero_copy has same values as original
      LIBMESH_ASSERT_FP_EQUAL(0.0, zero_copy->l1_norm(), _tolerance);
    }
  }

testGetAndSet()

void SparseMatrixTest< PetscMatrix< Number > >::testGetAndSet ( )

inlineinherited

Definition at line 138 of file sparse_matrix_test.h.

  {
    LOG_UNIT_TEST;

    setValues();

    testValues();
  }

testPetscBinaryRead()

void PetscMatrixTest::testPetscBinaryRead ( )

inline

Definition at line 42 of file petsc_matrix_test.C.

References libMesh::TOLERANCE.

  {
    auto mat_to_read = std::make_unique<PetscMatrix<Number>>(*my_comm);

    // Petsc binary formats depend on sizeof(PetscInt) and
    // sizeof(PetscScalar)
#if LIBMESH_DOF_ID_BYTES == 4 && LIBMESH_DEFAULT_DOUBLE_PRECISION
    mat_to_read->read("matrices/geom_1_extraction_op.petsc32");
#elif LIBMESH_DOF_ID_BYTES == 8 && LIBMESH_DEFAULT_DOUBLE_PRECISION
    mat_to_read->read("matrices/geom_1_extraction_op.petsc64");
#else
    return;
#endif

    CPPUNIT_ASSERT_EQUAL(mat_to_read->m(), dof_id_type(27));
    CPPUNIT_ASSERT_EQUAL(mat_to_read->n(), dof_id_type(27));

    // Our read_matlab partitioning doesn't necessarily match PETSc's
    // MatLoad partitioning, so we'll partition a matrix to compare
    // against manually.  These particular files have bandwidth 8,
    // so we'll ask for sufficient n_nz and n_oz to handle that
    // regardless of partitioning.
    auto mat_ascii_format = std::make_unique<PetscMatrix<Number>>(*my_comm);
    mat_ascii_format->init(mat_to_read->m(), mat_to_read->n(),
                           mat_to_read->local_m(), mat_to_read->local_n(),
                           8, 7);

    mat_ascii_format->read_matlab("matrices/geom_1_extraction_op.m");

    mat_ascii_format->add(-1, *mat_to_read);
    CPPUNIT_ASSERT_LESS(TOLERANCE, mat_ascii_format->l1_norm());
  }

testPetscBinaryWrite()

void PetscMatrixTest::testPetscBinaryWrite ( )

inline

Definition at line 76 of file petsc_matrix_test.C.

References libMesh::TOLERANCE.

  {
    auto mat_to_read = std::make_unique<PetscMatrix<Number>>(*my_comm);
    mat_to_read->read_matlab("matrices/geom_1_extraction_op.m");
    mat_to_read->print_petsc_binary("geom_1_extraction_op.petsc");

    // Our read_matlab partitioning doesn't necessarily match PETSc's
    // MatLoad partitioning, so we'll partition a matrix to compare
    // against manually.  These particular files have bandwidth 8,
    // so we'll ask for sufficient n_nz and n_oz to handle that
    // regardless of partitioning.
    auto mat_reread = std::make_unique<PetscMatrix<Number>>(*my_comm);
    mat_reread->init(mat_to_read->m(), mat_to_read->n(),
                     mat_to_read->local_m(), mat_to_read->local_n(),
                     8, 7);

    mat_reread->read_petsc_binary("geom_1_extraction_op.petsc");

    mat_to_read->add(-1, *mat_reread);
    CPPUNIT_ASSERT_LESS(TOLERANCE, mat_to_read->l1_norm());
  }

testPetscCopyFromHash()

void PetscMatrixTest::testPetscCopyFromHash ( )

inline

Definition at line 113 of file petsc_matrix_test.C.

References libMesh::PetscMatrix< T >::add(), libMesh::PetscMatrix< T >::copy_from_hash(), libMesh::PetscMatrix< T >::finish_initialization(), libMesh::PetscMatrix< T >::init_without_preallocation(), libMesh::make_range(), and libMesh::SparseMatrix< T >::use_hash_table().

  {
    PetscMatrix<Number> mat(*my_comm);
    const numeric_index_type M = my_comm->size();
    const numeric_index_type m = 1;
    const numeric_index_type blocksize = 1;
    mat.use_hash_table(true);
    mat.init_without_preallocation(M, M, m, m, blocksize);
    mat.finish_initialization();

    // We'll just write a dense row
    for (const auto j : make_range(my_comm->size()))
      mat.add(my_comm->rank(), j, my_comm->rank() * j);

    auto copy = mat.copy_from_hash();
    for (const auto j : make_range(my_comm->size()))
      CPPUNIT_ASSERT_EQUAL((*copy)(my_comm->rank(), j), static_cast<Number>(my_comm->rank() * j));
  }

testPetscHDF5Write()

void PetscMatrixTest::testPetscHDF5Write ( )

inline

Definition at line 99 of file petsc_matrix_test.C.

References libMesh::TOLERANCE.

  {
    auto mat_to_read = std::make_unique<PetscMatrix<Number>>(*my_comm);
    mat_to_read->read_matlab("matrices/geom_1_extraction_op.m");
    mat_to_read->print_petsc_hdf5("geom_1_extraction_op.hdf5");

    auto mat_reread = std::make_unique<PetscMatrix<Number>>(*my_comm);
    mat_reread->read_petsc_hdf5("geom_1_extraction_op.hdf5");

    mat_to_read->add(-1, *mat_reread);
    CPPUNIT_ASSERT_LESS(TOLERANCE, mat_to_read->l1_norm());
  }

testReadHDF5()

void SparseMatrixTest< PetscMatrix< Number > >::testReadHDF5 ( )

inlineinherited

Definition at line 192 of file sparse_matrix_test.h.

  {
#ifdef LIBMESH_HAVE_HDF5
    LOG_UNIT_TEST;

    matrix->clear();
    auto matrix2 = std::make_unique<DerivedClass>(*my_comm);
    matrix->read("matrices/geom_1_extraction_op.m");
    matrix2->read("matrices/geom_1_extraction_op.h5");

    // We need some more SparseMatrix operators, but not today
    CPPUNIT_ASSERT(matrix->l1_norm() == matrix2->l1_norm());
    CPPUNIT_ASSERT(matrix->linfty_norm() == matrix2->linfty_norm());
#endif // LIBMESH_HAVE_HDF5
  }

testReadMatlab()

void SparseMatrixTest< PetscMatrix< Number > >::testReadMatlab ( const std::string &  filename )

inlineinherited

Definition at line 147 of file sparse_matrix_test.h.

  {
    // Laspack doesn't handle non-square matrices)
    if (matrix->solver_package() == libMesh::LASPACK_SOLVERS)
      return;

    matrix->clear();

    auto matrix2 = std::make_unique<DerivedClass>(*my_comm);

    matrix->read(filename);

#ifndef LIBMESH_HAVE_GZSTREAM
    return;
#endif

    matrix2->read(std::string(filename)+".gz");

    // We need some more SparseMatrix operators, but not today
    CPPUNIT_ASSERT(matrix->l1_norm() == matrix2->l1_norm());
    CPPUNIT_ASSERT(matrix->linfty_norm() == matrix2->linfty_norm());
  }

testReadMatlab1()

void SparseMatrixTest< PetscMatrix< Number > >::testReadMatlab1 ( )

inlineinherited

Definition at line 171 of file sparse_matrix_test.h.

  {
    LOG_UNIT_TEST;
    testReadMatlab("matrices/geom_1_extraction_op.m");
  }

testReadMatlab2()

void SparseMatrixTest< PetscMatrix< Number > >::testReadMatlab2 ( )

inlineinherited

Definition at line 178 of file sparse_matrix_test.h.

  {
    LOG_UNIT_TEST;
    testReadMatlab("matrices/geom_2_extraction_op.m");
  }

testReadMatlab4()

void SparseMatrixTest< PetscMatrix< Number > >::testReadMatlab4 ( )

inlineinherited

Definition at line 185 of file sparse_matrix_test.h.

  {
    LOG_UNIT_TEST;
    testReadMatlab("matrices/geom_4_extraction_op.m");
  }

testValues()

void SparseMatrixTest< PetscMatrix< Number > >::testValues ( )

inlineinherited

Definition at line 98 of file sparse_matrix_test.h.

  {
    auto functor = [this]()
    {
      std::vector<libMesh::numeric_index_type> cols_to_get;
      std::vector<libMesh::Number> values;
      const libMesh::numeric_index_type col_start =
        matrix->col_start();
      for (libMesh::numeric_index_type i :
           libMesh::make_range(matrix->row_start(),
                               matrix->row_stop()))
        {
          matrix->get_row(i, cols_to_get, values);
          for (libMesh::numeric_index_type col_j :
               libMesh::index_range(cols_to_get))
            {
              CPPUNIT_ASSERT_EQUAL(cols_to_get[col_j], col_start + col_j);
              LIBMESH_ASSERT_NUMBERS_EQUAL
                ((i - matrix->row_start() + 1) * (col_j + 1) * (my_comm->rank() + 1),
                 values[col_j], _tolerance);
            }
        }
    };

#ifdef LIBMESH_HAVE_CXX11_THREAD
    auto num_threads = std::min(unsigned(2),
                                std::max(
                                  std::thread::hardware_concurrency(),
                                  unsigned(1)));
    std::vector<std::thread> threads(num_threads);
    for (unsigned int thread = 0; thread < num_threads; ++thread)
      threads[thread] = std::thread(functor);
    std::for_each(threads.begin(), threads.end(),
                  [](std::thread & x){x.join();});
#else
    functor();
#endif
  }

testWriteAndRead()

void SparseMatrixTest< PetscMatrix< Number > >::testWriteAndRead ( )

inlineinherited

Definition at line 209 of file sparse_matrix_test.h.

  {
    LOG_UNIT_TEST;

    setValues();

    // If we're working with serial matrices then just print one of
    // them so they don't step on the others' toes.
    //
    // Use a very short filename, because we had a bug with that and
    // we want to test it.
    if (matrix->n_processors() > 1 ||
        TestCommWorld->rank() == 0)
      matrix->print_matlab("M.m");

    matrix->clear();

    // Let's make sure we don't have any race conditions; we have
    // multiple SparseMatrix subclasses that might be trying to read
    // and write the same file.

    TestCommWorld->barrier();

#ifdef LIBMESH_USE_COMPLEX_NUMBERS
    // We're not supporting complex reads quite yet
    return;
#endif

    matrix->read("M.m");

    TestCommWorld->barrier();

    testValues();
  }

Member Data Documentation

_tolerance

const libMesh::Real SparseMatrixTest< PetscMatrix< Number > >::_tolerance

protectedinherited

Definition at line 299 of file sparse_matrix_test.h.

global_m

libMesh::numeric_index_type SparseMatrixTest< PetscMatrix< Number > >::global_m

protectedinherited

Definition at line 295 of file sparse_matrix_test.h.

global_n

libMesh::numeric_index_type SparseMatrixTest< PetscMatrix< Number > >::global_n

protectedinherited

Definition at line 295 of file sparse_matrix_test.h.

libmesh_suite_name

std::string SparseMatrixTest< PetscMatrix< Number > >::libmesh_suite_name

protectedinherited

Definition at line 289 of file sparse_matrix_test.h.

local_m

libMesh::numeric_index_type SparseMatrixTest< PetscMatrix< Number > >::local_m

protectedinherited

Definition at line 295 of file sparse_matrix_test.h.

local_n

libMesh::numeric_index_type SparseMatrixTest< PetscMatrix< Number > >::local_n

protectedinherited

Definition at line 295 of file sparse_matrix_test.h.

matrix

std::unique_ptr<PetscMatrix< Number > > SparseMatrixTest< PetscMatrix< Number > >::matrix

protectedinherited

Definition at line 293 of file sparse_matrix_test.h.

my_comm

libMesh::Parallel::Communicator* SparseMatrixTest< PetscMatrix< Number > >::my_comm

protectedinherited

Definition at line 291 of file sparse_matrix_test.h.

nonsquare

libMesh::numeric_index_type SparseMatrixTest< PetscMatrix< Number > >::nonsquare

protectedinherited

Definition at line 295 of file sparse_matrix_test.h.

---

The documentation for this class was generated from the following file:

• tests/numerics/petsc_matrix_test.C