Arcane  v3.16.2.0
Documentation utilisateur
Chargement...
Recherche...
Aucune correspondance
Item.h
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/* Item.h (C) 2000-2025 */
9/* */
10/* Informations sur les éléments du maillage. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_CORE_ITEM_H
13#define ARCANE_CORE_ITEM_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
18#include "arcane/core/ItemInternal.h"
19#include "arcane/core/ItemLocalId.h"
20
21#include <atomic>
22
23/*---------------------------------------------------------------------------*/
24/*---------------------------------------------------------------------------*/
25
26namespace Arcane
27{
28
29/*---------------------------------------------------------------------------*/
30/*---------------------------------------------------------------------------*/
31
32// Macro pour vérifier en mode Check que les conversions entre les
33// les genres d'entités sont correctes.
34#ifdef ARCANE_CHECK
35#define ARCANE_CHECK_KIND(type) _checkKind(type())
36#else
37#define ARCANE_CHECK_KIND(type)
38#endif
39
40#ifdef ARCANE_CHECK
41#define ARCANE_WANT_ITEM_STAT
42#endif
43
44#ifdef ARCANE_WANT_ITEM_STAT
45#define ARCANE_ITEM_ADD_STAT(var) ++var
46#else
47#define ARCANE_ITEM_ADD_STAT(var)
48#endif
49
50/*---------------------------------------------------------------------------*/
51/*---------------------------------------------------------------------------*/
52/*!
53 * \brief Classe de base d'un élément de maillage.
54 *
55 * \ingroup Mesh
56
57 Les éléments du maillage sont les noeuds (Node), les mailles (Cell),
58 les faces (Face), les arêtes (Edge), les particules (Particle) ou les
59 degrés de liberté (DoF). Chacun de ses éléments est décrit
60 dans la classe dérivée correspondante.
61
62 Cette classe et les classes dérivées sont des objets légers qui s'utilisent par
63 valeur plutôt que par référence et qui ne doivent pas être conservés entre deux
64 modifications du la famille (IItemFamily) à laquelle ils sont associés.
65
66 Quel que soit son type un élément du maillage possède un identifiant
67 unique (localId()) pour son type et local au sous-domaine géré et un identifiant
68 unique (uniqueId()) pour son type sur l'ensemble du domaine. La numérotation est
69 <b>continue</b> et commence à <b>0</b>. L'identifiant local est utilisé par
70 exemple pour accéder aux variables ou pour la connectivité.
71
72 Par exemple, si un maillage possède 2 mailles hexaédriques qui se joignent
73 par une face, il y 12 noeuds, 11 faces et 2 mailles. Dans ce cas, le premier
74 noeud aura l'identifiant 0, le second 1 et ainsi de suite jusqu'à 11. La
75 première face aura l'identifiant 0, la seconde 1 et ainsi de suite
76 jusqu'à 10.
77
78 Il existe une entité correspondant à un objet nul. C'est la seule
79 pour laquelle null() est vrai. Aucune opération autre que l'appel à null()
80 et les opérations de comparaisons ne sont valides sur l'entité nulle.
81 */
82class ARCANE_CORE_EXPORT Item
83{
84 // Pour accéder aux constructeurs privés
85 friend class ItemEnumeratorBaseT<Item>;
87 friend class ItemVector;
88 friend class ItemVectorView;
89 friend class ItemVectorViewConstIterator;
90 friend class ItemConnectedListViewConstIterator;
91 friend class SimdItem;
92 friend class SimdItemEnumeratorBase;
93 friend class ItemInfoListView;
94 friend class ItemLocalIdToItemConverter;
95 template<typename ItemType> friend class ItemLocalIdToItemConverterT;
96 friend class ItemPairEnumerator;
97 template<int Extent> friend class ItemConnectedListView;
98 template<typename ItemType> friend class ItemEnumeratorBaseT;
99
100 // Pour accéder à _internal()
101 friend class ItemCompatibility;
102
103 public:
104
105 typedef ItemInternal* ItemInternalPtr;
106
107 //! Type du localId()
109
110 using ItemBase = impl::ItemBase;
111
112 public:
113
114 /*!
115 * \brief Index d'un Item dans une variable.
116 * \deprecated
117 */
118 class Index
119 {
120 // TODO Rendre obsolète lorsqu'on aura supprimer
121 // les classes dérivées qui sont obsolètes.
122 // On ne peut pas le faire avant car cela génère trop
123 // d'avertissements de compilation.
124 public:
125 Index() : m_local_id(NULL_ITEM_LOCAL_ID){}
126 explicit Index(Int32 id) : m_local_id(id){}
127 Index(Item item) : m_local_id(item.localId()){}
128 operator ItemLocalId() const { return ItemLocalId{m_local_id}; }
129 public:
130 Int32 localId() const { return m_local_id; }
131 private:
132 Int32 m_local_id;
133 };
134
135 public:
136
137 /*!
138 * \brief Type des éléments.
139 *
140 * Les valeurs des types doivent aller de 0 à #NB_TYPE par pas de 1.
141 *
142 * \deprecated. Utilise les types définis dans ArcaneTypes.h
143 */
144 enum
145 {
146 Unknown ARCANE_DEPRECATED_REASON("Use 'IT_NullType' instead") = IT_NullType, //!< Elément de type nul
147 Vertex ARCANE_DEPRECATED_REASON("Use 'IT_Vertex' instead") = IT_Vertex, //!< Elément de type noeud (1 sommet 1D, 2D et 3D)
148 Bar2 ARCANE_DEPRECATED_REASON("Use 'IT_Line2' instead") = IT_Line2, //!< Elément de type arête (2 sommets, 1D, 2D et 3D)
149 Tri3 ARCANE_DEPRECATED_REASON("Use 'IT_Triangle3' instead") = IT_Triangle3, //!< Elément de type triangle (3 sommets, 2D)
150 Quad4 ARCANE_DEPRECATED_REASON("Use 'IT_Quad4' instead") = IT_Quad4, //!< Elément de type quad (4 sommets, 2D)
151 Pentagon5 ARCANE_DEPRECATED_REASON("Use 'IT_Pentagon5' instead") = IT_Pentagon5, //!< Elément de type pentagone (5 sommets, 2D)
152 Hexagon6 ARCANE_DEPRECATED_REASON("Use 'IT_Hexagon6' instead") = IT_Hexagon6, //!< Elément de type hexagone (6 sommets, 2D)
153 Tetra ARCANE_DEPRECATED_REASON("Use 'IT_Tetraedron4' instead") = IT_Tetraedron4, //!< Elément de type tétraédre (4 sommets, 3D)
154 Pyramid ARCANE_DEPRECATED_REASON("Use 'IT_Pyramid5' instead") = IT_Pyramid5, //!< Elément de type pyramide (5 sommets, 3D)
155 Penta ARCANE_DEPRECATED_REASON("Use 'IT_Pentaedron6' instead") = IT_Pentaedron6, //!< Elément de type pentaèdre (6 sommets, 3D)
156 Hexa ARCANE_DEPRECATED_REASON("Use 'IT_Hexaedron8' instead") = IT_Hexaedron8, //!< Elément de type hexaèdre (8 sommets, 3D)
157 Wedge7 ARCANE_DEPRECATED_REASON("Use 'IT_Heptaedron10' instead") = IT_Heptaedron10, //!< Elément de type prisme à 7 faces (base pentagonale)
158 Wedge8 ARCANE_DEPRECATED_REASON("Use 'IT_Octaedron12' instead") = IT_Octaedron12 //!< Elément de type prisme à 8 faces (base hexagonale)
159 // Réduit au minimum pour compatibilité.
160 };
161
162 //! Indice d'un élément nul
163 static const Int32 NULL_ELEMENT = NULL_ITEM_ID;
164
165 //! Nom du type de maille \a cell_type
166 ARCCORE_DEPRECATED_2021("Use ItemTypeMng::typeName() instead")
167 static String typeName(Int32 type);
168
169 protected:
170
171 //! Constructeur réservé pour les énumérateurs
172 constexpr ARCCORE_HOST_DEVICE Item(Int32 local_id,ItemSharedInfo* shared_info)
173 : m_shared_info(shared_info), m_local_id(local_id) {}
174
175 public:
176
177 //! Création d'une entité de maillage nulle
178 Item() = default;
180 //! Construit une référence à l'entité \a internal
181 //ARCANE_DEPRECATED_REASON("Remove this overload")
182 Item(ItemInternal* ainternal)
183 {
184 ARCANE_CHECK_PTR(ainternal);
185 m_shared_info = ainternal->m_shared_info;
186 m_local_id = ainternal->m_local_id;
187 ARCANE_ITEM_ADD_STAT(m_nb_created_from_internal);
188 }
189
190 // NOTE: Pour le constructeur suivant; il est indispensable d'utiliser
191 // const& pour éviter une ambiguité avec le constructeur par recopie
192 //! Construit une référence à l'entité \a abase
193 constexpr ARCCORE_HOST_DEVICE Item(const ItemBase& abase)
194 : m_shared_info(abase.m_shared_info)
195 , m_local_id(abase.m_local_id)
196 {
197 }
198
199 //! Construit une référence à l'entité \a internal
200 Item(const ItemInternalPtr* internals,Int32 local_id)
201 : Item(local_id,internals[local_id]->m_shared_info)
202 {
203 ARCANE_ITEM_ADD_STAT(m_nb_created_from_internalptr);
204 }
205
206 //! Opérateur de copie
208 {
209 _set(ainternal);
210 return (*this);
211 }
212
213 public:
214
215 //! \a true si l'entité est nul (i.e. non connecté au maillage)
216 constexpr bool null() const { return m_local_id==NULL_ITEM_ID; }
217
218 //! Identifiant local de l'entité dans le sous-domaine du processeur
219 constexpr Int32 localId() const { return m_local_id; }
220
221 //! Identifiant local de l'entité dans le sous-domaine du processeur
222 constexpr ItemLocalId itemLocalId() const { return ItemLocalId{ m_local_id }; }
223
224 //! Identifiant unique sur tous les domaines
226 {
227#ifdef ARCANE_CHECK
228 if (m_local_id!=NULL_ITEM_LOCAL_ID)
229 arcaneCheckAt((Integer)m_local_id,m_shared_info->m_unique_ids.size());
230#endif
231 // Ne pas utiliser l'accesseur normal car ce tableau peut etre utilise pour la maille
232 // nulle et dans ce cas m_local_id vaut NULL_ITEM_LOCAL_ID (qui est negatif)
233 // ce qui provoque une exception pour debordement de tableau.
234 return ItemUniqueId(m_shared_info->m_unique_ids.data()[m_local_id]);
235 }
236
237 //! Numéro du sous-domaine propriétaire de l'entité
238 Int32 owner() const { return m_shared_info->_ownerV2(m_local_id); }
239
240 //! Type de l'entité
241 Int16 type() const { return m_shared_info->_typeId(m_local_id); }
242
243 //! Type de l'entité
244 ItemTypeId itemTypeId() const { return ItemTypeId(type()); }
245
246 //! Famille dont est issue l'entité
247 IItemFamily* itemFamily() const { return m_shared_info->m_item_family; }
248
249 //! Genre de l'entité
250 eItemKind kind() const { return m_shared_info->m_item_kind; }
251
252 //! \a true si l'entité est appartient au sous-domaine
253 bool isOwn() const { return (_flags() & ItemFlags::II_Own)!=0; }
254
255 /*!
256 * \brief Vrai si l'entité est partagé d'autres sous-domaines.
257 *
258 * Une entité est considérée comme partagée si et seulement si
259 * isOwn() est vrai et elle est fantôme pour un ou plusieurs
260 * autres sous-domaines.
261 *
262 * Cette méthode n'est pertinente que si les informations de connectivité
263 * ont été calculées (par un appel à IItemFamily::computeSynchronizeInfos()).
264 */
265 bool isShared() const { return (_flags() & ItemFlags::II_Shared)!=0; }
266
267 //! Converti l'entité en le genre \a ItemWithNodes.
268 inline ItemWithNodes toItemWithNodes() const;
269 //! Converti l'entité en le genre \a Node.
270 inline Node toNode() const;
271 //! Converti l'entité en le genre \a Cell.
272 inline Cell toCell() const;
273 //! Converti l'entité en le genre \a Edge.
274 inline Edge toEdge() const;
275 //! Converti l'entité en le genre \a Edge.
276 inline Face toFace() const;
277 //! Converti l'entité en le genre \a Particle.
278 inline Particle toParticle() const;
279 //! Converti l'entité en le genre \a DoF.
280 inline DoF toDoF() const;
281
282 //! Nombre de parents pour les sous-maillages
283 Int32 nbParent() const { return _nbParent(); }
284
285 //! i-ème parent pour les sous-maillages
286 Item parent(Int32 i) const { return m_shared_info->_parentV2(m_local_id,i); }
287
288 //! premier parent pour les sous-maillages
289 Item parent() const { return m_shared_info->_parentV2(m_local_id,0); }
290
291 public:
292
293 //! \a true si l'entité est du genre \a ItemWithNodes.
294 bool isItemWithNodes() const
295 {
296 eItemKind ik = kind();
297 return (ik==IK_Unknown || ik==IK_Edge || ik==IK_Face || ik==IK_Cell );
298 }
299
300 //! \a true si l'entité est du genre \a Node.
301 bool isNode() const
302 {
303 eItemKind ik = kind();
304 return (ik==IK_Unknown || ik==IK_Node);
305 }
306 //! \a true si l'entité est du genre \a Cell.
307 bool isCell() const
308 {
309 eItemKind ik = kind();
310 return (ik==IK_Unknown || ik==IK_Cell);
311 }
312 //! \a true si l'entité est du genre \a Edge.
313 bool isEdge() const
314 {
315 eItemKind ik = kind();
316 return (ik==IK_Unknown || ik==IK_Edge);
317 }
318 //! \a true si l'entité est du genre \a Edge.
319 bool isFace() const
320 {
321 eItemKind ik = kind();
322 return (ik==IK_Unknown || ik==IK_Face);
323 }
324 //! \a true is l'entité est du genre \a Particle.
325 bool isParticle() const
326 {
327 eItemKind ik = kind();
328 return (ik==IK_Unknown || ik==IK_Particle);
329 }
330 //! \a true is l'entité est du genre \a DoF
331 bool isDoF() const
332 {
333 eItemKind ik = kind();
334 return (ik==IK_Unknown || ik==IK_DoF);
335 }
336
337 //! Retourne si les flags \a flags sont positionnées pour l'entité
338 bool hasFlags(Int32 flags) const { return (_flags() & flags); }
339
340 //! Flags de l'entité
341 Int32 flags() const { return m_shared_info->_flagsV2(m_local_id); }
342
343 public:
344
345 /*!
346 * \brief Partie interne de l'entité.
347 *
348 * \warning La partie interne de l'entité ne doit être modifiée que
349 * par ceux qui savent ce qu'ils font.
350 * \deprecated Utiliser itemBase() ou mutableItemBase() à la place pour
351 * les cas l'instance retournée n'est pas conservée.
352 */
353 ARCANE_DEPRECATED_REASON("Y2024: This method is internal to Arcane. use itemBase() or mutableItemBase() instead")
355 {
356 if (m_local_id!=NULL_ITEM_LOCAL_ID)
357 return m_shared_info->m_items_internal[m_local_id];
358 return ItemInternal::nullItem();
359 }
360
361 public:
362
363 /*!
364 * \brief Partie interne de l'entité.
365 *
366 * \warning La partie interne de l'entité ne doit être modifiée que
367 * par ceux qui savent ce qu'ils font.
368 */
369 impl::ItemBase itemBase() const
370 {
371 return impl::ItemBase(m_local_id,m_shared_info);
372 }
373
374 /*!
375 * \brief Partie interne modifiable de l'entité.
376 *
377 * \warning La partie interne de l'entité ne doit être modifiée que
378 * par ceux qui savent ce qu'ils font.
379 */
380 impl::MutableItemBase mutableItemBase() const
381 {
382 return impl::MutableItemBase(m_local_id,m_shared_info);
383 }
384
385 /*!
386 * \brief Infos sur le type de l'entité.
387 *
388 * Cette méthode permet d'obtenir les informations concernant
389 * un type donné d'entité , comme par exemple les numérotations locales
390 * de ces faces ou de ses arêtes.
391 */
392 const ItemTypeInfo* typeInfo() const { return m_shared_info->typeInfoFromId(type()); }
393
394 public:
395
396 ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
397 Item* operator->() { return this; }
398
399 ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
400 const Item* operator->() const { return this; }
401
402 private:
403
404 //! Infos partagées entre toutes les entités ayant les mêmes caractéristiques
405 ItemSharedInfo* m_shared_info = ItemSharedInfo::nullItemSharedInfoPointer;
406
407 protected:
408
409 /*!
410 * \brief Numéro local (au sous-domaine) de l'entité.
411 *
412 * Pour des raisons de performance, le numéro local doit être
413 * le premier champs de la classe.
414 */
415 Int32 m_local_id = NULL_ITEM_LOCAL_ID;
416
417 protected:
418
419 void _checkKind(bool is_valid) const
420 {
421 if (!is_valid)
422 _badConversion();
423 }
424 void _badConversion() const;
425 void _set(ItemInternal* ainternal)
426 {
427 _setFromInternal(ainternal);
428 }
429 void _set(const Item& rhs)
430 {
431 _setFromItem(rhs);
432 }
433
434 protected:
435
436 //! Flags de l'entité
437 Int32 _flags() const { return m_shared_info->_flagsV2(m_local_id); }
438 //! Nombre de noeuds de l'entité
439 Integer _nbNode() const { return _connectivity()->_nbNodeV2(m_local_id); }
440 //! Nombre d'arêtes de l'entité ou nombre d'arêtes connectés à l'entités (pour les noeuds)
441 Integer _nbEdge() const { return _connectivity()->_nbEdgeV2(m_local_id); }
442 //! Nombre de faces de l'entité ou nombre de faces connectés à l'entités (pour les noeuds et arêtes)
443 Integer _nbFace() const { return _connectivity()->_nbFaceV2(m_local_id); }
444 //! Nombre de mailles connectées à l'entité (pour les noeuds, arêtes et faces)
445 Integer _nbCell() const { return _connectivity()->_nbCellV2(m_local_id); }
446 //! Nombre de parent pour l'AMR
447 Int32 _nbHParent() const { return _connectivity()->_nbHParentV2(m_local_id); }
448 //! Nombre d' enfants pour l'AMR
449 Int32 _nbHChildren() const { return _connectivity()->_nbHChildrenV2(m_local_id); }
450 //! Nombre de parent pour les sous-maillages
451 Integer _nbParent() const { return m_shared_info->nbParent(); }
452 NodeLocalId _nodeId(Int32 index) const { return NodeLocalId(_connectivity()->_nodeLocalIdV2(m_local_id,index)); }
453 EdgeLocalId _edgeId(Int32 index) const { return EdgeLocalId(_connectivity()->_edgeLocalIdV2(m_local_id,index)); }
454 FaceLocalId _faceId(Int32 index) const { return FaceLocalId(_connectivity()->_faceLocalIdV2(m_local_id,index)); }
455 CellLocalId _cellId(Int32 index) const { return CellLocalId(_connectivity()->_cellLocalIdV2(m_local_id,index)); }
456 Int32 _hParentId(Int32 index) const { return _connectivity()->_hParentLocalIdV2(m_local_id,index); }
457 Int32 _hChildId(Int32 index) const { return _connectivity()->_hChildLocalIdV2(m_local_id,index); }
458 impl::ItemIndexedListView<DynExtent> _nodeList() const { return _connectivity()->nodeList(m_local_id); }
459 impl::ItemIndexedListView<DynExtent> _edgeList() const { return _connectivity()->edgeList(m_local_id); }
460 impl::ItemIndexedListView<DynExtent> _faceList() const { return _connectivity()->faceList(m_local_id); }
461 impl::ItemIndexedListView<DynExtent> _cellList() const { return _connectivity()->cellList(m_local_id); }
462 NodeLocalIdView _nodeIds() const { return _connectivity()->nodeLocalIdsView(m_local_id); }
463 EdgeLocalIdView _edgeIds() const { return _connectivity()->edgeLocalIdsView(m_local_id); }
464 FaceLocalIdView _faceIds() const { return _connectivity()->faceLocalIdsView(m_local_id); }
465 CellLocalIdView _cellIds() const { return _connectivity()->cellLocalIdsView(m_local_id); }
466
467 inline Node _node(Int32 index) const;
468 inline Edge _edge(Int32 index) const;
469 inline Face _face(Int32 index) const;
470 inline Cell _cell(Int32 index) const;
471
472 ItemBase _hParentBase(Int32 index) const { return _connectivity()->hParentBase(m_local_id, index, m_shared_info); }
473 ItemBase _hChildBase(Int32 index) const { return _connectivity()->hChildBase(m_local_id, index, m_shared_info); }
474 ItemBase _toItemBase() const { return ItemBase(m_local_id,m_shared_info); }
475
476 //! Nombre de noeuds de l'entité
477 Int32 _nbLinearNode() const { return itemBase()._nbLinearNode(); }
478
479 private:
480
481 ItemInternalConnectivityList* _connectivity() const
482 {
483 return m_shared_info->m_connectivity;
484 }
485 void _setFromInternal(ItemBase* rhs)
486 {
487 ARCANE_ITEM_ADD_STAT(m_nb_set_from_internal);
488 m_local_id = rhs->m_local_id;
489 m_shared_info = rhs->m_shared_info;
490 }
491 void _setFromItem(const Item& rhs)
492 {
493 m_local_id = rhs.m_local_id;
494 m_shared_info = rhs.m_shared_info;
495 }
496
497 public:
498
499 static void dumpStats(ITraceMng* tm);
500 static void resetStats();
501
502 private:
503
504 static std::atomic<int> m_nb_created_from_internal;
505 static std::atomic<int> m_nb_created_from_internalptr;
506 static std::atomic<int> m_nb_set_from_internal;
507
508 private:
509
510 ItemInternal* _internal() const
511 {
512 if (m_local_id!=NULL_ITEM_LOCAL_ID)
513 return m_shared_info->m_items_internal[m_local_id];
514 return ItemInternal::nullItem();
515 }
516};
517
518/*---------------------------------------------------------------------------*/
519/*---------------------------------------------------------------------------*/
520/*!
521 * \brief Compare deux entités.
522 *
523 * \retval true si elles sont identiques (mêmes localId())
524 * \retval false sinon
525 */
526inline bool
527operator==(const Item& item1,const Item& item2)
528{
529 return item1.localId()==item2.localId();
530}
531
532/*!
533 * \brief Compare deux entités.
534 *
535 * \retval true si elles sont différentes (différents localId())
536 * \retval false sinon
537 */
538inline bool
539operator!=(const Item& item1,const Item& item2)
540{
541 return item1.localId()!=item2.localId();
542}
543
544/*!
545 * \brief Compare deux entités.
546 *
547 * \retval true si elles sont inferieures (sur localId())
548 * \retval false sinon
549 */
550inline bool
551operator<(const Item& item1,const Item& item2)
552{
553 return item1.localId()<item2.localId();
554}
555
556/*---------------------------------------------------------------------------*/
557/*---------------------------------------------------------------------------*/
558
559} // End namespace Arcane
560
561/*---------------------------------------------------------------------------*/
562/*---------------------------------------------------------------------------*/
563
564#include "arcane/ItemVectorView.h"
565#include "arcane/ItemConnectedListView.h"
566
567/*---------------------------------------------------------------------------*/
568/*---------------------------------------------------------------------------*/
569
570namespace Arcane
571{
572
573/*---------------------------------------------------------------------------*/
574/*---------------------------------------------------------------------------*/
575/*!
576 * \brief Noeud d'un maillage.
577 *
578 * \ingroup Mesh
579 */
580class ARCANE_CORE_EXPORT Node
581: public Item
582{
583 using ThatClass = Node;
584 // Pour accéder aux constructeurs privés
585 friend class ItemEnumeratorBaseT<ThatClass>;
586 friend class ItemConnectedEnumeratorBaseT<ThatClass>;
587 friend class ItemVectorT<ThatClass>;
588 friend class ItemVectorViewT<ThatClass>;
589 friend class ItemConnectedListViewT<ThatClass>;
590 friend class ItemVectorViewConstIteratorT<ThatClass>;
591 friend class ItemConnectedListViewConstIteratorT<ThatClass>;
592 friend class SimdItemT<ThatClass>;
593 friend class ItemInfoListViewT<ThatClass>;
594 friend class ItemLocalIdToItemConverterT<ThatClass>;
595
596 public:
597
598 /*!
599 * \brief Index d'un Node dans une variable.
600 * \deprecated
601 */
602 class ARCANE_DEPRECATED_REASON("Y2024: Use NodeLocalId instead") Index
603 : public Item::Index
604 {
605 public:
606 typedef Item::Index Base;
607 public:
608 explicit Index(Int32 id) : Base(id){}
609 Index(Node item) : Base(item){}
610 operator NodeLocalId() const { return NodeLocalId{localId()}; }
611 };
612
613 protected:
614
615 //! Constructeur réservé pour les énumérateurs
616 Node(Int32 local_id,ItemSharedInfo* shared_info)
617 : Item(local_id,shared_info) {}
618
619 public:
620
621 //! Type du localId()
622 typedef NodeLocalId LocalIdType;
623
624 //! Création d'un noeud non connecté au maillage
625 Node() = default;
626
627 //! Construit une référence à l'entité \a internal
628 Node(ItemInternal* ainternal) : Item(ainternal)
629 { ARCANE_CHECK_KIND(isNode); }
630
631 //! Construit une référence à l'entité \a abase
632 Node(const ItemBase& abase) : Item(abase)
633 { ARCANE_CHECK_KIND(isNode); }
634
635 //! Construit une référence à l'entité \a abase
636 explicit Node(const Item& aitem) : Item(aitem)
637 { ARCANE_CHECK_KIND(isNode); }
638
639 //! Construit une référence à l'entité \a internal
640 Node(const ItemInternalPtr* internals,Int32 local_id) : Item(internals,local_id)
641 { ARCANE_CHECK_KIND(isNode); }
642
643 //! Opérateur de copie
645 {
646 _set(ainternal);
647 return (*this);
648 }
649
650 public:
651
652 //! Identifiant local de l'entité dans le sous-domaine du processeur
653 NodeLocalId itemLocalId() const { return NodeLocalId{ m_local_id }; }
654
655 //! Nombre d'arêtes connectées au noeud
656 Int32 nbEdge() const { return _nbEdge(); }
657
658 //! Nombre de faces connectées au noeud
659 Int32 nbFace() const { return _nbFace(); }
660
661 //! Nombre de mailles connectées au noeud
662 Int32 nbCell() const { return _nbCell(); }
663
664 //! i-ème arête du noeud
665 inline Edge edge(Int32 i) const;
666
667 //! i-ème face du noeud
668 inline Face face(Int32 i) const;
669
670 //! i-ème maille du noeud
671 inline Cell cell(Int32 i) const;
672
673 //! i-ème arête du noeud
674 EdgeLocalId edgeId(Int32 i) const { return _edgeId(i); }
675
676 //! i-ème face du noeud
677 FaceLocalId faceId(Int32 i) const { return _faceId(i); }
678
679 //! i-ème maille du noeud
680 CellLocalId cellId(Int32 i) const { return _cellId(i); }
681
682 //! Liste des arêtes du noeud
683 EdgeConnectedListViewType edges() const { return _edgeList(); }
684
685 //! Liste des faces du noeud
686 FaceConnectedListViewType faces() const { return _faceList(); }
687
688 //! Liste des mailles du noeud
689 CellConnectedListViewType cells() const { return _cellList(); }
690
691 //! Liste des arêtes du noeud
692 EdgeLocalIdView edgeIds() const { return _edgeIds(); }
693
694 //! Liste des faces du noeud
695 FaceLocalIdView faceIds() const { return _faceIds(); }
696
697 //! Liste des mailles du noeud
698 CellLocalIdView cellIds() const { return _cellIds(); }
699
700 // AMR
701
702 //! Enumére les mailles connectées au noeud
704 {
705 return _toItemBase()._internalActiveCells2(local_ids);
706 }
707
708 ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
709 Node* operator->() { return this; }
710
711 ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
712 const Node* operator->() const { return this; }
713};
714
715/*---------------------------------------------------------------------------*/
716/*---------------------------------------------------------------------------*/
717
718inline Node Item::
719_node(Int32 index) const
720{
721 return Node(_connectivity()->nodeBase(m_local_id,index));
722}
723
724/*---------------------------------------------------------------------------*/
725/*---------------------------------------------------------------------------*/
726/*!
727 * \brief Elément de maillage s'appuyant sur des noeuds (Edge,Face,Cell).
728 *
729 * \ingroup Mesh
730 */
731class ARCANE_CORE_EXPORT ItemWithNodes
732: public Item
733{
734 using ThatClass = ItemWithNodes;
735 // Pour accéder aux constructeurs privés
736 friend class ItemEnumeratorBaseT<ThatClass>;
737 friend class ItemConnectedEnumeratorBaseT<ThatClass>;
738 friend class ItemVectorT<ThatClass>;
739 friend class ItemVectorViewT<ThatClass>;
740 friend class ItemConnectedListViewT<ThatClass>;
741 friend class ItemVectorViewConstIteratorT<ThatClass>;
742 friend class ItemConnectedListViewConstIteratorT<ThatClass>;
743 friend class SimdItemT<ThatClass>;
744 friend class ItemInfoListViewT<ThatClass>;
745 friend class ItemLocalIdToItemConverterT<ThatClass>;
746
747 protected:
748
749 //! Constructeur réservé pour les énumérateurs
750 ItemWithNodes(Int32 local_id,ItemSharedInfo* shared_info)
751 : Item(local_id,shared_info) {}
752
753 public:
754
755 //! Création d'une entité non connectée au maillage
756 ItemWithNodes() = default;
757
758 //! Construit une référence à l'entité \a internal
759 ItemWithNodes(ItemInternal* ainternal) : Item(ainternal)
760 { ARCANE_CHECK_KIND(isItemWithNodes); }
761
762 //! Construit une référence à l'entité \a abase
763 ItemWithNodes(const ItemBase& abase) : Item(abase)
764 { ARCANE_CHECK_KIND(isItemWithNodes); }
765
766 //! Construit une référence à l'entité \a aitem
767 explicit ItemWithNodes(const Item& aitem) : Item(aitem)
768 { ARCANE_CHECK_KIND(isItemWithNodes); }
769
770 //! Construit une référence à l'entité \a internal
771 ItemWithNodes(const ItemInternalPtr* internals,Int32 local_id)
772 : Item(internals,local_id)
773 { ARCANE_CHECK_KIND(isItemWithNodes); }
774
775 //! Opérateur de copie
777 {
778 _set(ainternal);
779 return (*this);
780 }
781
782 public:
783
784 //! Nombre de noeuds de l'entité
785 Int32 nbNode() const { return _nbNode(); }
786
787 //! i-ème noeud de l'entité
788 Node node(Int32 i) const { return _node(i); }
789
790 //! Liste des noeuds de l'entité
791 NodeConnectedListViewType nodes() const { return _nodeList(); }
792
793 //! Liste des noeuds de l'entité
794 NodeLocalIdView nodeIds() const { return _nodeIds(); }
795
796 //! i-ème noeud de l'entité.
797 NodeLocalId nodeId(Int32 index) const { return _nodeId(index); }
798
799 //! Nombre de noeuds de l'entité linéaire associée (si entité ordre 2 ou plus)
800 Int32 nbLinearNode() const { return _nbLinearNode(); }
801
802 public:
803
804 ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
805 ItemWithNodes* operator->() { return this; }
806
807 ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
808 const ItemWithNodes* operator->() const { return this; }
809};
810
811/*---------------------------------------------------------------------------*/
812/*---------------------------------------------------------------------------*/
813/*!
814 * \brief Arête d'une maille.
815 *
816 * Les arêtes n'existent qu'en 3D. En 2D, il faut utiliser la structure
817 * 'Face'.
818 *
819 * \ingroup Mesh
820 */
821class ARCANE_CORE_EXPORT Edge
822: public ItemWithNodes
823{
824 using ThatClass = Edge;
825 // Pour accéder aux constructeurs privés
826 friend class ItemEnumeratorBaseT<ThatClass>;
827 friend class ItemConnectedEnumeratorBaseT<ThatClass>;
828 friend class ItemVectorT<ThatClass>;
829 friend class ItemVectorViewT<ThatClass>;
830 friend class ItemConnectedListViewT<ThatClass>;
831 friend class ItemVectorViewConstIteratorT<ThatClass>;
832 friend class ItemConnectedListViewConstIteratorT<ThatClass>;
833 friend class SimdItemT<ThatClass>;
834 friend class ItemInfoListViewT<ThatClass>;
835 friend class ItemLocalIdToItemConverterT<ThatClass>;
836
837 public:
838
839 /*!
840 * \brief Index d'une Edge dans une variable.
841 * \deprecated
842 */
843 class ARCANE_DEPRECATED_REASON("Y2024: Use EdgeLocalId instead") Index
844 : public Item::Index
845 {
846 public:
847 typedef Item::Index Base;
848 public:
849 explicit Index(Int32 id) : Base(id){}
850 Index(Edge item) : Base(item){}
851 operator EdgeLocalId() const { return EdgeLocalId{localId()}; }
852 };
853
854 private:
855
856 //! Constructeur réservé pour les énumérateurs
857 Edge(Int32 local_id,ItemSharedInfo* shared_info)
858 : ItemWithNodes(local_id,shared_info) {}
859
860 public:
861
862 //! Type du localId()
863 typedef EdgeLocalId LocalIdType;
864
865 //! Créé une arête nulle
866 Edge() = default;
867
868 //! Construit une référence à l'entité \a internal
869 Edge(ItemInternal* ainternal) : ItemWithNodes(ainternal)
870 { ARCANE_CHECK_KIND(isEdge); }
871
872 //! Construit une référence à l'entité \a abase
873 Edge(const ItemBase& abase) : ItemWithNodes(abase)
874 { ARCANE_CHECK_KIND(isEdge); }
875
876 //! Construit une référence à l'entité \a aitem
877 explicit Edge(const Item& aitem) : ItemWithNodes(aitem)
878 { ARCANE_CHECK_KIND(isEdge); }
879
880 //! Construit une référence à l'entité \a internal
881 Edge(const ItemInternalPtr* internals,Int32 local_id)
882 : ItemWithNodes(internals,local_id)
883 { ARCANE_CHECK_KIND(isEdge); }
884
885 //! Opérateur de copie
886 Edge& operator=(ItemInternal* ainternal)
887 {
888 _set(ainternal);
889 return (*this);
890 }
891
892 public:
893
894 //! Identifiant local de l'entité dans le sous-domaine du processeur
895 EdgeLocalId itemLocalId() const { return EdgeLocalId{ m_local_id }; }
896
897 //! Nombre de sommets de l'arête
898 Int32 nbNode() const { return 2; }
899
900 //! Nombre de faces connectées à l'arête
901 Int32 nbFace() const { return _nbFace(); }
902
903 //! Nombre de mailles connectées à l'arête
904 Int32 nbCell() const { return _nbCell(); }
905
906 //! i-ème maille de l'arête
907 inline Cell cell(Int32 i) const;
908
909 //! Liste des mailles de l'arête
910 CellConnectedListViewType cells() const { return _cellList(); }
911
912 //! i-ème maille de l'arête
913 CellLocalId cellId(Int32 i) const { return _cellId(i); }
914
915 //! Liste des mailles de l'arête
916 CellLocalIdView cellIds() const { return _cellIds(); }
917
918 //! i-ème face de l'arête
919 inline Face face(Int32 i) const;
920
921 //! Liste des faces de l'arête
922 FaceConnectedListViewType faces() const { return _faceList(); }
923
924 //! i-ème face de l'arête
925 FaceLocalId faceId(Int32 i) const { return _faceId(i); }
926
927 //! Liste des faces de l'arête
928 FaceLocalIdView faceIds() const { return _faceIds(); }
929
930 ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
931 Edge* operator->() { return this; }
932
933 ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
934 const Edge* operator->() const { return this; }
935};
936
937/*---------------------------------------------------------------------------*/
938/*---------------------------------------------------------------------------*/
939
940inline Edge Item::
941_edge(Int32 index) const
942{
943 return Edge(_connectivity()->edgeBase(m_local_id,index));
944}
945
946/*---------------------------------------------------------------------------*/
947/*---------------------------------------------------------------------------*/
948/*!
949 * \brief Face d'une maille.
950 *
951 * \ingroup Mesh
952 *
953 Une face est décrite par la liste ordonnée de ses sommets, ce qui lui
954 donne une orientation.
955 */
956class ARCANE_CORE_EXPORT Face
957: public ItemWithNodes
958{
959 using ThatClass = Face;
960 // Pour accéder aux constructeurs privés
961 friend class ItemEnumeratorBaseT<ThatClass>;
962 friend class ItemConnectedEnumeratorBaseT<ThatClass>;
963 friend class ItemVectorT<ThatClass>;
964 friend class ItemVectorViewT<ThatClass>;
965 friend class ItemConnectedListViewT<ThatClass>;
966 friend class ItemVectorViewConstIteratorT<ThatClass>;
967 friend class ItemConnectedListViewConstIteratorT<ThatClass>;
968 friend class SimdItemT<ThatClass>;
969 friend class ItemInfoListViewT<ThatClass>;
970 friend class ItemLocalIdToItemConverterT<ThatClass>;
971
972 public:
973
974 /*!
975 * \brief Index d'une Face dans une variable.
976 * \deprecated
977 */
978 class ARCANE_DEPRECATED_REASON("Y2024: Use FaceLocalId instead") Index
979 : public Item::Index
980 {
981 public:
982 typedef Item::Index Base;
983 public:
984 explicit Index(Int32 id) : Base(id){}
985 Index(Face item) : Base(item){}
986 operator FaceLocalId() const { return FaceLocalId{localId()}; }
987 };
988
989 private:
990
991 //! Constructeur réservé pour les énumérateurs
992 Face(Int32 local_id,ItemSharedInfo* shared_info)
993 : ItemWithNodes(local_id,shared_info) {}
994
995 public:
996
997 //! Type du localId()
998 typedef FaceLocalId LocalIdType;
999
1000 //! Création d'une face non connecté au maillage
1001 Face() = default;
1002
1003 //! Construit une référence à l'entité \a internal
1004 Face(ItemInternal* ainternal) : ItemWithNodes(ainternal)
1005 { ARCANE_CHECK_KIND(isFace); }
1006
1007 //! Construit une référence à l'entité \a abase
1008 Face(const ItemBase& abase) : ItemWithNodes(abase)
1009 { ARCANE_CHECK_KIND(isFace); }
1010
1011 //! Construit une référence à l'entité \a aitem
1012 explicit Face(const Item& aitem) : ItemWithNodes(aitem)
1013 { ARCANE_CHECK_KIND(isFace); }
1014
1015 //! Construit une référence à l'entité \a internal
1016 Face(const ItemInternalPtr* internals,Int32 local_id)
1017 : ItemWithNodes(internals,local_id)
1018 { ARCANE_CHECK_KIND(isFace); }
1019
1020 //! Opérateur de copie
1021 Face& operator=(ItemInternal* ainternal)
1022 {
1023 _set(ainternal);
1024 return (*this);
1025 }
1026
1027 public:
1028
1029 //! Identifiant local de l'entité dans le sous-domaine du processeur
1030 FaceLocalId itemLocalId() const { return FaceLocalId{ m_local_id }; }
1031
1032 //! Nombre de mailles de la face (1 ou 2)
1033 Int32 nbCell() const { return _nbCell(); }
1034
1035 //! i-ème maille de la face
1036 inline Cell cell(Int32 i) const;
1037
1038 //! Liste des mailles de la face
1039 CellConnectedListViewType cells() const { return _cellList(); }
1040
1041 //! i-ème maille de la face
1042 CellLocalId cellId(Int32 i) const { return _cellId(i); }
1043
1044 //! Liste des mailles de la face
1045 CellLocalIdView cellIds() const { return _cellIds(); }
1046
1047 /*!
1048 * \brief Indique si la face est au bord du sous-domaine (i.e nbCell()==1)
1049 *
1050 * \warning Une face au bord du sous-domaine n'est pas nécessairement au bord du maillage global.
1051 */
1052 bool isSubDomainBoundary() const { return (_flags() & ItemFlags::II_Boundary)!=0; }
1053
1054 /*!
1055 * \a true si la face est au bord du sous-domaine.
1056 * \deprecated Utiliser isSubDomainBoundary() à la place.
1057 */
1058 ARCANE_DEPRECATED_118 bool isBoundary() const { return isSubDomainBoundary(); }
1059
1060 //! Indique si la face est au bord t orientée vers l'extérieur.
1062 {
1064 }
1065
1066 /*!
1067 * \brief Indique si la face est au bord t orientée vers l'extérieur.
1068 *
1069 * \deprecated Utiliser isSubDomainBoundaryOutside()
1070 */
1071 ARCANE_DEPRECATED_118 bool isBoundaryOutside() const
1072 {
1074 }
1075
1076 //! Maille associée à cette face frontière (maille nulle si aucune)
1077 inline Cell boundaryCell() const;
1078
1079 //! Maille derrière la face (maille nulle si aucune)
1080 inline Cell backCell() const;
1081
1082 //! Maille derrière la face (maille nulle si aucune)
1083 CellLocalId backCellId() const { return CellLocalId(_toItemBase().backCellId()); }
1084
1085 //! Maille devant la face (maille nulle si aucune)
1086 inline Cell frontCell() const;
1087
1088 //! Maille devant la face (maille nulle si aucune)
1089 CellLocalId frontCellId() const { return CellLocalId(_toItemBase().frontCellId()); }
1090
1091 /*!
1092 * \brief Maille opposée de cette face à la maille \a cell.
1093 *
1094 * \pre backCell()==cell || frontCell()==cell.
1095 */
1096 inline Cell oppositeCell(Cell cell) const;
1097
1098 /*!
1099 * \brief Maille opposée de cette face à la maille \a cell.
1100 *
1101 * \pre backCell()==cell || frontCell()==cell.
1102 */
1103 CellLocalId oppositeCellId(CellLocalId cell_id) const
1104 {
1105 ARCANE_ASSERT((backCellId()==cell_id || frontCellId()==cell_id),("cell is not connected to the face"));
1106 return (backCellId()==cell_id) ? frontCellId() : backCellId();
1107 }
1108
1109 /*!
1110 * \brief Face maître associée à cette face.
1111 *
1112 * Cette face n'est non nul que si la face est liée à une interface
1113 * et est une face esclave de cette interface (i.e. isSlaveFace() est vrai)
1114 *
1115 * \sa ITiedInterface
1116 */
1117 Face masterFace() const { return _toItemBase().masterFace(); }
1118
1119 //! \a true s'il s'agit de la face maître d'une interface
1120 bool isMasterFace() const { return _toItemBase().isMasterFace(); }
1121
1122 //! \a true s'il s'agit d'une face esclave d'une interface
1123 bool isSlaveFace() const { return _toItemBase().isSlaveFace(); }
1124
1125 //! \a true s'il s'agit d'une face esclave ou maître d'une interface
1126 bool isTiedFace() const { return isSlaveFace() || isMasterFace(); }
1127
1128 /*!
1129 * \brief Liste des faces esclaves associées à cette face maître.
1130 *
1131 * Cette liste n'existe que pour les faces dont isMasterFace() est vrai.
1132 * Pour les autres, elle est vide.
1133 */
1135 {
1136 if (_toItemBase().isMasterFace())
1137 return _faceList();
1139 }
1140
1141 public:
1142
1143 //! Nombre d'arêtes de la face
1144 Int32 nbEdge() const { return _nbEdge(); }
1145
1146 //! i-ème arête de la face
1147 Edge edge(Int32 i) const { return _edge(i); }
1148
1149 //! Liste des arêtes de la face
1150 EdgeConnectedListViewType edges() const { return _edgeList(); }
1151
1152 //! i-ème arête de la face
1153 EdgeLocalId edgeId(Int32 i) const { return _edgeId(i); }
1154
1155 //! Liste des arêtes de la face
1156 EdgeLocalIdView edgeIds() const { return _edgeIds(); }
1157
1158 ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
1159 Face* operator->() { return this; }
1160
1161 ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
1162 const Face* operator->() const { return this; }
1163};
1164
1165/*---------------------------------------------------------------------------*/
1166/*---------------------------------------------------------------------------*/
1167
1168inline Face Item::
1169_face(Int32 index) const
1170{
1171 return Face(_connectivity()->faceBase(m_local_id,index));
1172}
1173
1174/*---------------------------------------------------------------------------*/
1175/*---------------------------------------------------------------------------*/
1176/*!
1177 * \brief Maille d'un maillage.
1178 *
1179 * \ingroup Mesh
1180 *
1181 Chaque maille utilise de la mémoire pour stocker sa connectivité. Cela
1182 permet aux modules d'écrire leur boucle de manière identique quelle que
1183 soit le type de la maille. Dans un premier temps, c'est le mécanisme le
1184 plus simple. On peut envisager par la suite d'utiliser des classes template
1185 pour traiter la même information de manière statique (i.e. toute la connectivité
1186 est gérée à la compilation).
1187
1188 La connectivité utilise la numérotation <b>locale</b> des sommets de
1189 la maille. Elle est stockée dans les variables de classe #global_face_list
1190 pour les faces et #global_edge_list pour les arêtes.
1191
1192 La connectivité utilisée est celle qui est décrite dans la notice
1193 LIMA version 3.1 à ceci près que la numérotation commence à zéro et non
1194 pas à un.
1195
1196 LIMA ne décrivant pas la pyramide, la numérotation utilisée est celle
1197 de l'hexaèdre dégénérée en considérant que les sommets 4, 5, 6 et 7
1198 sont le sommet de la pyramide
1199
1200 Dans la version actuelle (1.6), les arêtes ne sont pas prises en compte
1201 de manière globale (i.e: il n'y a pas d'entités Edge par maille).
1202*/
1203class ARCANE_CORE_EXPORT Cell
1204: public ItemWithNodes
1205{
1206 using ThatClass = Cell;
1207 // Pour accéder aux constructeurs privés
1208 friend class ItemEnumeratorBaseT<ThatClass>;
1209 friend class ItemConnectedEnumeratorBaseT<ThatClass>;
1210 friend class ItemVectorT<ThatClass>;
1211 friend class ItemVectorViewT<ThatClass>;
1212 friend class ItemConnectedListViewT<ThatClass>;
1213 friend class ItemVectorViewConstIteratorT<ThatClass>;
1214 friend class ItemConnectedListViewConstIteratorT<ThatClass>;
1215 friend class SimdItemT<ThatClass>;
1216 friend class ItemInfoListViewT<ThatClass>;
1217 friend class ItemLocalIdToItemConverterT<ThatClass>;
1218
1219 public:
1220
1221 /*!
1222 * \brief Index d'une Cell dans une variable.
1223 * \deprecated
1224 */
1225 class ARCANE_DEPRECATED_REASON("Y2024: Use CellLocalId instead") Index
1226 : public Item::Index
1227 {
1228 public:
1229 typedef Item::Index Base;
1230 public:
1231 explicit Index(Int32 id) : Base(id){}
1232 Index(Cell item) : Base(item){}
1233 operator CellLocalId() const { return CellLocalId{localId()}; }
1234 };
1235
1236 private:
1237
1238 //! Constructeur réservé pour les énumérateurs
1239 Cell(Int32 local_id,ItemSharedInfo* shared_info)
1240 : ItemWithNodes(local_id,shared_info) {}
1241
1242 public:
1243
1244 //! Type du localId()
1245 typedef CellLocalId LocalIdType;
1246
1247 //! Constructeur d'une maille nulle
1248 Cell() = default;
1249
1250 //! Construit une référence à l'entité \a internal
1251 Cell(ItemInternal* ainternal) : ItemWithNodes(ainternal)
1252 { ARCANE_CHECK_KIND(isCell); }
1253
1254 //! Construit une référence à l'entité \a abase
1255 Cell(const ItemBase& abase) : ItemWithNodes(abase)
1256 { ARCANE_CHECK_KIND(isCell); }
1257
1258 //! Construit une référence à l'entité \a aitem
1259 explicit Cell(const Item& aitem) : ItemWithNodes(aitem)
1260 { ARCANE_CHECK_KIND(isCell); }
1261
1262 //! Construit une référence à l'entité \a internal
1263 Cell(const ItemInternalPtr* internals,Int32 local_id)
1264 : ItemWithNodes(internals,local_id)
1265 { ARCANE_CHECK_KIND(isCell); }
1266
1267 //! Opérateur de copie
1268 Cell& operator=(ItemInternal* ainternal)
1269 {
1270 _set(ainternal);
1271 return (*this);
1272 }
1273
1274 public:
1275
1276 //! Identifiant local de l'entité dans le sous-domaine du processeur
1277 CellLocalId itemLocalId() const { return CellLocalId{ m_local_id }; }
1278
1279 //! Nombre de faces de la maille
1280 Int32 nbFace() const { return _nbFace(); }
1281
1282 //! i-ème face de la maille
1283 Face face(Int32 i) const { return _face(i); }
1284
1285 //! Liste des faces de la maille
1286 FaceConnectedListViewType faces() const { return _faceList(); }
1287
1288 //! i-ème face de la maille
1289 FaceLocalId faceId(Int32 i) const { return _faceId(i); }
1290
1291 //! Liste des faces de la maille
1292 FaceLocalIdView faceIds() const { return _faceIds(); }
1293
1294 //! Nombre d'arêtes de la maille
1295 Int32 nbEdge() const { return _nbEdge(); }
1296
1297 //! i-ème arête de la maille
1298 Edge edge(Int32 i) const { return _edge(i); }
1299
1300 //! i-ème arête de la maille
1301 EdgeLocalId edgeId(Int32 i) const { return _edgeId(i); }
1302
1303 //! Liste des arêtes de la maille
1304 EdgeConnectedListViewType edges() const { return _edgeList(); }
1305
1306 //! Liste des arêtes de la maille
1307 EdgeLocalIdView edgeIds() const { return _edgeIds(); }
1308
1309 //! AMR
1310 //! ATT: la notion de parent est utilisé à la fois dans le concept sous-maillages et AMR.
1311 //! La première implémentation AMR sépare les deux concepts pour des raisons de consistances.
1312 //! Une fusion des deux notions est envisageable dans un deuxième temps
1313 //! dans un premier temps, les appelations, pour l'amr, sont en français i.e. parent -> pere et child -> enfant
1314 //! un seul parent
1315 Cell hParent() const { return Cell(_hParentBase(0)); }
1316
1317 //! Nombre de parent pour l'AMR
1318 Int32 nbHParent() const { return _nbHParent(); }
1319
1320 //! Nombre d'enfants pour l'AMR
1321 Int32 nbHChildren() const { return _nbHChildren(); }
1322
1323 //! i-ème enfant AMR
1324 Cell hChild(Int32 i) const { return Cell(_hChildBase(i)); }
1325
1326 //! parent de niveau 0 pour l'AMR
1327 Cell topHParent() const { return Cell(_toItemBase().topHParentBase()); }
1328
1329 /*!
1330 * \returns \p true si l'item est actif (i.e. n'a pas de
1331 * descendants actifs), \p false sinon. Notez qu'il suffit de vérifier
1332 * le premier enfant seulement. Renvoie toujours \p true si l'AMR est désactivé.
1333 */
1334 bool isActive() const { return _toItemBase().isActive(); }
1335
1336 bool isSubactive() const { return _toItemBase().isSubactive(); }
1337
1338 /*!
1339 * \returns \p true si l'item est un ancetre (i.e. a un
1340 * enfant actif ou un enfant ancetre), \p false sinon.
1341 * Renvoie toujours \p false si l'AMR est désactivé.
1342 */
1343 bool isAncestor() const { return _toItemBase().isAncestor(); }
1344
1345 /*!
1346 * \returns \p true si l'item a des enfants (actifs ou non),
1347 * \p false sinon. Renvoie toujours \p false si l'AMR est désactivé.
1348 */
1349 bool hasHChildren() const { return _toItemBase().hasHChildren(); }
1350
1351 /*!
1352 * \returns le niveau de raffinement de l'item courant. Si l'item
1353 * parent est \p NULL donc par convention il est au niveau 0,
1354 * sinon il est simplement au niveau superieur que celui de son parent.
1355 */
1356 Int32 level() const
1357 {
1358 //! si je n'ai pas de parent donc j'ai été crée
1359 //! directement à partir d'un fichier ou par l'utilisateur,
1360 //! donc je suis un item de niveau 0
1361 if (this->_nbHParent() == 0)
1362 return 0;
1363 //! sinon je suis au niveau supérieur que celui de mon parent
1364 return (this->_hParentBase(0).level() + 1);
1365 }
1366
1367 /*!
1368 * \returns le rang de l'enfant \p (iitem).
1369 * exemple: si rank = m_internal->whichChildAmI(iitem); donc
1370 * m_internal->hChild(rank) serait iitem;
1371 */
1373 {
1374 return _toItemBase().whichChildAmI(iitem->localId());
1375 }
1376
1377 /*!
1378 * \returns le rang de l'enfant avec \p (iitem).
1379 * exemple: si rank = m_internal->whichChildAmI(iitem); donc
1380 * m_internal->hChild(rank) serait iitem;
1381 */
1382 Int32 whichChildAmI(CellLocalId local_id) const
1383 {
1384 return _toItemBase().whichChildAmI(local_id);
1385 }
1386
1387 ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
1388 Cell* operator->() { return this; }
1389
1390 ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
1391 const Cell* operator->() const { return this; }
1392};
1393
1394/*---------------------------------------------------------------------------*/
1395/*---------------------------------------------------------------------------*/
1396
1397inline Cell Item::
1398_cell(Int32 index) const
1399{
1400 return Cell(_connectivity()->cellBase(m_local_id,index));
1401}
1402
1403/*---------------------------------------------------------------------------*/
1404/*---------------------------------------------------------------------------*/
1405/*!
1406 * \brief Particule.
1407 * \ingroup Mesh
1408 */
1409class Particle
1410: public Item
1411{
1412 using ThatClass = Particle;
1413 // Pour accéder aux constructeurs privés
1414 friend class ItemEnumeratorBaseT<ThatClass>;
1415 friend class ItemConnectedEnumeratorBaseT<ThatClass>;
1416 friend class ItemVectorT<ThatClass>;
1417 friend class ItemVectorViewT<ThatClass>;
1418 friend class ItemConnectedListViewT<ThatClass>;
1419 friend class ItemVectorViewConstIteratorT<ThatClass>;
1420 friend class ItemConnectedListViewConstIteratorT<ThatClass>;
1421 friend class SimdItemT<ThatClass>;
1422 friend class ItemInfoListViewT<ThatClass>;
1423 friend class ItemLocalIdToItemConverterT<ThatClass>;
1424
1425 private:
1426
1427 //! Constructeur réservé pour les énumérateurs
1428 Particle(Int32 local_id,ItemSharedInfo* shared_info)
1429 : Item(local_id,shared_info) {}
1430
1431 public:
1432
1433 //! Type du localId()
1434 typedef ParticleLocalId LocalIdType;
1435
1436 //! Constructeur d'une particule nulle
1437 Particle() = default;
1438
1439 //! Construit une référence à l'entité \a internal
1440 Particle(ItemInternal* ainternal) : Item(ainternal)
1441 { ARCANE_CHECK_KIND(isParticle); }
1442
1443 //! Construit une référence à l'entité \a abase
1444 Particle(const ItemBase& abase) : Item(abase)
1445 { ARCANE_CHECK_KIND(isParticle); }
1446
1447 //! Construit une référence à l'entité \a aitem
1448 explicit Particle(const Item& aitem) : Item(aitem)
1449 { ARCANE_CHECK_KIND(isParticle); }
1450
1451 //! Construit une référence à l'entité \a internal
1452 Particle(const ItemInternalPtr* internals,Int32 local_id)
1453 : Item(internals,local_id)
1454 { ARCANE_CHECK_KIND(isParticle); }
1455
1456 //! Opérateur de copie
1457 Particle& operator=(ItemInternal* ainternal)
1458 {
1459 _set(ainternal);
1460 return (*this);
1461 }
1462
1463 public:
1464
1465 //! Identifiant local de l'entité dans le sous-domaine du processeur
1466 ParticleLocalId itemLocalId() const { return ParticleLocalId{ m_local_id }; }
1467
1468 /*!
1469 * \brief Maille à laquelle appartient la particule.
1470 * Il faut appeler setCell() avant d'appeler cette fonction.
1471 * \precondition hasCell() doit être vrai.
1472 */
1473 Cell cell() const { return _cell(0); }
1474
1475 //! Maille connectée à la particule
1476 CellLocalId cellId() const { return _cellId(0); }
1477
1478 //! Vrai si la particule est dans une maille du maillage
1479 bool hasCell() const { return (_cellId(0).localId()!=NULL_ITEM_LOCAL_ID); }
1480
1481 /*!
1482 * \brief Maille à laquelle appartient la particule ou maille nulle.
1483 * Retourne cell() si la particule est dans une maille ou la
1484 * maille nulle si la particule n'est dans aucune maille.
1485 */
1487 {
1488 Int32 cell_local_id = _cellId(0).localId();
1489 if (cell_local_id==NULL_ITEM_LOCAL_ID)
1490 return Cell();
1491 return _cell(0);
1492 }
1493
1494 ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
1495 Particle* operator->() { return this; }
1496
1497 ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
1498 const Particle* operator->() const { return this; }
1499};
1500
1501/*---------------------------------------------------------------------------*/
1502/*---------------------------------------------------------------------------*/
1503/*!
1504 *
1505 * \brief classe degré de liberté.
1506 *
1507 * \ingroup Mesh
1508 *
1509 * Ce nouvel item DoF introduit une nouvelle gestion de la connectivité, déportée
1510 * dans des propriétés et non plus stockées dans l'ItemSharedInfo afin de pouvoir créer
1511 * de nouvelles connectivités en fonction des besoins de l'utilisateur. Par défaut aucune
1512 * connectivité n'est associée au DoF. Les connectivités nécessaires seront ajoutées par l'utilisateur.
1513 *
1514 */
1515class DoF
1516: public Item
1517{
1518 using ThatClass = DoF;
1519 // Pour accéder aux constructeurs privés
1520 friend class ItemEnumeratorBaseT<ThatClass>;
1521 friend class ItemConnectedEnumeratorBaseT<ThatClass>;
1522 friend class ItemVectorT<ThatClass>;
1523 friend class ItemVectorViewT<ThatClass>;
1524 friend class ItemConnectedListViewT<ThatClass>;
1525 friend class ItemVectorViewConstIteratorT<ThatClass>;
1526 friend class ItemConnectedListViewConstIteratorT<ThatClass>;
1527 friend class SimdItemT<ThatClass>;
1528 friend class ItemInfoListViewT<ThatClass>;
1529 friend class ItemLocalIdToItemConverterT<ThatClass>;
1530
1531 private:
1532
1533 //! Constructeur réservé pour les énumérateurs
1534 DoF(Int32 local_id,ItemSharedInfo* shared_info)
1535 : Item(local_id,shared_info) {}
1536
1537
1538 public:
1539
1540 using LocalIdType = DoFLocalId;
1541
1542 //! Constructeur d'une maille non connectée
1543 DoF() = default;
1544
1545 //! Construit une référence à l'entité \a internal
1546 DoF(ItemInternal* ainternal) : Item(ainternal)
1547 { ARCANE_CHECK_KIND(isDoF); }
1548
1549 //! Construit une référence à l'entité \a abase
1550 DoF(const ItemBase& abase) : Item(abase)
1551 { ARCANE_CHECK_KIND(isDoF); }
1552
1553 //! Construit une référence à l'entité \a abase
1554 explicit DoF(const Item& aitem) : Item(aitem)
1555 { ARCANE_CHECK_KIND(isDoF); }
1556
1557 //! Construit une référence à l'entité \a internal
1558 DoF(const ItemInternalPtr* internals,Int32 local_id)
1559 : Item(internals,local_id)
1560 { ARCANE_CHECK_KIND(isDoF); }
1561
1562 //! Opérateur de copie
1563 DoF& operator=(ItemInternal* ainternal)
1564 {
1565 _set(ainternal);
1566 return (*this);
1567 }
1568
1569 ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
1570 DoF* operator->() { return this; }
1571
1572 ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
1573 const DoF* operator->() const { return this; }
1574
1575 //! Identifiant local de l'entité dans le sous-domaine du processeur
1576 DoFLocalId itemLocalId() const { return DoFLocalId{ m_local_id }; }
1577};
1578
1579/*---------------------------------------------------------------------------*/
1580/*---------------------------------------------------------------------------*/
1581
1582/*---------------------------------------------------------------------------*/
1583/*---------------------------------------------------------------------------*/
1584
1586edge(Int32 i) const
1587{
1588 return _edge(i);
1589}
1590
1592face(Int32 i) const
1593{
1594 return _face(i);
1595}
1596
1598cell(Int32 i) const
1599{
1600 return _cell(i);
1601}
1602
1603/*---------------------------------------------------------------------------*/
1604/*---------------------------------------------------------------------------*/
1605
1607face(Int32 i) const
1608{
1609 return _face(i);
1610}
1611
1613cell(Int32 i) const
1614{
1615 return _cell(i);
1616}
1617
1618/*---------------------------------------------------------------------------*/
1619/*---------------------------------------------------------------------------*/
1620
1622boundaryCell() const
1623{
1624 return Cell(_toItemBase().boundaryCell());
1625}
1626
1628backCell() const
1629{
1630 return Cell(_toItemBase().backCell());
1631}
1632
1634frontCell() const
1635{
1636 return Cell(_toItemBase().frontCell());
1637}
1638
1640oppositeCell(Cell cell) const
1641{
1642 ARCANE_ASSERT((backCell()==cell || frontCell()==cell),("cell is not connected to the face"));
1643 return (backCell()==cell) ? frontCell() : backCell();
1644}
1645
1647cell(Int32 i) const
1648{
1649 return _cell(i);
1650}
1651
1652/*---------------------------------------------------------------------------*/
1653/*---------------------------------------------------------------------------*/
1654
1656toItemWithNodes() const
1657{
1658 ARCANE_CHECK_KIND(isItemWithNodes);
1659 return ItemWithNodes(*this);
1660}
1661
1663toNode() const
1664{
1665 ARCANE_CHECK_KIND(isNode);
1666 return Node(*this);
1667}
1668
1670toEdge() const
1671{
1672 ARCANE_CHECK_KIND(isEdge);
1673 return Edge(*this);
1674}
1675
1677toFace() const
1678{
1679 ARCANE_CHECK_KIND(isFace);
1680 return Face(*this);
1681}
1682
1684toCell() const
1685{
1686 ARCANE_CHECK_KIND(isCell);
1687 return Cell(*this);
1688}
1689
1691toParticle() const
1692{
1693 ARCANE_CHECK_KIND(isParticle);
1694 return Particle(*this);
1695}
1696
1698toDoF() const
1699{
1700 ARCANE_CHECK_KIND(isDoF);
1701 return DoF(*this);
1702}
1703
1704/*---------------------------------------------------------------------------*/
1705/*---------------------------------------------------------------------------*/
1706
1707inline ItemLocalId::
1708ItemLocalId(Item item)
1709: m_local_id(item.localId())
1710{
1711}
1712
1713template<typename ItemType> inline ItemLocalIdT<ItemType>::
1714ItemLocalIdT(ItemType item)
1715: ItemLocalId(item.localId())
1716{
1717}
1718
1719/*---------------------------------------------------------------------------*/
1720/*---------------------------------------------------------------------------*/
1721
1723operator[](ItemLocalId local_id) const
1724{
1725 return Item(local_id.localId(), m_item_shared_info);
1726}
1727
1728/*---------------------------------------------------------------------------*/
1729/*---------------------------------------------------------------------------*/
1730
1732operator[](Int32 local_id) const
1733{
1734 return Item(local_id, m_item_shared_info);
1735}
1736
1737/*---------------------------------------------------------------------------*/
1738/*---------------------------------------------------------------------------*/
1739
1740template<typename ItemType> inline ItemType ItemInfoListViewT<ItemType>::
1741operator[](ItemLocalId local_id) const
1742{
1743 return ItemType(local_id.localId(), m_item_shared_info);
1744}
1745
1746/*---------------------------------------------------------------------------*/
1747/*---------------------------------------------------------------------------*/
1748
1749template<typename ItemType> inline ItemType ItemInfoListViewT<ItemType>::
1750operator[](Int32 local_id) const
1751{
1752 return ItemType(local_id, m_item_shared_info);
1753}
1754
1755/*---------------------------------------------------------------------------*/
1756/*---------------------------------------------------------------------------*/
1757
1758inline constexpr ARCCORE_HOST_DEVICE Item ItemLocalIdToItemConverter::
1759operator[](ItemLocalId local_id) const
1760{
1761 return Item(local_id.localId(), m_item_shared_info);
1762}
1763
1764/*---------------------------------------------------------------------------*/
1765/*---------------------------------------------------------------------------*/
1766
1767inline constexpr ARCCORE_HOST_DEVICE Item ItemLocalIdToItemConverter::
1768operator[](Int32 local_id) const
1769{
1770 return Item(local_id, m_item_shared_info);
1771}
1772
1773/*---------------------------------------------------------------------------*/
1774/*---------------------------------------------------------------------------*/
1775
1776template<typename ItemType_> inline constexpr ARCCORE_HOST_DEVICE ItemType_
1778operator[](ItemLocalIdType local_id) const
1779{
1780 return ItemType(local_id.localId(), m_item_shared_info);
1781}
1782
1783/*---------------------------------------------------------------------------*/
1784/*---------------------------------------------------------------------------*/
1785
1786template<typename ItemType_> inline constexpr ARCCORE_HOST_DEVICE ItemType_
1788operator[](Int32 local_id) const
1789{
1790 return ItemType(local_id, m_item_shared_info);
1791}
1792
1793/*---------------------------------------------------------------------------*/
1794/*---------------------------------------------------------------------------*/
1795
1796} // End namespace Arcane
1797
1798/*---------------------------------------------------------------------------*/
1799/*---------------------------------------------------------------------------*/
1800
1801#include "arcane/ItemCompatibility.h"
1802
1803/*---------------------------------------------------------------------------*/
1804/*---------------------------------------------------------------------------*/
1805
1806#endif
Déclarations de types sur les entités.
Maille d'un maillage.
Definition Item.h:1205
Cell topHParent() const
parent de niveau 0 pour l'AMR
Definition Item.h:1327
Int32 nbEdge() const
Nombre d'arêtes de la maille.
Definition Item.h:1295
Cell(const Item &aitem)
Construit une référence à l'entité aitem.
Definition Item.h:1259
FaceConnectedListViewType faces() const
Liste des faces de la maille.
Definition Item.h:1286
Int32 nbHChildren() const
Nombre d'enfants pour l'AMR.
Definition Item.h:1321
bool isAncestor() const
Definition Item.h:1343
Face face(Int32 i) const
i-ème face de la maille
Definition Item.h:1283
FaceLocalIdView faceIds() const
Liste des faces de la maille.
Definition Item.h:1292
Cell(ItemInternal *ainternal)
Construit une référence à l'entité internal.
Definition Item.h:1251
Int32 nbFace() const
Nombre de faces de la maille.
Definition Item.h:1280
Cell & operator=(ItemInternal *ainternal)
Opérateur de copie.
Definition Item.h:1268
Cell(const ItemInternalPtr *internals, Int32 local_id)
Construit une référence à l'entité internal.
Definition Item.h:1263
CellLocalId itemLocalId() const
Identifiant local de l'entité dans le sous-domaine du processeur.
Definition Item.h:1277
EdgeLocalIdView edgeIds() const
Liste des arêtes de la maille.
Definition Item.h:1307
EdgeLocalId edgeId(Int32 i) const
i-ème arête de la maille
Definition Item.h:1301
Int32 whichChildAmI(const ItemInternal *iitem) const
Definition Item.h:1372
Cell hChild(Int32 i) const
i-ème enfant AMR
Definition Item.h:1324
bool hasHChildren() const
Definition Item.h:1349
Cell(const ItemBase &abase)
Construit une référence à l'entité abase.
Definition Item.h:1255
Edge edge(Int32 i) const
i-ème arête de la maille
Definition Item.h:1298
Cell()=default
Constructeur d'une maille nulle.
Int32 whichChildAmI(CellLocalId local_id) const
Definition Item.h:1382
FaceLocalId faceId(Int32 i) const
i-ème face de la maille
Definition Item.h:1289
bool isActive() const
Definition Item.h:1334
Int32 level() const
Definition Item.h:1356
Cell hParent() const
Definition Item.h:1315
EdgeConnectedListViewType edges() const
Liste des arêtes de la maille.
Definition Item.h:1304
Int32 nbHParent() const
Nombre de parent pour l'AMR.
Definition Item.h:1318
CellLocalId LocalIdType
Type du localId()
Definition Item.h:1245
classe degré de liberté.
Definition Item.h:1517
DoF(const ItemInternalPtr *internals, Int32 local_id)
Construit une référence à l'entité internal.
Definition Item.h:1558
DoF()=default
Constructeur d'une maille non connectée.
DoF(const ItemBase &abase)
Construit une référence à l'entité abase.
Definition Item.h:1550
DoF(const Item &aitem)
Construit une référence à l'entité abase.
Definition Item.h:1554
DoFLocalId itemLocalId() const
Identifiant local de l'entité dans le sous-domaine du processeur.
Definition Item.h:1576
DoF & operator=(ItemInternal *ainternal)
Opérateur de copie.
Definition Item.h:1563
DoF(ItemInternal *ainternal)
Construit une référence à l'entité internal.
Definition Item.h:1546
Arête d'une maille.
Definition Item.h:823
FaceConnectedListViewType faces() const
Liste des faces de l'arête.
Definition Item.h:922
CellConnectedListViewType cells() const
Liste des mailles de l'arête.
Definition Item.h:910
Cell cell(Int32 i) const
i-ème maille de l'arête
Definition Item.h:1613
Edge(const ItemBase &abase)
Construit une référence à l'entité abase.
Definition Item.h:873
Face face(Int32 i) const
i-ème face de l'arête
Definition Item.h:1607
Edge(const ItemInternalPtr *internals, Int32 local_id)
Construit une référence à l'entité internal.
Definition Item.h:881
FaceLocalIdView faceIds() const
Liste des faces de l'arête.
Definition Item.h:928
Edge & operator=(ItemInternal *ainternal)
Opérateur de copie.
Definition Item.h:886
Int32 nbFace() const
Nombre de faces connectées à l'arête.
Definition Item.h:901
CellLocalIdView cellIds() const
Liste des mailles de l'arête.
Definition Item.h:916
Edge(const Item &aitem)
Construit une référence à l'entité aitem.
Definition Item.h:877
Edge()=default
Créé une arête nulle.
FaceLocalId faceId(Int32 i) const
i-ème face de l'arête
Definition Item.h:925
Edge(ItemInternal *ainternal)
Construit une référence à l'entité internal.
Definition Item.h:869
EdgeLocalId LocalIdType
Type du localId()
Definition Item.h:863
Int32 nbNode() const
Nombre de sommets de l'arête.
Definition Item.h:898
CellLocalId cellId(Int32 i) const
i-ème maille de l'arête
Definition Item.h:913
Int32 nbCell() const
Nombre de mailles connectées à l'arête.
Definition Item.h:904
EdgeLocalId itemLocalId() const
Identifiant local de l'entité dans le sous-domaine du processeur.
Definition Item.h:895
Face d'une maille.
Definition Item.h:958
Face()=default
Création d'une face non connecté au maillage.
bool isMasterFace() const
true s'il s'agit de la face maître d'une interface
Definition Item.h:1120
FaceLocalId LocalIdType
Type du localId()
Definition Item.h:998
CellLocalId frontCellId() const
Maille devant la face (maille nulle si aucune)
Definition Item.h:1089
Face(const ItemBase &abase)
Construit une référence à l'entité abase.
Definition Item.h:1008
Cell frontCell() const
Maille devant la face (maille nulle si aucune)
Definition Item.h:1634
CellLocalId cellId(Int32 i) const
i-ème maille de la face
Definition Item.h:1042
EdgeLocalIdView edgeIds() const
Liste des arêtes de la face.
Definition Item.h:1156
Cell cell(Int32 i) const
i-ème maille de la face
Definition Item.h:1647
Int32 nbCell() const
Nombre de mailles de la face (1 ou 2)
Definition Item.h:1033
ARCANE_DEPRECATED_118 bool isBoundary() const
Definition Item.h:1058
FaceConnectedListViewType slaveFaces() const
Liste des faces esclaves associées à cette face maître.
Definition Item.h:1134
ARCANE_DEPRECATED_118 bool isBoundaryOutside() const
Indique si la face est au bord t orientée vers l'extérieur.
Definition Item.h:1071
EdgeConnectedListViewType edges() const
Liste des arêtes de la face.
Definition Item.h:1150
bool isSubDomainBoundary() const
Indique si la face est au bord du sous-domaine (i.e nbCell()==1)
Definition Item.h:1052
Face(const Item &aitem)
Construit une référence à l'entité aitem.
Definition Item.h:1012
FaceLocalId itemLocalId() const
Identifiant local de l'entité dans le sous-domaine du processeur.
Definition Item.h:1030
EdgeLocalId edgeId(Int32 i) const
i-ème arête de la face
Definition Item.h:1153
CellConnectedListViewType cells() const
Liste des mailles de la face.
Definition Item.h:1039
Face masterFace() const
Face maître associée à cette face.
Definition Item.h:1117
bool isSlaveFace() const
true s'il s'agit d'une face esclave d'une interface
Definition Item.h:1123
Edge edge(Int32 i) const
i-ème arête de la face
Definition Item.h:1147
CellLocalId backCellId() const
Maille derrière la face (maille nulle si aucune)
Definition Item.h:1083
Face(const ItemInternalPtr *internals, Int32 local_id)
Construit une référence à l'entité internal.
Definition Item.h:1016
bool isSubDomainBoundaryOutside() const
Indique si la face est au bord t orientée vers l'extérieur.
Definition Item.h:1061
Face(ItemInternal *ainternal)
Construit une référence à l'entité internal.
Definition Item.h:1004
Cell boundaryCell() const
Maille associée à cette face frontière (maille nulle si aucune)
Definition Item.h:1622
Int32 nbEdge() const
Nombre d'arêtes de la face.
Definition Item.h:1144
bool isTiedFace() const
true s'il s'agit d'une face esclave ou maître d'une interface
Definition Item.h:1126
CellLocalIdView cellIds() const
Liste des mailles de la face.
Definition Item.h:1045
Face & operator=(ItemInternal *ainternal)
Opérateur de copie.
Definition Item.h:1021
Cell backCell() const
Maille derrière la face (maille nulle si aucune)
Definition Item.h:1628
Cell oppositeCell(Cell cell) const
Maille opposée de cette face à la maille cell.
Definition Item.h:1640
CellLocalId oppositeCellId(CellLocalId cell_id) const
Maille opposée de cette face à la maille cell.
Definition Item.h:1103
Interface d'une famille d'entités.
Definition IItemFamily.h:84
Classe de base pour les entités du maillage.
Int32 localId() const
Numéro local (au sous-domaine) de l'entité
Classe de base typeé des énumérateurs sur une liste d'entité connectées.
Vue sur une liste d'entités connectées à une autre.
Classe de base des énumérateurs sur une liste d'entité.
@ II_Shared
L'entité est partagée par un autre sous-domaine.
Definition ItemFlags.h:58
@ II_HasBackCell
L'entité a une maille derrière.
Definition ItemFlags.h:52
@ II_Own
L'entité est une entité propre au sous-domaine.
Definition ItemFlags.h:55
@ II_Boundary
L'entité est sur la frontière.
Definition ItemFlags.h:50
Classe de base des vues spécialisées des informations sur les entités.
ItemType operator[](ItemLocalId local_id) const
Entité associée du numéro local local_id.
Definition Item.h:1741
Item operator[](ItemLocalId local_id) const
Entité associée du numéro local local_id.
Definition Item.h:1723
Classe pour convertir un ItemLocalId vers une entité (Item).
constexpr __host__ __device__ ItemType operator[](ItemLocalIdType local_id) const
Entité de numéro local local_id.
Definition Item.h:1778
constexpr __host__ __device__ Item operator[](ItemLocalId local_id) const
Entité de numéro local local_id.
Definition Item.h:1759
Index d'un Item dans une variable.
Definition ItemLocalId.h:41
Type d'une entité (Item).
Definition ItemTypeId.h:32
Infos sur un type d'entité du maillage.
Identifiant unique d'une entité.
Vecteur typé d'entité.
Definition ItemVector.h:166
Vue sur un tableau typé d'entités.
Elément de maillage s'appuyant sur des noeuds (Edge,Face,Cell).
Definition Item.h:733
ItemWithNodes(const ItemInternalPtr *internals, Int32 local_id)
Construit une référence à l'entité internal.
Definition Item.h:771
NodeLocalId nodeId(Int32 index) const
i-ème noeud de l'entité.
Definition Item.h:797
ItemWithNodes(const ItemBase &abase)
Construit une référence à l'entité abase.
Definition Item.h:763
Node node(Int32 i) const
i-ème noeud de l'entité
Definition Item.h:788
ItemWithNodes(Int32 local_id, ItemSharedInfo *shared_info)
Constructeur réservé pour les énumérateurs.
Definition Item.h:750
ItemWithNodes(const Item &aitem)
Construit une référence à l'entité aitem.
Definition Item.h:767
Int32 nbLinearNode() const
Nombre de noeuds de l'entité linéaire associée (si entité ordre 2 ou plus)
Definition Item.h:800
NodeConnectedListViewType nodes() const
Liste des noeuds de l'entité
Definition Item.h:791
ItemWithNodes(ItemInternal *ainternal)
Construit une référence à l'entité internal.
Definition Item.h:759
ItemWithNodes()=default
Création d'une entité non connectée au maillage.
Int32 nbNode() const
Nombre de noeuds de l'entité
Definition Item.h:785
NodeLocalIdView nodeIds() const
Liste des noeuds de l'entité
Definition Item.h:794
ItemWithNodes & operator=(ItemInternal *ainternal)
Opérateur de copie.
Definition Item.h:776
Index d'un Item dans une variable.
Definition Item.h:119
Classe de base d'un élément de maillage.
Definition Item.h:83
Int32 nbParent() const
Nombre de parents pour les sous-maillages.
Definition Item.h:283
const ItemTypeInfo * typeInfo() const
Infos sur le type de l'entité.
Definition Item.h:392
impl::MutableItemBase mutableItemBase() const
Partie interne modifiable de l'entité.
Definition Item.h:380
Int32 _nbHParent() const
Nombre de parent pour l'AMR.
Definition Item.h:447
static const Int32 NULL_ELEMENT
Indice d'un élément nul.
Definition Item.h:163
bool isItemWithNodes() const
true si l'entité est du genre ItemWithNodes.
Definition Item.h:294
Item(ItemInternal *ainternal)
Construit une référence à l'entité internal.
Definition Item.h:182
Integer _nbEdge() const
Nombre d'arêtes de l'entité ou nombre d'arêtes connectés à l'entités (pour les noeuds)
Definition Item.h:441
Integer _nbNode() const
Nombre de noeuds de l'entité
Definition Item.h:439
ItemInternal * internal() const
Partie interne de l'entité.
Definition Item.h:354
constexpr Int32 localId() const
Identifiant local de l'entité dans le sous-domaine du processeur.
Definition Item.h:219
Edge toEdge() const
Converti l'entité en le genre Edge.
Definition Item.h:1670
Item(const ItemInternalPtr *internals, Int32 local_id)
Construit une référence à l'entité internal.
Definition Item.h:200
Item()=default
Création d'une entité de maillage nulle.
bool isOwn() const
true si l'entité est appartient au sous-domaine
Definition Item.h:253
static String typeName(Int32 type)
Nom du type de maille cell_type.
Definition Item.cc:51
bool isCell() const
true si l'entité est du genre Cell.
Definition Item.h:307
Int32 owner() const
Numéro du sous-domaine propriétaire de l'entité
Definition Item.h:238
ItemLocalId LocalIdType
Type du localId()
Definition Item.h:108
Integer _nbFace() const
Nombre de faces de l'entité ou nombre de faces connectés à l'entités (pour les noeuds et arêtes)
Definition Item.h:443
ItemWithNodes toItemWithNodes() const
Converti l'entité en le genre ItemWithNodes.
Definition Item.h:1656
DoF toDoF() const
Converti l'entité en le genre DoF.
Definition Item.h:1698
Cell toCell() const
Converti l'entité en le genre Cell.
Definition Item.h:1684
eItemKind kind() const
Genre de l'entité
Definition Item.h:250
@ Tri3
Elément de type triangle (3 sommets, 2D)
Definition Item.h:149
@ Quad4
Elément de type quad (4 sommets, 2D)
Definition Item.h:150
@ Pentagon5
Elément de type pentagone (5 sommets, 2D)
Definition Item.h:151
@ Unknown
Elément de type nul.
Definition Item.h:146
@ Pyramid
Elément de type pyramide (5 sommets, 3D)
Definition Item.h:154
@ Bar2
Elément de type arête (2 sommets, 1D, 2D et 3D)
Definition Item.h:148
@ Vertex
Elément de type noeud (1 sommet 1D, 2D et 3D)
Definition Item.h:147
@ Hexa
Elément de type hexaèdre (8 sommets, 3D)
Definition Item.h:156
@ Hexagon6
Elément de type hexagone (6 sommets, 2D)
Definition Item.h:152
@ Penta
Elément de type pentaèdre (6 sommets, 3D)
Definition Item.h:155
@ Wedge8
Elément de type prisme à 8 faces (base hexagonale)
Definition Item.h:158
@ Wedge7
Elément de type prisme à 7 faces (base pentagonale)
Definition Item.h:157
@ Tetra
Elément de type tétraédre (4 sommets, 3D)
Definition Item.h:153
IItemFamily * itemFamily() const
Famille dont est issue l'entité
Definition Item.h:247
Int32 flags() const
Flags de l'entité
Definition Item.h:341
Particle toParticle() const
Converti l'entité en le genre Particle.
Definition Item.h:1691
constexpr __host__ __device__ Item(const ItemBase &abase)
Construit une référence à l'entité abase.
Definition Item.h:193
ItemUniqueId uniqueId() const
Identifiant unique sur tous les domaines.
Definition Item.h:225
constexpr __host__ __device__ Item(Int32 local_id, ItemSharedInfo *shared_info)
Constructeur réservé pour les énumérateurs.
Definition Item.h:172
constexpr bool null() const
true si l'entité est nul (i.e. non connecté au maillage)
Definition Item.h:216
Int32 _flags() const
Flags de l'entité
Definition Item.h:437
constexpr ItemLocalId itemLocalId() const
Identifiant local de l'entité dans le sous-domaine du processeur.
Definition Item.h:222
bool isFace() const
true si l'entité est du genre Edge.
Definition Item.h:319
Face toFace() const
Converti l'entité en le genre Edge.
Definition Item.h:1677
bool isNode() const
true si l'entité est du genre Node.
Definition Item.h:301
Integer _nbParent() const
Nombre de parent pour les sous-maillages.
Definition Item.h:451
Integer _nbCell() const
Nombre de mailles connectées à l'entité (pour les noeuds, arêtes et faces)
Definition Item.h:445
bool isEdge() const
true si l'entité est du genre Edge.
Definition Item.h:313
Item parent(Int32 i) const
i-ème parent pour les sous-maillages
Definition Item.h:286
ItemTypeId itemTypeId() const
Type de l'entité
Definition Item.h:244
Item parent() const
premier parent pour les sous-maillages
Definition Item.h:289
bool isDoF() const
true is l'entité est du genre DoF
Definition Item.h:331
Int32 m_local_id
Numéro local (au sous-domaine) de l'entité.
Definition Item.h:415
impl::ItemBase itemBase() const
Partie interne de l'entité.
Definition Item.h:369
bool hasFlags(Int32 flags) const
Retourne si les flags flags sont positionnées pour l'entité
Definition Item.h:338
bool isShared() const
Vrai si l'entité est partagé d'autres sous-domaines.
Definition Item.h:265
bool isParticle() const
true is l'entité est du genre Particle.
Definition Item.h:325
Int32 _nbHChildren() const
Nombre d' enfants pour l'AMR.
Definition Item.h:449
Int16 type() const
Type de l'entité
Definition Item.h:241
Int32 _nbLinearNode() const
Nombre de noeuds de l'entité
Definition Item.h:477
Item & operator=(ItemInternal *ainternal)
Opérateur de copie.
Definition Item.h:207
Node toNode() const
Converti l'entité en le genre Node.
Definition Item.h:1663
Noeud d'un maillage.
Definition Item.h:582
Cell cell(Int32 i) const
i-ème maille du noeud
Definition Item.h:1598
FaceLocalIdView faceIds() const
Liste des faces du noeud.
Definition Item.h:695
Node(const ItemInternalPtr *internals, Int32 local_id)
Construit une référence à l'entité internal.
Definition Item.h:640
CellConnectedListViewType cells() const
Liste des mailles du noeud.
Definition Item.h:689
CellVectorView _internalActiveCells(Int32Array &local_ids) const
Enumére les mailles connectées au noeud.
Definition Item.h:703
Node(ItemInternal *ainternal)
Construit une référence à l'entité internal.
Definition Item.h:628
EdgeLocalIdView edgeIds() const
Liste des arêtes du noeud.
Definition Item.h:692
Node(Int32 local_id, ItemSharedInfo *shared_info)
Constructeur réservé pour les énumérateurs.
Definition Item.h:616
NodeLocalId itemLocalId() const
Identifiant local de l'entité dans le sous-domaine du processeur.
Definition Item.h:653
Node(const Item &aitem)
Construit une référence à l'entité abase.
Definition Item.h:636
FaceLocalId faceId(Int32 i) const
i-ème face du noeud
Definition Item.h:677
FaceConnectedListViewType faces() const
Liste des faces du noeud.
Definition Item.h:686
Node & operator=(ItemInternal *ainternal)
Opérateur de copie.
Definition Item.h:644
Face face(Int32 i) const
i-ème face du noeud
Definition Item.h:1592
Int32 nbEdge() const
Nombre d'arêtes connectées au noeud.
Definition Item.h:656
Node(const ItemBase &abase)
Construit une référence à l'entité abase.
Definition Item.h:632
CellLocalIdView cellIds() const
Liste des mailles du noeud.
Definition Item.h:698
Edge edge(Int32 i) const
i-ème arête du noeud
Definition Item.h:1586
Int32 nbFace() const
Nombre de faces connectées au noeud.
Definition Item.h:659
Int32 nbCell() const
Nombre de mailles connectées au noeud.
Definition Item.h:662
EdgeConnectedListViewType edges() const
Liste des arêtes du noeud.
Definition Item.h:683
CellLocalId cellId(Int32 i) const
i-ème maille du noeud
Definition Item.h:680
EdgeLocalId edgeId(Int32 i) const
i-ème arête du noeud
Definition Item.h:674
NodeLocalId LocalIdType
Type du localId()
Definition Item.h:622
Particule.
Definition Item.h:1411
Particle(const ItemBase &abase)
Construit une référence à l'entité abase.
Definition Item.h:1444
Particle()=default
Constructeur d'une particule nulle.
bool hasCell() const
Vrai si la particule est dans une maille du maillage.
Definition Item.h:1479
ParticleLocalId itemLocalId() const
Identifiant local de l'entité dans le sous-domaine du processeur.
Definition Item.h:1466
Cell cell() const
Maille à laquelle appartient la particule. Il faut appeler setCell() avant d'appeler cette fonction....
Definition Item.h:1473
CellLocalId cellId() const
Maille connectée à la particule.
Definition Item.h:1476
Particle(const ItemInternalPtr *internals, Int32 local_id)
Construit une référence à l'entité internal.
Definition Item.h:1452
Cell cellOrNull() const
Maille à laquelle appartient la particule ou maille nulle. Retourne cell() si la particule est dans u...
Definition Item.h:1486
Particle & operator=(ItemInternal *ainternal)
Opérateur de copie.
Definition Item.h:1457
ParticleLocalId LocalIdType
Type du localId()
Definition Item.h:1434
Particle(const Item &aitem)
Construit une référence à l'entité aitem.
Definition Item.h:1448
Particle(ItemInternal *ainternal)
Construit une référence à l'entité internal.
Definition Item.h:1440
Gère un vecteur d'entité ItemType.
Definition SimdItem.h:236
Chaîne de caractères unicode.
ItemLocalIdListViewT< Node > NodeLocalIdView
Vue sur les localId() d'une liste de noeuds.
Definition ItemTypes.h:407
ItemVectorViewT< Cell > CellVectorView
Vue sur un vecteur de mailles.
Definition ItemTypes.h:304
ItemLocalIdListViewT< Edge > EdgeLocalIdView
Vue sur les localId() d'une liste d'arêtes.
Definition ItemTypes.h:417
ItemLocalIdListViewT< Face > FaceLocalIdView
Vue sur les localId() d'une liste de faces.
Definition ItemTypes.h:427
ItemLocalIdListViewT< Cell > CellLocalIdView
Vue sur les localId() d'une liste de mailles.
Definition ItemTypes.h:437
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
NodeConnectedListView NodeConnectedListViewType
Liste de noeuds connectés.
Definition ItemTypes.h:349
Int32 Integer
Type représentant un entier.
CellConnectedListView CellConnectedListViewType
Liste de mailles connectées.
Definition ItemTypes.h:355
bool operator<(const Item &item1, const Item &item2)
Compare deux entités.
Definition Item.h:551
eItemKind
Genre d'entité de maillage.
@ IK_Particle
Entité de maillage de genre particule.
@ IK_Node
Entité de maillage de genre noeud.
@ IK_Cell
Entité de maillage de genre maille.
@ IK_Unknown
Entité de maillage de genre inconnu ou non initialisé
@ IK_Face
Entité de maillage de genre face.
@ IK_DoF
Entité de maillage de genre degre de liberte.
@ IK_Edge
Entité de maillage de genre arête.
std::int16_t Int16
Type entier signé sur 16 bits.
Array< Int32 > Int32Array
Tableau dynamique à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:214
EdgeConnectedListView EdgeConnectedListViewType
Liste d'arêtes connectées.
Definition ItemTypes.h:351
FaceConnectedListView FaceConnectedListViewType
Liste de faces connectées.
Definition ItemTypes.h:353
@ Cell
Le maillage est AMR par maille.
Definition MeshKind.h:52
std::int32_t Int32
Type entier signé sur 32 bits.