PetscVectorTest Class Reference

Inheritance diagram for PetscVectorTest:

Public Member Functions
	CPPUNIT_TEST_SUITE (PetscVectorTest)
NUMERICVECTORTEST	CPPUNIT_TEST (testGetArray)
	CPPUNIT_TEST_SUITE_END ()
void	testGetArray ()
void	setUp ()
void	tearDown ()
void	Localize (bool to_one=false)
void	LocalizeIndices ()
void	testLocalize ()
void	testLocalizeBase ()
void	testLocalizeToOne ()
void	testLocalizeToOneBase ()
void	testLocalizeIndices ()
void	testLocalizeIndicesBase ()

Protected Attributes
libMesh::Parallel::Communicator *	my_comm

Detailed Description

Definition at line 10 of file petsc_vector_test.C.

Member Function Documentation

CPPUNIT_TEST()

NUMERICVECTORTEST PetscVectorTest::CPPUNIT_TEST

(

testGetArray

)

CPPUNIT_TEST_SUITE()

PetscVectorTest::CPPUNIT_TEST_SUITE

(

PetscVectorTest

)

CPPUNIT_TEST_SUITE_END()

PetscVectorTest::CPPUNIT_TEST_SUITE_END

(

)

Localize()

void NumericVectorTest< PetscVector< Number > >::Localize ( bool  to_one = false )

inlineinherited

Definition at line 45 of file numeric_vector_test.h.

  {
    const libMesh::processor_id_type root_pid = 0;
    unsigned int block_size  = 10;
 
    // a different size on each processor.
    unsigned int local_size  = block_size +
      static_cast<unsigned int>(my_comm->rank());
    unsigned int global_size = 0;
 
    for (libMesh::processor_id_type p=0; p<my_comm->size(); p++)
      global_size += (block_size + static_cast<unsigned int>(p));
 
    {
      auto v_ptr = libmesh_make_unique<Derived>(*my_comm, global_size, local_size);
      Base & v = *v_ptr;
      std::vector<libMesh::Number> l(global_size);
 
      const libMesh::dof_id_type
        first = v.first_local_index(),
        last  = v.last_local_index();
 
      for (libMesh::dof_id_type n=first; n != last; n++)
        v.set (n, static_cast<libMesh::Number>(n));
      v.close();
 
      if (!to_one)
        v.localize(l);
      else
        v.localize_to_one(l,root_pid);
 
      if (!to_one || my_comm->rank() == root_pid)
        // Yes I really mean v.size()
        for (libMesh::dof_id_type i=0; i<v.size(); i++)
          LIBMESH_ASSERT_FP_EQUAL(libMesh::libmesh_real(i),
                                  libMesh::libmesh_real(l[i]),
                                  libMesh::TOLERANCE*libMesh::TOLERANCE);
    }
  }

LocalizeIndices()

void NumericVectorTest< PetscVector< Number > >::LocalizeIndices ( )

inlineinherited

Definition at line 87 of file numeric_vector_test.h.

  {
    unsigned int block_size  = 10;
 
    // a different size on each processor.
    unsigned int local_size  = block_size +
      static_cast<unsigned int>(my_comm->rank());
    unsigned int global_size = 0;
 
    for (libMesh::processor_id_type p=0; p<my_comm->size(); p++)
      global_size += (block_size + static_cast<unsigned int>(p));
 
    {
      auto v_ptr = libmesh_make_unique<Derived>(*my_comm, global_size, local_size);
      Base & v = *v_ptr;
 
      // Let's try pulling the same number of entries from each processor
      std::vector<libMesh::Number> values(block_size * my_comm->size());
      std::vector<libMesh::dof_id_type> indices;
      indices.reserve(block_size * my_comm->size());
 
      const libMesh::dof_id_type
        first = v.first_local_index(),
        last  = v.last_local_index();
 
      for (libMesh::dof_id_type n=first; n != last; n++)
        v.set (n, static_cast<libMesh::Number>(n));
      v.close();
 
      libMesh::dof_id_type end_index = 0;
      for (libMesh::processor_id_type p=0; p<my_comm->size(); p++)
        {
          end_index += block_size + p;
          for (unsigned int j = 0; j != block_size; ++j)
            indices.push_back(end_index-j-1);
        }
 
      v.localize(values, indices);
 
      end_index = 0;
      for (libMesh::processor_id_type p=0; p<my_comm->size(); p++)
        {
          end_index += block_size + p;
          for (unsigned int j = 0; j != block_size; ++j)
            LIBMESH_ASSERT_FP_EQUAL(libMesh::libmesh_real(values[p*block_size+j]),
                                    libMesh::libmesh_real(end_index-j-1),
                                    libMesh::TOLERANCE*libMesh::TOLERANCE);
        }
    }
  }

