libMesh
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
SlitMeshRefinedMeshTest Class Reference
Inheritance diagram for SlitMeshRefinedMeshTest:
[legend]

Public Member Functions

 LIBMESH_CPPUNIT_TEST_SUITE (SlitMeshRefinedMeshTest)
 The goal of this test is the same as the previous, but now we do a uniform refinement and make sure the result mesh is consistent. More...
 
 CPPUNIT_TEST (testMesh)
 
 CPPUNIT_TEST_SUITE_END ()
 
void setUp ()
 
void testMesh ()
 
 LIBMESH_CPPUNIT_TEST_SUITE (SlitMeshTest)
 The goal of this test is to ensure that a 2D mesh with nodes overlapping on opposite sides of an internal, "slit" edge is usable. More...
 
void tearDown ()
 

Protected Member Functions

void build_mesh ()
 

Protected Attributes

std::unique_ptr< Mesh > _mesh
 

Detailed Description

Definition at line 223 of file slit_mesh_test.C.

Member Function Documentation

◆ build_mesh()

void SlitMeshTest::build_mesh ( )
inlineprotectedinherited

Definition at line 90 of file slit_mesh_test.C.

References libMesh::Elem::build_with_id(), libMesh::QUAD4, and libMesh::Elem::set_node().

91  {
92  _mesh = std::make_unique<Mesh>(*TestCommWorld);
93 
94  // (-1,1) (0,1) (1,1) (2,1) (3,1)
95  // o----------o----------o----------o----------o
96  // | | | | |
97  // | | | | |
98  // | | | | |
99  // | | | | |
100  // o----------o==========8==========o----------o
101  // (-1,0) (0,0) (1,0) (2,0) (3,0)
102  // | | | | |
103  // | | | | |
104  // | | | | |
105  // o----------o----------o----------o----------o
106  // (-1,-1) (0,-1) (1,-1) (2,-1) (3,-1)
107 
108  _mesh->set_mesh_dimension(2);
109 
110  _mesh->add_point( Point(0.0, 0.0), 0 );
111  _mesh->add_point( Point(1.0, 0.0), 1 );
112  _mesh->add_point( Point(1.0, 1.0), 2 );
113  _mesh->add_point( Point(0.0, 1.0), 3 );
114  _mesh->add_point( Point(0.0,-1.0), 4 );
115  _mesh->add_point( Point(1.0,-1.0), 5 );
116  _mesh->add_point( Point(1.0, 0.0), 6 ); // Doubled!
117  _mesh->add_point( Point(2.0, 0.0), 7 );
118  _mesh->add_point( Point(2.0, 1.0), 8 );
119  _mesh->add_point( Point(2.0,-1.0), 9 );
120  _mesh->add_point( Point(-1.0,-1.0), 10);
121  _mesh->add_point( Point(-1.0, 0.0), 11);
122  _mesh->add_point( Point(-1.0, 1.0), 12);
123  _mesh->add_point( Point(3.0,-1.0), 13);
124  _mesh->add_point( Point(3.0, 0.0), 14);
125  _mesh->add_point( Point(3.0, 1.0), 15);
126 
127  {
128  Elem * elem_top_left = _mesh->add_elem(Elem::build_with_id(QUAD4, 0));
129  elem_top_left->set_node(0, _mesh->node_ptr(0));
130  elem_top_left->set_node(1, _mesh->node_ptr(1));
131  elem_top_left->set_node(2, _mesh->node_ptr(2));
132  elem_top_left->set_node(3, _mesh->node_ptr(3));
133 
134  Elem * elem_bottom_left = _mesh->add_elem(Elem::build_with_id(QUAD4, 1));
135  elem_bottom_left->set_node(0, _mesh->node_ptr(4));
136  elem_bottom_left->set_node(1, _mesh->node_ptr(5));
137  elem_bottom_left->set_node(2, _mesh->node_ptr(6));
138  elem_bottom_left->set_node(3, _mesh->node_ptr(0));
139 
140  Elem * elem_top_right = _mesh->add_elem(Elem::build_with_id(QUAD4, 2));
141  elem_top_right->set_node(0, _mesh->node_ptr(1));
142  elem_top_right->set_node(1, _mesh->node_ptr(7));
143  elem_top_right->set_node(2, _mesh->node_ptr(8));
144  elem_top_right->set_node(3, _mesh->node_ptr(2));
145 
146  Elem * elem_bottom_right = _mesh->add_elem(Elem::build_with_id(QUAD4, 3));
147  elem_bottom_right->set_node(0, _mesh->node_ptr(5));
148  elem_bottom_right->set_node(1, _mesh->node_ptr(9));
149  elem_bottom_right->set_node(2, _mesh->node_ptr(7));
150  elem_bottom_right->set_node(3, _mesh->node_ptr(6));
151 
152  Elem * elem_top_leftleft = _mesh->add_elem(Elem::build_with_id(QUAD4, 4));
153  elem_top_leftleft->set_node(0, _mesh->node_ptr(11));
154  elem_top_leftleft->set_node(1, _mesh->node_ptr(0));
155  elem_top_leftleft->set_node(2, _mesh->node_ptr(3));
156  elem_top_leftleft->set_node(3, _mesh->node_ptr(12));
157 
158  Elem * elem_bottom_leftleft = _mesh->add_elem(Elem::build_with_id(QUAD4, 5));
159  elem_bottom_leftleft->set_node(0, _mesh->node_ptr(10));
160  elem_bottom_leftleft->set_node(1, _mesh->node_ptr(4));
161  elem_bottom_leftleft->set_node(2, _mesh->node_ptr(0));
162  elem_bottom_leftleft->set_node(3, _mesh->node_ptr(11));
163 
164  Elem * elem_top_rightright = _mesh->add_elem(Elem::build_with_id(QUAD4, 6));
165  elem_top_rightright->set_node(0, _mesh->node_ptr(7));
166  elem_top_rightright->set_node(1, _mesh->node_ptr(14));
167  elem_top_rightright->set_node(2, _mesh->node_ptr(15));
168  elem_top_rightright->set_node(3, _mesh->node_ptr(8));
169 
170  Elem * elem_bottom_rightright = _mesh->add_elem(Elem::build_with_id(QUAD4, 7));
171  elem_bottom_rightright->set_node(0, _mesh->node_ptr(9));
172  elem_bottom_rightright->set_node(1, _mesh->node_ptr(13));
173  elem_bottom_rightright->set_node(2, _mesh->node_ptr(14));
174  elem_bottom_rightright->set_node(3, _mesh->node_ptr(7));
175  }
176 
177  // libMesh shouldn't renumber, or our based-on-initial-id
178  // assertions later may fail.
179  _mesh->allow_renumbering(false);
180 
181  _mesh->prepare_for_use();
182  }
libMesh::Elem::set_node
virtual Node *& set_node(const unsigned int i)
Definition: elem.h:2558
libMesh::Elem
This is the base class from which all geometric element types are derived.
Definition: elem.h:94
SlitMeshTest::_mesh
std::unique_ptr< Mesh > _mesh
Definition: slit_mesh_test.C:88
libMesh::Point
A Point defines a location in LIBMESH_DIM dimensional Real space.
Definition: point.h:39

