ParallelPointTest Class Reference

Inheritance diagram for ParallelPointTest:

Public Member Functions
	LIBMESH_CPPUNIT_TEST_SUITE (ParallelPointTest)
	CPPUNIT_TEST (testAllGatherPoint)
	CPPUNIT_TEST (testAllGatherPairPointPoint)
	CPPUNIT_TEST (testAllGatherPairRealPoint)
	CPPUNIT_TEST (testMapUnionGradient)
	CPPUNIT_TEST (testMapUnionPoint)
	CPPUNIT_TEST (testBroadcastVectorValueInt)
	CPPUNIT_TEST (testBroadcastVectorValueReal)
	CPPUNIT_TEST (testBroadcastPoint)
	CPPUNIT_TEST (testIsendRecv)
	CPPUNIT_TEST (testIrecvSend)
	CPPUNIT_TEST_SUITE_END ()
void	setUp ()
void	tearDown ()
void	testAllGatherPoint ()
void	testAllGatherPairPointPoint ()
void	testAllGatherPairRealPoint ()
template<typename VecType >
void	testMapUnionVec ()
void	testMapUnionGradient ()
void	testMapUnionPoint ()
template<typename T >
void	testBroadcastVectorValue ()
void	testBroadcastVectorValueInt ()
void	testBroadcastVectorValueReal ()
void	testBroadcastPoint ()
void	testIsendRecv ()
void	testIrecvSend ()

Detailed Description

Definition at line 11 of file parallel_point_test.C.

Member Function Documentation

CPPUNIT_TEST() [1/10]

ParallelPointTest::CPPUNIT_TEST

(

testAllGatherPoint

)

CPPUNIT_TEST() [2/10]

ParallelPointTest::CPPUNIT_TEST

(

testAllGatherPairPointPoint

)

CPPUNIT_TEST() [3/10]

ParallelPointTest::CPPUNIT_TEST

(

testAllGatherPairRealPoint

)

CPPUNIT_TEST() [4/10]

ParallelPointTest::CPPUNIT_TEST

(

testMapUnionGradient

)

CPPUNIT_TEST() [5/10]

ParallelPointTest::CPPUNIT_TEST

(

testMapUnionPoint

)

CPPUNIT_TEST() [6/10]

ParallelPointTest::CPPUNIT_TEST

(

testBroadcastVectorValueInt

)

CPPUNIT_TEST() [7/10]

ParallelPointTest::CPPUNIT_TEST

(

testBroadcastVectorValueReal

)

CPPUNIT_TEST() [8/10]

ParallelPointTest::CPPUNIT_TEST

(

testBroadcastPoint

)

CPPUNIT_TEST() [9/10]

ParallelPointTest::CPPUNIT_TEST

(

testIsendRecv

)

CPPUNIT_TEST() [10/10]

ParallelPointTest::CPPUNIT_TEST

(

testIrecvSend

)

CPPUNIT_TEST_SUITE_END()

ParallelPointTest::CPPUNIT_TEST_SUITE_END

(

)

LIBMESH_CPPUNIT_TEST_SUITE()

ParallelPointTest::LIBMESH_CPPUNIT_TEST_SUITE

(

ParallelPointTest

)

setUp()

void ParallelPointTest::setUp ( )

inline

Definition at line 34 of file parallel_point_test.C.

  {}

tearDown()

void ParallelPointTest::tearDown ( )

inline

Definition at line 37 of file parallel_point_test.C.

  {}

testAllGatherPairPointPoint()

void ParallelPointTest::testAllGatherPairPointPoint ( )

inline

Definition at line 64 of file parallel_point_test.C.