setUp()

void NumericVectorTest< PetscVector< Number > >::setUp ( )

inlineinherited

Definition at line 33 of file numeric_vector_test.h.

  {
    // By default we'll use the whole communicator in parallel;
    // Serial-only NumericVector subclasses will need to override
    // this.
    my_comm = TestCommWorld;
  }

tearDown()

void NumericVectorTest< PetscVector< Number > >::tearDown ( )

inlineinherited

Definition at line 41 of file numeric_vector_test.h.

  {}

testGetArray()

void PetscVectorTest::testGetArray ( )

inline

Definition at line 20 of file petsc_vector_test.C.

  {
    unsigned int min_block_size  = 2;
 
    // a different size on each processor.
    unsigned int my_p = my_comm->rank();
    unsigned int local_size  = (min_block_size + my_p);
    unsigned int global_size = 0;
    unsigned int my_offset = 0;
 
    for (libMesh::processor_id_type p=0; p<my_comm->size(); p++)
      {
        const unsigned int p_size =
          (min_block_size + static_cast<unsigned int>(p));
        global_size += p_size;
        if (p < my_p)
          my_offset += p_size;
      }
 
    PetscVector<Number> v(*my_comm, global_size, local_size);
 
    PetscScalar * values = v.get_array();
 
    for (unsigned int i=0; i<local_size; i++)
      values[i] = i;
 
    v.restore_array();
 
    v.close();
 
    // Check the values through the interface
    for (unsigned int i=0; i<local_size; i++)
      LIBMESH_ASSERT_FP_EQUAL(std::abs(v(my_offset + i)), i, TOLERANCE*TOLERANCE);
 
    // Check that we can see the same thing with get_array_read
    const PetscScalar * read_only_values = v.get_array_read();
 
    for (unsigned int i=0; i<local_size; i++)
      LIBMESH_ASSERT_FP_EQUAL(std::abs(read_only_values[i]), i, TOLERANCE*TOLERANCE);
 
    v.restore_array();
 
    // Test getting a read only array after getting a writable array
    values = v.get_array();
    read_only_values = v.get_array_read();
    CPPUNIT_ASSERT_EQUAL((intptr_t)read_only_values, (intptr_t)values);
 
    v.restore_array();
  }

References std::abs(), libMesh::PetscVector< T >::close(), libMesh::PetscVector< T >::get_array(), libMesh::PetscVector< T >::get_array_read(), libMesh::PetscVector< T >::restore_array(), and libMesh::TOLERANCE.

testLocalize()

void NumericVectorTest< PetscVector< Number > >::testLocalize ( )

inlineinherited

Definition at line 138 of file numeric_vector_test.h.

  {
    Localize<DerivedClass,DerivedClass>();
  }

testLocalizeBase()

void NumericVectorTest< PetscVector< Number > >::testLocalizeBase ( )

inlineinherited

Definition at line 143 of file numeric_vector_test.h.

  {
    Localize<libMesh::NumericVector<libMesh::Number>,DerivedClass>();
  }

testLocalizeIndices()

void NumericVectorTest< PetscVector< Number > >::testLocalizeIndices ( )

inlineinherited

Definition at line 158 of file numeric_vector_test.h.

  {
    LocalizeIndices<DerivedClass,DerivedClass >();
  }

testLocalizeIndicesBase()

void NumericVectorTest< PetscVector< Number > >::testLocalizeIndicesBase ( )

inlineinherited

Definition at line 163 of file numeric_vector_test.h.

  {
    LocalizeIndices<libMesh::NumericVector<libMesh::Number>,DerivedClass>();
  }

testLocalizeToOne()

void NumericVectorTest< PetscVector< Number > >::testLocalizeToOne ( )

inlineinherited

Definition at line 148 of file numeric_vector_test.h.

  {
    Localize<DerivedClass,DerivedClass >(true);
  }

testLocalizeToOneBase()

void NumericVectorTest< PetscVector< Number > >::testLocalizeToOneBase ( )

inlineinherited

Definition at line 153 of file numeric_vector_test.h.

  {
    Localize<libMesh::NumericVector<libMesh::Number>,DerivedClass>(true);
  }

Member Data Documentation

my_comm

libMesh::Parallel::Communicator* NumericVectorTest< PetscVector< Number > >::my_comm

protectedinherited

Definition at line 30 of file numeric_vector_test.h.

---

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

• tests/numerics/petsc_vector_test.C