LaspackVectorTest Class Reference

Inheritance diagram for LaspackVectorTest:

Public Member Functions
void	setUp ()
void	tearDown ()
	LaspackVectorTest ()
	CPPUNIT_TEST_SUITE (LaspackVectorTest)
NUMERICVECTORTEST	CPPUNIT_TEST_SUITE_END ()
void	Operations ()
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 ()

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

Private Attributes
std::unique_ptr< Parallel::Communicator >	_managed_comm

Detailed Description

Definition at line 10 of file laspack_vector_test.C.

Constructor & Destructor Documentation

LaspackVectorTest()

LaspackVectorTest::LaspackVectorTest ( )

inline

Definition at line 33 of file laspack_vector_test.C.

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

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

Member Function Documentation

CPPUNIT_TEST_SUITE()

LaspackVectorTest::CPPUNIT_TEST_SUITE

(

LaspackVectorTest

)

CPPUNIT_TEST_SUITE_END()

NUMERICVECTORTEST LaspackVectorTest::CPPUNIT_TEST_SUITE_END

(

)

Localize()

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

inlineinherited

Definition at line 201 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_FP_EQUAL(2.*libMesh::libmesh_real(i),
                                  libMesh::libmesh_real(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_FP_EQUAL(libMesh::libmesh_real(i),
                                  libMesh::libmesh_real(l[i]),
                                  libMesh::TOLERANCE*libMesh::TOLERANCE);
    }
  }

LocalizeIndices()

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

inlineinherited

Definition at line 256 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_FP_EQUAL(libMesh::libmesh_real(values[p*block_size+j]),
                                    libMesh::libmesh_real(end_index-j-1),
                                    libMesh::TOLERANCE*libMesh::TOLERANCE);
        }
    }
  }

Norms()

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

inlineinherited

Definition at line 147 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_FP_EQUAL(libMesh::libmesh_real(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< LaspackVector< Number > >::Operations ( )

inlineinherited

Definition at line 61 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;

    v += v;

    for (libMesh::dof_id_type n=first; n != last; n++)
      LIBMESH_ASSERT_FP_EQUAL(libMesh::libmesh_real(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_FP_EQUAL(libMesh::libmesh_real(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_FP_EQUAL(libMesh::libmesh_real(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_FP_EQUAL(libMesh::libmesh_real(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_FP_EQUAL(libMesh::libmesh_real(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_FP_EQUAL(libMesh::libmesh_real(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_FP_EQUAL(libMesh::libmesh_real(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_FP_EQUAL(libMesh::libmesh_real(v(n)),
                              libMesh::Real(4),
                              libMesh::TOLERANCE*libMesh::TOLERANCE);

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

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

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

setUp()

void LaspackVectorTest::setUp ( )

inline

Definition at line 19 of file laspack_vector_test.C.

  {
    // Laspack doesn't support distributed parallel vectors, but we
    // can build a serial vector on each processor
    _managed_comm = std::make_unique<Parallel::Communicator>();

    // Base class communicator points to our managed communicator
    my_comm = _managed_comm.get();

    this->NumericVectorTest<LaspackVector<Number>>::setUp();
  }

tearDown()

void LaspackVectorTest::tearDown ( )

inline

Definition at line 31 of file laspack_vector_test.C.

{}

testLocalize()

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

inlineinherited

Definition at line 297 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

    Localize<DerivedClass,DerivedClass>();
  }

testLocalizeBase()

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

inlineinherited

Definition at line 304 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

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

testLocalizeIndices()

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

inlineinherited

Definition at line 325 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

    LocalizeIndices<DerivedClass,DerivedClass >();
  }

testLocalizeIndicesBase()

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

inlineinherited

Definition at line 332 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

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

testLocalizeToOne()

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

inlineinherited

Definition at line 311 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

    Localize<DerivedClass,DerivedClass >(true);
  }

testLocalizeToOneBase()

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

inlineinherited

Definition at line 318 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

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

testNorms()

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

inlineinherited

Definition at line 339 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

    Norms<DerivedClass,DerivedClass >();
  }

testNormsBase()

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

inlineinherited

Definition at line 346 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

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

testOperations()

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

inlineinherited

Definition at line 353 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

    Operations<DerivedClass,DerivedClass >();
  }

testOperationsBase()

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

inlineinherited

Definition at line 360 of file numeric_vector_test.h.

  {
    LOG_UNIT_TEST;

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

Member Data Documentation

_managed_comm

std::unique_ptr<Parallel::Communicator> LaspackVectorTest::_managed_comm

private

Definition at line 16 of file laspack_vector_test.C.

block_size

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

protectedinherited

Definition at line 35 of file numeric_vector_test.h.

global_size

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

protectedinherited

Definition at line 35 of file numeric_vector_test.h.

libmesh_suite_name

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

protectedinherited

Definition at line 33 of file numeric_vector_test.h.

local_size

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

protectedinherited

Definition at line 35 of file numeric_vector_test.h.

my_comm

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

protectedinherited

Definition at line 31 of file numeric_vector_test.h.

---

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

• tests/numerics/laspack_vector_test.C