1 /*****************************************************************************/
2 /* XDMF */
3 /* eXtensible Data Model and Format */
4 /* */
5 /* Id : XdmfTopologyType.cpp */
6 /* */
7 /* Author: */
8 /* Kenneth Leiter */
9 /* kenneth.leiter@arl.army.mil */
10 /* US Army Research Laboratory */
11 /* Aberdeen Proving Ground, MD */
12 /* */
13 /* Copyright @ 2011 US Army Research Laboratory */
14 /* All Rights Reserved */
15 /* See Copyright.txt for details */
16 /* */
17 /* This software is distributed WITHOUT ANY WARRANTY; without */
18 /* even the implied warranty of MERCHANTABILITY or FITNESS */
19 /* FOR A PARTICULAR PURPOSE. See the above copyright notice */
20 /* for more information. */
21 /* */
22 /*****************************************************************************/
23
24 #include <cctype>
25 #include <sstream>
26 #include <utility>
27 #include "XdmfError.hpp"
28 #include "XdmfTopologyType.hpp"
29
30 // Supported XdmfTopologyTypes
31 shared_ptr<const XdmfTopologyType>
NoTopologyType()32 XdmfTopologyType::NoTopologyType()
33 {
34 std::vector<shared_ptr<const XdmfTopologyType> > faces;
35 static shared_ptr<const XdmfTopologyType>
36 p(new XdmfTopologyType(0, 0, faces, 0, "NoTopology", NoCellType, 0x0));
37 return p;
38 }
39
40 shared_ptr<const XdmfTopologyType>
Polyvertex()41 XdmfTopologyType::Polyvertex()
42 {
43 std::vector<shared_ptr<const XdmfTopologyType> > faces;
44 faces.push_back(XdmfTopologyType::NoTopologyType());
45 static shared_ptr<const XdmfTopologyType>
46 p(new XdmfTopologyType(1, 0, faces, 0, "Polyvertex", Linear, 0x1));
47 return p;
48 }
49
50 shared_ptr<const XdmfTopologyType>
Polyline(const unsigned int nodesPerElement)51 XdmfTopologyType::Polyline(const unsigned int nodesPerElement)
52 {
53 std::vector<shared_ptr<const XdmfTopologyType> > faces;
54 faces.push_back(XdmfTopologyType::NoTopologyType());
55 static std::map<unsigned int, shared_ptr<const XdmfTopologyType> >
56 previousTypes;
57 std::map<unsigned int, shared_ptr<const XdmfTopologyType> >::const_iterator
58 type = previousTypes.find(nodesPerElement);
59 if(type != previousTypes.end()) {
60 return type->second;
61 }
62 shared_ptr<const XdmfTopologyType>
63 p(new XdmfTopologyType(nodesPerElement, 0, faces, nodesPerElement - 1,
64 "Polyline", Linear, 0x2));
65 previousTypes[nodesPerElement] = p;
66 return p;
67 }
68
69 shared_ptr<const XdmfTopologyType>
Polygon(const unsigned int nodesPerElement)70 XdmfTopologyType::Polygon(const unsigned int nodesPerElement)
71 {
72 std::vector<shared_ptr<const XdmfTopologyType> > faces;
73 faces.push_back(XdmfTopologyType::NoTopologyType());
74 static std::map<unsigned int, shared_ptr<const XdmfTopologyType> >
75 previousTypes;
76 std::map<unsigned int, shared_ptr<const XdmfTopologyType> >::const_iterator
77 type = previousTypes.find(nodesPerElement);
78 if(type != previousTypes.end()) {
79 return type->second;
80 }
81 shared_ptr<const XdmfTopologyType>
82 p(new XdmfTopologyType(nodesPerElement, 1, faces, nodesPerElement,
83 "Polygon", Linear, 0x3));
84 previousTypes[nodesPerElement] = p;
85 return p;
86 }
87
88 shared_ptr<const XdmfTopologyType>
Triangle()89 XdmfTopologyType::Triangle()
90 {
91 std::vector<shared_ptr<const XdmfTopologyType> > faces;
92 faces.push_back(XdmfTopologyType::NoTopologyType());
93 static shared_ptr<const XdmfTopologyType>
94 p(new XdmfTopologyType(3, 1, faces, 3, "Triangle", Linear, 0x4));
95 return p;
96 }
97
98 shared_ptr<const XdmfTopologyType>
Quadrilateral()99 XdmfTopologyType::Quadrilateral()
100 {
101 std::vector<shared_ptr<const XdmfTopologyType> > faces;
102 faces.push_back(XdmfTopologyType::NoTopologyType());
103 static shared_ptr<const XdmfTopologyType>
104 p(new XdmfTopologyType(4, 1, faces, 4, "Quadrilateral", Linear, 0x5));
105 return p;
106 }
107
108 shared_ptr<const XdmfTopologyType>
Tetrahedron()109 XdmfTopologyType::Tetrahedron()
110 {
111 std::vector<shared_ptr<const XdmfTopologyType> > faces;
112 faces.push_back(XdmfTopologyType::Triangle());
113 static shared_ptr<const XdmfTopologyType>
114 p(new XdmfTopologyType(4, 4, faces, 6, "Tetrahedron", Linear, 0x6));
115 return p;
116 }
117
118 shared_ptr<const XdmfTopologyType>
Pyramid()119 XdmfTopologyType::Pyramid()
120 {
121 std::vector<shared_ptr<const XdmfTopologyType> > faces;
122 faces.push_back(XdmfTopologyType::NoTopologyType());
123 static shared_ptr<const XdmfTopologyType>
124 p(new XdmfTopologyType(5, 5, faces, 8, "Pyramid", Linear, 0x7));
125 return p;
126 }
127
128 shared_ptr<const XdmfTopologyType>
Wedge()129 XdmfTopologyType::Wedge()
130 {
131 std::vector<shared_ptr<const XdmfTopologyType> > faces;
132 faces.push_back(XdmfTopologyType::NoTopologyType());
133 static shared_ptr<const XdmfTopologyType>
134 p(new XdmfTopologyType(6, 5, faces, 9, "Wedge", Linear, 0x8));
135 return p;
136 }
137
138 shared_ptr<const XdmfTopologyType>
Hexahedron()139 XdmfTopologyType::Hexahedron()
140 {
141 std::vector<shared_ptr<const XdmfTopologyType> > faces;
142 faces.push_back(XdmfTopologyType::Quadrilateral());
143 static shared_ptr<const XdmfTopologyType>
144 p(new XdmfTopologyType(8, 6, faces, 12, "Hexahedron", Linear, 0x9));
145 return p;
146 }
147
148 shared_ptr<const XdmfTopologyType>
Edge_3()149 XdmfTopologyType::Edge_3()
150 {
151 std::vector<shared_ptr<const XdmfTopologyType> > faces;
152 faces.push_back(XdmfTopologyType::NoTopologyType());
153 static shared_ptr<const XdmfTopologyType>
154 p(new XdmfTopologyType(3, 0, faces, 1, "Edge_3", Quadratic, 0x22));
155 return p;
156 }
157
158 shared_ptr<const XdmfTopologyType>
Triangle_6()159 XdmfTopologyType::Triangle_6()
160 {
161 std::vector<shared_ptr<const XdmfTopologyType> > faces;
162 faces.push_back(XdmfTopologyType::NoTopologyType());
163 static shared_ptr<const XdmfTopologyType>
164 p(new XdmfTopologyType(6, 1, faces, 3, "Triangle_6", Quadratic, 0x24));
165 return p;
166 }
167
168 shared_ptr<const XdmfTopologyType>
Quadrilateral_8()169 XdmfTopologyType::Quadrilateral_8()
170 {
171 std::vector<shared_ptr<const XdmfTopologyType> > faces;
172 faces.push_back(XdmfTopologyType::NoTopologyType());
173 static shared_ptr<const XdmfTopologyType>
174 p(new XdmfTopologyType(8, 1, faces, 4, "Quadrilateral_8", Quadratic, 0x25));
175 return p;
176 }
177
178 shared_ptr<const XdmfTopologyType>
Quadrilateral_9()179 XdmfTopologyType::Quadrilateral_9()
180 {
181 std::vector<shared_ptr<const XdmfTopologyType> > faces;
182 faces.push_back(XdmfTopologyType::NoTopologyType());
183 static shared_ptr<const XdmfTopologyType>
184 p(new XdmfTopologyType(9, 1, faces, 4, "Quadrilateral_9", Quadratic, 0x23));
185 return p;
186 }
187
188 shared_ptr<const XdmfTopologyType>
Tetrahedron_10()189 XdmfTopologyType::Tetrahedron_10()
190 {
191 std::vector<shared_ptr<const XdmfTopologyType> > faces;
192 faces.push_back(XdmfTopologyType::NoTopologyType());
193 faces.push_back(XdmfTopologyType::Triangle_6());
194 static shared_ptr<const XdmfTopologyType>
195 p(new XdmfTopologyType(10, 4, faces, 6, "Tetrahedron_10", Quadratic, 0x26));
196 return p;
197 }
198
199 shared_ptr<const XdmfTopologyType>
Pyramid_13()200 XdmfTopologyType::Pyramid_13()
201 {
202 std::vector<shared_ptr<const XdmfTopologyType> > faces;
203 faces.push_back(XdmfTopologyType::NoTopologyType());
204 static shared_ptr<const XdmfTopologyType>
205 p(new XdmfTopologyType(13, 5, faces, 8, "Pyramid_13", Quadratic, 0x27));
206 return p;
207 }
208
209 shared_ptr<const XdmfTopologyType>
Wedge_15()210 XdmfTopologyType::Wedge_15()
211 {
212 std::vector<shared_ptr<const XdmfTopologyType> > faces;
213 faces.push_back(XdmfTopologyType::NoTopologyType());
214 static shared_ptr<const XdmfTopologyType>
215 p(new XdmfTopologyType(15, 5, faces, 9, "Wedge_15", Quadratic, 0x28));
216 return p;
217 }
218
219 shared_ptr<const XdmfTopologyType>
Wedge_18()220 XdmfTopologyType::Wedge_18()
221 {
222 std::vector<shared_ptr<const XdmfTopologyType> > faces;
223 faces.push_back(XdmfTopologyType::NoTopologyType());
224 static shared_ptr<const XdmfTopologyType>
225 p(new XdmfTopologyType(18, 5, faces, 9, "Wedge_18", Quadratic, 0x29));
226 return p;
227 }
228
229 shared_ptr<const XdmfTopologyType>
Hexahedron_20()230 XdmfTopologyType::Hexahedron_20()
231 {
232 std::vector<shared_ptr<const XdmfTopologyType> > faces;
233 faces.push_back(XdmfTopologyType::Quadrilateral_8());
234 static shared_ptr<const XdmfTopologyType>
235 p(new XdmfTopologyType(20, 6, faces, 12, "Hexahedron_20", Quadratic, 0x30));
236 return p;
237 }
238
239 shared_ptr<const XdmfTopologyType>
Hexahedron_24()240 XdmfTopologyType::Hexahedron_24()
241 {
242 std::vector<shared_ptr<const XdmfTopologyType> > faces;
243 faces.push_back(XdmfTopologyType::NoTopologyType());
244 static shared_ptr<const XdmfTopologyType>
245 p(new XdmfTopologyType(24, 6, faces, 12, "Hexahedron_24", Quadratic, 0x31));
246 return p;
247 }
248
249 shared_ptr<const XdmfTopologyType>
Hexahedron_27()250 XdmfTopologyType::Hexahedron_27()
251 {
252 std::vector<shared_ptr<const XdmfTopologyType> > faces;
253 faces.push_back(XdmfTopologyType::Quadrilateral_9());
254 static shared_ptr<const XdmfTopologyType>
255 p(new XdmfTopologyType(27, 6, faces, 12, "Hexahedron_27", Quadratic, 0x32));
256 return p;
257 }
258
259 shared_ptr<const XdmfTopologyType>
Hexahedron_64()260 XdmfTopologyType::Hexahedron_64()
261 {
262 std::vector<shared_ptr<const XdmfTopologyType> > faces;
263 faces.push_back(XdmfTopologyType::NoTopologyType());
264 static shared_ptr<const XdmfTopologyType>
265 p(new XdmfTopologyType(64, 6, faces, 12, "Hexahedron_64", Cubic, 0x33));
266 return p;
267 }
268
269 shared_ptr<const XdmfTopologyType>
Hexahedron_125()270 XdmfTopologyType::Hexahedron_125()
271 {
272 std::vector<shared_ptr<const XdmfTopologyType> > faces;
273 faces.push_back(XdmfTopologyType::NoTopologyType());
274 static shared_ptr<const XdmfTopologyType>
275 p(new XdmfTopologyType(125, 6, faces, 12, "Hexahedron_125", Quartic, 0x34));
276 return p;
277 }
278
279 shared_ptr<const XdmfTopologyType>
Hexahedron_216()280 XdmfTopologyType::Hexahedron_216()
281 {
282 std::vector<shared_ptr<const XdmfTopologyType> > faces;
283 faces.push_back(XdmfTopologyType::NoTopologyType());
284 static shared_ptr<const XdmfTopologyType>
285 p(new XdmfTopologyType(216, 6, faces, 12, "Hexahedron_216", Quintic, 0x35));
286 return p;
287 }
288
289
290 shared_ptr<const XdmfTopologyType>
Hexahedron_343()291 XdmfTopologyType::Hexahedron_343()
292 {
293 std::vector<shared_ptr<const XdmfTopologyType> > faces;
294 faces.push_back(XdmfTopologyType::NoTopologyType());
295 static shared_ptr<const XdmfTopologyType>
296 p(new XdmfTopologyType(343, 6, faces, 12, "Hexahedron_343", Sextic, 0x36));
297 return p;
298 }
299
300
301 shared_ptr<const XdmfTopologyType>
Hexahedron_512()302 XdmfTopologyType::Hexahedron_512()
303 {
304 std::vector<shared_ptr<const XdmfTopologyType> > faces;
305 faces.push_back(XdmfTopologyType::NoTopologyType());
306 static shared_ptr<const XdmfTopologyType>
307 p(new XdmfTopologyType(512, 6, faces, 12, "Hexahedron_512", Septic, 0x37));
308 return p;
309 }
310
311
312 shared_ptr<const XdmfTopologyType>
Hexahedron_729()313 XdmfTopologyType::Hexahedron_729()
314 {
315 std::vector<shared_ptr<const XdmfTopologyType> > faces;
316 faces.push_back(XdmfTopologyType::NoTopologyType());
317 static shared_ptr<const XdmfTopologyType>
318 p(new XdmfTopologyType(729, 6, faces, 12, "Hexahedron_729", Octic, 0x38));
319 return p;
320 }
321
322
323 shared_ptr<const XdmfTopologyType>
Hexahedron_1000()324 XdmfTopologyType::Hexahedron_1000()
325 {
326 std::vector<shared_ptr<const XdmfTopologyType> > faces;
327 faces.push_back(XdmfTopologyType::NoTopologyType());
328 static shared_ptr<const XdmfTopologyType>
329 p(new XdmfTopologyType(1000, 6, faces, 12, "Hexahedron_1000", Nonic, 0x39));
330 return p;
331 }
332
333 shared_ptr<const XdmfTopologyType>
Hexahedron_1331()334 XdmfTopologyType::Hexahedron_1331()
335 {
336 std::vector<shared_ptr<const XdmfTopologyType> > faces;
337 faces.push_back(XdmfTopologyType::NoTopologyType());
338 static shared_ptr<const XdmfTopologyType>
339 p(new XdmfTopologyType(1331, 6, faces, 12, "Hexahedron_1331", Decic, 0x40));
340 return p;
341 }
342
343 shared_ptr<const XdmfTopologyType>
Hexahedron_Spectral_64()344 XdmfTopologyType::Hexahedron_Spectral_64()
345 {
346 std::vector<shared_ptr<const XdmfTopologyType> > faces;
347 faces.push_back(XdmfTopologyType::NoTopologyType());
348 static shared_ptr<const XdmfTopologyType>
349 p(new XdmfTopologyType(64, 6, faces, 12, "Hexahedron_Spectral_64", Cubic, 0x41));
350 return p;
351 }
352
353 shared_ptr<const XdmfTopologyType>
Hexahedron_Spectral_125()354 XdmfTopologyType::Hexahedron_Spectral_125()
355 {
356 std::vector<shared_ptr<const XdmfTopologyType> > faces;
357 faces.push_back(XdmfTopologyType::NoTopologyType());
358 static shared_ptr<const XdmfTopologyType>
359 p(new XdmfTopologyType(125, 6, faces, 12,
360 "Hexahedron_Spectral_125", Quartic, 0x42));
361 return p;
362 }
363
364 shared_ptr<const XdmfTopologyType>
Hexahedron_Spectral_216()365 XdmfTopologyType::Hexahedron_Spectral_216()
366 {
367 std::vector<shared_ptr<const XdmfTopologyType> > faces;
368 faces.push_back(XdmfTopologyType::NoTopologyType());
369 static shared_ptr<const XdmfTopologyType>
370 p(new XdmfTopologyType(216, 6, faces, 12,
371 "Hexahedron_Spectral_216", Quintic, 0x43));
372 return p;
373 }
374
375
376 shared_ptr<const XdmfTopologyType>
Hexahedron_Spectral_343()377 XdmfTopologyType::Hexahedron_Spectral_343()
378 {
379 std::vector<shared_ptr<const XdmfTopologyType> > faces;
380 faces.push_back(XdmfTopologyType::NoTopologyType());
381 static shared_ptr<const XdmfTopologyType>
382 p(new XdmfTopologyType(343, 6, faces, 12,
383 "Hexahedron_Spectral_343", Sextic, 0x44));
384 return p;
385 }
386
387
388 shared_ptr<const XdmfTopologyType>
Hexahedron_Spectral_512()389 XdmfTopologyType::Hexahedron_Spectral_512()
390 {
391 std::vector<shared_ptr<const XdmfTopologyType> > faces;
392 faces.push_back(XdmfTopologyType::NoTopologyType());
393 static shared_ptr<const XdmfTopologyType>
394 p(new XdmfTopologyType(512, 6, faces, 12,
395 "Hexahedron_Spectral_512", Septic, 0x45));
396 return p;
397 }
398
399
400 shared_ptr<const XdmfTopologyType>
Hexahedron_Spectral_729()401 XdmfTopologyType::Hexahedron_Spectral_729()
402 {
403 std::vector<shared_ptr<const XdmfTopologyType> > faces;
404 faces.push_back(XdmfTopologyType::NoTopologyType());
405 static shared_ptr<const XdmfTopologyType>
406 p(new XdmfTopologyType(729, 6, faces, 12,
407 "Hexahedron_Spectral_729", Octic, 0x46));
408 return p;
409 }
410
411
412 shared_ptr<const XdmfTopologyType>
Hexahedron_Spectral_1000()413 XdmfTopologyType::Hexahedron_Spectral_1000()
414 {
415 std::vector<shared_ptr<const XdmfTopologyType> > faces;
416 faces.push_back(XdmfTopologyType::NoTopologyType());
417 static shared_ptr<const XdmfTopologyType>
418 p(new XdmfTopologyType(1000, 6, faces, 12,
419 "Hexahedron_Spectral_1000", Nonic, 0x47));
420 return p;
421 }
422
423 shared_ptr<const XdmfTopologyType>
Hexahedron_Spectral_1331()424 XdmfTopologyType::Hexahedron_Spectral_1331()
425 {
426 std::vector<shared_ptr<const XdmfTopologyType> > faces;
427 faces.push_back(XdmfTopologyType::NoTopologyType());
428 static shared_ptr<const XdmfTopologyType>
429 p(new XdmfTopologyType(1331, 6, faces, 12,
430 "Hexahedron_Spectral_1331", Decic, 0x48));
431 return p;
432 }
433
434 shared_ptr<const XdmfTopologyType>
Mixed()435 XdmfTopologyType::Mixed()
436 {
437 std::vector<shared_ptr<const XdmfTopologyType> > faces;
438 static shared_ptr<const XdmfTopologyType>
439 p(new XdmfTopologyType(0, 0, faces, 0, "Mixed", Arbitrary, 0x70));
440 return p;
441 }
442
443 shared_ptr<const XdmfTopologyType>
New(const unsigned int id)444 XdmfTopologyType::New(const unsigned int id)
445 {
446 if(id == XdmfTopologyType::NoTopologyType()->getID()) {
447 return XdmfTopologyType::NoTopologyType();
448 }
449 else if(id == XdmfTopologyType::Polyvertex()->getID()) {
450 return XdmfTopologyType::Polyvertex();
451 }
452 else if(id == XdmfTopologyType::Polyline(0)->getID()) {
453 return XdmfTopologyType::Polyline(0);
454 }
455 else if(id == XdmfTopologyType::Polygon(0)->getID()) {
456 return XdmfTopologyType::Polygon(0);
457 }
458 else if(id == XdmfTopologyType::Triangle()->getID()) {
459 return XdmfTopologyType::Triangle();
460 }
461 else if(id == XdmfTopologyType::Quadrilateral()->getID()) {
462 return XdmfTopologyType::Quadrilateral();
463 }
464 else if(id == XdmfTopologyType::Tetrahedron()->getID()) {
465 return XdmfTopologyType::Tetrahedron();
466 }
467 else if(id == XdmfTopologyType::Pyramid()->getID()) {
468 return XdmfTopologyType::Pyramid();
469 }
470 else if(id == XdmfTopologyType::Wedge()->getID()) {
471 return XdmfTopologyType::Wedge();
472 }
473 else if(id == XdmfTopologyType::Hexahedron()->getID()) {
474 return XdmfTopologyType::Hexahedron();
475 }
476 else if(id == XdmfTopologyType::Edge_3()->getID()) {
477 return XdmfTopologyType::Edge_3();
478 }
479 else if(id == XdmfTopologyType::Triangle_6()->getID()) {
480 return XdmfTopologyType::Triangle_6();
481 }
482 else if(id == XdmfTopologyType::Quadrilateral_8()->getID()) {
483 return XdmfTopologyType::Quadrilateral_8();
484 }
485 else if(id == XdmfTopologyType::Quadrilateral_9()->getID()) {
486 return XdmfTopologyType::Quadrilateral_9();
487 }
488 else if(id == XdmfTopologyType::Tetrahedron_10()->getID()) {
489 return XdmfTopologyType::Tetrahedron_10();
490 }
491 else if(id == XdmfTopologyType::Pyramid_13()->getID()) {
492 return XdmfTopologyType::Pyramid_13();
493 }
494 else if(id == XdmfTopologyType::Wedge_15()->getID()) {
495 return XdmfTopologyType::Wedge_15();
496 }
497 else if(id == XdmfTopologyType::Wedge_18()->getID()) {
498 return XdmfTopologyType::Wedge_18();
499 }
500 else if(id == XdmfTopologyType::Hexahedron_20()->getID()) {
501 return XdmfTopologyType::Hexahedron_20();
502 }
503 else if(id == XdmfTopologyType::Hexahedron_24()->getID()) {
504 return XdmfTopologyType::Hexahedron_24();
505 }
506 else if(id == XdmfTopologyType::Hexahedron_27()->getID()) {
507 return XdmfTopologyType::Hexahedron_27();
508 }
509 else if(id == XdmfTopologyType::Hexahedron_64()->getID()) {
510 return XdmfTopologyType::Hexahedron_64();
511 }
512 else if(id == XdmfTopologyType::Hexahedron_125()->getID()) {
513 return XdmfTopologyType::Hexahedron_125();
514 }
515 else if(id == XdmfTopologyType::Hexahedron_216()->getID()) {
516 return XdmfTopologyType::Hexahedron_216();
517 }
518 else if(id == XdmfTopologyType::Hexahedron_343()->getID()) {
519 return XdmfTopologyType::Hexahedron_343();
520 }
521 else if(id == XdmfTopologyType::Hexahedron_512()->getID()) {
522 return XdmfTopologyType::Hexahedron_512();
523 }
524 else if(id == XdmfTopologyType::Hexahedron_729()->getID()) {
525 return XdmfTopologyType::Hexahedron_729();
526 }
527 else if(id == XdmfTopologyType::Hexahedron_1000()->getID()) {
528 return XdmfTopologyType::Hexahedron_1000();
529 }
530 else if(id == XdmfTopologyType::Hexahedron_1331()->getID()) {
531 return XdmfTopologyType::Hexahedron_1331();
532 }
533 else if(id == XdmfTopologyType::Hexahedron_Spectral_64()->getID()) {
534 return XdmfTopologyType::Hexahedron_Spectral_64();
535 }
536 else if(id == XdmfTopologyType::Hexahedron_Spectral_125()->getID()) {
537 return XdmfTopologyType::Hexahedron_Spectral_125();
538 }
539 else if(id == XdmfTopologyType::Hexahedron_Spectral_216()->getID()) {
540 return XdmfTopologyType::Hexahedron_Spectral_216();
541 }
542 else if(id == XdmfTopologyType::Hexahedron_Spectral_343()->getID()) {
543 return XdmfTopologyType::Hexahedron_Spectral_343();
544 }
545 else if(id == XdmfTopologyType::Hexahedron_Spectral_512()->getID()) {
546 return XdmfTopologyType::Hexahedron_Spectral_512();
547 }
548 else if(id == XdmfTopologyType::Hexahedron_Spectral_729()->getID()) {
549 return XdmfTopologyType::Hexahedron_Spectral_729();
550 }
551 else if(id == XdmfTopologyType::Hexahedron_Spectral_1000()->getID()) {
552 return XdmfTopologyType::Hexahedron_Spectral_1000();
553 }
554 else if(id == XdmfTopologyType::Hexahedron_Spectral_1331()->getID()) {
555 return XdmfTopologyType::Hexahedron_Spectral_1331();
556 }
557 else if(id == XdmfTopologyType::Mixed()->getID()) {
558 return XdmfTopologyType::Mixed();
559 }
560 return shared_ptr<const XdmfTopologyType>();
561 }
562
XdmfTopologyType(const unsigned int nodesPerElement,const unsigned int facesPerElement,const std::vector<shared_ptr<const XdmfTopologyType>> & faces,const unsigned int edgesPerElement,const std::string & name,const CellType cellType,const unsigned int id)563 XdmfTopologyType::XdmfTopologyType(const unsigned int nodesPerElement,
564 const unsigned int facesPerElement,
565 const std::vector<shared_ptr<const XdmfTopologyType> > & faces,
566 const unsigned int edgesPerElement,
567 const std::string & name,
568 const CellType cellType,
569 const unsigned int id) :
570 mCellType(cellType),
571 mEdgesPerElement(edgesPerElement),
572 mFacesPerElement(facesPerElement),
573 mFaces(faces),
574 mID(id),
575 mName(name),
576 mNodesPerElement(nodesPerElement)
577 {
578 }
579
~XdmfTopologyType()580 XdmfTopologyType::~XdmfTopologyType()
581 {
582 }
583
584 shared_ptr<const XdmfTopologyType>
New(const std::map<std::string,std::string> & itemProperties)585 XdmfTopologyType::New(const std::map<std::string, std::string> & itemProperties)
586 {
587 std::map<std::string, std::string>::const_iterator type =
588 itemProperties.find("Type");
589 if(type == itemProperties.end()) {
590 type = itemProperties.find("TopologyType");
591 }
592 if(type == itemProperties.end()) {
593 XdmfError::message(XdmfError::FATAL,
594 "Neither 'Type' nor 'TopologyType' found in "
595 "itemProperties in XdmfTopologyType::New");
596 }
597 std::string typeVal = type->second;
598 std::transform(typeVal.begin(),
599 typeVal.end(),
600 typeVal.begin(),
601 (int(*)(int))toupper);
602
603 std::map<std::string, std::string>::const_iterator nodesPerElement =
604 itemProperties.find("NodesPerElement");
605
606 if(typeVal.compare("NOTOPOLOGY") == 0) {
607 return NoTopologyType();
608 }
609 else if(typeVal.compare("POLYVERTEX") == 0) {
610 return Polyvertex();
611 }
612 else if(typeVal.compare("POLYLINE") == 0) {
613 if(nodesPerElement != itemProperties.end()) {
614 return Polyline(atoi(nodesPerElement->second.c_str()));
615 }
616 XdmfError::message(XdmfError::FATAL,
617 "'NodesPerElement' not in itemProperties and type "
618 "'POLYLINE' selected in XdmfTopologyType::New");
619 }
620 else if(typeVal.compare("POLYGON") == 0) {
621 if(nodesPerElement != itemProperties.end()) {
622 return Polygon(atoi(nodesPerElement->second.c_str()));
623 }
624 XdmfError::message(XdmfError::FATAL,
625 "'NodesPerElement' not in itemProperties and type "
626 "'POLYGON' selected in XdmfTopologyType::New");
627 }
628 else if(typeVal.compare("TRIANGLE") == 0) {
629 return Triangle();
630 }
631 else if(typeVal.compare("QUADRILATERAL") == 0) {
632 return Quadrilateral();
633 }
634 else if(typeVal.compare("TETRAHEDRON") == 0) {
635 return Tetrahedron();
636 }
637 else if(typeVal.compare("PYRAMID") == 0) {
638 return Pyramid();
639 }
640 else if(typeVal.compare("WEDGE") == 0) {
641 return Wedge();
642 }
643 else if(typeVal.compare("HEXAHEDRON") == 0) {
644 return Hexahedron();
645 }
646 else if(typeVal.compare("EDGE_3") == 0) {
647 return Edge_3();
648 }
649 else if(typeVal.compare("TRIANGLE_6") == 0) {
650 return Triangle_6();
651 }
652 else if(typeVal.compare("QUADRILATERAL_8") == 0) {
653 return Quadrilateral_8();
654 }
655 else if(typeVal.compare("TETRAHEDRON_10") == 0) {
656 return Tetrahedron_10();
657 }
658 else if(typeVal.compare("PYRAMID_13") == 0) {
659 return Pyramid_13();
660 }
661 else if(typeVal.compare("WEDGE_15") == 0) {
662 return Wedge_15();
663 }
664 else if(typeVal.compare("HEXAHEDRON_20") == 0) {
665 return Hexahedron_20();
666 }
667 else if(typeVal.compare("HEXAHEDRON_24") == 0) {
668 return Hexahedron_24();
669 }
670 else if(typeVal.compare("HEXAHEDRON_27") == 0) {
671 return Hexahedron_27();
672 }
673 else if(typeVal.compare("HEXAHEDRON_64") == 0) {
674 return Hexahedron_64();
675 }
676 else if(typeVal.compare("HEXAHEDRON_125") == 0) {
677 return Hexahedron_125();
678 }
679 else if(typeVal.compare("HEXAHEDRON_216") == 0) {
680 return Hexahedron_216();
681 }
682 else if(typeVal.compare("HEXAHEDRON_343") == 0) {
683 return Hexahedron_343();
684 }
685 else if(typeVal.compare("HEXAHEDRON_512") == 0) {
686 return Hexahedron_512();
687 }
688 else if(typeVal.compare("HEXAHEDRON_729") == 0) {
689 return Hexahedron_729();
690 }
691 else if(typeVal.compare("HEXAHEDRON_1000") == 0) {
692 return Hexahedron_1000();
693 }
694 else if(typeVal.compare("HEXAHEDRON_1331") == 0) {
695 return Hexahedron_1331();
696 }
697 else if(typeVal.compare("HEXAHEDRON_SPECTRAL_64") == 0) {
698 return Hexahedron_Spectral_64();
699 }
700 else if(typeVal.compare("HEXAHEDRON_SPECTRAL_125") == 0) {
701 return Hexahedron_Spectral_125();
702 }
703 else if(typeVal.compare("HEXAHEDRON_SPECTRAL_216") == 0) {
704 return Hexahedron_Spectral_216();
705 }
706 else if(typeVal.compare("HEXAHEDRON_SPECTRAL_343") == 0) {
707 return Hexahedron_Spectral_343();
708 }
709 else if(typeVal.compare("HEXAHEDRON_SPECTRAL_512") == 0) {
710 return Hexahedron_Spectral_512();
711 }
712 else if(typeVal.compare("HEXAHEDRON_SPECTRAL_729") == 0) {
713 return Hexahedron_Spectral_729();
714 }
715 else if(typeVal.compare("HEXAHEDRON_SPECTRAL_1000") == 0) {
716 return Hexahedron_Spectral_1000();
717 }
718 else if(typeVal.compare("HEXAHEDRON_SPECTRAL_1331") == 0) {
719 return Hexahedron_Spectral_1331();
720 }
721 else if(typeVal.compare("MIXED") == 0) {
722 return Mixed();
723 }
724
725 XdmfError::message(XdmfError::FATAL,
726 "Invalid Type selected in XdmfTopologyType::New");
727
728 // unreachable
729 return shared_ptr<const XdmfTopologyType>();
730 }
731
732 XdmfTopologyType::CellType
getCellType() const733 XdmfTopologyType::getCellType() const
734 {
735 return mCellType;
736 }
737
738 unsigned int
getEdgesPerElement() const739 XdmfTopologyType::getEdgesPerElement() const
740 {
741 return mEdgesPerElement;
742 }
743
744 shared_ptr<const XdmfTopologyType>
getFaceType()745 XdmfTopologyType::getFaceType()
746 {
747 if (mFaces.size() == 0) {
748 return XdmfTopologyType::NoTopologyType();
749 }
750 else {
751 return mFaces[0];
752 }
753 }
754
755 unsigned int
getFacesPerElement() const756 XdmfTopologyType::getFacesPerElement() const
757 {
758 return mFacesPerElement;
759 }
760
761 unsigned int
getID() const762 XdmfTopologyType::getID() const
763 {
764 return mID;
765 }
766
767 std::string
getName() const768 XdmfTopologyType::getName() const
769 {
770 return mName;
771 }
772
773 unsigned int
getNodesPerElement() const774 XdmfTopologyType::getNodesPerElement() const
775 {
776 return mNodesPerElement;
777 }
778
779 void
getProperties(std::map<std::string,std::string> & collectedProperties) const780 XdmfTopologyType::getProperties(std::map<std::string, std::string> & collectedProperties) const
781 {
782 collectedProperties.insert(std::make_pair("Type", this->getName()));
783 if(mName.compare("Polygon") == 0 || mName.compare("Polyline") == 0) {
784 std::stringstream nodesPerElement;
785 nodesPerElement << mNodesPerElement;
786 collectedProperties.insert(std::make_pair("NodesPerElement",
787 nodesPerElement.str()));
788 }
789 }
790