libMesh
Loading...
Searching...
No Matches
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.
 
 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.
 
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.

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 }
SlitMeshTest::_mesh
std::unique_ptr< Mesh > _mesh
Definition slit_mesh_test.C:88
libMesh::Elem
This is the base class from which all geometric element types are derived.
Definition elem.h:96
libMesh::Elem::set_node
virtual Node *& set_node(const unsigned int i)
Definition elem.h:2567
libMesh::Elem::build_with_id
static std::unique_ptr< Elem > build_with_id(const ElemType type, dof_id_type id)
Calls the build() method above with a nullptr parent, and additionally sets the newly-created Elem's ...
Definition elem.C:556
libMesh::Point
A Point defines a location in LIBMESH_DIM dimensional Real space.
Definition point.h:40

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

Referenced by SlitMeshTest::setUp(), setUp(), and SlitMeshRefinedSystemTest::setUp().

◆ CPPUNIT_TEST()

SlitMeshRefinedMeshTest::CPPUNIT_TEST ( testMesh  )

◆ CPPUNIT_TEST_SUITE_END()

SlitMeshRefinedMeshTest::CPPUNIT_TEST_SUITE_END ( )

◆ LIBMESH_CPPUNIT_TEST_SUITE() [1/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.

◆ LIBMESH_CPPUNIT_TEST_SUITE() [2/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.

◆ setUp()

void SlitMeshRefinedMeshTest::setUp ( )
inline

Definition at line 242 of file slit_mesh_test.C.

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:62
libMesh::MeshRefinement::uniformly_refine
void uniformly_refine(unsigned int n=1)
Uniformly refines the mesh n times.
Definition mesh_refinement.C:1720

References SlitMeshTest::build_mesh(), and libMesh::MeshRefinement::uniformly_refine().

◆ 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 }
libMesh::dof_id_type
uint8_t dof_id_type
Definition id_types.h:67

References SlitMeshTest::_mesh.

Member Data Documentation

◆ _mesh

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

Definition at line 88 of file slit_mesh_test.C.

Referenced by SlitMeshTest::build_mesh(), SlitMeshRefinedSystemTest::setUp(), SlitMeshTest::testMesh(), testMesh(), SlitMeshRefinedSystemTest::testMesh(), SlitMeshRefinedSystemTest::testRestart(), and SlitMeshRefinedSystemTest::testSystem().

The documentation for this class was generated from the following file:
Generated on Mon Aug 24 2026 19:00:44 for libMesh by doxygen 1.9.8