PetscVectorTest Class Reference

Inheritance diagram for PetscVectorTest:

Public Member Functions
	PetscVectorTest ()
	CPPUNIT_TEST_SUITE (PetscVectorTest)
NUMERICVECTORTEST	CPPUNIT_TEST (testGetArray)
	CPPUNIT_TEST (testPetscOperations)
	CPPUNIT_TEST (testSubvectors)
	CPPUNIT_TEST (testSubvectorsBase)
	CPPUNIT_TEST_SUITE_END ()
void	testGetArray ()
void	testPetscOperations ()
void	setUp ()
void	tearDown ()
void	Operations ()
void	Subvectors ()
void	WriteAndRead ()
void	Norms ()
void	Localize (bool to_one=false)
void	LocalizeIndices ()
void	testLocalize ()
void	testLocalizeBase ()
void	testLocalizeToOne ()
void	testLocalizeToOneBase ()
void	testLocalizeIndices ()
void	testLocalizeIndicesBase ()
void	testNorms ()
void	testNormsBase ()
void	testOperations ()
void	testOperationsBase ()
void	testSubvectors ()
void	testSubvectorsBase ()
void	testWriteAndRead ()
void	testWriteAndReadBase ()

Protected Attributes
libMesh::Parallel::Communicator *	my_comm
std::string	libmesh_suite_name
unsigned int	block_size
unsigned int	local_size
unsigned int	global_size

Detailed Description

Definition at line 10 of file petsc_vector_test.C.

Constructor & Destructor Documentation

PetscVectorTest()

PetscVectorTest::PetscVectorTest ( )

inline

Definition at line 12 of file petsc_vector_test.C.

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

                    :
    NumericVectorTest<PetscVector<Number>>() {
    if (unitlog->summarized_logs_enabled())
      this->libmesh_suite_name = "NumericVectorTest";
    else
      this->libmesh_suite_name = "PetscVectorTest";
  }

Member Function Documentation

CPPUNIT_TEST() [1/4]

NUMERICVECTORTEST PetscVectorTest::CPPUNIT_TEST

(

testGetArray

)

CPPUNIT_TEST() [2/4]

PetscVectorTest::CPPUNIT_TEST

(

testPetscOperations

)

CPPUNIT_TEST() [3/4]

PetscVectorTest::CPPUNIT_TEST

(

testSubvectors

)

CPPUNIT_TEST() [4/4]

PetscVectorTest::CPPUNIT_TEST

