Arcane  v3.16.2.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
Array2Variable.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/* Array2Variable.cc (C) 2000-2025 */
9/* */
10/* Variable tableau 2D. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/core/Array2Variable.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/CheckedConvert.h"
22#include "arcane/utils/ArrayShape.h"
23#include "arcane/utils/ITraceMng.h"
24
25#include "arcane/datatype/DataTypeTraits.h"
26#include "arcane/datatype/DataStorageBuildInfo.h"
27
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"
41
42#include "arcane/core/internal/IDataInternal.h"
43#include "arcane/core/internal/IVariableMngInternal.h"
44#include "arcane/core/internal/IVariableInternal.h"
45
46/*---------------------------------------------------------------------------*/
47/*---------------------------------------------------------------------------*/
48
49namespace Arcane
50{
51
52/*---------------------------------------------------------------------------*/
53/*---------------------------------------------------------------------------*/
54
55template<class DataType>
57: public VariableDiff<DataType>
59 typedef VariableDataTypeTraitsT<DataType> VarDataTypeTraits;
61
62 public:
63
66 const VariableComparerArgs& compare_args)
67 {
68 const int max_print = compare_args.maxPrint();
69 const bool compare_ghost = compare_args.isCompareGhost();
70 ItemGroup group = var->itemGroup();
71 if (group.null())
72 return {};
73 IMesh* mesh = group.mesh();
74 if (!mesh)
75 return {};
76 ITraceMng* msg = mesh->traceMng();
77 IParallelMng* pm = mesh->parallelMng();
78
79 GroupIndexTable * group_index_table = (var->isPartial())?group.localIdToIndex().get():0;
80
81 int nb_diff = 0;
82 Int32 sid = pm->commRank();
83 Integer current_total_nb_element = current.totalNbElement();
84 /*if (ref.totalNbElement()!=current_total_nb_element){
85 msg->pinfo() << "Processeur: " << sid << " VDIFF: Variable '" << var->name()
86 << "'different number of elements "
87 << " current: " << current_total_nb_element
88 << " ref: " << ref.totalNbElement();
89 return current_total_nb_element;
90 }*/
91 if (current_total_nb_element==0)
92 return {};
93 Integer ref_size1 = ref.dim1Size();
94 Integer current_size1 = current.dim1Size();
95 Integer ref_size2 = ref.dim2Size();
96 Integer current_size2 = current.dim2Size();
97 if (ref_size2!=current_size2){
98 msg->pinfo() << "Processor: " << sid << " VDIFF: Variable '" << var->name()
99 << " bad dim2 size: ref=" << ref_size2 << " current=" << current_size2;
100 }
101 ENUMERATE_ITEM(i,group){
102 Item item = *i;
103 if (!item.isOwn() && !compare_ghost)
104 continue;
105 Integer index = item.localId();
106 if (group_index_table)
107 index = (*group_index_table)[index];
108
109 if (index>=ref_size1 || index>=current_size1){
110 ++nb_diff;
111 msg->pinfo() << "Processor: " << sid << " VDIFF: Variable '" << var->name()
112 << "wrong number of elements : impossible comparison";
113 continue;
114 }
115 ConstArrayView<DataType> lref = ref[index];
116 ConstArrayView<DataType> lcurrent = current[index];
117 for( Integer z=0; z<ref_size2; ++z ){
118 DataType diff = DataType();
119 DataType dref = lref[z];
120 DataType dcurrent = lcurrent[z];
121 if (VarDataTypeTraits::verifDifferent(dref,dcurrent,diff,true)){
122 this->m_diffs_info.add(DiffInfo(dcurrent,dref,diff,item,z));
123 ++nb_diff;
124 }
125 }
126 }
127 if (nb_diff!=0)
128 this->_sortAndDump(var,pm,max_print);
129
130 return VariableComparerResults(nb_diff);
131 }
132
133 VariableComparerResults
134 checkReplica(IVariable* var, ConstArray2View<DataType> var_values,
135 const VariableComparerArgs& compare_args)
136 {
137 IParallelMng* replica_pm = var->_internalApi()->replicaParallelMng();
138 if (!replica_pm)
139 return {};
140 // Appelle la bonne spécialisation pour être certain que le type template possède
141 // la réduction.
142 using ReduceType = typename VariableDataTypeTraitsT<DataType>::HasReduceMinMax;
143 if constexpr(std::is_same<TrueType,ReduceType>::value)
144 return _checkReplica2(replica_pm, var, var_values, compare_args);
145
146 ARCANE_UNUSED(replica_pm);
147 ARCANE_UNUSED(var);
148 ARCANE_UNUSED(var_values);
149 ARCANE_UNUSED(compare_args);
150 throw NotSupportedException(A_FUNCINFO);
151 }
152
153 private:
154
155 VariableComparerResults
156 _checkReplica2(IParallelMng* pm, IVariable* var, ConstArray2View<DataType> var_values,
157 const VariableComparerArgs& compare_args)
158 {
159 const int max_print = compare_args.maxPrint();
160 ITraceMng* msg = pm->traceMng();
161 ItemGroup group = var->itemGroup();
162 //TODO: traiter les variables qui ne sont pas sur des éléments du maillage.
163 if (group.null())
164 return {};
165 GroupIndexTable * group_index_table = (var->isPartial())?group.localIdToIndex().get():0;
166 // Vérifie que tous les réplica ont le même nombre d'éléments dans chaque
167 // dimension pour la variable.
168 Integer total_nb_element = var_values.totalNbElement();
169 Integer ref_size1 = var_values.dim1Size();
170 Integer ref_size2 = var_values.dim2Size();
171
172 Integer a_min_dims[2];
173 ArrayView<Integer> min_dims(2,a_min_dims);
174 Integer a_max_dims[2];
175 ArrayView<Integer> max_dims(2,a_max_dims);
176 max_dims[0] = min_dims[0] = ref_size1;
177 max_dims[1] = min_dims[1] = ref_size2;
178
179 pm->reduce(Parallel::ReduceMax,max_dims);
180 pm->reduce(Parallel::ReduceMin,min_dims);
181 msg->info(4) << "Array2Variable::CheckReplica2 rep_size=" << pm->commSize() << " rank=" << pm->commRank();
182 if (max_dims[0]!=min_dims[0] || max_dims[1]!=min_dims[1]){
183 const String& var_name = var->name();
184 msg->info() << "Can not compare values on replica for variable '" << var_name << "'"
185 << " because the number of elements is not the same on all the replica "
186 << " min=" << min_dims[0] << "," << min_dims[1]
187 << " max="<< max_dims[0] << "," << max_dims[1];
188 return VariableComparerResults(total_nb_element);
189 }
190 if (total_nb_element==0)
191 return {};
192 Integer nb_diff = 0;
193 UniqueArray2<DataType> min_values(var_values);
194 UniqueArray2<DataType> max_values(var_values);
195 pm->reduce(Parallel::ReduceMax,max_values.viewAsArray());
196 pm->reduce(Parallel::ReduceMin,min_values.viewAsArray());
197
198 ENUMERATE_ITEM(i,group){
199 Item item = *i;
200 Integer index = item.localId();
201 if (group_index_table)
202 index = (*group_index_table)[index];
203
204 if (index>=ref_size1){
205 ++nb_diff;
206 msg->pinfo() << "Processor: " << msg->traceId() << " VDIFF: Variable '" << var->name()
207 << "wrong number of elements : impossible comparison";
208 continue;
209 }
210 ConstArrayView<DataType> lref = min_values[index];
211 ConstArrayView<DataType> lcurrent = max_values[index];
212 for( Integer z=0; z<ref_size2; ++z ){
213 DataType diff = DataType();
214 DataType dref = lref[z];
215 DataType dcurrent = lcurrent[z];
216 if (VarDataTypeTraits::verifDifferent(dref,dcurrent,diff,true)){
217 this->m_diffs_info.add(DiffInfo(dcurrent,dref,diff,item,z));
218 ++nb_diff;
219 }
220 }
221 }
222
223 if (nb_diff!=0)
224 this->_sortAndDump(var,pm,max_print);
225
226 return VariableComparerResults(nb_diff);
227 }
228
229};
230
231/*---------------------------------------------------------------------------*/
232/*---------------------------------------------------------------------------*/
233
234/*---------------------------------------------------------------------------*/
235/*---------------------------------------------------------------------------*/
236
237template<typename T> Array2VariableT<T>::
239: Variable(vb,info)
240, m_data(nullptr)
241{
242 IDataFactoryMng* df = vb.dataFactoryMng();
243 DataStorageBuildInfo storage_build_info(vb.traceMng());
244 String storage_full_type = info.storageTypeInfo().fullName();
245 Ref<IData> data = df->createSimpleDataRef(storage_full_type,storage_build_info);
246 m_data = dynamic_cast<ValueDataType*>(data.get());
247 _setData(makeRef(m_data));
248}
249
250/*---------------------------------------------------------------------------*/
251/*---------------------------------------------------------------------------*/
252
253template<typename T> Array2VariableT<T>* Array2VariableT<T>::
255{
256 if (vb.isNull())
257 return nullptr;
258 ThatClass* true_ptr = nullptr;
259 IVariableMng* vm = vb.variableMng();
260 IVariable* var = vm->checkVariable(vi);
261 if (var)
262 true_ptr = dynamic_cast<ThatClass*>(var);
263 else{
264 true_ptr = new ThatClass(vb,vi);
265 vm->_internalApi()->addVariable(true_ptr);
266 }
267 ARCANE_CHECK_PTR(true_ptr);
268 return true_ptr;
269}
270
271/*---------------------------------------------------------------------------*/
272/*---------------------------------------------------------------------------*/
273
274template<typename T> Array2VariableT<T>* Array2VariableT<T>::
276{
277 if (!var)
278 throw ArgumentException(A_FUNCINFO,"null variable");
279 ThatClass* true_ptr = dynamic_cast<ThatClass*>(var);
280 if (!true_ptr)
281 ARCANE_FATAL("Cannot build a reference from variable {0}",var->name());
282 return true_ptr;
283}
284
285/*---------------------------------------------------------------------------*/
286/*---------------------------------------------------------------------------*/
287
288template<typename T> void Array2VariableT<T>::
290{
291 /*info() << "RESIZE(1) " << fullName()
292 << " wanted_dim1_size=" << s
293 << " dim2_size=" << m_data->value().dim2Size()
294 << " total=" << m_data->value().totalNbElement();*/
295 m_data->_internal()->resizeOnlyDim1(s);
296 syncReferences();
297}
298
299/*---------------------------------------------------------------------------*/
300/*---------------------------------------------------------------------------*/
301
302template<typename DataType> void Array2VariableT<DataType>::
303directResize(Integer dim1_size,Integer dim2_size)
304{
305 /*info() << "RESIZE(2) " << fullName()
306 << " wanted_dim1_size=" << dim1_size
307 << " wanted_dim2_size=" << dim2_size
308 << " total=" << m_data->value().totalNbElement()
309 << " dim1_size=" << m_data->value().dim1Size()
310 << " dim2_size=" << m_data->value().dim2Size();*/
311 m_data->_internal()->resize(dim1_size,dim2_size);
312 /*info() << "RESIZE(2) AFTER " << fullName()
313 << " total=" << m_data->value().totalNbElement()
314 << " dim1_size=" << m_data->value().dim1Size()
315 << " dim2_size=" << m_data->value().dim2Size()
316 << " addr=" << m_data->value().view().unguardedBasePointer();*/
317 syncReferences();
318}
319
320/*---------------------------------------------------------------------------*/
321/*---------------------------------------------------------------------------*/
322
323template<typename DataType> void Array2VariableT<DataType>::
325{
326 Int32 dim1_size = valueView().dim1Size();
327 Int32 dim2_size = CheckedConvert::toInt32(shape.totalNbElement());
328
329 m_data->_internal()->resize(dim1_size,dim2_size);
330 m_data->setShape(shape);
331
332 syncReferences();
333}
334
335/*---------------------------------------------------------------------------*/
336/*---------------------------------------------------------------------------*/
337
338template<typename DataType> void Array2VariableT<DataType>::
340{
341 m_data->_internal()->shrink();
343}
344
345/*---------------------------------------------------------------------------*/
346/*---------------------------------------------------------------------------*/
347
348template<typename T> void Array2VariableT<T>::
349print(std::ostream&) const
350{
351 //ConstArray2View<T> x(m_data->value().constView());
352 //arrayDumpValue(o,x);
353}
354
355/*---------------------------------------------------------------------------*/
356/*---------------------------------------------------------------------------*/
357
358template<typename T> void Array2VariableT<T>::
360{
361 if (itemKind()==IK_Unknown)
362 ARCANE_THROW(NotSupportedException,"variable '{0}' is not a mesh variable",fullName());
363 IItemFamily* family = itemGroup().itemFamily();
364 if (!family)
365 ARCANE_FATAL("variable '{0}' without family",fullName());
366 if(isPartial())
367 itemGroup().synchronizer()->synchronize(this);
368 else
369 family->allItemsSynchronizer()->synchronize(this);
370}
371
372/*---------------------------------------------------------------------------*/
373/*---------------------------------------------------------------------------*/
374
375template<typename T> void Array2VariableT<T>::
377{
378 if (itemKind()==IK_Unknown)
379 ARCANE_THROW(NotSupportedException,"variable '{0}' is not a mesh variable",fullName());
380 IItemFamily* family = itemGroup().itemFamily();
381 if (!family)
382 ARCANE_FATAL("variable '{0}' without family",fullName());
383 if(isPartial())
384 itemGroup().synchronizer()->synchronize(this, local_ids);
385 else
386 family->allItemsSynchronizer()->synchronize(this, local_ids);
387}
388
389/*---------------------------------------------------------------------------*/
390/*---------------------------------------------------------------------------*/
391
392template<typename T> Real Array2VariableT<T>::
393allocatedMemory() const
394{
395 Real v1 = static_cast<Real>(sizeof(T));
396 Real v2 = static_cast<Real>(m_data->view().totalNbElement());
397 return v1*v2;
398}
399
400/*---------------------------------------------------------------------------*/
401/*---------------------------------------------------------------------------*/
402// Utilise une fonction Helper afin de spécialiser l'appel dans le
403// cas du type 'Byte' car ArrayVariableDiff::checkReplica() utilise
404// une réduction Min/Max et cela n'existe pas en MPI pour le type Byte.
405namespace
406{
407 template <typename T> VariableComparerResults
408 _checkIfSameOnAllReplicaHelper(IVariable* var, ConstArray2View<T> values,
409 const VariableComparerArgs& compare_args)
410 {
412 return csa.checkReplica(var, values, compare_args);
413 }
414
415 // Spécialisation pour le type 'Byte' qui ne supporte pas les réductions.
416 VariableComparerResults
417 _checkIfSameOnAllReplicaHelper(IVariable* var, ConstArray2View<Byte> values,
418 const VariableComparerArgs& compare_args)
419 {
420 Integer dim1_size = values.dim1Size();
421 Integer dim2_size = values.dim2Size();
422 UniqueArray2<Integer> int_values(dim1_size,dim2_size);
423 for( Integer i=0; i<dim1_size; ++i )
424 for( Integer j=0; j<dim2_size; ++j )
425 int_values[i][j] = values[i][j];
426 Array2VariableDiff<Integer> csa;
427 return csa.checkReplica(var, int_values, compare_args);
428 }
429}
430
431/*---------------------------------------------------------------------------*/
432/*---------------------------------------------------------------------------*/
433
435_compareVariable(const VariableComparerArgs& compare_args)
436{
437 switch (compare_args.compareMode()) {
439 if (itemKind() == IK_Particle)
440 return {};
441 IDataReader* reader = compare_args.dataReader();
442 ARCANE_CHECK_POINTER(reader);
443
444 ConstArray2View<T> from_array(valueView());
445 Ref<IArray2DataT<T>> ref_data(m_data->cloneTrueEmptyRef());
446 reader->read(this, ref_data.get());
447
449 VariableComparerResults r = csa.check(this, ref_data->view(), from_array, compare_args);
450 return r;
451 } break;
453 IItemFamily* family = itemGroup().itemFamily();
454 if (!family)
455 return {};
456
457 Integer dim1_size = valueView().dim1Size();
458 if (dim1_size == 0)
459 return {};
460
461 ValueType& data_values = m_data->_internal()->_internalDeprecatedValue();
462
463 UniqueArray2<T> ref_array(constValueView());
464 this->synchronize(); // fonctionne pour toutes les variables
466 Array2View<T> from_array(valueView());
467 VariableComparerResults results = csa.check(this, ref_array, from_array, compare_args);
468 data_values.copy(ref_array);
469 return results;
470 }
472 VariableComparerResults r = _checkIfSameOnAllReplicaHelper(this, constValueView(), compare_args);
473 return r;
474 }
475 }
476 ARCANE_FATAL("Invalid value for compare mode '{0}'", (int)compare_args.compareMode());
477}
478
479/*---------------------------------------------------------------------------*/
480/*---------------------------------------------------------------------------*/
481
482template<typename T> void Array2VariableT<T>::
483_internalResize(const VariableResizeArgs& resize_args)
484{
485 Int32 new_size = resize_args.newSize();
486 Int32 nb_additional_element = resize_args.nbAdditionalCapacity();
487 bool use_no_init = resize_args.isUseNoInit();
488
489 // Exception deplace de ItemGroupImpl::removeItems.
490 // C'est un probleme d'implementation des variables partielles Arcane et non
491 // du concept de variable partielle (cf ItemGroupMap qui l'implemente).
492 // if (isPartial() && new_size < value().dim1Size())
493 // throw NotSupportedException(A_FUNCINFO,"Cannot remove items to group with partial variables");
494
495 ValueType& data_values = m_data->_internal()->_internalDeprecatedValue();
496 ValueType& container_ref = data_values;
497
498 Integer dim2_size = data_values.dim2Size();
499
500 if (nb_additional_element!=0){
501 Integer capacity = data_values.capacity();
502 if (new_size>capacity)
503 data_values.reserve(new_size+nb_additional_element*dim2_size);
504 }
505
507 // Si la nouvelle taille est supérieure à l'ancienne,
508 // initialise les nouveaux éléments suivant
509 // la politique voulue
510 Integer current_size = data_values.dim1Size();
511
512 /*info() << "RESIZE INTERNAL " << fullName()
513 << " wanted_dim1_size=" << new_size
514 << " dim1_size=" << value().dim1Size()
515 << " dim2size=" << dim2_size
516 << " total=" << value().totalNbElement();*/
517 if (use_no_init || (init_policy!=DIP_InitWithDefault))
518 data_values.resizeNoInit(new_size,dim2_size);
519 else
520 data_values.resize(new_size,dim2_size);
521
522 if (new_size>current_size){
523 bool use_nan = (init_policy==DIP_InitWithNan);
524 bool use_nan2 = (init_policy==DIP_InitInitialWithNanResizeWithDefault) && !_hasValidData();
525 if (use_nan || use_nan2){
526 for( Integer i=current_size; i<new_size; ++i )
527 DataTypeTraitsT<T>::fillNan(data_values[i]);
528 }
529 }
530
531 // Compacte la mémoire si demandé
532 if (_wantShrink()){
533 if (container_ref.totalNbElement() < container_ref.capacity())
534 container_ref.shrink();
535 }
536
537 /*info() << "RESIZE INTERNAL AFTER " << fullName()
538 << " addr=" << m_data->value().view().unguardedBasePointer()
539 << " dim1=" << value().dim1Size()
540 << " dim2=" << value().dim2Size();*/
541}
542
543/*---------------------------------------------------------------------------*/
544/*---------------------------------------------------------------------------*/
545
546template<typename T> void Array2VariableT<T>::
548{
549 ARCANE_ASSERT(source.size()==destination.size(),
550 ("Unable to copy: source and destination have different sizes !"));
551
552 const Integer dim2_size = valueView().dim2Size();
553 const Integer nb_copy = source.size();
554 Array2View<T> value = m_data->view();
555
556 for( Integer i=0; i<nb_copy; ++i ){
557 for( Integer j=0; j<dim2_size; ++j )
558 value[destination[i]][j] = value[source[i]][j];
559 }
561}
562
563/*---------------------------------------------------------------------------*/
564/*---------------------------------------------------------------------------*/
565
566template<typename T> void Array2VariableT<T>::
568 Int32ConstArrayView second_source,
569 Int32ConstArrayView destination)
570{
571 ARCANE_ASSERT((first_source.size()==destination.size()) && (second_source.size()==destination.size()),
572 ("Unable to copy: source and destination have different sizes !"));
573
574 const Integer dim2_size = valueView().dim2Size();
575 const Integer nb_copy = first_source.size();
576 Array2View<T> value = m_data->view();
577
578 for( Integer i=0; i<nb_copy; ++i ){
579 for( Integer j=0; j<dim2_size; ++j )
580 value[destination[i]][j] = (T)((value[first_source[i]][j]+value[second_source[i]][j])/2);
581 }
583}
584
585/*---------------------------------------------------------------------------*/
586/*---------------------------------------------------------------------------*/
587
588template<typename T> void Array2VariableT<T>::
589compact(Int32ConstArrayView new_to_old_ids)
590{
591 if (isPartial()) {
592 debug(Trace::High) << "Skip compact for partial variable " << name();
593 return;
594 }
595
596 ValueType& current_value = m_data->_internal()->_internalDeprecatedValue();
597 Integer current_size = current_value.dim1Size();
598 if (current_size==0)
599 return;
600
601 Integer dim2_size = current_value.dim2Size();
602 if (dim2_size==0)
603 return;
604
605 //TODO: eviter le clone
606 UniqueArray2<T> old_value(current_value);
607
608 Integer new_size = new_to_old_ids.size();
609 current_value.resize(new_size,dim2_size);
610 /*info() << "Variable: " << name() << " Compacte2D: size=" << current_size
611 << " dim2_size=" << dim2_size
612 << " new_size=" << new_size;*/
613
614 if (arcaneIsCheck()){
615 for( Integer i=0; i<new_size; ++i ){
616 Integer nto = new_to_old_ids[i];
617 ArrayView<T> v = current_value.at(i);
618 ArrayView<T> ov = old_value.at(nto);
619 for( Integer j=0; j<dim2_size; ++j )
620 v.setAt(j,ov.at(j));
621 }
622 }
623 else{
624 for( Integer i=0; i<new_size; ++i ){
625 Integer nto = new_to_old_ids[i];
626 for( Integer j=0; j<dim2_size; ++j )
627 current_value[i][j] = old_value[nto][j];
628 }
629 }
630
632}
633
634/*---------------------------------------------------------------------------*/
635/*---------------------------------------------------------------------------*/
636
637template<typename T> void Array2VariableT<T>::
639{
640}
641
642/*---------------------------------------------------------------------------*/
643/*---------------------------------------------------------------------------*/
644
645template<typename T> void Array2VariableT<T>::
647{
648}
649
650/*---------------------------------------------------------------------------*/
651/*---------------------------------------------------------------------------*/
652
653template<typename DataType> void
655swapValues(ThatClass& rhs)
656{
657 _checkSwapIsValid(&rhs);
658 // TODO: regarder s'il faut que les deux variables aient le même nombre
659 // d'éléments mais a priori cela ne semble pas indispensable.
660 m_data->swapValues(rhs.m_data);
661 // Il faut mettre à jour les références pour cette variable et \a rhs.
662 syncReferences();
663 rhs.syncReferences();
664}
665
666/*---------------------------------------------------------------------------*/
667/*---------------------------------------------------------------------------*/
668
669template<typename DataType> auto
670Array2VariableT<DataType>::
671value() -> ValueType&
672{
673 return m_data->_internal()->_internalDeprecatedValue();
674}
675
676/*---------------------------------------------------------------------------*/
677/*---------------------------------------------------------------------------*/
678
679template<typename DataType> void
681fillShape(ArrayShape& shape_with_item)
682{
683 // TODO: Cette méthode est indépendante du type de donnée.
684 // Il faudrait pouvoir en faire une seule version.
685 ArrayShape shape = m_data->shape();
686 const Int32 nb_rank = shape_with_item.nbDimension();
687 //std::cout << "SHAPE=" << shape.dimensions() << " internal_rank=" << nb_rank << "\n";
688 auto array_view = m_data->view();
689 Int32 dim0_size = array_view.dim1Size();
690
691 shape_with_item.setDimension(0, dim0_size);
692 Int32 nb_orig_shape = shape.nbDimension();
693 for (Int32 i = 0; i < nb_orig_shape; ++i) {
694 shape_with_item.setDimension(i + 1, shape.dimension(i));
695 }
696
697 // Si la forme est plus petite que notre rang, remplit les dimensions
698 // supplémentaires par la valeur 1.
699 for (Int32 i = (nb_orig_shape + 1); i < nb_rank; ++i) {
700 shape_with_item.setDimension(i, 1);
701 }
702}
703
704/*---------------------------------------------------------------------------*/
705/*---------------------------------------------------------------------------*/
706
707/*---------------------------------------------------------------------------*/
708/*---------------------------------------------------------------------------*/
709
710ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE(Array2VariableT);
711
712/*---------------------------------------------------------------------------*/
713/*---------------------------------------------------------------------------*/
714
715} // End namespace Arcane
716
717/*---------------------------------------------------------------------------*/
718/*---------------------------------------------------------------------------*/
#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.
#define ENUMERATE_ITEM(name, group)
Enumérateur générique d'un groupe de noeuds.
Exception lorsqu'un argument est invalide.
Variable sur un tableau 2D.
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(Integer size)
Redimensionnement de la deuxième dimension du tableau.
ConstArrayView< DataType > at(Int64 i) const
Elément d'indice i. Vérifie toujours les débordements.
Forme d'un tableau.
Definition ArrayShape.h:40
Vue modifiable d'un tableau d'un 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 d'une famille d'entités.
Definition IItemFamily.h:84
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.
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.
virtual void synchronize(IVariable *var)=0
Synchronise la variable var en mode bloquant.
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
Exception lorsqu'une opération n'est pas supportée.
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.
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.
Arguments pour redimensionner une 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
bool isPartial() const override
Indique si la variable est partielle.
Definition Variable.cc:864
String name() const final
Nom de la variable.
Definition Variable.cc:476
ItemGroup itemGroup() const final
Groupe du maillage associé.
Definition Variable.cc:828
void syncReferences() override
Synchronise les références.
Definition Variable.cc:750
String fullName() const final
Nom complet de la variable (avec le préfixe de la famille)
Definition Variable.cc:485
eItemKind itemKind() const override
Type des entités du maillage sur lequel repose la variable.
Definition Variable.cc:837
void resize(Integer n) override
Positionne le nombre d'éléments pour une variable tableau.
Definition Variable.cc:976
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.
Definition Misc.cc:68
eDataInitialisationPolicy
Type de politique d'initialisation possible pour une donnée.
Definition DataTypes.h:131
@ DIP_InitInitialWithNanResizeWithDefault
Initialisation avec des NaN pour à la création et le constructeur par défaut ensuite.
Definition DataTypes.h:170
@ DIP_InitWithNan
Initialisation avec des NaN (Not a Number)
Definition DataTypes.h:148
@ DIP_InitWithDefault
Initialisation avec le constructeur par défaut.
Definition DataTypes.h:140
eDataInitialisationPolicy getGlobalDataInitialisationPolicy()
Récupère la politique d'initialisation des variables.
Definition DataTypes.cc:162
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.
@ 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.