libMesh
Loading...
Searching...
No Matches
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
MixedDimensionRefinedMeshTest Class Reference
Inheritance diagram for MixedDimensionRefinedMeshTest:
[legend]

Public Member Functions

 LIBMESH_CPPUNIT_TEST_SUITE (MixedDimensionRefinedMeshTest)
 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 (testDofOrdering)
 
 CPPUNIT_TEST_SUITE_END ()
 
void setUp ()
 
void testMesh ()
 
void testDofOrdering ()
 
 LIBMESH_CPPUNIT_TEST_SUITE (MixedDimensionMeshTest)
 The goal of this test is to ensure that a 2D mesh with 1D elements overlapping on the edge is consistent.
 
 CPPUNIT_TEST (testPointLocatorTree)
 
void tearDown ()
 
void testPointLocatorTree ()
 

Protected Member Functions

void build_mesh ()
 

Protected Attributes

std::unique_ptr< ReplicatedMesh > _mesh
 

Detailed Description

Definition at line 202 of file mixed_dim_mesh_test.C.

Member Function Documentation

◆ build_mesh()

void MixedDimensionMeshTest::build_mesh ( )
inlineprotectedinherited

Definition at line 41 of file mixed_dim_mesh_test.C.

42 {
43 _mesh = std::make_unique<ReplicatedMesh>(*TestCommWorld);
44
45 // (0,1) (1,1)
46 // x---------------x
47 // | |
48 // | |
49 // | |
50 // | |
51 // | |
52 // x---------------x
53 // (0,0) (1,0)
54 // | |
55 // | |
56 // | |
57 // | |
58 // x---------------x
59 // (0,-1) (1,-1)
60
61 _mesh->set_mesh_dimension(2);
62
63 _mesh->add_point( Point(0.0,-1.0), 4 );
64 _mesh->add_point( Point(1.0,-1.0), 5 );
65 _mesh->add_point( Point(1.0, 0.0), 1 );
66 _mesh->add_point( Point(1.0, 1.0), 2 );
67 _mesh->add_point( Point(0.0, 1.0), 3 );
68 _mesh->add_point( Point(0.0, 0.0), 0 );
69
70 {
71 Elem * elem_top = _mesh->add_elem(Elem::build(QUAD4));
72 elem_top->set_node(0, _mesh->node_ptr(0));
73 elem_top->set_node(1, _mesh->node_ptr(1));
74 elem_top->set_node(2, _mesh->node_ptr(2));
75 elem_top->set_node(3, _mesh->node_ptr(3));
76
77 Elem * elem_bottom = _mesh->add_elem(Elem::build(QUAD4));
78 elem_bottom->set_node(0, _mesh->node_ptr(4));
79 elem_bottom->set_node(1, _mesh->node_ptr(5));
80 elem_bottom->set_node(2, _mesh->node_ptr(1));
81 elem_bottom->set_node(3, _mesh->node_ptr(0));
82
83 Elem * edge = _mesh->add_elem(Elem::build(EDGE2));
84 edge->set_node(0, _mesh->node_ptr(0));
85 edge->set_node(1, _mesh->node_ptr(1));
86
87 // 2D elements will have subdomain id 0, this one will have 1
88 edge->subdomain_id() = 1;
89 }
90
91 _mesh->allow_renumbering(true);
92 _mesh->prepare_for_use();
93 }
MixedDimensionMeshTest::_mesh
std::unique_ptr< ReplicatedMesh > _mesh
Definition mixed_dim_mesh_test.C:39
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
static std::unique_ptr< Elem > build(const ElemType type, Elem *p=nullptr)
Definition elem.C:442
libMesh::Elem::subdomain_id
subdomain_id_type subdomain_id() const
Definition elem.h:2591
libMesh::Point
A Point defines a location in LIBMESH_DIM dimensional Real space.
Definition point.h:40

References MixedDimensionMeshTest::_mesh, libMesh::Elem::build(), libMesh::EDGE2, libMesh::QUAD4, libMesh::Elem::set_node(), libMesh::Elem::subdomain_id(), and TestCommWorld.

