Arcane  v3.16.2.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
ItemGroup.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/* ItemGroup.h (C) 2000-2025 */
9/* */
10/* Groupes d'entités du maillage. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_ITEMGROUP_H
13#define ARCANE_ITEMGROUP_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17#include "arcane/utils/AutoRef.h"
18#include "arcane/utils/Iterator.h"
19
20#include "arcane/core/ItemGroupImpl.h"
23
24/*---------------------------------------------------------------------------*/
25/*---------------------------------------------------------------------------*/
26
27namespace Arcane
28{
29
30/*---------------------------------------------------------------------------*/
31/*---------------------------------------------------------------------------*/
32
33class ItemVectorView;
35
36/*---------------------------------------------------------------------------*/
37/*---------------------------------------------------------------------------*/
38//NOTE: la documentation plus complète est dans ItemGroup.cc
48class ARCANE_CORE_EXPORT ItemGroup
49{
50 public:
51
53 ItemGroup();
55 // TODO: ce contructeur devrait être explicite pour éviter des conversions
56 // implicites mais on le met pas encore pour des raisons de compatibilité
57 /*explicit*/ ItemGroup(ItemGroupImpl* prv);
59 ItemGroup(const ItemGroup& from) : m_impl(from.m_impl) {}
60
62 ItemGroup& operator=(const ItemGroup& from) = default;
63
66
67 public:
68
70 inline bool null() const
71 {
72 return m_impl->null();
73 }
74
76 inline const String& name() const
77 {
78 return m_impl->name();
79 }
80
82 inline const String& fullName() const
83 {
84 return m_impl->fullName();
85 }
86
88 inline Integer size() const
89 {
90 m_impl->_checkNeedUpdateNoPadding();
91 return m_impl->size();
92 }
93
102 inline bool empty() const
103 {
104 m_impl->_checkNeedUpdateNoPadding();
105 return m_impl->empty();
106 }
107
109 inline eItemKind itemKind() const { return m_impl->itemKind(); }
110
111 public:
112
120 ItemGroupImpl* internal() const { return m_impl.get(); }
121
123 IItemFamily* itemFamily() const { return m_impl->itemFamily(); }
124
126 IMesh* mesh() const { return m_impl->mesh(); }
127
128 public:
129
130 // Items in the group owned by the subdomain
131 ItemGroup own() const;
132
133 // Items in the group not owned by the subdomain
134 ItemGroup ghost() const;
135
137 bool isOwn() const;
138
140 void setOwn(bool v);
141
142 // Items in the group lying on the boundary between two subdomains
143 // Implemented for faces only
144 ItemGroup interface() const;
145
147 NodeGroup nodeGroup() const;
148
150 EdgeGroup edgeGroup() const;
151
153 FaceGroup faceGroup() const;
154
156 CellGroup cellGroup() const;
157
164 FaceGroup innerFaceGroup() const;
165
172 FaceGroup outerFaceGroup() const;
173
176 CellGroup activeCellGroup() const;
177
179 CellGroup ownActiveCellGroup() const;
180
182 CellGroup levelCellGroup(const Integer& level) const;
183
185 CellGroup ownLevelCellGroup(const Integer& level) const;
186
192 FaceGroup activeFaceGroup() const;
193
199 FaceGroup ownActiveFaceGroup() const;
200
207 FaceGroup innerActiveFaceGroup() const;
208
215 FaceGroup outerActiveFaceGroup() const;
216
218
219 ItemGroup createSubGroup(const String& suffix, IItemFamily* family, ItemGroupComputeFunctor* functor) const;
220
222 ItemGroup findSubGroup(const String& suffix) const;
223
226 {
227 return m_impl->isLocalToSubDomain();
228 }
229
239 {
240 m_impl->setLocalToSubDomain(v);
241 }
242
252 void invalidate(bool force_recompute=false) { m_impl->invalidate(force_recompute); }
253
255 void addItems(Int32ConstArrayView items_local_id,bool check_if_present=true);
256
258 void removeItems(Int32ConstArrayView items_local_id,bool check_if_present=true);
259
261 void setItems(Int32ConstArrayView items_local_id);
262
268 void setItems(Int32ConstArrayView items_local_id,bool do_sort);
269
271 void checkValid();
272
274 void clear();
275
277 void applyOperation(IItemOperationByBasicType* operation) const;
278
280 ItemVectorView view() const;
281
283 bool isAllItems() const;
284
293 {
294 return m_impl->timestamp();
295 }
296
304 void incrementTimestamp() const;
305
308 {
309 return m_impl->localIdToIndex();
310 }
311
313 IVariableSynchronizer* synchronizer() const;
314
316 bool isAutoComputed() const;
317
319 bool hasSynchronizer() const;
320
322 bool checkIsSorted() const;
323
325 ItemVectorView _paddedView() const;
326
333 ItemVectorView _unpaddedView() const;
334
335 public:
336
338 ItemGroupImplInternal* _internalApi() const;
339
340 public:
341
343 ItemEnumerator enumerator() const;
344
345 private:
346
347 template <typename T>
350 ItemEnumerator _simdEnumerator() const;
351
352 protected:
353
356
357 protected:
358
361 {
362 return impl->itemKind()==ik ? impl : ItemGroupImpl::checkSharedNull();
363 }
364
365 ItemVectorView _view(bool do_padding) const;
366};
367
368/*---------------------------------------------------------------------------*/
369/*---------------------------------------------------------------------------*/
375inline bool
376operator==(const ItemGroup& g1,const ItemGroup& g2)
377{
378 return g1.internal()==g2.internal();
379}
380
388inline bool
389operator<(const ItemGroup& g1,const ItemGroup& g2)
390{
391 return g1.internal()<g2.internal();
392}
393
399inline bool
400operator!=(const ItemGroup& g1,const ItemGroup& g2)
401{
402 return g1.internal()!=g2.internal();
403}
404
405/*---------------------------------------------------------------------------*/
406/*---------------------------------------------------------------------------*/
410template<typename T>
411class ItemGroupT
412: public ItemGroup
413{
414 public:
415
417 typedef ItemGroupT<T> ThatClass;
420
421 typedef typename TraitsType::ItemType ItemType;
422
423 typedef const ItemType* const_iterator;
424 typedef ItemType* iterator;
425 typedef ItemType value_type;
426 typedef const ItemType& const_reference;
427
428 public:
429
430 inline ItemGroupT() = default;
431 inline explicit ItemGroupT(ItemGroupImpl* from)
432 : ItemGroup(_check(from,TraitsType::kind())){}
433 inline ItemGroupT(const ItemGroup& from)
434 : ItemGroup(_check(from.internal(),TraitsType::kind())) {}
435 inline ItemGroupT(const ItemGroupT<T>& from)
436 : ItemGroup(from) {}
437 inline const ItemGroupT<T>& operator=(const ItemGroupT<T>& from)
438 { m_impl = from.internal(); return (*this); }
439 inline const ItemGroupT<T>& operator=(const ItemGroup& from)
440 { _assign(from); return (*this); }
441
442 public:
443
444 ThatClass own() const
445 {
446 return ThatClass(ItemGroup::own());
447 }
448
449 ItemEnumeratorT<T> enumerator() const
450 {
451 return ItemEnumeratorT<T>::fromItemEnumerator(ItemGroup::enumerator());
452 }
453
454 protected:
455
456 void _assign(const ItemGroup& from)
457 {
458 m_impl = _check(from.internal(),TraitsType::kind());
459 }
460};
461
462/*---------------------------------------------------------------------------*/
463/*---------------------------------------------------------------------------*/
464
465} // End namespace Arcane
466
467/*---------------------------------------------------------------------------*/
468/*---------------------------------------------------------------------------*/
469
470#endif
Types et macros pour itérer sur les entités du maillage.
Déclarations de types sur les entités.
Encapsulation d'un pointeur avec compteur de référence.
Definition AutoRef.h:41
Interface d'une famille d'entités.
Definition IItemFamily.h:84
Interface d'un opérateur sur des entités rangées par type.
Interface d'un service de synchronisation de variable.
Enumérateur sur une liste d'entités.
Fonctor pour le calcul des éléments d'un groupe.
API interne à Arcane de ItemGroupImpl.
Implémentation d'un groupe d'entités de maillage.
eItemKind itemKind() const
Genre du groupe. Il s'agit du genre de ses éléments.
Référence à un groupe d'un genre donné.
Definition ItemGroup.h:413
ItemTraitsT< T > TraitsType
Type de la classe contenant les caractéristiques de l'entité
Definition ItemGroup.h:419
ItemGroupT< T > ThatClass
Type de cette classe.
Definition ItemGroup.h:417
Groupe d'entités de maillage.
Definition ItemGroup.h:49
ItemEnumerator enumerator() const
Enumérateur sur les entités du groupe.
Definition ItemGroup.cc:543
bool empty() const
Teste si le groupe est vide.
Definition ItemGroup.h:102
void setLocalToSubDomain(bool v)
Positionne le booléen indiquant si le groupe est local au sous-domaine.
Definition ItemGroup.h:238
ItemGroupImpl * internal() const
Retourne l'implémentation du groupe.
Definition ItemGroup.h:120
static ItemGroupImpl * _check(ItemGroupImpl *impl, eItemKind ik)
Retourne le groupe impl s'il est du genre kt, le groupe nul sinon.
Definition ItemGroup.h:360
const String & name() const
Nom du groupe.
Definition ItemGroup.h:76
bool isLocalToSubDomain() const
Vrai si le groupe est local au sous-domaine.
Definition ItemGroup.h:225
void invalidate(bool force_recompute=false)
Invalide le groupe.
Definition ItemGroup.h:252
Int64 timestamp() const
Definition ItemGroup.h:292
ItemGroup & operator=(const ItemGroup &from)=default
Affecte à cette instance une référence au groupe from.
const String & fullName() const
Nom du groupe.
Definition ItemGroup.h:82
SharedPtrT< GroupIndexTable > localIdToIndex() const
Table des local ids vers une position pour toutes les entités du groupe.
Definition ItemGroup.h:307
Integer size() const
Nombre d'éléments du groupe.
Definition ItemGroup.h:88
IItemFamily * itemFamily() const
Famille d'entité à laquelle appartient ce groupe (0 pour le group nul)
Definition ItemGroup.h:123
ItemGroup(const ItemGroup &from)
Construit une référence au groupe from.
Definition ItemGroup.h:59
AutoRefT< ItemGroupImpl > m_impl
Représentation interne du groupe.
Definition ItemGroup.h:355
eItemKind itemKind() const
Genre du groupe. Il s'agit du genre de ses éléments.
Definition ItemGroup.h:109
bool null() const
true is le groupe est le groupe nul
Definition ItemGroup.h:70
ItemEnumerator const_iter
Type de l'intervalle d'itération (à supprimer)
Definition ItemGroup.h:65
ItemGroup()
Construit un groupe nul.
Definition ItemGroup.cc:149
IMesh * mesh() const
Maillage auquel appartient ce groupe (0 pour le group nul)
Definition ItemGroup.h:126
ItemGroup own() const
Groupe équivalent à celui-ci mais contenant uniquement les éléments propres au sous-domaine.
Definition ItemGroup.cc:190
Caractéristiques des éléments du maillage.
Definition ItemTypes.h:621
static eItemKind kind()
Genre de l'entité
Definition ItemTypes.h:624
Vue sur un vecteur d'entités.
Chaîne de caractères unicode.
ItemGroupT< Cell > CellGroup
Groupe de mailles.
Definition ItemTypes.h:183
ItemGroupT< Face > FaceGroup
Groupe de faces.
Definition ItemTypes.h:178
ItemGroupT< Edge > EdgeGroup
Groupe d'arêtes.
Definition ItemTypes.h:173
ItemGroupT< Node > NodeGroup
Groupe de noeuds.
Definition ItemTypes.h:167
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
std::int64_t Int64
Type entier signé sur 64 bits.
Int32 Integer
Type représentant un entier.
ConstArrayView< Int32 > Int32ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:569
bool operator<(const Item &item1, const Item &item2)
Compare deux entités.
Definition Item.h:545
eItemKind
Genre d'entité de maillage.