Sierra Toolkit  Version of the Day
UnitTestFEMMetaData.cpp
1 /*------------------------------------------------------------------------*/
2 /* Copyright 2011 Sandia Corporation. */
3 /* Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive */
4 /* license for use of this work by or on behalf of the U.S. Government. */
5 /* Export of this program may require a license from the */
6 /* United States Government. */
7 /*------------------------------------------------------------------------*/
8 
9 #include <stdexcept>
10 #include <algorithm>
11 
12 #include <stk_mesh/fem/FEMMetaData.hpp>
13 #include <stk_util/unit_test_support/stk_utest_macros.hpp>
14 
16 
17 namespace {
18 
19 static const stk_classic::mesh::EntityRank NODE_RANK = FEMMetaData::NODE_RANK;
20 static const stk_classic::mesh::EntityRank EDGE_RANK = FEMMetaData::EDGE_RANK;
21 static const stk_classic::mesh::EntityRank FACE_RANK = FEMMetaData::FACE_RANK;
22 static const stk_classic::mesh::EntityRank VOLUME_RANK = FEMMetaData::VOLUME_RANK;
23 static const stk_classic::mesh::EntityRank INVALID_RANK = FEMMetaData::INVALID_RANK;
24 
25 }
26 
27 //----------------------------------------------------------------------------
28 
29 STKUNIT_UNIT_TEST ( UnitTestFEMMetaData, create )
30 {
32  STKUNIT_EXPECT_TRUE ( true );
33  STKUNIT_EXPECT_FALSE( fem_meta.is_FEM_initialized() );
34  STKUNIT_EXPECT_EQUAL( fem_meta.spatial_dimension(), 0u );
35  STKUNIT_EXPECT_EQUAL( fem_meta.node_rank(), NODE_RANK );
36  STKUNIT_EXPECT_EQUAL( fem_meta.edge_rank(), EDGE_RANK );
37  STKUNIT_EXPECT_EQUAL( fem_meta.face_rank(), FACE_RANK );
38  STKUNIT_EXPECT_EQUAL( fem_meta.side_rank(), INVALID_RANK );
39  STKUNIT_EXPECT_EQUAL( fem_meta.element_rank(), INVALID_RANK );
40 
41  // Verify throws/etc for FEM calls prior to initialization:
42  stk_classic::mesh::fem::CellTopology invalid_cell_topology( NULL );
43  stk_classic::mesh::Part & universal_part = fem_meta.universal_part();
44  STKUNIT_ASSERT_THROW( fem_meta.register_cell_topology( invalid_cell_topology, INVALID_RANK ), std::logic_error );
45  STKUNIT_ASSERT_THROW( fem_meta.get_cell_topology_root_part( invalid_cell_topology), std::logic_error );
46  STKUNIT_ASSERT_THROW( fem_meta.get_cell_topology( universal_part), std::logic_error );
47  STKUNIT_ASSERT_THROW( stk_classic::mesh::fem::set_cell_topology( universal_part, invalid_cell_topology), std::logic_error );
48  STKUNIT_EXPECT_EQUAL( fem_meta.get_entity_rank( invalid_cell_topology), INVALID_RANK );
49 
50 }
51 
52 STKUNIT_UNIT_TEST( UnitTestFEMMetaData, initialize )
53 {
55  const size_t spatial_dimension = 3;
56  fem_meta.FEM_initialize(spatial_dimension);
57  STKUNIT_EXPECT_TRUE( fem_meta.is_FEM_initialized() );
58  STKUNIT_EXPECT_EQUAL( fem_meta.spatial_dimension(), spatial_dimension );
59 }
60 
61 STKUNIT_UNIT_TEST( UnitTestFEMMetaData, invalid_initialize )
62 {
64  const size_t spatial_dimension = 0;
65  STKUNIT_ASSERT_THROW( fem_meta.FEM_initialize(spatial_dimension), std::logic_error );
66 }
67 
68 STKUNIT_UNIT_TEST( UnitTestFEMMetaData, initialize_only_once )
69 {
71  const size_t spatial_dimension = 3;
72  fem_meta.FEM_initialize(spatial_dimension);
73  STKUNIT_ASSERT_THROW( fem_meta.FEM_initialize(2), std::logic_error );
74 }
75 
76 STKUNIT_UNIT_TEST( UnitTestFEMMetaData, entity_ranks_1 )
77 {
79  const size_t spatial_dimension = 1;
80  fem_meta.FEM_initialize(spatial_dimension);
81  STKUNIT_EXPECT_EQUAL( fem_meta.node_rank(), NODE_RANK );
82  STKUNIT_EXPECT_EQUAL( fem_meta.edge_rank(), EDGE_RANK );
83  STKUNIT_EXPECT_EQUAL( fem_meta.face_rank(), FACE_RANK );
84  STKUNIT_EXPECT_EQUAL( fem_meta.side_rank(), NODE_RANK );
85  STKUNIT_EXPECT_EQUAL( fem_meta.element_rank(), EDGE_RANK );
86 
87 }
88 
89 
90 STKUNIT_UNIT_TEST( UnitTestFEMMetaData, entity_ranks_2 )
91 {
93  const size_t spatial_dimension = 2;
94  fem_meta.FEM_initialize(spatial_dimension);
95  STKUNIT_EXPECT_EQUAL( fem_meta.node_rank(), NODE_RANK );
96  STKUNIT_EXPECT_EQUAL( fem_meta.edge_rank(), EDGE_RANK );
97  STKUNIT_EXPECT_EQUAL( fem_meta.face_rank(), FACE_RANK );
98  STKUNIT_EXPECT_EQUAL( fem_meta.side_rank(), EDGE_RANK );
99  STKUNIT_EXPECT_EQUAL( fem_meta.element_rank(), FACE_RANK );
100 
101 }
102 
103 
104 STKUNIT_UNIT_TEST( UnitTestFEMMetaData, entity_ranks_3 )
105 {
107  const size_t spatial_dimension = 3;
108  fem_meta.FEM_initialize(spatial_dimension);
109  STKUNIT_EXPECT_EQUAL( fem_meta.node_rank(), NODE_RANK );
110  STKUNIT_EXPECT_EQUAL( fem_meta.edge_rank(), EDGE_RANK );
111  STKUNIT_EXPECT_EQUAL( fem_meta.face_rank(), FACE_RANK );
112  STKUNIT_EXPECT_EQUAL( fem_meta.side_rank(), FACE_RANK );
113  STKUNIT_EXPECT_EQUAL( fem_meta.element_rank(), VOLUME_RANK );
114 }
115 
116 
117 STKUNIT_UNIT_TEST( UnitTestFEMMetaData, entity_ranks_4 )
118 {
120  const size_t spatial_dimension = 4;
121  std::vector<std::string> entity_rank_names(spatial_dimension+1);
122  // When using spatial_dimension > 3, you must pass in names.
123  entity_rank_names[0] = "node";
124  entity_rank_names[1] = "super node";
125  entity_rank_names[2] = "super duper node";
126  entity_rank_names[3] = "particle";
127  entity_rank_names[4] = "thing";
128 
129  fem_meta.FEM_initialize(spatial_dimension,entity_rank_names);
130  STKUNIT_EXPECT_EQUAL( fem_meta.node_rank(), NODE_RANK );
131  STKUNIT_EXPECT_EQUAL( fem_meta.edge_rank(), EDGE_RANK );
132  STKUNIT_EXPECT_EQUAL( fem_meta.face_rank(), FACE_RANK );
133  STKUNIT_EXPECT_EQUAL( fem_meta.side_rank(), VOLUME_RANK );
134  STKUNIT_EXPECT_EQUAL( fem_meta.element_rank(), 4u );
135 }
136 
137 
138 STKUNIT_UNIT_TEST( UnitTestFEMMetaData, get_cell_topology_trivial )
139 {
141  const size_t spatial_dimension = 3;
142  fem_meta.FEM_initialize(spatial_dimension);
143  stk_classic::mesh::fem::CellTopology hex_top(shards::getCellTopologyData<shards::Hexahedron<8> >());
144  stk_classic::mesh::Part & hex_part = fem_meta.get_cell_topology_root_part(hex_top);
145 
146  STKUNIT_EXPECT_TRUE( stk_classic::mesh::is_auto_declared_part(hex_part) );
147  STKUNIT_EXPECT_EQUAL( hex_part.primary_entity_rank(), spatial_dimension );
148  stk_classic::mesh::fem::CellTopology topology = fem_meta.get_cell_topology(hex_part);
149  STKUNIT_EXPECT_EQUAL( (topology == hex_top), true );
150 }
151 
152 
153 STKUNIT_UNIT_TEST( UnitTestFEMMetaData, get_cell_topology_simple )
154 {
156  const size_t spatial_dimension = 3;
157  fem_meta.FEM_initialize(spatial_dimension);
158  stk_classic::mesh::fem::CellTopology hex_top(shards::getCellTopologyData<shards::Hexahedron<8> >());
159  stk_classic::mesh::Part & hex_part = fem_meta.get_cell_topology_root_part(hex_top);
160  stk_classic::mesh::Part & A = fem_meta.declare_part("Part A", fem_meta.element_rank() );
161  STKUNIT_EXPECT_TRUE( stk_classic::mesh::is_auto_declared_part(hex_part) );
162  STKUNIT_EXPECT_TRUE( !stk_classic::mesh::is_auto_declared_part(A) );
163  fem_meta.declare_part_subset( hex_part, A );
164  stk_classic::mesh::fem::CellTopology topology = fem_meta.get_cell_topology(A);
165  STKUNIT_ASSERT_EQUAL( (topology == hex_top), true );
166 }
167 
168 
169 STKUNIT_UNIT_TEST( UnitTestFEMMetaData, get_cell_topology_invalid )
170 {
172  const size_t spatial_dimension = 2;
173  fem_meta.FEM_initialize(spatial_dimension);
174  stk_classic::mesh::fem::CellTopology hex_top(shards::getCellTopologyData<shards::Hexahedron<8> >());
175  STKUNIT_ASSERT_THROW( fem_meta.get_cell_topology_root_part(hex_top), std::runtime_error );
176 }
177 
178 
179 STKUNIT_UNIT_TEST( UnitTestFEMMetaData, cell_topology_subsetting )
180 {
182  const size_t spatial_dimension = 3;
183  const stk_classic::mesh::EntityRank element_rank = spatial_dimension;
184  fem_meta.FEM_initialize(spatial_dimension);
185  stk_classic::mesh::Part & element_part = fem_meta.declare_part("element part", element_rank );
186  stk_classic::mesh::fem::CellTopology hex_top(shards::getCellTopologyData<shards::Hexahedron<8> >());
187  stk_classic::mesh::fem::set_cell_topology( element_part, hex_top );
188 
189  stk_classic::mesh::Part & hex_part = fem_meta.get_cell_topology_root_part(hex_top);
190 
191  const stk_classic::mesh::PartVector & element_part_supersets = element_part.supersets();
192  STKUNIT_EXPECT_EQUAL(
193  std::count(element_part_supersets.begin(),element_part_supersets.end(),&hex_part), 1
194  );
195 }
196 
197 // 02/16/11: Cell Topology Induced Membership
198 //
199 // Invariants:
200 // 1. Root cell topology parts cannot be subsets of parts with cell topologies
201 // 2. Incompatible cell topologies are prohibited. I.e. parts with
202 // different cell topologies of the same rank (as the part) cannot be subsets
203 // of each other.
204 //
205 // Decision tree for declare_part_subset(superset,subset):
206 // Q: Does the superset part have a topology?
207 // A: No
208 // [ Okay, go forward ] (Test 1)
209 // A: Yes
210 // Q: Is the subset part a root cell topology part or are any of the subset's parts subsets a root cell topology part?
211 // A: Yes
212 // [ Throw ] (Test 2 a,b)
213 // A: No
214 // Q: How many cell topologies of the same rank as the superset are defined for the subset part and the subset's subsets parts?
215 // A: 0
216 // [ Okay, go forward ] (Test 3 a,b,c)
217 // A: 1+
218 // Q: Are all the cell topologies the same?
219 // A: Yes
220 // [ Okay, go forward ] (Test 4 a,b)
221 // A: No
222 // [ Throw ] (Test 5 a,b,c)
223 //
224 // Tests:
225 // The following parts are necessary for the tests [spatial_dimension = 3]:
226 // Part A, rank 3, no topology
227 // Part B, rank 3, no topology
228 // Part C, rank 2, no topology
229 // Part D, rank 2, no topolooy
230 // Part E, rank 3, no topology
231 // Part F, rank 3, no topolooy
232 // Part H, rank 3, Hex<8> topology, HR > H (HR = Hex<8> root cell topology part)
233 // Part Q, rank 2, Quad<4> topology, QR > Q (QR = Quad<4> root cell topology part)
234 // Part W, rank 3, Wedge<6> topology, WR > W (WR = Wedge<6> root cell topology part)
235 // 1: Part A > HR -> Okay
236 // 2a: HR > QR -> Throw
237 // 2b: HR > A, B > QR, A > B -> Throw
238 // 3a: Subset has no cell topology and subset's subsets have no cell topology
239 // HR > A -> Okay
240 // 3b: Different rank cell topology on subset
241 // QR > D, HR > A, A > D -> Okay
242 // 3c: Different rank cell topology on subset's subset
243 // QR > C, B > C, HR > A, A > B -> Okay
244 // 4a: Subset has same cell topology
245 // HR > A, HR > B, A > B -> Okay
246 // 4b: Subset's subsets have same cell topology
247 // HR > C, B > C, HR > A, A > B -> Okay
248 // 5a: Subset has different cell topology
249 // WR > A, HR > B, A > B -> Throw
250 // 5b: Subset's subsets have different cell topology
251 // WR > E, B > E, HR > A, A > B -> Throw
252 // 5c: Multiple different cell topologies in subset's subsets
253 // HR > F, WR > E, B > F, B > E, HR > A, A > B -> Throw
254 
255 // 1: Part A > HR -> Okay
256 STKUNIT_UNIT_TEST( UnitTestFEMMetaData, cell_topology_test_1 )
257 {
259  const size_t spatial_dimension = 3;
260  fem_meta.FEM_initialize(spatial_dimension);
261  stk_classic::mesh::fem::CellTopology HR_top(shards::getCellTopologyData<shards::Hexahedron<8> >());
263 
264  stk_classic::mesh::Part & A = fem_meta.declare_part("Part A", fem_meta.element_rank() );
265 
266  fem_meta.declare_part_subset(A, HR);
267  const stk_classic::mesh::PartVector & HR_supersets = HR.supersets();
268  STKUNIT_EXPECT_EQUAL(
269  std::count(HR_supersets.begin(),HR_supersets.end(),&A), 1
270  );
271 }
272 
273 
274 // 2a: HR > QR -> Throw
275 STKUNIT_UNIT_TEST( UnitTestFEMMetaData, cell_topology_test_2a )
276 {
278  const size_t spatial_dimension = 3;
279  fem_meta.FEM_initialize(spatial_dimension);
280  stk_classic::mesh::fem::CellTopology HR_top(shards::getCellTopologyData<shards::Hexahedron<8> >());
281  stk_classic::mesh::fem::CellTopology QR_top(shards::getCellTopologyData<shards::Quadrilateral<4> >());
282 
285 
286  STKUNIT_ASSERT_THROW( fem_meta.declare_part_subset(HR, QR), std::runtime_error );
287 }
288 
289 
290 // 2b: HR > A, B > QR, A > B -> Throw
291 STKUNIT_UNIT_TEST( UnitTestFEMMetaData, cell_topology_test_2b )
292 {
294  const size_t spatial_dimension = 3;
295  fem_meta.FEM_initialize(spatial_dimension);
296 
297  stk_classic::mesh::Part & A = fem_meta.declare_part("Part A", fem_meta.element_rank() );
298  stk_classic::mesh::Part & B = fem_meta.declare_part("Part B", fem_meta.element_rank() );
299 
300  stk_classic::mesh::fem::CellTopology HR_top(shards::getCellTopologyData<shards::Hexahedron<8> >());
302 
303  stk_classic::mesh::fem::CellTopology QR_top(shards::getCellTopologyData<shards::Quadrilateral<4> >());
305 
306  fem_meta.declare_part_subset( HR, A );
307  fem_meta.declare_part_subset( B, QR );
308  STKUNIT_ASSERT_THROW( fem_meta.declare_part_subset(A, B), std::runtime_error );
309 }
310 
311 
312 // 3a: Subset has no cell topology and subset's subsets have no cell topology
313 // HR > A -> Okay
314 STKUNIT_UNIT_TEST( UnitTestFEMMetaData, cell_topology_test_3a )
315 {
317  const size_t spatial_dimension = 3;
318  fem_meta.FEM_initialize(spatial_dimension);
319 
320  stk_classic::mesh::Part & A = fem_meta.declare_part("Part A", fem_meta.element_rank() );
321 
322  stk_classic::mesh::fem::CellTopology HR_top(shards::getCellTopologyData<shards::Hexahedron<8> >());
324 
325  fem_meta.declare_part_subset( HR, A );
326 
327  const stk_classic::mesh::PartVector & A_supersets = A.supersets();
328  STKUNIT_EXPECT_EQUAL(
329  std::count(A_supersets.begin(),A_supersets.end(),&HR), 1
330  );
331 }
332 
333 
334 // 3b: Different rank cell topology on subset
335 // QR > D, HR > A, A > D -> Okay
336 STKUNIT_UNIT_TEST( UnitTestFEMMetaData, cell_topology_test_3b )
337 {
339  const size_t spatial_dimension = 3;
340  fem_meta.FEM_initialize(spatial_dimension);
341 
342  stk_classic::mesh::Part & A = fem_meta.declare_part("Part A", fem_meta.element_rank() );
343  stk_classic::mesh::Part & D = fem_meta.declare_part("Part D", fem_meta.side_rank() );
344 
345  stk_classic::mesh::fem::CellTopology HR_top(shards::getCellTopologyData<shards::Hexahedron<8> >());
347 
348  stk_classic::mesh::fem::CellTopology QR_top(shards::getCellTopologyData<shards::Quadrilateral<4> >());
350 
351  fem_meta.declare_part_subset( QR, D );
352  fem_meta.declare_part_subset( HR, A );
353  fem_meta.declare_part_subset( A, D );
354 
355  const stk_classic::mesh::PartVector & D_supersets = D.supersets();
356  STKUNIT_EXPECT_EQUAL(
357  std::count(D_supersets.begin(),D_supersets.end(),&A), 1
358  );
359 }
360 
361 
362 // 3c: Different rank cell topology on subset's subset
363 // QR > C, B > C, HR > A, A > B -> Okay
364 STKUNIT_UNIT_TEST( UnitTestFEMMetaData, cell_topology_test_3c )
365 {
367  const size_t spatial_dimension = 3;
368  fem_meta.FEM_initialize(spatial_dimension);
369 
370  stk_classic::mesh::Part & A = fem_meta.declare_part("Part A", fem_meta.element_rank() );
371  stk_classic::mesh::Part & B = fem_meta.declare_part("Part B", fem_meta.element_rank() );
372  stk_classic::mesh::Part & C = fem_meta.declare_part("Part C", fem_meta.side_rank() );
373 
374  stk_classic::mesh::fem::CellTopology HR_top(shards::getCellTopologyData<shards::Hexahedron<8> >());
376 
377  stk_classic::mesh::fem::CellTopology QR_top(shards::getCellTopologyData<shards::Quadrilateral<4> >());
379 
380  fem_meta.declare_part_subset( QR, C );
381  fem_meta.declare_part_subset( B, C );
382  fem_meta.declare_part_subset( HR, A );
383  fem_meta.declare_part_subset( A, B );
384 
385  const stk_classic::mesh::PartVector & B_supersets = B.supersets();
386  STKUNIT_EXPECT_EQUAL(
387  std::count(B_supersets.begin(),B_supersets.end(),&A), 1
388  );
389 }
390 
391 
392 // 4a: Subset has same cell topology
393 // HR > A, HR > B, A > B -> Okay
394 STKUNIT_UNIT_TEST( UnitTestFEMMetaData, cell_topology_test_4a )
395 {
397  const size_t spatial_dimension = 3;
398  fem_meta.FEM_initialize(spatial_dimension);
399 
400  stk_classic::mesh::Part & A = fem_meta.declare_part("Part A", fem_meta.element_rank() );
401  stk_classic::mesh::Part & B = fem_meta.declare_part("Part B", fem_meta.element_rank() );
402 
403  stk_classic::mesh::fem::CellTopology HR_top(shards::getCellTopologyData<shards::Hexahedron<8> >());
405 
406  fem_meta.declare_part_subset( HR, A );
407  fem_meta.declare_part_subset( HR, B );
408  fem_meta.declare_part_subset( A, B );
409 
410  const stk_classic::mesh::PartVector & B_supersets = B.supersets();
411  STKUNIT_EXPECT_EQUAL(
412  std::count(B_supersets.begin(),B_supersets.end(),&A), 1
413  );
414 }
415 
416 
417 // 4b: Subset's subsets have same cell topology
418 // HR > C, B > C, HR > A, A > B -> Okay
419 STKUNIT_UNIT_TEST( UnitTestFEMMetaData, cell_topology_test_4b )
420 {
422  const size_t spatial_dimension = 3;
423  fem_meta.FEM_initialize(spatial_dimension);
424 
425  stk_classic::mesh::Part & A = fem_meta.declare_part("Part A", fem_meta.element_rank() );
426  stk_classic::mesh::Part & B = fem_meta.declare_part("Part B", fem_meta.element_rank() );
427  stk_classic::mesh::Part & C = fem_meta.declare_part("Part C", fem_meta.side_rank() );
428 
429  stk_classic::mesh::fem::CellTopology HR_top(shards::getCellTopologyData<shards::Hexahedron<8> >());
431 
432  fem_meta.declare_part_subset( HR, C );
433  fem_meta.declare_part_subset( B, C );
434  fem_meta.declare_part_subset( HR, A );
435  fem_meta.declare_part_subset( A, B );
436 
437  const stk_classic::mesh::PartVector & B_supersets = B.supersets();
438  STKUNIT_EXPECT_EQUAL(
439  std::count(B_supersets.begin(),B_supersets.end(),&A), 1
440  );
441 }
442 
443 
444 // 5a: Subset has different cell topology
445 // WR > A, HR > B, A > B -> Throw
446 STKUNIT_UNIT_TEST( UnitTestFEMMetaData, cell_topology_test_5a )
447 {
449  const size_t spatial_dimension = 3;
450  fem_meta.FEM_initialize(spatial_dimension);
451 
452  stk_classic::mesh::Part & A = fem_meta.declare_part("Part A", fem_meta.element_rank() );
453  stk_classic::mesh::Part & B = fem_meta.declare_part("Part B", fem_meta.element_rank() );
454 
455  stk_classic::mesh::fem::CellTopology HR_top(shards::getCellTopologyData<shards::Hexahedron<8> >());
457 
458  stk_classic::mesh::fem::CellTopology WR_top(shards::getCellTopologyData<shards::Wedge<6> >());
460 
461  fem_meta.declare_part_subset( WR, A );
462  fem_meta.declare_part_subset( HR, B );
463  STKUNIT_ASSERT_THROW( fem_meta.declare_part_subset(A, B), std::runtime_error );
464 }
465 
466 
467 // 5b: Subset's subsets have different cell topology
468 // WR > E, B > E, HR > A, A > B -> Throw
469 STKUNIT_UNIT_TEST( UnitTestFEMMetaData, cell_topology_test_5b )
470 {
472  const size_t spatial_dimension = 3;
473  fem_meta.FEM_initialize(spatial_dimension);
474 
475  stk_classic::mesh::Part & A = fem_meta.declare_part("Part A", fem_meta.element_rank() );
476  stk_classic::mesh::Part & B = fem_meta.declare_part("Part B", fem_meta.element_rank() );
477  stk_classic::mesh::Part & E = fem_meta.declare_part("Part E", fem_meta.element_rank() );
478 
479  stk_classic::mesh::fem::CellTopology HR_top(shards::getCellTopologyData<shards::Hexahedron<8> >());
481 
482  stk_classic::mesh::fem::CellTopology WR_top(shards::getCellTopologyData<shards::Wedge<6> >());
484 
485  fem_meta.declare_part_subset( WR, E );
486  stk_classic::mesh::fem::CellTopology top = fem_meta.get_cell_topology(E);
487  STKUNIT_ASSERT_TRUE( top.isValid() );
488  fem_meta.declare_part_subset( B, E );
489  fem_meta.declare_part_subset( HR, A );
490  STKUNIT_ASSERT_THROW( fem_meta.declare_part_subset(A, B), std::runtime_error );
491 }
492 
493 
494 // 5c: Multiple different cell topologies in subset's subsets
495 // HR > F, WR > E, B > F, B > E, HR > A, A > B -> Throw
496 STKUNIT_UNIT_TEST( UnitTestFEMMetaData, cell_topology_test_5c )
497 {
499  const size_t spatial_dimension = 3;
500  fem_meta.FEM_initialize(spatial_dimension);
501 
502  stk_classic::mesh::Part & A = fem_meta.declare_part("Part A", fem_meta.element_rank() );
503  stk_classic::mesh::Part & B = fem_meta.declare_part("Part B", fem_meta.element_rank() );
504  stk_classic::mesh::Part & F = fem_meta.declare_part("Part F", fem_meta.element_rank() );
505  stk_classic::mesh::Part & E = fem_meta.declare_part("Part E", fem_meta.element_rank() );
506 
507  stk_classic::mesh::fem::CellTopology HR_top(shards::getCellTopologyData<shards::Hexahedron<8> >());
509 
510  stk_classic::mesh::fem::CellTopology WR_top(shards::getCellTopologyData<shards::Wedge<6> >());
512 
513  fem_meta.declare_part_subset( HR, F );
514  fem_meta.declare_part_subset( WR, E );
515  fem_meta.declare_part_subset( B, F );
516  fem_meta.declare_part_subset( B, E );
517  fem_meta.declare_part_subset( HR, A );
518  STKUNIT_ASSERT_THROW( fem_meta.declare_part_subset(A, B), std::runtime_error );
519 }
520 
521 
522 
523 
524 
525 STKUNIT_UNIT_TEST( FEMMetaData, register_cell_topology_duplicate )
526 {
528  const size_t spatial_dimension = 2;
529  fem_meta.FEM_initialize(spatial_dimension);
530  const stk_classic::mesh::EntityRank hex_rank = 2;
531 
532  fem_meta.register_cell_topology( shards::getCellTopologyData<shards::Hexahedron<8> >(), hex_rank );
533  STKUNIT_ASSERT_NO_THROW( fem_meta.register_cell_topology( shards::getCellTopologyData<shards::Hexahedron<8> >(), hex_rank ) );
534 }
535 
536 
537 STKUNIT_UNIT_TEST( FEMMetaData, register_cell_topology_duplicate_with_different_ranks )
538 {
540  const size_t spatial_dimension = 2;
541  fem_meta.FEM_initialize(spatial_dimension);
542  const stk_classic::mesh::EntityRank hex_rank = 2;
543  const stk_classic::mesh::EntityRank bad_rank = 1;
544 
545  fem_meta.register_cell_topology( shards::getCellTopologyData<shards::Hexahedron<8> >(), hex_rank );
546  STKUNIT_ASSERT_THROW( fem_meta.register_cell_topology( shards::getCellTopologyData<shards::Hexahedron<8> >(), bad_rank ), std::runtime_error );
547 }
548 
549 
550 STKUNIT_UNIT_TEST( FEMMetaData, register_cell_topology_duplicate_with_invalid_rank )
551 {
553  const size_t spatial_dimension = 2;
554  fem_meta.FEM_initialize(spatial_dimension);
555  const stk_classic::mesh::EntityRank invalid_rank = 3;
556 
557  STKUNIT_ASSERT_THROW( fem_meta.register_cell_topology( shards::getCellTopologyData<shards::Hexahedron<8> >(), invalid_rank ), std::logic_error );
558 }
559 
560 
561 STKUNIT_UNIT_TEST( FEMMetaData, get_cell_topology_root_part_invalid )
562 {
564  const size_t spatial_dimension = 2;
565  fem_meta.FEM_initialize(spatial_dimension);
566 
567  stk_classic::mesh::fem::CellTopology hex_top(shards::getCellTopologyData<shards::Hexahedron<8> >());
568 
569  STKUNIT_ASSERT_THROW( fem_meta.get_cell_topology_root_part( hex_top ), std::runtime_error );
570 }
571 
572 
573 STKUNIT_UNIT_TEST( FEMMetaData, get_entity_rank_invalid )
574 {
576  const size_t spatial_dimension = 2;
577  fem_meta.FEM_initialize(spatial_dimension);
578 
579  stk_classic::mesh::fem::CellTopology hex_top(shards::getCellTopologyData<shards::Hexahedron<8> >());
580  stk_classic::mesh::EntityRank rank = fem_meta.get_entity_rank(hex_top);
581 
582  const stk_classic::mesh::EntityRank invalid_rank = INVALID_RANK;
583  STKUNIT_ASSERT_EQUAL( rank, invalid_rank );
584 }
585 
EntityRank face_rank() const
Returns the face rank which changes depending on spatial dimension.
FEMMetaData is a class that implements a Finite Element Method skin on top of the Sierra Tool Kit Met...
Definition: FEMMetaData.hpp:54
EntityRank side_rank() const
Returns the side rank which changes depending on spatial dimension.
EntityRank element_rank() const
Returns the element rank which is always equal to spatial dimension.
void register_cell_topology(const fem::CellTopology cell_topology, EntityRank in_entity_rank)
This function is used to register new cell topologies and their associated ranks with FEMMetaData...
Part & universal_part() const
Universal subset for the problem domain. All other parts are a subset of the universal part...
unsigned primary_entity_rank() const
The primary entity type for this part.
Definition: Part.hpp:64
An application-defined subset of a problem domain.
Definition: Part.hpp:49
bool is_FEM_initialized() const
This function returns whether this class has been initialized or not.
Part & declare_part(const std::string &name, fem::CellTopology cell_topology)
Declare a part with a given cell topology.
Part & get_cell_topology_root_part(const fem::CellTopology cell_topology) const
Return the root cell topology part associated with the given cell topology. This Part is created in r...
void declare_part_subset(Part &superset, Part &subset)
Declare a superset-subset relationship between parts Note: Cell Topologies are induced through part s...
const PartVector & supersets() const
Parts that are supersets of this part.
Definition: Part.hpp:75
EntityRank edge_rank() const
Returns the edge rank which changes depending on spatial dimension.
size_t spatial_dimension() const
Returns the spatial dimension that was passed in through FEM_initialize.
EntityRank get_entity_rank(const fem::CellTopology cell_topology) const
Return the EntityRank that is associated with the given cell topology. In several cases...
EntityRank node_rank() const
Returns the node rank, which is always zero.
std::vector< Part *> PartVector
Collections of parts are frequently maintained as a vector of Part pointers.
Definition: Types.hpp:31
fem::CellTopology get_cell_topology(const Part &part) const
Return the cell topology associated with the given part. The cell topology is set on a part through p...
void FEM_initialize(size_t spatial_dimension, const std::vector< std::string > &in_entity_rank_names=std::vector< std::string >())
Initialize the spatial dimension and an optional list of entity rank names associated with each rank...
Definition: FEMMetaData.cpp:61