Referenced by MixedDimensionMeshTest::setUp(), and setUp().

◆ CPPUNIT_TEST() [1/3]

MixedDimensionRefinedMeshTest::CPPUNIT_TEST ( testDofOrdering  )

◆ CPPUNIT_TEST() [2/3]

MixedDimensionRefinedMeshTest::CPPUNIT_TEST ( testMesh  )

◆ CPPUNIT_TEST() [3/3]

MixedDimensionMeshTest::CPPUNIT_TEST ( testPointLocatorTree  )
inherited

◆ CPPUNIT_TEST_SUITE_END()

MixedDimensionRefinedMeshTest::CPPUNIT_TEST_SUITE_END ( )

◆ LIBMESH_CPPUNIT_TEST_SUITE() [1/2]

MixedDimensionMeshTest::LIBMESH_CPPUNIT_TEST_SUITE ( MixedDimensionMeshTest  )
inherited

The goal of this test is to ensure that a 2D mesh with 1D elements overlapping on the edge is consistent.

That is, they share the same global node numbers and the same dof numbers for a variable.

◆ LIBMESH_CPPUNIT_TEST_SUITE() [2/2]

MixedDimensionRefinedMeshTest::LIBMESH_CPPUNIT_TEST_SUITE ( MixedDimensionRefinedMeshTest  )

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 MixedDimensionRefinedMeshTest::setUp ( )
inline

Definition at line 224 of file mixed_dim_mesh_test.C.

225 {
226 // 3-------10------2
227 // | | |
228 // | 5 | 6 |
229 // 8-------7-------9
230 // | | |
231 // | 3 | 4 |
232 // 0-------6-------1
233 // | | |
234 // | 9 | 10 |
235 // 13------12-------14
236 // | | |
237 // | 7 | 8 |
238 // 4-------11------5
239#if LIBMESH_DIM > 1
240 this->build_mesh();
241
242#ifdef LIBMESH_ENABLE_AMR
243 MeshRefinement(*_mesh).uniformly_refine(1);
244#endif
245#endif
246 }
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 MixedDimensionMeshTest::build_mesh(), and libMesh::MeshRefinement::uniformly_refine().

◆ tearDown()

void MixedDimensionMeshTest::tearDown ( )
inlineinherited

Definition at line 103 of file mixed_dim_mesh_test.C.

103{}

◆ testDofOrdering()

void MixedDimensionRefinedMeshTest::testDofOrdering ( )
inline

Definition at line 302 of file mixed_dim_mesh_test.C.