(

testSubvectorsBase

)

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 342 of file numeric_vector_test.h.

  {
    const libMesh::processor_id_type root_pid = 0;

    {
      auto v_ptr = std::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();
      for (libMesh::dof_id_type n=first; n != last; n++)
        v.add (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_NUMBERS_EQUAL
            (2.*i, l[i], libMesh::TOLERANCE*libMesh::TOLERANCE);

      for (libMesh::dof_id_type n=first; n != last; n++)
      {
        const auto value = static_cast<libMesh::Number>(n);
        v.insert (&value, std::vector<libMesh::numeric_index_type>({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_NUMBERS_EQUAL
            (libMesh::Real(i), l[i], libMesh::TOLERANCE*libMesh::TOLERANCE);
    }
  }

LocalizeIndices()

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

inlineinherited

Definition at line 395 of file numeric_vector_test.h.

  {
    {
      auto v_ptr = std::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_NUMBERS_EQUAL
              (values[p*block_size+j], libMesh::Real(end_index-j-1),
               libMesh::TOLERANCE*libMesh::TOLERANCE);
        }
    }
  }

Norms()

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

inlineinherited

Definition at line 288 of file numeric_vector_test.h.

  {
    auto v_ptr = std::make_unique<Derived>(*my_comm, global_size, local_size);
    Base & v = *v_ptr;

    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();
    for (libMesh::dof_id_type n=first; n != last; n++)
      v.add (n, -static_cast<libMesh::Number>(n));
    v.close();

    const libMesh::Real exact_l1 =
      global_size * (global_size-libMesh::Real(1));
    const libMesh::Real exact_l2 =
      std::sqrt(libMesh::Real(global_size-1) *
                (2*global_size) *
                (2*global_size-1) / 3);
    LIBMESH_ASSERT_NUMBERS_EQUAL(v.sum(), -exact_l1,
                            libMesh::TOLERANCE*libMesh::TOLERANCE);
    LIBMESH_ASSERT_FP_EQUAL(v.l1_norm(), exact_l1,
                            libMesh::TOLERANCE*libMesh::TOLERANCE);
    LIBMESH_ASSERT_FP_EQUAL(v.l2_norm(), exact_l2,
                            libMesh::TOLERANCE*libMesh::TOLERANCE);
    LIBMESH_ASSERT_FP_EQUAL(v.linfty_norm(), 2*(global_size-libMesh::Real(1)),
                            libMesh::TOLERANCE*libMesh::TOLERANCE);

    auto u_ptr = std::make_unique<Derived>(*my_comm, global_size, local_size);
    Base & u = *u_ptr;
    for (libMesh::dof_id_type n=first; n != last; n++)
      u.set (n, -static_cast<libMesh::Number>(n * n));
    u.close();

    Derived diff_derived(*my_comm, global_size, local_size);
    Base & diff = diff_derived;
    diff = u;
    diff -= v;
    diff.close();

    // Use a relative tolerance here; the norms are O(1e5) when our
    // processor count gets big enough, at which point O(1e-12) is
    // testing for exact equality...
    const auto diff_norm = diff.l2_norm();
    const auto norm_diff = u.l2_norm_diff(v);
    LIBMESH_ASSERT_FP_EQUAL(diff_norm, norm_diff,
                            (std::abs(diff_norm)+std::abs(norm_diff)) *
                            libMesh::TOLERANCE*libMesh::TOLERANCE);
  }

Operations()

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

inlineinherited

Definition at line 69 of file numeric_vector_test.h.

  {
    auto v_ptr = std::make_unique<Derived>(*my_comm, global_size, local_size);
    Base & v = *v_ptr;

    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+1));
    v.close();

    auto v_clone = v.clone();
    auto & vorig = *v_clone;

    CPPUNIT_ASSERT(relative_fuzzy_equals(v, vorig));

    v += v;

    CPPUNIT_ASSERT(!relative_fuzzy_equals(v, vorig));

    for (libMesh::dof_id_type n=first; n != last; n++)
      LIBMESH_ASSERT_NUMBERS_EQUAL
        (v(n), libMesh::Real(2*n+2),
         libMesh::TOLERANCE*libMesh::TOLERANCE);

    v *= v;

    for (libMesh::dof_id_type n=first; n != last; n++)
      LIBMESH_ASSERT_NUMBERS_EQUAL
        (v(n), libMesh::Real(4*n*n+8*n+4),
         libMesh::TOLERANCE*libMesh::TOLERANCE);

    v -= vorig;

    for (libMesh::dof_id_type n=first; n != last; n++)
      LIBMESH_ASSERT_NUMBERS_EQUAL
        (v(n), libMesh::Real(4*n*n+7*n+3),
         libMesh::TOLERANCE*libMesh::TOLERANCE);

    v /= vorig;

    for (libMesh::dof_id_type n=first; n != last; n++)
      LIBMESH_ASSERT_NUMBERS_EQUAL
        (v(n), libMesh::Real(4*n+3),
         libMesh::TOLERANCE*libMesh::TOLERANCE);

    v.add(1);
    for (libMesh::dof_id_type n=first; n != last; n++)
      LIBMESH_ASSERT_NUMBERS_EQUAL
        (v(n), libMesh::Real(4*n+4),
         libMesh::TOLERANCE*libMesh::TOLERANCE);

    v.add(2, vorig);
    for (libMesh::dof_id_type n=first; n != last; n++)
      LIBMESH_ASSERT_NUMBERS_EQUAL
        (v(n), libMesh::Real(6*n+6),
         libMesh::TOLERANCE*libMesh::TOLERANCE);

    v.scale(1/libMesh::Real(3));
    for (libMesh::dof_id_type n=first; n != last; n++)
      LIBMESH_ASSERT_NUMBERS_EQUAL
        (v(n), libMesh::Real(2*n+2),
         libMesh::TOLERANCE*libMesh::TOLERANCE);

    v = 4;
    for (libMesh::dof_id_type n=first; n != last; n++)
      LIBMESH_ASSERT_NUMBERS_EQUAL
        (v(n), libMesh::Real(4),
         libMesh::TOLERANCE*libMesh::TOLERANCE);

    v = vorig;
    for (libMesh::dof_id_type n=first; n != last; n++)
      LIBMESH_ASSERT_NUMBERS_EQUAL
        (v(n), libMesh::Real(n+1),
         libMesh::TOLERANCE*libMesh::TOLERANCE);

    v.reciprocal();
    for (libMesh::dof_id_type n=first; n != last; n++)
      LIBMESH_ASSERT_NUMBERS_EQUAL
        (v(n), 1/libMesh::Real(n+1),
         libMesh::TOLERANCE*libMesh::TOLERANCE);

    LIBMESH_ASSERT_NUMBERS_EQUAL
      (v.dot(vorig), libMesh::Real(global_size),
       libMesh::TOLERANCE*libMesh::TOLERANCE);
  }

setUp()

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

inlineinherited

Definition at line 46 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 and set something else first.
    if (!my_comm)
      my_comm = TestCommWorld;

    block_size  = 10;

    // a different size on each processor.
    local_size  = block_size +
      static_cast<unsigned int>(my_comm->rank());

    global_size = 0;
    for (libMesh::processor_id_type p=0; p<my_comm->size(); p++)
      global_size += (block_size + static_cast<unsigned int>(p));
  }

Subvectors()

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

inlineinherited

Definition at line 160 of file numeric_vector_test.h.

  {
    auto v_ptr = std::make_unique<Derived>(*my_comm, global_size, local_size);
    Base & v = *v_ptr;

    const libMesh::dof_id_type
      first = v.first_local_index(),
      last  = v.last_local_index();

    const unsigned int sub_local_size = block_size/2;
    const unsigned int sub_global_size = sub_local_size * my_comm->size();

    for (auto supplying_global_rows : {false, true})
      for (auto get_not_create : {false, true})
        {
          // We don't have such an option?
          if (get_not_create && supplying_global_rows)
            continue;

          for (libMesh::dof_id_type n=first; n != last; n++)
            v.set (n, static_cast<libMesh::Number>(n+1));
          v.close();

          std::unique_ptr<Base> s_ptr =
            std::make_unique<Derived>(*my_comm, sub_global_size,
                                      sub_local_size);

          const libMesh::dof_id_type
            sub_first = s_ptr->first_local_index(),
            sub_last  = s_ptr->last_local_index();

          CPPUNIT_ASSERT_EQUAL
            (sub_first, libMesh::dof_id_type(sub_local_size *
                                             my_comm->rank()));

          CPPUNIT_ASSERT_EQUAL
            (sub_last, libMesh::dof_id_type(sub_local_size *
                                            (my_comm->rank()+1)));

          std::vector<libMesh::dof_id_type> rows;
          for (auto i : libMesh::make_range(sub_local_size))
            rows.push_back(first+2*i);

          if (supplying_global_rows)
            my_comm->allgather(rows);

          if (get_not_create)
            {
              libMesh::NumericVector<libMesh::Number> * subvec_ptr =
                v.get_subvector(rows).release();
              s_ptr.reset(dynamic_cast<Base *>(subvec_ptr));
            }
          else
            v.create_subvector(*s_ptr, rows, supplying_global_rows);

          Base & s = *s_ptr;

          for (auto i : libMesh::make_range(sub_local_size))
            LIBMESH_ASSERT_NUMBERS_EQUAL
              (s(sub_first+i), libMesh::Real(first+2*i+1),
               libMesh::TOLERANCE*libMesh::TOLERANCE);

          for (libMesh::dof_id_type n=sub_first; n != sub_last; n++)
            s.set(n, (my_comm->rank()+1) * n);
          s.close();

          // If we "get" a subvector then we're set up to "restore" it
          // afterwards; if not then we're done.
          if (!get_not_create)
            continue;

          v.restore_subvector(std::move(s_ptr), rows);

          for (libMesh::dof_id_type n=first; n != last; n++)
            {
              const libMesh::dof_id_type offset = n - first;
              if (offset < 2*sub_local_size && !(offset%2))
                LIBMESH_ASSERT_NUMBERS_EQUAL
                  (v(n),
                   libMesh::Real((my_comm->rank()+1) *
                                 ((offset/2) + sub_first)),
                   libMesh::TOLERANCE*libMesh::TOLERANCE);
              else
                LIBMESH_ASSERT_NUMBERS_EQUAL
                  (v(n), libMesh::Real(n+1),
                   libMesh::TOLERANCE*libMesh::TOLERANCE);
            }
        }
  }

tearDown()

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

inlineinherited

Definition at line 65 of file numeric_vector_test.h.

  {}

testGetArray()

void PetscVectorTest::testGetArray ( )

inline

Definition at line 31 of file petsc_vector_test.C.

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

  {
    LOG_UNIT_TEST;

    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(i, std::abs(v(my_offset + 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(i, std::abs(read_only_values[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(read_only_values, const_cast<const PetscScalar *>(values));

    v.restore_array();

    // Test to make sure we can get arrays after other operators
    for (unsigned int i = 0; i < local_size; i++)
      v.set(my_offset + i, i * 2.0);
    v.close();
    for (unsigned int i = 0; i < local_size; i++)
      LIBMESH_ASSERT_FP_EQUAL(i * 2.0, std::abs(v(my_offset + i)), TOLERANCE * TOLERANCE);
    values = v.get_array();
    read_only_values = v.get_array_read();
    for (unsigned int i = 0; i < local_size; i++)
    {
      LIBMESH_ASSERT_FP_EQUAL(i * 2.0, std::abs(values[i]), TOLERANCE * TOLERANCE);
      LIBMESH_ASSERT_FP_EQUAL(i * 2.0, std::abs(read_only_values[i]), TOLERANCE * TOLERANCE);
    }
    v.restore_array();
  }

testLocalize()

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

inlineinherited

Definition at line 436 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

    Localize<DerivedClass,DerivedClass>();
  }

testLocalizeBase()

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

inlineinherited

Definition at line 443 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

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

testLocalizeIndices()

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

inlineinherited

Definition at line 464 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

    LocalizeIndices<DerivedClass,DerivedClass >();
  }

testLocalizeIndicesBase()

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

inlineinherited

Definition at line 471 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

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

testLocalizeToOne()

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

inlineinherited

Definition at line 450 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

    Localize<DerivedClass,DerivedClass >(true);
  }

testLocalizeToOneBase()

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

inlineinherited

Definition at line 457 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

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

testNorms()

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

inlineinherited

Definition at line 478 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

    Norms<DerivedClass,DerivedClass >();
  }

testNormsBase()

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

inlineinherited

Definition at line 485 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

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

testOperations()

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

inlineinherited

Definition at line 492 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

    Operations<DerivedClass,DerivedClass >();
  }

testOperationsBase()

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

inlineinherited

Definition at line 499 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

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

testPetscOperations()

void PetscVectorTest::testPetscOperations ( )

inline

Definition at line 98 of file petsc_vector_test.C.

References libMesh::PetscVector< T >::clone(), libMesh::PetscVector< T >::close(), libMesh::PetscVector< T >::first_local_index(), libMesh::PetscVector< T >::last_local_index(), libMesh::Real, libMesh::PetscVector< T >::set(), and libMesh::TOLERANCE.

  {
    PetscVector<Number> v1(*my_comm, global_size, local_size);
    auto v2 = v1.clone();

    const libMesh::dof_id_type
      first = v1.first_local_index(),
      last  = v1.last_local_index();

    for (libMesh::dof_id_type n=first; n != last; n++)
    {
      v1.set (n, static_cast<libMesh::Number>(n+1));
      v2->set (n, static_cast<libMesh::Number>(2*(n+1)));
    }
    v1.close();
    v2->close();

    auto v_working_ptr = v1.clone();
    auto & v_working = *v_working_ptr;

    v_working.pointwise_mult(v1, *v2);

    for (libMesh::dof_id_type n=first; n != last; n++)
      LIBMESH_ASSERT_NUMBERS_EQUAL
        (v_working(n), libMesh::Real((n+1)*2*(n+1)),
         libMesh::TOLERANCE*libMesh::TOLERANCE);

    v_working.pointwise_divide(v1, *v2);

    for (libMesh::dof_id_type n=first; n != last; n++)
      LIBMESH_ASSERT_NUMBERS_EQUAL
        (v_working(n), libMesh::Real(0.5),
         libMesh::TOLERANCE*libMesh::TOLERANCE);
  }

testSubvectors()

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

inlineinherited

Definition at line 506 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

    Subvectors<DerivedClass,DerivedClass >();
  }

testSubvectorsBase()

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

inlineinherited

Definition at line 513 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

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

testWriteAndRead()

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

inlineinherited

Definition at line 520 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

    WriteAndRead<DerivedClass,DerivedClass >();
  }

