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 bool compare_ghost = compare_args.isCompareGhost();
78 bool compare_failed =
false;
81 const Item& item = *i;
82 if (!item.
isOwn() && !compare_ghost)
85 if (group_index_table){
86 index = (*group_index_table)[index];
91 DataType diff = DataType();
94 compare_failed =
true;
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));
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;
114 this->_sortAndDump(var, pm, compare_args);
116 return VariableComparerResults(nb_diff);
119 VariableComparerResults
120 checkReplica(IVariable* var,
const DataType& var_value,
121 const VariableComparerArgs& compare_args)
123 IParallelMng* replica_pm = var->_internalApi()->replicaParallelMng();
126 const int max_print = compare_args.maxPrint();
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);
134 ARCANE_UNUSED(var_value);
135 ARCANE_UNUSED(max_print);
136 throw NotSupportedException(A_FUNCINFO);
141 VariableComparerResults
142 _checkReplica2(IParallelMng* pm,
const DataType& var_value)
144 Int32 nb_rank = pm->commSize();
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));
157 return VariableComparerResults(nb_diff);
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());
187 ThatClass* true_ptr = 0;
191 true_ptr =
dynamic_cast<ThatClass*
>(var);
193 true_ptr =
new ThatClass(vb,vi);
196 ARCANE_CHECK_PTR(true_ptr);
208 ThatClass* true_ptr =
dynamic_cast<ThatClass*
>(var);
210 ARCANE_FATAL(
"Can not build a reference from variable {0}",var->name());
222 _checkIfSameOnAllReplicaHelper(
IVariable* var,
const T& value,
226 return csa.checkReplica(var, value, compare_args);
231 _checkIfSameOnAllReplicaHelper(
IVariable* var,
const Byte& value,
236 return csa.checkReplica(var, int_value, compare_args);
246 switch (compare_args.compareMode()) {
256 reader->
read(
this, ref_data.
get());
257 ref = ref_data->value();
271 ARCANE_FATAL(
"Invalid value for compare mode '{0}'", (
int)compare_args.compareMode());
278print(std::ostream& o)
const
280 o << m_value->value();
299 ARCANE_UNUSED(local_ids);
308 return static_cast<Real>(
sizeof(T));
317 ARCANE_UNUSED(source);
318 ARCANE_UNUSED(destination);
329 ARCANE_UNUSED(first_source);
330 ARCANE_UNUSED(second_source);
331 ARCANE_UNUSED(destination);
340 ARCANE_UNUSED(new_to_old_ids);
357 ARCANE_UNUSED(group);
363template<
typename DataType>
void
367 _checkSwapIsValid(&rhs);
368 m_value->swapValues(rhs.m_value);
371 rhs.syncReferences();
377ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE(VariableScalarT);
378template 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'.
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.
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.
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.
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.