303 {
304#ifdef LIBMESH_ENABLE_AMR
305 LOG_UNIT_TEST;
306
307 EquationSystems es(*_mesh);
308 es.add_system<LinearImplicitSystem>("TestDofSystem");
309 es.get_system("TestDofSystem").add_variable("u",FIRST);
310 es.init();
311
312 DofMap& dof_map = es.get_system("TestDofSystem").get_dof_map();
313
314 std::vector<dof_id_type> top_quad3_dof_indices, top_quad4_dof_indices;
315 std::vector<dof_id_type> bottom_quad9_dof_indices, bottom_quad10_dof_indices;
316 std::vector<dof_id_type> edge11_dof_indices, edge12_dof_indices;
317
318 dof_map.dof_indices( _mesh->elem_ptr(3), top_quad3_dof_indices );
319 dof_map.dof_indices( _mesh->elem_ptr(4), top_quad4_dof_indices );
320 dof_map.dof_indices( _mesh->elem_ptr(9), bottom_quad9_dof_indices );
321 dof_map.dof_indices( _mesh->elem_ptr(10), bottom_quad10_dof_indices );
322 dof_map.dof_indices( _mesh->elem_ptr(11), edge11_dof_indices );
323 dof_map.dof_indices( _mesh->elem_ptr(12), edge12_dof_indices );
324
325 // EDGE2,id=11 should have same dofs as of bottom of QUAD4, id=3
326 CPPUNIT_ASSERT_EQUAL( edge11_dof_indices[0], top_quad3_dof_indices[0] );
327 CPPUNIT_ASSERT_EQUAL( edge11_dof_indices[1], top_quad3_dof_indices[1] );
328
329 // EDGE2,id=12 should have same dofs of bottom of QUAD4, id=4
330 CPPUNIT_ASSERT_EQUAL( edge12_dof_indices[0], top_quad4_dof_indices[0] );
331 CPPUNIT_ASSERT_EQUAL( edge12_dof_indices[1], top_quad4_dof_indices[1] );
332
333 // EDGE2,id=11 should have same dofs of top of QUAD4, id=9
334 CPPUNIT_ASSERT_EQUAL( edge11_dof_indices[0], bottom_quad9_dof_indices[3] );
335 CPPUNIT_ASSERT_EQUAL( edge11_dof_indices[1], bottom_quad9_dof_indices[2] );
336
337 // EDGE2,id=12 should have same dofs of top of QUAD4, id=10
338 CPPUNIT_ASSERT_EQUAL( edge12_dof_indices[0], bottom_quad10_dof_indices[3] );
339 CPPUNIT_ASSERT_EQUAL( edge12_dof_indices[1], bottom_quad10_dof_indices[2] );
340
341 //EDGE2 elements should have same shared dof number
342 CPPUNIT_ASSERT_EQUAL( edge11_dof_indices[1], edge12_dof_indices[0] );
343#endif
344 }
libMesh::DofMap
This class handles the numbering of degrees of freedom on a mesh.
Definition dof_map.h:181
libMesh::DofMap::dof_indices
void dof_indices(const Elem *const elem, std::vector< dof_id_type > &di) const
Definition dof_map.C:2201
libMesh::EquationSystems
This is the EquationSystems class.
Definition equation_systems.h:72
libMesh::LinearImplicitSystem
Manages consistently variables, degrees of freedom, coefficient vectors, matrices and linear solvers ...
Definition linear_implicit_system.h:56
libMesh::System::add_variable
unsigned int add_variable(std::string_view var, const FEType &type, const std::set< subdomain_id_type > *const active_subdomains=nullptr)
Adds the variable var to the list of variables for this system.
Definition system.C:1344

References MixedDimensionMeshTest::_mesh, libMesh::EquationSystems::add_system(), libMesh::DofMap::dof_indices(), libMesh::FIRST, libMesh::EquationSystems::get_system(), and libMesh::EquationSystems::init().

◆ testMesh()

void MixedDimensionRefinedMeshTest::testMesh ( )
inline

Definition at line 248 of file mixed_dim_mesh_test.C.

