Arcane  v3.16.2.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
VariableScalar.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/* VariableScalar.cc (C) 2000-2025 */
9/* */
10/* Variable scalaire. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/core/VariableScalar.h"
15
16#include "arcane/utils/NotSupportedException.h"
17#include "arcane/utils/ArgumentException.h"
18#include "arcane/utils/FatalErrorException.h"
19#include "arcane/utils/TraceInfo.h"
20#include "arcane/utils/Ref.h"
21#include "arcane/utils/ITraceMng.h"
22
23#include "arcane/core/VariableDiff.h"
24#include "arcane/core/VariableBuildInfo.h"
25#include "arcane/core/VariableInfo.h"
26#include "arcane/core/IApplication.h"
27#include "arcane/core/IVariableMng.h"
28#include "arcane/core/IItemFamily.h"
29#include "arcane/core/IVariableSynchronizer.h"
30#include "arcane/core/IDataReader.h"
31#include "arcane/core/ItemGroup.h"
32#include "arcane/core/IDataFactoryMng.h"
33#include "arcane/core/IParallelMng.h"
34#include "arcane/core/IMesh.h"
35#include "arcane/core/VariableComparer.h"
36#include "arcane/core/internal/IVariableInternal.h"
37#include "arcane/core/internal/IVariableMngInternal.h"
38
39#include "arcane/core/datatype/DataStorageBuildInfo.h"
40
41/*---------------------------------------------------------------------------*/
42/*---------------------------------------------------------------------------*/
43
44namespace Arcane
46
47/*---------------------------------------------------------------------------*/
48/*---------------------------------------------------------------------------*/
49
50template<class DataType>
52: public VariableDiff<DataType>
53{
54 typedef VariableDataTypeTraitsT<DataType> VarDataTypeTraits;
57 public:
58 //TODO: a simplifier car recopie de ArrayVariableDiff
59 // mais pour les variables scalaires il n'y a qu'une valeur et aucun groupe
60 // associé.
63 const VariableComparerArgs& compare_args)
64 {
65 const int max_print = compare_args.maxPrint();
66 const bool compare_ghost = compare_args.isCompareGhost();
67 ItemGroup group = var->itemGroup();
68 if (group.null())
69 return {};
70 IMesh* mesh = group.mesh();
71 if (!mesh)
72 return {};
73 ITraceMng* msg = mesh->traceMng();
74 IParallelMng* pm = mesh->parallelMng();
75
76 GroupIndexTable* group_index_table = (var->isPartial()) ? group.localIdToIndex().get() : nullptr;
77
78 int nb_diff = 0;
79 bool compare_failed = false;
80 Integer ref_size = ref.size();
81 ENUMERATE_ITEM(i,group){
82 const Item& item = *i;
83 if (!item.isOwn() && !compare_ghost)
84 continue;
85 Integer index = item.localId();
86 if (group_index_table){
87 index = (*group_index_table)[index];
88 if (index<0)
89 continue;
90 }
91
92 DataType diff = DataType();
93 if (index>=ref_size){
94 ++nb_diff;
95 compare_failed = true;
96 }
97 else{
98 DataType dref = ref[index];
99 DataType dcurrent = current[index];
100 if (VarDataTypeTraits::verifDifferent(dref,dcurrent,diff,true)){
101 this->m_diffs_info.add(DiffInfo(dcurrent,dref,diff,item,NULL_ITEM_ID));
102 ++nb_diff;
103 }
104 }
105 }
106 if (compare_failed){
107 Int32 sid = pm->commRank();
108 const String& var_name = var->name();
109 msg->pinfo() << "Processor " << sid << " : "
110 << " Unable to compare : elements numbers are different !"
111 << " pour la variable " << var_name << " ref_size=" << ref_size;
112
113 }
114 if (nb_diff!=0)
115 this->_sortAndDump(var,pm,max_print);
116
117 return VariableComparerResults(nb_diff);
118 }
119
120 VariableComparerResults
121 checkReplica(IVariable* var, const DataType& var_value,
122 const VariableComparerArgs& compare_args)
123 {
124 IParallelMng* replica_pm = var->_internalApi()->replicaParallelMng();
125 if (!replica_pm)
126 return {};
127 const int max_print = compare_args.maxPrint();
128 // Appelle la bonne spécialisation pour être certain que le type template possède
129 // la réduction.
130 using ReduceType = typename VariableDataTypeTraitsT<DataType>::HasReduceMinMax;
131 if constexpr(std::is_same<TrueType,ReduceType>::value)
132 return _checkReplica2(replica_pm, var_value);
133 ARCANE_UNUSED(replica_pm);
134 ARCANE_UNUSED(var);
135 ARCANE_UNUSED(var_value);
136 ARCANE_UNUSED(max_print);
137 throw NotSupportedException(A_FUNCINFO);
138 }
139
140 private:
141
142 VariableComparerResults
143 _checkReplica2(IParallelMng* pm, const DataType& var_value)
144 {
145 Int32 nb_rank = pm->commSize();
146 if (nb_rank==1)
147 return {};
148
149 DataType max_value = pm->reduce(Parallel::ReduceMax,var_value);
150 DataType min_value = pm->reduce(Parallel::ReduceMin,var_value);
151
152 Integer nb_diff = 0;
153 DataType diff = DataType();
154 if (VarDataTypeTraits::verifDifferent(min_value,max_value,diff,true)){
155 this->m_diffs_info.add(DiffInfo(min_value,max_value,diff,0,NULL_ITEM_ID));
156 ++nb_diff;
157 }
158 return VariableComparerResults(nb_diff);
159 }
160
161};
162
163/*---------------------------------------------------------------------------*/
164/*---------------------------------------------------------------------------*/
165
166/*---------------------------------------------------------------------------*/
167/*---------------------------------------------------------------------------*/
168
169template<typename T> VariableScalarT<T>::
171: Variable(v,info)
172, m_value(nullptr)
173{
174 IDataFactoryMng* df = v.dataFactoryMng();
175 DataStorageBuildInfo storage_build_info(v.traceMng());
176 String storage_full_type = info.storageTypeInfo().fullName();
177 Ref<IData> data = df->createSimpleDataRef(storage_full_type,storage_build_info);
178 m_value = dynamic_cast<ValueDataType*>(data.get());
179 _setData(makeRef(m_value));
180}
181
182/*---------------------------------------------------------------------------*/
183/*---------------------------------------------------------------------------*/
184
185template<typename T> auto VariableScalarT<T>::
186getReference(const VariableBuildInfo& vb,const VariableInfo& vi) -> ThatClass*
187{
188 ThatClass* true_ptr = 0;
189 IVariableMng* vm = vb.variableMng();
190 IVariable* var = vm->checkVariable(vi);
191 if (var)
192 true_ptr = dynamic_cast<ThatClass*>(var);
193 else{
194 true_ptr = new ThatClass(vb,vi);
195 vm->_internalApi()->addVariable(true_ptr);
196 }
197 ARCANE_CHECK_PTR(true_ptr);
198 return true_ptr;
199}
200
201/*---------------------------------------------------------------------------*/
202/*---------------------------------------------------------------------------*/
203
204template<typename T> VariableScalarT<T>* VariableScalarT<T>::
206{
207 if (!var)
208 throw ArgumentException(A_FUNCINFO,"null variable");
209 ThatClass* true_ptr = dynamic_cast<ThatClass*>(var);
210 if (!true_ptr)
211 ARCANE_FATAL("Can not build a reference from variable {0}",var->name());
212 return true_ptr;
213}
214
215/*---------------------------------------------------------------------------*/
216/*---------------------------------------------------------------------------*/
217// Utilise une fonction Helper afin de spécialiser l'appel dans le
218// cas du type 'Byte' car ArrayVariableDiff::checkReplica() utilise
219// une réduction Min/Max et cela n'existe pas en MPI pour le type Byte.
220namespace
221{
222 template <typename T> VariableComparerResults
223 _checkIfSameOnAllReplicaHelper(IVariable* var, const T& value,
224 const VariableComparerArgs& compare_args)
225 {
227 return csa.checkReplica(var, value, compare_args);
228 }
229
230 // Spécialisation pour le type 'Byte' qui ne supporte pas les réductions.
232 _checkIfSameOnAllReplicaHelper(IVariable* var, const Byte& value,
233 const VariableComparerArgs& compare_args)
234 {
235 Integer int_value = value;
237 return csa.checkReplica(var, int_value, compare_args);
238 }
239}
240
241/*---------------------------------------------------------------------------*/
242/*---------------------------------------------------------------------------*/
243
245_compareVariable(const VariableComparerArgs& compare_args)
246{
247 switch (compare_args.compareMode()) {
249
250 if (itemKind() == IK_Particle)
251 return {};
252 IDataReader* reader = compare_args.dataReader();
253 ARCANE_CHECK_POINTER(reader);
254 T from(value());
255 T ref = T();
256 Ref<IScalarDataT<T>> ref_data(m_value->cloneTrueEmptyRef());
257 reader->read(this, ref_data.get());
258 ref = ref_data->value();
259 ConstArrayView<T> from_array(1, &from);
260 ConstArrayView<T> ref_array(1, &ref);
262 VariableComparerResults r = csa.check(this, ref_array, from_array, compare_args);
263 return r;
264 }
266 return {};
268 VariableComparerResults r = _checkIfSameOnAllReplicaHelper(this, value(), compare_args);
269 return r;
270 }
271 }
272 ARCANE_FATAL("Invalid value for compare mode '{0}'", (int)compare_args.compareMode());
273}
274
275/*---------------------------------------------------------------------------*/
276/*---------------------------------------------------------------------------*/
277
278template<typename T> void VariableScalarT<T>::
279print(std::ostream& o) const
280{
281 o << m_value->value();
282}
283
284/*---------------------------------------------------------------------------*/
285/*---------------------------------------------------------------------------*/
286
287template<typename T> void VariableScalarT<T>::
289{
290 // Rien à faire pour les variables scalaires
291}
292
293/*---------------------------------------------------------------------------*/
294/*---------------------------------------------------------------------------*/
295
296template<typename T> void VariableScalarT<T>::
298{
299 // Rien à faire pour les variables scalaires
300 ARCANE_UNUSED(local_ids);
301}
302
303/*---------------------------------------------------------------------------*/
304/*---------------------------------------------------------------------------*/
305
306template<typename T> Real VariableScalarT<T>::
307allocatedMemory() const
308{
309 return static_cast<Real>(sizeof(T));
310}
311
312/*---------------------------------------------------------------------------*/
313/*---------------------------------------------------------------------------*/
314
315template<typename T> void VariableScalarT<T>::
317{
318 ARCANE_UNUSED(source);
319 ARCANE_UNUSED(destination);
320}
321
322/*---------------------------------------------------------------------------*/
323/*---------------------------------------------------------------------------*/
324
325template<typename T> void VariableScalarT<T>::
327 Int32ConstArrayView second_source,
328 Int32ConstArrayView destination)
329{
330 ARCANE_UNUSED(first_source);
331 ARCANE_UNUSED(second_source);
332 ARCANE_UNUSED(destination);
333}
334
335/*---------------------------------------------------------------------------*/
336/*---------------------------------------------------------------------------*/
337
338template<typename T> void VariableScalarT<T>::
339compact(Int32ConstArrayView new_to_old_ids)
340{
341 ARCANE_UNUSED(new_to_old_ids);
342}
343
344/*---------------------------------------------------------------------------*/
345/*---------------------------------------------------------------------------*/
346
347template<typename T> void VariableScalarT<T>::
349{
350}
351
352/*---------------------------------------------------------------------------*/
353/*---------------------------------------------------------------------------*/
354
355template<typename T> void VariableScalarT<T>::
356setIsSynchronized(const ItemGroup& group)
357{
358 ARCANE_UNUSED(group);
359}
360
361/*---------------------------------------------------------------------------*/
362/*---------------------------------------------------------------------------*/
363
364template<typename DataType> void
366swapValues(ThatClass& rhs)
367{
368 _checkSwapIsValid(&rhs);
369 m_value->swapValues(rhs.m_value);
370 // Il faut mettre à jour les références pour cette variable et \a rhs.
371 syncReferences();
372 rhs.syncReferences();
373}
374
375/*---------------------------------------------------------------------------*/
376/*---------------------------------------------------------------------------*/
377
378ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE(VariableScalarT);
379template class VariableScalarT<String>;
380
381/*---------------------------------------------------------------------------*/
382/*---------------------------------------------------------------------------*/
383
384} // End namespace Arcane
385
386/*---------------------------------------------------------------------------*/
387/*---------------------------------------------------------------------------*/
#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_FATAL(...)
Macro envoyant une exception FatalErrorException.
#define ENUMERATE_ITEM(name, group)
Enumérateur générique d'un groupe de noeuds.
Exception lorsqu'un argument est invalide.
Vue constante d'un tableau de type T.
constexpr Integer size() const noexcept
Nombre d'éléments du tableau.
Informations pour construire une instance de 'IData'.
Classe de base d'une table de hachage entre les items d'un groupe et leurs positions dans la table.
Interface du gestionnaire de fabrique d'une donnée.
Interface de lecture des données d'une variable.
Definition IDataReader.h:41
virtual void read(IVariable *var, IData *data)=0
Lit les données data de la variable var.
Interface du gestionnaire de parallélisme pour un sous-domaine.
virtual Int32 commRank() const =0
Rang de cette instance dans le communicateur.
Interface du gestionnaire de traces.
virtual TraceMessage pinfo()=0
Flot pour un message d'information parallèle.
virtual void addVariable(IVariable *var)=0
Ajoute une variable.
Interface du gestionnaire de variables.
virtual IVariable * checkVariable(const VariableInfo &infos)=0
Vérifie une variable.
virtual IVariableMngInternal * _internalApi()=0
API interne à Arcane.
Interface d'une variable.
Definition IVariable.h:56
virtual bool isPartial() const =0
Indique si la variable est partielle.
virtual ItemGroup itemGroup() const =0
Groupe du maillage associé.
virtual String name() const =0
Nom de la variable.
Groupe d'entités de maillage.
Definition ItemGroup.h:49
SharedPtrT< GroupIndexTable > localIdToIndex() const
Table des local ids vers une position pour toutes les entités du groupe.
Definition ItemGroup.h:307
bool null() const
true is le groupe est le groupe nul
Definition ItemGroup.h:70
IMesh * mesh() const
Maillage auquel appartient ce groupe (0 pour le group nul)
Definition ItemGroup.h:126
Classe de base d'un élément de maillage.
Definition Item.h:83
constexpr Int32 localId() const
Identifiant local de l'entité dans le sous-domaine du processeur.
Definition Item.h:219
bool isOwn() const
true si l'entité est appartient au sous-domaine
Definition Item.h:253
Référence à une instance.
InstanceType * get() const
Instance associée ou nullptr si aucune.
Chaîne de caractères unicode.
TraceMessage info() const
Flot pour un message d'information.
Paramètres nécessaires à la construction d'une variable.
Arguments des méthodes de VariableComparer.
Résultats d'une opération de comparaison.
Classe template d'informations sur un type d'une variable.
Classe de base pour les comparaisons de valeurs entre deux variables.
Infos caractérisant une variable.
Variable scalaire.
IData * data() override
Données associées à la variable.
void copyItemsValues(Int32ConstArrayView source, Int32ConstArrayView destination) override
Copie les valeurs des entités numéros source dans les entités numéro destination.
VariableScalarT(const VariableBuildInfo &v, const VariableInfo &vi)
Construit une variable basée sur la référence v.
void setIsSynchronized() override
Indique que la variable est synchronisée.
void synchronize() override
Synchronise la variable.
void copyItemsMeanValues(Int32ConstArrayView first_source, Int32ConstArrayView second_source, Int32ConstArrayView destination) override
Copie les moyennes des valeurs des entités numéros first_source et second_source dans les entités num...
VariableComparerResults _compareVariable(const VariableComparerArgs &compare_args) final
Comparaison de valeurs entre variables.
void print(std::ostream &o) const override
Imprime les valeurs de la variable sur le flot o.
void compact(Int32ConstArrayView new_to_old_ids) override
Compacte les valeurs de la variable.
Real allocatedMemory() const override
Taille mémoire (en Koctet) utilisée par la variable.
IMesh * mesh() const final
Maillage auquel est associé la variable.
Definition Variable.cc:808
Variable(const VariableBuildInfo &v, const VariableInfo &vi)
Créé une variable lié à la référence v.
Definition Variable.cc:336
void _setData(const Ref< IData > &data)
Positionne la donnée.
Definition Variable.cc:882
eItemKind itemKind() const override
Type des entités du maillage sur lequel repose la variable.
Definition Variable.cc:837
@ ReduceMin
Minimum des valeurs.
@ ReduceMax
Maximum des valeurs.
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
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
@ SameOnAllReplica
Vérifie que les valeurs de la variable sont les même sur tous les replica.
@ Same
Compare avec une référence.
@ Sync
Vérifie que la variable est bien synchronisée.
@ IK_Particle
Entité de maillage de genre particule.
double Real
Type représentant un réel.
unsigned char Byte
Type d'un octet.
Definition BaseTypes.h:43
auto makeRef(InstanceType *t) -> Ref< InstanceType >
Créé une référence sur un pointeur.
std::int32_t Int32
Type entier signé sur 32 bits.