References TIMPI::Communicator::allgather(), TIMPI::Communicator::rank(), libMesh::Real, TIMPI::Communicator::size(), and TestCommWorld.

  {
    LOG_UNIT_TEST;

    std::vector<std::pair<Point, Point>> vals;
    Real myrank = TestCommWorld->rank();
    TestCommWorld->allgather
      (std::make_pair(Point(myrank, myrank+0.125, myrank+0.25), Point(myrank+0.5, myrank+0.625, myrank+0.75)), vals);

    const std::size_t comm_size = TestCommWorld->size();
    const std::size_t vec_size  = vals.size();
    CPPUNIT_ASSERT_EQUAL( comm_size, vec_size );

    for (processor_id_type i=0; i<vals.size(); i++)
      {
        Real theirrank = i;
        CPPUNIT_ASSERT_EQUAL( theirrank,             vals[i].first(0) );
        CPPUNIT_ASSERT_EQUAL( theirrank+Real(0.125), vals[i].first(1) );
        CPPUNIT_ASSERT_EQUAL( theirrank+Real(0.25),  vals[i].first(2) );
        CPPUNIT_ASSERT_EQUAL( theirrank+Real(0.5),   vals[i].second(0) );
        CPPUNIT_ASSERT_EQUAL( theirrank+Real(0.625), vals[i].second(1) );
        CPPUNIT_ASSERT_EQUAL( theirrank+Real(0.75),  vals[i].second(2) );
      }
  }

testAllGatherPairRealPoint()

void ParallelPointTest::testAllGatherPairRealPoint ( )

inline

Definition at line 90 of file parallel_point_test.C.

References TIMPI::Communicator::allgather(), TIMPI::Communicator::rank(), libMesh::Real, TIMPI::Communicator::size(), and TestCommWorld.

  {
    LOG_UNIT_TEST;

    std::vector<std::pair<Real, Point>> vals;
    Real myrank = TestCommWorld->rank();
    TestCommWorld->allgather
      (std::make_pair(Real(myrank+0.75), Point(myrank, myrank+0.25, myrank+0.5)), vals);

    const std::size_t comm_size = TestCommWorld->size();
    const std::size_t vec_size  = vals.size();
    CPPUNIT_ASSERT_EQUAL( comm_size, vec_size );

    for (processor_id_type i=0; i<vals.size(); i++)
      {
        Real theirrank = i;
        CPPUNIT_ASSERT_EQUAL( theirrank,            vals[i].second(0) );
        CPPUNIT_ASSERT_EQUAL( theirrank+Real(0.25), vals[i].second(1) );
        CPPUNIT_ASSERT_EQUAL( theirrank+Real(0.5),  vals[i].second(2) );
        CPPUNIT_ASSERT_EQUAL( theirrank+Real(0.75), vals[i].first );
      }
  }

testAllGatherPoint()

void ParallelPointTest::testAllGatherPoint ( )

inline

Definition at line 42 of file parallel_point_test.C.

References TIMPI::Communicator::allgather(), TIMPI::Communicator::rank(), libMesh::Real, TIMPI::Communicator::size(), and TestCommWorld.

  {
    LOG_UNIT_TEST;

    std::vector<Point> vals;
    Real myrank = TestCommWorld->rank();
    TestCommWorld->allgather(Point(myrank, myrank+0.25, myrank+0.5),vals);

    const std::size_t comm_size = TestCommWorld->size();
    const std::size_t vec_size  = vals.size();
    CPPUNIT_ASSERT_EQUAL( comm_size, vec_size );
    for (processor_id_type i=0; i<vals.size(); i++)
      {
        Real theirrank = i;
        CPPUNIT_ASSERT_EQUAL( theirrank,            vals[i](0) );
        CPPUNIT_ASSERT_EQUAL( theirrank+Real(0.25), vals[i](1) );
        CPPUNIT_ASSERT_EQUAL( theirrank+Real(0.5),  vals[i](2) );
      }
  }

testBroadcastPoint()

void ParallelPointTest::testBroadcastPoint ( )

inline

Definition at line 197 of file parallel_point_test.C.

