Arcane  v3.16.0.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
ParticleFamilySerializer.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/* ParticleFamilySerializer.cc (C) 2000-2024 */
9/* */
10/* Sérialisation/Désérialisation des familles de particules. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/core/ISerializer.h"
15#include "arcane/core/ItemPrinter.h"
16#include "arcane/core/IMesh.h"
17#include "arcane/core/IParallelMng.h"
18
19#include "arcane/mesh/ParticleFamilySerializer.h"
20#include "arcane/mesh/ParticleFamily.h"
21
22/*---------------------------------------------------------------------------*/
23/*---------------------------------------------------------------------------*/
24
25namespace Arcane::mesh
26{
27
28/*---------------------------------------------------------------------------*/
29/*---------------------------------------------------------------------------*/
30
31ParticleFamilySerializer::
32ParticleFamilySerializer(ParticleFamily* family)
33: TraceAccessor(family->traceMng())
34, m_family(family)
35{
36}
37
38/*---------------------------------------------------------------------------*/
39/*---------------------------------------------------------------------------*/
40
41void ParticleFamilySerializer::
42serializeItems(ISerializer* sbuf,Int32ConstArrayView local_ids)
43{
44 const Integer nb_item = local_ids.size();
45 ItemInfoListView items_internal(m_family);
46
47 switch(sbuf->mode()){
48 case ISerializer::ModeReserve:
49 sbuf->reserveInt64(1); // Pour le nombre de particules
50 sbuf->reserveSpan(eBasicDataType::Int64,nb_item); // Pour les uniqueId() des particules.
51 sbuf->reserveSpan(eBasicDataType::Int64,nb_item); // Pour les uniqueId() des mailles dans lesquelles se trouve les particules
52 break;
54 sbuf->putInt64(nb_item);
55 {
56 Int64UniqueArray particle_unique_ids(nb_item);
57 for( Integer z=0; z<nb_item; ++z ){
58 particle_unique_ids[z] = items_internal.uniqueId(local_ids[z]).asInt64();
59 }
60 sbuf->putSpan(particle_unique_ids);
61 }
62 {
63 Int64UniqueArray particles_cell_uid(nb_item);
64 for( Integer z=0; z<nb_item; ++z ){
65 Particle item(items_internal[local_ids[z]]);
66 bool has_cell = item.hasCell();
67 particles_cell_uid[z] = (has_cell) ? item.cell().uniqueId() : NULL_ITEM_UNIQUE_ID;
68 }
69 sbuf->putSpan(particles_cell_uid);
70 }
71 break;
73 deserializeItems(sbuf,nullptr);
74 break;
75 }
76}
77
78/*---------------------------------------------------------------------------*/
79/*---------------------------------------------------------------------------*/
80
81void ParticleFamilySerializer::
82deserializeItems(ISerializer* sbuf,Int32Array* local_ids)
83{
84 // NOTE: les mailles doivent avoir été désérialisées avant.
85 Int64UniqueArray particles_uid;
86 Int64UniqueArray cells_unique_id;
87 Int32UniqueArray cells_local_id;
88 Int32UniqueArray particles_owner;
89 IMesh* mesh = m_family->mesh();
90 IItemFamily* cell_family = mesh->cellFamily();
91 CellInfoListView internal_cells(cell_family);
92
93 Int64 nb_item = sbuf->getInt64();
94 particles_uid.resize(nb_item);
95 sbuf->getSpan(particles_uid);
96 cells_unique_id.resize(nb_item);
97 cells_local_id.resize(nb_item);
98 sbuf->getSpan(cells_unique_id);
99 Int32UniqueArray temporary_particles_local_id;
100 Int32Array* particles_local_id = (local_ids) ? local_ids : &temporary_particles_local_id;
101 particles_local_id->resize(nb_item);
102 Int32ArrayView local_ids_view = particles_local_id->view();
103 cell_family->itemsUniqueIdToLocalId(cells_local_id,cells_unique_id,true);
104
105 // Si on gère les particules fantômes, alors les particules ont un propriétaire
106 // et dans ce cas il faut créér les particules avec cette information.
107 // On suppose alors que le propriétaire d'une particule est la maille dans laquelle
108 // elle se trouve.
109 // NOTE: dans la version actuelle, le support des particules fantômes implique
110 // que ces dernières aient une table de hashage pour les uniqueId()
111 // (c'est à dire particle_family->hasUniqueIdMap() == true).
112 if (!m_family->getEnableGhostItems()){
113 m_family->addParticles(particles_uid,local_ids_view);
114 }
115 else{
116 particles_owner.resize(nb_item) ;
117 for( Integer zz=0; zz<nb_item; ++zz ){
118 Int32 cell_lid = cells_local_id[zz];
119 if (cell_lid!=NULL_ITEM_LOCAL_ID){
120 Cell c = internal_cells[ cell_lid ];
121 particles_owner[zz] = c.owner() ;
122 }
123 else
124 particles_owner[zz] = NULL_SUB_DOMAIN_ID;
125 }
126
127 m_family->addParticles2(particles_uid,particles_owner,local_ids_view);
128 }
129
130 // IMPORTANT: il faut le faire ici car cela peut changer via le endUpdate()
131 ItemInternalList internal_particles(m_family->itemsInternal());
132 for( Integer zz=0; zz<nb_item; ++zz ){
133 Particle p = internal_particles[ local_ids_view[zz] ];
134 Int32 cell_lid = cells_local_id[zz];
135 if (cell_lid!=NULL_ITEM_LOCAL_ID){
136 Cell c = internal_cells[ cell_lid ];
137 m_family->setParticleCell(p,c);
138 }
139 else
140 m_family->setParticleCell(p,Cell());
141 }
142}
143
144/*---------------------------------------------------------------------------*/
145/*---------------------------------------------------------------------------*/
146
147IItemFamily* ParticleFamilySerializer::
148family() const
149{
150 return m_family;
151}
152
153/*---------------------------------------------------------------------------*/
154/*---------------------------------------------------------------------------*/
155
156}
157
158/*---------------------------------------------------------------------------*/
159/*---------------------------------------------------------------------------*/
void resize(Int64 s)
Change le nombre d'éléments du tableau à s.
ArrayView< T > view() const
Vue mutable sur ce tableau.
Vue sur les informations des mailles.
Maille d'un maillage.
Definition Item.h:1191
constexpr Integer size() const noexcept
Nombre d'éléments du tableau.
Interface d'une famille d'entités.
Definition IItemFamily.h:84
virtual void itemsUniqueIdToLocalId(Int32ArrayView local_ids, Int64ConstArrayView unique_ids, bool do_fatal=true) const =0
Converti un tableau de numéros uniques en numéros locaux.
@ 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.
__host__ __device__ ItemUniqueId uniqueId(Int32 local_id) const
uniqueId() de l'entité de numéro local local_id
Vue sur une liste pour obtenir des informations sur les entités.
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
void deserializeItems(ISerializer *buf, Int32Array *local_ids) override
Désérialise depuis buf les entités de la famille family().
Particule.
Definition Item.h:1397
bool hasCell() const
Vrai si la particule est dans une maille du maillage.
Definition Item.h:1465
Cell cell() const
Maille à laquelle appartient la particule. Il faut appeler setCell() avant d'appeler cette fonction....
Definition Item.h:1459
Famille de particules.
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
UniqueArray< Int32 > Int32UniqueArray
Tableau dynamique à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:428
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.