14#include "arcane/core/Array2Variable.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/CheckedConvert.h"
22#include "arcane/utils/ArrayShape.h"
23#include "arcane/utils/ITraceMng.h"
25#include "arcane/datatype/DataTypeTraits.h"
26#include "arcane/datatype/DataStorageBuildInfo.h"
28#include "arcane/core/VariableDiff.h"
29#include "arcane/core/VariableBuildInfo.h"
30#include "arcane/core/VariableInfo.h"
31#include "arcane/core/IApplication.h"
32#include "arcane/core/IVariableMng.h"
33#include "arcane/core/IItemFamily.h"
34#include "arcane/core/IVariableSynchronizer.h"
35#include "arcane/core/IDataReader.h"
36#include "arcane/core/ItemGroup.h"
37#include "arcane/core/IParallelMng.h"
38#include "arcane/core/IDataFactoryMng.h"
39#include "arcane/core/IMesh.h"
40#include "arcane/core/VariableComparer.h"
42#include "arcane/core/internal/IDataInternal.h"
43#include "arcane/core/internal/IVariableMngInternal.h"
44#include "arcane/core/internal/IVariableInternal.h"
55template<
class DataType>
68 const bool compare_ghost = compare_args.isCompareGhost();
82 Integer current_total_nb_element = current.totalNbElement();
90 if (current_total_nb_element==0)
92 Integer ref_size1 = ref.dim1Size();
93 Integer current_size1 = current.dim1Size();
94 Integer ref_size2 = ref.dim2Size();
95 Integer current_size2 = current.dim2Size();
96 if (ref_size2!=current_size2){
97 msg->
pinfo() <<
"Processor: " << sid <<
" VDIFF: Variable '" << var->
name()
98 <<
" bad dim2 size: ref=" << ref_size2 <<
" current=" << current_size2;
102 if (!item.isOwn() && !compare_ghost)
104 Integer index = item.localId();
105 if (group_index_table)
106 index = (*group_index_table)[index];
108 if (index>=ref_size1 || index>=current_size1){
110 msg->
pinfo() <<
"Processor: " << sid <<
" VDIFF: Variable '" << var->
name()
111 <<
"wrong number of elements : impossible comparison";
114 ConstArrayView<DataType> lref = ref[index];
115 ConstArrayView<DataType> lcurrent = current[index];
116 for(
Integer z=0; z<ref_size2; ++z ){
117 DataType diff = DataType();
118 DataType dref = lref[z];
119 DataType dcurrent = lcurrent[z];
120 if (VarDataTypeTraits::verifDifferent(dref,dcurrent,diff,
true)){
121 this->m_diffs_info.add(DiffInfo(dcurrent,dref,diff,item,z));
127 this->_sortAndDump(var, pm, compare_args);
129 return VariableComparerResults(nb_diff);
132 VariableComparerResults
133 checkReplica(IVariable* var, ConstArray2View<DataType> var_values,
134 const VariableComparerArgs& compare_args)
136 IParallelMng* replica_pm = var->_internalApi()->replicaParallelMng();
141 using ReduceType =
typename VariableDataTypeTraitsT<DataType>::HasReduceMinMax;
142 if constexpr(std::is_same<TrueType,ReduceType>::value)
143 return _checkReplica2(replica_pm, var, var_values, compare_args);
145 ARCANE_UNUSED(replica_pm);
147 ARCANE_UNUSED(var_values);
148 ARCANE_UNUSED(compare_args);
149 throw NotSupportedException(A_FUNCINFO);
154 VariableComparerResults
155 _checkReplica2(IParallelMng* pm, IVariable* var, ConstArray2View<DataType> var_values,
156 const VariableComparerArgs& compare_args)
158 ITraceMng* msg = pm->traceMng();
159 ItemGroup group = var->itemGroup();
163 GroupIndexTable * group_index_table = (var->isPartial())?group.localIdToIndex().get():0;
166 Integer total_nb_element = var_values.totalNbElement();
167 Integer ref_size1 = var_values.dim1Size();
168 Integer ref_size2 = var_values.dim2Size();
171 ArrayView<Integer> min_dims(2,a_min_dims);
173 ArrayView<Integer> max_dims(2,a_max_dims);
174 max_dims[0] = min_dims[0] = ref_size1;
175 max_dims[1] = min_dims[1] = ref_size2;
179 msg->info(4) <<
"Array2Variable::CheckReplica2 rep_size=" << pm->commSize() <<
" rank=" << pm->commRank();
180 if (max_dims[0]!=min_dims[0] || max_dims[1]!=min_dims[1]){
181 const String& var_name = var->name();
182 msg->info() <<
"Can not compare values on replica for variable '" << var_name <<
"'"
183 <<
" because the number of elements is not the same on all the replica "
184 <<
" min=" << min_dims[0] <<
"," << min_dims[1]
185 <<
" max="<< max_dims[0] <<
"," << max_dims[1];
186 return VariableComparerResults(total_nb_element);
188 if (total_nb_element==0)
191 UniqueArray2<DataType> min_values(var_values);
192 UniqueArray2<DataType> max_values(var_values);
198 Integer index = item.localId();
199 if (group_index_table)
200 index = (*group_index_table)[index];
202 if (index>=ref_size1){
204 msg->pinfo() <<
"Processor: " << msg->traceId() <<
" VDIFF: Variable '" << var->name()
205 <<
"wrong number of elements : impossible comparison";
208 ConstArrayView<DataType> lref = min_values[index];
209 ConstArrayView<DataType> lcurrent = max_values[index];
210 for(
Integer z=0; z<ref_size2; ++z ){
211 DataType diff = DataType();
212 DataType dref = lref[z];
213 DataType dcurrent = lcurrent[z];
214 if (VarDataTypeTraits::verifDifferent(dref,dcurrent,diff,
true)){
215 this->m_diffs_info.add(DiffInfo(dcurrent,dref,diff,item,z));
222 this->_sortAndDump(var, pm, compare_args);
224 return VariableComparerResults(nb_diff);
242 String storage_full_type =
info.storageTypeInfo().fullName();
243 Ref<IData> data = df->createSimpleDataRef(storage_full_type,storage_build_info);
244 m_data =
dynamic_cast<ValueDataType*
>(
data.get());
256 ThatClass* true_ptr =
nullptr;
260 true_ptr =
dynamic_cast<ThatClass*
>(var);
262 true_ptr =
new ThatClass(vb,vi);
265 ARCANE_CHECK_PTR(true_ptr);
277 ThatClass* true_ptr =
dynamic_cast<ThatClass*
>(var);
279 ARCANE_FATAL(
"Cannot build a reference from variable {0}",var->name());
293 m_data->_internal()->resizeOnlyDim1(s);
309 m_data->_internal()->
resize(dim1_size,dim2_size);
324 Int32 dim1_size = valueView().dim1Size();
327 m_data->_internal()->resize(dim1_size,dim2_size);
328 m_data->setShape(shape);
339 m_data->_internal()->shrink();
347print(std::ostream&)
const
365 itemGroup().synchronizer()->synchronize(
this);
382 itemGroup().synchronizer()->synchronize(
this, local_ids);
393 Real v1 =
static_cast<Real>(
sizeof(T));
394 Real v2 =
static_cast<Real>(m_data->view().totalNbElement());
410 return csa.checkReplica(var, values, compare_args);
414 VariableComparerResults
415 _checkIfSameOnAllReplicaHelper(IVariable* var, ConstArray2View<Byte> values,
416 const VariableComparerArgs& compare_args)
418 Integer dim1_size = values.dim1Size();
419 Integer dim2_size = values.dim2Size();
420 UniqueArray2<Integer> int_values(dim1_size,dim2_size);
421 for(
Integer i=0; i<dim1_size; ++i )
422 for(
Integer j=0; j<dim2_size; ++j )
423 int_values[i][j] = values[i][j];
424 Array2VariableDiff<Integer> csa;
425 return csa.checkReplica(var, int_values, compare_args);
435 switch (compare_args.compareMode()) {
444 reader->
read(
this, ref_data.
get());
455 Integer dim1_size = valueView().dim1Size();
459 ValueType& data_values = m_data->_internal()->_internalDeprecatedValue();
466 data_values.
copy(ref_array);
474 ARCANE_FATAL(
"Invalid value for compare mode '{0}'", (
int)compare_args.compareMode());
483 Int32 new_size = resize_args.newSize();
484 Int32 nb_additional_element = resize_args.nbAdditionalCapacity();
485 bool use_no_init = resize_args.isUseNoInit();
493 ValueType& data_values = m_data->_internal()->_internalDeprecatedValue();
496 Integer dim2_size = data_values.dim2Size();
498 if (nb_additional_element!=0){
499 Integer capacity = data_values.capacity();
500 if (new_size>capacity)
501 data_values.reserve(new_size+nb_additional_element*dim2_size);
508 Integer current_size = data_values.dim1Size();
516 data_values.resizeNoInit(new_size,dim2_size);
518 data_values.resize(new_size,dim2_size);
520 if (new_size>current_size){
523 if (use_nan || use_nan2){
524 for(
Integer i=current_size; i<new_size; ++i )
525 DataTypeTraitsT<T>::fillNan(data_values[i]);
531 if (container_ref.totalNbElement() < container_ref.capacity())
532 container_ref.shrink();
547 ARCANE_ASSERT(source.
size()==destination.
size(),
548 (
"Unable to copy: source and destination have different sizes !"));
550 const Integer dim2_size = valueView().dim2Size();
554 for(
Integer i=0; i<nb_copy; ++i ){
555 for(
Integer j=0; j<dim2_size; ++j )
556 value[destination[i]][j] = value[source[i]][j];
569 ARCANE_ASSERT((first_source.
size()==destination.
size()) && (second_source.
size()==destination.
size()),
570 (
"Unable to copy: source and destination have different sizes !"));
572 const Integer dim2_size = valueView().dim2Size();
576 for(
Integer i=0; i<nb_copy; ++i ){
577 for(
Integer j=0; j<dim2_size; ++j )
578 value[destination[i]][j] = (T)((value[first_source[i]][j]+value[second_source[i]][j])/2);
594 ValueType& current_value = m_data->_internal()->_internalDeprecatedValue();
595 Integer current_size = current_value.dim1Size();
599 Integer dim2_size = current_value.dim2Size();
607 current_value.
resize(new_size,dim2_size);
613 for(
Integer i=0; i<new_size; ++i ){
614 Integer nto = new_to_old_ids[i];
617 for(
Integer j=0; j<dim2_size; ++j )
622 for(
Integer i=0; i<new_size; ++i ){
623 Integer nto = new_to_old_ids[i];
624 for(
Integer j=0; j<dim2_size; ++j )
625 current_value[i][j] = old_value[nto][j];
651template<
typename DataType>
void
655 _checkSwapIsValid(&rhs);
658 m_data->swapValues(rhs.m_data);
661 rhs.syncReferences();
667template<
typename DataType>
auto
668Array2VariableT<DataType>::
671 return m_data->_internal()->_internalDeprecatedValue();
677template<
typename DataType>
void
684 const Int32 nb_rank = shape_with_item.nbDimension();
686 auto array_view = m_data->view();
687 Int32 dim0_size = array_view.dim1Size();
689 shape_with_item.setDimension(0, dim0_size);
690 Int32 nb_orig_shape = shape.nbDimension();
691 for (
Int32 i = 0; i < nb_orig_shape; ++i) {
692 shape_with_item.setDimension(i + 1, shape.dimension(i));
697 for (
Int32 i = (nb_orig_shape + 1); i < nb_rank; ++i) {
698 shape_with_item.setDimension(i, 1);
708ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE(
Array2VariableT);
#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_THROW(exception_class,...)
Macro pour envoyer une exception avec formattage.
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
Exception lorsqu'un argument est invalide.
VariableComparerResults _compareVariable(const VariableComparerArgs &compare_args) final
Comparaison de valeurs entre variables.
void compact(Int32ConstArrayView old_to_new_ids) override
Compacte les valeurs de la variable.
void setIsSynchronized() override
Indique que la variable est synchronisée.
Array2VariableT(const VariableBuildInfo &v, const VariableInfo &vi)
Construit une variable basée sur la référence v.
IData * data() override
Données associées à 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...
void copyItemsValues(Int32ConstArrayView source, Int32ConstArrayView destination) override
Copie les valeurs des entités numéros source dans les entités numéro destination.
void synchronize() override
Synchronise la variable.
Real allocatedMemory() const override
Taille mémoire (en Koctet) utilisée par la variable.
void print(std::ostream &o) const override
Imprime les valeurs de la variable sur le flot o.
void shrinkMemory() override
Libère l'éventuelle mémoire supplémentaire allouée pour les données.
Vue modifiable pour un tableau 2D.
void copy(Span2< const DataType > rhs)
Redimensionne l'instance à partir des dimensions de rhs et copie dedans les valeurs de rhs.
void resize(Int64 new_size)
Redimensionne uniquement la première dimension en laissant la deuxième à l'identique.
ConstArrayView< DataType > at(Int64 i) const
Elément d'indice i. Vérifie toujours les débordements.
Vue modifiable d'un tableau d'un type T.
Vue pour un tableau 2D constant.
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 d'une famille d'entités.
virtual IVariableSynchronizer * allItemsSynchronizer()=0
Synchroniseur sur toutes les entités de la famille.
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 void synchronize(IVariable *var)=0
Synchronise la variable var en mode bloquant.
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)
Référence à une instance.
InstanceType * get() const
Instance associée ou nullptr si aucune.
Chaîne de caractères unicode.
TraceMessageDbg debug(Trace::eDebugLevel=Trace::Medium) const
Flot pour un message de debug.
TraceMessage info() const
Flot pour un message d'information.
Vecteur de données 2D avec sémantique par valeur (style STL).
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.
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.
bool isPartial() const override
Indique si la variable est partielle.
String name() const final
Nom de la variable.
ItemGroup itemGroup() const final
Groupe du maillage associé.
void syncReferences() override
Synchronise les références.
String fullName() const final
Nom complet de la variable (avec le préfixe de la famille)
eItemKind itemKind() const override
Type des entités du maillage sur lequel repose la variable.
void resize(Integer n) override
Positionne le nombre d'éléments pour une variable tableau.
Int32 toInt32(Int64 v)
Converti un Int64 en un Int32.
@ ReduceMin
Minimum des valeurs.
@ ReduceMax
Maximum des valeurs.
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
bool arcaneIsCheck()
Vrai si on est en mode vérification.
eDataInitialisationPolicy
Type de politique d'initialisation possible pour une donnée.
@ DIP_InitInitialWithNanResizeWithDefault
Initialisation avec des NaN pour à la création et le constructeur par défaut ensuite.
@ DIP_InitWithNan
Initialisation avec des NaN (Not a Number)
@ DIP_InitWithDefault
Initialisation avec le constructeur par défaut.
eDataInitialisationPolicy getGlobalDataInitialisationPolicy()
Récupère la politique d'initialisation des variables.
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.
@ IK_Unknown
Entité de maillage de genre inconnu ou non initialisé
double Real
Type représentant un réel.
auto makeRef(InstanceType *t) -> Ref< InstanceType >
Créé une référence sur un pointeur.
std::int32_t Int32
Type entier signé sur 32 bits.