Arcane  v3.16.0.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
CellFamilySerializer.cc
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2024 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/* CellFamilySerializer.cc (C) 2000-2024 */
9/* */
10/* Sérialisation/Désérialisation des familles de mailles. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/mesh/CellFamilySerializer.h"
15
16#include "arcane/core/ISerializer.h"
17#include "arcane/core/ItemPrinter.h"
18#include "arcane/core/IMesh.h"
19#include "arcane/core/MeshPartInfo.h"
20
21#include "arcane/mesh/FullItemInfo.h"
22#include "arcane/mesh/DynamicMeshIncrementalBuilder.h"
23#include "arcane/mesh/OneMeshItemAdder.h"
24
25/*---------------------------------------------------------------------------*/
26/*---------------------------------------------------------------------------*/
27
28namespace Arcane::mesh
29{
30
31/*---------------------------------------------------------------------------*/
32/*---------------------------------------------------------------------------*/
33
34CellFamilySerializer::
35CellFamilySerializer(CellFamily* family,bool use_flags,
37: TraceAccessor(family->traceMng())
38, m_mesh_builder(mesh_builder)
39, m_family(family)
40, m_use_flags(use_flags)
41{
42}
43
44/*---------------------------------------------------------------------------*/
45/*---------------------------------------------------------------------------*/
46
47void CellFamilySerializer::
48serializeItems(ISerializer* buf,Int32ConstArrayView cells_local_id)
49{
50 ItemInternalList cells_internal = m_family->itemsInternal();
51
52 const Integer nb_cell = cells_local_id.size();
53
54 IMesh* mesh = m_family->mesh();
55 Int32 my_rank = mesh->meshPartInfo().partRank();
56 const Integer parent_info = FullCellInfo::parentInfo(mesh);
57 const bool has_amr = mesh->isAmrActivated();
58 const bool has_edge = m_mesh_builder->hasEdge();
59 const bool use_flags = m_use_flags;
60
61 info(4) << "_serializeItems : "
62 << mesh->name() << " "
63 << m_family->name() << " "
64 << m_family->parentFamilyDepth();
65
66 switch(buf->mode()){
67 case ISerializer::ModeReserve:
68 {
69 buf->reserveInt64(2); // 1 pour le rang du sous-domaine et 1 pour le nombre de mailles
70 UniqueArray<Int64> tmp_buf;
71 tmp_buf.reserve(200);
72 for( Integer i_cell=0; i_cell<nb_cell; ++i_cell ){
73 Int32 lid = cells_local_id[i_cell];
74 ItemInternal* cell = cells_internal[lid];
75 tmp_buf.clear();
76 FullCellInfo::dump(cell,tmp_buf,parent_info,has_edge,has_amr,use_flags);
77 buf->reserveInt64(1);
78 buf->reserveSpan(tmp_buf);
79 }
80 }
81 break;
83 {
84 buf->putInt64(my_rank); // Stocke le numéro du sous-domaine
85 buf->putInt64(nb_cell); // Stocke le nombre de mailles
86 info(4) << "Serialize: Put: nb_cell=" << nb_cell;
87 UniqueArray<Int64> tmp_buf;
88 tmp_buf.reserve(200);
89 for( Integer i_cell=0; i_cell<nb_cell; ++i_cell ){
90 Int32 lid = cells_local_id[i_cell];
91 ItemInternal* cell = cells_internal[lid];
92 tmp_buf.clear();
93 FullCellInfo::dump(cell,tmp_buf,parent_info,has_edge,has_amr,use_flags);
94 buf->putInt64(tmp_buf.largeSize());
95 buf->putSpan(tmp_buf);
96 }
97 }
98 break;
100 {
101 deserializeItems(buf,nullptr);
102 }
103 break;
104 }
105}
106
107/*---------------------------------------------------------------------------*/
108/*---------------------------------------------------------------------------*/
109
110void CellFamilySerializer::
111deserializeItems(ISerializer* buf,Int32Array* cells_local_id)
112{
113 IMesh* mesh = m_family->mesh();
114 ItemTypeMng* itm = mesh->itemTypeMng();
115 Int32 my_rank = mesh->meshPartInfo().partRank();
116 Int32 orig_rank = CheckedConvert::toInt32(buf->getInt64()); // Numéro du sous-domaine source
117 Int64 nb_cell = buf->getInt64();
118 const Integer parent_info = FullCellInfo::parentInfo(mesh);
119
120 Int64UniqueArray mem_buf;
121 mem_buf.reserve(200);
122 Int32ArrayView locals_id_view;
123 bool use_array = false;
124 if (cells_local_id){
125 cells_local_id->resize(nb_cell);
126 locals_id_view = (*cells_local_id);
127 use_array = true;
128 }
129 const bool is_check = arcaneIsCheck();
130 const bool has_edge = m_mesh_builder->hasEdge();
131 const bool has_amr = mesh->isAmrActivated();
132 const bool use_flags = m_use_flags;
133 info(4) << "DeserializeCells: nb_cell=" << nb_cell << " orig=" << orig_rank << " has_edge=" << has_edge
134 << " has_amr=" << has_amr << " use_flags=" << use_flags;
135 for( Integer i_cell=0; i_cell<nb_cell; ++i_cell ){
136 Int64 memory_needed = buf->getInt64();
137 mem_buf.resize(memory_needed);
138 buf->getSpan(mem_buf);
139 FullCellInfo current_cell(mem_buf,0,itm,parent_info,has_edge,has_amr,use_flags);
140 ItemInternal* icell = m_mesh_builder->oneMeshItemAdder()->addOneCell(current_cell);
141 Cell cell(icell);
142 if (use_array)
143 locals_id_view[i_cell] = icell->localId();
144 {
145 // Attention dans le flag IT_Own n'est pas correct, il est forcé apres
146 if (use_flags)
147 icell->setFlags(current_cell.flags()) ;
148 // Force les owners à la valeur de sérialisation, car ils ne seront
149 // pas corrects dans le cas ou la maille ou un de ses éléments
150 // existait déjà
151 icell->setOwner(current_cell.owner(),my_rank);
152 if (is_check){
153 // Vérifie que les unique_ids des éléments actuels de la maille
154 // sont les même que ceux qu'on désérialise.
155 bool has_error = false;
156 Integer node_index = 0;
157 for( Node node : cell.nodes() ){
158 has_error |= (node.uniqueId()!=current_cell.nodeUniqueId(node_index));
159 ++node_index;
160 }
161 Integer edge_index = 0;
162 for( Edge edge : cell.edges() ){
163 has_error |= (edge.uniqueId()!=current_cell.edgeUniqueId(edge_index));
164 ++edge_index;
165 }
166 Integer face_index = 0;
167 for( Face face : cell.faces() ){
168 has_error |= (face.uniqueId()!=current_cell.faceUniqueId(face_index));
169 ++face_index;
170 }
171 if (has_error){
172 node_index = 0;
173 for( Node node : cell.nodes() ){
174 info() << "Cell c=" << ItemPrinter(cell) << " node=" << ItemPrinter(node)
175 << " remote_uid=" << current_cell.nodeUniqueId(node_index);
176 ++node_index;
177 }
178 edge_index = 0;
179 for( Edge edge : cell.edges() ){
180 info() << "Cell c=" << ItemPrinter(cell) << " edge=" << ItemPrinter(edge)
181 << " remote_uid=" << current_cell.edgeUniqueId(edge_index);
182 ++edge_index;
183 }
184 face_index = 0;
185 for( Face face : cell.faces() ){
186 info() << "Cell c=" << ItemPrinter(cell) << " face=" << ItemPrinter(face)
187 << " remote_uid=" << current_cell.faceUniqueId(face_index);
188 ++face_index;
189 }
190 ARCANE_FATAL("Incoherent local and remote node, edge or face unique id");
191 }
192 }
193
194 // TODO: vérifier si cela est utile. A priori non car le travail
195 // est fait lors de la désérialisation des mailles.
196 Integer node_index = 0;
197 for( Node node : cell.nodes() ){
198 node.mutableItemBase().setOwner(current_cell.nodeOwner(node_index),my_rank);
199 ++node_index;
200 }
201 Integer edge_index = 0;
202 for( Edge edge : cell.edges() ){
203 edge.mutableItemBase().setOwner(current_cell.edgeOwner(edge_index),my_rank);
204 ++edge_index;
205 }
206 Integer face_index = 0;
207 for( Face face : cell.faces() ){
208 face.mutableItemBase().setOwner(current_cell.faceOwner(face_index),my_rank);
209 ++face_index;
210 }
211 }
212 }
213 info(4) << "EndDeserializeCells: nb_cell=" << nb_cell << " orig=" << orig_rank;
214}
215
216/*---------------------------------------------------------------------------*/
217/*---------------------------------------------------------------------------*/
218
219IItemFamily* CellFamilySerializer::
220family() const
221{
222 return m_family;
223}
224
225/*---------------------------------------------------------------------------*/
226/*---------------------------------------------------------------------------*/
227
228} // End namespace Arcane::mesh
229
230/*---------------------------------------------------------------------------*/
231/*---------------------------------------------------------------------------*/
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
Int64 largeSize() const
Nombre d'éléments du vecteur (en 64 bits)
void clear()
Supprime les éléments 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.
Maille d'un maillage.
Definition Item.h:1191
FaceConnectedListViewType faces() const
Liste des faces de la maille.
Definition Item.h:1272
EdgeConnectedListViewType edges() const
Liste des arêtes de la maille.
Definition Item.h:1290
constexpr Integer size() const noexcept
Nombre d'éléments du tableau.
Arête d'une maille.
Definition Item.h:809
Face d'une maille.
Definition Item.h:944
Interface d'une famille d'entités.
Definition IItemFamily.h:84
@ ModePut
Le sérialiseur attend des reserve()
virtual Int64 getInt64()=0
Récupère une taille.
virtual void putSpan(Span< const Real > values)
Ajoute le tableau values.
virtual eMode mode() const =0
Mode de fonctionnement actuel.
virtual void getSpan(Span< Real > values)
Récupère le tableau values.
virtual void reserveSpan(eBasicDataType dt, Int64 n)=0
Réserve de la mémoire pour n valeurs de dt.
virtual void putInt64(Int64 value)=0
Ajoute l'entier value.
Int32 localId() const
Numéro local (au sous-domaine) de l'entité
Structure interne d'une entité de maillage.
Classe utilitaire pour imprimer les infos sur une entité.
Definition ItemPrinter.h:35
Gestionnaire des types d'entités de maillage.
Definition ItemTypeMng.h:66
NodeConnectedListViewType nodes() const
Liste des noeuds de l'entité
Definition Item.h:782
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é
Noeud d'un maillage.
Definition Item.h:573
TraceMessage info() const
Flot pour un message d'information.
Vecteur 1D de données avec sémantique par valeur (style STL).
void deserializeItems(ISerializer *buf, Int32Array *cells_local_id) override
Désérialise depuis buf les entités de la famille family().
Famille de mailles.
Definition CellFamily.h:46
Construction d'un maillage de manière incrémentale.
Infos pour créer/sérialiser une maille connaissant les uniqueId() et owner() de toutes ces sous-entit...
Int32 toInt32(Int64 v)
Converti un Int64 en un Int32.
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
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
ConstArrayView< ItemInternal * > ItemInternalList
Type de la liste interne des entités.
Definition ItemTypes.h:466
ArrayView< Int32 > Int32ArrayView
Equivalent C d'un tableau à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:540
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.