References TIMPI::Communicator::broadcast(), TIMPI::Communicator::rank(), libMesh::Real, and TestCommWorld.

  {
    LOG_UNIT_TEST;

    std::vector<Point> src(3), dest(3);

    {
      Real val=0.;
      for (unsigned int i=0; i<3; i++)
        for (unsigned int j=0; j<LIBMESH_DIM; j++)
          src[i](j) = val++;

      if (TestCommWorld->rank() == 0)
        dest = src;
    }

    TestCommWorld->broadcast(dest);

    for (unsigned int i=0; i<3; i++)
      for (unsigned int j=0; j<LIBMESH_DIM; j++)
        CPPUNIT_ASSERT_EQUAL (src[i](j), dest[i](j) );
  }

testBroadcastVectorValue()

template<typename T >

void ParallelPointTest::testBroadcastVectorValue ( )

inline

Definition at line 156 of file parallel_point_test.C.

References TIMPI::Communicator::broadcast(), TIMPI::Communicator::rank(), and TestCommWorld.

  {
    std::vector<VectorValue<T>> src(3), dest(3);

    {
      T val=T(0);
      for (unsigned int i=0; i<3; i++)
        for (unsigned int j=0; j<LIBMESH_DIM; j++)
          src[i](j) = val++;

      if (TestCommWorld->rank() == 0)
        dest = src;
    }

    TestCommWorld->broadcast(dest);

    for (unsigned int i=0; i<3; i++)
      for (unsigned int j=0; j<LIBMESH_DIM; j++)
        CPPUNIT_ASSERT_EQUAL (src[i](j), dest[i](j) );
  }

testBroadcastVectorValueInt()

void ParallelPointTest::testBroadcastVectorValueInt ( )

inline

Definition at line 179 of file parallel_point_test.C.

  {
    LOG_UNIT_TEST;

    this->testBroadcastVectorValue<int>();
  }

testBroadcastVectorValueReal()

void ParallelPointTest::testBroadcastVectorValueReal ( )

inline

Definition at line 188 of file parallel_point_test.C.

  {
    LOG_UNIT_TEST;

    this->testBroadcastVectorValue<Real>();
  }

testIrecvSend()

void ParallelPointTest::testIrecvSend ( )

inline

Definition at line 285 of file parallel_point_test.C.

References TIMPI::Communicator::DEFAULT, TIMPI::Communicator::rank(), TIMPI::Communicator::receive(), TIMPI::Communicator::send(), TIMPI::Communicator::send_mode(), TIMPI::Communicator::size(), TIMPI::Communicator::SYNCHRONOUS, and TestCommWorld.

  {
    LOG_UNIT_TEST;

    unsigned int procup = (TestCommWorld->rank() + 1) %
      TestCommWorld->size();
    unsigned int procdown = (TestCommWorld->size() +
                             TestCommWorld->rank() - 1) %
      TestCommWorld->size();

    std::vector<unsigned int> src_val(3), recv_val(3);

    src_val[0] = 0;
    src_val[1] = 1;
    src_val[2] = 2;

    Parallel::Request request;

    if (TestCommWorld->size() > 1)
      {
        // Default communication
        TestCommWorld->send_mode(Parallel::Communicator::DEFAULT);

        TestCommWorld->receive (procdown,
                                recv_val,
                                request);

        TestCommWorld->send (procup,
                             src_val);

        Parallel::wait (request);

        CPPUNIT_ASSERT_EQUAL ( src_val.size() , recv_val.size() );

        for (std::size_t i=0; i<src_val.size(); i++)
          CPPUNIT_ASSERT_EQUAL( src_val[i] , recv_val[i] );

        // Synchronous communication
        TestCommWorld->send_mode(Parallel::Communicator::SYNCHRONOUS);
        std::fill (recv_val.begin(), recv_val.end(), 0);


        TestCommWorld->receive (procdown,
                                recv_val,
                                request);

        TestCommWorld->send (procup,
                             src_val);

        Parallel::wait (request);

        CPPUNIT_ASSERT_EQUAL ( src_val.size() , recv_val.size() );

        for (std::size_t i=0; i<src_val.size(); i++)
          CPPUNIT_ASSERT_EQUAL( src_val[i] , recv_val[i] );

        // Restore default communication
        TestCommWorld->send_mode(Parallel::Communicator::DEFAULT);
      }
  }