testWriteAndReadBase()

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

inlineinherited

Definition at line 527 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

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

WriteAndRead()

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

inlineinherited

Definition at line 251 of file numeric_vector_test.h.

  {
    auto v_ptr = std::make_unique<Derived>(*my_comm, global_size, local_size);
    Base & v = *v_ptr;

    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+1));
    v.close();

    v.print_matlab(libmesh_suite_name+"_vector.m");

    // 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

    auto v_new_ptr = std::make_unique<Derived>(*my_comm, global_size, local_size);
    Base & v_new = *v_new_ptr;

    v_new.read_matlab(libmesh_suite_name+"_vector.m");

    TestCommWorld->barrier();

    CPPUNIT_ASSERT_EQUAL(v.l1_norm_diff(v_new), libMesh::Real(0));
  }

Member Data Documentation

block_size

unsigned int NumericVectorTest< PetscVector< Number > >::block_size

protectedinherited

Definition at line 43 of file numeric_vector_test.h.

global_size

unsigned int NumericVectorTest< PetscVector< Number > >::global_size

protectedinherited

Definition at line 43 of file numeric_vector_test.h.

libmesh_suite_name

std::string NumericVectorTest< PetscVector< Number > >::libmesh_suite_name

protectedinherited

Definition at line 41 of file numeric_vector_test.h.

local_size

unsigned int NumericVectorTest< PetscVector< Number > >::local_size

protectedinherited

Definition at line 43 of file numeric_vector_test.h.

my_comm

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

protectedinherited

Definition at line 39 of file numeric_vector_test.h.

---

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

• tests/numerics/petsc_vector_test.C