14#include "arcane/core/VariableScalar.h"
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"
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"
39#include "arcane/core/datatype/DataStorageBuildInfo.h"
50template<
class DataType>
65 const int max_print = compare_args.maxPrint();
66 const bool compare_ghost = compare_args.isCompareGhost();
79 bool compare_failed =
false;
82 const Item& item = *i;
83 if (!item.
isOwn() && !compare_ghost)
86 if (group_index_table){
87 index = (*group_index_table)[index];
92 DataType diff = DataType();
95 compare_failed =
true;
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));
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;
115 this->_sortAndDump(var,pm,max_print);
117 return VariableComparerResults(nb_diff);
120 VariableComparerResults
121 checkReplica(IVariable* var,
const DataType& var_value,
122 const VariableComparerArgs& compare_args)
124 IParallelMng* replica_pm = var->_internalApi()->replicaParallelMng();
127 const int max_print = compare_args.maxPrint();
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);
135 ARCANE_UNUSED(var_value);
136 ARCANE_UNUSED(max_print);
137 throw NotSupportedException(A_FUNCINFO);
142 VariableComparerResults
143 _checkReplica2(IParallelMng* pm,
const DataType& var_value)
145 Int32 nb_rank = pm->commSize();
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));
158 return VariableComparerResults(nb_diff);
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());
188 ThatClass* true_ptr = 0;
192 true_ptr =
dynamic_cast<ThatClass*
>(var);
194 true_ptr =
new ThatClass(vb,vi);
197 ARCANE_CHECK_PTR(true_ptr);
209 ThatClass* true_ptr =
dynamic_cast<ThatClass*
>(var);
211 ARCANE_FATAL(
"Can not build a reference from variable {0}",var->name());
223 _checkIfSameOnAllReplicaHelper(
IVariable* var,
const T& value,
227 return csa.checkReplica(var, value, compare_args);
232 _checkIfSameOnAllReplicaHelper(
IVariable* var,
const Byte& value,
237 return csa.checkReplica(var, int_value, compare_args);
247 switch (compare_args.compareMode()) {
257 reader->
read(
this, ref_data.
get());
258 ref = ref_data->value();
272 ARCANE_FATAL(
"Invalid value for compare mode '{0}'", (
int)compare_args.compareMode());
279print(std::ostream& o)
const
281 o << m_value->value();
300 ARCANE_UNUSED(local_ids);
309 return static_cast<Real>(
sizeof(T));
318 ARCANE_UNUSED(source);
319 ARCANE_UNUSED(destination);
330 ARCANE_UNUSED(first_source);
331 ARCANE_UNUSED(second_source);
332 ARCANE_UNUSED(destination);
341 ARCANE_UNUSED(new_to_old_ids);
358 ARCANE_UNUSED(group);
364template<
typename DataType>
void
368 _checkSwapIsValid(&rhs);
369 m_value->swapValues(rhs.m_value);
372 rhs.syncReferences();
378ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE(VariableScalarT);
379template class VariableScalarT<String>;
#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.
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.
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.
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.
SharedPtrT< GroupIndexTable > localIdToIndex() const
Table des local ids vers une position pour toutes les entités du groupe.
bool null() const
true is le groupe est le groupe nul
IMesh * mesh() const
Maillage auquel appartient ce groupe (0 pour le group nul)
Classe de base d'un élément de maillage.
constexpr Int32 localId() const
Identifiant local de l'entité dans le sous-domaine du processeur.
bool isOwn() const
true si l'entité est appartient au sous-domaine
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.
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.
Variable(const VariableBuildInfo &v, const VariableInfo &vi)
Créé une variable lié à la référence v.
void _setData(const Ref< IData > &data)
Positionne la donnée.
eItemKind itemKind() const override
Type des entités du maillage sur lequel repose la variable.
@ 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.
@ 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.
auto makeRef(InstanceType *t) -> Ref< InstanceType >
Créé une référence sur un pointeur.
std::int32_t Int32
Type entier signé sur 32 bits.