Arcane  v3.16.3.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
DynamicMesh.h
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2025 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
4// See the top-level COPYRIGHT file for details.
5// SPDX-License-Identifier: Apache-2.0
6//-----------------------------------------------------------------------------
7/*---------------------------------------------------------------------------*/
8/* DynamicMesh.h (C) 2000-2025 */
9/* */
10/* Classe de gestion d'un maillage évolutif. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_MESH_DYNAMICMESH_H
13#define ARCANE_MESH_DYNAMICMESH_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17#include "arcane/utils/TraceAccessor.h"
18#include "arcane/utils/PerfCounterMng.h"
19#include "arcane/utils/ArgumentException.h"
20#include "arcane/utils/List.h"
21
22#include "arcane/core/IMeshModifier.h"
23#include "arcane/core/IPrimaryMesh.h"
24#include "arcane/core/IItemFamily.h"
25#include "arcane/core/IItemFamilyModifier.h"
26#include "arcane/core/ObserverPool.h"
27#include "arcane/core/MeshPartInfo.h"
28#include "arcane/core/IItemFamilyNetwork.h"
29#include "arcane/core/MeshHandle.h"
30#include "arcane/core/IMeshInitialAllocator.h"
31#include "arcane/core/MeshKind.h"
32
33#include "arcane/mesh/SubMeshTools.h"
34#include "arcane/mesh/MeshVariables.h"
35#include "arcane/mesh/NewWithLegacyConnectivity.h"
36#include "arcane/mesh/MeshEventsImpl.h"
37
38#include <functional>
39#include <memory>
40
41/*---------------------------------------------------------------------------*/
42/*---------------------------------------------------------------------------*/
43
44namespace Arcane
45{
46class IVariableMng;
47class Properties;
48class IUserDataList;
51class IMeshCompactMng;
54}
55
56/*---------------------------------------------------------------------------*/
57/*---------------------------------------------------------------------------*/
58
59namespace Arcane::mesh
60{
61
62/*---------------------------------------------------------------------------*/
63/*---------------------------------------------------------------------------*/
64
67class ItemMemoryReferenceMng;
68class MeshTiedInterface;
69class TiedInterface;
70class MeshPartitionConstraintMng;
71class TiedInterfaceMng;
72class NodeFamily;
73class EdgeFamily;
74class FaceFamily;
75class CellFamily;
76class DulaNodeFamily;
78class MeshRefinement;
79class NewItemOwnerBuilder;
82
85
86/*---------------------------------------------------------------------------*/
87/*---------------------------------------------------------------------------*/
91class ARCANE_MESH_EXPORT DynamicMesh
92: public MeshVariables
93, public TraceAccessor
94, public IPrimaryMesh
95, public IMeshModifier
98{
99 private:
100
101 friend DynamicMeshInternal;
102
103 // TEMPORAIRE
104 friend DynamicMeshMergerHelper;
105
106 public:
107
108 typedef ItemInternal* ItemInternalPtr;
109 typedef List<IItemFamily*> ItemFamilyList;
110
111 class InitialAllocator
112 : public IMeshInitialAllocator
113 {
114 public:
115
116 InitialAllocator(DynamicMesh* m) : m_mesh(m){}
118 {
119 return m_mesh;
120 }
122 {
123 return m_mesh;
124 }
125
126 private:
127
128 DynamicMesh* m_mesh;
129 };
130
131#ifdef ACTIVATE_PERF_COUNTER
132 struct PerfCounter
133 {
134 typedef enum {
135 UPGHOSTLAYER1,
136 UPGHOSTLAYER2,
137 UPGHOSTLAYER3,
138 UPGHOSTLAYER4,
139 UPGHOSTLAYER5,
140 UPGHOSTLAYER6,
141 UPGHOSTLAYER7,
142 NbCounters
143 } eType ;
144
145 static const std::string m_names[NbCounters] ;
146 } ;
147#endif
148 public:
149
150 void _checkKindRange(eItemKind ik) const // Il faut rendre fatal pour les particules, les dofs et le graph ??
151 {
152 if (ik==IK_Node ||
153 ik==IK_Edge ||
154 ik==IK_Face ||
155 ik==IK_Cell ||
156 ik==IK_DoF)
157 return;
158 throw ArgumentException(A_FUNCINFO,"Invalid Range");
159 }
160
161 public:
162
163 DynamicMesh(ISubDomain* sd,const MeshBuildInfo& mbi, bool is_submesh);
164 ~DynamicMesh();
165
166 public:
167
168 void build() override;
169
170 public:
171
172 MeshHandle handle() const override { return m_mesh_handle; }
173 String name() const override { return m_name; }
174 String factoryName() const override { return m_factory_name; }
175
176 IMesh* mesh() override { return this; }
177 Integer dimension() override { return m_mesh_dimension(); }
178 void setDimension(Integer dim) override;
180 Integer nbNode() override;
181 Integer nbEdge() override;
182 Integer nbFace() override;
183 Integer nbCell() override;
184
186 {
187 _checkKindRange(ik);
188 return m_item_families[ik]->nbItem();
189 }
190
191 ItemInternalArrayView itemsInternal(eItemKind ik) override
192 {
193 _checkKindRange(ik);
194 return m_item_families[ik]->itemsInternal();
195 }
196
197 VariableNodeReal3& nodesCoordinates() override;
198 SharedVariableNodeReal3 sharedNodesCoordinates() override;
199
200 public:
201
202 void setEstimatedCells(Integer nb_cell);
203
204 public:
205
206 void exchangeItems() override;
207 void clearItems() override;
208
213 void updateGhostLayers() override;
214 void updateGhostLayers(bool remove_old_ghost) override;
216 void updateGhostLayerFromParent(Array<Int64>& ghost_cell_to_refine,
217 Array<Int64>& cells_to_coarsen,
218 bool remove_old_ghost) override;
219
221 void mergeMeshes(ConstArrayView<IMesh*> meshes) override;
222
223 void addExtraGhostCellsBuilder(IExtraGhostCellsBuilder* builder) override;
224 void removeExtraGhostCellsBuilder(IExtraGhostCellsBuilder* builder) override;
225 void addExtraGhostParticlesBuilder(IExtraGhostParticlesBuilder* builder) override;
226 void removeExtraGhostParticlesBuilder(IExtraGhostParticlesBuilder* builder) override;
227
228 void serializeCells(ISerializer* buffer,Int32ConstArrayView cells_local_id) override;
229 Int32 meshRank() { return m_mesh_part_info.partRank(); }
230
231 void checkValidMesh() override;
232 void checkValidMeshFull() override;
233 void checkValidConnectivity();
234
235 public:
236
237 bool isAllocated() override { return m_is_allocated; }
238
239 void reloadMesh() override;
240
241 void deallocate() override;
242 void allocateCells(Integer mesh_nb_cell,Int64ConstArrayView cells_info,bool one_alloc) override;
243 void endAllocate() override;
244
245 void addCells(Integer nb_cell,Int64ConstArrayView cell_infos,Int32ArrayView cells) override;
246 void addCells(const MeshModifierAddCellsArgs& args) override;
247 void addCells(ISerializer* buffer) override;
248 void addCells(ISerializer* buffer,Int32Array& cells_local_id) override;
249 void addFaces(Integer nb_face,Int64ConstArrayView face_infos,Int32ArrayView faces) override;
250 void addFaces(const MeshModifierAddFacesArgs& args) override;
251 void addEdges(Integer nb_edge,Int64ConstArrayView edge_infos,Int32ArrayView edges) override;
252 void addNodes(Int64ConstArrayView nodes_uid,Int32ArrayView nodes) override;
253 void removeCells(Int32ConstArrayView cells_local_id,bool update_graph) override;
254 void removeCells(Int32ConstArrayView cells_local_id) override
255 {
256 removeCells(cells_local_id,true) ;
257 }
258 void detachCells(Int32ConstArrayView cells_local_id) override;
259 void removeDetachedCells(Int32ConstArrayView cells_local_id) override;
261 void flagCellToRefine(Int32ConstArrayView cells_lids) override;
262 void flagCellToCoarsen(Int32ConstArrayView cells_lids) override;
263 void refineItems() override;
264 void coarsenItems() override;
265 void coarsenItemsV2(bool update_parent_flag) override;
266 void compact() ;
267 bool adapt() override;
268 void registerCallBack(IAMRTransportFunctor* f) override;
269 void unRegisterCallBack(IAMRTransportFunctor* f) override;
270 void addHChildrenCells(Cell parent_cell,Integer nb_cell,
271 Int64ConstArrayView cells_infos,Int32ArrayView cells) override;
272
273 void addParentCellToCell(Cell child, Cell parent) override;
274 void addChildCellToCell(Cell parent, Cell child) override;
275
276 void addParentFaceToFace(Face child, Face parent) override;
277 void addChildFaceToFace(Face parent, Face child) override;
278
279 void addParentNodeToNode(Node child, Node parent) override;
280 void addChildNodeToNode(Node parent, Node child) override;
281
282 void endUpdate() override;
283 Int64 timestamp() override { return m_timestamp; }
284
285 bool isPrimaryMesh() const override;
286 IPrimaryMesh* toPrimaryMesh() override;
287
289 const MeshPartInfo& meshPartInfo() const override { return m_mesh_part_info; }
290 void setMeshPartInfo(const MeshPartInfo& mpi) override;
291 IUserDataList* userDataList() override { return m_mesh_handle.meshUserDataList(); }
292 const IUserDataList* userDataList() const override { return m_mesh_handle.meshUserDataList(); }
293
294 IGhostLayerMng* ghostLayerMng() const override { return m_ghost_layer_mng; }
295 IMeshUniqueIdMng* meshUniqueIdMng() const override { return m_mesh_unique_id_mng; }
296 IMeshChecker* checker() const override;
297
298public:
299
301 {
302 _checkKindRange(ik);
303 return m_item_families[ik]->itemsNewOwner();
304 }
305
306 ItemInternalMap& nodesMap();
307 ItemInternalMap& edgesMap();
308 ItemInternalMap& facesMap();
309 ItemInternalMap& cellsMap();
310
311 void addParentCells(ItemVectorView & items);
312
313 // ItemFamilyNetwork
314 void removeItems(IItemFamily* item_family, Int32ConstArrayView cells_local_id);
315
316 private:
317
318 ISubDomain* m_sub_domain;
319 IMeshMng* m_mesh_mng;
320 MeshHandle m_mesh_handle;
321 IParallelMng* m_parallel_mng;
322 MeshItemInternalList m_item_internal_list;
323 IVariableMng* m_variable_mng;
324 Properties* m_properties;
325 Int64 m_timestamp;
326 bool m_is_allocated;
327 Integer m_dimension;
328 String m_name;
329 String m_factory_name;
330 bool m_need_compact;
331 bool m_has_edge;
332
333 public:
334
335 NodeFamily* m_node_family;
336 EdgeFamily* m_edge_family;
337 FaceFamily* m_face_family;
338 CellFamily* m_cell_family;
339
340 private:
341
342 IMesh* m_parent_mesh;
343 ItemGroupImpl* m_parent_group;
344 UniqueArray<DynamicMesh*> m_child_meshes;
345
346 public:
347
348 NodeFamily& trueNodeFamily() { return *m_node_family; }
349 EdgeFamily& trueEdgeFamily() { return *m_edge_family; }
350 FaceFamily& trueFaceFamily() { return *m_face_family; }
351 CellFamily& trueCellFamily() { return *m_cell_family; }
352
353 public:
354
355 NodeGroup allNodes() override { return allItems(IK_Node); }
356 EdgeGroup allEdges() override { return allItems(IK_Edge); }
357 FaceGroup allFaces() override { return allItems(IK_Face); }
358 CellGroup allCells() override { return allItems(IK_Cell); }
359
360 //TODO: supprimer cette méthode
361 ItemGroup allItems(eItemKind kind)
362 {
363 _checkKindRange(kind);
364 return m_item_families[kind]->allItems();
365 }
366
367 NodeGroup ownNodes() override { return ownItems(IK_Node); }
368 EdgeGroup ownEdges() override { return ownItems(IK_Edge); }
369 FaceGroup ownFaces() override { return ownItems(IK_Face); }
370 CellGroup ownCells() override { return ownItems(IK_Cell); }
371
372 //TODO: supprimer cette méthode
373 ItemGroup ownItems(eItemKind kind)
374 {
375 _checkKindRange(kind);
376 return m_item_families[kind]->allItems().own();
377 }
378
379 FaceGroup outerFaces() override;
380
383 CellGroup allActiveCells() override;
384
386 CellGroup ownActiveCells() override;
387
389 CellGroup allLevelCells(const Integer& level) override;
390
392 CellGroup ownLevelCells(const Integer& level) override;
393
395 FaceGroup allActiveFaces() override;
396
398 FaceGroup ownActiveFaces() override;
399
401 FaceGroup innerActiveFaces() override;
402
404 FaceGroup outerActiveFaces() override;
405
406// void readAmrActivator(const XmlNode& mesh_node) override;
407
408 public:
409
410 MeshItemInternalList* meshItemInternalList() override
411 { return &m_item_internal_list; }
412
413 public:
414
415 ISubDomain* subDomain() override { return m_sub_domain; }
416 IParallelMng* parallelMng() override;
418
419 ItemGroupCollection groups() override;
420
421 void prepareForDump() override;
422 void initializeVariables(const XmlNode& init_node) override;
423 ItemGroup findGroup(const String& name) override;
424 ItemGroup findGroup(const String& name,eItemKind ik,bool create_if_needed);
425 void destroyGroups() override;
426
427 NodeGroup findNodeGroup(const String& aname)
428 { return findGroup(aname,IK_Node,false); }
429 EdgeGroup findEdgeGroup(const String& aname)
430 { return findGroup(aname,IK_Edge,false); }
431 FaceGroup findFaceGroup(const String& aname)
432 { return findGroup(aname,IK_Face,false); }
433 CellGroup findCellGroup(const String& aname)
434 { return findGroup(aname,IK_Cell,false); }
435
436 ItemGroup createGroup(const String& aname,const ItemGroup& parent);
437 ItemGroup createGroup(const String& aname,eItemKind ik);
438
440 bool isAmrActivated() const override
441 {
442 return m_is_amr_activated;
443 }
444
445 public:
446
447 IItemFamily* createItemFamily(eItemKind ik,const String& name) override;
448
449 IItemFamily* findItemFamily(eItemKind ik,const String& name,bool create_if_needed,bool register_modifier_if_created) override;
450 IItemFamily* findItemFamily(const String& name,bool throw_exception=true) override;
451 IItemFamilyModifier* findItemFamilyModifier(eItemKind ik,const String& name) override;
452 void addItemFamilyModifier(IItemFamilyModifier*) ;
453
455 {
456 _checkKindRange(ik);
457 return m_item_families[ik];
458 }
459 IItemFamily* nodeFamily() override;
460 IItemFamily* edgeFamily() override;
461 IItemFamily* faceFamily() override;
462 IItemFamily* cellFamily() override;
463
464 IItemFamilyCollection itemFamilies() override
465 {
466 return m_item_families;
467 }
468
469 public:
470
471 bool isDynamic() const override
472 {
473 return m_is_dynamic;
474 }
475
476 void setDynamic(bool v) override
477 {
478 m_is_dynamic = v;
479 }
480
481 void setCheckLevel(Integer level) override;
482
483 Integer checkLevel() const override;
484
485 public:
486
487 void computeTiedInterfaces(const XmlNode& xml_node) override;
488 bool hasTiedInterface() override;
489 TiedInterfaceCollection tiedInterfaces() override;
490 IMeshPartitionConstraintMng* partitionConstraintMng() override;
491 ConstArrayView<TiedInterface*> trueTiedInterfaces();
492
493 public:
494
495 IMeshUtilities* utilities() override;
496 IMeshModifier* modifier() override { return this; }
497 Properties* properties() override { return m_properties; }
498 void synchronizeGroupsAndVariables() override;
499
500 public:
501
502 void defineParentForBuild(IMesh* mesh, ItemGroup group) override;
503 IMesh* parentMesh() const override;
504 ItemGroup parentGroup() const override;
505 void addChildMesh(IMesh* sub_mesh) override;
506 IMeshCollection childMeshes() const override;
507
508 void setOwnersFromCells() override { _setOwnersFromCells(); }
509 IMeshCompactMng* _compactMng() override { return m_mesh_compact_mng; }
511 {
512 return m_connectivity_policy;
513 }
514
515 public:
516
517 DynamicMeshIncrementalBuilder* incrementalBuilder() { return m_mesh_builder; }
518 MeshRefinement* meshRefinement() { return m_mesh_refinement; }
519 void endUpdate(bool update_ghost_layer, bool remove_old_ghost) override;
520
521 public:
522
523 bool useMeshItemFamilyDependencies() const override {return m_use_mesh_item_family_dependencies; }
524 IItemFamilyNetwork* itemFamilyNetwork() override {return m_item_family_network;}
525 IIndexedIncrementalItemConnectivityMng* indexedConnectivityMng() override { return m_indexed_connectivity_mng.get(); }
526
527 public:
528
529 IMeshMng* meshMng() const override { return m_mesh_mng; }
530 IVariableMng* variableMng() const override { return m_variable_mng; }
531 ItemTypeMng* itemTypeMng() const override { return m_item_type_mng; }
532
533 void computeSynchronizeInfos() override;
534
535 public:
536
537 IMeshInitialAllocator* initialAllocator() override { return &m_initial_allocator; }
538 void allocate(UnstructuredMeshAllocateBuildInfo& build_info) override;
539 void allocate(CartesianMeshAllocateBuildInfo& build_info) override;
540
541 public:
542
544 {
545 return m_mesh_events.eventObservable(type);
546 }
547
548 public:
549
550 const MeshKind meshKind() const override { return m_mesh_kind; }
551
552 IMeshInternal* _internalApi() override;
553 IMeshModifierInternal* _modifierInternalApi() override;
554
555 private:
556
557 IMeshUtilities* m_mesh_utilities = nullptr;
558
559 public:
560
561 DynamicMeshIncrementalBuilder* m_mesh_builder = nullptr;
562
563 private:
564
565 DynamicMeshChecker* m_mesh_checker = nullptr;
566 SubMeshTools* m_submesh_tools = nullptr;
569 NewItemOwnerBuilder * m_new_item_owner_builder = nullptr;
570 ExtraGhostCellsBuilder* m_extra_ghost_cells_builder = nullptr;
571 ExtraGhostParticlesBuilder* m_extra_ghost_particles_builder = nullptr;
572 InitialAllocator m_initial_allocator;
573 std::unique_ptr<DynamicMeshInternal> m_internal_api;
574
575 private:
576
578 bool m_is_amr_activated = false;
579 eMeshAMRKind m_amr_type;
580
581 bool m_is_dynamic = false;
582
585
587 ItemFamilyList m_item_families;
588
591 UniqueArray<IItemFamilyModifier*> m_family_modifiers; // used for item family network
592
593 ObserverPool m_observer_pool;
594 TiedInterfaceMng* m_tied_interface_mng = nullptr;
595 bool m_is_sub_connectivity_set = false;
596 bool m_tied_interface_need_prepare_dump = false;
597
598 MeshPartitionConstraintMng* m_partition_constraint_mng = nullptr;
599 IGhostLayerMng* m_ghost_layer_mng = nullptr;
600 IMeshUniqueIdMng* m_mesh_unique_id_mng = nullptr;
601 IMeshExchangeMng* m_mesh_exchange_mng = nullptr;
602 IMeshCompactMng* m_mesh_compact_mng = nullptr;
603
604#ifdef ACTIVATE_PERF_COUNTER
605 PerfCounterMng<PerfCounter> m_perf_counter;
606#endif
607
608 InternalConnectivityPolicy m_connectivity_policy;
609 MeshPartInfo m_mesh_part_info;
610
611 bool m_use_mesh_item_family_dependencies = false ;
612 IItemFamilyNetwork* m_item_family_network = nullptr;
613 ItemTypeMng* m_item_type_mng = nullptr;
614 std::unique_ptr<IIndexedIncrementalItemConnectivityMng> m_indexed_connectivity_mng;
615 MeshKind m_mesh_kind;
616 bool m_do_not_save_need_compact = false;
617
618 MeshEventsImpl m_mesh_events;
619
620 private:
621
622 void _printMesh(std::ostream& ostr);
623 void _allocateCells(Integer mesh_nb_cell,
624 Int64ConstArrayView cells_info,
626 bool allow_build_face = true);
627
628 const char* _className() const { return "Mesh"; }
629
630 void _allocateCells2(DynamicMeshIncrementalBuilder* mib);
631 void _itemsUniqueIdsToLocalIdsSorted(eItemKind item_kind,ArrayView<Integer> ids);
632 void _prepareForDump();
633 void _prepareForDumpReal();
634 void _readFromDump();
635
636 void _setOwnersFromCells();
637 // Les méthodes _synchronizeXXX ne sont pas récursives sur les sous-maillages
638 void _synchronizeGroupsAndVariables();
639 void _synchronizeGroups();
640 void _synchronizeVariables();
641 void _writeMesh(const String& base_name);
642 void _removeGhostItems() ;
643 // AMR
644 void _removeGhostChildItems();
645 void _removeGhostChildItems2(Array<Int64>& cells_to_coarsen);
646 void _checkAMR() const;
647
648 void _sortInternalReferences();
649 void _finalizeMeshChanged();
650 void _compactItemInternalReferences();
651 void _compactItems(bool do_sort,bool compact_variables_and_groups);
652 void _checkValidItem(ItemInternal* item);
653
654 void _computeSynchronizeInfos();
655 void _computeFamilySynchronizeInfos();
656 void _computeGroupSynchronizeInfos();
657 void _exchangeItems(bool do_compact);
658 void _exchangeItemsNew();
659 void _checkDimension() const;
660 void _checkConnectivity();
661 void _writeCells(const String& filename);
662
663 void _prepareTiedInterfacesForDump();
664 void _readTiedInterfacesFromDump();
665 void _applyTiedInterfaceStructuration(TiedInterface* tied_interface);
666 void _deleteTiedInterfaces();
667
668 void _multipleExchangeItems(Integer nb_exchange,Integer version,bool do_compact);
669 void _addCells(ISerializer* buffer,Int32Array* cells_local_id);
670 void _setSubConnectivity();
671 void _setDimension(Integer dim);
672 void _internalUpdateGhost(bool update_ghost_layer,bool remove_old_ghost);
673 void _internalEndUpdateInit(bool update_sync_info);
674 void _internalEndUpdateResizeVariables();
675 void _internalEndUpdateFinal(bool print_stat);
676
677 void _computeExtraGhostCells();
678 void _computeExtraGhostParticles();
679
680 void _notifyEndUpdateForFamilies();
681 ItemFamily* _createNewFamily(eItemKind kind, const String & name);
682
683 void _saveProperties();
684 void _loadProperties();
685 void _addFamily(ItemFamily* true_family);
686
687 void _buildAndInitFamily(IItemFamily* family);
688 IItemFamilyPolicyMng* _createFamilyPolicyMng(ItemFamily* family);
689 void _applyCompactPolicy(const String& timer_name,
690 std::function<void(IItemFamilyCompactPolicy*)> functor);
691 void _updateGroupsAfterRemove();
692 void _printConnectivityPolicy();
693
694 // Add a dependency (downward adjacencies only) between two family: ie the source family
695 // is built on the target family (ex a cell is build owns its nodes)
696 template <class SourceFamily, class TargetFamily>
697 void _addDependency(SourceFamily* source_family, TargetFamily* target_family)
698 {
699 typedef typename NewWithLegacyConnectivityType<SourceFamily,TargetFamily>::type CType;
700 String name = String::format("{0}{1}",source_family->name(),target_family->name());
701 auto connectivity = new CType(source_family,target_family,name);
702 m_item_family_network->addDependency(source_family,target_family,connectivity);
703 }
704
705 // Add a relation : source family "sees" target family (ex a face sees its cells). Often upward adjacencies.
706 template <class SourceFamily, class TargetFamily>
707 void _addRelation(SourceFamily* source_family, TargetFamily* target_family)
708 {
709 typedef typename NewWithLegacyConnectivityType<SourceFamily,TargetFamily>::type CType;
710 String name = String::format("{0}{1}",source_family->name(),target_family->name());
711 auto connectivity = new CType(source_family,target_family,name);
712 m_item_family_network->addRelation(source_family,target_family,connectivity);
713 }
714
715 // Update family dependencies with set connectivities
716 void _updateItemFamilyDependencies(VariableScalarInteger connectivity);
717
718 // Serialize Item
719 void _serializeItems(ISerializer* buffer,Int32ConstArrayView item_local_ids, IItemFamily* item_family);
720 void _deserializeItems(ISerializer* buffer,Int32Array *item_local_ids, IItemFamily* item_family);
721 void _fillSerializer(ISerializer* buffer, std::map<String, Int32UniqueArray>& serializedItems);
722
723};
724
725/*---------------------------------------------------------------------------*/
726/*---------------------------------------------------------------------------*/
727
728} // End namespace Arcane::mesh
729
730/*---------------------------------------------------------------------------*/
731/*---------------------------------------------------------------------------*/
732
733#endif
Vue modifiable d'un tableau d'un type T.
Tableau d'items de types quelconques.
Informations pour allouer les entités d'un maillage non structuré.
Maille d'un maillage.
Definition Item.h:1205
Vue constante d'un tableau de type T.
Classe de base d'un handler d'évènement.
Definition Event.h:193
Face d'une maille.
Definition Item.h:958
Interface d'un fonctor avec argument.
Allocateur pour les maillages cartésiens.
Interface d'un constructeur de mailles fantômes "extraordinaires".
Interface d'un constructeur de mailles fantômes "extraordinaires".
Interface du gestionnaire des connectivités incrémentales indexées sur les entités.
Politique de compactage des entités.
Interface de modification d'une famille.
virtual void addDependency(IItemFamily *master_family, IItemFamily *slave_family, IIncrementalItemConnectivity *slave_to_master_connectivity, bool is_deep_connectivity=true)=0
virtual void addRelation(IItemFamily *source_family, IItemFamily *target_family, IIncrementalItemConnectivity *source_to_target_connectivity)=0
Interface des politiques d'une famille d'entités.
Interface d'une famille d'entités.
Definition IItemFamily.h:84
Interface de méthodes de vérification d'un maillage.
Interface du gestionnaire des compactages de familles d'un maillage.
Interface du gestionnaire des échanges de maillages entre sous-domaines.
Interface d'allocation des entités du maillage.
Partie interne de IMesh.
Interface du gestionnaire des maillages.
Definition IMeshMng.h:40
Partie interne de IMeshModifier.
Interface de modification du maillage.
Interface d'un gestionnaire de contraintes de partitionnement de maillage.
Interface d'une classe proposant des fonctions utilitaires sur maillage.
Interface du gestionnaire de parallélisme pour un sous-domaine.
Interface du gestionnaire d'un sous-domaine.
Definition ISubDomain.h:74
Interface du gestionnaire de traces.
Allocateur pour les maillages non structurés.
Interface d'une liste qui gère des données utilisateurs.
Interface du gestionnaire de variables.
Implémentation d'un groupe d'entités de maillage.
Groupe d'entités de maillage.
Definition ItemGroup.h:49
Structure interne d'une entité de maillage.
Gestionnaire des types d'entités d'un maillage.
Definition ItemTypeMng.h:65
Vue sur un vecteur d'entités.
Implémentation d'une collection d'éléments sous forme de vecteur.
Definition List.h:222
Handle sur un maillage.
Definition MeshHandle.h:47
Tableaux d'indirection sur les entités d'un maillage.
Caractéristiques d'un maillage.
Definition MeshKind.h:104
Arguments pour IMeshModifier::addCells().
Arguments pour IMeshModifier::addFaces().
Informations un maillage partitionné.
VariableScalarInteger m_mesh_connectivity
Connectivité du maillage.
VariableScalarInteger m_mesh_dimension
Dimension du maillage.
Noeud d'un maillage.
Definition Item.h:582
Liste d'observateurs.
Liste de propriétés.
Definition Properties.h:64
Chaîne de caractères unicode.
Implémentation du gestionnaire d'interfaces liées.
Informations sur les semi-conformitées du maillage.
TraceAccessor(ITraceMng *m)
Construit un accesseur via le gestionnaire de trace m.
ITraceMng * traceMng() const
Gestionnaire de trace.
Vecteur 1D de données avec sémantique par valeur (style STL).
Informations pour allouer les entités d'un maillage non structuré.
Noeud d'un arbre DOM.
Definition XmlNode.h:51
Famille de mailles.
Definition CellFamily.h:46
Construction d'un maillage de manière incrémentale.
ICartesianMeshInitialAllocator * cartesianMeshAllocator() override
Allocateur pour les maillages cartésiens.
IUnstructuredMeshInitialAllocator * unstructuredMeshAllocator() override
Allocateur pour les maillages non structurés.
bool useMeshItemFamilyDependencies() const override
check if the network itemFamily dependencies is activated
VariableItemInt32 & itemsNewOwner(eItemKind ik) override
Variable contenant l'identifiant du sous-domaine propriétaire.
IMeshCompactMng * _compactMng() override
String factoryName() const override
Nom de la fabrique utilisée pour créer le maillage.
FaceGroup allFaces() override
Groupe de toutes les faces.
bool isDynamic() const override
Indique si le maillage est dynamique (peut évoluer)
UniqueArray< ItemFamily * > m_true_item_families
Liste des implémentations des familles d'entités.
bool isAmrActivated() const override
AMR.
ITraceMng * traceMng() override
Gestionnaire de message associé
IItemFamily * itemFamily(eItemKind ik) override
Retourne la famille d'entité de type ik.
IMesh * mesh() override
Maillage associé
String name() const override
Nom du maillage.
IMeshMng * meshMng() const override
Gestionnaire de maillage associé
NodeGroup ownNodes() override
Groupe de tous les noeuds propres au domaine.
EdgeGroup ownEdges() override
Groupe de toutes les arêtes propres au domaine.
IIndexedIncrementalItemConnectivityMng * indexedConnectivityMng() override
Interface du gestionnaire des connectivités incrémentales indexées.
ItemInternalArrayView itemsInternal(eItemKind ik) override
Tableau interne des éléments du maillage de type type.
Int64 timestamp() override
Compteur indiquant le temps de dernière modification du maillage.
IMeshModifier * modifier() override
Interface de modification associée.
const IUserDataList * userDataList() const override
Gestionnnaire de données utilisateurs associé
VariableScalarInteger connectivity() override
Descripteur de connectivité
Integer dimension() override
Dimension du maillage (1D, 2D ou 3D).
void setDynamic(bool v) override
Positionne la propriété indiquant si le maillage peut évoluer.
ItemFamilyList m_item_families
Liste des interfaces familles d'entités.
EdgeGroup allEdges() override
Groupe de toutes les arêtes.
const MeshPartInfo & meshPartInfo() const override
Informations sur les parties du maillage.
ItemTypeMng * itemTypeMng() const override
Gestionnaire de types d'entités associé
CellGroup allCells() override
Groupe de toutes les mailles.
bool isAllocated() override
Vrai si le maillage est allouée.
IVariableMng * variableMng() const override
Gestionnaire de variable associé
IGhostLayerMng * ghostLayerMng() const override
Gestionnare de couche fantômes associé
InternalConnectivityPolicy _connectivityPolicy() const override
Politique d'utilisation des connectivitées.
void removeCells(Int32ConstArrayView cells_local_id) override
Supprime des mailles.
FaceGroup ownFaces() override
Groupe de toutes les faces propres au domaine.
Integer nbItem(eItemKind ik) override
Nombre d'éléments du genre ik.
IMeshInitialAllocator * initialAllocator() override
Allocateur initial spécifique.
const MeshKind meshKind() const override
Caractéristiques du maillage.
Properties * properties() override
Propriétés associées à ce maillage.
CellGroup ownCells() override
Groupe de toutes les mailles propres au domaine.
IItemFamilyNetwork * itemFamilyNetwork() override
Interface du réseau de familles (familles connectées)
void setOwnersFromCells() override
Positionne les propriétaires des entités à partir du propriétaire des mailles.
IMeshUniqueIdMng * meshUniqueIdMng() const override
Gestionnare de la numérotation des identifiants uniques.
NodeGroup allNodes() override
Groupe de tous les noeuds.
MeshHandle handle() const override
Handle sur ce maillage.
ItemGroupList m_all_groups
Liste des groupes d'entités.
MeshRefinement * m_mesh_refinement
AMR.
EventObservable< const MeshEventArgs & > & eventObservable(eMeshEventType type) override
Observable pour un évènement.
IUserDataList * userDataList() override
Gestionnnaire de données utilisateurs associé
Famille d'arêtes.
Definition EdgeFamily.h:35
Construction des mailles fantômes supplémentaires.
Construction des mailles fantômes supplémentaires.
Famille de faces.
Definition FaceFamily.h:53
Famille d'entités.
Definition ItemFamily.h:76
Tableau associatif de ItemInternal.
Implémentation des évènements sur le maillage.
Implémentation des algorithmes d'adaptation par raffinement de maillages non-structuré.
Famille de noeuds.
Definition NodeFamily.h:37
ItemGroupT< Cell > CellGroup
Groupe de mailles.
Definition ItemTypes.h:183
ItemGroupT< Face > FaceGroup
Groupe de faces.
Definition ItemTypes.h:178
ItemGroupT< Edge > EdgeGroup
Groupe d'arêtes.
Definition ItemTypes.h:173
ItemGroupT< Node > NodeGroup
Groupe de noeuds.
Definition ItemTypes.h:167
MeshVariableScalarRefT< Node, Real3 > VariableNodeReal3
Grandeur au noeud de type coordonnées.
ItemVariableScalarRefT< Int32 > VariableItemInt32
Grandeur de type entier 32 bits.
VariableRefScalarT< Integer > VariableScalarInteger
Variable scalaire de type entier.
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
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.
SharedMeshVariableScalarRefT< Node, Real3 > SharedVariableNodeReal3
Grandeur au noeud de type coordonnées.
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
eMeshEventType
Evènements générés par IMesh.
Definition MeshEvents.h:30
ArrayView< Int32 > Int32ArrayView
Equivalent C d'un tableau à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:540
eItemKind
Genre d'entité de maillage.
@ IK_Node
Entité de maillage de genre noeud.
@ IK_Cell
Entité de maillage de genre maille.
@ IK_Face
Entité de maillage de genre face.
@ IK_Edge
Entité de maillage de genre arête.
Array< Int32 > Int32Array
Tableau dynamique à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:214
Collection< IMesh * > IMeshCollection
Collection de maillages.
InternalConnectivityPolicy
Politique d'utilisation des connectivités.
Definition ItemTypes.h:516
eMeshAMRKind
Type de maillage AMR.
Definition MeshKind.h:48
Collection< ITiedInterface * > TiedInterfaceCollection
Collection d'interfaces liées.
std::int32_t Int32
Type entier signé sur 32 bits.