Arcane  v3.16.2.0
Documentation utilisateur
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 bool compare_ghost = compare_args.isCompareGhost();
66 ItemGroup group = var->itemGroup();
67 if (group.null())
68 return {};
69 IMesh* mesh = group.mesh();
70 if (!mesh)
71 return {};
72 ITraceMng* msg = mesh->traceMng();
73 IParallelMng* pm = mesh->parallelMng();
74
75 GroupIndexTable* group_index_table = (var->isPartial()) ? group.localIdToIndex().get() : nullptr;
76
77 int nb_diff = 0;
78 bool compare_failed = false;
79 Integer ref_size = ref.size();
80 ENUMERATE_ITEM(i,group){
81 const Item& item = *i;
82 if (!item.isOwn() && !compare_ghost)
83 continue;
84 Integer index = item.localId();
85 if (group_index_table){
86 index = (*group_index_table)[index];
87 if (index<0)
88 continue;
89 }
90
91 DataType diff = DataType();
92 if (index>=ref_size){
93 ++nb_diff;
94 compare_failed = true;
95 }
96 else{
97 DataType dref = ref[index];
98 DataType dcurrent = current[index];
99 if (VarDataTypeTraits::verifDifferent(dref,dcurrent,diff,true)){
100 this->m_diffs_info.add(DiffInfo(dcurrent,dref,diff,item,NULL_ITEM_ID));
101 ++nb_diff;
102 }
103 }
104 }
105 if (compare_failed){
106 Int32 sid = pm->commRank();
107 const String& var_name = var->name();
108 msg->pinfo() << "Processor " << sid << " : "
109 << " Unable to compare : elements numbers are different !"
110 << " pour la variable " << var_name << " ref_size=" << ref_size;
111
112 }
113 if (nb_diff!=0)
114 this->_sortAndDump(var, pm, compare_args);
115
116 return VariableComparerResults(nb_diff);
117 }
118
119 VariableComparerResults
120 checkReplica(IVariable* var, const DataType& var_value,
121 const VariableComparerArgs& compare_args)
122 {
123 IParallelMng* replica_pm = var->_internalApi()->replicaParallelMng();
124 if (!replica_pm)
125 return {};
126 const int max_print = compare_args.maxPrint();
127 // Appelle la bonne spécialisation pour être certain que le type template possède
128 // la réduction.
129 using ReduceType = typename VariableDataTypeTraitsT<DataType>::HasReduceMinMax;
130 if constexpr(std::is_same<TrueType,ReduceType>::value)
131 return _checkReplica2(replica_pm, var_value);
132 ARCANE_UNUSED(replica_pm);
133 ARCANE_UNUSED(var);
134 ARCANE_UNUSED(var_value);
135 ARCANE_UNUSED(max_print);
136 throw NotSupportedException(A_FUNCINFO);
137 }
138
139 private:
140
141 VariableComparerResults
142 _checkReplica2(IParallelMng* pm, const DataType& var_value)
143 {
144 Int32 nb_rank = pm->commSize();
145 if (nb_rank==1)
146 return {};
147
148 DataType max_value = pm->reduce(Parallel::ReduceMax,var_value);
149 DataType min_value = pm->reduce(Parallel::ReduceMin,var_value);
150
151 Integer nb_diff = 0;
152 DataType diff = DataType();
153 if (VarDataTypeTraits::verifDifferent(min_value,max_value,diff,true)){
154 this->m_diffs_info.add(DiffInfo(min_value,max_value,diff,0,NULL_ITEM_ID));
155 ++nb_diff;
156 }
157 return VariableComparerResults(nb_diff);
158 }
159
160};
161
162/*---------------------------------------------------------------------------*/
163/*---------------------------------------------------------------------------*/
164
165/*---------------------------------------------------------------------------*/
166/*---------------------------------------------------------------------------*/
167
168template<typename T> VariableScalarT<T>::
170: Variable(v,info)
171, m_value(nullptr)
172{
173 IDataFactoryMng* df = v.dataFactoryMng();
174 DataStorageBuildInfo storage_build_info(v.traceMng());
175 String storage_full_type = info.storageTypeInfo().fullName();
176 Ref<IData> data = df->createSimpleDataRef(storage_full_type,storage_build_info);
177 m_value = dynamic_cast<ValueDataType*>(data.get());
178 _setData(makeRef(m_value));
179}
180
181/*---------------------------------------------------------------------------*/
182/*---------------------------------------------------------------------------*/
183
184template<typename T> auto VariableScalarT<T>::
185getReference(const VariableBuildInfo& vb,const VariableInfo& vi) -> ThatClass*
186{
187 ThatClass* true_ptr = 0;
188 IVariableMng* vm = vb.variableMng();
189 IVariable* var = vm->checkVariable(vi);
190 if (var)
191 true_ptr = dynamic_cast<ThatClass*>(var);
192 else{
193 true_ptr = new ThatClass(vb,vi);
194 vm->_internalApi()->addVariable(true_ptr);
195 }
196 ARCANE_CHECK_PTR(true_ptr);
197 return true_ptr;
198}
199
200/*---------------------------------------------------------------------------*/
201/*---------------------------------------------------------------------------*/
202
203template<typename T> VariableScalarT<T>* VariableScalarT<T>::
205{
206 if (!var)
207 throw ArgumentException(A_FUNCINFO,"null variable");
208 ThatClass* true_ptr = dynamic_cast<ThatClass*>(var);
209 if (!true_ptr)
210 ARCANE_FATAL("Can not build a reference from variable {0}",var->name());
211 return true_ptr;
212}
213
214/*---------------------------------------------------------------------------*/
215/*---------------------------------------------------------------------------*/
216// Utilise une fonction Helper afin de spécialiser l'appel dans le
217// cas du type 'Byte' car ArrayVariableDiff::checkReplica() utilise
218// une réduction Min/Max et cela n'existe pas en MPI pour le type Byte.
219namespace
220{
221 template <typename T> VariableComparerResults
222 _checkIfSameOnAllReplicaHelper(IVariable* var, const T& value,
223 const VariableComparerArgs& compare_args)
224 {
226 return csa.checkReplica(var, value, compare_args);
227 }
228
229 // Spécialisation pour le type 'Byte' qui ne supporte pas les réductions.
231 _checkIfSameOnAllReplicaHelper(IVariable* var, const Byte& value,
232 const VariableComparerArgs& compare_args)
233 {
234 Integer int_value = value;
236 return csa.checkReplica(var, int_value, compare_args);
237 }
238}
239
240/*---------------------------------------------------------------------------*/
241/*---------------------------------------------------------------------------*/
242
244_compareVariable(const VariableComparerArgs& compare_args)
245{
246 switch (compare_args.compareMode()) {
248
249 if (itemKind() == IK_Particle)
250 return {};
251 IDataReader* reader = compare_args.dataReader();
252 ARCANE_CHECK_POINTER(reader);
253 T from(value());
254 T ref = T();
255 Ref<IScalarDataT<T>> ref_data(m_value->cloneTrueEmptyRef());
256 reader->read(this, ref_data.get());
257 ref = ref_data->value();
258 ConstArrayView<T> from_array(1, &from);
259 ConstArrayView<T> ref_array(1, &ref);
261 VariableComparerResults r = csa.check(this, ref_array, from_array, compare_args);
262 return r;
263 }
265 return {};
267 VariableComparerResults r = _checkIfSameOnAllReplicaHelper(this, value(), compare_args);
268 return r;
269 }
270 }
271 ARCANE_FATAL("Invalid value for compare mode '{0}'", (int)compare_args.compareMode());
272}
273
274/*---------------------------------------------------------------------------*/
275/*---------------------------------------------------------------------------*/
276
277template<typename T> void VariableScalarT<T>::
278print(std::ostream& o) const
279{
280 o << m_value->value();
281}
282
283/*---------------------------------------------------------------------------*/
284/*---------------------------------------------------------------------------*/
285
286template<typename T> void VariableScalarT<T>::
288{
289 // Rien à faire pour les variables scalaires
290}
291
292/*---------------------------------------------------------------------------*/
293/*---------------------------------------------------------------------------*/
294
295template<typename T> void VariableScalarT<T>::
297{
298 // Rien à faire pour les variables scalaires
299 ARCANE_UNUSED(local_ids);
300}
301
302/*---------------------------------------------------------------------------*/
303/*---------------------------------------------------------------------------*/
304
305template<typename T> Real VariableScalarT<T>::
306allocatedMemory() const
307{
308 return static_cast<Real>(sizeof(T));
309}
310
311/*---------------------------------------------------------------------------*/
312/*---------------------------------------------------------------------------*/
313
314template<typename T> void VariableScalarT<T>::
316{
317 ARCANE_UNUSED(source);
318 ARCANE_UNUSED(destination);
319}
320
321/*---------------------------------------------------------------------------*/
322/*---------------------------------------------------------------------------*/
323
324template<typename T> void VariableScalarT<T>::
326 Int32ConstArrayView second_source,
327 Int32ConstArrayView destination)
328{
329 ARCANE_UNUSED(first_source);
330 ARCANE_UNUSED(second_source);
331 ARCANE_UNUSED(destination);
332}
333
334/*---------------------------------------------------------------------------*/
335/*---------------------------------------------------------------------------*/
336
337template<typename T> void VariableScalarT<T>::
338compact(Int32ConstArrayView new_to_old_ids)
339{
340 ARCANE_UNUSED(new_to_old_ids);
341}
342
343/*---------------------------------------------------------------------------*/
344/*---------------------------------------------------------------------------*/
345
346template<typename T> void VariableScalarT<T>::
348{
349}
350
351/*---------------------------------------------------------------------------*/
352/*---------------------------------------------------------------------------*/
353
354template<typename T> void VariableScalarT<T>::
355setIsSynchronized(const ItemGroup& group)
356{
357 ARCANE_UNUSED(group);
358}
359
360/*---------------------------------------------------------------------------*/
361/*---------------------------------------------------------------------------*/
362
363template<typename DataType> void
365swapValues(ThatClass& rhs)
366{
367 _checkSwapIsValid(&rhs);
368 m_value->swapValues(rhs.m_value);
369 // Il faut mettre à jour les références pour cette variable et \a rhs.
370 syncReferences();
371 rhs.syncReferences();
372}
373
374/*---------------------------------------------------------------------------*/
375/*---------------------------------------------------------------------------*/
376
377ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE(VariableScalarT);
378template class VariableScalarT<String>;
379
380/*---------------------------------------------------------------------------*/
381/*---------------------------------------------------------------------------*/
382
383} // End namespace Arcane
384
385/*---------------------------------------------------------------------------*/
386/*---------------------------------------------------------------------------*/
#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'.
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.
Interface du gestionnaire de variables.
virtual IVariable * checkVariable(const VariableInfo &infos)=0
Vérifie une variable.
virtual IVariableMngInternal * _internalApi()=0
API interne à Arcane.
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.
Infos caractérisant une variable.
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.