Arcane  v3.16.0.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
ItemConnectivity.h
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2023 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/* ItemConnectivity.h (C) 2000-2023 */
9/* */
10/* External connectivities. First version with DoF */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_MESH_ITEMCONNECTIVITY_H
13#define ARCANE_MESH_ITEMCONNECTIVITY_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17#include "arcane/utils/FatalErrorException.h"
18#include "arcane/utils/ITraceMng.h"
19
20#include "arcane/IItemFamily.h"
21#include "arcane/ItemVector.h"
22#include "arcane/VariableTypes.h"
23#include "arcane/ItemInternal.h"
24#include "arcane/IItemConnectivity.h"
25#include "arcane/ConnectivityItemVector.h"
26
27#include "arcane/mesh/DoFFamily.h"
28#include "arcane/mesh/ItemProperty.h"
29
30/*---------------------------------------------------------------------------*/
31/*---------------------------------------------------------------------------*/
32
33namespace Arcane
34{
35
36/*---------------------------------------------------------------------------*/
37/*---------------------------------------------------------------------------*/
44class ARCANE_MESH_EXPORT AbstractConnectivity
45: public IItemConnectivity
46{
47 public:
48 AbstractConnectivity(IItemFamily* source_family, IItemFamily* target_family, const String& connectivity_name)
49 : m_source_family(source_family)
50 , m_target_family(target_family)
51 , m_name(connectivity_name)
52 {
53 m_families.add(m_source_family);
54 m_families.add(m_target_family);
55 }
56
57 public:
58
59 virtual const String& name() const
60 {
61 return m_name;
62 }
63
64 public:
65
66 virtual ConstArrayView<IItemFamily*> families() const { return m_families.constView();}
67 virtual IItemFamily* sourceFamily() const { return m_source_family;}
68 virtual IItemFamily* targetFamily() const { return m_target_family;}
69 virtual void _initializeStorage(ConnectivityItemVector*)
70 {
71 // Pour l'instant ne fait rien. A terme, cela pourra servir par exemple
72 // pour dimensionner au nombre max d'entités connectées afin de ne pas
73 // faire de réallocations lors de la récupération des entités via _connectedItems().
74 }
75
76 protected:
77
78 ConstArrayView<IItemFamily*> _families() const { return m_families.constView();}
79 IItemFamily* _sourceFamily() const { return m_source_family;}
80 IItemFamily* _targetFamily() const { return m_target_family;}
81
82 private:
83
84 IItemFamily* m_source_family;
85 IItemFamily* m_target_family;
86 SharedArray<IItemFamily*> m_families;
87 String m_name;
88};
89
90/*---------------------------------------------------------------------------*/
91/*---------------------------------------------------------------------------*/
95class ARCANE_MESH_EXPORT ItemConnectivity
96: public AbstractConnectivity
97{
98public:
99 typedef ItemScalarProperty<Int32> ItemPropertyType;
100
101 public:
102 ItemConnectivity(IItemFamily* source_family, IItemFamily* target_family,const String& aname)
103 : AbstractConnectivity(source_family,target_family,aname)
104 {
105 compute();
106 }
107
108 ItemConnectivity(IItemFamily* source_family, IItemFamily* target_family,const ItemPropertyType& item_property, const String& aname)
109 : AbstractConnectivity(source_family,target_family,aname) // IFPEN : voir le paramètre own de GE...
110 {
111 m_item_property.copy(item_property);
112 }
113
114 public:
115
117 {
118 ARCANE_ASSERT((con_items.accessor()==this),("Bad connectivity"));
119 return con_items.setItem(m_item_property[item]);
120 }
121
122 virtual ConnectivityItemVectorCatalyst _connectedItems(ItemLocalId item) const
123 {
124 auto set = [this](ConnectivityItemVector& civ)mutable{civ = ConnectivityItemVector((ItemConnectivity*)this);};
125 auto apply = [this,item](ConnectivityItemVector& civ){this->_connectedItems(item,civ);};
126 return {set,apply};
127 }
128
129 virtual void updateConnectivity(Int32ConstArrayView from_items, Int32ConstArrayView to_items);
130
131 public:
132
133 const Item operator() (ItemLocalId item) const
134 {
135 /*
136 ARCANE_ASSERT((m_item_property[item] != NULL_ITEM_LOCAL_ID),
137 ("Item must be connected to one item in ItemConnectivity."));
138 //TODO: conserver ItemInternalList pour des raisons de performance.
139 return Item(_targetFamily()->itemsInternal()[m_item_property[item]]);
140 */
141 // Needed for IFPEN applicative test: eventually returns a null item (reasonable for perf ?)
142 if (m_item_property[item] != NULL_ITEM_LOCAL_ID)
143 return _targetFamily()->itemInfoListView()[m_item_property[item]];
144 return Item();
145 }
146
147 ItemScalarProperty<Int32>& itemProperty() {return m_item_property;}
148
149 void updateItemProperty(const ItemScalarProperty<Int32>& item_property) {m_item_property.copy(item_property);}
150
152 {
153 ARCANE_UNUSED(lid);
154 return 1;
155 }
156
157 virtual Int32 connectedItemLocalId(ItemLocalId lid,[[maybe_unused]] Integer index) const
158 {
159 ARCANE_ASSERT((index==0),("Invalid value for index"))
160 return m_item_property[lid];
161 }
162
165 {
166 m_item_property.updateSupport(new_to_old_ids);
167 }
168
170 virtual void notifyTargetFamilyLocalIdChanged(Int32ConstArrayView old_to_new_ids);
171
172 private:
173
174 ItemScalarProperty<Int32> m_item_property;
175 SharedArray<ItemInternal*> m_item_internals;
176
177 private:
178
179 void compute();
180};
181
182/*---------------------------------------------------------------------------*/
183/*---------------------------------------------------------------------------*/
184
185template <class FromItemType, class ToItemType>
186class ItemConnectivityT
187: public ItemConnectivity
188{
189 public:
190
191 typedef typename FromItemType::LocalIdType FromLocalIdType;
192
193 public:
194
195 ItemConnectivityT(IItemFamily* source_family, IItemFamily* target_family,const String& connectivity_name)
196 : ItemConnectivity(source_family,target_family,connectivity_name){}
197
198 ItemConnectivityT(IItemFamily* source_family, IItemFamily* target_family,const ItemPropertyType& item_property,const String& connectivity_name)
199 : ItemConnectivity(source_family,target_family,item_property, connectivity_name){}
200
201 public:
202
203 const ToItemType operator()(FromLocalIdType item) const
204 {
205 return ItemConnectivity::operator ()(item).itemBase();
206 }
207};
208
209/*---------------------------------------------------------------------------*/
210/*---------------------------------------------------------------------------*/
211
212class ARCANE_MESH_EXPORT ItemArrayConnectivity
213: public AbstractConnectivity
214{
215public:
216 typedef ItemArrayProperty<Int32> ItemPropertyType;
217
218 public:
219 ItemArrayConnectivity(IItemFamily* source_family, IItemFamily* target_family,Integer nb_dof_per_item, const String& name)
220 : AbstractConnectivity(source_family,target_family,name)
221 , m_nb_dof_per_item(nb_dof_per_item)
222 {
223 compute();
224 }
225
226 ItemArrayConnectivity(IItemFamily* source_family, IItemFamily* target_family,const ItemPropertyType& item_property, const String& name)
227 : AbstractConnectivity(source_family,target_family,name)
228 , m_nb_dof_per_item(item_property.dim2Size())
229 {
230 m_item_property.copy(item_property);
231 }
232
233 public:
234
236 {
237 return this->operator()(item,con_items);
238 }
239
240 virtual ConnectivityItemVectorCatalyst _connectedItems(ItemLocalId item) const
241 {
242 return this->operator ()(item);
243 }
244
245 virtual void updateConnectivity(Int32ConstArrayView from_items, Int32ConstArrayView to_items);
246
247 public:
248
249 ItemArrayProperty<Int32>& itemProperty() { return m_item_property; }
250
251 void updateItemProperty(const ItemArrayProperty<Int32>& item_property) {m_item_property.copy(item_property);}
252
253 ItemVectorView operator() (ItemLocalId item,ConnectivityItemVector& con_items) const
254 {
255 ARCANE_ASSERT((con_items.accessor()==this),("Bad connectivity"));
256 return con_items.resizeAndCopy(m_item_property[item]);
257 }
258
259 ConnectivityItemVectorCatalyst operator()(ItemLocalId item) const
260 {
261 auto set = [this](ConnectivityItemVector& civ)mutable{civ = ConnectivityItemVector((ItemConnectivity*)this);};
262 auto apply = [this,item](ConnectivityItemVector& civ){this->operator ()(item,civ);};
263 return {set,apply};
264 }
265
267 {
268 ARCANE_UNUSED(lid);
269 return m_nb_dof_per_item;
270 }
271
273 {
274 return m_item_property[lid][index];
275 }
276
279 {
280 m_item_property.updateSupport(new_to_old_ids);
281 }
282
284 virtual void notifyTargetFamilyLocalIdChanged(Int32ConstArrayView old_to_new_ids);
285
286 private:
287
288 Integer m_nb_dof_per_item;
289 ItemArrayProperty<Int32> m_item_property;
290
291 private:
292
293 void compute();
294};
295
296/*---------------------------------------------------------------------------*/
297/*---------------------------------------------------------------------------*/
298
299template<class FromItemType,class ToItemType>
300class ItemArrayConnectivityT
301: public ItemArrayConnectivity
302{
303 public:
304
305 typedef typename FromItemType::LocalIdType FromLocalIdType;
306
307 public:
308
309 ItemArrayConnectivityT(IItemFamily* source_family, IItemFamily* target_family,Integer nb_dof_per_item, const String& connectivity_name)
310 : ItemArrayConnectivity(source_family,target_family,nb_dof_per_item,connectivity_name){}
311
312 ItemArrayConnectivityT(IItemFamily* source_family, IItemFamily* target_family,const ItemPropertyType& item_property, const String& connectivity_name)
313 : ItemArrayConnectivity(source_family,target_family,item_property,connectivity_name){}
314
315 ItemVectorView operator() (FromLocalIdType item,ConnectivityItemVector& con_items) const
316 {
317 return ItemArrayConnectivity::operator()(item,con_items);
318 }
319
320 ConnectivityItemVectorCatalyst operator() (FromLocalIdType item) const
321 {
322 return ItemArrayConnectivity::operator()(item);
323 }
324};
325
326/*---------------------------------------------------------------------------*/
327/*---------------------------------------------------------------------------*/
328
329class ARCANE_MESH_EXPORT ItemMultiArrayConnectivity
330: public AbstractConnectivity
331{
332public:
333 typedef ItemMultiArrayProperty<Int32> ItemPropertyType;
334
335 public:
336 ItemMultiArrayConnectivity(IItemFamily* source_family, IItemFamily* target_family,IntegerConstArrayView nb_dof_per_item, const String& name)
337 : AbstractConnectivity(source_family,target_family,name)
338 {
339 compute(nb_dof_per_item);
340 }
341
342 ItemMultiArrayConnectivity(IItemFamily* source_family, IItemFamily* target_family,const ItemPropertyType& item_property, const String& name)
343 : AbstractConnectivity(source_family,target_family,name)
344 {
345 m_item_property.copy(item_property);
346 }
347
348 public:
349
351 {
352 return this->operator()(item,con_items);
353 }
354
355 virtual ConnectivityItemVectorCatalyst _connectedItems(ItemLocalId item) const
356 {
357 return this->operator ()(item);
358 }
359
360 virtual void updateConnectivity(Int32ConstArrayView from_items, Int32ConstArrayView to_items);
361
362 public:
363
364 ItemMultiArrayProperty<Int32>& itemProperty() {return m_item_property;}
365
366 void updateItemProperty(ItemMultiArrayProperty<Int32>& item_property) {m_item_property.copy(item_property);}
367
368 ItemVectorView operator() (ItemLocalId item,ConnectivityItemVector& con_items) const
369 {
370 ARCANE_ASSERT((con_items.accessor()==this),("Bad connectivity"));
371 return con_items.resizeAndCopy(m_item_property[item]);
372 }
373
374 ConnectivityItemVectorCatalyst operator()(ItemLocalId item) const
375 {
376 auto set = [this](ConnectivityItemVector& civ)mutable{civ = ConnectivityItemVector((ItemConnectivity*)this);};
377 auto apply = [this,item](ConnectivityItemVector& civ){this->operator ()(item,civ);};
378 return {set,apply};
379 }
380
381
383 {
384 return m_item_property[lid].size();
385 }
386
388 {
389 return m_item_property[lid][index];
390 }
391
394 {
395 m_item_property.updateSupport(new_to_old_ids);
396 }
397
399 virtual void notifyTargetFamilyLocalIdChanged(Int32ConstArrayView old_to_new_ids);
400
401 private:
402
403 ItemMultiArrayProperty<Int32> m_item_property;
404
405 private:
406
407 void compute(IntegerConstArrayView nb_dof_per_item);
408};
409
410/*---------------------------------------------------------------------------*/
411/*---------------------------------------------------------------------------*/
412
413template<class FromItemType,class ToItemType>
414class ItemMultiArrayConnectivityT
415: public ItemMultiArrayConnectivity
416{
417 public:
418
419 typedef typename FromItemType::LocalIdType FromLocalIdType;
420
421 public:
422
423 ItemMultiArrayConnectivityT(IItemFamily* source_family, IItemFamily* target_family,const IntegerConstArrayView nb_dof_per_item, const String& connectivity_name)
424 : ItemMultiArrayConnectivity(source_family,target_family,nb_dof_per_item,connectivity_name){}
425
426 ItemMultiArrayConnectivityT(IItemFamily* source_family, IItemFamily* target_family,const ItemPropertyType& item_property, const String& connectivity_name)
427 : ItemMultiArrayConnectivity(source_family,target_family,item_property,connectivity_name){}
428
429 public:
430
431 ItemVectorViewT<ToItemType> operator() (FromLocalIdType item,ConnectivityItemVector& con_items) const
432 {
433 return ItemMultiArrayConnectivity::operator() (item,con_items);
434 }
435
436 ConnectivityItemVectorCatalyst operator()(ItemLocalId item) const
437 {
438 return ItemMultiArrayConnectivity::operator() (item);
439 }
440};
441
442/*---------------------------------------------------------------------------*/
443/*---------------------------------------------------------------------------*/
444
445}
446
447/*---------------------------------------------------------------------------*/
448/*---------------------------------------------------------------------------*/
449
450#endif /* CONNECTIVITY_H_ */
virtual ConstArrayView< IItemFamily * > families() const
Liste des familles (sourceFamily() + targetFamily())
virtual void _initializeStorage(ConnectivityItemVector *)
Implémente l'initialisation de civ pour cette connectivitée.
virtual IItemFamily * sourceFamily() const
Famille source.
virtual const String & name() const
Nom de la connectivité
virtual IItemFamily * targetFamily() const
Famille cible.
Gère la récupération des informations de connectivité.
ItemVectorView setItem(Int32 id)
Positionne la liste de connectivité avec l'entité de localId() id.
IItemConnectivityAccessor * accessor() const
Connectivité associée.
Vue constante d'un tableau de type T.
Interface pour gérer une connectivité.
Interface d'une famille d'entités.
Definition IItemFamily.h:84
virtual void notifySourceFamilyLocalIdChanged(Int32ConstArrayView new_to_old_ids)
Notifie la connectivité que la famille source est compactée.
virtual Int32 connectedItemLocalId(ItemLocalId lid, Integer index) const
localId() de la index-ième entitée connectées à l'entité source de numéro local lid
virtual Integer nbConnectedItem(ItemLocalId lid) const
Nombre d'entité connectées à l'entité source de numéro local lid.
virtual ItemVectorView _connectedItems(ItemLocalId item, ConnectivityItemVector &con_items) const
Remplit con_items avec les entités connectées à item.
Connectivite item->item, exactement 1 item connecté par item (0 non admis).
virtual void notifySourceFamilyLocalIdChanged(Int32ConstArrayView new_to_old_ids)
Notifie la connectivité que la famille source est compactée.
virtual Integer nbConnectedItem(ItemLocalId lid) const
Nombre d'entité connectées à l'entité source de numéro local lid.
virtual Int32 connectedItemLocalId(ItemLocalId lid, Integer index) const
localId() de la index-ième entitée connectées à l'entité source de numéro local lid
virtual ItemVectorView _connectedItems(ItemLocalId item, ConnectivityItemVector &con_items) const
Remplit con_items avec les entités connectées à item.
Index d'un Item dans une variable.
Definition ItemLocalId.h:41
virtual Int32 connectedItemLocalId(ItemLocalId lid, Integer index) const
localId() de la index-ième entitée connectées à l'entité source de numéro local lid
virtual ItemVectorView _connectedItems(ItemLocalId item, ConnectivityItemVector &con_items) const
Remplit con_items avec les entités connectées à item.
virtual Integer nbConnectedItem(ItemLocalId lid) const
Nombre d'entité connectées à l'entité source de numéro local lid.
virtual void notifySourceFamilyLocalIdChanged(Int32ConstArrayView new_to_old_ids)
Notifie la connectivité que la famille source est compactée.
Vue sur un tableau typé d'entités.
Vue sur un vecteur d'entités.
Vecteur 1D de données avec sémantique par référence.
Chaîne de caractères unicode.
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
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
ConstArrayView< Integer > IntegerConstArrayView
Equivalent C d'un tableau à une dimension d'entiers.
Definition UtilsTypes.h:573
std::int32_t Int32
Type entier signé sur 32 bits.
Type temporaire automatiquement casté en ConnectivityItemVector.