Arcane  4.1.12.0
Developer documentation
Loading...
Searching...
No Matches
ItemRefinementPattern.h
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2026 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
4// See the top-level COPYRIGHT file for details.
5// SPDX-License-Identifier: Apache-2.0
6//-----------------------------------------------------------------------------
7/*---------------------------------------------------------------------------*/
8/* ItemRefinementPattern.h (C) 2000-2025 */
9/* */
10/* Utility functions for AMR. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_CORE_ITEMREFINEMENTPATTERN_H
13#define ARCANE_CORE_ITEMREFINEMENTPATTERN_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17#include "arcane/utils/ArcaneGlobal.h"
18#include "arcane/utils/Real3.h"
19#include "arcane/utils/TraceInfo.h"
20#include "arcane/utils/NotSupportedException.h"
21#include "arcane/utils/NotImplementedException.h"
22
23#include "arcane/core/ArcaneTypes.h"
24#include "arcane/utils/FatalErrorException.h"
25#include "arcane/utils/StringBuilder.h"
26
27/*---------------------------------------------------------------------------*/
28/*---------------------------------------------------------------------------*/
29
30namespace Arcane
31{
32
33/*---------------------------------------------------------------------------*/
34/*---------------------------------------------------------------------------*/
35// Barton & Nackman Trick
36template <class TypeImp>
37class RefinementPatternT
38{
39 public:
40
41 Real refine_matrix(const Integer i, const Integer j, const Integer k) const
42 {
43 return asImp().refine_matrix(i, j, k);
44 }
45 Integer face_mapping(const Integer i, const Integer j) const
46 {
47 return asImp().face_mapping(i, j);
48 }
49 Integer face_mapping_topo(const Integer i, const Integer j) const
50 {
51 return asImp().face_mapping_topo(i, j);
52 }
53 Integer hChildrenTypeId(const Integer i) const
54 {
55 return asImp().hChildrenTypeId(i);
56 }
57 Integer getNbHChildren() const
58 {
59 return asImp().getNbHChildren();
60 }
61
62 protected:
63
65 TypeImp& asImp()
66 {
67 return static_cast<TypeImp&>(*this);
68 }
69 const TypeImp& asImp() const
70 {
71 return static_cast<const TypeImp&>(*this);
72 }
73};
74
75/*---------------------------------------------------------------------------*/
76/*---------------------------------------------------------------------------*/
77
78template <int type_id> class ItemRefinementPatternT;
79typedef ItemRefinementPatternT<IT_Quad4> Quad4RefinementPattern4Quad;
80typedef ItemRefinementPatternT<IT_Hexaedron8> HexRefinementPattern8Hex;
81typedef ItemRefinementPatternT<IT_Tetraedron4> TetraRefinementPattern2Hex_2Penta_2Py_2Tetra;
82typedef ItemRefinementPatternT<IT_Pentaedron6> PrismRefinementPattern4Hex_4Pr;
83typedef ItemRefinementPatternT<IT_Pyramid5> PyramidRefinementPattern4Hex_4Py;
84typedef ItemRefinementPatternT<IT_HemiHexa5> HemiHex5RefinementPattern2Hex_4Penta_2HHex5;
85typedef ItemRefinementPatternT<IT_HemiHexa6> HemiHex6RefinementPattern4Hex_4HHex7;
86typedef ItemRefinementPatternT<IT_HemiHexa7> HemiHex7RefinementPattern6Hex_2HHex7;
87typedef ItemRefinementPatternT<IT_AntiWedgeLeft6> AntiWedgeLeft6RefinementPattern4Hex_4HHex7;
88typedef ItemRefinementPatternT<IT_AntiWedgeRight6> AntiWedgeRight6RefinementPattern4Hex_4HHex7;
89typedef ItemRefinementPatternT<IT_DiTetra5> DiTetra5RefinementPattern2Hex_6HHex7;
90
91/*---------------------------------------------------------------------------*/
92/*---------------------------------------------------------------------------*/
93
94/*---------------------------------------------------------------------------*/
95/*---------------------------------------------------------------------------*/
96
97template <>
98class ARCANE_CORE_EXPORT ItemRefinementPatternT<IT_Quad4>
99: public RefinementPatternT<ItemRefinementPatternT<IT_Quad4>>
100{
101 public:
102
103 ItemRefinementPatternT() {}
104
106 Real refine_matrix(const Integer i, const Integer j, const Integer k) const
107 {
108 return _refine_matrix[i][j][k];
109 }
110 Integer face_mapping(const Integer i, const Integer j) const
111 {
112 return _face_mapping[i][j];
113 }
114 Integer face_mapping_topo(const Integer i, const Integer j) const
115 {
116 return _face_mapping_topo[i][j];
117 }
118 Integer hChildrenTypeId(const Integer) const
119 {
120 return IT_Quad4;
121 }
122 Integer getNbHChildren() const
123 {
124 return m_nb_hChildren;
125 }
126
127 private:
128
129 static const Integer m_nb_hChildren = 4;
130
131 static const Real _refine_matrix[4][4][4];
132 static const Integer _face_mapping[4][4];
133 static const Integer _face_mapping_topo[4][4];
134};
135
136/*---------------------------------------------------------------------------*/
137/*---------------------------------------------------------------------------*/
138
139template <>
140class ARCANE_CORE_EXPORT ItemRefinementPatternT<IT_Hexaedron8>
141: public RefinementPatternT<ItemRefinementPatternT<IT_Hexaedron8>>
142{
143 public:
144
145 ItemRefinementPatternT() {}
146
148 Real refine_matrix(const Integer i, const Integer j, const Integer k) const
149 {
150 return _refine_matrix[i][j][k];
151 }
152 Integer face_mapping(const Integer i, const Integer j) const
153 {
154 return _face_mapping[i][j];
155 }
156 Integer face_mapping_topo(const Integer i, const Integer j) const
157 {
158 return _face_mapping_topo[i][j];
159 }
160 Integer hChildrenTypeId(const Integer) const
161 {
162 return IT_Hexaedron8;
163 }
164 Integer getNbHChildren() const
165 {
166 return m_nb_hChildren;
167 }
168
169 private:
170
171 static const Integer m_nb_hChildren = 8;
172
173 static const Real _refine_matrix[8][8][8];
174 static const Integer _face_mapping[8][6];
175 static const Integer _face_mapping_topo[8][6];
176};
177
178/*---------------------------------------------------------------------------*/
179/*---------------------------------------------------------------------------*/
180
181class ARCANE_CORE_EXPORT HexRefinementPattern27Hex
182: public RefinementPatternT<HexRefinementPattern27Hex>
183{
184 public:
185
186 HexRefinementPattern27Hex() {}
187
189 Real refine_matrix(const Integer, const Integer, const Integer) const
190 {
191 throw NotSupportedException(A_FUNCINFO);
192 }
193 Integer face_mapping(const Integer, const Integer) const
194 {
195 throw FatalErrorException(A_FUNCINFO, "not implemented");
196 }
197 Integer hChildrenTypeId(const Integer) const
198 {
199 return IT_Hexaedron8;
200 }
201 Integer getNbHChildren() const
202 {
203 return m_nb_hChildren;
204 }
205
206 private:
207
208 static const Integer m_nb_hChildren = 27;
209 static const double _refine_matrix_1[27][8][8];
210};
211
212/*---------------------------------------------------------------------------*/
213/*---------------------------------------------------------------------------*/
214
215template <>
216class ARCANE_CORE_EXPORT ItemRefinementPatternT<IT_Tetraedron4> : public RefinementPatternT<ItemRefinementPatternT<IT_Tetraedron4>>
217{
218 public:
219
220 ItemRefinementPatternT() {}
221
223 Real refine_matrix(const Integer i, const Integer j, const Integer k) const
224 {
225 if (i < 2)
226 return _refine_matrix_1[i][j][k];
227 if (i < 4)
228 return _refine_matrix_2[i - 2][j][k];
229 if (i < 6)
230 return _refine_matrix_3[i - 4][j][k];
231 return _refine_matrix_4[i - 6][j][k];
232 }
233 Integer face_mapping(const Integer i, const Integer j) const
234 {
235 if (i < 2)
236 return _face_mapping_1[i][j];
237 if (i < 4)
238 return _face_mapping_2[i - 2][j];
239 if (i < 6)
240 return _face_mapping_3[i - 4][j];
241 return _face_mapping_4[i - 6][j];
242 }
243 Integer face_mapping_topo(const Integer i, const Integer j) const
244 {
245 if (i < 2)
246 return _face_mapping_topo_1[i][j];
247 if (i < 4)
248 return _face_mapping_topo_2[i - 2][j];
249 if (i < 6)
250 return _face_mapping_topo_3[i - 4][j];
251 return _face_mapping_topo_4[i - 6][j];
252 }
253 Integer hChildrenTypeId(const Integer i) const
254 {
255 if (i < 2)
256 return IT_Hexaedron8;
257 if (i < 4)
258 return IT_Pentaedron6;
259 if (i < 6)
260 return IT_Pyramid5;
261 return IT_Tetraedron4;
262 }
263 Integer getNbHChildren() const
264 {
265 return m_nb_hChildren;
266 }
267
268 private:
269
270 static const Integer m_nb_hChildren = 8;
271
272 static const double _refine_matrix_1[2][8][4];
273 static const Integer _face_mapping_1[2][6];
274 static const Integer _face_mapping_topo_1[2][6];
275
276 static const double _refine_matrix_2[2][6][4];
277 static const Integer _face_mapping_2[2][5];
278 static const Integer _face_mapping_topo_2[2][5];
279
280 static const double _refine_matrix_3[2][5][4];
281 static const Integer _face_mapping_3[2][5];
282 static const Integer _face_mapping_topo_3[2][5];
283
284 static const double _refine_matrix_4[2][4][4];
285 static const Integer _face_mapping_4[2][4];
286 static const Integer _face_mapping_topo_4[2][4];
287};
288
289/*---------------------------------------------------------------------------*/
290/*---------------------------------------------------------------------------*/
291
292class ARCANE_CORE_EXPORT TetraRefinementPattern8T
293: public RefinementPatternT<TetraRefinementPattern8T>
294{
295 public:
296
297 TetraRefinementPattern8T() {}
298
300 Real refine_matrix(const Integer i, const Integer j, const Integer k) const
301 {
302 return _refine_matrix_1[i][j][k];
303 }
304 Integer face_mapping(const Integer, const Integer) const
305 {
306 throw FatalErrorException(A_FUNCINFO, "not implemented");
307 }
308 Integer hChildrenTypeId(const Integer) const
309 {
310 return IT_Tetraedron4;
311 }
312 Integer getNbHChildren() const
313 {
314 return m_nb_hChildren;
315 }
316
317 private:
318
319 static const Integer m_nb_hChildren = 8;
320 static const double _refine_matrix_1[8][4][4];
321};
322
323/*---------------------------------------------------------------------------*/
324/*---------------------------------------------------------------------------*/
325
326class ARCANE_CORE_EXPORT TetraRefinementPattern32T
327: public RefinementPatternT<TetraRefinementPattern32T>
328{
329 public:
330
331 TetraRefinementPattern32T() {}
332
334 Real refine_matrix(const Integer, const Integer, const Integer) const
335 {
336 throw NotSupportedException(A_FUNCINFO);
337 }
338 Integer face_mapping(const Integer, const Integer) const
339 {
340 throw FatalErrorException(A_FUNCINFO, "not implemented");
341 }
342 Integer hChildrenTypeId(const Integer) const
343 {
344 return IT_Tetraedron4;
345 }
346 Integer getNbHChildren() const
347 {
348 return m_nb_hChildren;
349 }
350
351 private:
352
353 static const Integer m_nb_hChildren = 32;
354 static const double _refine_matrix_1[32][4][4];
355};
356
357/*---------------------------------------------------------------------------*/
358/*---------------------------------------------------------------------------*/
359
360template <>
361class ARCANE_CORE_EXPORT ItemRefinementPatternT<IT_Pentaedron6> : public RefinementPatternT<ItemRefinementPatternT<IT_Pentaedron6>>
362{
363 public:
364
365 ItemRefinementPatternT() {}
366
368 Real refine_matrix(const Integer i, const Integer j, const Integer k) const
369 {
370 if (i < 4)
371 return _refine_matrix_1[i][j][k];
372 return _refine_matrix_2[i - 4][j][k];
373 }
374 Integer face_mapping(const Integer i, const Integer j) const
375 {
376 if (i < 4)
377 return _face_mapping_1[i][j];
378 return _face_mapping_2[i - 4][j];
379 }
380 Integer face_mapping_topo(const Integer i, const Integer j) const
381 {
382 if (i < 4)
383 return _face_mapping_topo_1[i][j];
384 return _face_mapping_topo_2[i - 4][j];
385 }
386 Integer hChildrenTypeId(const Integer i) const
387 {
388 if (i < 4)
389 return IT_Hexaedron8;
390 return IT_Pentaedron6;
391 }
392 Integer getNbHChildren() const
393 {
394 return m_nb_hChildren;
395 }
396
397 private:
398
399 static const Integer m_nb_hChildren = 8;
400
401 static const double _refine_matrix_1[4][8][6];
402 static const Integer _face_mapping_1[4][6];
403 static const Integer _face_mapping_topo_1[4][6];
404
405 static const double _refine_matrix_2[4][6][6];
406 static const Integer _face_mapping_2[4][5];
407 static const Integer _face_mapping_topo_2[4][5];
408};
409
410/*---------------------------------------------------------------------------*/
411/*---------------------------------------------------------------------------*/
412
413class ARCANE_CORE_EXPORT PrismRefinementPattern8Pr
414: public RefinementPatternT<PrismRefinementPattern8Pr>
415{
416 public:
417
418 PrismRefinementPattern8Pr() {}
419
421 Real refine_matrix(const Integer i, const Integer j, const Integer k) const
422 {
423 return _refine_matrix_1[i][j][k];
424 }
425 Integer face_mapping(const Integer, const Integer) const
426 {
427 throw FatalErrorException(A_FUNCINFO, "not implemented");
428 }
429 Integer hChildrenTypeId(const Integer) const
430 {
431 return IT_Pentaedron6;
432 }
433 Integer getNbHChildren() const
434 {
435 return m_nb_hChildren;
436 }
437
438 private:
439
440 static const Integer m_nb_hChildren = 8;
441 static const double _refine_matrix_1[8][6][6];
442};
443
444/*---------------------------------------------------------------------------*/
445/*---------------------------------------------------------------------------*/
446
447class ARCANE_CORE_EXPORT PrismRefinementPattern27Pr
448: public RefinementPatternT<PrismRefinementPattern27Pr>
449{
450 public:
451
452 PrismRefinementPattern27Pr() {}
453
455 Real refine_matrix(const Integer, const Integer, const Integer) const
456 {
457 throw NotSupportedException(A_FUNCINFO);
458 }
459 Integer face_mapping(const Integer, const Integer) const
460 {
461 throw FatalErrorException(A_FUNCINFO, "not implemented");
462 }
463 Integer hChildrenTypeId(const Integer) const
464 {
465 return IT_Pentaedron6;
466 }
467 Integer getNbHChildren() const
468 {
469 return m_nb_hChildren;
470 }
471
472 private:
473
474 static const Integer m_nb_hChildren = 27;
475
476 static const double _refine_matrix_1[27][6][6];
477};
478
479/*---------------------------------------------------------------------------*/
480/*---------------------------------------------------------------------------*/
481
482template <>
483class ARCANE_CORE_EXPORT ItemRefinementPatternT<IT_Pyramid5> : public RefinementPatternT<ItemRefinementPatternT<IT_Pyramid5>>
484{
485 public:
486
487 ItemRefinementPatternT() {}
488
490 Real refine_matrix(const Integer i, const Integer j, const Integer k) const
491 {
492 if (i < 4)
493 return _refine_matrix_1[i][j][k];
494 return _refine_matrix_2[i - 4][j][k];
495 }
496 Integer face_mapping(const Integer i, const Integer j) const
497 {
498 if (i < 4)
499 return _face_mapping_1[i][j];
500 return _face_mapping_2[i - 4][j];
501 }
502 Integer face_mapping_topo(const Integer i, const Integer j) const
503 {
504 if (i < 4)
505 return _face_mapping_topo_1[i][j];
506 return _face_mapping_topo_2[i - 4][j];
507 }
508 Integer hChildrenTypeId(const Integer i) const
509 {
510 if (i < 4)
511 return IT_Hexaedron8;
512 return IT_Pyramid5;
513 }
514 Integer getNbHChildren() const
515 {
516 return m_nb_hChildren;
517 }
518
519 private:
520
521 static const Integer m_nb_hChildren = 8;
522
523 static const double _refine_matrix_1[4][8][5];
524 static const Integer _face_mapping_1[4][6];
525 static const Integer _face_mapping_topo_1[4][6];
526
527 static const double _refine_matrix_2[4][5][5];
528 static const Integer _face_mapping_2[4][5];
529 static const Integer _face_mapping_topo_2[4][5];
530};
531/*---------------------------------------------------------------------------*/
532/*---------------------------------------------------------------------------*/
533
534class ARCANE_CORE_EXPORT PyramidRefinementPattern4Py8T
535: public RefinementPatternT<PyramidRefinementPattern4Py8T>
536{
537 public:
538
539 PyramidRefinementPattern4Py8T() {}
540
542 Real refine_matrix(const Integer i, const Integer j, const Integer k) const
543 {
544 if (i < 4)
545 return _refine_matrix_1[i][j][k];
546 return _refine_matrix_2[i - 4][j][k];
547 }
548 Integer face_mapping(const Integer, const Integer) const
549 {
550 throw FatalErrorException(A_FUNCINFO, "not implemented");
551 }
552 Integer hChildrenTypeId(const Integer i) const
553 {
554 if (i < 4)
555 return IT_Pyramid5;
556 return IT_Tetraedron4;
557 }
558 Integer getNbHChildren() const
559 {
560 return m_nb_hChildren;
561 }
562
563 private:
564
565 static const Integer m_nb_hChildren = 12;
566
567 static const double _refine_matrix_1[4][5][5];
568
569 static const double _refine_matrix_2[8][4][5];
570};
571
572/*---------------------------------------------------------------------------*/
573/*---------------------------------------------------------------------------*/
574
575class ARCANE_CORE_EXPORT PyramidRefinementPattern6Py4T
576: public RefinementPatternT<PyramidRefinementPattern6Py4T>
577{
578 public:
579
580 PyramidRefinementPattern6Py4T() {}
581
583 Real refine_matrix(const Integer i, const Integer j, const Integer k) const
584 {
585 if (i < 6)
586 return _refine_matrix_1[i][j][k];
587 return _refine_matrix_2[i - 6][j][k];
588 throw NotSupportedException(A_FUNCINFO);
589 }
590 Integer hChildrenTypeId(const Integer i) const
591 {
592 if (i < 6)
593 return IT_Pyramid5;
594 return IT_Tetraedron4;
595 }
596 Integer getNbHChildren() const
597 {
598 return m_nb_hChildren;
599 }
600
601 private:
602
603 static const Integer m_nb_hChildren = 10;
604
605 static const double _refine_matrix_1[6][5][5];
606
607 static const double _refine_matrix_2[4][4][5];
608};
609
610/*---------------------------------------------------------------------------*/
611/*---------------------------------------------------------------------------*/
612
613class ARCANE_CORE_EXPORT PyramidRefinementPattern4Py
614: public RefinementPatternT<PyramidRefinementPattern4Py>
615{
616 public:
617
618 PyramidRefinementPattern4Py() {}
619
621 Real refine_matrix(const Integer, const Integer, const Integer) const
622 {
623 throw NotSupportedException(A_FUNCINFO);
624 }
625 Integer face_mapping(const Integer, const Integer) const
626 {
627 throw FatalErrorException(A_FUNCINFO, "not implemented");
628 }
629 Integer hChildrenTypeId(const Integer) const
630 {
631 return IT_Pyramid5;
632 }
633 Integer getNbHChildren() const
634 {
635 return m_nb_hChildren;
636 }
637
638 private:
639
640 static const Integer m_nb_hChildren = 4;
641 static const double _refine_matrix_1[4][5][5];
642};
643
644/*---------------------------------------------------------------------------*/
645/*---------------------------------------------------------------------------*/
646
647class ARCANE_CORE_EXPORT PyramidRefinementPattern19Py12T
648: public RefinementPatternT<PyramidRefinementPattern19Py12T>
649{
650 public:
651
652 PyramidRefinementPattern19Py12T() {}
653
655 Real refine_matrix(const Integer i, const Integer j, const Integer k) const
656 {
657 if (i < 19)
658 return _refine_matrix_1[i][j][k];
659 return _refine_matrix_2[i - 19][j][k];
660 throw NotSupportedException(A_FUNCINFO);
661 }
662 Integer face_mapping(const Integer, const Integer) const
663 {
664 throw FatalErrorException(A_FUNCINFO, "not implemented");
665 }
666 Integer hChildrenTypeId(const Integer i) const
667 {
668 if (i < 19)
669 return IT_Pyramid5;
670 return IT_Tetraedron4;
671 }
672 Integer getNbHChildren() const
673 {
674 return m_nb_hChildren;
675 }
676
677 private:
678
679 static const Integer m_nb_hChildren = 31;
680 static const double _refine_matrix_1[19][5][5];
681 static const double _refine_matrix_2[12][4][5];
682};
683
684/*---------------------------------------------------------------------------*/
685/*---------------------------------------------------------------------------*/
686
687template <>
688class ARCANE_CORE_EXPORT ItemRefinementPatternT<IT_HemiHexa5> : public RefinementPatternT<ItemRefinementPatternT<IT_HemiHexa5>>
689{
690 public:
691
692 ItemRefinementPatternT() {}
693
695 Real refine_matrix(const Integer i, const Integer j, const Integer k) const
696 {
697 if (i < 2)
698 return _refine_matrix_1[i][j][k];
699 if (i < 6)
700 return _refine_matrix_2[i - 2][j][k];
701 return _refine_matrix_3[i - 6][j][k];
702 }
703
704 Integer face_mapping(const Integer i, const Integer j) const
705 {
706 if (i < 2)
707 return _face_mapping_1[i][j];
708 if (i < 6)
709 return _face_mapping_2[i - 2][j];
710 return _face_mapping_3[i - 6][j];
711 }
712 Integer face_mapping_topo(const Integer i, const Integer j) const
713 {
714 if (i < 2)
715 return _face_mapping_topo_1[i][j];
716 if (i < 6)
717 return _face_mapping_topo_2[i - 2][j];
718 return _face_mapping_topo_3[i - 6][j];
719 }
720 Integer hChildrenTypeId(const Integer i) const
721 {
722 if (i < 2)
723 return IT_Hexaedron8;
724 if (i < 6)
725 return IT_Pentaedron6;
726 return IT_HemiHexa5;
727 }
728 Integer getNbHChildren() const
729 {
730 return m_nb_hChildren;
731 }
732
733 private:
734
735 static const Integer m_nb_hChildren = 8;
736
737 static const double _refine_matrix_1[2][8][5];
738 static const Integer _face_mapping_1[2][6];
739 static const Integer _face_mapping_topo_1[2][6];
740
741 static const double _refine_matrix_2[4][6][5];
742 static const Integer _face_mapping_2[4][5];
743 static const Integer _face_mapping_topo_2[4][5];
744
745 static const double _refine_matrix_3[2][5][5];
746 static const Integer _face_mapping_3[2][4];
747 static const Integer _face_mapping_topo_3[2][4];
748};
749
750/*---------------------------------------------------------------------------*/
751/*---------------------------------------------------------------------------*/
752
753class ARCANE_CORE_EXPORT HemiHex5RefinementPattern3HHex5_2Pr_1HHex7
754: public RefinementPatternT<HemiHex5RefinementPattern3HHex5_2Pr_1HHex7>
755{
756 public:
757
758 HemiHex5RefinementPattern3HHex5_2Pr_1HHex7() {}
759
761 Real refine_matrix(const Integer i, const Integer j, const Integer k) const
762 {
763 if (i < 3)
764 return _refine_matrix_1[i][j][k];
765 if (i < 5)
766 return _refine_matrix_2[i - 3][j][k];
767 return _refine_matrix_3[i - 5][j][k];
768 }
769 Integer face_mapping(const Integer, const Integer) const
770 {
771 throw NotImplementedException(A_FUNCINFO);
772 }
773 Integer hChildrenTypeId(const Integer i) const
774 {
775 if (i < 3)
776 return IT_HemiHexa5;
777 if (i < 5)
778 return IT_Pentaedron6;
779 return IT_HemiHexa7;
780 }
781 Integer getNbHChildren() const
782 {
783 return m_nb_hChildren;
784 }
785
786 private:
787
788 static const Integer m_nb_hChildren = 6;
789
790 static const double _refine_matrix_1[3][5][5];
791
792 static const double _refine_matrix_2[2][6][5];
793
794 static const double _refine_matrix_3[1][7][5];
795};
796
797/*---------------------------------------------------------------------------*/
798/*---------------------------------------------------------------------------*/
799
800class ARCANE_CORE_EXPORT HemiHex5RefinementPattern7HHex5_4Pr_3HHex6_2HHex7_1Hex
801: public RefinementPatternT<HemiHex5RefinementPattern7HHex5_4Pr_3HHex6_2HHex7_1Hex>
802{
803 public:
804
805 HemiHex5RefinementPattern7HHex5_4Pr_3HHex6_2HHex7_1Hex() {}
806
808 Real refine_matrix(const Integer i, const Integer j, const Integer k) const
809 {
810 if (i < 7)
811 return _refine_matrix_1[i][j][k];
812 if (i < 11)
813 return _refine_matrix_2[i - 7][j][k];
814 if (i < 14)
815 return _refine_matrix_3[i - 11][j][k];
816 if (i < 16)
817 return _refine_matrix_4[i - 14][j][k];
818 return _refine_matrix_5[i - 16][j][k];
819 }
820 Integer face_mapping(const Integer, const Integer) const
821 {
822 throw NotImplementedException(A_FUNCINFO);
823 }
824 Integer hChildrenTypeId(const Integer i) const
825 {
826 if (i < 7)
827 return IT_HemiHexa5;
828 if (i < 11)
829 return IT_Pentaedron6;
830 if (i < 14)
831 return IT_HemiHexa6;
832 if (i < 16)
833 return IT_HemiHexa7;
834 return IT_Hexaedron8;
835 }
836 Integer getNbHChildren() const
837 {
838 return m_nb_hChildren;
839 }
840
841 private:
842
843 static const Integer m_nb_hChildren = 17;
844 static const double _refine_matrix_1[7][5][5];
845 static const double _refine_matrix_2[4][6][5];
846 static const double _refine_matrix_3[3][6][5];
847 static const double _refine_matrix_4[2][7][5];
848 static const double _refine_matrix_5[1][8][5];
849};
850
851/*---------------------------------------------------------------------------*/
852/*---------------------------------------------------------------------------*/
853
854template <>
855class ARCANE_CORE_EXPORT ItemRefinementPatternT<IT_HemiHexa6> : public RefinementPatternT<ItemRefinementPatternT<IT_HemiHexa6>>
856{
857 public:
858
859 ItemRefinementPatternT() {}
860
862 Real refine_matrix(const Integer i, const Integer j, const Integer k) const
863 {
864 if (i < 4)
865 return _refine_matrix_1[i][j][k];
866 return _refine_matrix_2[i - 4][j][k];
867 }
868 Integer face_mapping(const Integer i, const Integer j) const
869 {
870 if (i < 4)
871 return _face_mapping_1[i][j];
872 return _face_mapping_2[i - 4][j];
873 }
874 Integer face_mapping_topo(const Integer i, const Integer j) const
875 {
876 if (i < 4)
877 return _face_mapping_topo_1[i][j];
878 return _face_mapping_topo_2[i - 4][j];
879 }
880 Integer hChildrenTypeId(const Integer i) const
881 {
882 if (i < 4)
883 return IT_Hexaedron8;
884 return IT_HemiHexa7;
885 }
886 Integer getNbHChildren() const
887 {
888 return m_nb_hChildren;
889 }
890
891 private:
892
893 static const Integer m_nb_hChildren = 8;
894
895 static const double _refine_matrix_1[4][8][6];
896 static const Integer _face_mapping_1[4][6];
897 static const Integer _face_mapping_topo_1[4][6];
898
899 static const double _refine_matrix_2[4][7][6];
900 static const Integer _face_mapping_2[4][6];
901 static const Integer _face_mapping_topo_2[4][6];
902};
903
904/*---------------------------------------------------------------------------*/
905/*---------------------------------------------------------------------------*/
906
907class ARCANE_CORE_EXPORT HemiHex6RefinementPattern4HHex5_4HHex7
908: public RefinementPatternT<HemiHex6RefinementPattern4HHex5_4HHex7>
909{
910 public:
911
912 HemiHex6RefinementPattern4HHex5_4HHex7() {}
913
915 Real refine_matrix(const Integer i, const Integer j, const Integer k) const
916 {
917 if (i < 4)
918 return _refine_matrix_1[i][j][k];
919 return _refine_matrix_2[i - 4][j][k];
920 }
921 Integer face_mapping(const Integer, const Integer) const
922 {
923 throw FatalErrorException(A_FUNCINFO, "not implemented");
924 }
925 Integer hChildrenTypeId(const Integer i) const
926 {
927 if (i < 4)
928 return IT_HemiHexa5;
929 return IT_HemiHexa7;
930 }
931 Integer getNbHChildren() const
932 {
933 return m_nb_hChildren;
934 }
935
936 private:
937
938 static const Integer m_nb_hChildren = 8;
939 static const double _refine_matrix_1[4][5][6];
940 static const double _refine_matrix_2[4][7][6];
941};
942
943/*---------------------------------------------------------------------------*/
944/*---------------------------------------------------------------------------*/
945
946class ARCANE_CORE_EXPORT HemiHex6RefinementPattern6HHex6_12HHex5_6HHex7_1Hex
947: public RefinementPatternT<HemiHex6RefinementPattern6HHex6_12HHex5_6HHex7_1Hex>
948{
949 public:
950
951 HemiHex6RefinementPattern6HHex6_12HHex5_6HHex7_1Hex() {}
952
954 Real refine_matrix(const Integer i, const Integer j, const Integer k) const
955 {
956 if (i < 6)
957 return _refine_matrix_1[i][j][k];
958 if (i < 18)
959 return _refine_matrix_2[i - 6][j][k];
960 if (i < 24)
961 return _refine_matrix_3[i - 18][j][k];
962 return _refine_matrix_4[i - 24][j][k];
963 }
964 Integer face_mapping(const Integer, const Integer) const
965 {
966 throw NotImplementedException(A_FUNCINFO);
967 }
968 Integer hChildrenTypeId(const Integer i) const
969 {
970 if (i < 6)
971 return IT_HemiHexa6;
972 if (i < 18)
973 return IT_HemiHexa5;
974 if (i < 24)
975 return IT_HemiHexa7;
976 return IT_Hexaedron8;
977 }
978 Integer getNbHChildren() const
979 {
980 return m_nb_hChildren;
981 }
982
983 private:
984
985 static const Integer m_nb_hChildren = 25;
986 static const double _refine_matrix_1[6][6][6];
987 static const double _refine_matrix_2[12][5][6];
988 static const double _refine_matrix_3[6][7][6];
989 static const double _refine_matrix_4[1][8][6];
990};
991
992/*---------------------------------------------------------------------------*/
993/*---------------------------------------------------------------------------*/
994
995template <>
996class ARCANE_CORE_EXPORT ItemRefinementPatternT<IT_HemiHexa7> : public RefinementPatternT<ItemRefinementPatternT<IT_HemiHexa7>>
997{
998 public:
999
1000 ItemRefinementPatternT() {}
1001
1003 Real refine_matrix(const Integer i, const Integer j, const Integer k) const
1004 {
1005 if (i < 6)
1006 return _refine_matrix_1[i][j][k];
1007 return _refine_matrix_2[i - 6][j][k];
1008 }
1009
1010 Integer face_mapping(const Integer i, const Integer j) const
1011 {
1012 if (i < 6)
1013 return _face_mapping_1[i][j];
1014 return _face_mapping_2[i - 6][j];
1015 }
1016 Integer face_mapping_topo(const Integer i, const Integer j) const
1017 {
1018 if (i < 6)
1019 return _face_mapping_topo_1[i][j];
1020 return _face_mapping_topo_2[i - 6][j];
1021 }
1022 Integer hChildrenTypeId(const Integer i) const
1023 {
1024 if (i < 6)
1025 return IT_Hexaedron8;
1026 return IT_HemiHexa7;
1027 }
1028 Integer getNbHChildren() const
1029 {
1030 return m_nb_hChildren;
1031 }
1032
1033 private:
1034
1035 static const Integer m_nb_hChildren = 8;
1036
1037 static const double _refine_matrix_1[6][8][7];
1038 static const Integer _face_mapping_1[6][6];
1039 static const Integer _face_mapping_topo_1[6][6];
1040
1041 static const double _refine_matrix_2[2][7][7];
1042 static const Integer _face_mapping_2[2][6];
1043 static const Integer _face_mapping_topo_2[2][6];
1044};
1045
1046/*---------------------------------------------------------------------------*/
1047/*---------------------------------------------------------------------------*/
1048
1049class ARCANE_CORE_EXPORT HemiHex7RefinementPattern4HHex7_4Pr_2HHex5_1Hex
1050: public RefinementPatternT<HemiHex7RefinementPattern4HHex7_4Pr_2HHex5_1Hex>
1051{
1052 public:
1053
1054 HemiHex7RefinementPattern4HHex7_4Pr_2HHex5_1Hex() {}
1055
1057 Real refine_matrix(const Integer i, const Integer j, const Integer k) const
1058 {
1059 if (i < 4)
1060 return _refine_matrix_1[i][j][k];
1061 if (i < 8)
1062 return _refine_matrix_2[i - 4][j][k];
1063 if (i < 10)
1064 return _refine_matrix_3[i - 8][j][k];
1065 return _refine_matrix_4[i - 10][j][k];
1066 }
1067 Integer face_mapping(const Integer, const Integer) const
1068 {
1069 throw FatalErrorException(A_FUNCINFO, "not implemented");
1070 }
1071 Integer hChildrenTypeId(const Integer i) const
1072 {
1073 if (i < 4)
1074 return IT_HemiHexa7;
1075 if (i < 8)
1076 return IT_Pentaedron6;
1077 if (i < 10)
1078 return IT_HemiHexa5;
1079 return IT_Hexaedron8;
1080 }
1081 Integer getNbHChildren() const
1082 {
1083 return m_nb_hChildren;
1084 }
1085
1086 private:
1087
1088 static const Integer m_nb_hChildren = 11;
1089 static const double _refine_matrix_1[4][7][7];
1090 static const double _refine_matrix_2[4][6][7];
1091 static const double _refine_matrix_3[2][5][7];
1092 static const double _refine_matrix_4[1][8][7];
1093};
1094
1095/*---------------------------------------------------------------------------*/
1096/*---------------------------------------------------------------------------*/
1097
1098class ARCANE_CORE_EXPORT HemiHex7RefinementPattern8HHex7_14Pr_9HHex5_7Hex
1099: public RefinementPatternT<HemiHex7RefinementPattern8HHex7_14Pr_9HHex5_7Hex>
1100{
1101 public:
1102
1103 HemiHex7RefinementPattern8HHex7_14Pr_9HHex5_7Hex() {}
1104
1106 Real refine_matrix(const Integer i, const Integer j, const Integer k) const
1107 {
1108 if (i < 8)
1109 return _refine_matrix_1[i][j][k];
1110 if (i < 22)
1111 return _refine_matrix_2[i - 8][j][k];
1112 if (i < 31)
1113 return _refine_matrix_3[i - 22][j][k];
1114 return _refine_matrix_4[i - 31][j][k];
1115 }
1116 Integer face_mapping(const Integer, const Integer) const
1117 {
1118 throw FatalErrorException(A_FUNCINFO, "not implemented");
1119 }
1120 Integer hChildrenTypeId(const Integer i) const
1121 {
1122 if (i < 8)
1123 return IT_HemiHexa7;
1124 if (i < 22)
1125 return IT_Pentaedron6;
1126 if (i < 31)
1127 return IT_HemiHexa5;
1128 return IT_Hexaedron8;
1129 }
1130 Integer getNbHChildren() const
1131 {
1132 return m_nb_hChildren;
1133 }
1134
1135 private:
1136
1137 static const Integer m_nb_hChildren = 38;
1138 static const double _refine_matrix_1[8][7][7];
1139 static const double _refine_matrix_2[14][6][7];
1140 static const double _refine_matrix_3[9][5][7];
1141 static const double _refine_matrix_4[7][8][7];
1142};
1143
1144/*---------------------------------------------------------------------------*/
1145/*---------------------------------------------------------------------------*/
1146
1147template <>
1148class ARCANE_CORE_EXPORT ItemRefinementPatternT<IT_AntiWedgeLeft6> : public RefinementPatternT<ItemRefinementPatternT<IT_AntiWedgeLeft6>>
1149{
1150 public:
1151
1152 ItemRefinementPatternT() {}
1153
1155 Real refine_matrix(const Integer i, const Integer j, const Integer k) const
1156 {
1157 if (i < 4)
1158 return _refine_matrix_1[i][j][k];
1159 return _refine_matrix_2[i - 4][j][k];
1160 }
1161 Integer face_mapping(const Integer i, const Integer j) const
1162 {
1163 if (i < 4)
1164 return _face_mapping_1[i][j];
1165 return _face_mapping_2[i - 4][j];
1166 }
1167 Integer face_mapping_topo(const Integer i, const Integer j) const
1168 {
1169 if (i < 4)
1170 return _face_mapping_topo_1[i][j];
1171 return _face_mapping_topo_2[i - 4][j];
1172 }
1173 Integer hChildrenTypeId(const Integer i) const
1174 {
1175 if (i < 4)
1176 return IT_Hexaedron8;
1177 return IT_HemiHexa7;
1178 }
1179 Integer getNbHChildren() const
1180 {
1181 return m_nb_hChildren;
1182 }
1183
1184 private:
1185
1186 static const Integer m_nb_hChildren = 8;
1187 static const double _refine_matrix_1[4][8][6];
1188 static const Integer _face_mapping_1[4][6];
1189 static const Integer _face_mapping_topo_1[4][6];
1190 static const double _refine_matrix_2[4][7][6];
1191 static const Integer _face_mapping_2[4][6];
1192 static const Integer _face_mapping_topo_2[4][6];
1193};
1194/*---------------------------------------------------------------------------*/
1195/*---------------------------------------------------------------------------*/
1196
1197class ARCANE_CORE_EXPORT AntiWedgeLeft6RefinementPattern4AWL6_4Pr
1198: public RefinementPatternT<AntiWedgeLeft6RefinementPattern4AWL6_4Pr>
1199{
1200 public:
1201
1202 AntiWedgeLeft6RefinementPattern4AWL6_4Pr() {}
1203
1205 Real refine_matrix(const Integer i, const Integer j, const Integer k) const
1206 {
1207 if (i < 4)
1208 return _refine_matrix_1[i][j][k];
1209 return _refine_matrix_2[i - 4][j][k];
1210 }
1211 Integer face_mapping(const Integer, const Integer) const
1212 {
1213 throw FatalErrorException(A_FUNCINFO, "not implemented");
1214 }
1215 Integer hChildrenTypeId(const Integer i) const
1216 {
1217 if (i < 4)
1218 return IT_AntiWedgeLeft6;
1219 return IT_Pentaedron6;
1220 }
1221 Integer getNbHChildren() const
1222 {
1223 return m_nb_hChildren;
1224 }
1225
1226 private:
1227
1228 static const Integer m_nb_hChildren = 8;
1229 static const double _refine_matrix_1[4][6][6];
1230 static const double _refine_matrix_2[4][6][6];
1231};
1232
1233/*---------------------------------------------------------------------------*/
1234/*---------------------------------------------------------------------------*/
1235
1236class ARCANE_CORE_EXPORT AntiWedgeLeft6RefinementPattern9AWL6_18Pr
1237: public RefinementPatternT<AntiWedgeLeft6RefinementPattern9AWL6_18Pr>
1238{
1239 public:
1240
1241 AntiWedgeLeft6RefinementPattern9AWL6_18Pr() {}
1242
1244 Real refine_matrix(const Integer i, const Integer j, const Integer k) const
1245 {
1246 if (i < 9)
1247 return _refine_matrix_1[i][j][k];
1248 return _refine_matrix_2[i - 9][j][k];
1249 }
1250 Integer face_mapping(const Integer, const Integer) const
1251 {
1252 throw FatalErrorException(A_FUNCINFO, "not implemented");
1253 }
1254 Integer hChildrenTypeId(const Integer i) const
1255 {
1256 if (i < 9)
1257 return IT_AntiWedgeLeft6;
1258 return IT_Pentaedron6;
1259 }
1260 Integer getNbHChildren() const
1261 {
1262 return m_nb_hChildren;
1263 }
1264
1265 private:
1266
1267 static const Integer m_nb_hChildren = 27;
1268 static const double _refine_matrix_1[9][6][6];
1269 static const double _refine_matrix_2[18][6][6];
1270};
1271
1272/*---------------------------------------------------------------------------*/
1273/*---------------------------------------------------------------------------*/
1274
1275template <>
1276class ARCANE_CORE_EXPORT ItemRefinementPatternT<IT_AntiWedgeRight6> : public RefinementPatternT<ItemRefinementPatternT<IT_AntiWedgeRight6>>
1277{
1278 public:
1279
1280 ItemRefinementPatternT() {}
1281
1283 Real refine_matrix(const Integer i, const Integer j, const Integer k) const
1284 {
1285 if (i < 4)
1286 return _refine_matrix_1[i][j][k];
1287 return _refine_matrix_2[i - 4][j][k];
1288 }
1289 Integer face_mapping(const Integer i, const Integer j) const
1290 {
1291 if (i < 4)
1292 return _face_mapping_1[i][j];
1293 return _face_mapping_2[i - 4][j];
1294 }
1295 Integer face_mapping_topo(const Integer i, const Integer j) const
1296 {
1297 if (i < 4)
1298 return _face_mapping_topo_1[i][j];
1299 return _face_mapping_topo_2[i - 4][j];
1300 }
1301 Integer hChildrenTypeId(const Integer i) const
1302 {
1303 if (i < 4)
1304 return IT_Hexaedron8;
1305 return IT_HemiHexa7;
1306 }
1307 Integer getNbHChildren() const
1308 {
1309 return m_nb_hChildren;
1310 }
1311
1312 private:
1313
1314 static const Integer m_nb_hChildren = 8;
1315 static const double _refine_matrix_1[4][8][6];
1316 static const Integer _face_mapping_1[4][6];
1317 static const Integer _face_mapping_topo_1[4][6];
1318 static const double _refine_matrix_2[4][7][6];
1319 static const Integer _face_mapping_2[4][6];
1320 static const Integer _face_mapping_topo_2[4][6];
1321};
1322/*---------------------------------------------------------------------------*/
1323/*---------------------------------------------------------------------------*/
1324
1325class ARCANE_CORE_EXPORT AntiWedgeRight6RefinementPattern4AWR6_4Pr
1326: public RefinementPatternT<AntiWedgeRight6RefinementPattern4AWR6_4Pr>
1327{
1328 public:
1329
1330 AntiWedgeRight6RefinementPattern4AWR6_4Pr() {}
1331
1333 Real refine_matrix(const Integer i, const Integer j, const Integer k) const
1334 {
1335 if (i < 4)
1336 return _refine_matrix_1[i][j][k];
1337 return _refine_matrix_2[i - 4][j][k];
1338 }
1339 Integer face_mapping(const Integer, const Integer) const
1340 {
1341 throw FatalErrorException(A_FUNCINFO, "not implemented");
1342 }
1343 Integer hChildrenTypeId(const Integer i) const
1344 {
1345 if (i < 4)
1346 return IT_AntiWedgeRight6;
1347 return IT_Pentaedron6;
1348 }
1349 Integer getNbHChildren() const
1350 {
1351 return m_nb_hChildren;
1352 }
1353
1354 private:
1355
1356 static const Integer m_nb_hChildren = 8;
1357 static const double _refine_matrix_1[4][6][6];
1358 static const double _refine_matrix_2[4][6][6];
1359};
1360
1361/*---------------------------------------------------------------------------*/
1362/*---------------------------------------------------------------------------*/
1363
1364class ARCANE_CORE_EXPORT AntiWedgeRight6RefinementPattern9AWR6_18Pr
1365: public RefinementPatternT<AntiWedgeRight6RefinementPattern9AWR6_18Pr>
1366{
1367 public:
1368
1369 AntiWedgeRight6RefinementPattern9AWR6_18Pr() {}
1370
1372 Real refine_matrix(const Integer i, const Integer j, const Integer k) const
1373 {
1374 if (i < 9)
1375 return _refine_matrix_1[i][j][k];
1376 return _refine_matrix_2[i - 9][j][k];
1377 throw NotSupportedException(A_FUNCINFO);
1378 }
1379 Integer face_mapping(const Integer, const Integer) const
1380 {
1381 throw FatalErrorException(A_FUNCINFO, "not implemented");
1382 }
1383 Integer hChildrenTypeId(const Integer i) const
1384 {
1385 if (i < 9)
1386 return IT_AntiWedgeRight6;
1387 return IT_Pentaedron6;
1388 }
1389 Integer getNbHChildren() const
1390 {
1391 return m_nb_hChildren;
1392 }
1393
1394 private:
1395
1396 static const Integer m_nb_hChildren = 27;
1397 static const double _refine_matrix_1[9][6][6];
1398 static const double _refine_matrix_2[18][6][6];
1399};
1400
1401/*---------------------------------------------------------------------------*/
1402/*---------------------------------------------------------------------------*/
1403
1404template <>
1405class ARCANE_CORE_EXPORT ItemRefinementPatternT<IT_DiTetra5> : public RefinementPatternT<ItemRefinementPatternT<IT_DiTetra5>>
1406{
1407 public:
1408
1409 ItemRefinementPatternT() {}
1410
1412 Real refine_matrix(const Integer i, const Integer j, const Integer k) const
1413 {
1414 if (i < 2)
1415 return _refine_matrix_1[i][j][k];
1416 return _refine_matrix_2[i - 2][j][k];
1417 }
1418
1419 Integer face_mapping(const Integer i, const Integer j) const
1420 {
1421 if (i < 2)
1422 return _face_mapping_1[i][j];
1423 return _face_mapping_2[i - 2][j];
1424 }
1425 Integer face_mapping_topo(const Integer i, const Integer j) const
1426 {
1427 if (i < 2)
1428 return _face_mapping_topo_1[i][j];
1429 return _face_mapping_topo_2[i - 2][j];
1430 }
1431 Integer hChildrenTypeId(const Integer i) const
1432 {
1433 if (i < 2)
1434 return IT_Hexaedron8;
1435 return IT_HemiHexa7;
1436 }
1437 Integer getNbHChildren() const
1438 {
1439 return m_nb_hChildren;
1440 }
1441
1442 private:
1443
1444 static const Integer m_nb_hChildren = 8;
1445 static const double _refine_matrix_1[2][8][5];
1446 static const Integer _face_mapping_1[2][6];
1447 static const Integer _face_mapping_topo_1[2][6];
1448 static const double _refine_matrix_2[6][7][5];
1449 static const Integer _face_mapping_2[6][6];
1450 static const Integer _face_mapping_topo_2[6][6];
1451};
1452
1453/*---------------------------------------------------------------------------*/
1454/*---------------------------------------------------------------------------*/
1455
1456class ARCANE_CORE_EXPORT DiTetra5RefinementPattern3DT_4Py_2T
1457: public RefinementPatternT<DiTetra5RefinementPattern3DT_4Py_2T>
1458{
1459 public:
1460
1461 DiTetra5RefinementPattern3DT_4Py_2T() {}
1462
1464 Real refine_matrix(const Integer i, const Integer j, const Integer k) const
1465 {
1466 if (i < 3)
1467 return _refine_matrix_1[i][j][k];
1468 if (i < 7)
1469 return _refine_matrix_2[i - 3][j][k];
1470 return _refine_matrix_3[i - 7][j][k];
1471 }
1472 Integer face_mapping(const Integer, const Integer) const
1473 {
1474 throw FatalErrorException(A_FUNCINFO, "not implemented");
1475 }
1476 Integer hChildrenTypeId(const Integer i) const
1477 {
1478 if (i < 3)
1479 return IT_DiTetra5;
1480 if (i < 7)
1481 return IT_Pyramid5;
1482 return IT_Tetraedron4;
1483 }
1484 Integer getNbHChildren() const
1485 {
1486 return m_nb_hChildren;
1487 }
1488
1489 private:
1490
1491 static const Integer m_nb_hChildren = 9;
1492 static const double _refine_matrix_1[3][5][5];
1493 static const double _refine_matrix_2[4][5][5];
1494 static const double _refine_matrix_3[2][4][5];
1495};
1496
1497/*---------------------------------------------------------------------------*/
1498/*---------------------------------------------------------------------------*/
1499
1500class ARCANE_CORE_EXPORT DiTetra5RefinementPattern7DT_2T
1501: public RefinementPatternT<DiTetra5RefinementPattern7DT_2T>
1502{
1503 public:
1504
1505 DiTetra5RefinementPattern7DT_2T() {}
1506
1508 Real refine_matrix(const Integer i, const Integer j, const Integer k) const
1509 {
1510 if (i < 7)
1511 return _refine_matrix_1[i][j][k];
1512 return _refine_matrix_2[i - 7][j][k];
1513 }
1514 Integer face_mapping(const Integer, const Integer) const
1515 {
1516 throw FatalErrorException(A_FUNCINFO, "not implemented");
1517 }
1518 Integer hChildrenTypeId(const Integer i) const
1519 {
1520 if (i < 7)
1521 return IT_DiTetra5;
1522 return IT_Tetraedron4;
1523 }
1524 Integer getNbHChildren() const
1525 {
1526 return m_nb_hChildren;
1527 }
1528
1529 private:
1530
1531 static const Integer m_nb_hChildren = 9;
1532 static const double _refine_matrix_1[7][5][5];
1533 static const double _refine_matrix_2[2][4][5];
1534};
1535
1536/*---------------------------------------------------------------------------*/
1537/*---------------------------------------------------------------------------*/
1538
1539class ARCANE_CORE_EXPORT DiTetra5RefinementPattern64T
1540: public RefinementPatternT<DiTetra5RefinementPattern64T>
1541{
1542 public:
1543
1544 DiTetra5RefinementPattern64T() {}
1545
1547 Real refine_matrix(const Integer, const Integer, const Integer) const
1548 {
1549 throw NotSupportedException(A_FUNCINFO);
1550 }
1551 Integer face_mapping(const Integer, const Integer) const
1552 {
1553 throw FatalErrorException(A_FUNCINFO, "not implemented");
1554 }
1555 Integer hChildrenTypeId(const Integer) const
1556 {
1557 return IT_Tetraedron4;
1558 }
1559 Integer getNbHChildren() const
1560 {
1561 return m_nb_hChildren;
1562 }
1563
1564 private:
1565
1566 static const Integer m_nb_hChildren = 64;
1567 static const double _refine_matrix_1[64][4][5];
1568};
1569
1570/*---------------------------------------------------------------------------*/
1571/*---------------------------------------------------------------------------*/
1572
1573class ARCANE_CORE_EXPORT DiTetra5RefinementPattern32DT
1574: public RefinementPatternT<DiTetra5RefinementPattern32DT>
1575{
1576 public:
1577
1578 DiTetra5RefinementPattern32DT() {}
1579
1581 Real refine_matrix(const Integer, const Integer, const Integer) const
1582 {
1583 throw NotSupportedException(A_FUNCINFO);
1584 }
1585 Integer face_mapping(const Integer, const Integer) const
1586 {
1587 throw NotSupportedException(A_FUNCINFO);
1588 }
1589 Integer hChildrenTypeId(const Integer) const
1590 {
1591 return IT_Tetraedron4;
1592 }
1593 Integer getNbHChildren() const
1594 {
1595 return m_nb_hChildren;
1596 }
1597
1598 private:
1599
1600 static const Integer m_nb_hChildren = 32;
1601 static const double _refine_matrix_1[32][5][5];
1602};
1603
1604/*---------------------------------------------------------------------------*/
1605/*---------------------------------------------------------------------------*/
1606
1607} // End namespace Arcane
1608
1609/*---------------------------------------------------------------------------*/
1610/*---------------------------------------------------------------------------*/
1611
1612#endif
ArcaneGlobal.h
Arcane configuration file.
ArcaneTypes.h
Declarations of Arcane's general types.
Arcane::AntiWedgeLeft6RefinementPattern4AWL6_4Pr::refine_matrix
Real refine_matrix(const Integer i, const Integer j, const Integer k) const
transformation matrix of the parent cell nodes into child cell nodes
Definition ItemRefinementPattern.h:1205
Arcane::AntiWedgeLeft6RefinementPattern9AWL6_18Pr::refine_matrix
Real refine_matrix(const Integer i, const Integer j, const Integer k) const
transformation matrix of the parent cell nodes into child cell nodes
Definition ItemRefinementPattern.h:1244
Arcane::AntiWedgeRight6RefinementPattern4AWR6_4Pr::refine_matrix
Real refine_matrix(const Integer i, const Integer j, const Integer k) const
transformation matrix of the parent cell nodes into child cell nodes
Definition ItemRefinementPattern.h:1333
Arcane::AntiWedgeRight6RefinementPattern9AWR6_18Pr::refine_matrix
Real refine_matrix(const Integer i, const Integer j, const Integer k) const
transformation matrix of the parent cell nodes into child cell nodes
Definition ItemRefinementPattern.h:1372
Arcane::DiTetra5RefinementPattern32DT::refine_matrix
Real refine_matrix(const Integer, const Integer, const Integer) const
transformation matrix of the parent cell nodes into child cell nodes
Definition ItemRefinementPattern.h:1581
Arcane::DiTetra5RefinementPattern3DT_4Py_2T::refine_matrix
Real refine_matrix(const Integer i, const Integer j, const Integer k) const
transformation matrix of the parent cell nodes into child cell nodes
Definition ItemRefinementPattern.h:1464
Arcane::DiTetra5RefinementPattern64T::refine_matrix
Real refine_matrix(const Integer, const Integer, const Integer) const
transformation matrix of the parent cell nodes into child cell nodes
Definition ItemRefinementPattern.h:1547
Arcane::DiTetra5RefinementPattern7DT_2T::refine_matrix
Real refine_matrix(const Integer i, const Integer j, const Integer k) const
transformation matrix of the parent cell nodes into child cell nodes
Definition ItemRefinementPattern.h:1508
Arcane::HemiHex5RefinementPattern3HHex5_2Pr_1HHex7::refine_matrix
Real refine_matrix(const Integer i, const Integer j, const Integer k) const
transformation matrix of the nodes of the parent cell to the nodes of the child cells
Definition ItemRefinementPattern.h:761
Arcane::HemiHex5RefinementPattern7HHex5_4Pr_3HHex6_2HHex7_1Hex::refine_matrix
Real refine_matrix(const Integer i, const Integer j, const Integer k) const
transformation matrix of the nodes of the parent cell to the nodes of the child cells
Definition ItemRefinementPattern.h:808
Arcane::HemiHex6RefinementPattern4HHex5_4HHex7::refine_matrix
Real refine_matrix(const Integer i, const Integer j, const Integer k) const
transformation matrix of the nodes of the parent cell to the nodes of the child cells
Definition ItemRefinementPattern.h:915
Arcane::HemiHex6RefinementPattern6HHex6_12HHex5_6HHex7_1Hex::refine_matrix
Real refine_matrix(const Integer i, const Integer j, const Integer k) const
transformation matrix of the nodes of the parent cell to the nodes of the child cells
Definition ItemRefinementPattern.h:954
Arcane::HemiHex7RefinementPattern4HHex7_4Pr_2HHex5_1Hex::refine_matrix
Real refine_matrix(const Integer i, const Integer j, const Integer k) const
transformation matrix of the nodes of the parent cell to the nodes of the child cells
Definition ItemRefinementPattern.h:1057
Arcane::HemiHex7RefinementPattern8HHex7_14Pr_9HHex5_7Hex::refine_matrix
Real refine_matrix(const Integer i, const Integer j, const Integer k) const
transformation matrix of the parent cell nodes into child cell nodes
Definition ItemRefinementPattern.h:1106
Arcane::HexRefinementPattern27Hex::refine_matrix
Real refine_matrix(const Integer, const Integer, const Integer) const
transformation matrix of the parent cell nodes to the child cell nodes
Definition ItemRefinementPattern.h:189
Arcane::ItemRefinementPatternT< IT_AntiWedgeLeft6 >::refine_matrix
Real refine_matrix(const Integer i, const Integer j, const Integer k) const
transformation matrix of the parent cell nodes into child cell nodes
Definition ItemRefinementPattern.h:1155
Arcane::ItemRefinementPatternT< IT_AntiWedgeRight6 >::refine_matrix
Real refine_matrix(const Integer i, const Integer j, const Integer k) const
transformation matrix of the parent cell nodes into child cell nodes
Definition ItemRefinementPattern.h:1283
Arcane::ItemRefinementPatternT< IT_DiTetra5 >::face_mapping
Integer face_mapping(const Integer i, const Integer j) const
mapping of child cell face orientations with parent cell faces
Definition ItemRefinementPattern.h:1419
Arcane::ItemRefinementPatternT< IT_DiTetra5 >::refine_matrix
Real refine_matrix(const Integer i, const Integer j, const Integer k) const
transformation matrix of the parent cell nodes into child cell nodes
Definition ItemRefinementPattern.h:1412
Arcane::ItemRefinementPatternT< IT_HemiHexa5 >::face_mapping
Integer face_mapping(const Integer i, const Integer j) const
mapping of the orientations of the faces of the child cells with the faces of the parent cell
Definition ItemRefinementPattern.h:704
Arcane::ItemRefinementPatternT< IT_HemiHexa5 >::refine_matrix
Real refine_matrix(const Integer i, const Integer j, const Integer k) const
transformation matrix of the nodes of the parent cell to the nodes of the child cells
Definition ItemRefinementPattern.h:695
Arcane::ItemRefinementPatternT< IT_HemiHexa6 >::refine_matrix
Real refine_matrix(const Integer i, const Integer j, const Integer k) const
transformation matrix of the nodes of the parent cell to the nodes of the child cells
Definition ItemRefinementPattern.h:862
Arcane::ItemRefinementPatternT< IT_HemiHexa7 >::refine_matrix
Real refine_matrix(const Integer i, const Integer j, const Integer k) const
transformation matrix of the nodes of the parent cell to the nodes of the child cells
Definition ItemRefinementPattern.h:1003
Arcane::ItemRefinementPatternT< IT_HemiHexa7 >::face_mapping
Integer face_mapping(const Integer i, const Integer j) const
mapping of the orientations of the faces of the child cells with the faces of the parent cell
Definition ItemRefinementPattern.h:1010
Arcane::ItemRefinementPatternT< IT_Hexaedron8 >::refine_matrix
Real refine_matrix(const Integer i, const Integer j, const Integer k) const
transformation matrix of the parent cell nodes to the child cell nodes
Definition ItemRefinementPattern.h:148
Arcane::ItemRefinementPatternT< IT_Pentaedron6 >::refine_matrix
Real refine_matrix(const Integer i, const Integer j, const Integer k) const
transformation matrix of the parent cell nodes to the child cell nodes
Definition ItemRefinementPattern.h:368
Arcane::ItemRefinementPatternT< IT_Pyramid5 >::refine_matrix
Real refine_matrix(const Integer i, const Integer j, const Integer k) const
transformation matrix of the parent cell nodes to the child cell nodes
Definition ItemRefinementPattern.h:490
Arcane::ItemRefinementPatternT< IT_Quad4 >::refine_matrix
Real refine_matrix(const Integer i, const Integer j, const Integer k) const
transformation matrix of the parent cell nodes to the child cell nodes
Definition ItemRefinementPattern.h:106
Arcane::ItemRefinementPatternT< IT_Tetraedron4 >::refine_matrix
Real refine_matrix(const Integer i, const Integer j, const Integer k) const
transformation matrix of the parent cell nodes to the child cell nodes
Definition ItemRefinementPattern.h:223
Arcane::PrismRefinementPattern27Pr::refine_matrix
Real refine_matrix(const Integer, const Integer, const Integer) const
transformation matrix of the parent cell nodes to the child cell nodes
Definition ItemRefinementPattern.h:455
Arcane::PrismRefinementPattern8Pr::refine_matrix
Real refine_matrix(const Integer i, const Integer j, const Integer k) const
transformation matrix of the parent cell nodes to the child cell nodes
Definition ItemRefinementPattern.h:421
Arcane::PyramidRefinementPattern19Py12T::refine_matrix
Real refine_matrix(const Integer i, const Integer j, const Integer k) const
transformation matrix of the nodes of the parent cell to the nodes of the child cells
Definition ItemRefinementPattern.h:655
Arcane::PyramidRefinementPattern4Py8T::refine_matrix
Real refine_matrix(const Integer i, const Integer j, const Integer k) const
transformation matrix of the nodes of the parent cell to the nodes of the child cells
Definition ItemRefinementPattern.h:542
Arcane::PyramidRefinementPattern4Py::refine_matrix
Real refine_matrix(const Integer, const Integer, const Integer) const
transformation matrix of the nodes of the parent cell to the nodes of the child cells
Definition ItemRefinementPattern.h:621
Arcane::PyramidRefinementPattern6Py4T::refine_matrix
Real refine_matrix(const Integer i, const Integer j, const Integer k) const
transformation matrix of the nodes of the parent cell to the nodes of the child cells
Definition ItemRefinementPattern.h:583
Arcane::RefinementPatternT::asImp
TypeImp & asImp()
Barton & Nackman Trick.
Definition ItemRefinementPattern.h:65
Arcane::TetraRefinementPattern32T::refine_matrix
Real refine_matrix(const Integer, const Integer, const Integer) const
transformation matrix of the parent cell nodes to the child cell nodes
Definition ItemRefinementPattern.h:334
Arcane::TetraRefinementPattern8T::refine_matrix
Real refine_matrix(const Integer i, const Integer j, const Integer k) const
transformation matrix of the parent cell nodes to the child cell nodes
Definition ItemRefinementPattern.h:300
Arcane
-- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature --
Definition arcane/src/arcane/accelerator/AcceleratorGlobal.h:37
Arcane::Integer
Int32 Integer
Type representing an integer.
Definition ArccoreGlobal.h:293
Arcane::Real
double Real
Type representing a real number.
Definition ArccoreGlobal.h:275