Arcane  v3.16.2.0
Documentation utilisateur
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 bool compare_ghost = compare_args.isCompareGhost();
69 ItemGroup group = var->itemGroup();
70 if (group.null())
71 return {};
72 IMesh* mesh = group.mesh();
73 if (!mesh)
74 return {};
75 ITraceMng* msg = mesh->traceMng();
76 IParallelMng* pm = mesh->parallelMng();
77
78 GroupIndexTable * group_index_table = (var->isPartial())?group.localIdToIndex().get():0;
79
80 int nb_diff = 0;
81 Int32 sid = pm->commRank();
82 Integer current_total_nb_element = current.totalNbElement();
83 /*if (ref.totalNbElement()!=current_total_nb_element){
84 msg->pinfo() << "Processeur: " << sid << " VDIFF: Variable '" << var->name()
85 << "'different number of elements "
86 << " current: " << current_total_nb_element
87 << " ref: " << ref.totalNbElement();
88 return current_total_nb_element;
89 }*/
90 if (current_total_nb_element==0)
91 return {};
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;
99 }
100 ENUMERATE_ITEM(i,group){
101 Item item = *i;
102 if (!item.isOwn() && !compare_ghost)
103 continue;
104 Integer index = item.localId();
105 if (group_index_table)
106 index = (*group_index_table)[index];
107
108 if (index>=ref_size1 || index>=current_size1){
109 ++nb_diff;
110 msg->pinfo() << "Processor: " << sid << " VDIFF: Variable '" << var->name()
111 << "wrong number of elements : impossible comparison";
112 continue;
113 }
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));
122 ++nb_diff;
123 }
124 }
125 }
126 if (nb_diff!=0)
127 this->_sortAndDump(var, pm, compare_args);
128
129 return VariableComparerResults(nb_diff);
130 }
131
132 VariableComparerResults
133 checkReplica(IVariable* var, ConstArray2View<DataType> var_values,
134 const VariableComparerArgs& compare_args)
135 {
136 IParallelMng* replica_pm = var->_internalApi()->replicaParallelMng();
137 if (!replica_pm)
138 return {};
139 // Appelle la bonne spécialisation pour être certain que le type template possède
140 // la réduction.
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);
144
145 ARCANE_UNUSED(replica_pm);
146 ARCANE_UNUSED(var);
147 ARCANE_UNUSED(var_values);
148 ARCANE_UNUSED(compare_args);
149 throw NotSupportedException(A_FUNCINFO);
150 }
151
152 private:
153
154 VariableComparerResults
155 _checkReplica2(IParallelMng* pm, IVariable* var, ConstArray2View<DataType> var_values,
156 const VariableComparerArgs& compare_args)
157 {
158 ITraceMng* msg = pm->traceMng();
159 ItemGroup group = var->itemGroup();
160 //TODO: traiter les variables qui ne sont pas sur des éléments du maillage.
161 if (group.null())
162 return {};
163 GroupIndexTable * group_index_table = (var->isPartial())?group.localIdToIndex().get():0;
164 // Vérifie que tous les réplica ont le même nombre d'éléments dans chaque
165 // dimension pour la variable.
166 Integer total_nb_element = var_values.totalNbElement();
167 Integer ref_size1 = var_values.dim1Size();
168 Integer ref_size2 = var_values.dim2Size();
169
170 Integer a_min_dims[2];
171 ArrayView<Integer> min_dims(2,a_min_dims);
172 Integer a_max_dims[2];
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;
176
177 pm->reduce(Parallel::ReduceMax,max_dims);
178 pm->reduce(Parallel::ReduceMin,min_dims);
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);
187 }
188 if (total_nb_element==0)
189 return {};
190 Integer nb_diff = 0;
191 UniqueArray2<DataType> min_values(var_values);
192 UniqueArray2<DataType> max_values(var_values);
193 pm->reduce(Parallel::ReduceMax,max_values.viewAsArray());
194 pm->reduce(Parallel::ReduceMin,min_values.viewAsArray());
195
196 ENUMERATE_ITEM(i,group){
197 Item item = *i;
198 Integer index = item.localId();
199 if (group_index_table)
200 index = (*group_index_table)[index];
201
202 if (index>=ref_size1){
203 ++nb_diff;
204 msg->pinfo() << "Processor: " << msg->traceId() << " VDIFF: Variable '" << var->name()
205 << "wrong number of elements : impossible comparison";
206 continue;
207 }
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));
216 ++nb_diff;
217 }
218 }
219 }
220
221 if (nb_diff!=0)
222 this->_sortAndDump(var, pm, compare_args);
223
224 return VariableComparerResults(nb_diff);
225 }
226
227};
228
229/*---------------------------------------------------------------------------*/
230/*---------------------------------------------------------------------------*/
231
232/*---------------------------------------------------------------------------*/
233/*---------------------------------------------------------------------------*/
234
235template<typename T> Array2VariableT<T>::
237: Variable(vb,info)
238, m_data(nullptr)
239{
240 IDataFactoryMng* df = vb.dataFactoryMng();
241 DataStorageBuildInfo storage_build_info(vb.traceMng());
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());
245 _setData(makeRef(m_data));
246}
247
248/*---------------------------------------------------------------------------*/
249/*---------------------------------------------------------------------------*/
250
251template<typename T> Array2VariableT<T>* Array2VariableT<T>::
253{
254 if (vb.isNull())
255 return nullptr;
256 ThatClass* true_ptr = nullptr;
257 IVariableMng* vm = vb.variableMng();
258 IVariable* var = vm->checkVariable(vi);
259 if (var)
260 true_ptr = dynamic_cast<ThatClass*>(var);
261 else{
262 true_ptr = new ThatClass(vb,vi);
263 vm->_internalApi()->addVariable(true_ptr);
264 }
265 ARCANE_CHECK_PTR(true_ptr);
266 return true_ptr;
267}
268
269/*---------------------------------------------------------------------------*/
270/*---------------------------------------------------------------------------*/
271
272template<typename T> Array2VariableT<T>* Array2VariableT<T>::
274{
275 if (!var)
276 throw ArgumentException(A_FUNCINFO,"null variable");
277 ThatClass* true_ptr = dynamic_cast<ThatClass*>(var);
278 if (!true_ptr)
279 ARCANE_FATAL("Cannot build a reference from variable {0}",var->name());
280 return true_ptr;
281}
282
283/*---------------------------------------------------------------------------*/
284/*---------------------------------------------------------------------------*/
285
286template<typename T> void Array2VariableT<T>::
288{
289 /*info() << "RESIZE(1) " << fullName()
290 << " wanted_dim1_size=" << s
291 << " dim2_size=" << m_data->value().dim2Size()
292 << " total=" << m_data->value().totalNbElement();*/
293 m_data->_internal()->resizeOnlyDim1(s);
294 syncReferences();
295}
296
297/*---------------------------------------------------------------------------*/
298/*---------------------------------------------------------------------------*/
299
300template<typename DataType> void Array2VariableT<DataType>::
301directResize(Integer dim1_size,Integer dim2_size)
302{
303 /*info() << "RESIZE(2) " << fullName()
304 << " wanted_dim1_size=" << dim1_size
305 << " wanted_dim2_size=" << dim2_size
306 << " total=" << m_data->value().totalNbElement()
307 << " dim1_size=" << m_data->value().dim1Size()
308 << " dim2_size=" << m_data->value().dim2Size();*/
309 m_data->_internal()->resize(dim1_size,dim2_size);
310 /*info() << "RESIZE(2) AFTER " << fullName()
311 << " total=" << m_data->value().totalNbElement()
312 << " dim1_size=" << m_data->value().dim1Size()
313 << " dim2_size=" << m_data->value().dim2Size()
314 << " addr=" << m_data->value().view().unguardedBasePointer();*/
315 syncReferences();
316}
317
318/*---------------------------------------------------------------------------*/
319/*---------------------------------------------------------------------------*/
320
321template<typename DataType> void Array2VariableT<DataType>::
323{
324 Int32 dim1_size = valueView().dim1Size();
325 Int32 dim2_size = CheckedConvert::toInt32(shape.totalNbElement());
326
327 m_data->_internal()->resize(dim1_size,dim2_size);
328 m_data->setShape(shape);
329
330 syncReferences();
331}
332
333/*---------------------------------------------------------------------------*/
334/*---------------------------------------------------------------------------*/
335
336template<typename DataType> void Array2VariableT<DataType>::
338{
339 m_data->_internal()->shrink();
341}
342
343/*---------------------------------------------------------------------------*/
344/*---------------------------------------------------------------------------*/
345
346template<typename T> void Array2VariableT<T>::
347print(std::ostream&) const
348{
349 //ConstArray2View<T> x(m_data->value().constView());
350 //arrayDumpValue(o,x);
351}
352
353/*---------------------------------------------------------------------------*/
354/*---------------------------------------------------------------------------*/
355
356template<typename T> void Array2VariableT<T>::
358{
359 if (itemKind()==IK_Unknown)
360 ARCANE_THROW(NotSupportedException,"variable '{0}' is not a mesh variable",fullName());
361 IItemFamily* family = itemGroup().itemFamily();
362 if (!family)
363 ARCANE_FATAL("variable '{0}' without family",fullName());
364 if(isPartial())
365 itemGroup().synchronizer()->synchronize(this);
366 else
367 family->allItemsSynchronizer()->synchronize(this);
368}
369
370/*---------------------------------------------------------------------------*/
371/*---------------------------------------------------------------------------*/
372
373template<typename T> void Array2VariableT<T>::
375{
376 if (itemKind()==IK_Unknown)
377 ARCANE_THROW(NotSupportedException,"variable '{0}' is not a mesh variable",fullName());
378 IItemFamily* family = itemGroup().itemFamily();
379 if (!family)
380 ARCANE_FATAL("variable '{0}' without family",fullName());
381 if(isPartial())
382 itemGroup().synchronizer()->synchronize(this, local_ids);
383 else
384 family->allItemsSynchronizer()->synchronize(this, local_ids);
385}
386
387/*---------------------------------------------------------------------------*/
388/*---------------------------------------------------------------------------*/
389
390template<typename T> Real Array2VariableT<T>::
391allocatedMemory() const
392{
393 Real v1 = static_cast<Real>(sizeof(T));
394 Real v2 = static_cast<Real>(m_data->view().totalNbElement());
395 return v1*v2;
396}
397
398/*---------------------------------------------------------------------------*/
399/*---------------------------------------------------------------------------*/
400// Utilise une fonction Helper afin de spécialiser l'appel dans le
401// cas du type 'Byte' car ArrayVariableDiff::checkReplica() utilise
402// une réduction Min/Max et cela n'existe pas en MPI pour le type Byte.
403namespace
404{
405 template <typename T> VariableComparerResults
406 _checkIfSameOnAllReplicaHelper(IVariable* var, ConstArray2View<T> values,
407 const VariableComparerArgs& compare_args)
408 {
410 return csa.checkReplica(var, values, compare_args);
411 }
412
413 // Spécialisation pour le type 'Byte' qui ne supporte pas les réductions.
414 VariableComparerResults
415 _checkIfSameOnAllReplicaHelper(IVariable* var, ConstArray2View<Byte> values,
416 const VariableComparerArgs& compare_args)
417 {
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);
426 }
427}
428
429/*---------------------------------------------------------------------------*/
430/*---------------------------------------------------------------------------*/
431
433_compareVariable(const VariableComparerArgs& compare_args)
434{
435 switch (compare_args.compareMode()) {
437 if (itemKind() == IK_Particle)
438 return {};
439 IDataReader* reader = compare_args.dataReader();
440 ARCANE_CHECK_POINTER(reader);
441
442 ConstArray2View<T> from_array(valueView());
443 Ref<IArray2DataT<T>> ref_data(m_data->cloneTrueEmptyRef());
444 reader->read(this, ref_data.get());
445
447 VariableComparerResults r = csa.check(this, ref_data->view(), from_array, compare_args);
448 return r;
449 } break;
451 IItemFamily* family = itemGroup().itemFamily();
452 if (!family)
453 return {};
454
455 Integer dim1_size = valueView().dim1Size();
456 if (dim1_size == 0)
457 return {};
458
459 ValueType& data_values = m_data->_internal()->_internalDeprecatedValue();
460
461 UniqueArray2<T> ref_array(constValueView());
462 this->synchronize(); // fonctionne pour toutes les variables
464 Array2View<T> from_array(valueView());
465 VariableComparerResults results = csa.check(this, ref_array, from_array, compare_args);
466 data_values.copy(ref_array);
467 return results;
468 }
470 VariableComparerResults r = _checkIfSameOnAllReplicaHelper(this, constValueView(), compare_args);
471 return r;
472 }
473 }
474 ARCANE_FATAL("Invalid value for compare mode '{0}'", (int)compare_args.compareMode());
475}
476
477/*---------------------------------------------------------------------------*/
478/*---------------------------------------------------------------------------*/
479
480template<typename T> void Array2VariableT<T>::
481_internalResize(const VariableResizeArgs& resize_args)
482{
483 Int32 new_size = resize_args.newSize();
484 Int32 nb_additional_element = resize_args.nbAdditionalCapacity();
485 bool use_no_init = resize_args.isUseNoInit();
486
487 // Exception deplace de ItemGroupImpl::removeItems.
488 // C'est un probleme d'implementation des variables partielles Arcane et non
489 // du concept de variable partielle (cf ItemGroupMap qui l'implemente).
490 // if (isPartial() && new_size < value().dim1Size())
491 // throw NotSupportedException(A_FUNCINFO,"Cannot remove items to group with partial variables");
492
493 ValueType& data_values = m_data->_internal()->_internalDeprecatedValue();
494 ValueType& container_ref = data_values;
495
496 Integer dim2_size = data_values.dim2Size();
497
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);
502 }
503
505 // Si la nouvelle taille est supérieure à l'ancienne,
506 // initialise les nouveaux éléments suivant
507 // la politique voulue
508 Integer current_size = data_values.dim1Size();
509
510 /*info() << "RESIZE INTERNAL " << fullName()
511 << " wanted_dim1_size=" << new_size
512 << " dim1_size=" << value().dim1Size()
513 << " dim2size=" << dim2_size
514 << " total=" << value().totalNbElement();*/
515 if (use_no_init || (init_policy!=DIP_InitWithDefault))
516 data_values.resizeNoInit(new_size,dim2_size);
517 else
518 data_values.resize(new_size,dim2_size);
519
520 if (new_size>current_size){
521 bool use_nan = (init_policy==DIP_InitWithNan);
522 bool use_nan2 = (init_policy==DIP_InitInitialWithNanResizeWithDefault) && !_hasValidData();
523 if (use_nan || use_nan2){
524 for( Integer i=current_size; i<new_size; ++i )
525 DataTypeTraitsT<T>::fillNan(data_values[i]);
526 }
527 }
528
529 // Compacte la mémoire si demandé
530 if (_wantShrink()){
531 if (container_ref.totalNbElement() < container_ref.capacity())
532 container_ref.shrink();
533 }
534
535 /*info() << "RESIZE INTERNAL AFTER " << fullName()
536 << " addr=" << m_data->value().view().unguardedBasePointer()
537 << " dim1=" << value().dim1Size()
538 << " dim2=" << value().dim2Size();*/
539}
540
541/*---------------------------------------------------------------------------*/
542/*---------------------------------------------------------------------------*/
543
544template<typename T> void Array2VariableT<T>::
546{
547 ARCANE_ASSERT(source.size()==destination.size(),
548 ("Unable to copy: source and destination have different sizes !"));
549
550 const Integer dim2_size = valueView().dim2Size();
551 const Integer nb_copy = source.size();
552 Array2View<T> value = m_data->view();
553
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];
557 }
559}
560
561/*---------------------------------------------------------------------------*/
562/*---------------------------------------------------------------------------*/
563
564template<typename T> void Array2VariableT<T>::
566 Int32ConstArrayView second_source,
567 Int32ConstArrayView destination)
568{
569 ARCANE_ASSERT((first_source.size()==destination.size()) && (second_source.size()==destination.size()),
570 ("Unable to copy: source and destination have different sizes !"));
571
572 const Integer dim2_size = valueView().dim2Size();
573 const Integer nb_copy = first_source.size();
574 Array2View<T> value = m_data->view();
575
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);
579 }
581}
582
583/*---------------------------------------------------------------------------*/
584/*---------------------------------------------------------------------------*/
585
586template<typename T> void Array2VariableT<T>::
587compact(Int32ConstArrayView new_to_old_ids)
588{
589 if (isPartial()) {
590 debug(Trace::High) << "Skip compact for partial variable " << name();
591 return;
592 }
593
594 ValueType& current_value = m_data->_internal()->_internalDeprecatedValue();
595 Integer current_size = current_value.dim1Size();
596 if (current_size==0)
597 return;
598
599 Integer dim2_size = current_value.dim2Size();
600 if (dim2_size==0)
601 return;
602
603 //TODO: eviter le clone
604 UniqueArray2<T> old_value(current_value);
605
606 Integer new_size = new_to_old_ids.size();
607 current_value.resize(new_size,dim2_size);
608 /*info() << "Variable: " << name() << " Compacte2D: size=" << current_size
609 << " dim2_size=" << dim2_size
610 << " new_size=" << new_size;*/
611
612 if (arcaneIsCheck()){
613 for( Integer i=0; i<new_size; ++i ){
614 Integer nto = new_to_old_ids[i];
615 ArrayView<T> v = current_value.at(i);
616 ArrayView<T> ov = old_value.at(nto);
617 for( Integer j=0; j<dim2_size; ++j )
618 v.setAt(j,ov.at(j));
619 }
620 }
621 else{
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];
626 }
627 }
628
630}
631
632/*---------------------------------------------------------------------------*/
633/*---------------------------------------------------------------------------*/
634
635template<typename T> void Array2VariableT<T>::
637{
638}
639
640/*---------------------------------------------------------------------------*/
641/*---------------------------------------------------------------------------*/
642
643template<typename T> void Array2VariableT<T>::
645{
646}
647
648/*---------------------------------------------------------------------------*/
649/*---------------------------------------------------------------------------*/
650
651template<typename DataType> void
653swapValues(ThatClass& rhs)
654{
655 _checkSwapIsValid(&rhs);
656 // TODO: regarder s'il faut que les deux variables aient le même nombre
657 // d'éléments mais a priori cela ne semble pas indispensable.
658 m_data->swapValues(rhs.m_data);
659 // Il faut mettre à jour les références pour cette variable et \a rhs.
660 syncReferences();
661 rhs.syncReferences();
662}
663
664/*---------------------------------------------------------------------------*/
665/*---------------------------------------------------------------------------*/
666
667template<typename DataType> auto
668Array2VariableT<DataType>::
669value() -> ValueType&
670{
671 return m_data->_internal()->_internalDeprecatedValue();
672}
673
674/*---------------------------------------------------------------------------*/
675/*---------------------------------------------------------------------------*/
676
677template<typename DataType> void
679fillShape(ArrayShape& shape_with_item)
680{
681 // TODO: Cette méthode est indépendante du type de donnée.
682 // Il faudrait pouvoir en faire une seule version.
683 ArrayShape shape = m_data->shape();
684 const Int32 nb_rank = shape_with_item.nbDimension();
685 //std::cout << "SHAPE=" << shape.dimensions() << " internal_rank=" << nb_rank << "\n";
686 auto array_view = m_data->view();
687 Int32 dim0_size = array_view.dim1Size();
688
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));
693 }
694
695 // Si la forme est plus petite que notre rang, remplit les dimensions
696 // supplémentaires par la valeur 1.
697 for (Int32 i = (nb_orig_shape + 1); i < nb_rank; ++i) {
698 shape_with_item.setDimension(i, 1);
699 }
700}
701
702/*---------------------------------------------------------------------------*/
703/*---------------------------------------------------------------------------*/
704
705/*---------------------------------------------------------------------------*/
706/*---------------------------------------------------------------------------*/
707
708ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE(Array2VariableT);
709
710/*---------------------------------------------------------------------------*/
711/*---------------------------------------------------------------------------*/
712
713} // End namespace Arcane
714
715/*---------------------------------------------------------------------------*/
716/*---------------------------------------------------------------------------*/
#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.
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.
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'.
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.
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.
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
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.
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.