NumericVectorTest< DerivedClass > Class Template Reference

#include <numeric_vector_test.h>

Inheritance diagram for NumericVectorTest< DerivedClass >:

Public Member Functions
void	setUp ()
void	tearDown ()
template<class Base , class Derived >
void	Operations ()
template<class Base , class Derived >
void	WriteAndRead ()
template<class Base , class Derived >
void	Norms ()
template<class Base , class Derived >
void	Localize (bool to_one=false)
template<class Base , class Derived >
void	LocalizeIndices ()
void	testLocalize ()
void	testLocalizeBase ()
void	testLocalizeToOne ()
void	testLocalizeToOneBase ()
void	testLocalizeIndices ()
void	testLocalizeIndicesBase ()
void	testNorms ()
void	testNormsBase ()
void	testOperations ()
void	testOperationsBase ()
void	testWriteAndRead ()
void	testWriteAndReadBase ()

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

Detailed Description

template<class DerivedClass>
class NumericVectorTest< DerivedClass >

Definition at line 31 of file numeric_vector_test.h.

Member Function Documentation

Localize()

template<class DerivedClass>

template<class Base , class Derived >

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

inline

Definition at line 245 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()

template<class DerivedClass>

template<class Base , class Derived >

void NumericVectorTest< DerivedClass >::LocalizeIndices ( )

inline

Definition at line 298 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()

template<class DerivedClass>

template<class Base , class Derived >

void NumericVectorTest< DerivedClass >::Norms ( )

inline

Definition at line 191 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()

template<class DerivedClass>

template<class Base , class Derived >

void NumericVectorTest< DerivedClass >::Operations ( )

inline

Definition at line 64 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()

template<class DerivedClass>

void NumericVectorTest< DerivedClass >::setUp ( )

inline

Definition at line 41 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));
  }

tearDown()

template<class DerivedClass>

void NumericVectorTest< DerivedClass >::tearDown ( )

inline

Definition at line 60 of file numeric_vector_test.h.

  {}

testLocalize()

template<class DerivedClass>

void NumericVectorTest< DerivedClass >::testLocalize ( )

inline

Definition at line 339 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

    Localize<DerivedClass,DerivedClass>();
  }

testLocalizeBase()

template<class DerivedClass>

void NumericVectorTest< DerivedClass >::testLocalizeBase ( )

inline

Definition at line 346 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

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

testLocalizeIndices()

template<class DerivedClass>

void NumericVectorTest< DerivedClass >::testLocalizeIndices ( )

inline

Definition at line 367 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

    LocalizeIndices<DerivedClass,DerivedClass >();
  }

testLocalizeIndicesBase()

template<class DerivedClass>

void NumericVectorTest< DerivedClass >::testLocalizeIndicesBase ( )

inline

Definition at line 374 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

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

testLocalizeToOne()

template<class DerivedClass>

void NumericVectorTest< DerivedClass >::testLocalizeToOne ( )

inline

Definition at line 353 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

    Localize<DerivedClass,DerivedClass >(true);
  }

testLocalizeToOneBase()

template<class DerivedClass>

void NumericVectorTest< DerivedClass >::testLocalizeToOneBase ( )

inline

Definition at line 360 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

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

testNorms()

template<class DerivedClass>

void NumericVectorTest< DerivedClass >::testNorms ( )

inline

Definition at line 381 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

    Norms<DerivedClass,DerivedClass >();
  }

testNormsBase()

template<class DerivedClass>

void NumericVectorTest< DerivedClass >::testNormsBase ( )

inline

Definition at line 388 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

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

testOperations()

template<class DerivedClass>

void NumericVectorTest< DerivedClass >::testOperations ( )

inline

Definition at line 395 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

    Operations<DerivedClass,DerivedClass >();
  }

testOperationsBase()

template<class DerivedClass>

void NumericVectorTest< DerivedClass >::testOperationsBase ( )

inline

Definition at line 402 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

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

testWriteAndRead()

template<class DerivedClass>

void NumericVectorTest< DerivedClass >::testWriteAndRead ( )

inline

Definition at line 409 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

    WriteAndRead<DerivedClass,DerivedClass >();
  }

testWriteAndReadBase()

template<class DerivedClass>

void NumericVectorTest< DerivedClass >::testWriteAndReadBase ( )

inline

Definition at line 416 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

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

WriteAndRead()

template<class DerivedClass>

template<class Base , class Derived >

void NumericVectorTest< DerivedClass >::WriteAndRead ( )

inline

Definition at line 154 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

template<class DerivedClass>

unsigned int NumericVectorTest< DerivedClass >::block_size

protected

Definition at line 38 of file numeric_vector_test.h.

Referenced by NumericVectorTest< DistributedVector< Number > >::LocalizeIndices(), and NumericVectorTest< DistributedVector< Number > >::setUp().

global_size

template<class DerivedClass>

unsigned int NumericVectorTest< DerivedClass >::global_size

protected

Definition at line 38 of file numeric_vector_test.h.

Referenced by NumericVectorTest< DistributedVector< Number > >::Localize(), NumericVectorTest< DistributedVector< Number > >::LocalizeIndices(), NumericVectorTest< DistributedVector< Number > >::Norms(), NumericVectorTest< DistributedVector< Number > >::Operations(), NumericVectorTest< DistributedVector< Number > >::setUp(), and NumericVectorTest< DistributedVector< Number > >::WriteAndRead().

libmesh_suite_name

template<class DerivedClass>

std::string NumericVectorTest< DerivedClass >::libmesh_suite_name

protected

Definition at line 36 of file numeric_vector_test.h.

Referenced by NumericVectorTest< DistributedVector< Number > >::WriteAndRead().

local_size

template<class DerivedClass>

unsigned int NumericVectorTest< DerivedClass >::local_size

protected

Definition at line 38 of file numeric_vector_test.h.

Referenced by NumericVectorTest< DistributedVector< Number > >::Localize(), NumericVectorTest< DistributedVector< Number > >::LocalizeIndices(), NumericVectorTest< DistributedVector< Number > >::Norms(), NumericVectorTest< DistributedVector< Number > >::Operations(), NumericVectorTest< DistributedVector< Number > >::setUp(), and NumericVectorTest< DistributedVector< Number > >::WriteAndRead().

my_comm

template<class DerivedClass>

libMesh::Parallel::Communicator* NumericVectorTest< DerivedClass >::my_comm = nullptr

protected

Definition at line 34 of file numeric_vector_test.h.

Referenced by NumericVectorTest< DistributedVector< Number > >::Localize(), NumericVectorTest< DistributedVector< Number > >::LocalizeIndices(), NumericVectorTest< DistributedVector< Number > >::Norms(), NumericVectorTest< DistributedVector< Number > >::Operations(), NumericVectorTest< DistributedVector< Number > >::setUp(), and NumericVectorTest< DistributedVector< Number > >::WriteAndRead().

---

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

• tests/numerics/numeric_vector_test.h