◆ CPPUNIT_TEST()

SlitMeshRefinedMeshTest::CPPUNIT_TEST ( testMesh  )

◆ CPPUNIT_TEST_SUITE_END()

SlitMeshRefinedMeshTest::CPPUNIT_TEST_SUITE_END ( )

◆ LIBMESH_CPPUNIT_TEST_SUITE() [1/2]

SlitMeshTest::LIBMESH_CPPUNIT_TEST_SUITE ( SlitMeshTest  )
inherited

The goal of this test is to ensure that a 2D mesh with nodes overlapping on opposite sides of an internal, "slit" edge is usable.

The mesh has to be connected at more than one node on each side of the slit, however, to ensure that we can find point neighbors of each node.

◆ LIBMESH_CPPUNIT_TEST_SUITE() [2/2]

SlitMeshRefinedMeshTest::LIBMESH_CPPUNIT_TEST_SUITE ( SlitMeshRefinedMeshTest  )

The goal of this test is the same as the previous, but now we do a uniform refinement and make sure the result mesh is consistent.

i.e. the new node shared between the 1D elements is the same as the node shared on the underlying quads, and so on.

◆ setUp()

void SlitMeshRefinedMeshTest::setUp ( )
inline

Definition at line 242 of file slit_mesh_test.C.

References libMesh::MeshRefinement::uniformly_refine().

243  {
244 #if LIBMESH_DIM > 1
245  this->build_mesh();
246 
247 #ifdef LIBMESH_ENABLE_AMR
248  MeshRefinement(*_mesh).uniformly_refine(1);
249 #endif
250 #endif
251  }
libMesh::MeshRefinement
Implements (adaptive) mesh refinement algorithms for a MeshBase.
Definition: mesh_refinement.h:61
SlitMeshTest::build_mesh
void build_mesh()
Definition: slit_mesh_test.C:90
libMesh::MeshRefinement::uniformly_refine
void uniformly_refine(unsigned int n=1)
Uniformly refines the mesh n times.
Definition: mesh_refinement.C:1682

◆ tearDown()

void SlitMeshTest::tearDown ( )
inlineinherited

Definition at line 192 of file slit_mesh_test.C.

192 {}

◆ testMesh()

void SlitMeshRefinedMeshTest::testMesh ( )
inline

Definition at line 253 of file slit_mesh_test.C.

254  {
255  LOG_UNIT_TEST;
256 
257 #ifdef LIBMESH_ENABLE_AMR
258  // We should have 40 total and 32 active elements.
259  CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(40), _mesh->n_elem());
260  CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(32), _mesh->n_active_elem());
261 
262  // We should have 48 nodes, not 45 or 46
263  CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(48), _mesh->n_nodes());
264 #endif
265  }
SlitMeshTest::_mesh
std::unique_ptr< Mesh > _mesh
Definition: slit_mesh_test.C:88

Member Data Documentation

◆ _mesh

std::unique_ptr<Mesh> SlitMeshTest::_mesh
protectedinherited

Definition at line 88 of file slit_mesh_test.C.

The documentation for this class was generated from the following file:
Generated on Thu Jul 17 2025 01:29:20 for libMesh by   doxygen 1.8.14