testIsendRecv()

void ParallelPointTest::testIsendRecv ( )

inline

Definition at line 222 of file parallel_point_test.C.

References TIMPI::Communicator::DEFAULT, TIMPI::Communicator::rank(), TIMPI::Communicator::receive(), TIMPI::Communicator::send(), TIMPI::Communicator::send_mode(), TIMPI::Communicator::size(), TIMPI::Communicator::SYNCHRONOUS, and TestCommWorld.

  {
    LOG_UNIT_TEST;

    unsigned int procup = (TestCommWorld->rank() + 1) %
      TestCommWorld->size();
    unsigned int procdown = (TestCommWorld->size() +
                             TestCommWorld->rank() - 1) %
      TestCommWorld->size();

    std::vector<unsigned int> src_val(3), recv_val(3);

    src_val[0] = 0;
    src_val[1] = 1;
    src_val[2] = 2;

    Parallel::Request request;

    if (TestCommWorld->size() > 1)
      {
        // Default communication
        TestCommWorld->send_mode(Parallel::Communicator::DEFAULT);

        TestCommWorld->send (procup,
                             src_val,
                             request);

        TestCommWorld->receive (procdown,
                                recv_val);

        Parallel::wait (request);

        CPPUNIT_ASSERT_EQUAL ( src_val.size() , recv_val.size() );

        for (std::size_t i=0; i<src_val.size(); i++)
          CPPUNIT_ASSERT_EQUAL( src_val[i] , recv_val[i] );


        // Synchronous communication
        TestCommWorld->send_mode(Parallel::Communicator::SYNCHRONOUS);
        std::fill (recv_val.begin(), recv_val.end(), 0);

        TestCommWorld->send (procup,
                             src_val,
                             request);

        TestCommWorld->receive (procdown,
                                recv_val);

        Parallel::wait (request);

        CPPUNIT_ASSERT_EQUAL ( src_val.size() , recv_val.size() );

        for (std::size_t i=0; i<src_val.size(); i++)
          CPPUNIT_ASSERT_EQUAL( src_val[i] , recv_val[i] );

        // Restore default communication
        TestCommWorld->send_mode(Parallel::Communicator::DEFAULT);
      }
  }

testMapUnionGradient()

void ParallelPointTest::testMapUnionGradient ( )

inline

Definition at line 139 of file parallel_point_test.C.

  {
    LOG_UNIT_TEST;

    testMapUnionVec<Gradient>();
  }

testMapUnionPoint()

void ParallelPointTest::testMapUnionPoint ( )

inline

Definition at line 147 of file parallel_point_test.C.

  {
    LOG_UNIT_TEST;

    testMapUnionVec<Point>();
  }

testMapUnionVec()

template<typename VecType >

void ParallelPointTest::testMapUnionVec ( )

inline

Definition at line 116 of file parallel_point_test.C.

References libMesh::libmesh_real(), libMesh::make_range(), TIMPI::Communicator::rank(), libMesh::Real, TIMPI::Communicator::set_union(), TIMPI::Communicator::size(), and TestCommWorld.

  {
    // std::map<processor_id_type , std::vector<Point>> vals;
    std::map<processor_id_type , std::vector<VecType>> vals;

    const processor_id_type myrank = TestCommWorld->rank();

    vals[myrank*2].resize(1);
    vals[myrank*2][0](0) = myrank+1;

    TestCommWorld->set_union(vals);

    const processor_id_type comm_size = TestCommWorld->size();

    CPPUNIT_ASSERT_EQUAL(vals.size(), std::size_t(comm_size));
    for (auto p : make_range(comm_size))
      {
        CPPUNIT_ASSERT_EQUAL(vals[p*2].size(), std::size_t(1));
        CPPUNIT_ASSERT_EQUAL(Real(p+1), libmesh_real(vals[p*2][0](0)));
      }
  }

---

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

• tests/parallel/parallel_point_test.C