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

Public Member Functions

 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...
 
 CPPUNIT_TEST (testMesh)
 
 CPPUNIT_TEST_SUITE_END ()
 
void setUp ()
 
void tearDown ()
 
void testMesh ()
 

Protected Member Functions

void build_mesh ()
 

Protected Attributes

std::unique_ptr< Mesh_mesh
 

Detailed Description

Definition at line 65 of file slit_mesh_test.C.

Member Function Documentation

◆ build_mesh()

void SlitMeshTest::build_mesh ( )
inlineprotected

Definition at line 86 of file slit_mesh_test.C.

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

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

◆ CPPUNIT_TEST()

SlitMeshTest::CPPUNIT_TEST ( testMesh  )

◆ CPPUNIT_TEST_SUITE_END()

SlitMeshTest::CPPUNIT_TEST_SUITE_END ( )

◆ LIBMESH_CPPUNIT_TEST_SUITE()

SlitMeshTest::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.

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

Definition at line 181 of file slit_mesh_test.C.

182  {
183 #if LIBMESH_DIM > 1
184  this->build_mesh();
185 #endif
186  }
void build_mesh()

◆ tearDown()

void SlitMeshTest::tearDown ( )
inline

Definition at line 188 of file slit_mesh_test.C.

188 {}

◆ testMesh()

void SlitMeshTest::testMesh ( )
inline

Definition at line 190 of file slit_mesh_test.C.

191  {
192  LOG_UNIT_TEST;
193 
194  // There'd better be 8 elements
195  CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(8), _mesh->n_elem());
196 
197  // There'd better still be a full 16 nodes
198  CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(16), _mesh->n_nodes());
199 
200  /* The middle nodes should still be distinct between the top and
201  * bottom elements */
202  if (_mesh->query_elem_ptr(0) && _mesh->query_elem_ptr(1))
203  CPPUNIT_ASSERT( _mesh->elem_ref(0).node_id(1) != _mesh->elem_ref(1).node_id(2) );
204  if (_mesh->query_elem_ptr(2) && _mesh->query_elem_ptr(3))
205  CPPUNIT_ASSERT( _mesh->elem_ref(2).node_id(0) != _mesh->elem_ref(3).node_id(3) );
206 
207  /* The middle nodes should still be shared between left and right
208  * elements on top and bottom */
209  if (_mesh->query_elem_ptr(0) && _mesh->query_elem_ptr(2))
210  CPPUNIT_ASSERT_EQUAL( _mesh->elem_ref(0).node_id(1),
211  _mesh->elem_ref(2).node_id(0) );
212  if (_mesh->query_elem_ptr(1) && _mesh->query_elem_ptr(3))
213  CPPUNIT_ASSERT_EQUAL( _mesh->elem_ref(1).node_id(2),
214  _mesh->elem_ref(3).node_id(3) );
215  }
std::unique_ptr< Mesh > _mesh

Member Data Documentation

◆ _mesh

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

Definition at line 84 of file slit_mesh_test.C.


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