Arcane  v3.16.6.0
Documentation utilisateur
Chargement...
Recherche...
Aucune correspondance
Variable.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/* Variable.cc (C) 2000-2025 */
9/* */
10/* Classe gérant une variable. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13#ifndef ARCANE_VARIABLE_CC
14#define ARCANE_VARIABLE_CC
15/*---------------------------------------------------------------------------*/
16/*---------------------------------------------------------------------------*/
17
18#include "arcane/utils/List.h"
19#include "arcane/utils/FatalErrorException.h"
20#include "arcane/utils/OStringStream.h"
21#include "arcane/utils/Iterator.h"
22#include "arcane/utils/Iostream.h"
23#include "arcane/utils/String.h"
24#include "arcane/utils/ITraceMng.h"
25#include "arcane/utils/PlatformUtils.h"
26#include "arcane/utils/IStackTraceService.h"
27#include "arcane/utils/MemoryAccessInfo.h"
28#include "arcane/utils/NotImplementedException.h"
29#include "arcane/utils/ScopedPtr.h"
30#include "arcane/utils/StringBuilder.h"
31#include "arcane/utils/MemoryView.h"
32
33#include "arcane/core/ItemGroupObserver.h"
34#include "arcane/core/Variable.h"
35#include "arcane/core/VarRefEnumerator.h"
36#include "arcane/core/IVariableAccessor.h"
37#include "arcane/core/ItemGroup.h"
38#include "arcane/core/IMesh.h"
39#include "arcane/core/IItemFamily.h"
40#include "arcane/core/ISubDomain.h"
41#include "arcane/core/VariableInfo.h"
42#include "arcane/core/ISerializer.h"
43#include "arcane/core/VariableBuildInfo.h"
44#include "arcane/core/VariableComputeFunction.h"
45#include "arcane/core/CommonVariables.h"
46#include "arcane/core/Observable.h"
47#include "arcane/core/IVariableMng.h"
48#include "arcane/core/IDataReader.h"
49#include "arcane/core/IDataWriter.h"
50#include "arcane/core/IParallelMng.h"
51#include "arcane/core/VariableDependInfo.h"
52#include "arcane/core/IParallelReplication.h"
53#include "arcane/core/VariableMetaData.h"
54#include "arcane/core/IMeshMng.h"
55#include "arcane/core/MeshHandle.h"
56#include "arcane/core/VariableComparer.h"
57#include "arcane/core/datatype/DataAllocationInfo.h"
58#include "arcane/core/internal/IItemFamilyInternal.h"
59#include "arcane/core/internal/IVariableMngInternal.h"
60#include "arcane/core/internal/IVariableInternal.h"
61#include "arcane/core/internal/IDataInternal.h"
62
63#include <map>
64#include <set>
65#include <atomic>
66
67/*---------------------------------------------------------------------------*/
68/*---------------------------------------------------------------------------*/
69
70namespace Arcane
71{
72
73/*---------------------------------------------------------------------------*/
74/*---------------------------------------------------------------------------*/
75
76const char* IVariable::TAG_POST_PROCESSING = "PostProcessing";
77const char* IVariable::TAG_POST_PROCESSING_AT_THIS_ITERATION = "PostProcessingAtThisIteration";
78
79/*---------------------------------------------------------------------------*/
80/*---------------------------------------------------------------------------*/
81/*
82 * \brief Partie privée d'une variable.
83 */
84class VariablePrivate
85: public IVariableInternal
86{
87 public:
88
89 VariablePrivate(const VariableBuildInfo& v, const VariableInfo& vi, Variable* var);
90
91 public:
92
93 static std::atomic<Int64> modified_time_global_value;
94
95 public:
96
97 ISubDomain* m_sub_domain = nullptr;
98 IDataFactoryMng* m_data_factory_mng = nullptr;
99 MeshHandle m_mesh_handle; //!< Maillage (peut être nul)
100 Ref<IData> m_data; //!< Données de la variable
101 ItemGroup m_item_group; //!< Groupe d'entité sur lequel est associé la variable
102 IItemFamily* m_item_family = nullptr; //!< Familly d'entité (peut être nul)
103 VariableInfo m_infos; //!< Infos caractéristiques de la variable
104 int m_property = 0; //!< Propriétés de la variable
105 bool m_is_partial = false; //!< Vrai si la variable est partielle
106 bool m_need_property_update = false;
107 bool m_is_used = false; //!< Etat d'utilisation de la variable
108 bool m_has_valid_data = false; //!< Vrai si les données sont valide
109 Real m_last_update_time = 0.0; //!< Temps physique de la dernière mise à jour
110 VariableRef* m_first_reference = nullptr; //! Première référence sur la variable
112 UniqueArray<VariableDependInfo> m_depends; //!< Liste des dépendances de cette variable
113 Int64 m_modified_time = 0; //!< Tag de la dernière modification
115 AutoDetachObservable m_write_observable; //!< Observable en écriture
116 AutoDetachObservable m_read_observable; //!< Observable en lecture
117 AutoDetachObservable m_on_size_changed_observable; //!< Observable en redimensionnement
118 std::map<String, String> m_tags; //!< Liste des tags
119 bool m_has_recursive_depend = true; //!< Vrai si les dépendances sont récursives
120 bool m_want_shrink = false;
121 Variable* m_variable = nullptr; //!< Variable associée
122
123 public:
124
125 /*!
126 * \brief Sérialise le `hashid`.
127 *
128 * Lors de la désérialisation, vérifie que le `hashid` est correctement
129 * et si ce n'est pas le cas renvoie une exception.
130 */
132 {
133 switch (sbuf->mode()) {
134 case ISerializer::ModeReserve:
135 sbuf->reserveSpan(eBasicDataType::Byte, HASHID_SIZE);
136 break;
138 sbuf->putSpan(Span<const Byte>(m_hash_id, HASHID_SIZE));
139 break;
141 Byte read_hash_id_buf[HASHID_SIZE];
142 Span<Byte> read_span(read_hash_id_buf, HASHID_SIZE);
143 sbuf->getSpan(read_span);
144 Span<const Byte> ref_span(m_hash_id, HASHID_SIZE);
145 if (ref_span != Span<const Byte>(read_span))
146 ARCANE_FATAL("Bad hashid for variable name='{0}'\n"
147 " expected_hash_id='{1}'\n"
148 " hash_id ='{2}'\n"
149 " This may be due to incoherence in variable list (order) between ranks"
150 " during serialization",
151 m_infos.fullName(), String(ref_span), String(read_span));
152 } break;
153 }
154 }
155
156 public:
157
158 //!@{ \name Implémentation de IVariableInternal
159 String computeComparisonHashCollective(IHashAlgorithm* hash_algo, IData* sorted_data) override;
160 void changeAllocator(const MemoryAllocationOptions& alloc_info) override;
161 void resize(const VariableResizeArgs& resize_args) override;
162 VariableComparerResults compareVariable(const VariableComparerArgs& compare_args) override;
163 IParallelMng* replicaParallelMng() const;
164 //!@}
165
166 private:
167
168 static const int HASHID_SIZE = 64;
169 /*!
170 * \brief hash de la variable pour vérifier la cohérence de la sérialisation.
171 *
172 * Les 16 premiers octets sont le hash du nom au format hexadécimal (issu d'un Int64)
173 * et les suivants sont le nom complet (fullName()), éventuellement tronqué, de la variable.
174 * Les éventuels caractères restants sont des '~'.
175 */
176 Byte m_hash_id[HASHID_SIZE];
177
178 void _setHashId()
179 {
180 constexpr Int64 hashid_hexa_length = 16;
181 constexpr Int64 name_length = HASHID_SIZE - hashid_hexa_length;
182 Span<Byte> hash_id(m_hash_id, HASHID_SIZE);
183 hash_id.fill('~');
184 const String& full_name = m_infos.fullName();
185 Int64 hash_value = IntegerHashFunctionT<StringView>::hashfunc(full_name.view());
186 Convert::toHexaString(hash_value, hash_id);
187 Span<const Byte> bytes = full_name.bytes();
188 if (bytes.size() > name_length)
189 bytes = bytes.subspan(0, name_length);
190 auto hash_id2 = hash_id.subspan(hashid_hexa_length, name_length);
191 hash_id2.copy(bytes);
192 }
193};
194
195/*---------------------------------------------------------------------------*/
196/*---------------------------------------------------------------------------*/
197
198std::atomic<Int64> VariablePrivate::modified_time_global_value = 1;
199
200/*---------------------------------------------------------------------------*/
201/*---------------------------------------------------------------------------*/
202
205{
206 Int64 v = VariablePrivate::modified_time_global_value;
207 ++VariablePrivate::modified_time_global_value;
208 return v;
209}
210
211/*---------------------------------------------------------------------------*/
212/*---------------------------------------------------------------------------*/
213
214VariablePrivate::
215VariablePrivate(const VariableBuildInfo& v, const VariableInfo& vi, Variable* var)
216: m_sub_domain(v._subDomain())
217, m_data_factory_mng(v.dataFactoryMng())
218, m_mesh_handle(v.meshHandle())
219, m_infos(vi)
220, m_property(v.property())
221, m_is_partial(vi.isPartial())
222, m_variable(var)
223{
224 _setHashId();
225 m_infos.setDefaultItemGroupName();
226
227 // Pour test uniquement
228 if (!platform::getEnvironmentVariable("ARCANE_NO_RECURSIVE_DEPEND").null())
229 m_has_recursive_depend = false;
230
231 // Pour teste de libération mémoire.
232 {
233 String str = platform::getEnvironmentVariable("ARCANE_VARIABLE_SHRINK_MEMORY");
234 if (str == "1")
235 m_want_shrink = true;
236 }
237}
238
239/*---------------------------------------------------------------------------*/
240/*---------------------------------------------------------------------------*/
241
242//! Observer des évènements sur ItemGroup sous-jacent.
243class ItemGroupPartialVariableObserver
244: public IItemGroupObserver
245{
246 public:
247
248 explicit ItemGroupPartialVariableObserver(IVariable* var)
249 : m_var(var)
250 {
251 ARCANE_ASSERT((m_var), ("Variable pointer null"));
252
253 if (var->itemGroup().isAllItems())
254 ARCANE_FATAL("No observer should be attached on all items group");
255 }
256
257 void executeExtend(const Int32ConstArrayView* info) override
258 {
259 const Int32ConstArrayView& new_ids = *info;
260 if (new_ids.empty())
261 return;
262 ItemGroup group = m_var->itemGroup();
263 SharedPtrT<GroupIndexTable> id_to_index = group.localIdToIndex();
264
265 const Integer old_size = id_to_index->size();
266 const Integer group_size = group.size();
267 if (group_size != (old_size + new_ids.size()))
268 ARCANE_FATAL("Inconsitent extended size");
269 m_var->resizeFromGroup();
270 //id_to_index->update();
271 }
272
273 void executeReduce(const Int32ConstArrayView* info) override
274 {
275 // contient la liste des localids des items supprimés dans l'ancien groupe
276 const Int32ConstArrayView& removed_lids = *info;
277 if (removed_lids.empty())
278 return;
279 ItemGroup group = m_var->itemGroup();
280 SharedPtrT<GroupIndexTable> id_to_index = group.localIdToIndex();
281
282 const Integer old_size = id_to_index->size();
283 const Integer group_size = group.size();
284
285 if (group_size != (old_size - removed_lids.size()))
286 ARCANE_FATAL("Inconsitent reduced size {0} vs {1}", group_size, old_size);
287 [[maybe_unused]] ItemVectorView view = group.view();
288 Int32UniqueArray source;
289 Int32UniqueArray destination;
290 source.reserve(group_size);
291 destination.reserve(group_size);
292 for (Integer i = 0, index = 0, removed_index = 0; i < old_size; ++i) {
293 if (removed_index < removed_lids.size() &&
294 id_to_index->keyLocalId(i) == removed_lids[removed_index]) {
295 ++removed_index;
296 }
297 else {
298 ARCANE_ASSERT((id_to_index->keyLocalId(i) == view[index].localId()),
299 ("Inconsistent key (pos=%d,key=%d) vs (pos=%d,key=%d)",
300 i, id_to_index->keyLocalId(i), index, view[index].localId()));
301 if (i != index) {
302 destination.add(index);
303 source.add(i);
304 }
305 ++index;
306 }
307 }
308 m_var->copyItemsValues(source, destination);
309 m_var->resizeFromGroup();
310 }
311
312 void executeCompact(const Int32ConstArrayView* info) override
313 {
314 const Int32ConstArrayView& ids = *info;
315 if (ids.empty())
316 return;
317 ItemGroup group = m_var->itemGroup();
318 SharedPtrT<GroupIndexTable> id_to_index = group.localIdToIndex();
319 m_var->compact(*info);
320 //id_to_index->compact(info);
321 }
322
323 void executeInvalidate() override
324 {
325 ItemGroup group = m_var->itemGroup();
326 SharedPtrT<GroupIndexTable> id_to_index = group.localIdToIndex();
327 m_var->resizeFromGroup();
328 //id_to_index->update();
329 }
330
331 bool needInfo() const override { return true; }
332
333 private:
334
335 IVariable* m_var = nullptr;
336};
337
338/*---------------------------------------------------------------------------*/
339/*---------------------------------------------------------------------------*/
340
342Variable(const VariableBuildInfo& v, const VariableInfo& vi)
344, m_p(new VariablePrivate(v, vi, this))
345{
346}
347
348/*---------------------------------------------------------------------------*/
349/*---------------------------------------------------------------------------*/
350
352~Variable()
353{
354 //NOTE: si la variable possède un groupe, c'est le IVariableMng
355 // qui supprime la référence de cette variable sur le groupe
356 delete m_p;
357}
358
359/*---------------------------------------------------------------------------*/
360/*---------------------------------------------------------------------------*/
361
362bool Variable::
363_hasReference() const
364{
365 return m_p->m_first_reference;
366}
367
368/*---------------------------------------------------------------------------*/
369/*---------------------------------------------------------------------------*/
370
373{
374 _checkSetProperty(ref);
375 ++m_p->m_nb_reference;
376 ref->setNextReference(m_p->m_first_reference);
377 if (m_p->m_first_reference) {
378 VariableRef* _list = m_p->m_first_reference;
379 if (_list->previousReference())
380 _list->previousReference()->setNextReference(ref);
381 _list->setPreviousReference(ref);
382 }
383 else {
384 ref->setPreviousReference(0);
385 }
386 m_p->m_first_reference = ref;
387}
388
389/*---------------------------------------------------------------------------*/
390/*---------------------------------------------------------------------------*/
391
394{
395 {
396 VariableRef* tmp = ref;
397 if (tmp->previousReference())
398 tmp->previousReference()->setNextReference(tmp->nextReference());
399 if (tmp->nextReference())
400 tmp->nextReference()->setPreviousReference(tmp->previousReference());
401 if (m_p->m_first_reference == tmp)
402 m_p->m_first_reference = m_p->m_first_reference->nextReference();
403 }
404 // La référence peut être utilisée par la suite donc il ne faut pas oublier
405 // de supprimer le précédent et le suivant.
406 ref->setNextReference(0);
407 ref->setPreviousReference(0);
408
409 --m_p->m_nb_reference;
410 _checkSetProperty(ref);
411
412 // Lorsqu'il n'y a plus de références sur cette variable, le signale au
413 // gestionnaire de variable, sauf s'il s'agit d'une variable persistante
414 if (!_hasReference()) {
415 bool is_persistant = property() & IVariable::PPersistant;
416 if (!is_persistant) {
417 //m_p->m_trace->info() << " REF PROPERTY name=" << name() << " " << ref->referenceProperty();
418 _removeMeshReference();
419 ISubDomain* sd = m_p->m_sub_domain;
420 IVariableMng* vm = sd->variableMng();
421 vm->_internalApi()->removeVariable(this);
422 }
423 }
424}
425
426/*---------------------------------------------------------------------------*/
427/*---------------------------------------------------------------------------*/
428
430firstReference() const
431{
432 return m_p->m_first_reference;
433}
434
435/*---------------------------------------------------------------------------*/
436/*---------------------------------------------------------------------------*/
437
438void Variable::
439_checkSetProperty(VariableRef* ref)
440{
441 // Garantie que la propriété est correctement mise à jour avec la valeur
442 // de la seule référence.
443 if (!_hasReference()) {
444 m_p->m_property = ref->referenceProperty();
445 m_p->m_need_property_update = false;
446 }
447 else
448 m_p->m_need_property_update = true;
449}
450
451/*---------------------------------------------------------------------------*/
452/*---------------------------------------------------------------------------*/
453
455nbReference() const
456{
457 return m_p->m_nb_reference;
458}
459
460/*---------------------------------------------------------------------------*/
461/*---------------------------------------------------------------------------*/
462
464subDomain()
465{
466 return m_p->m_sub_domain;
467}
468
469/*---------------------------------------------------------------------------*/
470/*---------------------------------------------------------------------------*/
471
473variableMng() const
474{
475 return m_p->m_sub_domain->variableMng();
476}
477
478/*---------------------------------------------------------------------------*/
479/*---------------------------------------------------------------------------*/
480
482name() const
483{
484 return m_p->m_infos.localName();
485}
486
487/*---------------------------------------------------------------------------*/
488/*---------------------------------------------------------------------------*/
489
491fullName() const
492{
493 return m_p->m_infos.fullName();
494}
495
496/*---------------------------------------------------------------------------*/
497/*---------------------------------------------------------------------------*/
498
500itemFamilyName() const
501{
502 return m_p->m_infos.itemFamilyName();
503}
504
505/*---------------------------------------------------------------------------*/
506/*---------------------------------------------------------------------------*/
507
509itemGroupName() const
510{
511 return m_p->m_infos.itemGroupName();
512}
513
514/*---------------------------------------------------------------------------*/
515/*---------------------------------------------------------------------------*/
516
518meshName() const
519{
520 return m_p->m_infos.meshName();
521}
522
523/*---------------------------------------------------------------------------*/
524/*---------------------------------------------------------------------------*/
525
527dataType() const
528{
529 return m_p->m_infos.dataType();
530}
531
532/*---------------------------------------------------------------------------*/
533/*---------------------------------------------------------------------------*/
534/*!
535 * \todo traiter le cas PSubDomainPrivate.
536 */
538property() const
539{
540 if (!m_p->m_need_property_update)
541 return m_p->m_property;
542
543 // Les propriétés de la variable dépendent de ce que chaque
544 // référence souhaite et il faut les remettre à jour lorsque ces
545 // dernières changent.
546 // Par exemple, si toutes les références sont PNoDump et qu'une seule
547 // ne l'est pas, la variable ne doit pas l'être.
548 m_p->m_need_property_update = false;
549
550 bool want_dump = false;
551 bool want_sync = false;
552 bool want_replica_sync = false;
553 bool sub_domain_depend = false;
554 bool execution_depend = false;
555 bool want_private = false;
556 bool want_restore = false;
557 bool want_notemporary = false;
558 bool want_exchange = false;
559 bool want_persistant = false;
560
561 int property = 0;
562 for (VarRefEnumerator i(this); i.hasNext(); ++i) {
563 VariableRef* vref = *i;
564 int p = vref->referenceProperty();
565 if (!(p & IVariable::PNoDump))
566 want_dump = true;
567 if (!(p & IVariable::PNoNeedSync))
568 want_sync = true;
569 if (!(p & IVariable::PNoReplicaSync))
570 want_replica_sync = true;
572 sub_domain_depend = true;
574 execution_depend = true;
575 if ((p & IVariable::PPersistant))
576 want_persistant = true;
577 if ((p & IVariable::PPrivate))
578 want_private = true;
579 if (!(p & IVariable::PNoRestore))
580 want_restore = true;
581 if (!(p & IVariable::PNoExchange))
582 want_exchange = true;
583 if (!(p & IVariable::PTemporary))
584 want_notemporary = true;
585 }
586
587 if (!want_dump)
588 property |= IVariable::PNoDump;
589 if (!want_sync)
590 property |= IVariable::PNoNeedSync;
591 if (!want_replica_sync)
592 property |= IVariable::PNoReplicaSync;
593 if (sub_domain_depend)
594 property |= IVariable::PSubDomainDepend;
595 if (execution_depend)
596 property |= IVariable::PExecutionDepend;
597 if (want_private)
598 property |= IVariable::PPrivate;
599 if (want_persistant)
600 property |= IVariable::PPersistant;
601 if (!want_restore)
602 property |= IVariable::PNoRestore;
603 if (!want_exchange)
604 property |= IVariable::PNoExchange;
605 if (!want_notemporary)
606 property |= IVariable::PTemporary;
607
608 m_p->m_property = property;
609 return m_p->m_property;
610}
611
612/*---------------------------------------------------------------------------*/
613/*---------------------------------------------------------------------------*/
614
617{
618 m_p->m_need_property_update = true;
619}
620
621/*---------------------------------------------------------------------------*/
622/*---------------------------------------------------------------------------*/
623
625setUsed(bool is_used)
626{
627 if (m_p->m_is_used == is_used)
628 return;
629
630 m_p->m_is_used = is_used;
631
632 eItemKind ik = itemKind();
633
634 if (m_p->m_is_used) {
635 if (m_p->m_item_group.null() && ik != IK_Unknown) {
636 _checkSetItemFamily();
637 _checkSetItemGroup();
638 // Attention à ne pas reinitialiser les valeurs lorsque ces dernières
639 // sont valides, ce qui est le cas par exemple après une protection.
640 if (!m_p->m_has_valid_data) {
642 // Historiquement on remplissait dans tous les cas la variable avec le
643 // constructeur par défaut
644 // de la donnée en appelant systématiquement fillDefautt(). Cependant,
645 // ce n'était pas le comportement souhaité qui doit être celui défini par
646 // getGlobalDataInitialisationPolicy() (dans DataTypes.h).
647 // On ne le fait maintenant que si le mode d'initialisation est égal
648 // à DIP_Legacy. Ce mode doit à terme disparaître.
650 m_p->m_data->fillDefault();
651 m_p->m_has_valid_data = true;
652 }
653 }
654 }
655 else {
656 _removeMeshReference();
657 if (ik == IK_Unknown)
658 resize(0);
659 else
661 // Indique que les valeurs ne sont plus valides
662 m_p->m_has_valid_data = false;
663 }
664
665 for (VarRefEnumerator i(this); i.hasNext(); ++i) {
666 VariableRef* ref = *i;
667 ref->internalSetUsed(m_p->m_is_used);
668 }
669}
670
671/*---------------------------------------------------------------------------*/
672/*---------------------------------------------------------------------------*/
673
674void Variable::
675_removeMeshReference()
676{
677 IItemFamily* family = m_p->m_item_family;
678 if (family)
679 family->_internalApi()->removeVariable(this);
680
681 if (isPartial())
682 m_p->m_item_group.internal()->detachObserver(this);
683
684 m_p->m_item_group = ItemGroup();
685 m_p->m_item_family = 0;
686}
687
688/*---------------------------------------------------------------------------*/
689/*---------------------------------------------------------------------------*/
690
692isUsed() const
693{
694 return m_p->m_is_used;
695}
696
697/*---------------------------------------------------------------------------*/
698/*---------------------------------------------------------------------------*/
699
700namespace
701{
702
703 String _buildVariableFullType(const IVariable* var)
704 {
705 StringBuilder full_type_b;
706 full_type_b = dataTypeName(var->dataType());
707 full_type_b += ".";
708 full_type_b += itemKindName(var->itemKind());
709 full_type_b += ".";
710 full_type_b += var->dimension();
711 full_type_b += ".";
712 full_type_b += var->multiTag();
713 if (var->isPartial())
714 full_type_b += ".Partial";
715 return full_type_b.toString();
716 }
717
718}
719
720/*---------------------------------------------------------------------------*/
721/*---------------------------------------------------------------------------*/
722
723VariableMetaData* Variable::
724_createMetaData() const
725{
726 auto vmd = new VariableMetaData(name(), meshName(), itemFamilyName(),
728 vmd->setFullType(_buildVariableFullType(this));
729 vmd->setMultiTag(String::fromNumber(multiTag()));
730 vmd->setProperty(property());
731 return vmd;
732}
733
734/*---------------------------------------------------------------------------*/
735/*---------------------------------------------------------------------------*/
736
738createMetaData() const
739{
740 return _createMetaData();
741}
742
743/*---------------------------------------------------------------------------*/
744/*---------------------------------------------------------------------------*/
745
747createMetaDataRef() const
748{
749 return makeRef(_createMetaData());
750}
751
752/*---------------------------------------------------------------------------*/
753/*---------------------------------------------------------------------------*/
754
757{
758 //cout << "** SYNC REFERENCE N=" << m_p->m_nb_reference << " F=" << m_p->m_first_reference << '\n';
759 for (VarRefEnumerator i(this); i.hasNext(); ++i) {
760 VariableRef* ref = *i;
761 //cout << "** SYNC REFERENCE V=" << ref << '\n';
762 ref->updateFromInternal();
763 }
764 // Il faut le faire après la mise à jour des références
765 // car les observateurs peuvent lire les valeurs via une référence
767}
768
769/*---------------------------------------------------------------------------*/
770/*---------------------------------------------------------------------------*/
771
773checkIfSync(int max_print)
774{
775 VariableComparerArgs compare_args;
776 compare_args.setCompareMode(eVariableComparerCompareMode::Sync);
777 compare_args.setMaxPrint(max_print);
778 compare_args.setCompareGhost(true);
779 VariableComparerResults results = _compareVariable(compare_args);
780 return results.nbDifference();
781}
782
783/*---------------------------------------------------------------------------*/
784/*---------------------------------------------------------------------------*/
785
788{
789 VariableComparerArgs compare_args;
790 compare_args.setCompareMode(eVariableComparerCompareMode::SameOnAllReplica);
791 compare_args.setMaxPrint(max_print);
793 return r.nbDifference();
794}
795
796/*---------------------------------------------------------------------------*/
797/*---------------------------------------------------------------------------*/
798
800checkIfSame(IDataReader* reader, Integer max_print, bool compare_ghost)
801{
802 VariableComparerArgs compare_args;
803 compare_args.setMaxPrint(max_print);
804 compare_args.setCompareGhost(compare_ghost);
805 compare_args.setDataReader(reader);
807 return r.nbDifference();
808}
809
810/*---------------------------------------------------------------------------*/
811/*---------------------------------------------------------------------------*/
812
814mesh() const
815{
816 if (m_p->m_mesh_handle.hasMesh())
817 return m_p->m_mesh_handle.mesh();
818 return nullptr;
819}
820
821/*---------------------------------------------------------------------------*/
822/*---------------------------------------------------------------------------*/
823
825meshHandle() const
826{
827 return m_p->m_mesh_handle;
828}
829
830/*---------------------------------------------------------------------------*/
831/*---------------------------------------------------------------------------*/
832
834itemGroup() const
835{
836 return m_p->m_item_group;
837}
838
839/*---------------------------------------------------------------------------*/
840/*---------------------------------------------------------------------------*/
841
843itemKind() const
844{
845 return m_p->m_infos.itemKind();
846}
847
848/*---------------------------------------------------------------------------*/
849/*---------------------------------------------------------------------------*/
850
852dimension() const
853{
854 return m_p->m_infos.dimension();
855}
856
857/*---------------------------------------------------------------------------*/
858/*---------------------------------------------------------------------------*/
859
861multiTag() const
862{
863 return m_p->m_infos.multiTag();
864}
865
866/*---------------------------------------------------------------------------*/
867/*---------------------------------------------------------------------------*/
868
870isPartial() const
871{
872 return m_p->m_is_partial;
873}
874
875/*---------------------------------------------------------------------------*/
876/*---------------------------------------------------------------------------*/
877
879itemFamily() const
880{
881 return m_p->m_item_family;
882}
883
884/*---------------------------------------------------------------------------*/
885/*---------------------------------------------------------------------------*/
886
889{
890 m_p->m_data = data;
891 if (!data.get()) {
892 ARCANE_FATAL("Invalid data: name={0} datatype={1} dimension={2} multitag={3}",
893 m_p->m_infos.fullName(), m_p->m_infos.dataType(),
894 m_p->m_infos.dimension(), m_p->m_infos.multiTag());
895 }
896 data->setName(m_p->m_infos.fullName());
897}
898
899/*---------------------------------------------------------------------------*/
900/*---------------------------------------------------------------------------*/
901
903_setValidData(bool valid_data)
904{
905 m_p->m_has_valid_data = valid_data;
906}
907
908/*---------------------------------------------------------------------------*/
909/*---------------------------------------------------------------------------*/
910
912_hasValidData() const
913{
914 return m_p->m_has_valid_data;
915}
916
917/*---------------------------------------------------------------------------*/
918/*---------------------------------------------------------------------------*/
919
920void Variable::
921_setProperty(int property)
922{
923 m_p->m_property |= property;
924}
925
926/*---------------------------------------------------------------------------*/
927/*---------------------------------------------------------------------------*/
928
930dataFactoryMng() const
931{
932 return m_p->m_data_factory_mng;
933}
934
935/*---------------------------------------------------------------------------*/
936/*---------------------------------------------------------------------------*/
937
940{
941 debug(Trace::High) << "Serialize (partial) variable name=" << fullName();
942 m_p->serializeHashId(sbuffer);
943 m_p->m_data->serialize(sbuffer, ids, operation);
944 // En mode lecture, les données sont modifiées
945 if (sbuffer->mode() == ISerializer::ModeGet)
947}
948
949/*---------------------------------------------------------------------------*/
950/*---------------------------------------------------------------------------*/
951
953serialize(ISerializer* sbuffer, IDataOperation* operation)
954{
955 debug(Trace::High) << "Serialize (full) variable name=" << fullName();
956
957 m_p->serializeHashId(sbuffer);
958 m_p->m_data->serialize(sbuffer, operation);
959 // En mode lecture, les données sont modifiées
960 if (sbuffer->mode() == ISerializer::ModeGet)
962}
963
964/*---------------------------------------------------------------------------*/
965/*---------------------------------------------------------------------------*/
966
967void Variable::
968_resize(const VariableResizeArgs& resize_args)
969{
970 eItemKind ik = itemKind();
971 if (ik != IK_Unknown) {
972 ARCANE_FATAL("This call is invalid for item variable. Use resizeFromGroup() instead");
973 }
974 _internalResize(resize_args);
976}
977
978/*---------------------------------------------------------------------------*/
979/*---------------------------------------------------------------------------*/
980
982resize(Integer new_size)
983{
984 _resize(VariableResizeArgs(new_size));
985}
986
987/*---------------------------------------------------------------------------*/
988/*---------------------------------------------------------------------------*/
989
992{
993 eItemKind ik = itemKind();
994 if (ik == IK_Unknown)
995 return;
996 Integer new_size = 0;
997 IItemFamily* family = m_p->m_item_family;
998 if (family) {
999 if (m_p->m_item_group.isAllItems())
1000 new_size = m_p->m_item_family->maxLocalId();
1001 else
1002 new_size = m_p->m_item_group.size();
1003 }
1004 else {
1005 ItemGroup group = m_p->m_item_group;
1006 if (!group.null()) {
1007 ARCANE_FATAL("Variable '{0}' has group but no family", fullName());
1008 }
1009 }
1010 debug(Trace::High) << "Variable::resizeFromGroup() var='" << fullName()
1011 << "' with " << new_size << " items "
1012 << " this=" << this;
1013 _internalResize(VariableResizeArgs(new_size, new_size / 20));
1015}
1016
1017/*---------------------------------------------------------------------------*/
1018/*---------------------------------------------------------------------------*/
1019
1020void Variable::
1021_checkSetItemFamily()
1022{
1023 if (m_p->m_item_family || !m_p->m_item_group.null())
1024 return;
1025
1026 if (m_p->m_mesh_handle.isNull())
1027 m_p->m_mesh_handle = m_p->m_sub_domain->meshMng()->findMeshHandle(m_p->m_infos.meshName());
1028
1029 IMesh* mesh = m_p->m_mesh_handle.mesh();
1030 if (!mesh)
1031 ARCANE_FATAL("No mesh named '{0}' exists for variable '{1}'", m_p->m_infos.meshName(), name());
1032
1033 eItemKind ik = itemKind();
1034
1035 IItemFamily* family = 0;
1036 const String& family_name = m_p->m_infos.itemFamilyName();
1037 if (ik == IK_Particle || ik == IK_DoF) {
1038 if (family_name.null()) {
1039 ARCANE_FATAL("family name not specified for variable {0}", name());
1040 }
1041 family = mesh->findItemFamily(ik, family_name, true);
1042 }
1043 else {
1044 family = mesh->itemFamily(ik);
1045 }
1046
1047 if (family && family->itemKind() != itemKind())
1048 ARCANE_FATAL("Bad family kind '{0}' '{1}'", family->itemKind(), itemKind());
1049
1050 if (family && family->name() != itemFamilyName())
1051 ARCANE_FATAL("Incoherent family name. var={0} from_type={1} given={2}",
1052 name(), family->name(), itemFamilyName());
1053
1054 if (!family)
1055 ARCANE_FATAL("Family not found");
1056
1057 if (isPartial() && !family->hasUniqueIdMap())
1058 ARCANE_FATAL("Cannot have partial variable for a family without unique id map");
1059
1060 m_p->m_item_family = family;
1061 debug(Trace::High) << "Variable::setItemFamily() name=" << name()
1062 << " family=" << family
1063 << " familyname='" << family_name << "'";
1064 family->_internalApi()->addVariable(this);
1065}
1066
1067/*---------------------------------------------------------------------------*/
1068/*---------------------------------------------------------------------------*/
1069
1070void Variable::
1071_checkSetItemGroup()
1072{
1073 if (!m_p->m_item_group.null())
1074 return;
1075 const String& group_name = m_p->m_infos.itemGroupName();
1076 //info() << " CHECK SET GROUP var=" << name() << " group=" << group_name;
1077 if (group_name.null()) {
1078 m_p->m_item_group = m_p->m_item_family->allItems();
1079 }
1080 else
1081 m_p->m_item_group = m_p->m_item_family->findGroup(group_name, true);
1082
1083 ItemGroupImpl* internal = m_p->m_item_group.internal();
1084 // (HP) TODO: faut il garder ce controle hérité de l'ancienne implémentation de addVariable
1085 if (internal->parent() && (mesh()->parallelMng()->isParallel() && internal->isOwn()))
1086 ARCANE_FATAL("Cannot add variable ({0}) on a own group (name={1})",
1087 fullName(), internal->name());
1088 if (isPartial()) {
1089 if (group_name.empty())
1090 ARCANE_FATAL("Cannot create a partial variable with an empty item_group_name");
1091 debug(Trace::High) << "Attach ItemGroupPartialVariableObserver from " << fullName()
1092 << " to " << m_p->m_item_group.name();
1093 internal->attachObserver(this, new ItemGroupPartialVariableObserver(this));
1094 }
1095}
1096
1097/*---------------------------------------------------------------------------*/
1098/*---------------------------------------------------------------------------*/
1099
1102{
1103 return &(m_p->m_write_observable);
1104}
1105
1106/*---------------------------------------------------------------------------*/
1107/*---------------------------------------------------------------------------*/
1108
1111{
1112 return &(m_p->m_read_observable);
1113}
1114
1115/*---------------------------------------------------------------------------*/
1116/*---------------------------------------------------------------------------*/
1117
1120{
1121 return &(m_p->m_on_size_changed_observable);
1122}
1123
1124/*---------------------------------------------------------------------------*/
1125/*---------------------------------------------------------------------------*/
1126
1127/*---------------------------------------------------------------------------*/
1128/*---------------------------------------------------------------------------*/
1129
1131update()
1132{
1133 update(DPT_PreviousTime);
1134}
1135
1136/*---------------------------------------------------------------------------*/
1137/*---------------------------------------------------------------------------*/
1138
1139void Variable::
1140update(Real wanted_time)
1141{
1142 if (m_p->m_last_update_time < wanted_time) {
1143 for (Integer k = 0, n = m_p->m_depends.size(); k < n; ++k) {
1144 VariableDependInfo& vdi = m_p->m_depends[k];
1145 if (vdi.dependType() == DPT_PreviousTime)
1146 vdi.variable()->update(wanted_time);
1147 }
1148 }
1149
1150 if (m_p->m_has_recursive_depend) {
1151 for (Integer k = 0, n = m_p->m_depends.size(); k < n; ++k) {
1152 VariableDependInfo& vdi = m_p->m_depends[k];
1153 if (vdi.dependType() == DPT_CurrentTime)
1154 vdi.variable()->update(m_p->m_last_update_time);
1155 }
1156 }
1157
1158 bool need_update = false;
1159 Int64 modified_time = m_p->m_modified_time;
1160 for (Integer k = 0, n = m_p->m_depends.size(); k < n; ++k) {
1161 VariableDependInfo& vdi = m_p->m_depends[k];
1162 Int64 mt = vdi.variable()->modifiedTime();
1163 if (mt > modified_time) {
1164 need_update = true;
1165 break;
1166 }
1167 }
1168 if (need_update) {
1169 IVariableComputeFunction* cf = m_p->m_compute_function.get();
1170 //msg->info() << "Need Compute For Variable <" << name() << "> " << cf;
1171 if (cf) {
1172 //msg->info() << "Compute For Variable <" << name() << ">";
1173 cf->execute();
1174 }
1175 else {
1176 ARCANE_FATAL("No compute function for variable '{0}'", fullName());
1177 }
1178 }
1179}
1180
1181/*---------------------------------------------------------------------------*/
1182/*---------------------------------------------------------------------------*/
1183
1186{
1187 m_p->m_last_update_time = subDomain()->commonVariables().globalTime();
1188 m_p->m_modified_time = IVariable::incrementModifiedTime();
1189}
1190
1191/*---------------------------------------------------------------------------*/
1192/*---------------------------------------------------------------------------*/
1193
1196{
1197 return m_p->m_modified_time;
1198}
1199
1200/*---------------------------------------------------------------------------*/
1201/*---------------------------------------------------------------------------*/
1202
1205{
1206 m_p->m_depends.add(VariableDependInfo(var, dt, TraceInfo()));
1207}
1208
1209/*---------------------------------------------------------------------------*/
1210/*---------------------------------------------------------------------------*/
1211
1213addDepend(IVariable* var, eDependType dt, const TraceInfo& tinfo)
1214{
1215 m_p->m_depends.add(VariableDependInfo(var, dt, tinfo));
1216}
1217
1218/*---------------------------------------------------------------------------*/
1219/*---------------------------------------------------------------------------*/
1220
1223{
1224 ARCANE_UNUSED(var);
1225 throw NotImplementedException(A_FUNCINFO);
1226}
1227
1228/*---------------------------------------------------------------------------*/
1229/*---------------------------------------------------------------------------*/
1230
1233{
1234 m_p->m_compute_function = v;
1235}
1236
1237/*---------------------------------------------------------------------------*/
1238/*---------------------------------------------------------------------------*/
1239
1242{
1243 return m_p->m_compute_function.get();
1244}
1245
1246/*---------------------------------------------------------------------------*/
1247/*---------------------------------------------------------------------------*/
1248
1251{
1252 for (Integer k = 0, n = m_p->m_depends.size(); k < n; ++k) {
1253 VariableDependInfo& vdi = m_p->m_depends[k];
1254 infos.add(vdi);
1255 }
1256}
1257
1258/*---------------------------------------------------------------------------*/
1259/*---------------------------------------------------------------------------*/
1260
1261/*---------------------------------------------------------------------------*/
1262/*---------------------------------------------------------------------------*/
1263
1265addTag(const String& tagname, const String& tagvalue)
1266{
1267 m_p->m_tags[tagname] = tagvalue;
1268}
1269
1270/*---------------------------------------------------------------------------*/
1271/*---------------------------------------------------------------------------*/
1272
1274removeTag(const String& tagname)
1275{
1276 m_p->m_tags.erase(tagname);
1277}
1278
1279/*---------------------------------------------------------------------------*/
1280/*---------------------------------------------------------------------------*/
1281
1283hasTag(const String& tagname)
1284{
1285 return m_p->m_tags.find(tagname) != m_p->m_tags.end();
1286}
1287
1288/*---------------------------------------------------------------------------*/
1289/*---------------------------------------------------------------------------*/
1290
1292tagValue(const String& tagname)
1293{
1294 std::map<String, String>::const_iterator i = m_p->m_tags.find(tagname);
1295 if (i == m_p->m_tags.end())
1296 return String();
1297 return i->second;
1298}
1299
1300/*---------------------------------------------------------------------------*/
1301/*---------------------------------------------------------------------------*/
1302
1305{
1306 setUpToDate();
1309 _setValidData(true);
1310}
1311
1312/*---------------------------------------------------------------------------*/
1313/*---------------------------------------------------------------------------*/
1314
1320
1321/*---------------------------------------------------------------------------*/
1322/*---------------------------------------------------------------------------*/
1323
1325read(IDataReader* reader)
1326{
1327 reader->read(this, data());
1328 notifyEndRead();
1329}
1330
1331/*---------------------------------------------------------------------------*/
1332/*---------------------------------------------------------------------------*/
1333
1335write(IDataWriter* writer)
1336{
1338 writer->write(this, data());
1339}
1340
1341/*---------------------------------------------------------------------------*/
1342/*---------------------------------------------------------------------------*/
1343
1345changeGroupIds(Int32ConstArrayView old_to_new_ids)
1346{
1347 ARCANE_UNUSED(old_to_new_ids);
1348 // pH: default implementation since this method is not yet official
1349}
1350
1351/*---------------------------------------------------------------------------*/
1352/*---------------------------------------------------------------------------*/
1353/*!
1354 * \brief Vérifie qu'il est possible d'échanger les valeurs de l'instance
1355 * avec celle de \a rhs.
1356 *
1357 * Cette méthode étant appelée par une classe dérivée, on est sur que \a rhs
1358 * est du même type C++ que l'instance et donc il n'y a pas besoin de
1359 * vérifier par exemple que les dimensions ou le type des données sont les
1360 * mêmes. Pour que l'échange soit valide, il faut que le maillage, la famille
1361 * et le groupe soit les mêmes. Pour cela, il suffit de vérifier que le
1362 * groupe est le même.
1363 */
1366{
1367 if (!m_p->m_is_used)
1368 ARCANE_FATAL("Can not swap variable values for unused variable (instance)");
1369 if (!rhs->m_p->m_is_used)
1370 ARCANE_FATAL("Can not swap variable values for unused variable (argument)");
1371 if (isPartial() || rhs->isPartial())
1372 ARCANE_FATAL("Can not swap variable values for partial variables");
1373 if (itemGroup() != rhs->itemGroup())
1374 ARCANE_FATAL("Can not swap variable values for variables from different groups");
1375}
1376
1377/*---------------------------------------------------------------------------*/
1378/*---------------------------------------------------------------------------*/
1379
1380bool Variable::
1381_wantShrink() const
1382{
1383 return m_p->m_want_shrink;
1384}
1385
1386/*---------------------------------------------------------------------------*/
1387/*---------------------------------------------------------------------------*/
1388
1391{
1392 data()->setAllocationInfo(v);
1393 // Il est possible que le changement d'allocation modifie les données
1394 // allouées. Il faut donc synchroniser les références.
1396}
1397
1398/*---------------------------------------------------------------------------*/
1399/*---------------------------------------------------------------------------*/
1400
1402allocationInfo() const
1403{
1404 return data()->allocationInfo();
1405}
1406
1407/*---------------------------------------------------------------------------*/
1408/*---------------------------------------------------------------------------*/
1409
1410IVariableInternal* Variable::
1412{
1413 return m_p;
1414}
1415
1416/*---------------------------------------------------------------------------*/
1417/*---------------------------------------------------------------------------*/
1418
1419/*---------------------------------------------------------------------------*/
1420/*---------------------------------------------------------------------------*/
1421
1422String VariablePrivate::
1423computeComparisonHashCollective(IHashAlgorithm* hash_algo,
1424 IData* sorted_data)
1425{
1426 ARCANE_CHECK_POINTER(hash_algo);
1427 ARCANE_CHECK_POINTER(sorted_data);
1428
1429 INumericDataInternal* num_data = sorted_data->_commonInternal()->numericData();
1430 if (!num_data)
1431 return {};
1432 if (!m_item_family)
1433 return {};
1434
1435 IParallelMng* pm = m_item_family->parallelMng();
1436 Int32 my_rank = pm->commRank();
1437 Int32 master_rank = pm->masterIORank();
1438 ConstMemoryView memory_view = num_data->memoryView();
1439
1440 UniqueArray<Byte> bytes;
1441
1442 pm->gatherVariable(Arccore::asSpan<Byte>(memory_view.bytes()).smallView(), bytes, master_rank);
1443
1444 String hash_string;
1445 if (my_rank == master_rank) {
1446 HashAlgorithmValue hash_value;
1447 hash_algo->computeHash(asBytes(bytes), hash_value);
1448 hash_string = Convert::toHexaString(asBytes(hash_value.bytes()));
1449 }
1450 return hash_string;
1451}
1452
1453/*---------------------------------------------------------------------------*/
1454/*---------------------------------------------------------------------------*/
1455
1456void VariablePrivate::
1457changeAllocator(const MemoryAllocationOptions& mem_options)
1458{
1459 INumericDataInternal* dx = m_data->_commonInternal()->numericData();
1460 if (dx) {
1461 dx->changeAllocator(mem_options);
1462 m_variable->syncReferences();
1463 }
1464}
1465
1466/*---------------------------------------------------------------------------*/
1467/*---------------------------------------------------------------------------*/
1468
1469void VariablePrivate::
1470resize(const VariableResizeArgs& resize_args)
1471{
1472 return m_variable->_resize(resize_args);
1473}
1474
1475/*---------------------------------------------------------------------------*/
1476/*---------------------------------------------------------------------------*/
1477
1478VariableComparerResults VariablePrivate::
1479compareVariable(const VariableComparerArgs& compare_args)
1480{
1481 return m_variable->_compareVariable(compare_args);
1482}
1483
1484/*---------------------------------------------------------------------------*/
1485/*---------------------------------------------------------------------------*/
1486
1487IParallelMng* VariablePrivate::
1488replicaParallelMng() const
1489{
1490 //TODO: regarder si la variable est utilisée.
1491 IMesh* mesh = m_variable->mesh();
1492 // TODO: faut-il prendre le sous-domaine dans ce cas ?
1493 IParallelMng* pm = (mesh) ? mesh->parallelMng() : m_variable->subDomain()->parallelMng();
1494 IParallelReplication* pr = pm->replication();
1495 if (!pr->hasReplication())
1496 return nullptr;
1497 return pr->replicaParallelMng();
1498}
1499
1500/*---------------------------------------------------------------------------*/
1501/*---------------------------------------------------------------------------*/
1502
1503} // End namespace Arcane
1504
1505/*---------------------------------------------------------------------------*/
1506/*---------------------------------------------------------------------------*/
1507
1508#endif
#define ARCANE_CHECK_POINTER(ptr)
Macro retournant le pointeur ptr s'il est non nul ou lancant une exception s'il est nul.
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
Classe de base des vecteurs 1D de données.
void add(ConstReferenceType val)
Ajoute l'élément val à la fin du tableau.
void reserve(Int64 new_capacity)
Réserve le mémoire pour new_capacity éléments.
Observable qui appelle automatiquement IObservable::detachAllObservers() dans le destructeur.
Real globalTime() const
Temps courant.
constexpr Integer size() const noexcept
Nombre d'éléments du tableau.
constexpr bool empty() const noexcept
true si le tableau est vide (size()==0)
Informations sur l'allocation d'une donnée.
Interface de lecture des données d'une variable.
Definition IDataReader.h:34
virtual void read(IVariable *var, IData *data)=0
Lit les données data de la variable var.
Interface d'écriture des données d'une variable.
Definition IDataWriter.h:44
virtual void write(IVariable *var, IData *data)=0
Ecrit les données data de la variable var.
Interface d'une donnée.
Definition IData.h:33
virtual DataAllocationInfo allocationInfo() const =0
Informations sur l'allocation.
virtual void setAllocationInfo(const DataAllocationInfo &v)=0
Positionne les informations sur l'allocation.
Interface d'un algorithme de hashage.
virtual void computeHash(Span< const std::byte > input, HashAlgorithmValue &value)
Calcule la valeur du hash pour le tableau input.
Interface d'une famille d'entités.
Definition IItemFamily.h:84
virtual bool hasUniqueIdMap() const =0
Indique si la famille possède une table de conversion uniqueId vers localId.
virtual String name() const =0
Nom de la famille.
virtual eItemKind itemKind() const =0
Genre des entités.
virtual IItemFamilyInternal * _internalApi()=0
API interne à Arcane.
virtual IItemFamily * findItemFamily(eItemKind ik, const String &name, bool create_if_needed=false, bool register_modifier_if_created=false)=0
Retourne la famille de nom name.
virtual MeshHandle * findMeshHandle(const String &name, bool throw_exception)=0
Recherche le maillage de nom name.
Interface d'un observable.
virtual void notifyAllObservers()=0
Notifie tous les observateurs.
Interface du gestionnaire de parallélisme pour un sous-domaine.
@ ModePut
Le sérialiseur attend des reserve()
virtual void putSpan(Span< const Real > values)
Ajoute le tableau values.
virtual eMode mode() const =0
Mode de fonctionnement actuel.
virtual void getSpan(Span< Real > values)
Récupère le tableau values.
virtual void reserveSpan(eBasicDataType dt, Int64 n)=0
Réserve de la mémoire pour n valeurs de dt.
Interface du gestionnaire d'un sous-domaine.
Definition ISubDomain.h:74
virtual const CommonVariables & commonVariables() const =0
Informations sur les variables standards.
virtual IMeshMng * meshMng() const =0
Retourne le gestionnaire de maillage.
virtual IVariableMng * variableMng()=0
Retourne le gestionnaire de variables.
Interface de la classe functor de re-calcul d'une variable.
Interface du gestionnaire de variables.
virtual IVariableMngInternal * _internalApi()=0
API interne à Arcane.
Interface d'une variable.
Definition IVariable.h:39
virtual eDataType dataType() const =0
Type de la donnée gérée par la variable (Real, Integer, ...)
eDependType
Type des dépendances.
Definition IVariable.h:44
@ PSubDomainDepend
Indique que la valeur de la variable est dépendante du sous-domaine.
Definition IVariable.h:76
@ PNoExchange
Indique que la variable ne doit pas être échangée.
Definition IVariable.h:128
@ PNoReplicaSync
Indique que la variable n'a pas forcément la même valeur entre les réplicas.
Definition IVariable.h:144
@ PTemporary
Indique que la variable est temporaire.
Definition IVariable.h:111
@ PExecutionDepend
Indique que la valeur de la variable est dépendante de l'exécution.
Definition IVariable.h:91
@ PPrivate
Indique que la variable est privée.
Definition IVariable.h:99
@ PPersistant
Indique que la variable est persistante.
Definition IVariable.h:135
@ PNoRestore
Indique que la variable ne doit pas être restaurée.
Definition IVariable.h:118
@ PNoNeedSync
Indique que la variable n'est pas nécessairement synchronisée.
Definition IVariable.h:65
@ PNoDump
Indique que la variable ne doit pas être sauvegardée.
Definition IVariable.h:57
virtual eItemKind itemKind() const =0
Genre des entités du maillage sur lequel repose la variable.
virtual bool isPartial() const =0
Indique si la variable est partielle.
virtual Integer dimension() const =0
Dimension de la variable.
virtual IData * data()=0
Données associées à la variable.
virtual ItemGroup itemGroup() const =0
Groupe du maillage associé.
static Int64 incrementModifiedTime()
Incrémente le compteur de modification et retourne sa valeur avant modification.
Definition Variable.cc:204
virtual Integer multiTag() const =0
Indique si la variable est un tableau à taille multiple.
virtual void update()=0
Recalcule la variable si nécessaire.
static const char * TAG_POST_PROCESSING
Tag utilisé pour indiquer si une variable sera post-traitée.
Definition IVariable.h:150
static const char * TAG_POST_PROCESSING_AT_THIS_ITERATION
Tag utilisé pour indiquer si une variable sera post-traitée à cette itération.
Definition IVariable.h:153
void detachObserver(const void *ref)
Détache un observer.
void executeExtend(const Int32ConstArrayView *info) override
Execute l'action associée à l'extension.
Definition Variable.cc:257
void executeReduce(const Int32ConstArrayView *info) override
Execute l'action associée à l'extension.
Definition Variable.cc:273
void executeInvalidate() override
Execute l'action associée à l'invalidation.
Definition Variable.cc:323
void executeCompact(const Int32ConstArrayView *info) override
Éxecute l'action associée au compactage.
Definition Variable.cc:312
bool needInfo() const override
Indique si l'observer aura besoin d'information de transition.
Definition Variable.cc:331
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
ItemVectorView view() const
Vue sur les entités du groupe.
Definition ItemGroup.cc:583
Integer size() const
Nombre d'éléments du groupe.
Definition ItemGroup.h:88
bool isAllItems() const
Indique si le groupe est celui de toutes les entités.
Definition ItemGroup.cc:610
bool null() const
true is le groupe est le groupe nul
Definition ItemGroup.h:70
Vue sur un vecteur d'entités.
Options pour configurer les allocations.
Handle sur un maillage.
Definition MeshHandle.h:47
bool isNull() const
Indique si le handle est nul (il ne référence aucun maillage existant ou non)
Definition MeshHandle.h:162
IMesh * mesh() const
Maillage associé.
Référence à une instance.
Encapsulation d'un pointeur qui se détruit automatiquement.
Definition ScopedPtr.h:44
constexpr __host__ __device__ SizeType size() const noexcept
Retourne la taille du tableau.
Definition Span.h:212
Vue d'un tableau d'éléments de type T.
Definition Span.h:513
constexpr __host__ __device__ Span< T, DynExtent > subspan(Int64 abegin, Int64 asize) const
Sous-vue à partir de l'élément abegin et contenant asize éléments.
Definition Span.h:593
Constructeur de chaîne de caractère unicode.
String toString() const
Retourne la chaîne de caractères construite.
Chaîne de caractères unicode.
bool null() const
Retourne true si la chaîne est nulle.
Definition String.cc:304
Span< const Byte > bytes() const
Retourne la conversion de l'instance dans l'encodage UTF-8.
Definition String.cc:291
StringView view() const
Retourne une vue sur la chaîne actuelle.
Definition String.cc:367
TraceAccessor(ITraceMng *m)
Construit un accesseur via le gestionnaire de trace m.
TraceMessageDbg debug(Trace::eDebugLevel=Trace::Medium) const
Flot pour un message de debug.
ITraceMng * traceMng() const
Gestionnaire de trace.
Vecteur 1D de données avec sémantique par valeur (style STL).
Paramètres nécessaires à la construction d'une variable.
Arguments des méthodes de VariableComparer.
void setMaxPrint(Int32 v)
Positionne le nombre d'erreurs à afficher dans le listing.
void setCompareGhost(bool v)
Indique sur quelles entités on fait la comparaison.
Résultats d'une opération de comparaison.
Informations sur une dépendance de variable.
IVariable::eDependType dependType() const
Type de dépendance.
IVariable * variable() const
Variable.
Infos caractérisant une variable.
const String & itemFamilyName() const
Nom de la famille d'entité à laquelle la variable est associée.
const String & meshName() const
Nom du maillage auquel la variable est associée.
const String & fullName() const
Nom complet de la variable (associé à la famille)
void setDefaultItemGroupName()
Si null, change itemGroupName() en le nom du groupe de toutes les entités de la famille.
Meta-données sur une variable.
bool m_has_recursive_depend
Vrai si les dépendances sont récursives.
Definition Variable.cc:119
VariableInfo m_infos
Infos caractéristiques de la variable.
Definition Variable.cc:103
IItemFamily * m_item_family
Familly d'entité (peut être nul)
Definition Variable.cc:102
Integer m_nb_reference
Première référence sur la variable.
Definition Variable.cc:111
UniqueArray< VariableDependInfo > m_depends
Liste des dépendances de cette variable.
Definition Variable.cc:112
int m_property
Propriétés de la variable.
Definition Variable.cc:104
AutoDetachObservable m_on_size_changed_observable
Observable en redimensionnement.
Definition Variable.cc:117
Real m_last_update_time
Temps physique de la dernière mise à jour.
Definition Variable.cc:109
Int64 m_modified_time
Tag de la dernière modification.
Definition Variable.cc:113
MeshHandle m_mesh_handle
Maillage (peut être nul)
Definition Variable.cc:99
std::map< String, String > m_tags
Liste des tags.
Definition Variable.cc:118
ItemGroup m_item_group
Groupe d'entité sur lequel est associé la variable.
Definition Variable.cc:101
bool m_is_used
Etat d'utilisation de la variable.
Definition Variable.cc:107
void serializeHashId(ISerializer *sbuf)
Sérialise le hashid.
Definition Variable.cc:131
ScopedPtrT< IVariableComputeFunction > m_compute_function
Fonction de calcul.
Definition Variable.cc:114
AutoDetachObservable m_read_observable
Observable en lecture.
Definition Variable.cc:116
AutoDetachObservable m_write_observable
Observable en écriture.
Definition Variable.cc:115
bool m_has_valid_data
Vrai si les données sont valide.
Definition Variable.cc:108
bool m_is_partial
Vrai si la variable est partielle.
Definition Variable.cc:105
Variable * m_variable
Variable associée.
Definition Variable.cc:121
Ref< IData > m_data
Données de la variable.
Definition Variable.cc:100
Référence à une variable.
Definition VariableRef.h:56
virtual void updateFromInternal()
Mise à jour à partir de la partie interne.
VariableRef * previousReference()
Référence précédente (ou null) sur variable()
virtual int referenceProperty() const
Propriétés de la référence (interne)
VariableRef * nextReference()
Référence suivante (ou null) sur variable()
void resizeFromGroup() override
Positionne le nombre d'éléments pour une variable du maillage.
Definition Variable.cc:991
String itemGroupName() const final
Nom du groupe d'entité associée.
Definition Variable.cc:509
IMesh * mesh() const final
Maillage auquel est associé la variable.
Definition Variable.cc:814
void notifyBeginWrite() override
Notifie du début d'écriture de data().
Definition Variable.cc:1316
Integer nbReference() const override
Nombre de références sur cette variable.
Definition Variable.cc:455
void removeVariableRef(VariableRef *ref) override
Supprime une référence à cette variable.
Definition Variable.cc:393
void _checkSwapIsValid(Variable *rhs)
Vérifie qu'il est possible d'échanger les valeurs de l'instance avec celle de rhs.
Definition Variable.cc:1365
bool isUsed() const override
Etat d'utilisation de la variable.
Definition Variable.cc:692
Variable(const VariableBuildInfo &v, const VariableInfo &vi)
Créé une variable lié à la référence v.
Definition Variable.cc:342
void _setData(const Ref< IData > &data)
Positionne la donnée.
Definition Variable.cc:888
void _setValidData(bool valid_data)
Indique si les données de la variable sont valides.
Definition Variable.cc:903
VariableMetaData * createMetaData() const override
Créé une instance contenant les meta-données de la variable.
Definition Variable.cc:738
IVariableComputeFunction * computeFunction() override
Fonction utilisée pour mettre à jour la variable.
Definition Variable.cc:1241
Ref< VariableMetaData > createMetaDataRef() const override
Créé une instance contenant les meta-données de la variable.
Definition Variable.cc:747
bool isPartial() const override
Indique si la variable est partielle.
Definition Variable.cc:870
String tagValue(const String &tagname) override
Valeur du tag tagname. La chaîne est nulle si le tag n'existe pas.
Definition Variable.cc:1292
void notifyReferencePropertyChanged() override
Indique que les propriétés d'une des références à cette variable ont changé (interne)
Definition Variable.cc:616
IVariableMng * variableMng() const override
Gestionnaire de variable associé à la variable.
Definition Variable.cc:473
void removeTag(const String &tagname) override
Supprime le tag tagname.
Definition Variable.cc:1274
void addDepend(IVariable *var, eDependType dt) override
Ajoute var à la liste des dépendances.
Definition Variable.cc:1204
String name() const final
Nom de la variable.
Definition Variable.cc:482
IObservable * readObservable() override
Observable en lecture.
Definition Variable.cc:1110
virtual VariableComparerResults _compareVariable(const VariableComparerArgs &compare_args)=0
Comparaison de valeurs entre variables.
void serialize(ISerializer *sbuffer, IDataOperation *operation) override
Definition Variable.cc:953
ItemGroup itemGroup() const final
Groupe du maillage associé.
Definition Variable.cc:834
IObservable * onSizeChangedObservable() override
Observable en redimensionnement.
Definition Variable.cc:1119
void notifyEndRead() override
Notifie de la modification externe de data().
Definition Variable.cc:1304
void read(IDataReader *d) override
Definition Variable.cc:1325
void syncReferences() override
Synchronise les références.
Definition Variable.cc:756
void setUsed(bool v) override
Positionne l'état d'utilisation de la variable.
Definition Variable.cc:625
VariableRef * firstReference() const override
Première réference (ou null) sur cette variable.
Definition Variable.cc:430
String fullName() const final
Nom complet de la variable (avec le préfixe de la famille)
Definition Variable.cc:491
eItemKind itemKind() const override
Genre des entités du maillage sur lequel repose la variable.
Definition Variable.cc:843
ISubDomain * subDomain() override
Sous-domaine associé à la variable (TODO rendre obsolète fin 2023)
Definition Variable.cc:464
void update() override
Recalcule la variable si nécessaire.
Definition Variable.cc:1131
Integer dimension() const override
Dimension de la variable.
Definition Variable.cc:852
Int64 modifiedTime() override
Temps auquel la variable a été mise à jour.
Definition Variable.cc:1195
void setUpToDate() override
Indique que la variable vient d'être mise à jour.
Definition Variable.cc:1185
void addTag(const String &tagname, const String &tagvalue) override
Ajoute le tag tagname avev la valeur tagvalue.
Definition Variable.cc:1265
Int32 checkIfSame(IDataReader *reader, Integer max_print, bool compare_ghost) final
Vérifie que la variable est identique à une valeur de référence.
Definition Variable.cc:800
~Variable() override
Libère les ressources.
Definition Variable.cc:352
bool _hasValidData() const
Indique si les données de la variable sont valides.
Definition Variable.cc:912
IObservable * writeObservable() override
Observable en écriture.
Definition Variable.cc:1101
void addVariableRef(VariableRef *ref) override
Ajoute une référence à cette variable.
Definition Variable.cc:372
Integer multiTag() const override
Indique si la variable est un tableau à taille multiple.
Definition Variable.cc:861
void setComputeFunction(IVariableComputeFunction *v) override
Positionne la fonction de recalcul de la variable.
Definition Variable.cc:1232
void resize(Integer n) override
Positionne le nombre d'éléments pour une variable tableau.
Definition Variable.cc:982
IVariableInternal * _internalApi() override
API interne à Arcane.
Definition Variable.cc:1411
IItemFamily * itemFamily() const final
Famille d'entité associée.
Definition Variable.cc:879
eDataType dataType() const override
Type de la donnée gérée par la variable (Real, Integer, ...)
Definition Variable.cc:527
void write(IDataWriter *d) override
Sauve la variable.
Definition Variable.cc:1335
IDataFactoryMng * dataFactoryMng() const final
Fabrique de données associées à la variable.
Definition Variable.cc:930
void changeGroupIds(Int32ConstArrayView old_to_new_ids) override
pH : EXPERIMENTAL
Definition Variable.cc:1345
void removeDepend(IVariable *var) override
Supprime var de la liste des dépendances.
Definition Variable.cc:1222
String itemFamilyName() const final
Nom de la famille associée (nul si aucune).
Definition Variable.cc:500
Int32 checkIfSync(Integer max_print) final
Vérifie si la variable est bien synchronisée.
Definition Variable.cc:773
DataAllocationInfo allocationInfo() const override
Informations sur l'allocation.
Definition Variable.cc:1402
int property() const override
Definition Variable.cc:538
Int32 checkIfSameOnAllReplica(Integer max_print) final
Vérifie si la variable a les mêmes valeurs sur tous les réplicas.
Definition Variable.cc:787
void dependInfos(Array< VariableDependInfo > &infos) override
Infos de dépendances.
Definition Variable.cc:1250
bool hasTag(const String &tagname) override
true si la variable possède le tag tagname
Definition Variable.cc:1283
void setAllocationInfo(const DataAllocationInfo &v) override
Positionne les informations sur l'allocation.
Definition Variable.cc:1390
MeshHandle meshHandle() const final
Maillage auquel est associé la variable.
Definition Variable.cc:825
String meshName() const final
Nom du maillage associé (nul si aucun).
Definition Variable.cc:518
String toHexaString(ByteConstArrayView input)
Converti un tableau d'octet en sa représentation hexadécimale.
Definition Convert.cc:75
ARCCORE_BASE_EXPORT String getEnvironmentVariable(const String &name)
Variable d'environnement du nom name.
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
@ DIP_Legacy
Initialisation en mode historique.
Definition DataTypes.h:161
std::int64_t Int64
Type entier signé sur 64 bits.
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
UniqueArray< Int32 > Int32UniqueArray
Tableau dynamique à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:428
impl::SpanTypeFromSize< conststd::byte, SizeType >::SpanType asBytes(const SpanImpl< DataType, SizeType, Extent > &s)
Converti la vue en un tableau d'octets non modifiables.
Definition Span.h:884
@ SameOnAllReplica
Vérifie que les valeurs de la variable sont les même sur tous les replica.
@ Sync
Vérifie que la variable est bien synchronisée.
eItemKind
Genre d'entité de maillage.
@ IK_Particle
Entité de maillage de genre particule.
@ IK_Unknown
Entité de maillage de genre inconnu ou non initialisé
@ IK_DoF
Entité de maillage de genre degre de liberte.
const char * itemKindName(eItemKind kind)
Nom du genre d'entité.
double Real
Type représentant un réel.
unsigned char Byte
Type d'un octet.
Definition BaseTypes.h:43
auto makeRef(InstanceType *t) -> Ref< InstanceType >
Créé une référence sur un pointeur.
eDataType
Type d'une donnée.
Definition DataTypes.h:39
const char * dataTypeName(eDataType type)
Nom du type de donnée.
Definition DataTypes.cc:70
std::int32_t Int32
Type entier signé sur 32 bits.
Span< DataType > asSpan(Span< std::byte, Extent > bytes)
Converti un Span<std::byte> en un Span<DataType>.
Definition Span.h:976