mixed_order_test.C

Go to the documentation of this file.

#include <libmesh/libmesh.h>
 
#include <libmesh/elem.h>
#include <libmesh/mesh.h>
#include <libmesh/mesh_generation.h>
 
#include <timpi/parallel_implementation.h>
 
#include "test_comm.h"
#include "libmesh_cppunit.h"
 
 
using namespace libMesh;
 
class MixedOrderTest : public CppUnit::TestCase
{
public:
  LIBMESH_CPPUNIT_TEST_SUITE( MixedOrderTest );
 
  CPPUNIT_TEST( testFindNeighbors );
  CPPUNIT_TEST( testStitch );
 
  CPPUNIT_TEST_SUITE_END();
 
public:
  void setUp() {}
 
  void tearDown() {}
 
  static int n_neighbor_links (const MeshBase & mesh)
  {
    int n_neighbors = 0;
    for (const auto & elem : mesh.local_element_ptr_range())
      for (const auto & neigh : elem->neighbor_ptr_range())
        if (neigh)
          ++n_neighbors;
    mesh.comm().sum(n_neighbors);
    return n_neighbors;
  }
 
 
  void testFindNeighbors()
  {
    LOG_UNIT_TEST;
 
    Mesh mesh(*TestCommWorld);
 
    // Construct a multi-element Tri3 mesh
    MeshTools::Generation::build_square(mesh,
                                        /*nx=*/3, /*ny=*/3,
                                        /*xmin=*/0., /*xmax=*/1.,
                                        /*ymin=*/0., /*ymax=*/1.,
                                        /*elem_type=*/TRI3);
 
    // Make some of them into Tri6
    auto range_start = mesh.elements_begin();
    const auto range_end = mesh.elements_end();
    while (range_start != range_end && (*range_start)->id() < 5)
      ++range_start;
 
    const int old_n_neighbors = n_neighbor_links(mesh);
 
    mesh.all_second_order_range({range_start,range_end},
                                /*full_ordered=*/true);
    const int new_n_neighbors = n_neighbor_links(mesh);
    CPPUNIT_ASSERT_EQUAL(old_n_neighbors, new_n_neighbors);
 
    mesh.find_neighbors();
    const int newer_n_neighbors = n_neighbor_links(mesh);
    CPPUNIT_ASSERT_EQUAL(old_n_neighbors, newer_n_neighbors);
  }
 
  void testStitch()
  {
    LOG_UNIT_TEST;
 
    Mesh mesh0(*TestCommWorld),
         mesh1(*TestCommWorld);
 
    // Quad4 mesh and Quad9 mesh
    MeshTools::Generation::build_square(mesh0,
                                        /*nx=*/3, /*ny=*/3,
                                        /*xmin=*/0., /*xmax=*/1.,
                                        /*ymin=*/0., /*ymax=*/1.,
                                        /*elem_type=*/QUAD4);
    CPPUNIT_ASSERT_EQUAL(mesh0.n_nodes(), dof_id_type(16));
 
    MeshTools::Generation::build_square(mesh1,
                                        /*nx=*/3, /*ny=*/3,
                                        /*xmin=*/-1., /*xmax=*/0.,
                                        /*ymin=*/0., /*ymax=*/1.,
                                        /*elem_type=*/QUAD9);
    CPPUNIT_ASSERT_EQUAL(mesh1.n_nodes(), dof_id_type(49));
 
    // Stitch them together
    mesh0.stitch_meshes(mesh1, 3, 1, TOLERANCE, /*clear_bcids*/ true,
                        /*verbose*/ false, /*binary_search*/ false,
                        /*enforce_all_nodes_match*/ false,
                        /*merge_all_or_nothing*/ false);
    CPPUNIT_ASSERT_EQUAL(mesh0.n_nodes(), dof_id_type(61));
 
    const int stitched_n_neighbors = n_neighbor_links(mesh0);
    CPPUNIT_ASSERT_EQUAL(stitched_n_neighbors, 54);
 
    mesh0.all_second_order_range(mesh0.element_ptr_range(),
                                 /*full_ordered=*/true);
    const int new_n_neighbors = n_neighbor_links(mesh0);
    CPPUNIT_ASSERT_EQUAL(new_n_neighbors, 54);
  }
};
 
 
CPPUNIT_TEST_SUITE_REGISTRATION( MixedOrderTest );