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	testTransposeNorms ()
void	testWriteAndRead (const std::string &filename)
void	testWriteAndReadHDF5 ()
void	testWriteAndReadMatlab ()
void	testWriteAndReadZippedMatlab ()
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.

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

References SparseMatrixTest< PetscMatrix< Number > >::libmesh_suite_name, libMesh::PerfLog::summarized_logs_enabled(), and unitlog.

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 53 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 93 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 90 of file sparse_matrix_test.h.

{}

testClone()

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

inlineinherited

Definition at line 296 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 153 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.

  {
    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());
  }

References libMesh::TOLERANCE.

testPetscBinaryWrite()

void PetscMatrixTest::testPetscBinaryWrite ( )

inline

Definition at line 76 of file petsc_matrix_test.C.

  {
    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());
  }

References libMesh::TOLERANCE.

testPetscCopyFromHash()

void PetscMatrixTest::testPetscCopyFromHash ( )

inline

Definition at line 113 of file petsc_matrix_test.C.

  {
    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));
  }

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(), SparseMatrixTest< PetscMatrix< Number > >::my_comm, libMesh::Parallel::Communicator::rank(), libMesh::Parallel::Communicator::size(), and libMesh::SparseMatrix< T >::use_hash_table().

testPetscHDF5Write()

void PetscMatrixTest::testPetscHDF5Write ( )

inline

Definition at line 99 of file petsc_matrix_test.C.

  {
    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());
  }

References libMesh::TOLERANCE.

testReadHDF5()

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

inlineinherited

Definition at line 209 of file sparse_matrix_test.h.

  {
    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());
  }

testReadMatlab()

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

inlineinherited

Definition at line 163 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 187 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 194 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 201 of file sparse_matrix_test.h.

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

testTransposeNorms()

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

inlineinherited

Definition at line 225 of file sparse_matrix_test.h.

  {
    LOG_UNIT_TEST;
 
    setValues();
 
    auto matrix2 = std::make_unique<DerivedClass>(*my_comm);
    matrix->get_transpose(*matrix2);
    LIBMESH_ASSERT_FP_EQUAL(matrix->l1_norm(), matrix2->linfty_norm(), _tolerance);
    LIBMESH_ASSERT_FP_EQUAL(matrix2->l1_norm(), matrix->linfty_norm(), _tolerance);
  }

testValues()

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

inlineinherited

Definition at line 113 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 ( const std::string &  filename )

inlineinherited

Definition at line 238 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.
    if (matrix->n_processors() > 1 ||
        TestCommWorld->rank() == 0)
      matrix->print(filename);
 
    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(filename);
 
    TestCommWorld->barrier();
 
    testValues();
  }

testWriteAndReadHDF5()

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

inlineinherited

Definition at line 271 of file sparse_matrix_test.h.

  {
    // This capability is not yet supported when libmesh is compiled
    // with complex number support
#ifndef LIBMESH_USE_COMPLEX_NUMBERS
    testWriteAndRead("M.h5");
#endif
  }

testWriteAndReadMatlab()

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

inlineinherited

Definition at line 282 of file sparse_matrix_test.h.

  {
    // Use a very short filename, because we had a bug with that and
    // we want to test it.
    testWriteAndRead("M.m");
  }

testWriteAndReadZippedMatlab()

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

inlineinherited

Definition at line 289 of file sparse_matrix_test.h.

  {
#ifdef LIBMESH_HAVE_GZSTREAM
    testWriteAndRead("Mzipped.m.gz");
#endif
  }

Member Data Documentation

_tolerance

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

protectedinherited

Definition at line 351 of file sparse_matrix_test.h.

global_m

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

protectedinherited

Definition at line 349 of file sparse_matrix_test.h.

global_n

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

protectedinherited

Definition at line 349 of file sparse_matrix_test.h.

libmesh_suite_name

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

protectedinherited

Definition at line 341 of file sparse_matrix_test.h.

local_m

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

protectedinherited

Definition at line 348 of file sparse_matrix_test.h.

local_n

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

protectedinherited

Definition at line 348 of file sparse_matrix_test.h.

matrix

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

protectedinherited

Definition at line 345 of file sparse_matrix_test.h.

my_comm

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

protectedinherited

Definition at line 343 of file sparse_matrix_test.h.

nonsquare

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

protectedinherited

Definition at line 347 of file sparse_matrix_test.h.

---

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

• tests/numerics/petsc_matrix_test.C