Arcane  v3.16.0.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
ItemFamily.cc
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2025 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
4// See the top-level COPYRIGHT file for details.
5// SPDX-License-Identifier: Apache-2.0
6//-----------------------------------------------------------------------------
7/*---------------------------------------------------------------------------*/
8/* ItemFamily.cc (C) 2000-2025 */
9/* */
10/* Infos de maillage pour un genre d'entité donnée. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/utils/FatalErrorException.h"
15#include "arcane/utils/ITraceMng.h"
16#include "arcane/utils/StringBuilder.h"
17#include "arcane/utils/ScopedPtr.h"
18#include "arcane/utils/NotImplementedException.h"
19#include "arcane/utils/NotSupportedException.h"
20#include "arcane/utils/ArgumentException.h"
21#include "arcane/utils/CheckedConvert.h"
22#include "arcane/utils/PlatformUtils.h"
23#include "arcane/utils/OStringStream.h"
24#include "arcane/utils/ValueConvert.h"
25
26#include "arcane/core/IParallelMng.h"
27#include "arcane/core/ISubDomain.h"
28#include "arcane/core/VariableTypes.h"
29#include "arcane/core/IVariableMng.h"
30#include "arcane/core/IVariable.h"
31#include "arcane/core/IMesh.h"
32#include "arcane/core/IMeshSubMeshTransition.h"
33#include "arcane/core/IApplication.h"
34#include "arcane/core/IDataFactoryMng.h"
35#include "arcane/core/ItemInfoListView.h"
36#include "arcane/core/ItemPairGroup.h"
37#include "arcane/core/ItemPairGroupImpl.h"
38#include "arcane/core/IMeshUtilities.h"
39#include "arcane/core/IVariableSynchronizer.h"
40#include "arcane/core/ItemInternalSortFunction.h"
41#include "arcane/core/Properties.h"
42#include "arcane/core/ItemFamilyCompactInfos.h"
43#include "arcane/core/IMeshMng.h"
44#include "arcane/core/IMeshCompacter.h"
45#include "arcane/core/IMeshCompactMng.h"
46#include "arcane/core/MeshPartInfo.h"
47#include "arcane/core/ParallelMngUtils.h"
48#include "arcane/core/internal/IDataInternal.h"
49#include "arcane/core/internal/IItemFamilyInternal.h"
50#include "arcane/core/internal/IIncrementalItemConnectivityInternal.h"
51#include "arcane/core/datatype/IDataOperation.h"
52
53#include "arcane/mesh/ItemFamily.h"
54#include "arcane/mesh/ItemSharedInfoList.h"
55#include "arcane/mesh/ItemConnectivityInfo.h"
56#include "arcane/mesh/ItemConnectivitySelector.h"
57#include "arcane/mesh/AbstractItemFamilyTopologyModifier.h"
58#include "arcane/mesh/DynamicMeshKindInfos.h"
59
60#include "arcane/core/parallel/GhostItemsVariableParallelOperation.h"
61#include "arcane/core/parallel/IStat.h"
62
63#include "arcane/core/IIncrementalItemConnectivity.h"
64#include "arcane/core/IItemConnectivityMng.h"
65#include "arcane/core/IItemFamilyPolicyMng.h"
66
67#include "arcane/core/ItemPrinter.h"
68#include "arcane/core/ConnectivityItemVector.h"
69#include "arcane/core/IndexedItemConnectivityView.h"
70
71#include "arcane/mesh/ItemProperty.h"
72#include "arcane/mesh/ItemData.h"
73#include "arcane/mesh/ConnectivityNewWithDependenciesTypes.h"
74
75#include <array>
76
77/*---------------------------------------------------------------------------*/
78/*---------------------------------------------------------------------------*/
79
80namespace Arcane::mesh
81{
82
83/*---------------------------------------------------------------------------*/
84/*---------------------------------------------------------------------------*/
85
86namespace
87{
88
89 template <typename DataType> void
90 _offsetArrayByOne(Array<DataType>* array)
91 {
92 Array<DataType>& v = *array;
93 MeshUtils::checkResizeArray(v, v.size() + 1, false);
94 Int32 n = v.size();
95 for (Int32 i = (n - 1); i >= 1; --i)
96 v[i] = v[i - 1];
97 }
98
99}
100
101/*---------------------------------------------------------------------------*/
102/*---------------------------------------------------------------------------*/
103
105: public IItemFamilyInternal
106{
107 public:
108
109 explicit InternalApi(ItemFamily* family)
110 : m_family(family)
111 {}
112
113 public:
114
116 {
117 return m_family->_unstructuredItemInternalConnectivityList();
118 }
120 {
121 return m_family->_topologyModifier();
122 }
124 {
125 return m_family->commonItemSharedInfo();
126 }
127 void addSourceConnectivity(IIncrementalItemSourceConnectivity* connectivity) override
128 {
129 m_family->_addSourceConnectivity(connectivity);
130 }
131 void addTargetConnectivity(IIncrementalItemTargetConnectivity* connectivity) override
132 {
133 m_family->_addTargetConnectivity(connectivity);
134 }
135 void endAllocate() override
136 {
137 return m_family->_endAllocate();
138 }
140 {
141 return m_family->_notifyEndUpdateFromMesh();
142 }
143 void addVariable(IVariable* var) override
144 {
145 return m_family->_addVariable(var);
146 }
147 void removeVariable(IVariable* var) override
148 {
149 return m_family->_removeVariable(var);
150 }
151 void resizeVariables(bool force_resize) override
152 {
153 return m_family->_resizeVariables(force_resize);
154 }
155
156 private:
157
158 ItemFamily* m_family = nullptr;
159};
160
161/*---------------------------------------------------------------------------*/
162/*---------------------------------------------------------------------------*/
163
165{
166 public:
167
168 Variables(IMesh* mesh,
169 const String& family_name,
170 eItemKind item_kind,
171 const String& shared_data_name,
172 const String& unique_ids_name,
173 const String& items_owner_name,
174 const String& items_flags_name,
175 const String& items_type_id_name,
176 const String& items_nb_parent_name,
177 const String& groups_name,
178 const String& current_id_name,
179 const String& new_owner_name,
180 const String& parent_mesh_name,
181 const String& parent_family_name,
182 const String& parent_family_depth_name,
183 const String& child_meshes_name,
184 const String& child_families_name)
191 , m_groups_name(VariableBuildInfo(mesh, groups_name))
192 , m_current_id(VariableBuildInfo(mesh, current_id_name))
194 , m_parent_mesh_name(VariableBuildInfo(mesh, parent_mesh_name, IVariable::PPrivate))
195 , m_parent_family_name(VariableBuildInfo(mesh, parent_family_name, IVariable::PPrivate))
196 , m_parent_family_depth(VariableBuildInfo(mesh, parent_family_depth_name, IVariable::PPrivate))
197 , m_child_meshes_name(VariableBuildInfo(mesh, child_meshes_name, IVariable::PPrivate))
198 , m_child_families_name(VariableBuildInfo(mesh, child_families_name, IVariable::PPrivate))
199 {}
200
201 public:
202
203 void setUsed()
204 {
205 m_items_new_owner.setUsed(true);
206 }
207
208 public:
209
211 // TODO: utiliser un Int16 lorsqu'on aura limité le nombre de ItemSharedInfo sur un Int16
229 VariableArrayString m_groups_name;
230 VariableScalarInteger m_current_id;
242 VariableScalarString m_parent_mesh_name;
243 VariableScalarString m_parent_family_name;
244 VariableScalarInteger m_parent_family_depth;
245 VariableArrayString m_child_meshes_name;
246 VariableArrayString m_child_families_name;
247};
248
249/*---------------------------------------------------------------------------*/
250/*---------------------------------------------------------------------------*/
251
252/*---------------------------------------------------------------------------*/
253/*---------------------------------------------------------------------------*/
254
255ItemFamily::
256ItemFamily(IMesh* mesh, eItemKind ik, const String& name)
258, m_name(name)
259, m_mesh(mesh)
260, m_internal_api(new InternalApi(this))
261, m_sub_domain(mesh->subDomain())
262, m_infos(std::make_unique<DynamicMeshKindInfos>(mesh, ik, name))
263, m_item_internal_list(mesh->meshItemInternalList())
264, m_common_item_shared_info(new ItemSharedInfo(this, m_item_internal_list, &m_item_connectivity_list))
265, m_item_shared_infos(new ItemSharedInfoList(this, m_common_item_shared_info))
266, m_properties(new Properties(*mesh->properties(), name))
267, m_sub_domain_id(mesh->meshPartInfo().partRank())
268{
269 m_item_connectivity_list.m_items = mesh->meshItemInternalList();
270 m_infos->setItemFamily(this);
271 m_connectivity_selector_list_by_item_kind.resize(ItemInternalConnectivityList::MAX_ITEM_KIND);
272}
273
274/*---------------------------------------------------------------------------*/
275/*---------------------------------------------------------------------------*/
276
277ItemFamily::
278~ItemFamily()
279{
280 delete m_topology_modifier;
281 delete m_policy_mng;
282 delete m_properties;
283 delete m_local_connectivity_info;
284 delete m_global_connectivity_info;
285 delete m_item_sort_function;
286 delete m_internal_variables;
287 delete m_item_shared_infos;
288
289 for (ItemConnectivitySelector* ics : m_connectivity_selector_list)
290 delete ics;
291
292 delete m_common_item_shared_info;
293 delete m_internal_api;
294}
295
296/*---------------------------------------------------------------------------*/
297/*---------------------------------------------------------------------------*/
298
299String ItemFamily::
300_variableName(const String& base_name) const
301{
302 return m_name + base_name;
303}
304
305/*---------------------------------------------------------------------------*/
306/*---------------------------------------------------------------------------*/
307
308void ItemFamily::
309build()
310{
311 m_item_type_mng = m_mesh->itemTypeMng();
312
313 // Créé le modificateur de topologie si cela n'a pas encore été fait par
314 // la classe dérivée.
315 if (!m_topology_modifier)
316 m_topology_modifier = new AbstractItemFamilyTopologyModifier(this);
317
318 m_full_name = m_mesh->name() + "_" + m_name;
319
320 m_local_connectivity_info = new ItemConnectivityInfo();
321 m_global_connectivity_info = new ItemConnectivityInfo();
322
323 IParallelMng* pm = m_mesh->parallelMng();
324 if (!pm->isParallel()) {
325 m_default_sub_domain_owner = 0;
326 m_is_parallel = false;
327 }
328 else
329 m_is_parallel = true;
330
331 // D'abord initialiser les infos car cela créé les groupes d'entités
332 // et c'est indispensable avant de créer des variables dessus.
333 m_infos->build();
334
335 // Construit l'instance qui contiendra les variables
336 // NOTE: si on change les noms ici, il faut aussi les changer dans MeshStats.cc
337 // sinon les statistiques ne seront pas fiables.
338 {
339 String var_unique_ids_name(_variableName("FamilyUniqueIds"));
340 String var_owner_name(_variableName("FamilyOwner"));
341 String var_flags_name(_variableName("FamilyFlags"));
342 String var_typeid_name(_variableName("FamilyItemTypeId"));
343 String var_nb_parent_name(_variableName("FamilyItemNbParent"));
344 String var_count_name(_variableName("FamilyItemsShared"));
345 String var_groups_name(_variableName("FamilyGroupsName"));
346 String var_current_id_name(_variableName("FamilyCurrentId"));
347 String var_new_owner_name(_variableName("FamilyNewOwnerName"));
348 String var_parent_mesh_name(_variableName("ParentMeshName"));
349 String var_parent_family_name(_variableName("ParentFamilyName"));
350 String var_parent_family_depth_name(_variableName("ParentFamilyDepthName"));
351 String var_child_meshes_name(_variableName("ChildMeshesName"));
352 String var_child_families_name(_variableName("ChildFamiliesName"));
353 m_internal_variables = new Variables(m_mesh, name(), itemKind(), var_count_name,
354 var_unique_ids_name, var_owner_name,
355 var_flags_name, var_typeid_name, var_nb_parent_name, var_groups_name,
356 var_current_id_name, var_new_owner_name,
357 var_parent_mesh_name, var_parent_family_name,
358 var_parent_family_depth_name,
359 var_child_meshes_name,
360 var_child_families_name);
361 // Il ne faut pas utiliser ces tableaux pour accéder aux entités car il y a un décalage
362 // de 1 pour gérer l'entité nulle. Il faut passer par la vue associée
363 // qui est dans m_common_item_shared_info.
364 m_items_unique_id = &m_internal_variables->m_items_unique_id._internalTrueData()->_internalDeprecatedValue();
365 m_items_owner = &m_internal_variables->m_items_owner._internalTrueData()->_internalDeprecatedValue();
366 m_items_flags = &m_internal_variables->m_items_flags._internalTrueData()->_internalDeprecatedValue();
367 m_items_type_id = &m_internal_variables->m_items_type_id._internalTrueData()->_internalDeprecatedValue();
368 m_items_nb_parent = &m_internal_variables->m_items_nb_parent._internalTrueData()->_internalDeprecatedValue();
369
370 // Ajoute notification pour la mise à jour des vues après un changement externe
371 _addOnSizeChangedObservable(m_internal_variables->m_items_unique_id);
372 _addOnSizeChangedObservable(m_internal_variables->m_items_owner);
373 _addOnSizeChangedObservable(m_internal_variables->m_items_flags);
374 _addOnSizeChangedObservable(m_internal_variables->m_items_type_id);
375 _addOnSizeChangedObservable(m_internal_variables->m_items_nb_parent);
376
377 _updateItemViews();
378 }
379
380 m_variable_synchronizer = ParallelMngUtils::createSynchronizerRef(pm, this);
381
382 m_item_sort_function = _defaultItemSortFunction();
383
384 {
385 String s = platform::getEnvironmentVariable("ARCANE_USE_LEGACY_COMPACT_ITEMS");
386 if (s == "TRUE" || s == "1") {
387 info() << "WARNING: Using legacy 'compactItem()' without compactReference()'";
388 m_use_legacy_compact_item = true;
389 }
390 }
391 {
392 if (auto v = Convert::Type<Int32>::tryParseFromEnvironment("ARCANE_ITEMFAMILY_SHRINK_AFTER_ALLOCATE", true))
393 m_do_shrink_after_allocate = (v.value() != 0);
394 }
395}
396
397/*---------------------------------------------------------------------------*/
398/*---------------------------------------------------------------------------*/
399
402{
403 return m_infos->findOne(uid);
404}
405ItemInternalMap& ItemFamily::
406itemsMap()
407{
408 return m_infos->itemsMap();
409}
410const DynamicMeshKindInfos& ItemFamily::
411infos() const
412{
413 return *m_infos;
414}
415
416const DynamicMeshKindInfos& ItemFamily::
417_infos() const
418{
419 return *m_infos;
420}
421
422void ItemFamily::
423_removeOne(Item item)
424{
425 // TODO: vérifier en mode check avec les nouvelles connectivités que l'entité supprimée
426 // n'a pas d'objets connectés.
427 m_infos->removeOne(ItemCompatibility::_itemInternal(item));
428}
429void ItemFamily::
430_detachOne(Item item)
431{
432 m_infos->detachOne(ItemCompatibility::_itemInternal(item));
433}
434ItemInternalList ItemFamily::
435_itemsInternal()
436{
437 return m_infos->itemsInternal();
438}
439ItemInternal* ItemFamily::
440_itemInternal(Int32 local_id)
441{
442 return m_infos->itemInternal(local_id);
443}
444ItemInternal* ItemFamily::
445_allocOne(Int64 unique_id)
446{
447 return m_infos->allocOne(unique_id);
448}
449ItemInternal* ItemFamily::
450_allocOne(Int64 unique_id, bool& need_alloc)
451{
452 return m_infos->allocOne(unique_id, need_alloc);
453}
454ItemInternal* ItemFamily::
455_findOrAllocOne(Int64 uid, bool& is_alloc)
456{
457 return m_infos->findOrAllocOne(uid, is_alloc);
458}
459void ItemFamily::
460_setHasUniqueIdMap(bool v)
461{
462 m_infos->setHasUniqueIdMap(v);
463}
464void ItemFamily::
465_removeMany(Int32ConstArrayView local_ids)
466{
467 m_infos->removeMany(local_ids);
468}
469void ItemFamily::
470_removeDetachedOne(Item item)
471{
472 m_infos->removeDetachedOne(ItemCompatibility::_itemInternal(item));
473}
475itemKind() const
476{
477 return m_infos->kind();
478}
479
480/*---------------------------------------------------------------------------*/
481/*---------------------------------------------------------------------------*/
482
484nbItem() const
485{
486 return m_infos->nbItem();
487}
488
489/*---------------------------------------------------------------------------*/
490/*---------------------------------------------------------------------------*/
491
493maxLocalId() const
494{
495 return m_infos->maxUsedLocalId();
496}
497
498/*---------------------------------------------------------------------------*/
499/*---------------------------------------------------------------------------*/
500
503{
504 return m_infos->itemsInternal();
505}
506
507/*---------------------------------------------------------------------------*/
508/*---------------------------------------------------------------------------*/
509
512{
513 return ItemInfoListView(m_common_item_shared_info);
514}
515
516/*---------------------------------------------------------------------------*/
517/*---------------------------------------------------------------------------*/
518
520parentFamily() const
521{
522 return m_parent_family;
523}
524
525/*---------------------------------------------------------------------------*/
526/*---------------------------------------------------------------------------*/
527
530{
531 m_parent_family = parent;
532 if (parent == this) // Auto-référencement
533 m_parent_family_depth = 1;
534 else if (!parent) // Pas de parent
535 m_parent_family_depth = 0;
536 else { // Référencement croisé
537 m_parent_family_depth = parent->parentFamilyDepth() + 1;
538 m_parent_family->addChildFamily(this);
539 }
540 ARCANE_ASSERT((m_parent_family_depth < 2), ("Not test if more than one depth level"));
541}
542
543/*---------------------------------------------------------------------------*/
544/*---------------------------------------------------------------------------*/
545
547parentFamilyDepth() const
548{
549 return m_parent_family_depth;
550}
551
552/*---------------------------------------------------------------------------*/
553/*---------------------------------------------------------------------------*/
554
557{
558 ItemFamily* true_family = ARCANE_CHECK_POINTER(dynamic_cast<ItemFamily*>(family));
559 m_child_families.add(true_family);
560}
561
562/*---------------------------------------------------------------------------*/
563/*---------------------------------------------------------------------------*/
564
567{
569 for (Integer i = 0; i < m_child_families.size(); ++i) {
570 collection.add(m_child_families[i]);
571 }
572 return collection;
573}
574
575/*---------------------------------------------------------------------------*/
576/*---------------------------------------------------------------------------*/
577
580{
581 return m_internal_variables->m_items_new_owner;
582}
583
584/*---------------------------------------------------------------------------*/
585/*---------------------------------------------------------------------------*/
586
589{
590 _checkValid();
591 m_item_shared_infos->checkValid();
592}
593
594/*---------------------------------------------------------------------------*/
595/*---------------------------------------------------------------------------*/
596
599{
600 _checkValidConnectivity();
601}
602
603/*---------------------------------------------------------------------------*/
604/*---------------------------------------------------------------------------*/
612{
613 // Recalcule les infos de connectivités locale et globales à tous les sous-domaines
614 _computeConnectivityInfo(m_local_connectivity_info);
615 _computeConnectivityInfo(m_global_connectivity_info);
616 m_global_connectivity_info->reduce(parallelMng());
617}
618
619/*---------------------------------------------------------------------------*/
620/*---------------------------------------------------------------------------*/
621
623endUpdate()
624{
625 _endUpdate(true);
626 // TODO: tester la connectivité mais ca fait planter certains cas tests
627 // (dof, amr2 et mesh_modification). A voir si c'est normal.
628 //if (arcaneIsCheck())
629 //checkValidConnectivity();
630}
631
632/*---------------------------------------------------------------------------*/
633/*---------------------------------------------------------------------------*/
634
635void ItemFamily::
636_endAllocate()
637{
638 // La variable n'est pas "used" par défaut car la famille n'est pas encore prête.
639 // Sur les sous-familles, il suffit donc de filtrer setUsed au moment du endAllocate
640 if (!m_parent_family) {
641 m_internal_variables->setUsed();
642 }
643 if (m_do_shrink_after_allocate)
644 _shrinkConnectivityAndPrintInfos();
645}
646
647/*---------------------------------------------------------------------------*/
648/*---------------------------------------------------------------------------*/
649
650void ItemFamily::
651_shrinkConnectivityAndPrintInfos()
652{
653 {
654 ItemConnectivityMemoryInfo mem_info;
655 for (ItemConnectivitySelector* cs : m_connectivity_selector_list) {
656 IIncrementalItemConnectivity* c = cs->customConnectivity();
657 c->_internalApi()->addMemoryInfos(mem_info);
658 }
659 const Int64 total_capacity = mem_info.m_total_capacity;
660 const Int64 total_size = mem_info.m_total_size;
661 Int64 ratio = 100 * (total_capacity - total_size);
662 ratio /= (total_size + 1); // Ajoute 1 pour éviter la division par zéro
663 const Int64 sizeof_int32 = sizeof(Int32);
664 const Int64 mega_byte = 1024 * 1024;
665 Int64 capacity_mega_byte = (mem_info.m_total_capacity * sizeof_int32) / mega_byte;
666 info() << "MemoryUsed for family name=" << name() << " size=" << mem_info.m_total_size
667 << " capacity=" << mem_info.m_total_capacity
668 << " capacity (MegaByte)=" << capacity_mega_byte
669 << " ratio=" << ratio;
670 }
671 OStringStream ostr;
672 std::ostream& o = ostr();
673 o << "Mem=" << platform::getMemoryUsed();
674 for (ItemConnectivitySelector* cs : m_connectivity_selector_list) {
675 IIncrementalItemConnectivity* c = cs->customConnectivity();
676 c->dumpStats(o);
677 o << "\n";
678 c->_internalApi()->shrinkMemory();
679 c->dumpStats(o);
680 o << "\n";
681 }
682 o << "Mem=" << platform::getMemoryUsed();
683 info() << ostr.str();
684}
685
686/*---------------------------------------------------------------------------*/
687/*---------------------------------------------------------------------------*/
688
689bool ItemFamily::
690_partialEndUpdate()
691{
692 bool need_end_update = m_infos->changed();
693 info(4) << "ItemFamily::endUpdate() " << fullName() << " need_end_update?=" << need_end_update;
694 if (!need_end_update) {
695 // Même si aucune entité n'est ajoutée ou supprimée, si \a m_need_prepare_dump
696 // est vrai cela signifie que quelque chose a changé dans la famille. Dans ce
697 // cas il est préférable d'incrémenter le current_id. Sans cela, si on appelle
698 // readFromDump() (par exemple suite à un retour-arrière), les données ne seront
699 // pas restaurées si entre temps current_id n'a pas changé.
700 if (m_need_prepare_dump) {
701 _computeConnectivityInfo(m_local_connectivity_info);
702 ++m_current_id;
703 }
704 return true;
705 }
706 m_item_need_prepare_dump = true;
707 _computeConnectivityInfo(m_local_connectivity_info);
708 ++m_current_id;
709
710 // Update "external" connectivities
712 m_connectivity_mng->setModifiedItems(this, m_infos->addedItems(), m_infos->removedItems());
713 //
714 m_infos->finalizeMeshChanged();
715
716 return false;
717}
718
719/*---------------------------------------------------------------------------*/
720/*---------------------------------------------------------------------------*/
721
722void ItemFamily::
723_endUpdate(bool need_check_remove)
724{
725 if (_partialEndUpdate())
726 return;
727
728 _resizeVariables(false);
729 info(4) << "ItemFamily:endUpdate(): " << fullName()
730 << " hashmapsize=" << itemsMap().nbBucket()
731 << " nb_group=" << m_item_groups.count();
732
733 _updateGroups(need_check_remove);
734}
735
736/*---------------------------------------------------------------------------*/
737/*---------------------------------------------------------------------------*/
738
741{
742 _partialEndUpdate();
743}
744
745/*---------------------------------------------------------------------------*/
746/*---------------------------------------------------------------------------*/
747
750{
751 _updateGroup(group, true);
752}
753
754/*---------------------------------------------------------------------------*/
755/*---------------------------------------------------------------------------*/
756
757void ItemFamily::
758_updateGroup(ItemGroup group, bool need_check_remove)
759{
760 // Pas besoin de recalculer le groupe des entités globales
761 if (group == m_infos->allItems())
762 return;
763
764 if (group.internal()->hasComputeFunctor())
765 group.invalidate();
766 if (need_check_remove) {
767 debug(Trace::High) << "Reset SuppressedItems: " << group.name();
769 }
770 if (arcaneIsCheck())
771 group.checkValid();
772}
773
774/*---------------------------------------------------------------------------*/
775/*---------------------------------------------------------------------------*/
776
777void ItemFamily::
778_updateGroups(bool need_check_remove)
779{
780 for (ItemGroupList::Enumerator i(m_item_groups); ++i;) {
781 ItemGroup group = *i;
782 _updateGroup(group, need_check_remove);
783 }
784}
785
786/*---------------------------------------------------------------------------*/
787/*---------------------------------------------------------------------------*/
788
791{
792 _updateVariable(variable);
793}
794
795/*---------------------------------------------------------------------------*/
796/*---------------------------------------------------------------------------*/
797
798void ItemFamily::
799_updateVariable(IVariable* var)
800{
801 var->resizeFromGroup();
802}
803
804/*---------------------------------------------------------------------------*/
805/*---------------------------------------------------------------------------*/
806
807void ItemFamily::
808_resizeVariables(bool force_resize)
809{
810 debug(Trace::High) << "ItemFamily::resizeVariables: name=" << fullName()
811 << " varsize=" << maxLocalId()
812 << " nb_item=" << nbItem()
813 << " currentsize=" << m_current_variable_item_size;
814 if (force_resize || (maxLocalId() != m_current_variable_item_size)) {
815 info(4) << "ItemFamily::resizeVariables: name=" << fullName()
816 << " varsize=" << maxLocalId()
817 << " nb_item=" << nbItem()
818 << " currentsize=" << m_current_variable_item_size
819 << " group_nb_item=" << allItems().size()
820 << " nb_var=" << m_used_variables.size();
821
822 m_current_variable_item_size = maxLocalId();
823
824 for (IVariable* var : m_used_variables) {
825 _updateVariable(var);
826 }
827 }
828}
829
830/*---------------------------------------------------------------------------*/
831/*---------------------------------------------------------------------------*/
832
833void ItemFamily::
834itemsUniqueIdToLocalId(ArrayView<Int64> ids, bool do_fatal) const
835{
836 m_infos->itemsUniqueIdToLocalId(ids, do_fatal);
837}
838
839/*---------------------------------------------------------------------------*/
840/*---------------------------------------------------------------------------*/
841
842void ItemFamily::
843itemsUniqueIdToLocalId(Int32ArrayView local_ids,
844 Int64ConstArrayView unique_ids,
845 bool do_fatal) const
846{
847 m_infos->itemsUniqueIdToLocalId(local_ids, unique_ids, do_fatal);
848}
849
850/*---------------------------------------------------------------------------*/
851/*---------------------------------------------------------------------------*/
852
853void ItemFamily::
854itemsUniqueIdToLocalId(Int32ArrayView local_ids,
856 bool do_fatal) const
857{
858 m_infos->itemsUniqueIdToLocalId(local_ids, unique_ids, do_fatal);
859}
860
861/*---------------------------------------------------------------------------*/
862/*---------------------------------------------------------------------------*/
863
865subDomain() const
866{
867 return m_sub_domain;
868}
869
870/*---------------------------------------------------------------------------*/
871/*---------------------------------------------------------------------------*/
872
874traceMng() const
875{
877}
878
879/*---------------------------------------------------------------------------*/
880/*---------------------------------------------------------------------------*/
881
883mesh() const
884{
885 return m_mesh;
886}
887
888/*---------------------------------------------------------------------------*/
889/*---------------------------------------------------------------------------*/
890
892parallelMng() const
893{
894 return m_mesh->parallelMng();
895}
896
897/*---------------------------------------------------------------------------*/
898/*---------------------------------------------------------------------------*/
899
901allItems() const
902{
903 _checkNeedEndUpdate();
904 return m_infos->allItems();
905}
906
907/*---------------------------------------------------------------------------*/
908/*---------------------------------------------------------------------------*/
909
911createGroup(const String& name, Int32ConstArrayView elements, bool do_override)
912{
913 debug(Trace::High) << "ItemFamily:createGroup(name,Int32ConstArrayView): " << m_name << ":"
914 << " group_name=" << name
915 << " count=" << elements.size()
916 << " override=" << do_override;
917
918 _checkNeedEndUpdate();
919
920 {
921 ItemGroup group;
922 if (do_override) {
923 group = findGroup(name);
924 if (group.null())
925 group = createGroup(name);
926 }
927 else {
928 group = createGroup(name);
929 }
930 group.setItems(elements);
931 return group;
932 }
933}
934
935/*---------------------------------------------------------------------------*/
936/*---------------------------------------------------------------------------*/
937
939createGroup(const String& name)
940{
941 //#warning SDP CHANGE
942 // SDP: probleme protection-reprise ...
943 {
945 if (!g.null()) {
946 fatal() << "Attempting to create an already existing group '" << name << "'";
947 }
948 }
949 debug() << "ItemFamily:createGroup(name): " << m_name << ":"
950 << " name=" << name;
951 ItemGroup group(new ItemGroupImpl(this, name));
952 _processNewGroup(group);
953 return group;
954}
955
956/*---------------------------------------------------------------------------*/
957/*---------------------------------------------------------------------------*/
958
960createGroup(const String& name, const ItemGroup& parent, bool do_override)
961{
962 ItemGroup group = findGroup(name);
963 if (!group.null()) {
964 if (do_override) {
965 if (group.internal()->parentGroup() != parent)
966 fatal() << "Group already existing but with a different parent";
967 if (group == parent)
968 fatal() << "A group can not be its own parent name=" << name;
969 return group;
970 }
971 fatal() << "Attempting to create an already existing group '" << name << "'";
972 }
973 if (parent.null())
974 fatal() << "Attempting to create a group '" << name << "' with no parent.";
975 debug() << "ItemFamily:createGroup(name,parent): " << m_name << ":"
976 << " name=" << name
977 << " parent=" << parent.name();
978 group = ItemGroup(new ItemGroupImpl(this, parent.internal(), name));
979 _processNewGroup(group);
980 return group;
981}
982
983/*---------------------------------------------------------------------------*/
984/*---------------------------------------------------------------------------*/
985
988{
989 _invalidateComputedGroups();
990 ItemGroupList current_groups(m_item_groups.clone());
991 m_item_groups.clear();
992 for (ItemGroupList::Enumerator i(current_groups); ++i;) {
993 ItemGroup group(*i);
994 if (group.isAllItems())
995 m_item_groups.add(group);
996 else
997 group.internal()->destroy();
998 }
1000}
1001
1002/*---------------------------------------------------------------------------*/
1003/*---------------------------------------------------------------------------*/
1004
1007{
1008 debug() << "ItemFamily::notifyItemsOwnerChanged()";
1009 for (ItemGroup group : m_item_groups) {
1010 if (m_is_parallel && group.internal()->hasComputeFunctor())
1011 group.invalidate();
1012 }
1013
1014 // Propage les modifications sur les sous-familles
1015 for (Integer i = 0; i < m_child_families.size(); ++i) {
1016 IItemFamily* family = m_child_families[i];
1017 ItemInternalArrayView items(family->itemsInternal());
1018 for (Integer z = 0, zs = items.size(); z < zs; ++z) {
1019 impl::MutableItemBase item(items[z]);
1020 if (item.isSuppressed())
1021 continue;
1022 Item parent_item = item.parentBase(0);
1023 ARCANE_ASSERT((parent_item.uniqueId() == item.uniqueId()), ("Inconsistent parent uid"));
1024 item.setOwner(parent_item.owner(), m_sub_domain_id);
1025 }
1026 family->notifyItemsOwnerChanged();
1027 }
1028}
1029
1030/*---------------------------------------------------------------------------*/
1031/*---------------------------------------------------------------------------*/
1032
1033void ItemFamily::
1034_processNewGroup(ItemGroup group)
1035{
1036 // Vérifie que le groupe à le bon type
1037 if (group.itemKind() != itemKind()) {
1038 ARCANE_FATAL("Incoherent family name={0} wanted={1} current={2}",
1039 fullName(), itemKind(), group.itemKind());
1040 }
1041 m_item_groups.add(group);
1042 m_need_prepare_dump = true;
1043 // En séquentiel, tous les groupes sont des groupes propres
1044 // TODO: regarder pour supprimer le test avec 'm_is_parallel' mais
1045 // si on le fait ca fait planter certains tests avec aleph_kappa.
1046 if (!m_is_parallel && m_mesh->meshPartInfo().nbPart() == 1)
1047 group.setOwn(true);
1048}
1049
1050/*---------------------------------------------------------------------------*/
1051/*---------------------------------------------------------------------------*/
1052
1054groups() const
1055{
1056 return m_item_groups;
1057}
1058
1059/*---------------------------------------------------------------------------*/
1060/*---------------------------------------------------------------------------*/
1061
1063findGroup(const String& name) const
1064{
1065 for (const ItemGroup& group : m_item_groups) {
1066 if (group.name() == name)
1067 return group;
1068 }
1069 return ItemGroup();
1070}
1071
1072/*---------------------------------------------------------------------------*/
1073/*---------------------------------------------------------------------------*/
1074
1076findGroup(const String& name, bool create_if_needed)
1077{
1078 ItemGroup group = findGroup(name);
1079 if (group.null()) {
1080 if (create_if_needed)
1081 group = createGroup(name);
1082 }
1083 return group;
1084}
1085
1086/*---------------------------------------------------------------------------*/
1087/*---------------------------------------------------------------------------*/
1088
1091{
1092 itemsMap().notifyUniqueIdsChanged();
1093}
1094
1095/*---------------------------------------------------------------------------*/
1096/*---------------------------------------------------------------------------*/
1097
1098void ItemFamily::
1099_checkNeedEndUpdate() const
1100{
1101 if (m_infos->changed())
1102 ARCANE_FATAL("missing call to endUpdate() after modification");
1103}
1104
1105/*---------------------------------------------------------------------------*/
1106/*---------------------------------------------------------------------------*/
1107
1110{
1111 info(4) << "ItemFamily::prepareForDump(): " << fullName()
1112 << " need=" << m_need_prepare_dump
1113 << " item-need=" << m_item_need_prepare_dump
1114 << " m_item_shared_infos->hasChanged()=" << m_item_shared_infos->hasChanged()
1115 << " nb_item=" << m_infos->nbItem();
1116
1117 {
1118 auto* p = m_properties;
1119 p->setInt32("dump-version", 0x0307);
1120 p->setInt32("nb-item", m_infos->nbItem());
1121 p->setInt32("current-change-id", m_current_id);
1122 }
1123
1124 // TODO: ajoute flag vérification si nécessaire
1125 if (m_item_need_prepare_dump || m_item_shared_infos->hasChanged()) {
1126 info(4) << "Prepare for dump:2: name=" << m_name << " nb_alloc=" << m_nb_allocate_info
1127 << " uid_size=" << m_items_unique_id->size() << " cap=" << m_items_unique_id->capacity()
1128 << " byte=" << m_items_unique_id->capacity() * sizeof(Int64);
1129
1130 // TODO: pouvoir spécifier si on souhaite compacter ou pas.
1131 _compactOnlyItems(false);
1132
1133 // Suppose compression
1134 m_infos->prepareForDump();
1135 m_item_shared_infos->prepareForDump();
1136 m_need_prepare_dump = true;
1137 }
1138 m_item_need_prepare_dump = false;
1139 if (m_need_prepare_dump) {
1140 Integer nb_item = m_infos->nbItem();
1141 // TODO: regarder si ce ne serait pas mieux de faire cela dans finishCompactItem()
1142 _resizeItemVariables(nb_item, true);
1143 m_internal_variables->m_current_id = m_current_id;
1144 info(4) << " SET FAMILY ID name=" << name() << " id= " << m_current_id
1145 << " saveid=" << m_internal_variables->m_current_id();
1146 ItemInternalList items(m_infos->itemsInternal());
1147 m_internal_variables->m_items_shared_data_index.resize(nb_item);
1148 IntegerArrayView items_shared_data_index(m_internal_variables->m_items_shared_data_index);
1149 info(4) << "ItemFamily::prepareForDump(): " << m_name
1150 << " count=" << nb_item << " currentid=" << m_current_id;
1151 // Normalement items[i]->localId()==i pour toute les entités car on a effectué un compactage
1152 if (arcaneIsCheck()) {
1153 for (Integer i = 0; i < nb_item; ++i) {
1154 ItemInternal* item = items[i];
1155 if (item->localId() != i)
1156 ARCANE_FATAL("Incoherence between index ({0}) and localId() ({1})", i, item->localId());
1157 }
1158 }
1159 for (Integer i = 0; i < nb_item; ++i) {
1160 ItemInternal* item = items[i];
1161 ItemSharedInfoWithType* isi = m_item_shared_infos->findSharedInfo(item->typeInfo());
1162 items_shared_data_index[i] = isi->index();
1163#if 0
1164#ifdef ARCANE_DEBUG
1165 //if (itemKind()==IK_Particle){
1166 info() << "Item: SHARED_INDEX = " << items_shared_data_index[i]
1167 << " uid = " << item->uniqueId()
1168 << " lid = " << item->localId()
1169 << " dataindex = " << item->dataIndex()
1170 << " flags = " << item->flags();
1171 //}
1172#endif
1173#endif
1174 }
1175
1176 // Données de liaison de familles
1177 {
1178 if (m_parent_family) {
1179 m_internal_variables->m_parent_family_name = m_parent_family->name();
1180 m_internal_variables->m_parent_mesh_name = m_parent_family->mesh()->name();
1181 }
1182 m_internal_variables->m_parent_family_depth = m_parent_family_depth;
1183 const Integer child_count = m_child_families.size();
1184 m_internal_variables->m_child_meshes_name.resize(child_count);
1185 m_internal_variables->m_child_families_name.resize(child_count);
1186 for (Integer i = 0; i < child_count; ++i) {
1187 m_internal_variables->m_child_meshes_name[i] = m_child_families[i]->mesh()->name();
1188 m_internal_variables->m_child_families_name[i] = m_child_families[i]->name();
1189 }
1190 }
1191
1192 {
1193 // Détermine le nombre de groupes et d'entités à sauver.
1194 // On ne sauve pas les groupes générés dynamiquement
1195 Integer nb_group_to_save = 0;
1196 for (ItemGroupList::Enumerator i(m_item_groups); ++i;) {
1197 const ItemGroup& group = *i;
1198 if (group.internal()->hasComputeFunctor() || group.isLocalToSubDomain())
1199 continue;
1200 debug(Trace::High) << "Save group info name=" << group.name();
1201 ++nb_group_to_save;
1202 }
1203 m_internal_variables->m_groups_name.resize(nb_group_to_save);
1204 {
1205 Integer current_group_index = 0;
1206 for (ItemGroupList::Enumerator i(m_item_groups); ++i;) {
1207 const ItemGroup& group = *i;
1208 if (group.internal()->hasComputeFunctor() || group.isLocalToSubDomain())
1209 continue;
1210 m_internal_variables->m_groups_name[current_group_index] = group.name();
1211 ++current_group_index;
1212 }
1213 }
1214 }
1215 }
1216 // Fait en sorte que les groupes soient à jour, pour être sur que
1217 // la sauvegarde sera correcte.
1218 // NOTE: Est-ce ici qu'il faut le faire ?
1219 // NOTE: plutot utiliser un observer sur la variable du groupe?
1220 _applyCheckNeedUpdateOnGroups();
1221
1222 m_need_prepare_dump = false;
1223}
1224
1225/*---------------------------------------------------------------------------*/
1226/*---------------------------------------------------------------------------*/
1227
1230{
1231 // TODO: GG: utiliser un flag pour indiquer qu'il faudra reconstruire
1232 // les infos de synchro mais ne pas le faire directement dans cette methode.
1233
1234 Int32 nb_item = 0;
1235 Int32 dump_version = 0;
1236 // Indique si on utilise la variable contenant le type de l'entité pour
1237 // construire les ItemInternal. Cela n'est possible qu'avec les protections
1238 // effectuées depuis une version 3.7 de Arcane. Avant cela il faut utiliser
1239 // la variable m_items_shared_data_index.
1240 bool use_type_variable = false;
1241 {
1242 Int32 x = 0;
1243 auto* p = m_properties;
1244 if (p->get("dump-version", x))
1245 dump_version = x;
1246 if (dump_version >= 0x0307) {
1247 use_type_variable = true;
1248 nb_item = p->getInt32("nb-item");
1249 Int32 cid = p->getInt32("current-change-id");
1250 Int32 expected_cid = m_internal_variables->m_current_id();
1251 if (cid != expected_cid)
1252 ARCANE_FATAL("Bad value for current id mesh={0} id={1} expected={2}",
1253 fullName(), cid, expected_cid);
1254 }
1255 }
1256
1257 const bool allow_old_version = true;
1258 if (!allow_old_version)
1259 if (dump_version < 0x0307)
1260 ARCANE_FATAL("Your checkpoint is from a version of Arcane which is too old (mininum version is 3.7)");
1261
1262 // Le numéro de la partie peut changer en reprise. Il faut donc le
1263 // remettre à jour. De même, si on passe d'un maillage séquentiel à un
1264 // maillage en plusieurs parties en reprise, il faut supprimer le isOwn()
1265 // du groupe de toutes les entités.
1266 const MeshPartInfo& part_info = m_mesh->meshPartInfo();
1267 m_sub_domain_id = part_info.partRank();
1268 if (m_infos->allItems().isOwn() && part_info.nbPart() > 1)
1269 m_infos->allItems().setOwn(false);
1270
1271 // NOTE: l'implémentation actuelle suppose que les dataIndex() des
1272 // entites sont consécutifs et croissants avec le localId() des entités
1273 // (c.a.d l'entité de localId() valant 0 à aussi un dataIndex() de 0,
1274 // celle de localId() valant 1, le dataIndex() suivant ...)
1275 // Cette condition est vrai si compactReferences() a été appelé.
1276 // Lorsque ce ne sera plus le cas (trou dans la numérotation), il faudra
1277 // ajouter une variable data_index sur les entités.
1278 IntegerArrayView items_shared_data_index(m_internal_variables->m_items_shared_data_index);
1279 if (!use_type_variable)
1280 nb_item = items_shared_data_index.size();
1281
1282 info(4) << "ItemFamily::readFromDump(): " << fullName()
1283 << " count=" << nb_item
1284 << " currentid=" << m_current_id
1285 << " saveid=" << m_internal_variables->m_current_id()
1286 << " use_type_variable?=" << use_type_variable
1287 << " dump_version=" << dump_version;
1288
1289 if (!use_type_variable) {
1290 // Avec les anciennes protections il n'y a pas la variable pour le type de l'entité.
1291 // Il faut donc l'allouer ici car on s'en sert lorsqu'on appelle ItemInternal::setSharedInfo().
1292 if (nb_item > 0)
1293 MeshUtils::checkResizeArray(*m_items_type_id, nb_item + 1, false);
1294 // Il n'y a pas non plus le décalage de 1 pour les flags, owner et uniqueId.
1295 // On fait ce décalage ici.
1296 _handleOldCheckpoint();
1297 }
1298 _updateItemViews();
1299
1300 if (m_internal_variables->m_current_id() == m_current_id) {
1301 debug() << "Family unchanged. Nothing to do.";
1302 //GG: il faut quand meme recalculer les infos de synchro car cette famille
1303 // sur les autres sous-domaine peut avoir changee et dans ce cas cette
1304 // fonctione sera appelee. De meme, la liste des groupes peut avoir changée
1305 // et leur valeur aussi pour les groupes recalculés donc il faut les invalider
1307 _readGroups();
1308 _invalidateComputedGroups();
1309 return;
1310 }
1311
1312 m_current_id = m_internal_variables->m_current_id();
1313 // IMPORTANT: remise à zéro pour obligatoirement redimensionner les variables
1314 // au prochain ajout d'entités.
1315 m_current_variable_item_size = 0;
1316
1317 // Données de liaison de famille
1318 {
1319 IMeshMng* mesh_mng = m_mesh->meshMng();
1320 if (!m_internal_variables->m_parent_mesh_name().null()) {
1321 IMesh* parent_mesh = mesh_mng->findMeshHandle(m_internal_variables->m_parent_mesh_name()).mesh();
1322 m_parent_family = parent_mesh->findItemFamily(m_internal_variables->m_parent_family_name(), true); // true=> fatal si non trouvé
1323 }
1324 m_parent_family_depth = m_internal_variables->m_parent_family_depth();
1325 ARCANE_ASSERT((m_internal_variables->m_child_meshes_name.size() == m_internal_variables->m_child_families_name.size()),
1326 ("Incompatible child mesh/family sizes"));
1327 Integer child_count = m_internal_variables->m_child_families_name.size();
1328 for (Integer i = 0; i < child_count; ++i) {
1329 IMesh* child_mesh = mesh_mng->findMeshHandle(m_internal_variables->m_child_meshes_name[i]).mesh();
1330 IItemFamily* child_family = child_mesh->findItemFamily(m_internal_variables->m_child_families_name[i], true); // true=> fatal si non trouvé
1331 m_child_families.add(dynamic_cast<ItemFamily*>(child_family));
1332 }
1333 }
1334
1335 m_item_shared_infos->readFromDump();
1336 m_infos->readFromDump();
1337
1338 // En relecture les entités sont compactées donc la valeur max du localId()
1339 // est égal au nombre d'entités.
1340
1341 if (use_type_variable) {
1342 ItemTypeMng* type_mng = mesh()->itemTypeMng();
1343 for (Integer i = 0; i < nb_item; ++i) {
1344 ;
1345 ItemTypeId type_id{ m_common_item_shared_info->m_type_ids[i] };
1346 ItemSharedInfoWithType* isi = _findSharedInfo(type_mng->typeFromId(type_id));
1347 Int64 uid = m_items_unique_id_view[i];
1348 ItemInternal* item = m_infos->allocOne(uid);
1349 item->_setSharedInfo(isi->sharedInfo(), type_id);
1350 }
1351 }
1352 else {
1353 // Méthode utilisée pour les protections issues des versions 3.6 et antérieure de Arcane.
1354 auto item_shared_infos = m_item_shared_infos->itemSharedInfos();
1355 for (Integer i = 0; i < nb_item; ++i) {
1356 Integer shared_data_index = items_shared_data_index[i];
1357 ItemSharedInfoWithType* isi = item_shared_infos[shared_data_index];
1358 Int64 uid = m_items_unique_id_view[i];
1359 ItemInternal* item = m_infos->allocOne(uid);
1360 item->_setSharedInfo(isi->sharedInfo(), isi->itemTypeId());
1361 }
1362 }
1363
1364 // Supprime les entités du groupe total car elles vont être remises à jour
1365 // lors de l'appel à _endUpdate()
1366 m_infos->allItems().clear();
1367
1368 // Notifie les connectivités sources qu'on vient de faire une relecture.
1369 for (auto& c : m_source_incremental_item_connectivities)
1370 c->notifyReadFromDump();
1371
1372 // Recréation des groupes si nécessaire
1373 _readGroups();
1374
1375 // Invalide les groupes recalculés
1376 _invalidateComputedGroups();
1377
1378 _endUpdate(false);
1379
1381}
1382
1383/*---------------------------------------------------------------------------*/
1384/*---------------------------------------------------------------------------*/
1385
1386void ItemFamily::
1387_applyCheckNeedUpdateOnGroups()
1388{
1389 for (ItemGroupList::Enumerator i(m_item_groups); ++i;) {
1390 ItemGroup group = *i;
1391 // Pas besoin de recalculer le groupe des entités globales
1392 if (group == m_infos->allItems())
1393 continue;
1394 group.internal()->checkNeedUpdate();
1395 }
1396}
1397
1398/*---------------------------------------------------------------------------*/
1399/*---------------------------------------------------------------------------*/
1400
1401void ItemFamily::
1402_invalidateComputedGroups()
1403{
1404 // Si le groupe a un parent, il n'a pas de variable associée et
1405 // de plus peut contenir des valeurs invalides suite à un retour-arrière.
1406 // Dans ce cas, on le vide et on l'invalide.
1407 for (ItemGroupList::Enumerator i(m_item_groups); ++i;) {
1408 ItemGroup group = *i;
1409 if (!group.internal()->parentGroup().null()) {
1410 group.clear();
1411 group.invalidate();
1412 }
1413 }
1414}
1415
1416/*---------------------------------------------------------------------------*/
1417/*---------------------------------------------------------------------------*/
1423{
1424 // Recréation des groupes si nécessaire
1425 VariableArrayString& groups_var = m_internal_variables->m_groups_name;
1426 debug() << "ItemFamily::readFromDump(): number of group: " << groups_var.size();
1427 for (Integer i = 0, is = groups_var.size(); i < is; ++i) {
1428 String name(groups_var[i]);
1429 debug() << "Readign group again: " << name;
1430 ItemGroup group = findGroup(name);
1431 if (group.null())
1433 }
1434}
1435
1436/*---------------------------------------------------------------------------*/
1437/*---------------------------------------------------------------------------*/
1446{
1447 Int32 global_changed = parallelMng()->reduce(Parallel::ReduceMax, changed);
1448 if (global_changed != 0)
1450}
1451
1452/*---------------------------------------------------------------------------*/
1453/*---------------------------------------------------------------------------*/
1462_compactOnlyItems(bool do_sort)
1463{
1464 _compactItems(do_sort);
1465
1466 // Il est necessaire de mettre a jour les groupes.
1467 // TODO verifier s'il faut le faire tout le temps
1468 m_need_prepare_dump = true;
1469
1470 // Indique aussi qu'il faudra refaire un compactReference()
1471 // lors du dump.
1472 // NOTE: spécifier cela forcera aussi un recompactage lors du prepareForDump()
1473 // et ce compactage est inutile dans le cas présent.
1474 // TODO: regarder comment indiquer au prepareForDump() qu'on souhaite
1475 // juste faire un compactReference().
1476 m_item_need_prepare_dump = true;
1477}
1478
1479/*---------------------------------------------------------------------------*/
1480/*---------------------------------------------------------------------------*/
1485compactItems(bool do_sort)
1486{
1487 _compactOnlyItems(do_sort);
1488
1489 if (!m_use_legacy_compact_item) {
1490 // Il est nécessaire de mettre à jour les groupes
1491 // après un compactReferences().
1492 _applyCheckNeedUpdateOnGroups();
1493 }
1494}
1495
1496/*---------------------------------------------------------------------------*/
1497/*---------------------------------------------------------------------------*/
1502_compactItems(bool do_sort)
1503{
1504 IMeshCompactMng* compact_mng = mesh()->_compactMng();
1505 IMeshCompacter* compacter = compact_mng->beginCompact(this);
1506
1507 try {
1508 compacter->setSorted(do_sort);
1509 compacter->doAllActions();
1510 }
1511 catch (...) {
1512 compact_mng->endCompact();
1513 throw;
1514 }
1515 compact_mng->endCompact();
1516}
1517
1518/*---------------------------------------------------------------------------*/
1519/*---------------------------------------------------------------------------*/
1520
1521void ItemFamily::
1522beginCompactItems(ItemFamilyCompactInfos& compact_infos)
1523{
1524 m_infos->beginCompactItems(compact_infos);
1525
1526 if (arcaneIsCheck())
1527 m_infos->checkValid();
1528
1529 Int32ConstArrayView new_to_old_ids = compact_infos.newToOldLocalIds();
1530 Int32ConstArrayView old_to_new_ids = compact_infos.oldToNewLocalIds();
1531
1532 for (auto& c : m_source_incremental_item_connectivities)
1533 c->notifySourceFamilyLocalIdChanged(new_to_old_ids);
1534
1535 for (auto& c : m_target_incremental_item_connectivities)
1536 c->notifyTargetFamilyLocalIdChanged(old_to_new_ids);
1537
1538 for (IItemConnectivity* c : m_source_item_connectivities)
1539 c->notifySourceFamilyLocalIdChanged(new_to_old_ids);
1540
1542 c->notifyTargetFamilyLocalIdChanged(old_to_new_ids);
1543
1545 m_connectivity_mng->notifyLocalIdChanged(this, old_to_new_ids, nbItem());
1546
1547 // Compactage des variables internes associées aux entités
1548 {
1549 if (m_parent_family_depth > 0)
1550 m_internal_variables->m_items_nb_parent.variable()->compact(new_to_old_ids);
1551
1552 _updateItemViews();
1553 }
1554}
1555
1556/*---------------------------------------------------------------------------*/
1557/*---------------------------------------------------------------------------*/
1558
1559void ItemFamily::
1560finishCompactItems(ItemFamilyCompactInfos& compact_infos)
1561{
1562 if (arcaneIsCheck())
1563 m_infos->checkValid();
1564
1565 m_infos->finishCompactItems(compact_infos);
1566
1567 for (ItemConnectivitySelector* ics : m_connectivity_selector_list)
1568 ics->compactConnectivities();
1569}
1570
1571/*---------------------------------------------------------------------------*/
1572/*---------------------------------------------------------------------------*/
1582{
1583 ARCANE_ASSERT(source.size() == destination.size(),
1584 ("Can't copy. Source and destination have different size !"));
1585
1586 if (source.size() != 0) {
1587 for (IVariable* var : m_used_variables) {
1588 // (HP) : comme vu avec Gilles et Stéphane, on ne met pas de filtre à ce niveau
1589 // // si la variable est temporaire ou no restore, on ne la copie pas
1590 // if (!(var->property() & (IVariable::PTemporary | IVariable::PNoRestore))) {
1591 //if (var->itemFamily()==this) {
1592 var->copyItemsValues(source, destination);
1593 }
1594 }
1595}
1596
1597/*---------------------------------------------------------------------------*/
1598/*---------------------------------------------------------------------------*/
1610 Int32ConstArrayView second_source,
1611 Int32ConstArrayView destination)
1612{
1613 ARCANE_ASSERT(first_source.size() == destination.size(),
1614 ("Can't copy. : first_source and destination have different size !"));
1615 ARCANE_ASSERT(second_source.size() == destination.size(),
1616 ("Can't copy : second_source and destination have different size !"));
1617
1618 if (first_source.size() != 0) {
1619 for (IVariable* var : m_used_variables) {
1621 var->copyItemsMeanValues(first_source, second_source, destination);
1622 }
1623 }
1624 }
1625}
1626
1627/*---------------------------------------------------------------------------*/
1628/*---------------------------------------------------------------------------*/
1637{
1638 Int32ConstArrayView new_to_old_ids = compact_infos.newToOldLocalIds();
1639 Int32ConstArrayView old_to_new_ids = compact_infos.oldToNewLocalIds();
1640
1641 for (IVariable* var : m_used_variables) {
1642 debug(Trace::High) << "Compact variable " << var->fullName();
1643 var->compact(new_to_old_ids);
1644 }
1645
1646 m_variable_synchronizer->changeLocalIds(old_to_new_ids);
1647
1648 for (ItemGroupList::Enumerator i(m_item_groups); ++i;) {
1649 ItemGroup group = *i;
1650 debug(Trace::High) << "Change group Ids: " << group.name();
1651 group.internal()->changeIds(old_to_new_ids);
1652 if (group.hasSynchronizer())
1653 group.synchronizer()->changeLocalIds(old_to_new_ids);
1654 }
1655
1656 for (Integer i = 0; i < m_child_families.size(); ++i)
1657 m_child_families[i]->_compactFromParentFamily(compact_infos);
1658
1659 info(4) << "End compact family=" << fullName()
1660 << " max_local_id=" << maxLocalId()
1661 << " nb_item=" << nbItem();
1662
1663 // Apres compactage, les variables seront allouées avec comme nombre
1664 // d'éléments le nombre d'entité (c'est dans DynamicMeshKindInfos::finishCompactItems()
1665 // que maxLocalId() devient égal à nbItem()).
1666 m_current_variable_item_size = nbItem();
1667}
1668
1669/*---------------------------------------------------------------------------*/
1670/*---------------------------------------------------------------------------*/
1677#ifdef NEED_MERGE
1678void ItemFamily::
1679compactConnectivities()
1680{
1681 Int32ConstArrayView new_to_old_ids = m_infos.newToOldLocalIds();
1682 Int32ConstArrayView old_to_new_ids = m_infos.oldToNewLocalIds();
1683 for (IItemConnectivity* c : m_source_connectivities)
1684 c->notifySourceFamilyLocalIdChanged(new_to_old_ids);
1685
1686 for (IItemConnectivity* c : m_target_connectivities)
1687 c->notifyTargetFamilyLocalIdChanged(old_to_new_ids);
1688
1690 m_connectivity_mng->notifyLocalIdChanged(this, old_to_new_ids, nbItem());
1691}
1692#endif
1693
1694/*---------------------------------------------------------------------------*/
1695/*---------------------------------------------------------------------------*/
1696
1699{
1700 debug() << "Compacting child family " << fullName();
1701 if (m_parent_family_depth > 1)
1702 throw NotImplementedException(A_FUNCINFO, "Too deep parent family: not yet implemented");
1703 Int32ConstArrayView old_to_new_lids(compact_infos.oldToNewLocalIds());
1704 ARCANE_ASSERT((nbItem() == 0 || !old_to_new_lids.empty()), ("Empty oldToNewLocalIds"));
1705 debug() << "\tfrom parent family " << m_parent_family->name();
1706 if (this == m_parent_family)
1707 return; // already self compacted
1708 ItemInternalArrayView items(itemsInternal());
1709 for (Integer z = 0, zs = items.size(); z < zs; ++z) {
1710 ItemInternal* item = items[z];
1711 Int32 old_parent_lid = item->parentId(0); // depth==1 only !!
1712 item->setParent(0, old_to_new_lids[old_parent_lid]);
1713 }
1714 // Si depth>1, il faudrait plutot propager le compactage en modifiant les
1715 // oldToNewLocalIds des familles du sous-maillage courant et en appelant
1716 // DynamicMesh::_compactItems en cascade (à partir de ce sous-maillage)
1717}
1718
1719/*---------------------------------------------------------------------------*/
1720/*---------------------------------------------------------------------------*/
1721
1723internalRemoveItems(Int32ConstArrayView local_ids, bool keep_ghost)
1724{
1725 ARCANE_UNUSED(local_ids);
1726 ARCANE_UNUSED(keep_ghost);
1727 ARCANE_THROW(NotSupportedException, "this kind of family doesn't support this operation");
1728}
1729
1730/*---------------------------------------------------------------------------*/
1731/*---------------------------------------------------------------------------*/
1732
1733void ItemFamily::
1734_checkValid()
1735{
1736 // Vérifie que le numéro de la partie est le même que celui du maillage
1737 {
1738 Int32 part_rank = m_mesh->meshPartInfo().partRank();
1739 if (m_sub_domain_id != part_rank)
1740 ARCANE_FATAL("Family {0} Bad value for partRank ({1}) expected={2}",
1741 fullName(), m_sub_domain_id, part_rank);
1742 }
1743}
1744
1745/*---------------------------------------------------------------------------*/
1746/*---------------------------------------------------------------------------*/
1747
1748void ItemFamily::
1749_reserveInfosMemory(Integer memory)
1750{
1751 ARCANE_UNUSED(memory);
1752}
1753
1754/*---------------------------------------------------------------------------*/
1755/*---------------------------------------------------------------------------*/
1756
1757void ItemFamily::
1758_resizeInfos(Integer new_size)
1759{
1760 ARCANE_UNUSED(new_size);
1761}
1762
1763/*---------------------------------------------------------------------------*/
1764/*---------------------------------------------------------------------------*/
1765
1766Integer ItemFamily::
1767_allocMany(Integer memory)
1768{
1769 ARCANE_UNUSED(memory);
1770 return 0;
1771}
1772
1773/*---------------------------------------------------------------------------*/
1774/*---------------------------------------------------------------------------*/
1775
1776ItemSharedInfoWithType* ItemFamily::
1777_findSharedInfo(ItemTypeInfo* type)
1778{
1779 return m_item_shared_infos->findSharedInfo(type);
1780}
1781
1782/*---------------------------------------------------------------------------*/
1783/*---------------------------------------------------------------------------*/
1784
1785void ItemFamily::
1786_updateSharedInfo()
1787{
1788 //TODO: Regarder si cela est toujours utile
1789 m_need_prepare_dump = true;
1790}
1791
1792/*---------------------------------------------------------------------------*/
1793/*---------------------------------------------------------------------------*/
1794
1795void ItemFamily::
1796_allocateInfos(ItemInternal* item, Int64 uid, ItemTypeInfo* type)
1797{
1798 ItemSharedInfoWithType* isi = _findSharedInfo(type);
1799 _allocateInfos(item, uid, isi);
1800}
1801
1802/*---------------------------------------------------------------------------*/
1803/*---------------------------------------------------------------------------*/
1804
1805void ItemFamily::
1806_resizeItemVariables(Int32 new_size, bool force_resize)
1807{
1808 bool is_resize = MeshUtils::checkResizeArray(*m_items_unique_id, new_size + 1, force_resize);
1809 is_resize |= MeshUtils::checkResizeArray(*m_items_owner, new_size + 1, force_resize);
1810 is_resize |= MeshUtils::checkResizeArray(*m_items_flags, new_size + 1, force_resize);
1811 is_resize |= MeshUtils::checkResizeArray(*m_items_type_id, new_size + 1, force_resize);
1812 if (m_parent_family_depth > 0)
1813 is_resize |= MeshUtils::checkResizeArray(*m_items_nb_parent, new_size, force_resize);
1814 if (is_resize)
1815 _updateItemViews();
1816
1817 // Positionne les valeurs pour l'entité nulle.
1818 // NOTE: regarder pour faire cela à l'init.
1819 (*m_items_unique_id)[0] = NULL_ITEM_UNIQUE_ID;
1820 (*m_items_flags)[0] = 0;
1821 (*m_items_owner)[0] = A_NULL_RANK;
1822 (*m_items_type_id)[0] = IT_NullType;
1823}
1824
1825/*---------------------------------------------------------------------------*/
1826/*---------------------------------------------------------------------------*/
1827
1828void ItemFamily::
1829_allocateInfos(ItemInternal* item, Int64 uid, ItemSharedInfoWithType* isi)
1830{
1831 // TODO: faire en même temps que le réalloc de la variable uniqueId()
1832 // le réalloc des m_source_incremental_item_connectivities.
1833 Int32 local_id = item->localId();
1834 _resizeItemVariables(local_id + 1, false);
1835
1836 // TODO: regarder si encore utile car ItemInternal::reinitialize() doit le faire
1837 //(*m_items_unique_id)[local_id] = uid;
1838
1839 ItemTypeId iti = isi->itemTypeId();
1840 item->_setSharedInfo(isi->sharedInfo(), iti);
1841
1842 item->reinitialize(uid, m_default_sub_domain_owner, m_sub_domain_id);
1843 ++m_nb_allocate_info;
1844 // Notifie les connectivitées incrémentales qu'on a ajouté un élément à la source
1845 for (auto& c : m_source_incremental_item_connectivities)
1846 c->notifySourceItemAdded(ItemLocalId(local_id));
1847}
1848
1849/*---------------------------------------------------------------------------*/
1850/*---------------------------------------------------------------------------*/
1851
1852void ItemFamily::
1853_preAllocate(Int32 nb_item, bool pre_alloc_connectivity)
1854{
1855 if (nb_item > 1000)
1856 m_infos->itemsMap().resize(nb_item, true);
1857 _resizeItemVariables(nb_item, false);
1858 for (auto& c : m_source_incremental_item_connectivities)
1859 c->reserveMemoryForNbSourceItems(nb_item, pre_alloc_connectivity);
1860}
1861
1862/*---------------------------------------------------------------------------*/
1863/*---------------------------------------------------------------------------*/
1864
1865void ItemFamily::
1866_notifyDataIndexChanged()
1867{
1868 _updateItemViews();
1869}
1870
1871/*---------------------------------------------------------------------------*/
1872/*---------------------------------------------------------------------------*/
1873
1875getCommunicatingSubDomains(Int32Array& sub_domains) const
1876{
1877 Int32ConstArrayView ranks = m_variable_synchronizer->communicatingRanks();
1878 Integer s = ranks.size();
1879 sub_domains.resize(s);
1880 sub_domains.copy(ranks);
1881}
1882
1883/*---------------------------------------------------------------------------*/
1884/*---------------------------------------------------------------------------*/
1885
1888{
1889 // Ne calcul les infos de synchronisation que si on est en parallèle
1890 // et que le nombre de parties est égal au nombre de rang du parallelMng(),
1891 // ce qui n'est pas le cas en reprise lors d'un changement du nombre de
1892 // sous-domaines.
1893 if (m_is_parallel && m_mesh->meshPartInfo().nbPart() == parallelMng()->commSize()) {
1894 m_variable_synchronizer->compute();
1896 }
1897}
1898
1899/*---------------------------------------------------------------------------*/
1900/*---------------------------------------------------------------------------*/
1901// TODO déplacer cette méthode en dehors de ItemFamily
1904{
1905 if (!v)
1906 return;
1907 if (v->itemFamily() != this && v->itemGroup().itemFamily() != this)
1908 throw ArgumentException(A_FUNCINFO, "Variable not in this family");
1910 op.setItemFamily(this);
1911 op.addVariable(v);
1912 op.applyOperation(operation);
1913}
1914
1915/*---------------------------------------------------------------------------*/
1916/*---------------------------------------------------------------------------*/
1917// TODO déplacer cette méthode en dehors de ItemFamily
1920{
1922 operation = v->dataFactoryMng()->createDataOperation(reduction);
1923 reduceFromGhostItems(v, operation.get());
1924}
1925
1926/*---------------------------------------------------------------------------*/
1927/*---------------------------------------------------------------------------*/
1928
1929Int64ArrayView* ItemFamily::
1930uniqueIds()
1931{
1932 return &m_items_unique_id_view;
1933}
1934
1935/*---------------------------------------------------------------------------*/
1936/*---------------------------------------------------------------------------*/
1937
1939findVariable(const String& var_name, bool throw_exception)
1940{
1942 StringBuilder vname = mesh()->name();
1943 vname += "_";
1944 vname += name();
1945 vname += "_";
1946 vname += var_name;
1947 IVariable* var = vm->findVariableFullyQualified(vname.toString());
1948 if (!var && throw_exception) {
1949 ARCANE_FATAL("No variable named '{0}' in family '{1}'", var_name, name());
1950 }
1951 return var;
1952}
1953
1954/*---------------------------------------------------------------------------*/
1955/*---------------------------------------------------------------------------*/
1956
1958clearItems()
1959{
1960 m_infos->clear();
1961
1962 endUpdate();
1963}
1964
1965/*---------------------------------------------------------------------------*/
1966/*---------------------------------------------------------------------------*/
1967
1970{
1971 Integer nb_item = unique_ids.size();
1972 Int64UniqueArray all_unique_ids;
1973 IParallelMng* pm = m_mesh->parallelMng();
1974 pm->allGatherVariable(unique_ids, all_unique_ids);
1975 HashTableMapT<Int64, Integer> items_map(nb_item * 2, true);
1976 info() << "ItemFamily::checkUniqueIds name=" << name() << " n=" << nb_item
1977 << " total=" << all_unique_ids.size();
1978 for (Integer i = 0; i < nb_item; ++i)
1979 items_map.add(unique_ids[i], 0);
1980 for (Integer i = 0, is = all_unique_ids.size(); i < is; ++i) {
1981 HashTableMapT<Int64, Integer>::Data* data = items_map.lookup(all_unique_ids[i]);
1982 if (data)
1983 ++data->value();
1984 }
1985 for (Integer i = 0; i < nb_item; ++i) {
1986 Integer nb_ref = items_map[unique_ids[i]];
1987 if (nb_ref != 1) {
1988 fatal() << "Duplicate unique_id=" << unique_ids[i];
1989 }
1990 }
1991}
1992
1993/*---------------------------------------------------------------------------*/
1994/*---------------------------------------------------------------------------*/
1995
1997findAdjencyItems(const ItemGroup& group, const ItemGroup& sub_group,
1998 eItemKind link_kind, Integer layer)
1999{
2000 return findAdjacencyItems(group, sub_group, link_kind, layer);
2001}
2002
2004findAdjacencyItems(const ItemGroup& group, const ItemGroup& sub_group,
2005 eItemKind link_kind, Integer layer)
2006{
2007 AdjacencyInfo at(group, sub_group, link_kind, layer);
2008 auto i = m_adjacency_groups.find(at);
2009
2010 if (i == m_adjacency_groups.end()) {
2011 debug() << "** BUILD ADJENCY_ITEMS : " << group.name() << " x "
2012 << sub_group.name() << " link=" << link_kind << " nblayer=" << layer;
2013 ItemPairGroup v(new ItemPairGroupImpl(group,sub_group));
2014 mesh()->utilities()->computeAdjacency(v, link_kind, layer);
2015 m_adjacency_groups.insert(std::make_pair(at, v));
2016 return v;
2017 }
2018 debug() << "** FOUND KNOWN ADJENCY_ITEMS! : " << group.name() << " x "
2019 << sub_group.name() << " link=" << link_kind << " nblayer=" << layer;
2020 return i->second;
2021}
2022
2023/*---------------------------------------------------------------------------*/
2024/*---------------------------------------------------------------------------*/
2025
2028{
2029 return m_local_connectivity_info;
2030}
2031
2032/*---------------------------------------------------------------------------*/
2033/*---------------------------------------------------------------------------*/
2034
2037{
2038 return m_global_connectivity_info;
2039}
2040
2041/*---------------------------------------------------------------------------*/
2042/*---------------------------------------------------------------------------*/
2043
2045setHasUniqueIdMap(bool v)
2046{
2047 ARCANE_UNUSED(v);
2048 throw NotSupportedException(A_FUNCINFO,"this kind of family doesn't support this function");
2049}
2050
2051/*---------------------------------------------------------------------------*/
2052/*---------------------------------------------------------------------------*/
2053
2055hasUniqueIdMap() const
2056{
2057 return true;
2058}
2059
2060/*---------------------------------------------------------------------------*/
2061/*---------------------------------------------------------------------------*/
2062
2064view(Int32ConstArrayView local_ids)
2065{
2066 return ItemVectorView(itemInfoListView(),local_ids);
2067}
2068
2069/*---------------------------------------------------------------------------*/
2070/*---------------------------------------------------------------------------*/
2071
2073view()
2074{
2075 return allItems().view();
2076}
2077
2078/*---------------------------------------------------------------------------*/
2079/*---------------------------------------------------------------------------*/
2080
2081void ItemFamily::
2082_addVariable(IVariable* var)
2083{
2084 //info() << "Add var=" << var->fullName() << " to family=" << name();
2085 if (var->itemFamily()!=this)
2086 ARCANE_FATAL("Can not add a variable to a different family");
2087 m_used_variables.insert(var);
2088}
2089
2090/*---------------------------------------------------------------------------*/
2091/*---------------------------------------------------------------------------*/
2092
2093void ItemFamily::
2094_removeVariable(IVariable* var)
2095{
2096 //info() << "Remove var=" << var->fullName() << " to family=" << name();
2097 m_used_variables.erase(var);
2098}
2099
2100/*---------------------------------------------------------------------------*/
2101/*---------------------------------------------------------------------------*/
2102
2105{
2106 for( IVariable* var : m_used_variables ){
2107 collection.add(var);
2108 }
2109}
2110
2111/*---------------------------------------------------------------------------*/
2112/*---------------------------------------------------------------------------*/
2113
2116{
2117 return m_variable_synchronizer.get();
2118}
2119
2120/*---------------------------------------------------------------------------*/
2121/*---------------------------------------------------------------------------*/
2122
2125{
2126 if (m_item_sort_function==sort_function)
2127 return;
2128 delete m_item_sort_function;
2129 m_item_sort_function = sort_function;
2130 if (!m_item_sort_function)
2131 m_item_sort_function = _defaultItemSortFunction();
2132}
2133
2134/*---------------------------------------------------------------------------*/
2135/*---------------------------------------------------------------------------*/
2136
2138itemSortFunction() const
2139{
2140 return m_item_sort_function;
2141}
2142
2143/*---------------------------------------------------------------------------*/
2144/*---------------------------------------------------------------------------*/
2145
2148{
2149 m_variable_synchronizer->synchronize(variables);
2150}
2151
2152/*---------------------------------------------------------------------------*/
2153/*---------------------------------------------------------------------------*/
2154
2157{
2158 m_variable_synchronizer->synchronize(variables, local_ids);
2159}
2160
2161/*---------------------------------------------------------------------------*/
2162/*---------------------------------------------------------------------------*/
2163
2166{
2167 ARCANE_UNUSED(unique_ids);
2168 ARCANE_UNUSED(items);
2169 ARCANE_UNUSED(owners);
2170 ARCANE_THROW(NotImplementedException,"this kind of family doesn't support this operation yet. Only DoF at present.");
2171}
2172
2173/*---------------------------------------------------------------------------*/
2174/*---------------------------------------------------------------------------*/
2175
2176void ItemFamily::
2177removeItems2(ItemDataList& item_data_list)
2178{
2179 if (!m_mesh->itemFamilyNetwork())
2180 ARCANE_FATAL("Family name='{0}': IMesh::itemFamilyNetwork() is null",name());
2181
2182 ItemData& item_data = item_data_list[itemKind()];
2183 // 1-Prepare : Get child connectivities and families
2184 SharedArray<IIncrementalItemConnectivity*> child_connectivities = m_mesh->itemFamilyNetwork()->getChildDependencies(this); // TODO : change return type ? (List to Array ?)
2185 UniqueArray<IItemFamily*> child_families;
2186 UniqueArray<IIncrementalItemConnectivity*> child_families_to_current_family;
2187 UniqueArray<ItemScalarProperty<bool>> child_families_has_extra_parent_properties; // To indicate wheter child items have other parents.
2188 Integer index = 0;
2189 for (auto child_connectivity : child_connectivities) {
2190 child_families.add(child_connectivity->targetFamily());
2191 child_families_to_current_family.add(m_mesh->itemFamilyNetwork()->getConnectivity(child_families.back(),this,connectivityName(child_families.back(),this)));
2192 if (child_families_to_current_family.back() == nullptr) fatal() << "removeItems2 needs reverse connectivity. Missing Connectivity " << connectivityName(child_families.back(),this);
2193 child_families_has_extra_parent_properties.add(ItemScalarProperty<bool>());
2194 child_families_has_extra_parent_properties.back().resize(child_families.back(),false);
2195 for (auto parent_connectivity : m_mesh->itemFamilyNetwork()->getParentDependencies(child_families.back())) { // exclure parent actuel
2196 if (parent_connectivity == child_connectivity) continue;
2197 ItemVector connected_items;
2198 _getConnectedItems(parent_connectivity,connected_items);
2199 _fillHasExtraParentProperty(child_families_has_extra_parent_properties[index],connected_items);
2200 }
2201 index++;
2202 }
2203 // 2-Propagates item removal to child families
2204 Int64ArrayView removed_item_lids = item_data.itemInfos().view(); // Todo change ItemData to store removed item lids in Int32
2205 for (auto removed_item_lid_int64 : removed_item_lids) {
2206 Int32 removed_item_lid = CheckedConvert::toInt32(removed_item_lid_int64);
2207 index = 0;
2208 for (auto child_connectivity : child_connectivities) {
2209 ConnectivityItemVector child_con_accessor(child_connectivity);
2210 ENUMERATE_ITEM(connected_item, child_con_accessor.connectedItems(ItemLocalId(removed_item_lid))) {
2211 if (!this->itemsInternal()[removed_item_lid]->isDetached()) {// test necessary when doing removeDetached (the relations are already deleted).
2212 child_families_to_current_family[index]->removeConnectedItem(ItemLocalId(connected_item),ItemLocalId(removed_item_lid));
2213 }
2214 // Check if connected item is to remove
2215 if (! child_families_has_extra_parent_properties[index][connected_item] && child_families_to_current_family[index]->nbConnectedItem(ItemLocalId(connected_item)) == 0) {
2216 item_data_list[child_connectivity->targetFamily()->itemKind()].itemInfos().add((Int64) connected_item.localId());
2217 }
2218 }
2219 index++;
2220 }
2221 }
2222 // => merge this loop with previous one ?
2223 // 3-1 Remove relations for child relations
2224 for (auto removed_item_lid_int64 : removed_item_lids) {
2225 Int32 removed_item_lid = CheckedConvert::toInt32(removed_item_lid_int64);
2226 for (auto child_relation : m_mesh->itemFamilyNetwork()->getChildRelations(this)) {
2227 ConnectivityItemVector connectivity_accessor(child_relation);
2228 ENUMERATE_ITEM(connected_item, connectivity_accessor.connectedItems(ItemLocalId(removed_item_lid))) {
2229 child_relation->removeConnectedItem(ItemLocalId(removed_item_lid),ItemLocalId(connected_item));
2230 }
2231 }
2232 }
2233 // 3-2 Remove relations for parent relations
2234 ItemScalarProperty<bool> is_removed_item;
2235 is_removed_item.resize(this,false);
2236 for (auto removed_item_lid_int64 : removed_item_lids) {
2237 Int32 removed_item_lid = CheckedConvert::toInt32(removed_item_lid_int64);
2238 is_removed_item[*(this->itemsInternal()[removed_item_lid])] = true;
2239 }
2240 for (auto parent_relation : m_mesh->itemFamilyNetwork()->getParentRelations(this)) {
2241 for (auto source_item : parent_relation->sourceFamily()->itemsInternal()) {
2242 if (source_item->isSuppressed()) continue;
2243 ConnectivityItemVector connectivity_accessor(parent_relation);
2244 ENUMERATE_ITEM(connected_item, connectivity_accessor.connectedItems(ItemLocalId(source_item))) {
2245 if (is_removed_item[connected_item])
2246 parent_relation->removeConnectedItem(ItemLocalId(source_item),connected_item);
2247 }
2248 }
2249 }
2250 // 4-Remove items. Child items will be removed by an automatic call of removeItems2 on their family...
2251 for (auto removed_item_lid_int64 : removed_item_lids) {
2252 Int32 removed_item_lid = CheckedConvert::toInt32(removed_item_lid_int64);
2253 ItemInternal* removed_item = m_infos->itemInternal(removed_item_lid);
2254 if (removed_item->isDetached()) {
2255 m_infos->removeDetachedOne(removed_item);
2256 }
2257 else {
2258 m_infos->removeOne(removed_item);
2259 }
2260 }
2261 this->endUpdate();// endUpdate is needed since we then go deeper in the dependency graph and will need to enumerate this changed family.
2262}
2263
2264/*---------------------------------------------------------------------------*/
2265/*---------------------------------------------------------------------------*/
2266
2267void ItemFamily::
2268_getConnectedItems(IIncrementalItemConnectivity* parent_connectivity,ItemVector& target_family_connected_items)
2269{
2270 ConnectivityItemVector connectivity_accessor(parent_connectivity);
2271 for(auto source_item : parent_connectivity->sourceFamily()->itemsInternal()) {
2272 if (source_item->isSuppressed()) continue;
2273 target_family_connected_items.add(connectivity_accessor.connectedItems(ItemLocalId(source_item)).localIds());
2274 }
2275}
2276
2277/*---------------------------------------------------------------------------*/
2278/*---------------------------------------------------------------------------*/
2279
2280void ItemFamily::
2281_fillHasExtraParentProperty(ItemScalarProperty<bool>& child_families_has_extra_parent,ItemVectorView connected_items)
2282{
2283 ENUMERATE_ITEM(connected_item, connected_items) {
2284 child_families_has_extra_parent[connected_item] = true;
2285 }
2286}
2287
2288/*---------------------------------------------------------------------------*/
2289/*---------------------------------------------------------------------------*/
2290
2291void ItemFamily::
2292_detachCells2(Int32ConstArrayView local_ids)
2293{
2294 //- Only cells are detached, ie no parent dependencies are to be found
2295 ARCANE_ASSERT((m_mesh->itemFamilyNetwork()->getParentDependencies(this).empty()),("Only cells are detached, no parent dependencies are to be found."))
2296 // Remove all the relations parent and child. Keep child dependencies => used when removing detach cells. No parent dependencies
2297 // 1 Remove relations for child relations
2298 for (auto removed_item_lid : local_ids) {
2299 for (auto child_relation : m_mesh->itemFamilyNetwork()->getChildRelations(this)) {
2300 ConnectivityItemVector connectivity_accessor(child_relation);
2301 ENUMERATE_ITEM(connected_item, connectivity_accessor.connectedItems(ItemLocalId(removed_item_lid))) {
2302 child_relation->removeConnectedItem(ItemLocalId(removed_item_lid),ItemLocalId(connected_item));
2303 }
2304 }
2305 }
2306 // 2 Remove relations for parent relations
2307 ItemScalarProperty<bool> is_detached_item;
2308 is_detached_item.resize(this,false);
2309 for (auto detached_item_lid : local_ids) {
2310 is_detached_item[*(this->itemsInternal()[detached_item_lid])] = true;
2311 }
2312 for (auto parent_relation : m_mesh->itemFamilyNetwork()->getParentRelations(this)) {
2313 for(auto source_item : parent_relation->sourceFamily()->itemsInternal()) {
2314 if (source_item->isSuppressed()) continue;
2315 ConnectivityItemVector connectivity_accessor(parent_relation);
2316 ENUMERATE_ITEM(connected_item, connectivity_accessor.connectedItems(ItemLocalId(source_item))) {
2317 if (is_detached_item[connected_item]) {
2318 parent_relation->removeConnectedItem(ItemLocalId(source_item),connected_item);
2319 }
2320 }
2321 }
2322 }
2323 // 4-Detach items.
2324 for (auto detached_item_lid : local_ids) {
2325 m_infos->detachOne(m_infos->itemInternal(detached_item_lid)); // when family/mesh endUpdate is done ? needed ?
2326 }
2327}
2328
2329/*---------------------------------------------------------------------------*/
2330/*---------------------------------------------------------------------------*/
2331
2334{
2335 ItemInternalMap& item_map = itemsMap();
2336 if (item_map.count()==0)
2337 return;
2338
2339 if (!m_mesh->itemFamilyNetwork())
2340 ARCANE_FATAL("Family name='{0}': IMesh::itemFamilyNetwork() is null",name());
2341 if (!IItemFamilyNetwork::plug_serializer)
2342 ARCANE_FATAL("family name='{0}': removeNeedMarkedItems() cannot be called if ItemFamilyNetwork is unplugged.",name());
2343
2344 UniqueArray<ItemInternal*> items_to_remove;
2345 UniqueArray<Int32> items_to_remove_lids;
2346 items_to_remove.reserve(1000);
2347 items_to_remove_lids.reserve(1000);
2348
2349 item_map.eachItem([&](impl::ItemBase item) {
2350 Integer f = item.flags();
2351 if (f & ItemFlags::II_NeedRemove){
2352 f &= ~ItemFlags::II_NeedRemove & ItemFlags::II_Suppressed;
2353 item.toMutable().setFlags(f);
2354 items_to_remove.add(item._itemInternal());
2355 items_to_remove_lids.add(item.localId());
2356 }
2357 });
2358 info() << "Number of " << itemKind() << " of family "<< name()<<" to remove: " << items_to_remove.size();
2359 if (items_to_remove.size() == 0)
2360 return;
2361
2362 // Update connectivities => remove all con pointing on the removed items
2363 // Todo the nearly same procedure is done in _detachCells2 : mutualize in a method (watchout the connectivities used are parentConnectivities or parentRelations...)
2364 ItemScalarProperty<bool> is_removed_item;
2365 is_removed_item.resize(this,false);
2366 for (auto removed_item: items_to_remove) {
2367 is_removed_item[*removed_item] = true;
2368 }
2369 //for (auto parent_connectivity : m_mesh->itemFamilyNetwork()->getParentConnectivities(this)) {
2370 for (auto parent_connectivity : m_mesh->itemFamilyNetwork()->getParentRelations(this)) {
2371 for(auto source_item : parent_connectivity->sourceFamily()->itemsInternal()) {
2372 if (source_item->isSuppressed()) continue;
2373 ConnectivityItemVector connectivity_accessor(parent_connectivity);
2374 ENUMERATE_ITEM(connected_item, connectivity_accessor.connectedItems(ItemLocalId(source_item))) {
2375 if (is_removed_item[connected_item]) {
2376 parent_connectivity->removeConnectedItem(ItemLocalId(source_item),connected_item);
2377 }
2378 }
2379 }
2380 }
2381 // Remove items
2382 m_infos->removeMany(items_to_remove_lids);
2383}
2384
2385/*---------------------------------------------------------------------------*/
2386/*---------------------------------------------------------------------------*/
2387
2389{
2390 public:
2391 bool operator()(const ItemInternal* item1,const ItemInternal* item2) const
2392 {
2393 // Il faut mettre les entités détruites en fin de liste
2394 //cout << "Compare: " << item1->uniqueId() << " " << item2->uniqueId() << '\n';
2395 bool s1 = item1->isSuppressed();
2396 bool s2 = item2->isSuppressed();
2397 if (s1 && !s2)
2398 return false;
2399 if (!s1 && s2)
2400 return true;
2401 return item1->uniqueId() < item2->uniqueId();
2402 }
2403};
2404
2405/*---------------------------------------------------------------------------*/
2406/*---------------------------------------------------------------------------*/
2407
2408IItemInternalSortFunction* ItemFamily::
2409_defaultItemSortFunction()
2410{
2412}
2413
2414/*---------------------------------------------------------------------------*/
2415/*---------------------------------------------------------------------------*/
2416
2417void ItemFamily::
2418setPolicyMng(IItemFamilyPolicyMng* policy_mng)
2419{
2420 if (m_policy_mng==policy_mng)
2421 return;
2422 if (m_policy_mng)
2423 ARCANE_FATAL("PolicyMng already set");
2424 m_policy_mng = policy_mng;
2425}
2426
2427/*---------------------------------------------------------------------------*/
2428/*---------------------------------------------------------------------------*/
2429
2430void ItemFamily::
2431addSourceConnectivity(IItemConnectivity* connectivity)
2432{
2433 m_source_item_connectivities.insert(connectivity);
2434}
2435
2436/*---------------------------------------------------------------------------*/
2437/*---------------------------------------------------------------------------*/
2438
2439void ItemFamily::
2440addTargetConnectivity(IItemConnectivity* connectivity)
2441{
2442 m_target_item_connectivities.insert(connectivity);
2443}
2444
2445/*---------------------------------------------------------------------------*/
2446/*---------------------------------------------------------------------------*/
2447
2448void ItemFamily::
2449removeSourceConnectivity(IItemConnectivity* connectivity)
2450{
2451 m_source_item_connectivities.erase(m_source_item_connectivities.find(connectivity));
2452}
2453
2454/*---------------------------------------------------------------------------*/
2455/*---------------------------------------------------------------------------*/
2456
2457void ItemFamily::
2458removeTargetConnectivity(IItemConnectivity* connectivity)
2459{
2461}
2462
2463/*---------------------------------------------------------------------------*/
2464/*---------------------------------------------------------------------------*/
2465
2466void ItemFamily::
2467setConnectivityMng(IItemConnectivityMng* connectivity_mng)
2468{
2469 ARCANE_ASSERT((m_connectivity_mng == NULL || m_connectivity_mng== connectivity_mng),
2470 ("Connectivity Manager must be unique") )
2471 m_connectivity_mng = connectivity_mng;
2472}
2473
2474/*---------------------------------------------------------------------------*/
2475/*---------------------------------------------------------------------------*/
2476
2479{
2480 return m_infos->itemListChangedEvent();
2481}
2482
2483/*---------------------------------------------------------------------------*/
2484/*---------------------------------------------------------------------------*/
2485
2488{
2489 ItemInternal* iitem = _itemInternal(local_id);
2490 Int64 old_uid = iitem->uniqueId();
2491 if (old_uid==unique_id)
2492 return;
2493 //MutableItemBase item_base(local_id,m_common_item_shared_info);
2494 iitem->setUniqueId(unique_id);
2495
2496 if (m_infos->hasUniqueIdMap()){
2497 ItemInternalMap& item_map = itemsMap();
2498 item_map.remove(old_uid);
2499 item_map.add(unique_id,iitem);
2500 }
2501}
2502
2503/*---------------------------------------------------------------------------*/
2504/*---------------------------------------------------------------------------*/
2505
2506void ItemFamily::
2507_addSourceConnectivity(IIncrementalItemSourceConnectivity* c)
2508{
2509 m_source_incremental_item_connectivities.add(c->toSourceReference());
2510}
2511
2512/*---------------------------------------------------------------------------*/
2513/*---------------------------------------------------------------------------*/
2514
2515void ItemFamily::
2516_addTargetConnectivity(IIncrementalItemTargetConnectivity* c)
2517{
2518 m_target_incremental_item_connectivities.add(c->toTargetReference());
2519}
2520
2521/*---------------------------------------------------------------------------*/
2522/*---------------------------------------------------------------------------*/
2523
2524void ItemFamily::
2525_checkValidConnectivity()
2526{
2527 {
2528 // Vérifie qu'il n'y a pas d'entité nulle.
2530 Item item = *i;
2531 if (item.null())
2532 ARCANE_FATAL("family={0}: local item lid={1} is null",fullName(),item);
2533 }
2534 }
2535 {
2536 // Vérifie la cohérence de la partie interne
2538 Item item = *i;
2539 Item i1 = item;
2540 Item i2 = m_common_item_shared_info->m_items_internal[item.localId()];
2541 if (i1!=i2)
2542 ARCANE_FATAL("family={0}: incoherent item internal lid={1} i1={2} i2={3}",
2543 fullName(),item.localId(),ItemPrinter(i1),ItemPrinter(i2));
2544 }
2545 }
2546 constexpr Int32 MAX_KIND = ItemInternalConnectivityList::MAX_ITEM_KIND;
2547 std::array<Int32,MAX_KIND> computed_max;
2548 computed_max.fill(0);
2549
2550 for( Integer i=0; i<MAX_KIND; ++i ){
2551 eItemKind target_kind = static_cast<eItemKind>(i);
2552 IndexedItemConnectivityViewBase con_view{m_item_connectivity_list.containerView(i),itemKind(),target_kind};
2553 Int32 stored_max_nb = m_item_connectivity_list.maxNbConnectedItem(i);
2554 const Int32 con_nb_item_size = con_view.nbSourceItem();
2555
2556 info(4) << "Family name=" << fullName() << " I=" << i << " nb_item_size=" << con_nb_item_size;
2557
2558 Int32 max_nb = 0;
2559 if (con_nb_item_size!=0){
2560 // Il faut itérer sur toutes les entités et pas sur \a con_nb_item
2561 // car certaines valeurs peuvent ne pas être valides s'il y a des
2562 // trous dans la numérotation.
2564 Int32 x = con_view.nbItem(i);
2565 if (x>max_nb)
2566 max_nb = x;
2567 }
2568 if (stored_max_nb<max_nb)
2569 ARCANE_FATAL("Bad value for max connected item family={0} kind={1} stored={2} computed={3}",
2570 name(),i,stored_max_nb,max_nb);
2571 computed_max[i] = max_nb;
2572 }
2573 }
2574 // Vérifie que la valeur retournée par m_local_connectivity_info
2575 // est au moins supérieure à 'computed_max'
2576 {
2577 std::array<Int32,MAX_KIND> stored_max;
2578 stored_max.fill(0);
2579 auto* ci = m_local_connectivity_info;
2580 stored_max[ItemInternalConnectivityList::NODE_IDX] = ci->maxNodePerItem();
2581 stored_max[ItemInternalConnectivityList::EDGE_IDX] = ci->maxEdgePerItem();
2582 stored_max[ItemInternalConnectivityList::FACE_IDX] = ci->maxFacePerItem();
2583 stored_max[ItemInternalConnectivityList::CELL_IDX] = ci->maxCellPerItem();
2584 // Pour les deux suivants, il n'y a pas l'équivalent dans 'ItemConnectivityInfo' donc
2585 // on mets les valeurs calculées pour ne pas générer d'erreur.
2586 stored_max[ItemInternalConnectivityList::HPARENT_IDX] = computed_max[ItemInternalConnectivityList::HPARENT_IDX];
2587 stored_max[ItemInternalConnectivityList::HCHILD_IDX] = computed_max[ItemInternalConnectivityList::HCHILD_IDX];
2588 for( Integer i=0; i<MAX_KIND; ++i )
2589 if (stored_max[i]<computed_max[i])
2590 ARCANE_FATAL("Bad value for local_connectivity_info family={0} kind={1} stored={2} computed={3}",
2591 name(),i,stored_max[i],computed_max[i]);
2592 }
2593 for( auto ics : m_connectivity_selector_list )
2594 ics->checkValidConnectivityList();
2595}
2596
2597/*---------------------------------------------------------------------------*/
2598/*---------------------------------------------------------------------------*/
2599
2600void ItemFamily::
2601_addConnectivitySelector(ItemConnectivitySelector* selector)
2602{
2603 m_connectivity_selector_list.add(selector);
2604}
2605
2606/*---------------------------------------------------------------------------*/
2607/*---------------------------------------------------------------------------*/
2608
2609void ItemFamily::
2610_buildConnectivitySelectors()
2611{
2612 m_connectivity_selector_list_by_item_kind.clear();
2613 m_connectivity_selector_list_by_item_kind.resize(ItemInternalConnectivityList::MAX_ITEM_KIND);
2614 m_connectivity_selector_list_by_item_kind.fill(nullptr);
2615
2616 for( ItemConnectivitySelector* ics : m_connectivity_selector_list ){
2617 ics->build();
2618 Int32 i = ics->itemConnectivityIndex();
2619 if (i>=0){
2620 if (m_connectivity_selector_list_by_item_kind[i])
2621 ARCANE_FATAL("Can not have two connectivity selector for same item kind");
2622 m_connectivity_selector_list_by_item_kind[i] = ics;
2623 }
2624 }
2625}
2626
2627/*---------------------------------------------------------------------------*/
2628/*---------------------------------------------------------------------------*/
2629
2630void ItemFamily::
2631_setTopologyModifier(IItemFamilyTopologyModifier* tm)
2632{
2633 delete m_topology_modifier;
2634 m_topology_modifier = tm;
2635}
2636
2637/*---------------------------------------------------------------------------*/
2638/*---------------------------------------------------------------------------*/
2648{
2649 ItemInternalList items(_itemsInternal());
2650 for( Integer i=0, n=items.size(); i<n; ++i )
2651 items[i]->removeFlags(ItemFlags::II_Shared);
2652 Int32ConstArrayView comm_ranks = m_variable_synchronizer->communicatingRanks();
2653 Integer nb_rank = comm_ranks.size();
2654 // Parcours les sharedItems() du synchroniseur et positionne le flag
2655 // II_Shared pour les entités de la liste.
2656 for( Integer i=0; i<nb_rank; ++i ){
2657 Int32ConstArrayView shared_ids = m_variable_synchronizer->sharedItems(i);
2658 for( auto id : shared_ids )
2659 items[id]->addFlags(ItemFlags::II_Shared);
2660 }
2661}
2662
2663/*---------------------------------------------------------------------------*/
2664/*---------------------------------------------------------------------------*/
2665
2666void ItemFamily::
2667_computeConnectivityInfo(ItemConnectivityInfo* ici)
2668{
2669 ici->fill(itemInternalConnectivityList());
2670 info(5) << "COMPUTE CONNECTIVITY INFO family=" << name() << " v=" << ici
2671 << " node=" << ici->maxNodePerItem() << " face=" << ici->maxFacePerItem()
2672 << " edge=" << ici->maxEdgePerItem() << " cell=" << ici->maxCellPerItem();
2673}
2674
2675/*---------------------------------------------------------------------------*/
2676/*---------------------------------------------------------------------------*/
2677
2678void ItemFamily::
2679_handleOldCheckpoint()
2680{
2681 // Pas besoin de gérer 'm_items_type_id' car il n'est pas présent dans
2682 // les anciennes protections.
2683 _offsetArrayByOne(m_items_unique_id);
2684 _offsetArrayByOne(m_items_flags);
2685 _offsetArrayByOne(m_items_owner);
2686 (*m_items_unique_id)[0] = NULL_ITEM_UNIQUE_ID;
2687 (*m_items_flags)[0] = 0;
2688 (*m_items_owner)[0] = A_NULL_RANK;
2689}
2690
2691/*---------------------------------------------------------------------------*/
2692/*---------------------------------------------------------------------------*/
2693
2694namespace
2695{
2696
2697// Retourne une vue qui commence sur le dexuème élément du tableau.
2698template<typename DataType>
2699ArrayView<DataType> _getView(Array<DataType>* v)
2700{
2701 Int32 n = v->size();
2702 return v->subView(1,n-1);
2703 }
2704
2705}
2706
2707void ItemFamily::
2708_updateItemViews()
2709{
2710 m_common_item_shared_info->m_unique_ids = _getView(m_items_unique_id);
2711 m_common_item_shared_info->m_flags = _getView(m_items_flags);
2712 m_common_item_shared_info->m_type_ids = _getView(m_items_type_id);
2713 m_common_item_shared_info->m_owners = _getView(m_items_owner);
2714 m_common_item_shared_info->m_parent_item_ids = m_items_nb_parent->view();
2715
2716 m_items_unique_id_view = _getView(m_items_unique_id);
2717}
2718
2719/*---------------------------------------------------------------------------*/
2720/*---------------------------------------------------------------------------*/
2721
2722void ItemFamily::
2723_addOnSizeChangedObservable(VariableRef& var_ref)
2724{
2725 m_observers.addObserver(this,&ItemFamily::_updateItemViews,
2726 var_ref.variable()->onSizeChangedObservable());
2727}
2728
2729/*---------------------------------------------------------------------------*/
2730/*---------------------------------------------------------------------------*/
2731
2734{
2735 return m_internal_api;
2736}
2737
2738/*---------------------------------------------------------------------------*/
2739/*---------------------------------------------------------------------------*/
2740
2741} // End namespace Arcane::mesh
2742
2743/*---------------------------------------------------------------------------*/
2744/*---------------------------------------------------------------------------*/
#define ARCANE_CHECK_POINTER(ptr)
Macro retournant le pointeur ptr s'il est non nul ou lancant une exception s'il est nul.
#define ARCANE_THROW(exception_class,...)
Macro pour envoyer une exception avec formattage.
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
#define ENUMERATE_ITEM(name, group)
Enumérateur générique d'un groupe de noeuds.
bool checkResizeArray(Array< DataType > &array, Int64 new_size, bool force_resize)
Redimensionne un tableau qui est indexé par des 'ItemLocalId'.
Definition MeshUtils.h:391
Integer size() const
Nombre d'éléments du vecteur.
Exception lorsqu'un argument est invalide.
constexpr Integer size() const noexcept
Retourne la taille du tableau.
void resize(Int64 s)
Change le nombre d'éléments du tableau à s.
void reserve(Int64 new_capacity)
Réserve le mémoire pour new_capacity éléments.
void copy(Span< const T > rhs)
Copie les valeurs de rhs dans l'instance.
ArrayView< T > view() const
Vue mutable sur ce tableau.
void add(ConstReferenceType val)
Ajoute l'élément val à la fin du tableau.
T & back()
Dernier élément du tableau.
Gère la récupération des informations de connectivité.
ItemVectorView connectedItems(ItemLocalId item)
Retourne les entités connectées à item.
Vue constante d'un tableau de type T.
constexpr Integer size() const noexcept
Nombre d'éléments du tableau.
constexpr bool empty() const noexcept
true si le tableau est vide (size()==0)
static std::optional< Int32 > tryParseFromEnvironment(StringView s, bool throw_if_invalid)
Definition Convert.cc:122
Classe gérant les observateurs associés à un évènement.
Definition Event.h:248
Table de hachage pour tableaux associatifs.
Data * lookup(KeyTypeConstRef id)
Recherche la valeur correspondant à la clé id.
bool add(KeyTypeConstRef id, const ValueType &value)
Ajoute la valeur value correspondant à la clé id.
virtual IDataOperation * createDataOperation(Parallel::eReduceType rt)=0
Créé une opération effectuant une réduction de type rt.
Interface d'une opération sur une donnée.
Interface de la source d'une connectivité incrémentale.
virtual Ref< IIncrementalItemSourceConnectivity > toSourceReference()=0
Retourne une référence sur l'instance.
Interface de la cible d'une connectivité incrémentale.
virtual Ref< IIncrementalItemTargetConnectivity > toTargetReference()=0
Retourne une référence sur l'instance.
Interface des informations sur la connectivité par type d'entité.
virtual void notifyLocalIdChanged(IItemFamily *item_family, Int32ConstArrayView old_to_new_ids, Integer nb_item)=0
Mise à jour des items modifiés éventuellement compactés.
Interface pour gérer une connectivité.
Partie interne de IItemFamily.
virtual IIncrementalItemConnectivity * getConnectivity(IItemFamily *source_family, IItemFamily *target_family, const String &name)=0
Retourne la connectivité entre les familles source_family et target_family de nom name,...
virtual SharedArray< IIncrementalItemConnectivity * > getChildDependencies(IItemFamily *source_family)=0
Obtenir la liste de toutes les dépendances, filles d'une famille source_family ou parentes d'une fami...
Interface des politiques d'une famille d'entités.
Interface de modification de la topologie des entités d'une famille.
Interface d'une famille d'entités.
Definition IItemFamily.h:84
virtual Integer parentFamilyDepth() const =0
Donne la profondeur d'imbrication du maillage courant.
virtual ItemInternalArrayView itemsInternal()=0
Tableau interne des entités.
virtual void notifyItemsOwnerChanged()=0
Notifie que les entités propres au sous-domaine de la famille ont été modifiées.
Interface d'une fonction de tri des entités.
virtual String name() const =0
Nom du maillage.
virtual IItemFamily * findItemFamily(eItemKind ik, const String &name, bool create_if_needed=false, bool register_modifier_if_created=false)=0
Retourne la famille de nom name.
Interface du gestionnaire des compactages de familles d'un maillage.
virtual void endCompact()=0
Signale que le compactage est terminé.
virtual IMeshCompacter * beginCompact()=0
Débute un compactage sur toutes les familles du maillage.
Gestion d'un compactage de familles du maillage.
virtual void setSorted(bool v)=0
Indique s'il faut trier les entités lors du compactage.
virtual void doAllActions()=0
Exécute successivement toutes les actions de compactage.
Interface du gestionnaire des maillages.
Definition IMeshMng.h:40
virtual MeshHandle * findMeshHandle(const String &name, bool throw_exception)=0
Recherche le maillage de nom name.
virtual void computeAdjacency(const ItemPairGroup &adjacency_array, eItemKind link_kind, Integer nb_layer)
Calcul des adjacences, rangées dans adjacency_array.
virtual IParallelMng * parallelMng()=0
Gestionnaire de parallèlisme.
virtual IMeshUtilities * utilities()=0
Interface des fonctions utilitaires associée.
virtual ItemTypeMng * itemTypeMng() const =0
Gestionnaire de types d'entités associé
virtual IItemFamilyNetwork * itemFamilyNetwork()=0
Interface du réseau de familles (familles connectées)
virtual IMeshCompactMng * _compactMng()=0
virtual const MeshPartInfo & meshPartInfo() const =0
Informations sur les parties du maillage.
Interface du gestionnaire de parallélisme pour un sous-domaine.
virtual void allGatherVariable(ConstArrayView< char > send_buf, Array< char > &recv_buf)=0
Effectue un regroupement sur tous les processeurs.
virtual void build()=0
Construit l'instance.
virtual char reduce(eReduceType rt, char v)=0
Effectue la réduction de type rt sur le réel v et retourne la valeur.
Interface du gestionnaire d'un sous-domaine.
Definition ISubDomain.h:74
virtual IVariableMng * variableMng()=0
Retourne le gestionnaire de variables.
Interface du gestionnaire de traces.
Interface du gestionnaire de variables.
virtual IVariable * findVariableFullyQualified(const String &name)=0
Retourne la variable de nom complet name ou 0 si aucune de se nom existe.
Interface d'un service de synchronisation de variable.
virtual void changeLocalIds(Int32ConstArrayView old_to_new_ids)=0
Appelé lorsque les numéros locaux des entités sont modifiés.
Interface d'une variable.
Definition IVariable.h:56
virtual String fullName() const =0
Nom complet de la variable (avec le préfixe de la famille)
@ PSubDomainDepend
Indique que la valeur de la variable est dépendante du sous-domaine.
Definition IVariable.h:93
@ PTemporary
Indique que la variable est temporaire.
Definition IVariable.h:128
@ PExecutionDepend
Indique que la valeur de la variable est dépendante de l'exécution.
Definition IVariable.h:108
@ PPrivate
Indique que la variable est privée.
Definition IVariable.h:116
@ PNoRestore
Indique que la variable ne doit pas être restaurée.
Definition IVariable.h:135
@ PNoDump
Indique que la variable ne doit pas être sauvegardée.
Definition IVariable.h:74
virtual int property() const =0
Retourne les propriétés de la variable.
virtual IDataFactoryMng * dataFactoryMng() const =0
Fabrique de données associées à la variable.
virtual void resizeFromGroup()=0
Positionne le nombre d'éléments pour une variable du maillage.
virtual ItemGroup itemGroup() const =0
Groupe du maillage associé.
virtual void compact(Int32ConstArrayView new_to_old_ids)=0
Compacte les valeurs de la variable.
virtual void copyItemsMeanValues(Int32ConstArrayView first_source, Int32ConstArrayView second_source, Int32ConstArrayView destination)=0
Copie les moyennes des valeurs des entités numéros first_source et second_source dans les entités num...
virtual IItemFamily * itemFamily() const =0
Famille d'entité associée.
virtual void copyItemsValues(Int32ConstArrayView source, Int32ConstArrayView destination)=0
Copie les valeurs des entités numéros source dans les entités numéro destination.
bool isSuppressed() const
Vrai si l'entité est supprimée.
ItemUniqueId uniqueId() const
Numéro unique de l'entité
MutableItemBase toMutable()
Interface modifiable de cette entité
Int32 flags() const
Flags de l'entité
ItemTypeInfo * typeInfo() const
Type de l'entité.
Int32 localId() const
Numéro local (au sous-domaine) de l'entité
Informations pour gérer le compactage des entités d'une famille.
Int32ConstArrayView newToOldLocalIds() const
Conversion entre les nouveaux et les anciens id locaux.
Int32ConstArrayView oldToNewLocalIds() const
Conversion entre les anciens et les nouveaux id locaux.
Arguments de l'évènement pour l'ajout ou la supression d'entités.
Flags pour les caractéristiques des entités.
Definition ItemFlags.h:31
@ II_NeedRemove
L'entité doit être supprimé
Definition ItemFlags.h:55
@ II_Shared
L'entité est partagée par un autre sous-domaine.
Definition ItemFlags.h:51
@ II_Suppressed
L'entité vient d'être supprimée.
Definition ItemFlags.h:50
Implémentation d'un groupe d'entités de maillage.
bool checkNeedUpdate()
Réactualise le groupe si nécessaire.
void destroy()
Détruit le groupe. Après cet appel, le groupe devient un groupe nul.
void removeSuppressedItems()
Supprime du groupe les entités dont le flag isSuppressed() est vrai.
bool hasComputeFunctor() const
Indique si le groupe est calculé
ItemGroup parentGroup()
Groupe parent.
void changeIds(Int32ConstArrayView old_to_new_ids)
Change les indices des entités du groupe.
Groupe d'entités de maillage.
Definition ItemGroup.h:49
ItemGroupImpl * internal() const
Retourne l'implémentation du groupe.
Definition ItemGroup.h:120
IVariableSynchronizer * synchronizer() const
Synchronizer du groupe.
Definition ItemGroup.cc:618
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
ItemVectorView view() const
Vue sur les entités du groupe.
Definition ItemGroup.cc:582
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
void setItems(Int32ConstArrayView items_local_id)
Positionne les entités du groupe.
Definition ItemGroup.cc:488
eItemKind itemKind() const
Genre du groupe. Il s'agit du genre de ses éléments.
Definition ItemGroup.h:109
bool hasSynchronizer() const
Indique si le groupe possède un synchroniser actif.
Definition ItemGroup.cc:636
bool isAllItems() const
Indique si le groupe est celui de toutes les entités.
Definition ItemGroup.cc:609
void checkValid()
Vérification interne de la validité du groupe.
Definition ItemGroup.cc:521
bool null() const
true is le groupe est le groupe nul
Definition ItemGroup.h:70
void setOwn(bool v)
Positionne la propriété de groupe local ou non.
Definition ItemGroup.cc:169
Vue sur une liste pour obtenir des informations sur les entités.
Informations de connectivité, pour une famille d'entité, permettant la transition entre les anciennes...
Interface d'une fonction de tri des entités.
Structure interne d'une entité de maillage.
Index d'un Item dans une variable.
Definition ItemLocalId.h:41
Implémentation d'un tableau de listes d'entités.
Tableau de listes d'entités.
Structure interne partagée d'une entité de maillage.
Type d'une entité (Item).
Definition ItemTypeId.h:32
Gestionnaire des types d'entités de maillage.
Definition ItemTypeMng.h:66
ItemTypeInfo * typeFromId(Integer id) const
Type correspondant au numéro id.
Identifiant unique d'une entité.
Vue sur un vecteur d'entités.
Vecteur d'entités.
Definition ItemVector.h:59
Classe de base d'un élément de maillage.
Definition Item.h:83
Int32 owner() const
Numéro du sous-domaine propriétaire de l'entité
Definition Item.h:238
ItemUniqueId uniqueId() const
Identifiant unique sur tous les domaines.
Definition Item.h:225
Implémentation d'une collection d'éléments sous forme de vecteur.
Definition List.h:222
ListEnumeratorT< ItemGroup > Enumerator
Definition List.h:243
IMesh * mesh() const
Maillage associé.
Informations un maillage partitionné.
void setOwner(Integer suid, Int32 current_sub_domain)
Positionne le numéro du sous-domaine propriétaire de l'entité.
void setFlags(Int32 f)
Positionne les flags de l'entité
void setParent(Int32 aindex, Int32 parent_local_id)
Positionne le i-ème parent (actuellement aindex doit valoir 0)
Exception lorsqu'une fonction n'est pas implémentée.
Exception lorsqu'une opération n'est pas supportée.
void applyOperation(IDataOperation *operation) override
Applique l'opération.
void addVariable(IVariable *variable) override
Ajoute variable à la liste des variables concernées par l'opération.
void setItemFamily(IItemFamily *family) override
Positionne la famille d'entité sur laquelle on souhaite opérer.
Liste de propriétés.
Definition Properties.h:64
T * get() const
Retourne l'objet référé par l'instance.
Definition Ptr.h:121
Encapsulation d'un pointeur qui se détruit automatiquement.
Definition ScopedPtr.h:44
Vecteur 1D de données avec sémantique par référence.
Constructeur de chaîne de caractère unicode.
String toString() const
Retourne la chaîne de caractères construite.
Chaîne de caractères unicode.
TraceAccessor(ITraceMng *m)
Construit un accesseur via le gestionnaire de trace m.
TraceMessageDbg debug(Trace::eDebugLevel=Trace::Medium) const
Flot pour un message de debug.
TraceMessage fatal() const
Flot pour un message d'erreur fatale.
TraceMessage info() const
Flot pour un message d'information.
ITraceMng * traceMng() const
Gestionnaire de trace.
Vecteur 1D de données avec sémantique par valeur (style STL).
Paramètres nécessaires à la construction d'une variable.
Collection de variables.
IVariable * variable() const
Variable associée.
Infos de maillage pour un genre donné d'entité.
Informations sur la connectivité par type d'entité.
Integer maxNodePerItem() const override
Nombre maximal de noeuds par entité
Integer maxCellPerItem() const override
Nombre maximal de mailles par entité
Integer maxFacePerItem() const override
Nombre maximal de faces par entité
Integer maxEdgePerItem() const override
Nombre maximal d'arêtes par entité
Sélection entre les connectivités historiques et à la demande.
void resizeVariables(bool force_resize) override
Redimensionne les variables de cette famille.
void removeVariable(IVariable *var) override
Supprime une variable à cette famille.
void notifyEndUpdateFromMesh() override
Indique une fin de modification par le maillage.
ItemInternalConnectivityList * unstructuredItemInternalConnectivityList() override
Informations sur les connectivités non structurés.
void addVariable(IVariable *var) override
Ajoute une variable à cette famille.
void endAllocate() override
Indique une fin d'allocation.
ItemSharedInfo * commonItemSharedInfo() override
Instance de ItemSharedInfo pour les entités de la famille.
IItemFamilyTopologyModifier * topologyModifier() override
Interface du modificateur de topologie.
VariableArrayInt64 m_items_unique_id
Contient les uniqueIds() des entités de cette famille.
VariableArrayInteger m_items_shared_data_index
Indice dans le tableau des ItemSharedInfo pour chaque entité.
VariableArrayInt32 m_items_flags
Contient les flags() des entités de cette famille.
VariableArrayInt16 m_items_type_id
Contient les typeId() des entités de cette famille.
VariableArrayInt32 m_items_owner
Contient les owner() des entités de cette famille.
VariableItemInt32 m_items_new_owner
Contient le sous-domaine propriétaire de l'entité.
VariableArrayInt32 m_items_nb_parent
Contient le parent() des entités de cette famille.
bool hasUniqueIdMap() const override
Indique si la famille possède une table de conversion uniqueId vers localId.
IMesh * mesh() const override
Maillage associé
void partialEndUpdateVariable(IVariable *variable) override
Met à jour une variable.
void _compactItems(bool do_sort)
Compacte les entités.
void partialEndUpdate() override
Mise à jour partielle.
String fullName() const override
Nom complet de la famille (avec celui du maillage)
Definition ItemFamily.h:131
void _compactFromParentFamily(const ItemFamilyCompactInfos &compact_infos)
Compacte les connectivités.
void _checkComputeSynchronizeInfos(Int32 changed)
Test collectif permettant de savoir s'il faut mettre à jour les infos de synchro.
void _compactOnlyItems(bool do_sort)
Compacte les entités sans mise à jour des références.
EventObservableView< const ItemFamilyItemListChangedEventArgs & > itemListChangedEvent() override
Evènement pour l'ajout et la suppression d'entité
void clearItems() override
Supprime toutes les entités de la famille.
ItemPairGroup findAdjencyItems(const ItemGroup &group, const ItemGroup &sub_group, eItemKind link_kind, Integer layer) override
Cherche une liste d'adjacence.
void destroyGroups() override
Supprime tous les groupes de cette famille.
void prepareForDump() override
Prépare les données pour une protection.
ItemInternalConnectivityList m_item_connectivity_list
Accesseur pour les connectivités via Item et ItemInternal.
Definition ItemFamily.h:438
void addChildFamily(IItemFamily *family) override
Ajoute d'une famile en dépendance.
void checkValid() override
Vérification de la validité des structures internes (interne)
ItemInternal * findOneItem(Int64 uid) override
Entité de numéro unique unique_id.
IParallelMng * parallelMng() const override
Gestionnaire de parallélisme associé
void endUpdate() override
Notifie la fin de modification de la liste des entités.
void compactVariablesAndGroups(const ItemFamilyCompactInfos &compact_infos)
Compacte les variables et les groupes.
void usedVariables(VariableCollection collection) override
Ajoute à la collection collection la liste des variables utilisés de cette famille.
ITraceMng * traceMng() const override
Gestionnaire de trace associé
ItemGroup createGroup(const String &name, Int32ConstArrayView elements, bool do_override=false) override
Créé un groupe d'entités de nom name contenant les entités local_ids.
eItemKind itemKind() const override
Genre des entités.
Integer m_current_id
Identifiant de la famille.
Definition ItemFamily.h:424
VariableItemInt32 & itemsNewOwner() override
Variable contenant le numéro du nouveau sous-domaine propriétaire de l'entité.
ItemInternalConnectivityList * itemInternalConnectivityList()
Accesseur pour les connectivités via Item et ItemInternal.
Definition ItemFamily.h:295
void copyItemsValues(Int32ConstArrayView source, Int32ConstArrayView destination) override
void copyItemsMeanValues(Int32ConstArrayView first_source, Int32ConstArrayView second_source, Int32ConstArrayView destination) override
ItemGroup allItems() const override
Groupe de toutes les entités.
void experimentalChangeUniqueId(ItemLocalId local_id, ItemUniqueId unique_id) override
Change le numéro unique de l'entité.
void internalRemoveItems(Int32ConstArrayView local_ids, bool keep_ghost=false) override
Supprime les entités donnés par local_ids.
void addGhostItems(Int64ConstArrayView unique_ids, Int32ArrayView items, Int32ConstArrayView owners) override
Alloue des entités fantômes.
IItemFamilyInternal * _internalApi() override
API interne à Arcane.
void getCommunicatingSubDomains(Int32Array &sub_domains) const override
Liste des sous-domaines communiquants pour les entités.
void reduceFromGhostItems(IVariable *v, IDataOperation *operation) override
Applique une opération de réduction depuis les entités fantômes.
ItemConnectivitySet m_target_item_connectivities
connectivite ou ItemFamily == SourceFamily
Definition ItemFamily.h:357
IItemFamily * parentFamily() const override
IItemFamily parent.
void setHasUniqueIdMap(bool v) override
Indique si la famille possède une table de conversion uniqueId vers localId.
ItemInfoListView itemInfoListView() override
Vue sur la liste d'informations sur les entités.
void setParentFamily(IItemFamily *parent) override
Positionne l'IItemFamily parent.
void compactItems(bool do_sort) override
Compacte les entités.
Integer nbItem() const override
Nombre d'entités.
void notifyItemsUniqueIdChanged() override
Notifie que les numéros uniques des entités ont été modifiées.
ItemVectorView view() override
Vue sur toutes les entités de la famille.
void synchronize(VariableCollection variables) override
Synchronise les variables variables.
ItemPairGroup findAdjacencyItems(const ItemGroup &group, const ItemGroup &sub_group, eItemKind link_kind, Integer layer) override
Cherche une liste d'adjacence.
ItemInternalList itemsInternal() override
Tableau interne des entités.
void computeSynchronizeInfos() override
Construit les structures nécessaires à la synchronisation.
void checkValidConnectivity() override
Vérification de la validité des structures internes concernant la connectivité.
void _updateItemsSharedFlag()
Positionne les infos Item::isShared() pour les entités de la famille.
IVariable * findVariable(const String &name, bool throw_exception) override
Recherche la variable de nom name associée à cette famille.
void _readGroups()
Relit les groupes depuis une protection et les recréer si besoin.
Int32 maxLocalId() const override
void setItemSortFunction(IItemInternalSortFunction *sort_function) override
Positionne la fonction de tri des entités.
IItemInternalSortFunction * itemSortFunction() const override
Fonction de tri des entités.
ISubDomain * subDomain() const override
Sous-domaine associé
virtual void _notifyEndUpdateFromMesh()
IVariableSynchronizer * allItemsSynchronizer() override
Synchroniseur sur toutes les entités de la famille.
void notifyItemsOwnerChanged() override
Notifie que les entités propres au sous-domaine de la famille ont été modifiées.
Integer parentFamilyDepth() const override
Donne la profondeur d'imbrication du maillage courant.
ItemGroupCollection groups() const override
Liste des groupes de cette famille.
IItemConnectivityMng * m_connectivity_mng
connectivite ou ItemFamily == TargetFamily
Definition ItemFamily.h:358
IItemConnectivityInfo * localConnectivityInfos() const override
Informations sur la connectivité locale au sous-domaine pour à cette famille.
IItemFamilyCollection childFamilies() override
Familles enfantes de cette famille.
void partialEndUpdateGroup(const ItemGroup &group) override
Met à jour un groupe.
Properties * properties() override
Propriétés associées à cette famille.
Definition ItemFamily.h:275
void removeNeedRemoveMarkedItems() override
Supprime des entités et met a jour les connectivites.
IItemConnectivityInfo * globalConnectivityInfos() const override
Informations sur la connectivité globales à tous les sous-domaines.
void checkUniqueIds(Int64ConstArrayView unique_ids) override
Vérifie que les identifiants unique_ids sont bien uniques pour tous les sous-domaines.
ItemGroup findGroup(const String &name) const override
Recherche un groupe.
void readFromDump() override
Relit les données à partir d'une protection.
String name() const override
Nom de la famille.
Definition ItemFamily.h:130
Tableau associatif de ItemInternal.
void remove(Int64 key)
Supprime la valeur associée à la clé key.
void eachItem(const Lambda &lambda)
Fonction template pour itérer sur les entités de l'instance.
bool add(Int64 key, ItemInternal *v)
Ajoute la valeur v correspondant à la clé key.
Int32 count() const
Nombre d'éléments de la table.
Infos de maillage pour un genre donné d'entité.
Classe temporaire pour conserver un ItemSharedInfo et un type d'entité.
VariableRefArrayT< Int32 > VariableArrayInt32
Variable tableau de type entier 32 bits.
VariableRefArrayT< Int64 > VariableArrayInt64
Variable tableau de type entier 64 bits.
VariableRefArrayT< Int16 > VariableArrayInt16
Variable tableau de type entier 16 bits.
VariableRefScalarT< String > VariableScalarString
Variable scalaire de type chaine de caractère.
VariableRefArrayT< Integer > VariableArrayInteger
Variable tableau de type entier.
VariableRefArrayT< String > VariableArrayString
Variable tableau de type chaîne de caractères.
ItemVariableScalarRefT< Int32 > VariableItemInt32
Grandeur de type entier 32 bits.
VariableRefScalarT< Integer > VariableScalarInteger
Variable scalaire de type entier.
Int32 toInt32(Int64 v)
Converti un Int64 en un Int32.
eReduceType
Types des réductions supportées.
@ ReduceMax
Maximum des valeurs.
Ref< IVariableSynchronizer > createSynchronizerRef(IParallelMng *pm, IItemFamily *family)
Retourne une interface pour synchroniser des variables sur le groupe de la famille family.
ARCCORE_BASE_EXPORT double getMemoryUsed()
Mémoire utilisée em octets.
ARCCORE_BASE_EXPORT String getEnvironmentVariable(const String &name)
Variable d'environnement du nom name.
ArrayView< Int64 > Int64ArrayView
Equivalent C d'un tableau à une dimension d'entiers 64 bits.
Definition UtilsTypes.h:538
bool arcaneIsCheck()
Vrai si on est en mode vérification.
Definition Misc.cc:68
UniqueArray< Int64 > Int64UniqueArray
Tableau dynamique à une dimension d'entiers 64 bits.
Definition UtilsTypes.h:426
Collection< ItemGroup > ItemGroupCollection
Collection de groupes d'éléments du maillage.
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
List< ItemGroup > ItemGroupList
Tableau de groupes d'éléments du maillage.
ArrayView< Integer > IntegerArrayView
Equivalent C d'un tableau à une dimension d'entiers.
Definition UtilsTypes.h:544
ConstArrayView< ItemInternal * > ItemInternalList
Type de la liste interne des entités.
Definition ItemTypes.h:466
Collection< IItemFamily * > IItemFamilyCollection
Collection de familles d'entités.
ConstArrayView< Int64 > Int64ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 64 bits.
Definition UtilsTypes.h:567
ArrayView< Int32 > Int32ArrayView
Equivalent C d'un tableau à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:540
eItemKind
Genre d'entité de maillage.
Array< Int32 > Int32Array
Tableau dynamique à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:214
std::int32_t Int32
Type entier signé sur 32 bits.