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