249 {
250#ifdef LIBMESH_ENABLE_AMR
251 LOG_UNIT_TEST;
252
253 // We should have 13 total and 10 active elements.
254 CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(13), _mesh->n_elem());
255 CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(10), _mesh->n_active_elem());
256
257 // We should have 15 nodes
258 CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(15), _mesh->n_nodes());
259
260 // EDGE2,id=11 should have same nodes of bottom of QUAD4, id=3
261 CPPUNIT_ASSERT_EQUAL( _mesh->elem_ref(11).node_id(0),
262 _mesh->elem_ref(3).node_id(0) );
263 CPPUNIT_ASSERT_EQUAL( _mesh->elem_ref(11).node_id(1),
264 _mesh->elem_ref(3).node_id(1) );
265
266 // EDGE2,id=12 should have same nodes of bottom of QUAD4, id=4
267 CPPUNIT_ASSERT_EQUAL( _mesh->elem_ref(12).node_id(0),
268 _mesh->elem_ref(4).node_id(0) );
269 CPPUNIT_ASSERT_EQUAL( _mesh->elem_ref(12).node_id(1),
270 _mesh->elem_ref(4).node_id(1) );
271
272 // EDGE2,id=11 should have same nodes of top of QUAD4, id=9
273 CPPUNIT_ASSERT_EQUAL( _mesh->elem_ref(11).node_id(0),
274 _mesh->elem_ref(9).node_id(3) );
275 CPPUNIT_ASSERT_EQUAL( _mesh->elem_ref(11).node_id(1),
276 _mesh->elem_ref(9).node_id(2) );
277
278 // EDGE2,id=12 should have same nodes of top of QUAD4, id=10
279 CPPUNIT_ASSERT_EQUAL( _mesh->elem_ref(12).node_id(0),
280 _mesh->elem_ref(10).node_id(3) );
281 CPPUNIT_ASSERT_EQUAL( _mesh->elem_ref(12).node_id(1),
282 _mesh->elem_ref(10).node_id(2) );
283
284 // Shared node between the EDGE2 elements should have the same global id
285 CPPUNIT_ASSERT_EQUAL( _mesh->elem_ref(11).node_id(1),
286 _mesh->elem_ref(12).node_id(0) );
287
288 // EDGE2 child elements should have the correct parent
289 CPPUNIT_ASSERT_EQUAL( _mesh->elem_ref(11).parent(),
290 _mesh->elem_ptr(2) );
291 CPPUNIT_ASSERT_EQUAL( _mesh->elem_ref(12).parent(),
292 _mesh->elem_ptr(2) );
293
294 // EDGE2 child elements should have the correct interior_parent
295 CPPUNIT_ASSERT_EQUAL( _mesh->elem_ref(11).interior_parent(),
296 _mesh->elem_ptr(3) );
297 CPPUNIT_ASSERT_EQUAL( _mesh->elem_ref(12).interior_parent(),
298 _mesh->elem_ptr(4) );
299#endif
300 }
libMesh::dof_id_type
uint8_t dof_id_type
Definition id_types.h:67

References MixedDimensionMeshTest::_mesh.

◆ testPointLocatorTree()

void MixedDimensionMeshTest::testPointLocatorTree ( )
inlineinherited

Definition at line 168 of file mixed_dim_mesh_test.C.

169 {
170 LOG_UNIT_TEST;
171
172 std::unique_ptr<PointLocatorBase> locator = _mesh->sub_point_locator();
173
174 Point top_point(0.5, 0.5);
175 const Elem* top_elem = (*locator)(top_point);
176 CPPUNIT_ASSERT(top_elem);
177
178 // We should have gotten back the top quad
179 CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(0), top_elem->id());
180
181 Point bottom_point(0.5, -0.5);
182 const Elem* bottom_elem = (*locator)(bottom_point);
183 CPPUNIT_ASSERT(bottom_elem);
184
185 // We should have gotten back the bottom quad
186 CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(1), bottom_elem->id());
187
188 // Test getting back the edge
189 {
190 std::set<subdomain_id_type> subdomain_id; subdomain_id.insert(1);
191 Point interface_point( 0.5, 0.0 );
192 const Elem* interface_elem = (*locator)(interface_point, &subdomain_id);
193 CPPUNIT_ASSERT(interface_elem);
194
195 // We should have gotten back the overlapping edge element
196 CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(2), interface_elem->id());
197 }
198 }
libMesh::DofObject::id
dof_id_type id() const
Definition dof_object.h:819

References MixedDimensionMeshTest::_mesh, and libMesh::DofObject::id().

Member Data Documentation

◆ _mesh

std::unique_ptr<ReplicatedMesh> MixedDimensionMeshTest::_mesh
protectedinherited

Definition at line 39 of file mixed_dim_mesh_test.C.

Referenced by MixedDimensionMeshTest::build_mesh(), MixedDimensionMeshTest::testDofOrdering(), testDofOrdering(), MixedDimensionMeshTest::testMesh(), testMesh(), and MixedDimensionMeshTest::testPointLocatorTree().

The documentation for this class was generated from the following file:
Generated on Fri Aug 21 2026 13:32:35 for libMesh by doxygen 1.9.8