Arcane  v4.1.1.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
CartesianMeshNumberingMngInternal.cc
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2025 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/* CartesianMeshNumberingMngInternal.cc (C) 2000-2025 */
9/* */
10/* Gestionnaire de numérotation de maillage cartesian. La numérotation */
11/* des mailles et des noeuds est assez classique, la numérotation des faces */
12/* est expliquée (entre autres) dans les méthodes 'faceUniqueId()' et */
13/* 'cellFaceUniqueIds()'. */
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17#include "arcane/cartesianmesh/internal/CartesianMeshNumberingMngInternal.h"
18
19#include "arcane/utils/Vector2.h"
20#include "arcane/utils/ITraceMng.h"
21
22#include "arcane/core/IMesh.h"
23#include "arcane/core/IParallelMng.h"
24#include "arcane/core/VariableTypes.h"
25#include "arcane/core/ICartesianMeshGenerationInfo.h"
26#include "arcane/core/IItemFamily.h"
27#include "arcane/core/IMeshModifier.h"
28#include "arcane/core/Properties.h"
29
30/*---------------------------------------------------------------------------*/
31/*---------------------------------------------------------------------------*/
32
33namespace Arcane
34{
35
36/*---------------------------------------------------------------------------*/
37/*---------------------------------------------------------------------------*/
38
39CartesianMeshNumberingMngInternal::
40CartesianMeshNumberingMngInternal(IMesh* mesh)
41: TraceAccessor(mesh->traceMng())
42, m_mesh(mesh)
43, m_dimension(mesh->dimension())
44, m_pattern(2)
45, m_max_level(0)
46, m_min_level(0)
47, m_converting_numbering_face(true)
48, m_ori_level(0)
49{
50 const auto* m_generation_info = ICartesianMeshGenerationInfo::getReference(m_mesh, true);
51
52 Int64ConstArrayView global_nb_cells_by_direction = m_generation_info->globalNbCells();
53 m_nb_cell_ground.x = global_nb_cells_by_direction[MD_DirX];
54 m_nb_cell_ground.y = global_nb_cells_by_direction[MD_DirY];
55 m_nb_cell_ground.z = ((m_dimension == 2) ? 1 : global_nb_cells_by_direction[MD_DirZ]);
56
57 if (m_nb_cell_ground.x <= 0)
58 ARCANE_FATAL("Bad value '{0}' for globalNbCells()[MD_DirX] (should be >0)", m_nb_cell_ground.x);
59 if (m_nb_cell_ground.y <= 0)
60 ARCANE_FATAL("Bad value '{0}' for globalNbCells()[MD_DirY] (should be >0)", m_nb_cell_ground.y);
61 if (m_nb_cell_ground.z <= 0)
62 ARCANE_FATAL("Bad value '{0}' for globalNbCells()[MD_DirZ] (should be >0)", m_nb_cell_ground.z);
63
64 if (m_dimension == 2) {
65 m_latest_cell_uid = m_nb_cell_ground.x * m_nb_cell_ground.y;
66 m_latest_node_uid = (m_nb_cell_ground.x + 1) * (m_nb_cell_ground.y + 1);
67 m_latest_face_uid = (m_nb_cell_ground.x * m_nb_cell_ground.y) * 2 + m_nb_cell_ground.x * 2 + m_nb_cell_ground.y;
68 }
69 else {
70 m_latest_cell_uid = m_nb_cell_ground.x * m_nb_cell_ground.y * m_nb_cell_ground.z;
71 m_latest_node_uid = (m_nb_cell_ground.x + 1) * (m_nb_cell_ground.y + 1) * (m_nb_cell_ground.z + 1);
72 m_latest_face_uid = (m_nb_cell_ground.x + 1) * m_nb_cell_ground.y * m_nb_cell_ground.z + (m_nb_cell_ground.y + 1) * m_nb_cell_ground.z * m_nb_cell_ground.x + (m_nb_cell_ground.z + 1) * m_nb_cell_ground.x * m_nb_cell_ground.y;
73 }
74
75 m_first_cell_uid_level.add(0);
76 m_first_node_uid_level.add(0);
77 m_first_face_uid_level.add(0);
78
79 // Tant qu'on utilise la numérotation d'origine pour le niveau 0, on doit utiliser
80 // une conversion de la numérotation d'origine vers la nouvelle.
81 // TODO AH : Ça risque de pas très bien se passer en cas de repartitionnement...
82 if (m_converting_numbering_face) {
83 UniqueArray<Int64> face_uid(CartesianMeshNumberingMngInternal::nbFaceByCell());
84 ENUMERATE_ (Cell, icell, m_mesh->allLevelCells(0)) {
85 CartesianMeshNumberingMngInternal::cellFaceUniqueIds(face_uid, 0, icell->uniqueId());
86 for (Integer i = 0; i < CartesianMeshNumberingMngInternal::nbFaceByCell(); ++i) {
87 m_face_ori_numbering_to_new[icell->face(i).uniqueId()] = face_uid[i];
88 m_face_new_numbering_to_ori[face_uid[i]] = icell->face(i).uniqueId();
89 // debug() << "Face Ori <-> New -- Ori : " << icell->face(i).uniqueId() << " -- New : " << face_uid[i];
90 }
91 }
92 }
93}
94
95/*---------------------------------------------------------------------------*/
96/*---------------------------------------------------------------------------*/
97
98void CartesianMeshNumberingMngInternal::
99_build()
100{
101 m_properties = makeRef(new Properties(*(m_mesh->properties()), "CartesianMeshNumberingMngInternal"));
102}
103
104/*---------------------------------------------------------------------------*/
105/*---------------------------------------------------------------------------*/
106
107void CartesianMeshNumberingMngInternal::
108_saveInfosInProperties()
109{
110 m_properties->set("Version", 1);
111 m_properties->set("FirstCellUIDByLevel", m_first_cell_uid_level);
112
113 // Voir pour le recalculer à la reprise.
114 m_properties->set("FirstNodeUIDByLevel", m_first_node_uid_level);
115 m_properties->set("FirstFaceUIDByLevel", m_first_face_uid_level);
116
117 m_properties->set("OriginalGroundLevelForConverting", m_ori_level);
118}
119
120/*---------------------------------------------------------------------------*/
121/*---------------------------------------------------------------------------*/
122
123void CartesianMeshNumberingMngInternal::
124_recreateFromDump()
125{
126 Int32 v = m_properties->getInt32("Version");
127 if (v != 1)
128 ARCANE_FATAL("Bad numbering mng version: trying to read from incompatible checkpoint v={0} expected={1}", v, 1);
129
130 m_properties->get("FirstCellUIDByLevel", m_first_cell_uid_level);
131 m_properties->get("FirstNodeUIDByLevel", m_first_node_uid_level);
132 m_properties->get("FirstFaceUIDByLevel", m_first_face_uid_level);
133
134 m_properties->get("OriginalGroundLevelForConverting", m_ori_level);
135 if (m_ori_level == -1) {
136 m_converting_numbering_face = false;
137 m_face_ori_numbering_to_new.clear();
138 m_face_new_numbering_to_ori.clear();
139 }
140
141 m_nb_cell_ground = { globalNbCellsX(0), globalNbCellsY(0), globalNbCellsZ(0) };
142
143 m_max_level = m_first_cell_uid_level.size() - 1;
144
145 {
146 Integer pos = 0;
147 Int64 max = 0;
148 Integer iter = 0;
149 for (const Int64 elem : m_first_cell_uid_level) {
150 if (elem > max) {
151 max = elem;
152 pos = iter;
153 }
154 iter++;
155 }
156 m_latest_cell_uid = m_first_cell_uid_level[pos] + nbCellInLevel(pos);
157 m_latest_node_uid = m_first_node_uid_level[pos] + nbNodeInLevel(pos);
158 m_latest_face_uid = m_first_face_uid_level[pos] + nbFaceInLevel(pos);
159 }
160}
161
162/*---------------------------------------------------------------------------*/
163/*---------------------------------------------------------------------------*/
164
165void CartesianMeshNumberingMngInternal::
166renumberingFacesLevel0FromOriginalArcaneNumbering()
167{
168 if (!m_converting_numbering_face)
169 return;
170
171 UniqueArray<Int64> face_uid(nbFaceByCell());
172 ENUMERATE_ (Cell, icell, m_mesh->allLevelCells(m_ori_level)) {
173 cellFaceUniqueIds(face_uid, m_ori_level, icell->uniqueId());
174 for (Integer i = 0; i < nbFaceByCell(); ++i) {
175 // debug() << "Face Ori <-> New -- Ori : " << icell->face(i).uniqueId() << " -- New : " << face_uid[i];
176 icell->face(i).mutableItemBase().setUniqueId(face_uid[i]);
177 }
178 }
179 m_mesh->faceFamily()->notifyItemsUniqueIdChanged();
180 m_mesh->modifier()->endUpdate();
181 m_mesh->checkValidMesh();
182
183 m_converting_numbering_face = false;
184 m_ori_level = -1;
185 m_face_ori_numbering_to_new.clear();
186 m_face_new_numbering_to_ori.clear();
187}
188
189/*---------------------------------------------------------------------------*/
190/*---------------------------------------------------------------------------*/
191
192void CartesianMeshNumberingMngInternal::
193printStatus()
194{
195 ITraceMng* tm = m_mesh->traceMng();
196 Trace::Setter _(tm, "CartesianMeshNumberingMngInternal");
197
198 tm->info() << "CartesianMeshNumberingMngInternal status :";
199
200 // tm->info() << "FirstCellUIDByLevel : " << m_first_cell_uid_level;
201 // tm->info() << "FirstNodeUIDByLevel : " << m_first_node_uid_level;
202 // tm->info() << "FirstFaceUIDByLevel : " << m_first_face_uid_level;
203
204 tm->info() << "LatestCellUID : " << m_latest_cell_uid;
205 tm->info() << "LatestNodeUID : " << m_latest_node_uid;
206 tm->info() << "LatestFaceUID : " << m_latest_face_uid;
207
208 tm->info() << "MinLevel : " << m_min_level;
209 tm->info() << "MaxLevel : " << m_max_level;
210
211 tm->info() << "GroundLevelNbCells : " << m_nb_cell_ground;
212
213 if (m_ori_level == -1) {
214 tm->info() << "Ground Level is renumbered";
215 }
216 else {
217 tm->info() << "Ground Level is not renumbered -- OriginalGroundLevel : " << m_ori_level;
218 }
219
220 for (Integer i = m_min_level; i <= m_max_level; ++i) {
221 tm->info() << "Level " << i << " : ";
222 tm->info() << "\tUID Cells : [" << firstCellUniqueId(i) << ", " << (firstCellUniqueId(i) + nbCellInLevel(i)) << "[";
223 tm->info() << "\tUID Nodes : [" << firstNodeUniqueId(i) << ", " << (firstNodeUniqueId(i) + nbNodeInLevel(i)) << "[";
224 tm->info() << "\tUID Faces : [" << firstFaceUniqueId(i) << ", " << (firstFaceUniqueId(i) + nbFaceInLevel(i)) << "[";
225 }
226
227 const auto* m_generation_info = ICartesianMeshGenerationInfo::getReference(m_mesh, true);
228
229 Int64ConstArrayView global_nb_cells_by_direction = m_generation_info->globalNbCells();
230 tm->info() << "global_nb_cells_by_direction.x : " << global_nb_cells_by_direction[MD_DirX];
231 tm->info() << "global_nb_cells_by_direction.y : " << global_nb_cells_by_direction[MD_DirY];
232 tm->info() << "global_nb_cells_by_direction.z : " << global_nb_cells_by_direction[MD_DirZ];
233}
234
235/*---------------------------------------------------------------------------*/
236/*---------------------------------------------------------------------------*/
237
238void CartesianMeshNumberingMngInternal::
239prepareLevel(Int32 level)
240{
241 if (level <= m_max_level && level >= m_min_level)
242 return;
243 if (level == m_max_level + 1) {
244 m_max_level++;
245 m_first_cell_uid_level.add(m_latest_cell_uid);
246 m_first_node_uid_level.add(m_latest_node_uid);
247 m_first_face_uid_level.add(m_latest_face_uid);
248 }
249 else if (level == m_min_level - 1) {
250 m_min_level--;
251 _pushFront(m_first_cell_uid_level, m_latest_cell_uid);
252 _pushFront(m_first_node_uid_level, m_latest_node_uid);
253 _pushFront(m_first_face_uid_level, m_latest_face_uid);
254 }
255 else {
256 ARCANE_FATAL("Level error : {0}", level);
257 }
258
259 m_latest_cell_uid += nbCellInLevel(level);
260 m_latest_node_uid += nbNodeInLevel(level);
261 m_latest_face_uid += nbFaceInLevel(level);
262}
263
264/*---------------------------------------------------------------------------*/
265/*---------------------------------------------------------------------------*/
266
267void CartesianMeshNumberingMngInternal::
268updateFirstLevel()
269{
270 const Int32 nb_levels_to_add = -m_min_level;
271 m_ori_level += nb_levels_to_add;
272
273 if (nb_levels_to_add == 0) {
274 return;
275 }
276
277 m_max_level += nb_levels_to_add;
278 m_min_level += nb_levels_to_add;
279
280 const Integer to_div = m_pattern * nb_levels_to_add;
281 if (m_dimension == 2) {
282 m_nb_cell_ground.x /= to_div;
283 m_nb_cell_ground.y /= to_div;
284 // z reste à 1.
285 }
286 else {
287 m_nb_cell_ground /= to_div;
288 }
289
290 // ----------
291 // CartesianMeshCoarsening2::_recomputeMeshGenerationInfo()
292 // Recalcule les informations sur le nombre de mailles par direction.
293 auto* cmgi = ICartesianMeshGenerationInfo::getReference(m_mesh, false);
294 if (!cmgi)
295 return;
296
297 {
298 ConstArrayView<Int64> v = cmgi->ownCellOffsets();
299 cmgi->setOwnCellOffsets(v[0] / to_div, v[1] / to_div, v[2] / to_div);
300 }
301 {
302 ConstArrayView<Int64> v = cmgi->globalNbCells();
303 cmgi->setGlobalNbCells(v[0] / to_div, v[1] / to_div, v[2] / to_div);
304 }
305 {
306 ConstArrayView<Int32> v = cmgi->ownNbCells();
307 cmgi->setOwnNbCells(v[0] / to_div, v[1] / to_div, v[2] / to_div);
308 }
309 cmgi->setFirstOwnCellUniqueId(firstCellUniqueId(0));
310 // CartesianMeshCoarsening2::_recomputeMeshGenerationInfo()
311 // ----------
312}
313
314/*---------------------------------------------------------------------------*/
315/*---------------------------------------------------------------------------*/
316
317Int64 CartesianMeshNumberingMngInternal::
318firstCellUniqueId(Integer level) const
319{
320 return m_first_cell_uid_level[level - m_min_level];
321}
322
323/*---------------------------------------------------------------------------*/
324/*---------------------------------------------------------------------------*/
325
326Int64 CartesianMeshNumberingMngInternal::
327firstNodeUniqueId(Integer level) const
328{
329 return m_first_node_uid_level[level - m_min_level];
330}
331
332/*---------------------------------------------------------------------------*/
333/*---------------------------------------------------------------------------*/
334
335Int64 CartesianMeshNumberingMngInternal::
336firstFaceUniqueId(Integer level) const
337{
338 return m_first_face_uid_level[level - m_min_level];
339}
340
341/*---------------------------------------------------------------------------*/
342/*---------------------------------------------------------------------------*/
343
344Int64 CartesianMeshNumberingMngInternal::
345globalNbCellsX(Integer level) const
346{
347 return static_cast<Int64>(static_cast<Real>(m_nb_cell_ground.x) * std::pow(m_pattern, level));
348}
349
350/*---------------------------------------------------------------------------*/
351/*---------------------------------------------------------------------------*/
352
353Int64 CartesianMeshNumberingMngInternal::
354globalNbCellsY(Integer level) const
355{
356 return static_cast<Int64>(static_cast<Real>(m_nb_cell_ground.y) * std::pow(m_pattern, level));
357}
358
359/*---------------------------------------------------------------------------*/
360/*---------------------------------------------------------------------------*/
361
362Int64 CartesianMeshNumberingMngInternal::
363globalNbCellsZ(Integer level) const
364{
365 return static_cast<Int64>(static_cast<Real>(m_nb_cell_ground.z) * std::pow(m_pattern, level));
366}
367
368/*---------------------------------------------------------------------------*/
369/*---------------------------------------------------------------------------*/
370
371Int64 CartesianMeshNumberingMngInternal::
372globalNbNodesX(Integer level) const
373{
374 return globalNbCellsX(level) + 1;
375}
376
377/*---------------------------------------------------------------------------*/
378/*---------------------------------------------------------------------------*/
379
380Int64 CartesianMeshNumberingMngInternal::
381globalNbNodesY(Integer level) const
382{
383 return globalNbCellsY(level) + 1;
384}
385
386/*---------------------------------------------------------------------------*/
387/*---------------------------------------------------------------------------*/
388
389Int64 CartesianMeshNumberingMngInternal::
390globalNbNodesZ(Integer level) const
391{
392 return globalNbCellsZ(level) + 1;
393}
394
395/*---------------------------------------------------------------------------*/
396/*---------------------------------------------------------------------------*/
397
398Int64 CartesianMeshNumberingMngInternal::
399globalNbFacesX(Integer level) const
400{
401 return globalNbCellsX(level) + 1;
402}
403
404/*---------------------------------------------------------------------------*/
405/*---------------------------------------------------------------------------*/
406
407Int64 CartesianMeshNumberingMngInternal::
408globalNbFacesY(Integer level) const
409{
410 return globalNbCellsY(level) + 1;
411}
412
413/*---------------------------------------------------------------------------*/
414/*---------------------------------------------------------------------------*/
415
416Int64 CartesianMeshNumberingMngInternal::
417globalNbFacesZ(Integer level) const
418{
419 return globalNbCellsZ(level) + 1;
420}
421
422/*---------------------------------------------------------------------------*/
423/*---------------------------------------------------------------------------*/
424
425Int64 CartesianMeshNumberingMngInternal::
426globalNbFacesXCartesianView(Integer level) const
427{
428 return (globalNbCellsX(level) * 2) + 1;
429}
430
431/*---------------------------------------------------------------------------*/
432/*---------------------------------------------------------------------------*/
433
434Int64 CartesianMeshNumberingMngInternal::
435globalNbFacesYCartesianView(Integer level) const
436{
437 return (globalNbCellsY(level) * 2) + 1;
438}
439
440/*---------------------------------------------------------------------------*/
441/*---------------------------------------------------------------------------*/
442
443Int64 CartesianMeshNumberingMngInternal::
444globalNbFacesZCartesianView(Integer level) const
445{
446 return (globalNbCellsZ(level) * 2) + 1;
447}
448
449/*---------------------------------------------------------------------------*/
450/*---------------------------------------------------------------------------*/
451
452Int64 CartesianMeshNumberingMngInternal::
453nbCellInLevel(Integer level) const
454{
455 if (m_dimension == 2) {
456 const Int64x2 nb_cell(globalNbCellsX(level), globalNbCellsY(level));
457 return nb_cell.x * nb_cell.y;
458 }
459
460 const Int64x3 nb_cell(globalNbCellsX(level), globalNbCellsY(level), globalNbCellsZ(level));
461 return nb_cell.x * nb_cell.y * nb_cell.z;
462}
463
464/*---------------------------------------------------------------------------*/
465/*---------------------------------------------------------------------------*/
466
467Int64 CartesianMeshNumberingMngInternal::
468nbNodeInLevel(Integer level) const
469{
470 if (m_dimension == 2) {
471 const Int64x2 nb_cell(globalNbCellsX(level), globalNbCellsY(level));
472 return (nb_cell.x + 1) * (nb_cell.y + 1);
473 }
474
475 const Int64x3 nb_cell(globalNbCellsX(level), globalNbCellsY(level), globalNbCellsZ(level));
476 return (nb_cell.x + 1) * (nb_cell.y + 1) * (nb_cell.z + 1);
477}
478
479/*---------------------------------------------------------------------------*/
480/*---------------------------------------------------------------------------*/
481
482Int64 CartesianMeshNumberingMngInternal::
483nbFaceInLevel(Integer level) const
484{
485 if (m_dimension == 2) {
486 const Int64x2 nb_cell(globalNbCellsX(level), globalNbCellsY(level));
487 return (nb_cell.x * nb_cell.y) * 2 + nb_cell.x * 2 + nb_cell.y;
488 }
489
490 const Int64x3 nb_cell(globalNbCellsX(level), globalNbCellsY(level), globalNbCellsZ(level));
491 return (nb_cell.x + 1) * nb_cell.y * nb_cell.z + (nb_cell.y + 1) * nb_cell.z * nb_cell.x + (nb_cell.z + 1) * nb_cell.x * nb_cell.y;
492}
493
494/*---------------------------------------------------------------------------*/
495/*---------------------------------------------------------------------------*/
496
497Integer CartesianMeshNumberingMngInternal::
498pattern() const
499{
500 return m_pattern;
501}
502
503/*---------------------------------------------------------------------------*/
504/*---------------------------------------------------------------------------*/
505
506Int32 CartesianMeshNumberingMngInternal::
507cellLevel(Int64 uid) const
508{
509 Integer pos = -1;
510 Int64 max = -1;
511
512 for (Integer i = m_min_level; i <= m_max_level; ++i) {
513 const Int64 first_uid = firstCellUniqueId(i);
514 if (first_uid <= uid && first_uid > max) {
515 pos = i;
516 max = first_uid;
517 }
518 }
519#ifdef ARCANE_CHECK
520 if (max == -1) {
521 ARCANE_FATAL("CellUID is not in any patch (UID too low)");
522 }
523 if (uid >= firstCellUniqueId(pos) + nbCellInLevel(pos)) {
524 ARCANE_FATAL("CellUID is not in any patch (UID too high)");
525 }
526#endif
527 return pos;
528}
529
530/*---------------------------------------------------------------------------*/
531/*---------------------------------------------------------------------------*/
532
533Int32 CartesianMeshNumberingMngInternal::
534nodeLevel(Int64 uid) const
535{
536 Integer pos = -1;
537 Int64 max = -1;
538
539 for (Integer i = m_min_level; i <= m_max_level; ++i) {
540 const Int64 first_uid = firstNodeUniqueId(i);
541 if (first_uid <= uid && first_uid > max) {
542 pos = i;
543 max = first_uid;
544 }
545 }
546#ifdef ARCANE_CHECK
547 if (max == -1) {
548 ARCANE_FATAL("NodeUID is not in any patch (UID too low)");
549 }
550 if (uid >= firstNodeUniqueId(pos) + nbNodeInLevel(pos)) {
551 ARCANE_FATAL("NodeUID is not in any patch (UID too high)");
552 }
553#endif
554 return pos;
555}
556
557/*---------------------------------------------------------------------------*/
558/*---------------------------------------------------------------------------*/
559
560Int32 CartesianMeshNumberingMngInternal::
561faceLevel(Int64 uid) const
562{
563 Integer pos = -1;
564 Int64 max = -1;
565
566 for (Integer i = m_min_level; i <= m_max_level; ++i) {
567 const Int64 first_uid = firstFaceUniqueId(i);
568 if (first_uid <= uid && first_uid > max) {
569 pos = i;
570 max = first_uid;
571 }
572 }
573#ifdef ARCANE_CHECK
574 if (max == -1) {
575 ARCANE_FATAL("FaceUID is not in any patch (UID too low)");
576 }
577 if (uid >= firstFaceUniqueId(pos) + nbFaceInLevel(pos)) {
578 ARCANE_FATAL("FaceUID is not in any patch (UID too high)");
579 }
580#endif
581 return pos;
582}
583
584/*---------------------------------------------------------------------------*/
585/*---------------------------------------------------------------------------*/
586
587// Tant que l'on a un unique "pattern" pour x, y, z, pas besoin de trois méthodes.
588Int64 CartesianMeshNumberingMngInternal::
589offsetLevelToLevel(Int64 coord, Integer level_from, Integer level_to) const
590{
591 if (level_from == level_to) {
592 return coord;
593 }
594 if (level_from < level_to) {
595 return coord * m_pattern * (level_to - level_from);
596 }
597 return coord / (m_pattern * (level_from - level_to));
598}
599
600/*---------------------------------------------------------------------------*/
601/*---------------------------------------------------------------------------*/
602
603// Tant que l'on a un unique "pattern" pour x, y, z, pas besoin de trois méthodes.
604Int64 CartesianMeshNumberingMngInternal::
605faceOffsetLevelToLevel(Int64 coord, Integer level_from, Integer level_to) const
606{
607 // Admettons que l'on ai les faces suivantes :
608 // ┌─0──┬──2─┐
609 // 4│ 6│ 8│
610 // ├─5──┼─7──┤
611 // 9│ 11│ 13│
612 // └─10─┴─12─┘
613
614 // Pour la position d'une face, on considère cette disposition :
615 // ┌──┬──┬──┬──┬──┐
616 // │ │ 0│ │ 2│ │
617 // ├──┼──┼──┼──┼──┤
618 // │ 4│ │ 6│ │ 8│
619 // ├──┼──┼──┼──┼──┤
620 // │ │ 5│ │ 7│ │
621 // ├──┼──┼──┼──┼──┤
622 // │ 9│ │11│ │13│
623 // ├──┼──┼──┼──┼──┤
624 // │ │10│ │12│ │
625 // └──┴──┴──┴──┴──┘
626
627 if (level_from == level_to) {
628 return coord;
629 }
630 else if (level_from < level_to) {
631 const Integer pattern = m_pattern * (level_to - level_from);
632 if (coord % 2 == 0) {
633 return coord * pattern;
634 }
635 else {
636 return ((coord - 1) * pattern) + 1;
637 }
638 }
639 else {
640 const Integer pattern = m_pattern * (level_from - level_to);
641 if (coord % 2 == 0) {
642 if (coord % (pattern * 2) == 0) {
643 return coord / pattern;
644 }
645 else {
646 return -1;
647 }
648 }
649 else {
650 // auto a = coord - 1;
651 // auto b = a % (pattern * 2);
652 // auto c = a / (pattern * 2);
653 // auto d = c * (2 * (pattern - 1));
654 // auto e = d + b;
655 // auto f = coord - e;
656 // return f;
657
658 return coord - ((Int64((coord - 1) / (pattern * 2)) * (2 * (pattern - 1))) + ((coord - 1) % (pattern * 2)));
659 }
660 }
661}
662
663/*---------------------------------------------------------------------------*/
664/*---------------------------------------------------------------------------*/
665
666Int64 CartesianMeshNumberingMngInternal::
667cellUniqueIdToCoordX(Int64 uid, Integer level)
668{
669 const Int64 nb_cell_x = globalNbCellsX(level);
670 const Int64 nb_cell_y = globalNbCellsY(level);
671 const Int64 first_cell_uid = firstCellUniqueId(level);
672
673 uid -= first_cell_uid;
674
675 const Int64 to2d = uid % (nb_cell_x * nb_cell_y);
676 return to2d % nb_cell_x;
677}
678
679/*---------------------------------------------------------------------------*/
680/*---------------------------------------------------------------------------*/
681
682Int64 CartesianMeshNumberingMngInternal::
683cellUniqueIdToCoordX(Cell cell)
684{
685 return cellUniqueIdToCoordX(cell.uniqueId(), cell.level());
686}
687
688/*---------------------------------------------------------------------------*/
689/*---------------------------------------------------------------------------*/
690
691Int64 CartesianMeshNumberingMngInternal::
692cellUniqueIdToCoordY(Int64 uid, Integer level)
693{
694 const Int64 nb_cell_x = globalNbCellsX(level);
695 const Int64 nb_cell_y = globalNbCellsY(level);
696 const Int64 first_cell_uid = firstCellUniqueId(level);
697
698 uid -= first_cell_uid;
699
700 const Int64 to2d = uid % (nb_cell_x * nb_cell_y);
701 return to2d / nb_cell_x;
702}
703
704/*---------------------------------------------------------------------------*/
705/*---------------------------------------------------------------------------*/
706
707Int64 CartesianMeshNumberingMngInternal::
708cellUniqueIdToCoordY(Cell cell)
709{
710 return cellUniqueIdToCoordY(cell.uniqueId(), cell.level());
711}
712
713/*---------------------------------------------------------------------------*/
714/*---------------------------------------------------------------------------*/
715
716Int64 CartesianMeshNumberingMngInternal::
717cellUniqueIdToCoordZ(Int64 uid, Integer level)
718{
719 const Int64 nb_cell_x = globalNbCellsX(level);
720 const Int64 nb_cell_y = globalNbCellsY(level);
721 const Int64 first_cell_uid = firstCellUniqueId(level);
722
723 uid -= first_cell_uid;
724
725 return uid / (nb_cell_x * nb_cell_y);
726}
727
728/*---------------------------------------------------------------------------*/
729/*---------------------------------------------------------------------------*/
730
731Int64 CartesianMeshNumberingMngInternal::
732cellUniqueIdToCoordZ(Cell cell)
733{
734 return cellUniqueIdToCoordZ(cell.uniqueId(), cell.level());
735}
736
737/*---------------------------------------------------------------------------*/
738/*---------------------------------------------------------------------------*/
739
740Int64 CartesianMeshNumberingMngInternal::
741nodeUniqueIdToCoordX(Int64 uid, Integer level)
742{
743 const Int64 nb_node_x = globalNbNodesX(level);
744 const Int64 nb_node_y = globalNbNodesY(level);
745 const Int64 first_node_uid = firstNodeUniqueId(level);
746
747 uid -= first_node_uid;
748
749 const Int64 to2d = uid % (nb_node_x * nb_node_y);
750 return to2d % nb_node_x;
751}
752
753/*---------------------------------------------------------------------------*/
754/*---------------------------------------------------------------------------*/
755
756Int64 CartesianMeshNumberingMngInternal::
757nodeUniqueIdToCoordX(Node node)
758{
759 const Int64 uid = node.uniqueId();
760 return nodeUniqueIdToCoordX(uid, nodeLevel(uid));
761}
762
763/*---------------------------------------------------------------------------*/
764/*---------------------------------------------------------------------------*/
765
766Int64 CartesianMeshNumberingMngInternal::
767nodeUniqueIdToCoordY(Int64 uid, Integer level)
768{
769 const Int64 nb_node_x = globalNbNodesX(level);
770 const Int64 nb_node_y = globalNbNodesY(level);
771 const Int64 first_node_uid = firstNodeUniqueId(level);
772
773 uid -= first_node_uid;
774
775 const Int64 to2d = uid % (nb_node_x * nb_node_y);
776 return to2d / nb_node_x;
777}
778
779/*---------------------------------------------------------------------------*/
780/*---------------------------------------------------------------------------*/
781
782Int64 CartesianMeshNumberingMngInternal::
783nodeUniqueIdToCoordY(Node node)
784{
785 const Int64 uid = node.uniqueId();
786 return nodeUniqueIdToCoordY(uid, nodeLevel(uid));
787}
788
789/*---------------------------------------------------------------------------*/
790/*---------------------------------------------------------------------------*/
791
792Int64 CartesianMeshNumberingMngInternal::
793nodeUniqueIdToCoordZ(Int64 uid, Integer level)
794{
795 const Int64 nb_node_x = globalNbNodesX(level);
796 const Int64 nb_node_y = globalNbNodesY(level);
797 const Int64 first_node_uid = firstNodeUniqueId(level);
798
799 uid -= first_node_uid;
800
801 return uid / (nb_node_x * nb_node_y);
802}
803
804/*---------------------------------------------------------------------------*/
805/*---------------------------------------------------------------------------*/
806
807Int64 CartesianMeshNumberingMngInternal::
808nodeUniqueIdToCoordZ(Node node)
809{
810 const Int64 uid = node.uniqueId();
811 return nodeUniqueIdToCoordZ(uid, nodeLevel(uid));
812}
813
814/*---------------------------------------------------------------------------*/
815/*---------------------------------------------------------------------------*/
816
817Int64 CartesianMeshNumberingMngInternal::
818faceUniqueIdToCoordX(Int64 uid, Integer level)
819{
820 if (m_dimension == 2) {
821
822 const Int64 nb_face_x = globalNbFacesXCartesianView(level);
823 const Int64 first_face_uid = firstFaceUniqueId(level);
824
825 uid -= first_face_uid;
826 uid += 1;
827
828 // Le +1 nous permet d'avoir le niveau (imaginaire) -1 commençant à 0 :
829 //
830 // x = 0 1 2 3 4
831 // ┌──┬──┬──┬──┬──┐
832 // y = -1 │ 0│ │ 2│ │ 4│
833 // ┌──┬──┬──┬──┬──┐
834 // y = 0 │ │ 1│ │ 3│ │
835 // ├──┼──┼──┼──┼──┤
836 // y = 1 │ 5│ │ 7│ │ 9│
837 // ├──┼──┼──┼──┼──┤
838 // y = 2 │ │ 6│ │ 8│ │
839 // ├──┼──┼──┼──┼──┤
840 // y = 3 │10│ │12│ │14│
841 // ├──┼──┼──┼──┼──┤
842 // y = 4 │ │11│ │13│ │
843 // └──┴──┴──┴──┴──┘
844 //
845 // Si on fait "tomber" les faces (tetris), on obtient une numérotation
846 // cartésienne classique.
847
848 return uid % nb_face_x;
849 }
850 else {
851 const Int64 nb_face_x = globalNbFacesX(level);
852 const Int64 nb_cell_x = globalNbCellsX(level);
853 const Int64 first_face_uid = firstFaceUniqueId(level);
854
855 // Int64 initial_uid = uid;
856
857 uid -= first_face_uid;
858
859 Int64x3 three_parts_numbering = _face3DNumberingThreeParts(level);
860
861 // Prenons la vue des faces en grille cartésienne d'un maillage 2x2x2 :
862 // z = 0 │ z = 1 │ z = 2 │ z = 3 │ z = 4
863 // x = 0 1 2 3 4 │ 0 1 2 3 4 │ 0 1 2 3 4 │ 0 1 2 3 4 │ 0 1 2 3 4
864 // ┌──┬──┬──┬──┬──┐ │ ┌──┬──┬──┬──┬──┐ │ ┌──┬──┬──┬──┬──┐ │ ┌──┬──┬──┬──┬──┐ │ ┌──┬──┬──┬──┬──┐
865 // y = 0 │ │ │ │ │ │ │ │ │12│ │13│ │ │ │ │ │ │ │ │ │ │ │18│ │19│ │ │ │ │ │ │ │ │
866 // ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤
867 // y = 1 │ │24│ │25│ │ │ │ 0│ │ 1│ │ 2│ │ │ │28│ │29│ │ │ │ 6│ │ 7│ │ 8│ │ │ │32│ │33│ │
868 // ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤
869 // y = 2 │ │ │ │ │ │ │ │ │14│ │15│ │ │ │ │ │ │ │ │ │ │ │20│ │21│ │ │ │ │ │ │ │ │
870 // ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤
871 // y = 3 │ │26│ │27│ │ │ │ 3│ │ 4│ │ 5│ │ │ │30│ │31│ │ │ │ 9│ │10│ │11│ │ │ │34│ │35│ │
872 // ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤
873 // y = 4 │ │ │ │ │ │ │ │ │16│ │17│ │ │ │ │ │ │ │ │ │ │ │22│ │23│ │ │ │ │ │ │ │ │
874 // └──┴──┴──┴──┴──┘ │ └──┴──┴──┴──┴──┘ │ └──┴──┴──┴──┴──┘ │ └──┴──┴──┴──┴──┘ │ └──┴──┴──┴──┴──┘
875 // │ │ │ │
876 //
877 // On peut remarquer 3 "sortes de disposition" : les faces ayant les uid [0, 11],
878 // les faces ayant les uid [12, 23] et les faces ayant les uid [24, 35].
879 // On récupère ces intervalles avec la méthode face3DNumberingThreeParts().
880
881 // Pour l'intervalle [0, 11], on remarque que l'origine en X est toujours 0 et que les mailles
882 // contenant une face sont sur les X pairs.
883 // Enfin, on a "nb_face_x" faces en X.
884 if (uid < three_parts_numbering.x) {
885
886 // debug() << "faceUniqueIdToCoordX (2)"
887 // << " -- true uid : " << initial_uid
888 // << " -- uid : " << uid
889 // << " -- level : " << level
890 // << " -- three_parts_numbering : " << three_parts_numbering
891 // << " -- nb_face_x : " << nb_face_x
892 // << " -- return : " << ((uid % nb_face_x) * 2);
893
894 return (uid % nb_face_x) * 2;
895 }
896
897 // Pour l'intervalle [12, 23], on remarque que l'origine en X est toujours 1 et que les mailles
898 // contenant une face sont sur les X impairs.
899 // Enfin, on a "nb_cell_x" faces en X.
900 else if (uid < three_parts_numbering.x + three_parts_numbering.y) {
901 uid -= three_parts_numbering.x;
902 // debug() << "faceUniqueIdToCoordX (3)"
903 // << " -- true uid : " << initial_uid
904 // << " -- uid : " << uid
905 // << " -- level : " << level
906 // << " -- three_parts_numbering : " << three_parts_numbering
907 // << " -- nb_cell_x : " << nb_cell_x
908 // << " -- return : " << ((uid % nb_cell_x) * 2 + 1);
909
910 return (uid % nb_cell_x) * 2 + 1;
911 }
912
913 // Pour l'intervalle [24, 35], on remarque que l'origine en X est toujours 1 et que les mailles
914 // contenant une face sont sur les X impairs.
915 // Enfin, on a "nb_cell_x" faces en X.
916 else {
917 uid -= three_parts_numbering.x + three_parts_numbering.y;
918 // debug() << "faceUniqueIdToCoordX (1)"
919 // << " -- true uid : " << initial_uid
920 // << " -- uid : " << uid
921 // << " -- level : " << level
922 // << " -- three_parts_numbering : " << three_parts_numbering
923 // << " -- nb_cell_x : " << nb_cell_x
924 // << " -- return : " << ((uid % nb_cell_x) * 2 + 1);
925
926 return (uid % nb_cell_x) * 2 + 1;
927 }
928 }
929}
930
931/*---------------------------------------------------------------------------*/
932/*---------------------------------------------------------------------------*/
933
934Int64 CartesianMeshNumberingMngInternal::
935faceUniqueIdToCoordX(Face face)
936{
937 const Int64 uid = face.uniqueId();
938 return faceUniqueIdToCoordX(uid, faceLevel(uid));
939}
940
941/*---------------------------------------------------------------------------*/
942/*---------------------------------------------------------------------------*/
943
944Int64 CartesianMeshNumberingMngInternal::
945faceUniqueIdToCoordY(Int64 uid, Integer level)
946{
947 if (m_dimension == 2) {
948 const Int64 nb_face_x = globalNbFacesXCartesianView(level);
949 const Int64 first_face_uid = firstFaceUniqueId(level);
950
951 uid -= first_face_uid;
952 uid += 1;
953
954 // Le +1 nous permet d'avoir le niveau (imaginaire) -1 commençant à 0 :
955 //
956 // x = 0 1 2 3 4
957 // ┌──┬──┬──┬──┬──┐
958 // y = -1 │ 0│ │ 2│ │ 4│
959 // ┌──┬──┬──┬──┬──┐
960 // y = 0 │ │ 1│ │ 3│ │
961 // ├──┼──┼──┼──┼──┤
962 // y = 1 │ 5│ │ 7│ │ 9│
963 // ├──┼──┼──┼──┼──┤
964 // y = 2 │ │ 6│ │ 8│ │
965 // ├──┼──┼──┼──┼──┤
966 // y = 3 │10│ │12│ │14│
967 // ├──┼──┼──┼──┼──┤
968 // y = 4 │ │11│ │13│ │
969 // └──┴──┴──┴──┴──┘
970 //
971 // Si, en plus, on fait y+1, on simplifie le problème puisque si on fait
972 // "tomber" les faces (tetris), on obtient une numérotation cartesienne classique.
973
974 const Int64 flat_pos = uid / nb_face_x;
975 return (flat_pos * 2) + (flat_pos % 2 == uid % 2 ? 0 : 1) - 1; // Le -1 pour "retirer" le niveau imaginaire.
976 }
977 else {
978 const Int64 nb_face_x = globalNbFacesX(level);
979 const Int64 nb_face_y = globalNbFacesY(level);
980 const Int64 nb_cell_x = globalNbCellsX(level);
981 const Int64 nb_cell_y = globalNbCellsY(level);
982 const Int64 first_face_uid = firstFaceUniqueId(level);
983
984 // Int64 initial_uid = uid;
985
986 uid -= first_face_uid;
987
988 Int64x3 three_parts_numbering = _face3DNumberingThreeParts(level);
989
990 // Prenons la vue des faces en grille cartésienne d'un maillage 2x2x2 :
991 // z = 0 │ z = 1 │ z = 2 │ z = 3 │ z = 4
992 // x = 0 1 2 3 4 │ 0 1 2 3 4 │ 0 1 2 3 4 │ 0 1 2 3 4 │ 0 1 2 3 4
993 // ┌──┬──┬──┬──┬──┐ │ ┌──┬──┬──┬──┬──┐ │ ┌──┬──┬──┬──┬──┐ │ ┌──┬──┬──┬──┬──┐ │ ┌──┬──┬──┬──┬──┐
994 // y = 0 │ │ │ │ │ │ │ │ │12│ │13│ │ │ │ │ │ │ │ │ │ │ │18│ │19│ │ │ │ │ │ │ │ │
995 // ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤
996 // y = 1 │ │24│ │25│ │ │ │ 0│ │ 1│ │ 2│ │ │ │28│ │29│ │ │ │ 6│ │ 7│ │ 8│ │ │ │32│ │33│ │
997 // ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤
998 // y = 2 │ │ │ │ │ │ │ │ │14│ │15│ │ │ │ │ │ │ │ │ │ │ │20│ │21│ │ │ │ │ │ │ │ │
999 // ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤
1000 // y = 3 │ │26│ │27│ │ │ │ 3│ │ 4│ │ 5│ │ │ │30│ │31│ │ │ │ 9│ │10│ │11│ │ │ │34│ │35│ │
1001 // ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤
1002 // y = 4 │ │ │ │ │ │ │ │ │16│ │17│ │ │ │ │ │ │ │ │ │ │ │22│ │23│ │ │ │ │ │ │ │ │
1003 // └──┴──┴──┴──┴──┘ │ └──┴──┴──┴──┴──┘ │ └──┴──┴──┴──┴──┘ │ └──┴──┴──┴──┴──┘ │ └──┴──┴──┴──┴──┘
1004 // │ │ │ │
1005 //
1006 // On peut remarquer 3 "sortes de disposition" : les faces ayant les uid [0, 11],
1007 // les faces ayant les uid [12, 23] et les faces ayant les uid [24, 35].
1008 // On récupère ces intervalles avec la méthode face3DNumberingThreeParts().
1009
1010 // Pour l'intervalle [0, 1], on remarque que l'origine en Y est toujours 1 et que les mailles
1011 // contenant une face sont sur les Y impairs.
1012 // Enfin, on a "nb_cell_y" faces en Y.
1013 if (uid < three_parts_numbering.x) {
1014 uid %= nb_face_x * nb_cell_y;
1015
1016 // debug() << "faceUniqueIdToCoordY (2)"
1017 // << " -- true uid : " << initial_uid
1018 // << " -- uid : " << uid
1019 // << " -- level : " << level
1020 // << " -- three_parts_numbering : " << three_parts_numbering
1021 // << " -- nb_face_x : " << nb_face_x
1022 // << " -- nb_cell_y : " << nb_cell_y
1023 // << " -- return : " << ((uid / nb_face_x) * 2 + 1);
1024
1025 return (uid / nb_face_x) * 2 + 1;
1026 }
1027
1028 // Pour l'intervalle [12, 23], on remarque que l'origine en Y est toujours 0 et que les mailles
1029 // contenant une face sont sur les Y pairs.
1030 // Enfin, on a "nb_face_y" faces en Y.
1031 else if (uid < three_parts_numbering.x + three_parts_numbering.y) {
1032 uid -= three_parts_numbering.x;
1033 uid %= nb_cell_x * nb_face_y;
1034
1035 // debug() << "faceUniqueIdToCoordY (3)"
1036 // << " -- true uid : " << initial_uid
1037 // << " -- uid : " << uid
1038 // << " -- level : " << level
1039 // << " -- three_parts_numbering : " << three_parts_numbering
1040 // << " -- nb_cell_x : " << nb_cell_x
1041 // << " -- nb_face_y : " << nb_face_y
1042 // << " -- return : " << ((uid / nb_cell_x) * 2);
1043
1044 return (uid / nb_cell_x) * 2;
1045 }
1046
1047 // Pour l'intervalle [24, 35], on remarque que l'origine en Y est toujours 1 et que les mailles
1048 // contenant une face sont sur les Y impairs.
1049 // Enfin, on a "nb_cell_y" faces en Y.
1050 else {
1051 uid -= three_parts_numbering.x + three_parts_numbering.y;
1052 uid %= nb_cell_x * nb_cell_y;
1053
1054 // debug() << "faceUniqueIdToCoordY (1)"
1055 // << " -- true uid : " << initial_uid
1056 // << " -- uid : " << uid
1057 // << " -- level : " << level
1058 // << " -- three_parts_numbering : " << three_parts_numbering
1059 // << " -- nb_cell_x : " << nb_cell_x
1060 // << " -- nb_cell_y : " << nb_cell_y
1061 // << " -- return : " << ((uid / nb_cell_x) * 2 + 1);
1062
1063 return (uid / nb_cell_x) * 2 + 1;
1064 }
1065 }
1066}
1067
1068/*---------------------------------------------------------------------------*/
1069/*---------------------------------------------------------------------------*/
1070
1071Int64 CartesianMeshNumberingMngInternal::
1072faceUniqueIdToCoordY(Face face)
1073{
1074 const Int64 uid = face.uniqueId();
1075 return faceUniqueIdToCoordY(uid, faceLevel(uid));
1076}
1077
1078/*---------------------------------------------------------------------------*/
1079/*---------------------------------------------------------------------------*/
1080
1081Int64 CartesianMeshNumberingMngInternal::
1082faceUniqueIdToCoordZ(Int64 uid, Integer level)
1083{
1084 const Int64 nb_face_x = globalNbFacesX(level);
1085 const Int64 nb_face_y = globalNbFacesY(level);
1086 const Int64 nb_cell_x = globalNbCellsX(level);
1087 const Int64 nb_cell_y = globalNbCellsY(level);
1088 const Int64 first_face_uid = firstFaceUniqueId(level);
1089
1090 // Int64 initial_uid = uid;
1091
1092 uid -= first_face_uid;
1093
1094 Int64x3 three_parts_numbering = _face3DNumberingThreeParts(level);
1095
1096 // Prenons la vue des faces en grille cartésienne d'un maillage 2x2x2 :
1097 // z = 0 │ z = 1 │ z = 2 │ z = 3 │ z = 4
1098 // x = 0 1 2 3 4 │ 0 1 2 3 4 │ 0 1 2 3 4 │ 0 1 2 3 4 │ 0 1 2 3 4
1099 // ┌──┬──┬──┬──┬──┐ │ ┌──┬──┬──┬──┬──┐ │ ┌──┬──┬──┬──┬──┐ │ ┌──┬──┬──┬──┬──┐ │ ┌──┬──┬──┬──┬──┐
1100 // y = 0 │ │ │ │ │ │ │ │ │12│ │13│ │ │ │ │ │ │ │ │ │ │ │18│ │19│ │ │ │ │ │ │ │ │
1101 // ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤
1102 // y = 1 │ │24│ │25│ │ │ │ 0│ │ 1│ │ 2│ │ │ │28│ │29│ │ │ │ 6│ │ 7│ │ 8│ │ │ │32│ │33│ │
1103 // ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤
1104 // y = 2 │ │ │ │ │ │ │ │ │14│ │15│ │ │ │ │ │ │ │ │ │ │ │20│ │21│ │ │ │ │ │ │ │ │
1105 // ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤
1106 // y = 3 │ │26│ │27│ │ │ │ 3│ │ 4│ │ 5│ │ │ │30│ │31│ │ │ │ 9│ │10│ │11│ │ │ │34│ │35│ │
1107 // ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤
1108 // y = 4 │ │ │ │ │ │ │ │ │16│ │17│ │ │ │ │ │ │ │ │ │ │ │22│ │23│ │ │ │ │ │ │ │ │
1109 // └──┴──┴──┴──┴──┘ │ └──┴──┴──┴──┴──┘ │ └──┴──┴──┴──┴──┘ │ └──┴──┴──┴──┴──┘ │ └──┴──┴──┴──┴──┘
1110 // │ │ │ │
1111 //
1112 // On peut remarquer 3 "sortes de disposition" : les faces ayant les uid [0, 11],
1113 // les faces ayant les uid [12, 23] et les faces ayant les uid [24, 35].
1114 // On récupère ces intervalles avec la méthode face3DNumberingThreeParts().
1115
1116 // Pour l'intervalle [0, 11], on remarque que l'origine en Z est toujours 1 et que les mailles
1117 // contenant une face sont sur les Z impairs.
1118 // Enfin, on a "nb_cell_z" faces en Z.
1119 if (uid < three_parts_numbering.x) {
1120
1121 // debug() << "faceUniqueIdToCoordZ (2)"
1122 // << " -- true uid : " << initial_uid
1123 // << " -- uid : " << uid
1124 // << " -- level : " << level
1125 // << " -- three_parts_numbering : " << three_parts_numbering
1126 // << " -- nb_face_x : " << nb_face_x
1127 // << " -- nb_cell_y : " << nb_cell_y
1128 // << " -- return : " << ((uid / (nb_face_x * nb_cell_y)) * 2 + 1);
1129
1130 return (uid / (nb_face_x * nb_cell_y)) * 2 + 1;
1131 }
1132
1133 // Pour l'intervalle [12, 23], on remarque que l'origine en Z est toujours 1 et que les mailles
1134 // contenant une face sont sur les Z impairs.
1135 // Enfin, on a "nb_cell_z" faces en Z.
1136 else if (uid < three_parts_numbering.x + three_parts_numbering.y) {
1137 uid -= three_parts_numbering.x;
1138
1139 // debug() << "faceUniqueIdToCoordZ (3)"
1140 // << " -- true uid : " << initial_uid
1141 // << " -- uid : " << uid
1142 // << " -- level : " << level
1143 // << " -- three_parts_numbering : " << three_parts_numbering
1144 // << " -- nb_cell_x : " << nb_cell_x
1145 // << " -- nb_face_y : " << nb_face_y
1146 // << " -- return : " << ((uid / (nb_cell_x * nb_face_y)) * 2 + 1);
1147
1148 return (uid / (nb_cell_x * nb_face_y)) * 2 + 1;
1149 }
1150
1151 // Pour l'intervalle [24, 35], on remarque que l'origine en Z est toujours 0 et que les mailles
1152 // contenant une face sont sur les Z pairs.
1153 // Enfin, on a "nb_face_z" faces en Z.
1154 else {
1155 uid -= three_parts_numbering.x + three_parts_numbering.y;
1156
1157 // debug() << "faceUniqueIdToCoordZ (1)"
1158 // << " -- true uid : " << initial_uid
1159 // << " -- uid : " << uid
1160 // << " -- level : " << level
1161 // << " -- three_parts_numbering : " << three_parts_numbering
1162 // << " -- nb_cell_x : " << nb_cell_x
1163 // << " -- nb_cell_y : " << nb_cell_y
1164 // << " -- return : " << ((uid / (nb_cell_x * nb_cell_y)) * 2);
1165
1166 return (uid / (nb_cell_x * nb_cell_y)) * 2;
1167 }
1168}
1169
1170/*---------------------------------------------------------------------------*/
1171/*---------------------------------------------------------------------------*/
1172
1173Int64 CartesianMeshNumberingMngInternal::
1174faceUniqueIdToCoordZ(Face face)
1175{
1176 const Int64 uid = face.uniqueId();
1177 return faceUniqueIdToCoordZ(uid, faceLevel(uid));
1178}
1179
1180/*---------------------------------------------------------------------------*/
1181/*---------------------------------------------------------------------------*/
1182
1183Int64 CartesianMeshNumberingMngInternal::
1184cellUniqueId(Integer level, Int64x3 cell_coord)
1185{
1186 const Int64 nb_cell_x = globalNbCellsX(level);
1187 const Int64 nb_cell_y = globalNbCellsY(level);
1188 const Int64 first_cell_uid = firstCellUniqueId(level);
1189
1190 return (cell_coord.x + cell_coord.y * nb_cell_x + cell_coord.z * nb_cell_x * nb_cell_y) + first_cell_uid;
1191}
1192
1193/*---------------------------------------------------------------------------*/
1194/*---------------------------------------------------------------------------*/
1195
1196Int64 CartesianMeshNumberingMngInternal::
1197cellUniqueId(Integer level, Int64x2 cell_coord)
1198{
1199 const Int64 nb_cell_x = globalNbCellsX(level);
1200 const Int64 first_cell_uid = firstCellUniqueId(level);
1201
1202 return (cell_coord.x + cell_coord.y * nb_cell_x) + first_cell_uid;
1203}
1204
1205/*---------------------------------------------------------------------------*/
1206/*---------------------------------------------------------------------------*/
1207
1208Int64 CartesianMeshNumberingMngInternal::
1209nodeUniqueId(Integer level, Int64x3 node_coord)
1210{
1211 const Int64 nb_node_x = globalNbNodesX(level);
1212 const Int64 nb_node_y = globalNbNodesY(level);
1213 const Int64 first_node_uid = firstNodeUniqueId(level);
1214
1215 return (node_coord.x + node_coord.y * nb_node_x + node_coord.z * nb_node_x * nb_node_y) + first_node_uid;
1216}
1217
1218/*---------------------------------------------------------------------------*/
1219/*---------------------------------------------------------------------------*/
1220
1221Int64 CartesianMeshNumberingMngInternal::
1222nodeUniqueId(Integer level, Int64x2 node_coord)
1223{
1224 const Int64 nb_node_x = globalNbNodesX(level);
1225 const Int64 first_node_uid = firstNodeUniqueId(level);
1226
1227 return (node_coord.x + node_coord.y * nb_node_x) + first_node_uid;
1228}
1229
1230/*---------------------------------------------------------------------------*/
1231/*---------------------------------------------------------------------------*/
1232
1233Int64 CartesianMeshNumberingMngInternal::
1234faceUniqueId(Integer level, Int64x3 face_coord)
1235{
1236 const Int64 nb_face_x = globalNbFacesX(level);
1237 const Int64 nb_face_y = globalNbFacesY(level);
1238 const Int64 nb_cell_x = globalNbCellsX(level);
1239 const Int64 nb_cell_y = globalNbCellsY(level);
1240
1241 Int64x3 three_parts_numbering = _face3DNumberingThreeParts(level);
1242 Int64 uid = firstFaceUniqueId(level);
1243
1244 // Prenons la vue des faces en grille cartésienne d'un maillage 2x2x2 :
1245 // z = 0 │ z = 1 │ z = 2 │ z = 3 │ z = 4
1246 // x = 0 1 2 3 4 │ 0 1 2 3 4 │ 0 1 2 3 4 │ 0 1 2 3 4 │ 0 1 2 3 4
1247 // ┌──┬──┬──┬──┬──┐ │ ┌──┬──┬──┬──┬──┐ │ ┌──┬──┬──┬──┬──┐ │ ┌──┬──┬──┬──┬──┐ │ ┌──┬──┬──┬──┬──┐
1248 // y = 0 │ │ │ │ │ │ │ │ │12│ │13│ │ │ │ │ │ │ │ │ │ │ │18│ │19│ │ │ │ │ │ │ │ │
1249 // ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤
1250 // y = 1 │ │24│ │25│ │ │ │ 0│ │ 1│ │ 2│ │ │ │28│ │29│ │ │ │ 6│ │ 7│ │ 8│ │ │ │32│ │33│ │
1251 // ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤
1252 // y = 2 │ │ │ │ │ │ │ │ │14│ │15│ │ │ │ │ │ │ │ │ │ │ │20│ │21│ │ │ │ │ │ │ │ │
1253 // ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤
1254 // y = 3 │ │26│ │27│ │ │ │ 3│ │ 4│ │ 5│ │ │ │30│ │31│ │ │ │ 9│ │10│ │11│ │ │ │34│ │35│ │
1255 // ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤
1256 // y = 4 │ │ │ │ │ │ │ │ │16│ │17│ │ │ │ │ │ │ │ │ │ │ │22│ │23│ │ │ │ │ │ │ │ │
1257 // └──┴──┴──┴──┴──┘ │ └──┴──┴──┴──┴──┘ │ └──┴──┴──┴──┴──┘ │ └──┴──┴──┴──┴──┘ │ └──┴──┴──┴──┴──┘
1258 // │ │ │ │
1259 //
1260 // On peut remarquer 3 "sortes de disposition" : les faces ayant les uid [0, 11],
1261 // les faces ayant les uid [12, 23] et les faces ayant les uid [24, 35].
1262 // Ici, on veut faire l'inverse : passer des coordonnées x,y,z à un uid.
1263 // Pour identifier les trois intervalles, on regarde quelle coordonnée est pair.
1264 // En effet, pour l'intervalle [0, 11], on s'aperçoit que seule la coordonnée z est pair.
1265 // Pour l'intervalle [12, 23], seule la coordonnée x est pair et pour l'intervalle [24, 35],
1266 // seule la coordonnée y est pair.
1267
1268 // Intervalle [0, 11].
1269 if (face_coord.x % 2 == 0) {
1270
1271 // Ici, on place les mailles à l'origine 0*0*0 et on les met côte-à-côte.
1272 face_coord.y -= 1;
1273 face_coord.z -= 1;
1274
1275 face_coord /= 2;
1276
1277 // On est, à présent et pour cet intervalle, dans une vue cartésienne de
1278 // taille nb_face_x * nb_cell_y * nb_cell_z.
1279 uid += face_coord.x + (face_coord.y * nb_face_x) + (face_coord.z * nb_face_x * nb_cell_y);
1280 }
1281
1282 // Intervalle [12, 23].
1283 else if (face_coord.y % 2 == 0) {
1284 uid += three_parts_numbering.x;
1285
1286 // Ici, on place les mailles à l'origine 0*0*0 et on les met côte-à-côte.
1287 face_coord.x -= 1;
1288 face_coord.z -= 1;
1289
1290 face_coord /= 2;
1291
1292 // On est, à présent et pour cet intervalle, dans une vue cartésienne de
1293 // taille nb_cell_x * nb_face_y * nb_cell_z.
1294 uid += face_coord.x + (face_coord.y * nb_cell_x) + (face_coord.z * nb_cell_x * nb_face_y);
1295 }
1296
1297 // Intervalle [24, 35].
1298 else if (face_coord.z % 2 == 0) {
1299 uid += three_parts_numbering.x + three_parts_numbering.y;
1300
1301 // Ici, on place les mailles à l'origine 0*0*0 et on les met côte-à-côte.
1302 face_coord.x -= 1;
1303 face_coord.y -= 1;
1304
1305 face_coord /= 2;
1306
1307 // On est, à présent et pour cet intervalle, dans une vue cartésienne de
1308 // taille nb_cell_x * nb_cell_y * nb_face_z.
1309 uid += face_coord.x + (face_coord.y * nb_cell_x) + (face_coord.z * nb_cell_x * nb_cell_y);
1310 }
1311 else {
1312 ARCANE_FATAL("Bizarre -- x : {0} -- y : {1} -- z : {2}", face_coord.x, face_coord.y, face_coord.z);
1313 }
1314
1315 return uid;
1316}
1317
1318/*---------------------------------------------------------------------------*/
1319/*---------------------------------------------------------------------------*/
1320
1321Int64 CartesianMeshNumberingMngInternal::
1322faceUniqueId(Integer level, Int64x2 face_coord)
1323{
1324 const Int64 nb_face_x = globalNbFacesXCartesianView(level);
1325 const Int64 first_face_uid = firstFaceUniqueId(level);
1326
1327 // On considère que l'on a un niveau imaginaire -1 et que
1328 // l'on obtiendra uid+1 (dans la numérotation utilisée normalement,
1329 // la face à la position (1, 0) a un uid = 0).
1330 //
1331 // x = 0 1 2 3 4
1332 // ┌──┬──┬──┬──┬──┐
1333 // y = -1 │ 0│ │ 2│ │ 4│
1334 // ┌──┬──┬──┬──┬──┐
1335 // y = 0 │ │ 1│ │ 3│ │
1336 // ├──┼──┼──┼──┼──┤
1337 // y = 1 │ 5│ │ 7│ │ 9│
1338 // ├──┼──┼──┼──┼──┤
1339 // y = 2 │ │ 6│ │ 8│ │
1340 // ├──┼──┼──┼──┼──┤
1341 // y = 3 │10│ │12│ │14│
1342 // ├──┼──┼──┼──┼──┤
1343 // y = 4 │ │11│ │13│ │
1344 // └──┴──┴──┴──┴──┘
1345 //
1346
1347 face_coord.y += 1;
1348
1349 const Int64 a = (face_coord.y / 2) * nb_face_x;
1350
1351 return (face_coord.x + a - 1) + first_face_uid; // Le -1 est pour revenir à la numérotation normale.
1352}
1353
1354/*---------------------------------------------------------------------------*/
1355/*---------------------------------------------------------------------------*/
1356
1357Integer CartesianMeshNumberingMngInternal::
1358nbNodeByCell()
1359{
1360 return static_cast<Integer>(std::pow(m_pattern, m_mesh->dimension()));
1361}
1362
1363/*---------------------------------------------------------------------------*/
1364/*---------------------------------------------------------------------------*/
1365
1366void CartesianMeshNumberingMngInternal::
1367cellNodeUniqueIds(ArrayView<Int64> uid, Integer level, Int64x3 cell_coord)
1368{
1369 if (uid.size() != nbNodeByCell())
1370 ARCANE_FATAL("Bad size of arrayview");
1371
1372 const Int64 nb_node_x = globalNbNodesX(level);
1373 const Int64 nb_node_y = globalNbNodesY(level);
1374 const Int64 first_node_uid = firstNodeUniqueId(level);
1375
1376 uid[0] = (cell_coord.x + 0) + ((cell_coord.y + 0) * nb_node_x) + ((cell_coord.z + 0) * nb_node_x * nb_node_y) + first_node_uid;
1377 uid[1] = (cell_coord.x + 1) + ((cell_coord.y + 0) * nb_node_x) + ((cell_coord.z + 0) * nb_node_x * nb_node_y) + first_node_uid;
1378 uid[2] = (cell_coord.x + 1) + ((cell_coord.y + 1) * nb_node_x) + ((cell_coord.z + 0) * nb_node_x * nb_node_y) + first_node_uid;
1379 uid[3] = (cell_coord.x + 0) + ((cell_coord.y + 1) * nb_node_x) + ((cell_coord.z + 0) * nb_node_x * nb_node_y) + first_node_uid;
1380
1381 uid[4] = (cell_coord.x + 0) + ((cell_coord.y + 0) * nb_node_x) + ((cell_coord.z + 1) * nb_node_x * nb_node_y) + first_node_uid;
1382 uid[5] = (cell_coord.x + 1) + ((cell_coord.y + 0) * nb_node_x) + ((cell_coord.z + 1) * nb_node_x * nb_node_y) + first_node_uid;
1383 uid[6] = (cell_coord.x + 1) + ((cell_coord.y + 1) * nb_node_x) + ((cell_coord.z + 1) * nb_node_x * nb_node_y) + first_node_uid;
1384 uid[7] = (cell_coord.x + 0) + ((cell_coord.y + 1) * nb_node_x) + ((cell_coord.z + 1) * nb_node_x * nb_node_y) + first_node_uid;
1385}
1386
1387/*---------------------------------------------------------------------------*/
1388/*---------------------------------------------------------------------------*/
1389
1390void CartesianMeshNumberingMngInternal::
1391cellNodeUniqueIds(ArrayView<Int64> uid, Integer level, Int64x2 cell_coord)
1392{
1393 if (uid.size() != nbNodeByCell())
1394 ARCANE_FATAL("Bad size of arrayview");
1395
1396 const Int64 nb_node_x = globalNbNodesX(level);
1397 const Int64 first_node_uid = firstNodeUniqueId(level);
1398
1399 uid[0] = (cell_coord.x + 0) + ((cell_coord.y + 0) * nb_node_x) + first_node_uid;
1400 uid[1] = (cell_coord.x + 1) + ((cell_coord.y + 0) * nb_node_x) + first_node_uid;
1401 uid[2] = (cell_coord.x + 1) + ((cell_coord.y + 1) * nb_node_x) + first_node_uid;
1402 uid[3] = (cell_coord.x + 0) + ((cell_coord.y + 1) * nb_node_x) + first_node_uid;
1403}
1404
1405/*---------------------------------------------------------------------------*/
1406/*---------------------------------------------------------------------------*/
1407
1408void CartesianMeshNumberingMngInternal::
1409cellNodeUniqueIds(ArrayView<Int64> uid, Integer level, Int64 cell_uid)
1410{
1411 if (m_dimension == 2) {
1412 const Int64x2 cell_coord(cellUniqueIdToCoordX(cell_uid, level), cellUniqueIdToCoordY(cell_uid, level));
1413 cellNodeUniqueIds(uid, level, cell_coord);
1414 }
1415 else {
1416 const Int64x3 cell_coord(cellUniqueIdToCoordX(cell_uid, level), cellUniqueIdToCoordY(cell_uid, level), cellUniqueIdToCoordZ(cell_uid, level));
1417 cellNodeUniqueIds(uid, level, cell_coord);
1418 }
1419}
1420
1421/*---------------------------------------------------------------------------*/
1422/*---------------------------------------------------------------------------*/
1423
1424void CartesianMeshNumberingMngInternal::
1425cellNodeUniqueIds(ArrayView<Int64> uid, Cell cell)
1426{
1427 cellNodeUniqueIds(uid, cell.level(), cell.uniqueId().asInt64());
1428}
1429
1430/*---------------------------------------------------------------------------*/
1431/*---------------------------------------------------------------------------*/
1432
1433Integer CartesianMeshNumberingMngInternal::
1434nbFaceByCell()
1435{
1436 return m_pattern * m_dimension;
1437}
1438
1439/*---------------------------------------------------------------------------*/
1440/*---------------------------------------------------------------------------*/
1441
1442void CartesianMeshNumberingMngInternal::
1443cellFaceUniqueIds(ArrayView<Int64> uid, Integer level, Int64x3 cell_coord)
1444{
1445 if (uid.size() != nbFaceByCell())
1446 ARCANE_FATAL("Bad size of arrayview");
1447
1448 const Int64x3 nb_cell(globalNbCellsX(level), globalNbCellsY(level), globalNbCellsZ(level));
1449 const Int64x3 nb_face(nb_cell + 1);
1450
1451 const Int64 first_face_uid = firstFaceUniqueId(level);
1452
1453 // Numérote les faces
1454 // Cet algo n'est pas basé sur l'algo 2D.
1455 // Les UniqueIDs générés sont contigües.
1456 // Il est aussi possible de retrouver les UniqueIDs des faces
1457 // à l'aide de la position de la cellule et la taille du maillage.
1458 // De plus, l'ordre des UniqueIDs des faces d'une cellule est toujours le
1459 // même (en notation localId Arcane (cell.face(i)) : 1, 4, 2, 5, 0, 3).
1460 // Les UniqueIDs générés sont donc les mêmes quelque soit le découpage.
1461 //
1462 // Prenons la vue des faces en grille cartésienne d'un maillage 2x2x2 :
1463 // z = 0 │ z = 1 │ z = 2 │ z = 3 │ z = 4
1464 // x = 0 1 2 3 4 │ 0 1 2 3 4 │ 0 1 2 3 4 │ 0 1 2 3 4 │ 0 1 2 3 4
1465 // ┌──┬──┬──┬──┬──┐ │ ┌──┬──┬──┬──┬──┐ │ ┌──┬──┬──┬──┬──┐ │ ┌──┬──┬──┬──┬──┐ │ ┌──┬──┬──┬──┬──┐
1466 // y = 0 │ │ │ │ │ │ │ │ │12│ │13│ │ │ │ │ │ │ │ │ │ │ │18│ │19│ │ │ │ │ │ │ │ │
1467 // ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤
1468 // y = 1 │ │24│ │25│ │ │ │ 0│ │ 1│ │ 2│ │ │ │28│ │29│ │ │ │ 6│ │ 7│ │ 8│ │ │ │32│ │33│ │
1469 // ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤
1470 // y = 2 │ │ │ │ │ │ │ │ │14│ │15│ │ │ │ │ │ │ │ │ │ │ │20│ │21│ │ │ │ │ │ │ │ │
1471 // ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤
1472 // y = 3 │ │26│ │27│ │ │ │ 3│ │ 4│ │ 5│ │ │ │30│ │31│ │ │ │ 9│ │10│ │11│ │ │ │34│ │35│ │
1473 // ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤ │ ├──┼──┼──┼──┼──┤
1474 // y = 4 │ │ │ │ │ │ │ │ │16│ │17│ │ │ │ │ │ │ │ │ │ │ │22│ │23│ │ │ │ │ │ │ │ │
1475 // └──┴──┴──┴──┴──┘ │ └──┴──┴──┴──┴──┘ │ └──┴──┴──┴──┴──┘ │ └──┴──┴──┴──┴──┘ │ └──┴──┴──┴──┴──┘
1476 // │ │ │ │
1477 //
1478 // (dans cette vue, les mailles se situent aux X, Y et Z impaires
1479 // (donc ici, [1, 1, 1], [3, 1, 1], [1, 3, 1], &c)).
1480 //
1481 // On a un cube décomposé en huit cellules (2x2x2).
1482 // Le schéma au-dessus représente les faces des cellules de ce cube avec
1483 // les uniqueIDs que l'algorithme génèrera (sans face_adder).
1484 // Pour cet algo, on commence par les faces "yz" (direction X).
1485 // On énumère d'abord en x, puis en y, puis en z.
1486 // Une fois les faces "yz" numérotées, on fait les faces "zx" (direction Y).
1487 // Toujours le même ordre de numérotation.
1488 // On termine avec les faces "xy" (direction Z), encore dans le même ordre.
1489 //
1490 // Dans l'implémentation ci-dessous, on fait la numérotation
1491 // maille par maille.
1492
1493 const Int64 total_face_yz = nb_face.x * nb_cell.y * nb_cell.z;
1494 const Int64 total_face_yz_zx = total_face_yz + nb_face.y * nb_cell.z * nb_cell.x;
1495
1496 const Int64 nb_cell_before_j = cell_coord.y * nb_cell.x;
1497
1498 uid[0] = (cell_coord.z * nb_cell.x * nb_cell.y) + nb_cell_before_j + cell_coord.x + total_face_yz_zx;
1499
1500 uid[3] = uid[0] + nb_cell.x * nb_cell.y;
1501
1502 uid[1] = (cell_coord.z * nb_face.x * nb_cell.y) + (cell_coord.y * nb_face.x) + cell_coord.x;
1503
1504 uid[4] = uid[1] + 1;
1505
1506 uid[2] = (cell_coord.z * nb_cell.x * nb_face.y) + nb_cell_before_j + cell_coord.x + total_face_yz;
1507
1508 uid[5] = uid[2] + nb_cell.x;
1509
1510 uid[0] += first_face_uid;
1511 uid[1] += first_face_uid;
1512 uid[2] += first_face_uid;
1513 uid[3] += first_face_uid;
1514 uid[4] += first_face_uid;
1515 uid[5] += first_face_uid;
1516
1517 // debug() << "Coord : " << cell_coord << " -- UIDs : " << uid;
1518}
1519
1520/*---------------------------------------------------------------------------*/
1521/*---------------------------------------------------------------------------*/
1522
1523void CartesianMeshNumberingMngInternal::
1524cellFaceUniqueIds(ArrayView<Int64> uid, Integer level, Int64x2 cell_coord)
1525{
1526 if (uid.size() != nbFaceByCell())
1527 ARCANE_FATAL("Bad size of arrayview");
1528
1529 const Int64 nb_cell_x = globalNbCellsX(level);
1530 const Int64 nb_face_x = nb_cell_x + 1;
1531 const Int64 first_face_uid = firstFaceUniqueId(level);
1532
1533 // Numérote les faces
1534 // ┌─0──┬──2─┐
1535 // 4│ 6│ 8│
1536 // ├─5──┼─7──┤
1537 // 9│ 11│ 13│
1538 // └─10─┴─12─┘
1539 //
1540 // Avec cette numérotation, HAUT < GAUCHE < BAS < DROITE
1541 // Mis à part les uniqueIds de la première ligne de face, tous
1542 // les uniqueIds sont contigües.
1543
1544 // HAUT
1545 // - "(current_level_nb_face_x + current_level_nb_cell_x)" :
1546 // le nombre de faces GAUCHE BAS DROITE au dessus.
1547 // - "cell_coord.y * (current_level_nb_face_x + current_level_nb_cell_x)" :
1548 // le nombre total de faces GAUCHE BAS DROITE au dessus.
1549 // - "cell_coord.x * 2"
1550 // on avance deux à deux sur les faces d'un même "coté".
1551 uid[0] = cell_coord.x * 2 + cell_coord.y * (nb_face_x + nb_cell_x);
1552
1553 // BAS
1554 // Pour BAS, c'est comme HAUT mais avec un "nombre de face du dessus" en plus.
1555 uid[2] = uid[0] + (nb_face_x + nb_cell_x);
1556 // GAUCHE
1557 // Pour GAUCHE, c'est l'UID de BAS -1.
1558 uid[3] = uid[2] - 1;
1559 // DROITE
1560 // Pour DROITE, c'est l'UID de BAS +1.
1561 uid[1] = uid[2] + 1;
1562
1563 uid[0] += first_face_uid;
1564 uid[1] += first_face_uid;
1565 uid[2] += first_face_uid;
1566 uid[3] += first_face_uid;
1567}
1568
1569/*---------------------------------------------------------------------------*/
1570/*---------------------------------------------------------------------------*/
1571
1572void CartesianMeshNumberingMngInternal::
1573cellFaceUniqueIds(ArrayView<Int64> uid, Integer level, Int64 cell_uid)
1574{
1575 if (m_dimension == 2) {
1576 const Int64x2 cell_coord(cellUniqueIdToCoordX(cell_uid, level), cellUniqueIdToCoordY(cell_uid, level));
1577 cellFaceUniqueIds(uid, level, cell_coord);
1578 }
1579 else {
1580 const Int64x3 cell_coord(cellUniqueIdToCoordX(cell_uid, level), cellUniqueIdToCoordY(cell_uid, level), cellUniqueIdToCoordZ(cell_uid, level));
1581 cellFaceUniqueIds(uid, level, cell_coord);
1582 }
1583}
1584
1585/*---------------------------------------------------------------------------*/
1586/*---------------------------------------------------------------------------*/
1587
1588void CartesianMeshNumberingMngInternal::
1589cellFaceUniqueIds(ArrayView<Int64> uid, Cell cell)
1590{
1591 cellFaceUniqueIds(uid, cell.level(), cell.uniqueId().asInt64());
1592}
1593
1594/*---------------------------------------------------------------------------*/
1595/*---------------------------------------------------------------------------*/
1596
1597void CartesianMeshNumberingMngInternal::
1598cellUniqueIdsAroundCell(ArrayView<Int64> uid, Int64x3 cell_coord, Int32 level)
1599{
1600 ARCANE_ASSERT((uid.size() == 27), ("Size of uid array != 27"));
1601
1602 uid.fill(-1);
1603
1604 const Int64 nb_cells_x = globalNbCellsX(level);
1605 const Int64 nb_cells_y = globalNbCellsY(level);
1606 const Int64 nb_cells_z = globalNbCellsZ(level);
1607
1608 for (Integer k = -1; k < 2; ++k) {
1609 const Int64 coord_around_cell_z = cell_coord.z + k;
1610 if (coord_around_cell_z >= 0 && coord_around_cell_z < nb_cells_z) {
1611
1612 for (Integer j = -1; j < 2; ++j) {
1613 const Int64 coord_around_cell_y = cell_coord.y + j;
1614 if (coord_around_cell_y >= 0 && coord_around_cell_y < nb_cells_y) {
1615
1616 for (Integer i = -1; i < 2; ++i) {
1617 const Int64 coord_around_cell_x = cell_coord.x + i;
1618 if (coord_around_cell_x >= 0 && coord_around_cell_x < nb_cells_x) {
1619 uid[(i + 1) + ((j + 1) * 3) + ((k + 1) * 9)] = cellUniqueId(level, Int64x3{ coord_around_cell_x, coord_around_cell_y, coord_around_cell_z });
1620 }
1621 }
1622 }
1623 }
1624 }
1625 }
1626}
1627
1628/*---------------------------------------------------------------------------*/
1629/*---------------------------------------------------------------------------*/
1630
1631void CartesianMeshNumberingMngInternal::
1632cellUniqueIdsAroundCell(ArrayView<Int64> uid, Int64x2 cell_coord, Int32 level)
1633{
1634 ARCANE_ASSERT((uid.size() == 9), ("Size of uid array != 9"));
1635
1636 uid.fill(-1);
1637
1638 const Int64 nb_cells_x = globalNbCellsX(level);
1639 const Int64 nb_cells_y = globalNbCellsY(level);
1640
1641 for (Integer j = -1; j < 2; ++j) {
1642 const Int64 coord_around_cell_y = cell_coord.y + j;
1643 if (coord_around_cell_y >= 0 && coord_around_cell_y < nb_cells_y) {
1644
1645 for (Integer i = -1; i < 2; ++i) {
1646 const Int64 coord_around_cell_x = cell_coord.x + i;
1647 if (coord_around_cell_x >= 0 && coord_around_cell_x < nb_cells_x) {
1648 uid[(i + 1) + ((j + 1) * 3)] = cellUniqueId(level, Int64x2{ coord_around_cell_x, coord_around_cell_y });
1649 }
1650 }
1651 }
1652 }
1653}
1654
1655/*---------------------------------------------------------------------------*/
1656/*---------------------------------------------------------------------------*/
1657
1658void CartesianMeshNumberingMngInternal::
1659cellUniqueIdsAroundCell(ArrayView<Int64> uid, Int64 cell_uid, Int32 level)
1660{
1661 if (m_dimension == 2) {
1662 const Int64x2 cell_coord(cellUniqueIdToCoordX(cell_uid, level), cellUniqueIdToCoordY(cell_uid, level));
1663 cellUniqueIdsAroundCell(uid, cell_coord, level);
1664 }
1665 else {
1666 const Int64x3 cell_coord(cellUniqueIdToCoordX(cell_uid, level), cellUniqueIdToCoordY(cell_uid, level), cellUniqueIdToCoordZ(cell_uid, level));
1667 cellUniqueIdsAroundCell(uid, cell_coord, level);
1668 }
1669}
1670
1671/*---------------------------------------------------------------------------*/
1672/*---------------------------------------------------------------------------*/
1673
1674void CartesianMeshNumberingMngInternal::
1675cellUniqueIdsAroundCell(ArrayView<Int64> uid, Cell cell)
1676{
1677 cellUniqueIdsAroundCell(uid, cell.uniqueId().asInt64(), cell.level());
1678}
1679
1680/*---------------------------------------------------------------------------*/
1681/*---------------------------------------------------------------------------*/
1682
1683void CartesianMeshNumberingMngInternal::
1684cellUniqueIdsAroundNode(ArrayView<Int64> uid, Int64x3 node_coord, Int32 level)
1685{
1686 ARCANE_ASSERT((uid.size() == 8), ("Size of uid array != 8"));
1687
1688 uid.fill(-1);
1689
1690 const Int64 nb_cells_x = globalNbCellsX(level);
1691 const Int64 nb_cells_y = globalNbCellsY(level);
1692 const Int64 nb_cells_z = globalNbCellsZ(level);
1693
1694 for (Integer k = -1; k < 1; ++k) {
1695 const Int64 coord_cell_z = node_coord.z + k;
1696 if (coord_cell_z >= 0 && coord_cell_z < nb_cells_z) {
1697
1698 for (Integer j = -1; j < 1; ++j) {
1699 const Int64 coord_cell_y = node_coord.y + j;
1700 if (coord_cell_y >= 0 && coord_cell_y < nb_cells_y) {
1701
1702 for (Integer i = -1; i < 1; ++i) {
1703 const Int64 coord_cell_x = node_coord.x + i;
1704 if (coord_cell_x >= 0 && coord_cell_x < nb_cells_x) {
1705 uid[(i + 1) + ((j + 1) * 2) + ((k + 1) * 4)] = cellUniqueId(level, Int64x3{ coord_cell_x, coord_cell_y, coord_cell_z });
1706 }
1707 }
1708 }
1709 }
1710 }
1711 }
1712}
1713
1714/*---------------------------------------------------------------------------*/
1715/*---------------------------------------------------------------------------*/
1716
1717void CartesianMeshNumberingMngInternal::
1718cellUniqueIdsAroundNode(ArrayView<Int64> uid, Int64x2 node_coord, Int32 level)
1719{
1720 ARCANE_ASSERT((uid.size() == 4), ("Size of uid array != 4"));
1721
1722 uid.fill(-1);
1723
1724 const Int64 nb_cells_x = globalNbCellsX(level);
1725 const Int64 nb_cells_y = globalNbCellsY(level);
1726
1727 for (Integer j = -1; j < 1; ++j) {
1728 const Int64 coord_cell_y = node_coord.y + j;
1729 if (coord_cell_y >= 0 && coord_cell_y < nb_cells_y) {
1730
1731 for (Integer i = -1; i < 1; ++i) {
1732 const Int64 coord_cell_x = node_coord.x + i;
1733 if (coord_cell_x >= 0 && coord_cell_x < nb_cells_x) {
1734 uid[(i + 1) + ((j + 1) * 2)] = cellUniqueId(level, Int64x2{ coord_cell_x, coord_cell_y });
1735 }
1736 }
1737 }
1738 }
1739}
1740
1741/*---------------------------------------------------------------------------*/
1742/*---------------------------------------------------------------------------*/
1743
1744void CartesianMeshNumberingMngInternal::
1745cellUniqueIdsAroundNode(ArrayView<Int64> uid, Int64 node_uid, Int32 level)
1746{
1747 if (m_dimension == 2) {
1748 const Int64x2 node_coord{ nodeUniqueIdToCoordX(node_uid, level), nodeUniqueIdToCoordY(node_uid, level) };
1749 cellUniqueIdsAroundNode(uid, node_coord, level);
1750 }
1751 else {
1752 const Int64x3 node_coord{ nodeUniqueIdToCoordX(node_uid, level), nodeUniqueIdToCoordY(node_uid, level), nodeUniqueIdToCoordZ(node_uid, level) };
1753 cellUniqueIdsAroundNode(uid, node_coord, level);
1754 }
1755}
1756
1757/*---------------------------------------------------------------------------*/
1758/*---------------------------------------------------------------------------*/
1759
1760void CartesianMeshNumberingMngInternal::
1761cellUniqueIdsAroundNode(ArrayView<Int64> uid, Node node)
1762{
1763 cellUniqueIdsAroundNode(uid, node.uniqueId().asInt64(), nodeLevel(node.uniqueId().asInt64()));
1764}
1765
1766/*---------------------------------------------------------------------------*/
1767/*---------------------------------------------------------------------------*/
1768
1769void CartesianMeshNumberingMngInternal::
1770setChildNodeCoordinates(Cell parent_cell)
1771{
1772 if (!(parent_cell.itemBase().flags() & ItemFlags::II_JustRefined)) {
1773 ARCANE_FATAL("Cell not II_JustRefined");
1774 }
1775
1776 VariableNodeReal3& nodes_coords = m_mesh->nodesCoordinates();
1777
1778 const Real3& node0(nodes_coords[parent_cell.node(0)]);
1779 const Real3& node1(nodes_coords[parent_cell.node(1)]);
1780 const Real3& node2(nodes_coords[parent_cell.node(2)]);
1781 const Real3& node3(nodes_coords[parent_cell.node(3)]);
1782
1783 if (m_dimension == 2) {
1784
1785 /*
1786 =
1787 ┌─────────────────────►= y3
1788 │ = ▲ l
1789 ▼ = ▼
1790 X───────────────X◄────►= y2
1791 /▲ /▲ =
1792 / │ / │ =
1793 / │ / │ =
1794 / │ / │ =
1795 / │ / │ =
1796 / │ / │ =
1797 / │ / │ =
1798 / │ / │ =
1799 X───────────────X◄───────│─────►= y1
1800 ▲ │ ▲ │ = ▲ k
1801 │ │ │ │ = ▼
1802 ├──────────────────────────────►= y0
1803 │ │ │ │ =
1804 │ │ │ │ =
1805 ▼ ▼ ▼ ▼
1806 ==============================
1807 x0 ◄───► x3 x1 ◄───► x2
1808 i j
1809 */
1814 auto txty = [&](Integer pos_x, Integer pos_y) -> Real3 {
1815 const Real x = (Real)pos_x / (Real)m_pattern;
1816 const Real y = (Real)pos_y / (Real)m_pattern;
1817
1818 const Real i = (node3.x - node0.x) * y + node0.x;
1819 const Real j = (node2.x - node1.x) * y + node1.x;
1820
1821 const Real k = (node1.y - node0.y) * x + node0.y;
1822 const Real l = (node2.y - node3.y) * x + node3.y;
1823
1824 const Real tx = (j - i) * x + i;
1825 const Real ty = (l - k) * y + k;
1826
1827 /*
1828 info() << "[txty]"
1829 << " x : " << x
1830 << " -- y : " << y
1831 << " -- node0 : " << node0
1832 << " -- node1 : " << node1
1833 << " -- node2 : " << node2
1834 << " -- node3 : " << node3
1835 << " -- i : " << i
1836 << " -- j : " << j
1837 << " -- k : " << k
1838 << " -- l : " << l
1839 << " -- tx : " << tx
1840 << " -- ty : " << ty;
1841 */
1842 return { tx, ty, 0 };
1843 };
1844
1845 const Integer node_1d_2d_x[] = { 0, 1, 1, 0 };
1846 const Integer node_1d_2d_y[] = { 0, 0, 1, 1 };
1847
1848 for (Integer j = 0; j < m_pattern; ++j) {
1849 for (Integer i = 0; i < m_pattern; ++i) {
1850
1851 Integer begin = (i == 0 && j == 0 ? 0 : j == 0 ? 1
1852 : 2);
1853 Integer end = (i == 0 ? nbNodeByCell() : nbNodeByCell() - 1);
1854 Cell child = childCellOfCell(parent_cell, Int64x2(i, j));
1855
1856 for (Integer inode = begin; inode < end; ++inode) {
1857 nodes_coords[child.node(inode)] = txty(i + node_1d_2d_x[inode], j + node_1d_2d_y[inode]);
1858 // Real3 pos = txty(i + node_1d_2d_x[inode], j + node_1d_2d_y[inode]);
1859 // nodes_coords[child.node(inode)] = pos;
1860 // info() << "Node uid : " << child.node(inode).uniqueId()
1861 // << " -- nodeX : " << (i + node_1d_2d_x[inode])
1862 // << " -- nodeY : " << (j + node_1d_2d_y[inode])
1863 // << " -- Pos : " << pos;
1864 }
1865 }
1866 }
1867 }
1868
1869 else {
1870 const Real3& node4(nodes_coords[parent_cell.node(4)]);
1871 const Real3& node5(nodes_coords[parent_cell.node(5)]);
1872 const Real3& node6(nodes_coords[parent_cell.node(6)]);
1873 const Real3& node7(nodes_coords[parent_cell.node(7)]);
1874
1879 auto txtytz = [&](Integer pos_x, Integer pos_y, Integer pos_z) -> Real3 {
1880 const Real x = (Real)pos_x / (Real)m_pattern;
1881 const Real y = (Real)pos_y / (Real)m_pattern;
1882 const Real z = (Real)pos_z / (Real)m_pattern;
1883
1884 // Face (m, n, o, p) entre les faces (node0, node1, node2, node3) et (node4, node5, node6, node7).
1885 const Real3 m = (node4 - node0) * z + node0;
1886 const Real3 n = (node5 - node1) * z + node1;
1887 const Real3 o = (node6 - node2) * z + node2;
1888 const Real3 p = (node7 - node3) * z + node3;
1889
1890 // On calcule tx et ty comme en 2D mais sur la face (m, n, o, p).
1891 const Real i = (p.x - m.x) * y + m.x;
1892 const Real j = (o.x - n.x) * y + n.x;
1893
1894 const Real tx = (j - i) * x + i;
1895
1896 const Real k = (n.y - m.y) * x + m.y;
1897 const Real l = (o.y - p.y) * x + p.y;
1898
1899 const Real ty = (l - k) * y + k;
1900
1901 const Real q = (p.z - m.z) * y + m.z;
1902 const Real r = (o.z - n.z) * y + n.z;
1903
1904 const Real s = (n.z - m.z) * x + m.z;
1905 const Real t = (o.z - p.z) * x + p.z;
1906
1907 const Real tz = (((r - q) * x + q) + ((t - s) * y + s)) * 0.5;
1908
1909 /*
1910 info() << "[txtytz]"
1911 << " x : " << x
1912 << " -- y : " << y
1913 << " -- z : " << z
1914 << " -- node0 : " << node0
1915 << " -- node1 : " << node1
1916 << " -- node2 : " << node2
1917 << " -- node3 : " << node3
1918 << " -- node4 : " << node4
1919 << " -- node5 : " << node5
1920 << " -- node6 : " << node6
1921 << " -- node7 : " << node7
1922 << " -- m : " << m
1923 << " -- n : " << n
1924 << " -- o : " << o
1925 << " -- p : " << p
1926 << " -- j : " << j
1927 << " -- k : " << k
1928 << " -- l : " << l
1929 << " -- q : " << q
1930 << " -- r : " << r
1931 << " -- s : " << s
1932 << " -- t : " << t
1933 << " -- tx : " << tx
1934 << " -- ty : " << ty
1935 << " -- tz : " << tz;
1936 */
1937 return { tx, ty, tz };
1938 };
1939
1940 const Integer node_1d_3d_x[] = { 0, 1, 1, 0, 0, 1, 1, 0 };
1941 const Integer node_1d_3d_y[] = { 0, 0, 1, 1, 0, 0, 1, 1 };
1942 const Integer node_1d_3d_z[] = { 0, 0, 0, 0, 1, 1, 1, 1 };
1943
1944 for (Integer k = 0; k < m_pattern; ++k) {
1945 for (Integer j = 0; j < m_pattern; ++j) {
1946 for (Integer i = 0; i < m_pattern; ++i) {
1947
1948 // TODO : éviter les multiples appels pour un même noeud.
1949 Integer begin = 0;
1950 Integer end = nbNodeByCell();
1951 Cell child = childCellOfCell(parent_cell, Int64x3(i, j, k));
1952
1953 for (Integer inode = begin; inode < end; ++inode) {
1954 nodes_coords[child.node(inode)] = txtytz(i + node_1d_3d_x[inode], j + node_1d_3d_y[inode], k + node_1d_3d_z[inode]);
1955 // Real3 pos = txtytz(i + node_1d_3d_x[inode], j + node_1d_3d_y[inode], k + node_1d_3d_z[inode]);
1956 // nodes_coords[child.node(inode)] = pos;
1957 // info() << "Node uid : " << child.node(inode).uniqueId()
1958 // << " -- nodeX : " << (i + node_1d_3d_x[inode])
1959 // << " -- nodeY : " << (j + node_1d_3d_y[inode])
1960 // << " -- nodeZ : " << (k + node_1d_3d_z[inode])
1961 // << " -- Pos : " << pos;
1962 }
1963 }
1964 }
1965 }
1966 }
1967}
1968
1969/*---------------------------------------------------------------------------*/
1970/*---------------------------------------------------------------------------*/
1971
1972void CartesianMeshNumberingMngInternal::
1973setParentNodeCoordinates(Cell parent_cell)
1974{
1975 if (!(parent_cell.itemBase().flags() & ItemFlags::II_JustAdded)) {
1976 ARCANE_FATAL("Cell not II_JustAdded");
1977 }
1978
1979 VariableNodeReal3& nodes_coords = m_mesh->nodesCoordinates();
1980
1981 if (m_dimension == 2) {
1982 nodes_coords[parent_cell.node(0)] = nodes_coords[childCellOfCell(parent_cell, Int64x2(0, 0)).node(0)];
1983 nodes_coords[parent_cell.node(1)] = nodes_coords[childCellOfCell(parent_cell, Int64x2(m_pattern - 1, 0)).node(1)];
1984 nodes_coords[parent_cell.node(2)] = nodes_coords[childCellOfCell(parent_cell, Int64x2(m_pattern - 1, m_pattern - 1)).node(2)];
1985 nodes_coords[parent_cell.node(3)] = nodes_coords[childCellOfCell(parent_cell, Int64x2(0, m_pattern - 1)).node(3)];
1986 }
1987
1988 else {
1989 nodes_coords[parent_cell.node(0)] = nodes_coords[childCellOfCell(parent_cell, Int64x3(0, 0, 0)).node(0)];
1990 nodes_coords[parent_cell.node(1)] = nodes_coords[childCellOfCell(parent_cell, Int64x3(m_pattern - 1, 0, 0)).node(1)];
1991 nodes_coords[parent_cell.node(2)] = nodes_coords[childCellOfCell(parent_cell, Int64x3(m_pattern - 1, m_pattern - 1, 0)).node(2)];
1992 nodes_coords[parent_cell.node(3)] = nodes_coords[childCellOfCell(parent_cell, Int64x3(0, m_pattern - 1, 0)).node(3)];
1993
1994 nodes_coords[parent_cell.node(4)] = nodes_coords[childCellOfCell(parent_cell, Int64x3(0, 0, m_pattern - 1)).node(4)];
1995 nodes_coords[parent_cell.node(5)] = nodes_coords[childCellOfCell(parent_cell, Int64x3(m_pattern - 1, 0, m_pattern - 1)).node(5)];
1996 nodes_coords[parent_cell.node(6)] = nodes_coords[childCellOfCell(parent_cell, Int64x3(m_pattern - 1, m_pattern - 1, m_pattern - 1)).node(6)];
1997 nodes_coords[parent_cell.node(7)] = nodes_coords[childCellOfCell(parent_cell, Int64x3(0, m_pattern - 1, m_pattern - 1)).node(7)];
1998 }
1999}
2000
2001/*---------------------------------------------------------------------------*/
2002/*---------------------------------------------------------------------------*/
2003
2004Int64 CartesianMeshNumberingMngInternal::
2005parentCellUniqueIdOfCell(Int64 uid, Integer level, bool do_fatal)
2006{
2007 // Pour avoir la face parent d'une maille, on passe d'abord de l'uid vers les
2008 // coordonnées de la maille,
2009 // puis on détermine les coordonnées du parent grâce au m_pattern,
2010 // et enfin, on repasse des coordonnées du parent vers son uid.
2011
2012 if (globalNbCellsX(level - 1) == 0) {
2013 if (do_fatal) {
2014 ARCANE_FATAL("Level {0} do not exist", (level - 1));
2015 }
2016 return NULL_ITEM_UNIQUE_ID;
2017 }
2018
2019 if (m_dimension == 2) {
2020 return cellUniqueId(level - 1,
2021 Int64x2(offsetLevelToLevel(cellUniqueIdToCoordX(uid, level), level, level - 1),
2022 offsetLevelToLevel(cellUniqueIdToCoordY(uid, level), level, level - 1)));
2023 }
2024 else {
2025 return cellUniqueId(level - 1,
2026 Int64x3(offsetLevelToLevel(cellUniqueIdToCoordX(uid, level), level, level - 1),
2027 offsetLevelToLevel(cellUniqueIdToCoordY(uid, level), level, level - 1),
2028 offsetLevelToLevel(cellUniqueIdToCoordZ(uid, level), level, level - 1)));
2029 }
2030}
2031
2032/*---------------------------------------------------------------------------*/
2033/*---------------------------------------------------------------------------*/
2034
2035Int64 CartesianMeshNumberingMngInternal::
2036parentCellUniqueIdOfCell(Cell cell, bool do_fatal)
2037{
2038 return parentCellUniqueIdOfCell(cell.uniqueId(), cell.level(), do_fatal);
2039}
2040
2041/*---------------------------------------------------------------------------*/
2042/*---------------------------------------------------------------------------*/
2043
2044Int64 CartesianMeshNumberingMngInternal::
2045childCellUniqueIdOfCell(Cell cell, Int64x3 child_coord_in_parent)
2046{
2047 ARCANE_ASSERT((child_coord_in_parent.x < m_pattern && child_coord_in_parent.x >= 0), ("Bad child_coord_in_parent.x"))
2048 ARCANE_ASSERT((child_coord_in_parent.y < m_pattern && child_coord_in_parent.y >= 0), ("Bad child_coord_in_parent.y"))
2049 ARCANE_ASSERT((child_coord_in_parent.z < m_pattern && child_coord_in_parent.z >= 0), ("Bad child_coord_in_parent.z"))
2050
2051 const Int64 uid = cell.uniqueId();
2052 const Int32 level = cell.level();
2053
2054 return cellUniqueId(level + 1,
2055 Int64x3(offsetLevelToLevel(cellUniqueIdToCoordX(uid, level), level, level + 1) + child_coord_in_parent.x,
2056 offsetLevelToLevel(cellUniqueIdToCoordY(uid, level), level, level + 1) + child_coord_in_parent.y,
2057 offsetLevelToLevel(cellUniqueIdToCoordZ(uid, level), level, level + 1) + child_coord_in_parent.z));
2058}
2059
2060/*---------------------------------------------------------------------------*/
2061/*---------------------------------------------------------------------------*/
2062
2063Int64 CartesianMeshNumberingMngInternal::
2064childCellUniqueIdOfCell(Cell cell, Int64x2 child_coord_in_parent)
2065{
2066 ARCANE_ASSERT((child_coord_in_parent.x < m_pattern && child_coord_in_parent.x >= 0), ("Bad child_coord_in_parent.x"))
2067 ARCANE_ASSERT((child_coord_in_parent.y < m_pattern && child_coord_in_parent.y >= 0), ("Bad child_coord_in_parent.y"))
2068
2069 const Int64 uid = cell.uniqueId();
2070 const Int32 level = cell.level();
2071
2072 return cellUniqueId(level + 1,
2073 Int64x2(offsetLevelToLevel(cellUniqueIdToCoordX(uid, level), level, level + 1) + child_coord_in_parent.x,
2074 offsetLevelToLevel(cellUniqueIdToCoordY(uid, level), level, level + 1) + child_coord_in_parent.y));
2075}
2076
2077/*---------------------------------------------------------------------------*/
2078/*---------------------------------------------------------------------------*/
2079
2080Int64 CartesianMeshNumberingMngInternal::
2081childCellUniqueIdOfCell(Cell cell, Int64 child_index_in_parent)
2082{
2083 if (m_dimension == 2) {
2084 ARCANE_ASSERT((child_index_in_parent < m_pattern * m_pattern && child_index_in_parent >= 0), ("Bad child_index_in_parent"))
2085
2086 return childCellUniqueIdOfCell(cell,
2087 Int64x2(
2088 child_index_in_parent % m_pattern,
2089 child_index_in_parent / m_pattern));
2090 }
2091
2092 else {
2093 ARCANE_ASSERT((child_index_in_parent < m_pattern * m_pattern * m_pattern && child_index_in_parent >= 0), ("Bad child_index_in_parent"))
2094
2095 const Int64 to_2d = child_index_in_parent % (m_pattern * m_pattern);
2096 return childCellUniqueIdOfCell(cell,
2097 Int64x3(
2098 to_2d % m_pattern,
2099 to_2d / m_pattern,
2100 child_index_in_parent / (m_pattern * m_pattern)));
2101 }
2102}
2103
2104/*---------------------------------------------------------------------------*/
2105/*---------------------------------------------------------------------------*/
2106
2107Cell CartesianMeshNumberingMngInternal::
2108childCellOfCell(Cell cell, Int64x3 child_coord_in_parent)
2109{
2110 ARCANE_ASSERT((child_coord_in_parent.x < m_pattern && child_coord_in_parent.x >= 0), ("Bad child_coord_in_parent.x"))
2111 ARCANE_ASSERT((child_coord_in_parent.y < m_pattern && child_coord_in_parent.y >= 0), ("Bad child_coord_in_parent.y"))
2112
2113 Cell child = cell.hChild((Int32)child_coord_in_parent.x + ((Int32)child_coord_in_parent.y * m_pattern) + ((Int32)child_coord_in_parent.z * m_pattern * m_pattern));
2114 const Int64 uid = childCellUniqueIdOfCell(cell, child_coord_in_parent);
2115
2116 // Si jamais la maille à l'index calculé ne correspond pas à l'uniqueId
2117 // recherché, on recherche parmi les autres mailles enfants.
2118 if (child.uniqueId() != uid) {
2119 const Int32 nb_children = cell.nbHChildren();
2120 for (Integer i = 0; i < nb_children; ++i) {
2121 if (cell.hChild(i).uniqueId() == uid) {
2122 return cell.hChild(i);
2123 }
2124 }
2125 ARCANE_FATAL("Unknown cell uid -- uid : {0} -- parent_uid : {1}", uid, cell.uniqueId());
2126 }
2127 return child;
2128}
2129
2130/*---------------------------------------------------------------------------*/
2131/*---------------------------------------------------------------------------*/
2132
2133Cell CartesianMeshNumberingMngInternal::
2134childCellOfCell(Cell cell, Int64x2 child_coord_in_parent)
2135{
2136 ARCANE_ASSERT((child_coord_in_parent.x < m_pattern && child_coord_in_parent.x >= 0), ("Bad child_coord_in_parent.x"))
2137 ARCANE_ASSERT((child_coord_in_parent.y < m_pattern && child_coord_in_parent.y >= 0), ("Bad child_coord_in_parent.y"))
2138
2139 Cell child = cell.hChild((Int32)child_coord_in_parent.x + ((Int32)child_coord_in_parent.y * m_pattern));
2140 const Int64 uid = childCellUniqueIdOfCell(cell, child_coord_in_parent);
2141
2142 // Si jamais la maille à l'index calculé ne correspond pas à l'uniqueId
2143 // recherché, on recherche parmi les autres mailles enfants.
2144 if (child.uniqueId() != uid) {
2145 const Int32 nb_children = cell.nbHChildren();
2146 for (Integer i = 0; i < nb_children; ++i) {
2147 if (cell.hChild(i).uniqueId() == uid) {
2148 return cell.hChild(i);
2149 }
2150 }
2151 ARCANE_FATAL("Unknown cell uid -- uid : {0} -- parent_uid : {1}", uid, cell.uniqueId());
2152 }
2153 return child;
2154}
2155
2156/*---------------------------------------------------------------------------*/
2157/*---------------------------------------------------------------------------*/
2158
2159Int64 CartesianMeshNumberingMngInternal::
2160parentNodeUniqueIdOfNode(Int64 uid, Integer level, bool do_fatal)
2161{
2162 // Pour avoir le noeud parent d'un noeud, on passe d'abord de l'uid vers les
2163 // coordonnées du noeud, puis on détermine les coordonnées du parent grâce au m_pattern,
2164 // et enfin, on repasse des coordonnées du parent vers son uid.
2165
2166 const Int64 coord_x = nodeUniqueIdToCoordX(uid, level);
2167 const Int64 coord_y = nodeUniqueIdToCoordY(uid, level);
2168
2169 if (coord_x % m_pattern != 0 || coord_y % m_pattern != 0) {
2170 if (do_fatal) {
2171 ARCANE_FATAL("Node uid={0} do not have parent", uid);
2172 }
2173 return NULL_ITEM_UNIQUE_ID;
2174 }
2175
2176 if (m_dimension == 2) {
2177 return nodeUniqueId(level - 1,
2178 Int64x2(offsetLevelToLevel(coord_x, level, level - 1),
2179 offsetLevelToLevel(coord_y, level, level - 1)));
2180 }
2181 else {
2182 const Int64 coord_z = nodeUniqueIdToCoordZ(uid, level);
2183
2184 if (coord_z % m_pattern != 0) {
2185 if (do_fatal) {
2186 ARCANE_FATAL("Node uid={0} do not have parent", uid);
2187 }
2188 return NULL_ITEM_UNIQUE_ID;
2189 }
2190 return nodeUniqueId(level - 1,
2191 Int64x3(offsetLevelToLevel(coord_x, level, level - 1),
2192 offsetLevelToLevel(coord_y, level, level - 1),
2193 offsetLevelToLevel(coord_z, level, level - 1)));
2194 }
2195}
2196
2197/*---------------------------------------------------------------------------*/
2198/*---------------------------------------------------------------------------*/
2199
2200Int64 CartesianMeshNumberingMngInternal::
2201parentNodeUniqueIdOfNode(Node node, bool do_fatal)
2202{
2203 const Int64 uid = node.uniqueId();
2204 return parentNodeUniqueIdOfNode(uid, nodeLevel(uid), do_fatal);
2205}
2206
2207/*---------------------------------------------------------------------------*/
2208/*---------------------------------------------------------------------------*/
2209
2210Int64 CartesianMeshNumberingMngInternal::
2211childNodeUniqueIdOfNode(Int64 uid, Integer level)
2212{
2213 if (m_dimension == 2) {
2214 return nodeUniqueId(level + 1,
2215 Int64x2(offsetLevelToLevel(nodeUniqueIdToCoordX(uid, level), level, level + 1),
2216 offsetLevelToLevel(nodeUniqueIdToCoordY(uid, level), level, level + 1)));
2217 }
2218
2219 else {
2220 return nodeUniqueId(level + 1,
2221 Int64x3(offsetLevelToLevel(nodeUniqueIdToCoordX(uid, level), level, level + 1),
2222 offsetLevelToLevel(nodeUniqueIdToCoordY(uid, level), level, level + 1),
2223 offsetLevelToLevel(nodeUniqueIdToCoordZ(uid, level), level, level + 1)));
2224 }
2225}
2226
2227/*---------------------------------------------------------------------------*/
2228/*---------------------------------------------------------------------------*/
2229
2230Int64 CartesianMeshNumberingMngInternal::
2231childNodeUniqueIdOfNode(Node node)
2232{
2233 const Int64 uid = node.uniqueId();
2234 return childNodeUniqueIdOfNode(uid, nodeLevel(uid));
2235}
2236
2237/*---------------------------------------------------------------------------*/
2238/*---------------------------------------------------------------------------*/
2239
2240Int64 CartesianMeshNumberingMngInternal::
2241parentFaceUniqueIdOfFace(Int64 uid, Integer level, bool do_fatal)
2242{
2243 if (m_converting_numbering_face && level == m_ori_level) {
2244 uid = m_face_ori_numbering_to_new[uid];
2245 }
2246
2247 // Pour avoir la face parent d'une face, on passe d'abord de l'uid vers les
2248 // coordonnées de la face en "vue cartésienne",
2249 // puis on détermine les coordonnées du parent grâce au m_pattern,
2250 // et enfin, on repasse des coordonnées du parent vers son uid.
2251
2252 const Int64 coord_x = faceUniqueIdToCoordX(uid, level);
2253 const Int64 coord_y = faceUniqueIdToCoordY(uid, level);
2254
2255 ARCANE_ASSERT((coord_x < globalNbFacesXCartesianView(level) && coord_x >= 0), ("Bad coord_x"))
2256 ARCANE_ASSERT((coord_y < globalNbFacesYCartesianView(level) && coord_y >= 0), ("Bad coord_y"))
2257
2258 const Int64 parent_coord_x = faceOffsetLevelToLevel(coord_x, level, level - 1);
2259 const Int64 parent_coord_y = faceOffsetLevelToLevel(coord_y, level, level - 1);
2260
2261 if (parent_coord_x == -1 || parent_coord_y == -1) {
2262 if (do_fatal) {
2263 ARCANE_FATAL("Face uid={0} do not have parent", uid);
2264 }
2265 return NULL_ITEM_UNIQUE_ID;
2266 }
2267
2268 ARCANE_ASSERT((parent_coord_x < globalNbFacesXCartesianView(level - 1) && parent_coord_x >= 0), ("Bad parent_coord_x"))
2269 ARCANE_ASSERT((parent_coord_y < globalNbFacesYCartesianView(level - 1) && parent_coord_y >= 0), ("Bad parent_coord_y"))
2270
2271 if (m_dimension == 2) {
2272 if (m_converting_numbering_face && level - 1 == m_ori_level) {
2273 return m_face_new_numbering_to_ori[faceUniqueId(level - 1, Int64x2(parent_coord_x, parent_coord_y))];
2274 }
2275 return faceUniqueId(level - 1, Int64x2(parent_coord_x, parent_coord_y));
2276 }
2277 else {
2278 const Int64 coord_z = faceUniqueIdToCoordZ(uid, level);
2279 ARCANE_ASSERT((coord_z < globalNbFacesZCartesianView(level) && coord_z >= 0), ("Bad coord_z"))
2280
2281 const Int64 parent_coord_z = faceOffsetLevelToLevel(coord_z, level, level - 1);
2282
2283 if (parent_coord_z == -1) {
2284 if (do_fatal) {
2285 ARCANE_FATAL("Face uid={0} do not have parent", uid);
2286 }
2287 return NULL_ITEM_UNIQUE_ID;
2288 }
2289
2290 ARCANE_ASSERT((parent_coord_z < globalNbFacesZCartesianView(level - 1) && parent_coord_z >= 0), ("Bad parent_coord_z"))
2291
2292 // debug() << "Uid : " << uid << " -- CoordX : " << coord_x << " -- CoordY : " << coord_y << " -- CoordZ : " << coord_z;
2293
2294 if (m_converting_numbering_face && level - 1 == m_ori_level) {
2295 return m_face_new_numbering_to_ori[faceUniqueId(level - 1, Int64x3(parent_coord_x, parent_coord_y, parent_coord_z))];
2296 }
2297
2298 return faceUniqueId(level - 1, Int64x3(parent_coord_x, parent_coord_y, parent_coord_z));
2299 }
2300}
2301
2302/*---------------------------------------------------------------------------*/
2303/*---------------------------------------------------------------------------*/
2304
2305Int64 CartesianMeshNumberingMngInternal::
2306parentFaceUniqueIdOfFace(Face face, bool do_fatal)
2307{
2308 const Int64 uid = face.uniqueId();
2309 return parentFaceUniqueIdOfFace(uid, faceLevel(uid), do_fatal);
2310}
2311
2312/*---------------------------------------------------------------------------*/
2313/*---------------------------------------------------------------------------*/
2314
2315Int64 CartesianMeshNumberingMngInternal::
2316childFaceUniqueIdOfFace(Int64 uid, Integer level, Int64 child_index_in_parent)
2317{
2318 if (m_converting_numbering_face && level == m_ori_level) {
2319 uid = m_face_ori_numbering_to_new[uid];
2320 }
2321
2322 const Int64 coord_x = faceUniqueIdToCoordX(uid, level);
2323 const Int64 coord_y = faceUniqueIdToCoordY(uid, level);
2324
2325 ARCANE_ASSERT((coord_x < globalNbFacesXCartesianView(level) && coord_x >= 0), ("Bad coord_x"))
2326 ARCANE_ASSERT((coord_y < globalNbFacesYCartesianView(level) && coord_y >= 0), ("Bad coord_y"))
2327
2328 Int64 first_child_coord_x = faceOffsetLevelToLevel(coord_x, level, level + 1);
2329 Int64 first_child_coord_y = faceOffsetLevelToLevel(coord_y, level, level + 1);
2330
2331 ARCANE_ASSERT((first_child_coord_x < globalNbFacesXCartesianView(level + 1) && first_child_coord_x >= 0), ("Bad first_child_coord_x"))
2332 ARCANE_ASSERT((first_child_coord_y < globalNbFacesYCartesianView(level + 1) && first_child_coord_y >= 0), ("Bad first_child_coord_y"))
2333
2334 if (m_dimension == 2) {
2335 ARCANE_ASSERT((child_index_in_parent < m_pattern && child_index_in_parent >= 0), ("Invalid child_index_in_parent"))
2336
2337 if (coord_y % 2 == 0) {
2338 first_child_coord_x += child_index_in_parent * 2;
2339 }
2340 else if (coord_x % 2 == 0) {
2341 first_child_coord_y += child_index_in_parent * globalNbFacesY(level + 1);
2342 }
2343 else {
2344 ARCANE_FATAL("Impossible normalement");
2345 }
2346
2347 if (m_converting_numbering_face && level + 1 == m_ori_level) {
2348 return m_face_new_numbering_to_ori[faceUniqueId(level + 1, Int64x2(first_child_coord_x, first_child_coord_y))];
2349 }
2350
2351 return faceUniqueId(level + 1, Int64x2(first_child_coord_x, first_child_coord_y));
2352 }
2353
2354 else {
2355 ARCANE_ASSERT((child_index_in_parent < m_pattern * m_pattern && child_index_in_parent >= 0), ("Invalid child_index_in_parent"))
2356
2357 const Int64 coord_z = faceUniqueIdToCoordZ(uid, level);
2358 ARCANE_ASSERT((coord_z < globalNbFacesZCartesianView(level) && coord_z >= 0), ("Bad coord_z"))
2359
2360 Int64 first_child_coord_z = faceOffsetLevelToLevel(coord_z, level, level + 1);
2361 ARCANE_ASSERT((first_child_coord_z < globalNbFacesZCartesianView(level + 1) && first_child_coord_z >= 0), ("Bad first_child_coord_z"))
2362
2363 Int64 child_x = child_index_in_parent % m_pattern;
2364 Int64 child_y = child_index_in_parent / m_pattern;
2365
2366 Int64x3 three_parts_numbering = _face3DNumberingThreeParts(level);
2367
2368 if (uid < three_parts_numbering.x) {
2369 first_child_coord_y += child_x * 2;
2370 first_child_coord_z += child_y * 2;
2371 }
2372 else if (uid < three_parts_numbering.x + three_parts_numbering.y) {
2373 first_child_coord_x += child_x * 2;
2374 first_child_coord_z += child_y * 2;
2375 }
2376 else {
2377 first_child_coord_x += child_x * 2;
2378 first_child_coord_y += child_y * 2;
2379 }
2380
2381 if (m_converting_numbering_face && level + 1 == m_ori_level) {
2382 return m_face_new_numbering_to_ori[faceUniqueId(level + 1, Int64x3(first_child_coord_x, first_child_coord_y, first_child_coord_z))];
2383 }
2384
2385 return faceUniqueId(level + 1, Int64x3(first_child_coord_x, first_child_coord_y, first_child_coord_z));
2386 }
2387}
2388
2389/*---------------------------------------------------------------------------*/
2390/*---------------------------------------------------------------------------*/
2391
2392Int64 CartesianMeshNumberingMngInternal::
2393childFaceUniqueIdOfFace(Face face, Int64 child_index_in_parent)
2394{
2395 const Int64 uid = face.uniqueId();
2396 return childFaceUniqueIdOfFace(uid, faceLevel(uid), child_index_in_parent);
2397}
2398
2399/*---------------------------------------------------------------------------*/
2400/*---------------------------------------------------------------------------*/
2401
2402Int64x3 CartesianMeshNumberingMngInternal::
2403_face3DNumberingThreeParts(Integer level) const
2404{
2405 const Int64x3 nb_cell(globalNbCellsX(level), globalNbCellsY(level), globalNbCellsZ(level));
2406 return { (nb_cell.x + 1) * nb_cell.y * nb_cell.z, (nb_cell.y + 1) * nb_cell.z * nb_cell.x, (nb_cell.z + 1) * nb_cell.x * nb_cell.y };
2407}
2408
2409/*---------------------------------------------------------------------------*/
2410/*---------------------------------------------------------------------------*/
2411
2412void CartesianMeshNumberingMngInternal::
2413_pushFront(UniqueArray<Int64>& array, const Int64 elem)
2414{
2415 array.resize(array.size() + 1);
2416 array.back() = elem;
2417 for (Integer i = array.size() - 2; i >= 0; --i) {
2418 std::swap(array[i], array[i + 1]);
2419 }
2420}
2421
2422/*---------------------------------------------------------------------------*/
2423/*---------------------------------------------------------------------------*/
2424
2425} // End namespace Arcane
2426
2427/*---------------------------------------------------------------------------*/
2428/*---------------------------------------------------------------------------*/
ARCANE_FATAL
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
Definition ArcaneGlobal.h:740
ENUMERATE_
#define ENUMERATE_(type, name, group)
Enumérateur générique d'un groupe d'entité
Definition ItemEnumerator.h:407
Arcane::AbstractArray::size
Integer size() const
Nombre d'éléments du vecteur.
Definition AbstractArray.h:301
Arcane::ArrayView
Vue modifiable d'un tableau d'un type T.
Definition arccore/src/base/arccore/base/ArrayView.h:94
Arcane::ArrayView::fill
void fill(const T &o) noexcept
Remplit le tableau avec la valeur o.
Definition arccore/src/base/arccore/base/ArrayView.h:301
Arcane::ArrayView::size
constexpr Integer size() const noexcept
Retourne la taille du tableau.
Definition arccore/src/base/arccore/base/ArrayView.h:235
Arcane::Array::resize
void resize(Int64 s)
Change le nombre d'éléments du tableau à s.
Definition arccore/src/common/arccore/common/Array.h:249
Arcane::Array::back
T & back()
Dernier élément du tableau.
Definition arccore/src/common/arccore/common/Array.h:380
Arcane::CartesianMeshNumberingMngInternal::globalNbFacesY
Int64 globalNbFacesY(Integer level) const override
Méthode permettant de récupérer le nombre de faces global en Y d'un niveau.
Definition CartesianMeshNumberingMngInternal.cc:408
Arcane::CartesianMeshNumberingMngInternal::firstCellUniqueId
Int64 firstCellUniqueId(Integer level) const override
Méthode permettant de récupérer le premier unique id utilisé par les mailles d'un niveau....
Definition CartesianMeshNumberingMngInternal.cc:318
Arcane::CartesianMeshNumberingMngInternal::firstFaceUniqueId
Int64 firstFaceUniqueId(Integer level) const override
Méthode permettant de récupérer le premier unique id utilisé par les faces d'un niveau....
Definition CartesianMeshNumberingMngInternal.cc:336
Arcane::CartesianMeshNumberingMngInternal::nbNodeInLevel
Int64 nbNodeInLevel(Integer level) const override
Méthode permettant de récupérer le nombre de noeuds total dans un niveau.
Definition CartesianMeshNumberingMngInternal.cc:468
Arcane::CartesianMeshNumberingMngInternal::nodeUniqueIdToCoordX
Int64 nodeUniqueIdToCoordX(Int64 uid, Integer level) override
Méthode permettant de récupérer la coordonnée en X d'un noeud grâce à son uniqueId.
Definition CartesianMeshNumberingMngInternal.cc:741
Arcane::CartesianMeshNumberingMngInternal::offsetLevelToLevel
Int64 offsetLevelToLevel(Int64 coord, Integer level_from, Integer level_to) const override
Méthode permettant d'obtenir la position du premier noeud/maille fille à partir de la position du noe...
Definition CartesianMeshNumberingMngInternal.cc:589
Arcane::CartesianMeshNumberingMngInternal::cellUniqueIdToCoordY
Int64 cellUniqueIdToCoordY(Int64 uid, Integer level) override
Méthode permettant de récupérer la coordonnée en Y d'une maille grâce à son uniqueId.
Definition CartesianMeshNumberingMngInternal.cc:692
Arcane::CartesianMeshNumberingMngInternal::faceUniqueIdToCoordZ
Int64 faceUniqueIdToCoordZ(Int64 uid, Integer level) override
Méthode permettant de récupérer la coordonnée en Z d'une face grâce à son uniqueId.
Definition CartesianMeshNumberingMngInternal.cc:1082
Arcane::CartesianMeshNumberingMngInternal::cellUniqueIdToCoordX
Int64 cellUniqueIdToCoordX(Int64 uid, Integer level) override
Méthode permettant de récupérer la coordonnée en X d'une maille grâce à son uniqueId.
Definition CartesianMeshNumberingMngInternal.cc:667
Arcane::CartesianMeshNumberingMngInternal::faceUniqueIdToCoordY
Int64 faceUniqueIdToCoordY(Int64 uid, Integer level) override
Méthode permettant de récupérer la coordonnée en Y d'une face grâce à son uniqueId.
Definition CartesianMeshNumberingMngInternal.cc:945
Arcane::CartesianMeshNumberingMngInternal::pattern
Integer pattern() const override
Méthode permettant de récupérer le pattern de raffinement utilisé dans chaque maille....
Definition CartesianMeshNumberingMngInternal.cc:498
Arcane::CartesianMeshNumberingMngInternal::faceUniqueId
Int64 faceUniqueId(Integer level, Int64x3 face_coord) override
Méthode permettant de récupérer l'uniqueId d'une face à partir de sa position et de son niveau.
Definition CartesianMeshNumberingMngInternal.cc:1234
Arcane::CartesianMeshNumberingMngInternal::firstNodeUniqueId
Int64 firstNodeUniqueId(Integer level) const override
Méthode permettant de récupérer le premier unique id utilisé par les noeuds d'un niveau....
Definition CartesianMeshNumberingMngInternal.cc:327
Arcane::CartesianMeshNumberingMngInternal::globalNbFacesX
Int64 globalNbFacesX(Integer level) const override
Méthode permettant de récupérer le nombre de faces global en X d'un niveau.
Definition CartesianMeshNumberingMngInternal.cc:399
Arcane::CartesianMeshNumberingMngInternal::faceUniqueIdToCoordX
Int64 faceUniqueIdToCoordX(Int64 uid, Integer level) override
Méthode permettant de récupérer la coordonnée en X d'une face grâce à son uniqueId.
Definition CartesianMeshNumberingMngInternal.cc:818
Arcane::CartesianMeshNumberingMngInternal::globalNbCellsY
Int64 globalNbCellsY(Integer level) const override
Méthode permettant de récupérer le nombre de mailles global en Y d'un niveau.
Definition CartesianMeshNumberingMngInternal.cc:354
Arcane::CartesianMeshNumberingMngInternal::faceOffsetLevelToLevel
Int64 faceOffsetLevelToLevel(Int64 coord, Integer level_from, Integer level_to) const override
Méthode permettant d'obtenir la position de la première face enfant à partir de la position de la fac...
Definition CartesianMeshNumberingMngInternal.cc:605
Arcane::CartesianMeshNumberingMngInternal::globalNbCellsX
Int64 globalNbCellsX(Integer level) const override
Méthode permettant de récupérer le nombre de mailles global en X d'un niveau.
Definition CartesianMeshNumberingMngInternal.cc:345
Arcane::CartesianMeshNumberingMngInternal::faceLevel
Int32 faceLevel(Int64 uid) const override
Méthode permettant de récupérer le niveau d'une face avec son uid.
Definition CartesianMeshNumberingMngInternal.cc:561
Arcane::CartesianMeshNumberingMngInternal::globalNbNodesY
Int64 globalNbNodesY(Integer level) const override
Méthode permettant de récupérer le nombre de noeuds global en Y d'un niveau.
Definition CartesianMeshNumberingMngInternal.cc:381
Arcane::CartesianMeshNumberingMngInternal::cellNodeUniqueIds
void cellNodeUniqueIds(ArrayView< Int64 > uid, Integer level, Int64x3 cell_coord) override
Méthode permettant de récupérer les uniqueIds des noeuds d'une maille à partir de ses coordonnées.
Definition CartesianMeshNumberingMngInternal.cc:1367
Arcane::CartesianMeshNumberingMngInternal::nodeUniqueId
Int64 nodeUniqueId(Integer level, Int64x3 node_coord) override
Méthode permettant de récupérer l'uniqueId d'un noeud à partir de sa position et de son niveau.
Definition CartesianMeshNumberingMngInternal.cc:1209
Arcane::CartesianMeshNumberingMngInternal::cellUniqueId
Int64 cellUniqueId(Integer level, Int64x3 cell_coord) override
Méthode permettant de récupérer l'uniqueId d'une maille à partir de sa position et de son niveau.
Definition CartesianMeshNumberingMngInternal.cc:1184
Arcane::CartesianMeshNumberingMngInternal::cellUniqueIdsAroundNode
void cellUniqueIdsAroundNode(ArrayView< Int64 > uid, Int64x3 node_coord, Int32 level) override
Méthode permettant de récupérer les uniqueIds des mailles autour d'un noeud.
Definition CartesianMeshNumberingMngInternal.cc:1684
Arcane::CartesianMeshNumberingMngInternal::_face3DNumberingThreeParts
Int64x3 _face3DNumberingThreeParts(Integer level) const
Méthode permettant de récupérer le nombre de faces des trois parties de la numérotation.
Definition CartesianMeshNumberingMngInternal.cc:2403
Arcane::CartesianMeshNumberingMngInternal::parentNodeUniqueIdOfNode
Int64 parentNodeUniqueIdOfNode(Int64 uid, Integer level, bool do_fatal) override
Méthode permettant de récupérer l'uniqueId du parent d'un noeud.
Definition CartesianMeshNumberingMngInternal.cc:2160
Arcane::CartesianMeshNumberingMngInternal::childCellUniqueIdOfCell
Int64 childCellUniqueIdOfCell(Cell cell, Int64x3 child_coord_in_parent) override
Méthode permettant de récupérer l'uniqueId d'une maille enfant d'une maille parent à partir de la pos...
Definition CartesianMeshNumberingMngInternal.cc:2045
Arcane::CartesianMeshNumberingMngInternal::parentFaceUniqueIdOfFace
Int64 parentFaceUniqueIdOfFace(Int64 uid, Integer level, bool do_fatal) override
Méthode permettant de récupérer l'uniqueId du parent d'une face.
Definition CartesianMeshNumberingMngInternal.cc:2241
Arcane::CartesianMeshNumberingMngInternal::globalNbFacesXCartesianView
Int64 globalNbFacesXCartesianView(Integer level) const override
Méthode permettant de récupérer la taille de la vue "grille cartésienne" contenant les faces.
Definition CartesianMeshNumberingMngInternal.cc:426
Arcane::CartesianMeshNumberingMngInternal::globalNbCellsZ
Int64 globalNbCellsZ(Integer level) const override
Méthode permettant de récupérer le nombre de mailles global en Z d'un niveau.
Definition CartesianMeshNumberingMngInternal.cc:363
Arcane::CartesianMeshNumberingMngInternal::nbFaceInLevel
Int64 nbFaceInLevel(Integer level) const override
Méthode permettant de récupérer le nombre de faces total dans un niveau.
Definition CartesianMeshNumberingMngInternal.cc:483
Arcane::CartesianMeshNumberingMngInternal::childNodeUniqueIdOfNode
Int64 childNodeUniqueIdOfNode(Int64 uid, Integer level) override
Méthode permettant de récupérer l'uniqueId d'un noeud enfant d'un noeud parent.
Definition CartesianMeshNumberingMngInternal.cc:2211
Arcane::CartesianMeshNumberingMngInternal::globalNbFacesYCartesianView
Int64 globalNbFacesYCartesianView(Integer level) const override
Méthode permettant de récupérer la taille de la vue "grille cartésienne" contenant les faces.
Definition CartesianMeshNumberingMngInternal.cc:435
Arcane::CartesianMeshNumberingMngInternal::parentCellUniqueIdOfCell
Int64 parentCellUniqueIdOfCell(Int64 uid, Integer level, bool do_fatal) override
Méthode permettant de récupérer l'uniqueId du parent d'une maille.
Definition CartesianMeshNumberingMngInternal.cc:2005
Arcane::CartesianMeshNumberingMngInternal::nbCellInLevel
Int64 nbCellInLevel(Integer level) const override
Méthode permettant de récupérer le nombre de mailles total dans un niveau.
Definition CartesianMeshNumberingMngInternal.cc:453
Arcane::CartesianMeshNumberingMngInternal::nbNodeByCell
Integer nbNodeByCell() override
Méthode permettant de récupérer le nombre de noeuds dans une maille.
Definition CartesianMeshNumberingMngInternal.cc:1358
Arcane::CartesianMeshNumberingMngInternal::cellUniqueIdToCoordZ
Int64 cellUniqueIdToCoordZ(Int64 uid, Integer level) override
Méthode permettant de récupérer la coordonnée en Z d'une maille grâce à son uniqueId.
Definition CartesianMeshNumberingMngInternal.cc:717
Arcane::CartesianMeshNumberingMngInternal::nodeUniqueIdToCoordZ
Int64 nodeUniqueIdToCoordZ(Int64 uid, Integer level) override
Méthode permettant de récupérer la coordonnée en Z d'un noeud grâce à son uniqueId.
Definition CartesianMeshNumberingMngInternal.cc:793
Arcane::CartesianMeshNumberingMngInternal::globalNbNodesX
Int64 globalNbNodesX(Integer level) const override
Méthode permettant de récupérer le nombre de noeuds global en X d'un niveau.
Definition CartesianMeshNumberingMngInternal.cc:372
Arcane::CartesianMeshNumberingMngInternal::childFaceUniqueIdOfFace
Int64 childFaceUniqueIdOfFace(Int64 uid, Integer level, Int64 child_index_in_parent) override
Méthode permettant de récupérer l'uniqueId d'une face enfant d'une face parent à partir de l'index de...
Definition CartesianMeshNumberingMngInternal.cc:2316
Arcane::CartesianMeshNumberingMngInternal::nbFaceByCell
Integer nbFaceByCell() override
Méthode permettant de récupérer le nombre de faces dans une maille.
Definition CartesianMeshNumberingMngInternal.cc:1434
Arcane::CartesianMeshNumberingMngInternal::cellFaceUniqueIds
void cellFaceUniqueIds(ArrayView< Int64 > uid, Integer level, Int64x3 cell_coord) override
Méthode permettant de récupérer les uniqueIds des faces d'une maille à partir de ses coordonnées.
Definition CartesianMeshNumberingMngInternal.cc:1443
Arcane::CartesianMeshNumberingMngInternal::globalNbFacesZCartesianView
Int64 globalNbFacesZCartesianView(Integer level) const override
Méthode permettant de récupérer la taille de la vue "grille cartésienne" contenant les faces.
Definition CartesianMeshNumberingMngInternal.cc:444
Arcane::CartesianMeshNumberingMngInternal::childCellOfCell
Cell childCellOfCell(Cell cell, Int64x3 child_coord_in_parent) override
Méthode permettant de récupérer une maille enfant d'une maille parent à partir de la position de la m...
Definition CartesianMeshNumberingMngInternal.cc:2108
Arcane::CartesianMeshNumberingMngInternal::nodeLevel
Int32 nodeLevel(Int64 uid) const override
Méthode permettant de récupérer le niveau d'un noeud avec son uid.
Definition CartesianMeshNumberingMngInternal.cc:534
Arcane::CartesianMeshNumberingMngInternal::cellUniqueIdsAroundCell
void cellUniqueIdsAroundCell(ArrayView< Int64 > uid, Int64x3 cell_coord, Int32 level) override
Méthode permettant de récupérer les uniqueIds des mailles autour d'une maille.
Definition CartesianMeshNumberingMngInternal.cc:1598
Arcane::CartesianMeshNumberingMngInternal::nodeUniqueIdToCoordY
Int64 nodeUniqueIdToCoordY(Int64 uid, Integer level) override
Méthode permettant de récupérer la coordonnée en Y d'un noeud grâce à son uniqueId.
Definition CartesianMeshNumberingMngInternal.cc:767
Arcane::Cell
Maille d'un maillage.
Definition Item.h:1214
Arcane::Cell::nbHChildren
Int32 nbHChildren() const
Nombre d'enfants pour l'AMR.
Definition Item.h:1333
Arcane::Cell::hChild
Cell hChild(Int32 i) const
i-ème enfant AMR
Definition Item.h:1336
Arcane::Cell::level
Int32 level() const
Definition Item.h:1368
Arcane::ConstArrayView
Vue constante d'un tableau de type T.
Definition arccore/src/base/arccore/base/ArrayView.h:533
Arcane::Face
Face d'une maille.
Definition Item.h:964
Arcane::ITraceMng
Interface du gestionnaire de traces.
Definition arccore/src/trace/arccore/trace/ITraceMng.h:156
Arcane::ITraceMng::info
virtual TraceMessage info()=0
Flot pour un message d'information.
Arcane::ItemBase::flags
Int32 flags() const
Flags de l'entité
Definition ItemInternal.h:484
Arcane::ItemFlags::II_JustAdded
@ II_JustAdded
L'entité vient d'être ajoutée.
Definition ItemFlags.h:61
Arcane::ItemFlags::II_JustRefined
@ II_JustRefined
L'entité vient d'être raffinée.
Definition ItemFlags.h:78
Arcane::ItemWithNodes::node
Node node(Int32 i) const
i-ème noeud de l'entité
Definition Item.h:791
Arcane::Item::uniqueId
ItemUniqueId uniqueId() const
Identifiant unique sur tous les domaines.
Definition Item.h:225
Arcane::Item::itemBase
impl::ItemBase itemBase() const
Partie interne de l'entité.
Definition Item.h:369
Arcane::Node
Noeud d'un maillage.
Definition Item.h:582
Arcane::Real3
Classe gérant un vecteur de réel de dimension 3.
Definition Real3.h:132
Arcane::Trace::Setter
Positionne une classe de message.
Definition arccore/src/trace/arccore/trace/Trace.h:153
Arcane::UniqueArray
Vecteur 1D de données avec sémantique par valeur (style STL).
Definition arccore/src/common/arccore/common/Array.h:888
Arcane::math::max
T max(const T &a, const T &b, const T &c)
Retourne le maximum de trois éléments.
Definition MathUtils.h:392
Arcane::VariableNodeReal3
MeshVariableScalarRefT< Node, Real3 > VariableNodeReal3
Grandeur au noeud de type coordonnées.
Definition VariableTypedef.h:360
Arcane
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Definition arcane/src/arcane/accelerator/AcceleratorGlobal.h:37
Arcane::Int64
std::int64_t Int64
Type entier signé sur 64 bits.
Definition ArccoreGlobal.h:227
Arcane::Integer
Int32 Integer
Type représentant un entier.
Definition ArccoreGlobal.h:281
Arcane::Int64ConstArrayView
ConstArrayView< Int64 > Int64ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 64 bits.
Definition UtilsTypes.h:496
Arcane::MD_DirZ
@ MD_DirZ
Direction Z.
Definition ArcaneTypes.h:424
Arcane::MD_DirY
@ MD_DirY
Direction Y.
Definition ArcaneTypes.h:422
Arcane::MD_DirX
@ MD_DirX
Direction X.
Definition ArcaneTypes.h:420
Arcane::Real
double Real
Type représentant un réel.
Definition ArccoreGlobal.h:264
Arcane::makeRef
auto makeRef(InstanceType *t) -> Ref< InstanceType >
Créé une référence sur un pointeur.
Definition arccore/src/base/arccore/base/Ref.h:356
Arcane::Int32
std::int32_t Int32
Type entier signé sur 32 bits.
Definition ArccoreGlobal.h:225
Arcane::Real3POD::y
Real y
deuxième composante du triplet
Definition Real3.h:36
Arcane::Real3POD::z
Real z
troisième composante du triplet
Definition Real3.h:37
Arcane::Real3POD::x
Real x
première composante du triplet
Definition Real3.h:35