Arcane  v3.16.0.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
TiedInterfaceExchanger.cc
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2022 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/* TiedInterfaceExchanger.cc (C) 2000-2016 */
9/* */
10/* Echangeur entre sous-domaines des interfaces liées. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/utils/ArcanePrecomp.h"
15
16#include "arcane/utils/NotSupportedException.h"
17#include "arcane/utils/ArgumentException.h"
18
19#include "arcane/mesh/TiedInterfaceExchanger.h"
20#include "arcane/mesh/DynamicMesh.h"
21#include "arcane/mesh/TiedInterface.h"
22#include "arcane/mesh/FaceFamily.h"
23
24#include "arcane/SerializeBuffer.h"
25#include "arcane/IParallelMng.h"
26#include "arcane/ItemPrinter.h"
27#include "arcane/ItemFamilySerializeArgs.h"
28
29/*---------------------------------------------------------------------------*/
30/*---------------------------------------------------------------------------*/
31
32ARCANE_BEGIN_NAMESPACE
33
34/*---------------------------------------------------------------------------*/
35/*---------------------------------------------------------------------------*/
36
37ARCANE_MESH_BEGIN_NAMESPACE
38
39/*---------------------------------------------------------------------------*/
40/*---------------------------------------------------------------------------*/
41
43: public TraceAccessor
44{
45 public:
46 OneSubDomainInfo(ITraceMng* tm,Int32 rank)
47 : TraceAccessor(tm), m_rank(rank){}
48 public:
49 void addOne(Face face,ConstArrayView<TiedNode> tied_nodes,
50 ConstArrayView<TiedFace> tied_faces)
51 {
52 //info() << "ADD_ONE_TIED_FACE face=" << ItemPrinter(face) << " rank=" << m_rank;
53 uids.add(face.uniqueId());
54 Integer nb_tied_node = tied_nodes.size();
55 Integer nb_tied_face = tied_faces.size();
56 nb_items.add(nb_tied_node);
57 nb_items.add(nb_tied_face);
58 for( Integer z=0; z<nb_tied_node; ++z ){
59 const TiedNode& tn = tied_nodes[z];
60 slaves_node_uid.add(tn.node().uniqueId());
61 Real2 iso = tn.isoCoordinates();
62 //info() << "ADD NODE node=" << ItemPrinter(tn.node()) << " iso=" << iso;
63 isos.add(iso.x);
64 isos.add(iso.y);
65 }
66 for( Integer z=0; z<nb_tied_face; ++z ){
67 const TiedFace& tf = tied_faces[z];
68 slaves_face_uid.add(tf.face().uniqueId());
69 //info() << "ADD FACE face=" << ItemPrinter(tf.face());
70 }
71 }
72 void serializeReserve(ISerializer* buf)
73 {
74 buf->reserveArray(nb_items);
75 buf->reserveArray(isos);
76 buf->reserveArray(uids);
77 buf->reserveArray(slaves_node_uid);
78 buf->reserveArray(slaves_face_uid);
79 }
80
81 void serializePut(ISerializer* buf)
82 {
83 buf->putArray(uids);
84 buf->putArray(nb_items);
85 buf->putArray(isos);
86 buf->putArray(slaves_node_uid);
87 buf->putArray(slaves_face_uid);
88 }
89
90 void deserialize(ISerializer* buf)
91 {
92 buf->getArray(uids);
93 info() << "DESERIALIZE_INFO rank=" << m_rank << " nb_face=" << uids.largeSize();
94 buf->getArray(nb_items);
95 buf->getArray(isos);
96 buf->getArray(slaves_node_uid);
97 info() << "NODES: " << slaves_node_uid;
98 buf->getArray(slaves_face_uid);
99 info() << "FACES: " << slaves_face_uid;
100 }
101
102 public:
103 Int32 m_rank;
104 Int64UniqueArray uids;
105 Int64UniqueArray slaves_node_uid;
106 Int64UniqueArray slaves_face_uid;
107 IntegerUniqueArray nb_items;
108 RealUniqueArray isos;
113};
114
115/*---------------------------------------------------------------------------*/
116/*---------------------------------------------------------------------------*/
117
118/*---------------------------------------------------------------------------*/
119/*---------------------------------------------------------------------------*/
120
122: public TraceAccessor
124{
125 public:
126 DeserializedInfo(IMesh* mesh,ITraceMng* tm)
127 : TraceAccessor(tm), m_face_family(mesh->faceFamily()), m_node_family(mesh->nodeFamily()){}
128 public:
129 struct FaceInfo
130 {
139
140 FaceInfo(OneSubDomainInfo* _sd_info,
141 Integer _face_index,
142 Integer _slave_face_index,
143 Integer _slave_node_index)
144 {
145 sd_info = _sd_info;
146 face_index = _face_index;
147 slave_face_index = _slave_face_index;
148 slave_node_index = _slave_node_index;
149 }
150 };
151
156 {
157 Integer nb_uid = sdi->uids.size();
158 Integer face_index = 0;
159 Integer node_index = 0;
160 info(4) << "BUILD_AFTER_DESERIALIZE_INFO rank=" << sdi->m_rank << " nb_face=" << nb_uid;
161 for( Integer i=0; i<nb_uid; ++i ){
162 Int64 uid = sdi->uids[i];
163 Integer nb_slave_node = sdi->nb_items[i*2];
164 Integer nb_slave_face = sdi->nb_items[(i*2)+1];
165 //info() << "ADD_FACE uid=" << uid << " nb_node=" << nb_slave_node << " nb_face=" << nb_slave_face;
166 m_index_map.insert(std::make_pair(uid,FaceInfo(sdi,i,face_index,node_index)));
167 face_index += nb_slave_face;
168 node_index += nb_slave_node;
169 }
170 m_sdi_array.add(sdi);
171 }
172
173 void convertUniqueIds()
174 {
175 for(Integer z=0, n=m_sdi_array.size(); z<n; ++ z){
176 OneSubDomainInfo* sdi = m_sdi_array[z];
177
178 Integer nb_total_slave_face = sdi->slaves_face_uid.size();
179 info(4) << "CONVERT_UID nb_slave_face=" << nb_total_slave_face;
180 sdi->slaves_face_local_id.resize(sdi->slaves_face_uid.size());
181 m_face_family->itemsUniqueIdToLocalId(sdi->slaves_face_local_id,sdi->slaves_face_uid);
182
183 Integer nb_total_slave_node = sdi->slaves_node_uid.size();
184 info(4) << "CONVERT_UID nb_slave_node=" << nb_total_slave_node;
185 sdi->slaves_node_local_id.resize(sdi->slaves_node_uid.size());
186 m_node_family->itemsUniqueIdToLocalId(sdi->slaves_node_local_id,sdi->slaves_node_uid);
187 }
188 }
189
190 const FaceInfo& _getInfo(Int64 uid)
191 {
192 std::map<Int64,FaceInfo>::const_iterator iter = m_index_map.find(uid);
193 if (iter==m_index_map.end())
194 throw ArgumentException(A_FUNCINFO,String::format("Can not find uid '{0}'",uid));
195 return iter->second;
196 }
197
198 void getNbSlave(Int64 uid,Integer* nb_node,Integer* nb_face)
199 {
200 const FaceInfo& fi = _getInfo(uid);
201 Integer face_index = fi.face_index;
202 *nb_node = fi.sd_info->nb_items[face_index*2];
203 *nb_face = fi.sd_info->nb_items[(face_index*2)+1];
204 }
205
206 virtual void fillTiedInfos(Face face,
207 Int32ArrayView tied_nodes_lid,
208 Real2ArrayView tied_nodes_isos,
209 Int32ArrayView tied_faces_lid)
210 {
211 const FaceInfo& fi = _getInfo(face.uniqueId());
212 OneSubDomainInfo* sdi = fi.sd_info;
213 Int32ConstArrayView slaves_face_local_id = sdi->slaves_face_local_id.constView();
214 Int32ConstArrayView slaves_node_local_id = sdi->slaves_node_local_id.constView();
215 Integer face_index = fi.face_index;
216 Integer nb_node = sdi->nb_items[face_index*2];
217 Integer nb_face = sdi->nb_items[(face_index*2)+1];
218 RealConstArrayView isos = sdi->isos.subConstView(fi.slave_node_index*2,nb_node*2);
219 Int32ConstArrayView nodes_lid = slaves_node_local_id.subView(fi.slave_node_index,nb_node);
220 Int32ConstArrayView faces_lid = slaves_face_local_id.subView(fi.slave_face_index,nb_face);
221 tied_nodes_lid.copy(nodes_lid);
222 tied_faces_lid.copy(faces_lid);
223 for( Integer z=0; z<nb_node; ++z )
224 tied_nodes_isos[z] = Real2(isos[(z*2)],isos[(z*2)+1]);
225 }
226
227 private:
228
229 IItemFamily* m_face_family;
230 IItemFamily* m_node_family;
231 std::map<Int64,FaceInfo> m_index_map;
232 UniqueArray<OneSubDomainInfo*> m_sdi_array;
233};
234
235/*---------------------------------------------------------------------------*/
236/*---------------------------------------------------------------------------*/
237
238/*---------------------------------------------------------------------------*/
239/*---------------------------------------------------------------------------*/
240
241TiedInterfaceExchanger::
242TiedInterfaceExchanger(DynamicMesh* mesh)
243: TraceAccessor(mesh->traceMng())
244, m_mesh(mesh)
245, m_sub_domain(mesh->subDomain())
246, m_deserialized_info(new DeserializedInfo(mesh,traceMng()))
247, m_my_rank(mesh->parallelMng()->commRank())
248{
249}
250
251/*---------------------------------------------------------------------------*/
252/*---------------------------------------------------------------------------*/
253
254TiedInterfaceExchanger::
255~TiedInterfaceExchanger()
256{
257 for( SubDomainInfoMap::const_iterator iter(m_infos.begin()); iter!=m_infos.end(); ++iter )
258 delete iter->second;
259 delete m_deserialized_info;
260}
261
262/*---------------------------------------------------------------------------*/
263/*---------------------------------------------------------------------------*/
264
265inline TiedInterfaceExchanger::OneSubDomainInfo* TiedInterfaceExchanger::
266_getInfo(Int32 rank)
267{
268 SubDomainInfoMap::const_iterator iter = m_infos.find(rank);
269 if (iter!=m_infos.end())
270 return iter->second;
271 OneSubDomainInfo* sdi = new OneSubDomainInfo(traceMng(),rank);
272 m_infos.insert(std::make_pair(rank,sdi));
273 return sdi;
274}
275
276/*---------------------------------------------------------------------------*/
277/*---------------------------------------------------------------------------*/
278
281{
282 // precond:
283 // - cet appel doit se faire avant face.owner() new contiennent
284 // les nouveaux propriétaires car dans ce cas le ENUMERATE_FACE
285 // ne fonctionnera pas correctement puisqu'il s'agit d'une groupe
286 // de mailles propres et il est remis à jour lorsque les propriétaires
287 // changent.
288 // - les faces esclaves et leur face maitre doivent avoir le même propriétaire
289
290 // Parcours l'ensemble des interfaces liées et:
291 // 1- sauve les infos sur les faces liées qui seront conservées
292 // 2- prépare les infos pour chaque sous-domaine.
293 // Chaque face liée contient soit la face maître associée (s'il s'agit
294 // d'une face esclave), soit la liste des faces esclaves (s'il s'agit
295 // d'une face maître).
296 // 3- Supprime les infos de connectivité de chaque face.
297
298 ConstArrayView<TiedInterface*> tied_interfaces(m_mesh->trueTiedInterfaces());
299 FaceFamily& face_family = m_mesh->trueFaceFamily();
300 VariableItemInt32& new_owners(face_family.itemsNewOwner());
301 for( Integer i=0, n=tied_interfaces.size(); i<n; ++i ){
302 TiedInterface* ti = tied_interfaces[i];
303 FaceGroup master_group = ti->masterInterface();
304 TiedInterfaceNodeList tied_nodes = ti->tiedNodes();
305 TiedInterfaceFaceList tied_faces = ti->tiedFaces();
306 Integer index = 0;
307 ENUMERATE_FACE(iface,master_group){
308 Face face = *iface;
309 Int32 owner = new_owners[iface];
310 OneSubDomainInfo* sdi = _getInfo(owner);
311 ConstArrayView<TiedNode> face_tied_nodes = tied_nodes[index];
312 ConstArrayView<TiedFace> face_tied_faces = tied_faces[index];
313 //info() << "ADD_TIED_INFOS: face=" << ItemPrinter(face) << " n1=" << face_tied_nodes.size() << " n2=" << face_tied_faces.size();
314 sdi->addOne(face,face_tied_nodes,face_tied_faces);
315 ++index;
316 }
317 face_family.removeTiedInterface(ti);
318 }
319}
320
321/*---------------------------------------------------------------------------*/
322/*---------------------------------------------------------------------------*/
334{
335 ISerializer* buf = args.serializer();
336 Int32 rank = args.rank();
337 OneSubDomainInfo* sdi = _getInfo(rank);
338 switch(buf->mode()){
339 case ISerializer::ModeReserve:
340 sdi->serializeReserve(buf);
341 break;
343 sdi->serializePut(buf);
344 break;
346 sdi->deserialize(buf);
347 m_deserialized_info->buildAfterDeserializeInfo(sdi);
348 break;
349 }
350}
351
352/*---------------------------------------------------------------------------*/
353/*---------------------------------------------------------------------------*/
354
356finalize()
357{
358 // NOTE: il faut être certain que cette méthode soit appelée
359 // une fois que les localId() des entités n'évoluent plus
360 // (c.a.d après un compactage et un tri)
361
362 // Il faut éventuellement reconstruire les infos après désérialisation
363 // de notre propre sous-domaine car celui-ci n'a pas été désérialisé.
364 OneSubDomainInfo* sdi = _getInfo(m_my_rank);
365 m_deserialized_info->buildAfterDeserializeInfo(sdi);
366
367 // Il faut convertir les uniqueId en localId.
368 // Il ne faut surtout pas le faire avant d'être ici car les
369 // localId() peuvent changer durant un repartitonnement.
370 m_deserialized_info->convertUniqueIds();
371
372 // Toutes les nouvelles entités et les groupes
373 // ont été mis à jour. Il reste maintenant à récupérer les
374 // informations de chaque face liée, à savoir la liste des noeuds
375 // et face esclave ainsi que les coordonnées iso.
376 ConstArrayView<TiedInterface*> tied_interfaces(m_mesh->trueTiedInterfaces());
377 IntegerUniqueArray nb_slave_nodes;
378 IntegerUniqueArray nb_slave_faces;
379 FaceFamily& face_family = m_mesh->trueFaceFamily();
380 for( Integer i=0, n=tied_interfaces.size(); i<n; ++i ){
381 TiedInterface* ti = tied_interfaces[i];
382 FaceGroup master_group = ti->masterInterface();
383 Integer nb_master_face = master_group.size();
384 nb_slave_nodes.resize(nb_master_face);
385 nb_slave_faces.resize(nb_master_face);
386 Integer index = 0;
387 ENUMERATE_FACE(iface,master_group){
388 Face face = *iface;
389 Integer nb_node = 0;
390 Integer nb_face = 0;
391 //info() << "TRY GET INFO face=" << ItemPrinter(face) << " owner=" << face.owner()
392 m_deserialized_info->getNbSlave(face.uniqueId(),&nb_node,&nb_face);
393 nb_slave_nodes[index] = nb_node;
394 nb_slave_faces[index] = nb_face;
395 ++index;
396 }
397 ti->rebuild(m_deserialized_info,nb_slave_nodes,nb_slave_faces);
398 face_family.applyTiedInterface(ti);
399 ti->checkValid();
400 }
401}
402
403/*---------------------------------------------------------------------------*/
404/*---------------------------------------------------------------------------*/
405
407family() const
408{
409 return m_mesh->faceFamily();
410}
411
412/*---------------------------------------------------------------------------*/
413/*---------------------------------------------------------------------------*/
414
415ARCANE_MESH_END_NAMESPACE
416ARCANE_END_NAMESPACE
417
418/*---------------------------------------------------------------------------*/
419/*---------------------------------------------------------------------------*/
#define ENUMERATE_FACE(name, group)
Enumérateur générique d'un groupe de faces.
Integer size() const
Nombre d'éléments du vecteur.
void resize(Int64 s)
Change le nombre d'éléments du tableau à s.
Vue constante d'un tableau de type T.
constexpr ConstArrayView< T > subView(Integer abegin, Integer asize) const noexcept
Sous-vue (constante) à partir de l'élément abegin et contenant asize éléments.
constexpr Integer size() const noexcept
Nombre d'éléments du tableau.
constexpr ConstArrayView< T > subConstView(Integer abegin, Integer asize) const noexcept
Sous-vue (constante) à partir de l'élément abegin et contenant asize éléments.
Face d'une maille.
Definition Item.h:944
Interface d'une famille d'entités.
Definition IItemFamily.h:84
virtual void putArray(Span< const Real > values)=0
Sauve le nombre d'éléments et les values éléments.
virtual void reserveArray(Span< const Real > values)=0
Réserve pour sauver le nombre d'éléments et les values éléments.
virtual void getArray(Array< Real > &values)=0
Redimensionne et remplit values.
@ ModePut
Le sérialiseur attend des reserve()
virtual eMode mode() const =0
Mode de fonctionnement actuel.
Interface du gestionnaire de traces.
Arguments des callbacks de sérialisation des familles d'entités.
Int32 rank() const
Rang de la source ou de la destination.
ISerializer * serializer() const
Sérialiseur associé
Integer size() const
Nombre d'éléments du groupe.
Definition ItemGroup.h:88
ItemUniqueId uniqueId() const
Identifiant unique sur tous les domaines.
Definition Item.h:225
Classe gérant un vecteur de réel de dimension 2.
Definition Real2.h:121
constexpr __host__ __device__ Real2 & add(Real2 b)
Ajoute b au couple.
Definition Real2.h:210
Face semi-conforme du maillage.
Definition TiedFace.h:35
Face face() const
Face soudée.
Definition TiedFace.h:56
void buildAfterDeserializeInfo(OneSubDomainInfo *sdi)
Construit les infos après déserialisation.
Int32UniqueArray slaves_node_local_id
Uniquement après désérialisation, contient le localId() de chaque entité de slaves_node_uid.
Int32UniqueArray slaves_face_local_id
Uniquement après désérialisation, contient le localId() de chaque entité de slaves_face_uid.
void serialize(const ItemFamilySerializeArgs &args) override
Sérialise les faces dans le tampon buf.
void initialize() override
Initialise l'instance avant le début des échanges.
IItemFamily * family() const override
Famille associée.
void finalize() override
Effectue les traitements de fin d'échange.
Informations sur les semi-conformitées du maillage.
virtual TiedInterfaceFaceList tiedFaces() const
Liste des informations sur les faces esclaves d'une face maître.
virtual FaceGroup masterInterface() const
Groupe contenant les faces maîtres.
virtual TiedInterfaceNodeList tiedNodes() const
Liste des informations sur les noeuds esclaves d'une face maître.
Noeud semi-conforme du maillage.
Definition TiedNode.h:41
Node node() const
Noeud lié
Definition TiedNode.h:62
Real2 isoCoordinates() const
Coordonnées iso-barycentriques du noeud.
Definition TiedNode.h:65
TraceAccessor(ITraceMng *m)
Construit un accesseur via le gestionnaire de trace m.
TraceMessage info() const
Flot pour un message d'information.
ITraceMng * traceMng() const
Gestionnaire de trace.
ItemGroupT< Face > FaceGroup
Groupe de faces.
Definition ItemTypes.h:178
ItemVariableScalarRefT< Int32 > VariableItemInt32
Grandeur de type entier 32 bits.
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
UniqueArray< Int32 > Int32UniqueArray
Tableau dynamique à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:428
UniqueArray< Real > RealUniqueArray
Tableau dynamique à une dimension de réels.
Definition UtilsTypes.h:436
UniqueArray< Integer > IntegerUniqueArray
Tableau dynamique à une dimension d'entiers.
Definition UtilsTypes.h:434
std::int32_t Int32
Type entier signé sur 32 bits.
ConstArrayView< Real > RealConstArrayView
Equivalent C d'un tableau à une dimension de réels.
Definition UtilsTypes.h:575
Real y
deuxième composante du couple
Definition Real2.h:35
Real x
première composante du couple
Definition Real2.h:34
Integer slave_node_index
Indice dans isos et slaves_node_uid du première noeud esclave.
Integer slave_face_index
Indice dans slaves_face_uid de la première face esclave.
Integer face_index
Indice de la face dans le tableau uid.