Arcane  v3.16.6.0
Documentation utilisateur
Chargement...
Recherche...
Aucune correspondance
IVariable.h
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/* IVariable.h (C) 2000-2025 */
9/* */
10/* Interface de la classe Variable. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_CORE_IVARIABLE_H
13#define ARCANE_CORE_IVARIABLE_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17#include "arccore/serialize/SerializeGlobal.h"
18
19#include "arcane/utils/Ref.h"
21
22/*---------------------------------------------------------------------------*/
23/*---------------------------------------------------------------------------*/
24
25namespace Arcane
26{
27
28/*---------------------------------------------------------------------------*/
29/*---------------------------------------------------------------------------*/
30/*!
31 * \brief Interface d'une variable.
32 *
33 * L'implémentation de cette interface est la classe Variable.
34 *
35 * En général cette interface n'est pas utilisée directement. Les variables
36 * sont gérées par la classe VariableRef et les classes qui en dérive.
37 */
38class ARCANE_CORE_EXPORT IVariable
39{
40 public:
41
42 //! Type des dépendances
44 {
45 DPT_PreviousTime,
46 DPT_CurrentTime
47 };
48
49 public:
50
51 /*!
52 * \brief Propriétés d'une variable.
53 */
54 enum
55 {
56 //! Indique que la variable ne doit pas être sauvegardée.
57 PNoDump = (1 << 0),
58
59 /*!
60 * \brief Indique que la variable n'est pas nécessairement synchronisée.
61 *
62 * Cela signifie qu'il est normal que les valeurs de la variable soient
63 * différentes d'un processeur à l'autre sur les mailles fantômes
64 */
65 PNoNeedSync = (1 << 1),
66
67 //! Indique que la variable est tracée (uniquement en mode trace)
68 PHasTrace = (1 << 2),
69
70 /*! \brief Indique que la valeur de la variable est dépendante du sous-domaine.
71 *
72 * Cela signifie entre autre que la valeur de la variable est différente
73 * dès que le nombre de sous-domaines varie. C'est par exemple le cas
74 * de la variable contenant le numéro du sous-domaine propriétaire d'une entité.
75 */
76 PSubDomainDepend = (1 << 3),
77
78 /*! \brief Indique que la variable est privée au sous-domaine.
79 *
80 * Cela signifie que la variable est dépendante du sous-domaine et notamment
81 * qu'elle n'existe pas forcément sur tout les sous-domaines. Cette
82 * propriété ne peut pas être positionnée pour les variables du maillage.
83 */
85
86 /*! \brief Indique que la valeur de la variable est dépendante de l'exécution
87 *
88 * Les valeurs de ces variables changent entre deux exécutions. C'est par
89 * exemple le cas d'une variable contenant le temps CPU utilisé.
90 */
91 PExecutionDepend = (1 << 5),
92
93 /*! \brief Indique que la variable est privée
94 *
95 * Une variable privée ne peut pas posséder plus d'une référence.
96 * Cette propriété ne peut être positionner que lors de la création de la
97 * variable
98 */
99 PPrivate = (1 << 6),
100
101 /*! \brief Indique que la variable est temporaire
102 *
103 * Une variable temporaire est comme son nom l'indique temporaire. Elle
104 * ne peut pas être sauvée, n'est pas transférée en cas d'équilibrage
105 * du maillage (mais peut être synchronisée) et n'est pas sauvée en
106 * cas de retour arrière.
107 *
108 * Une variable temporaire qui n'est plus utilisée (aucune référence dessus)
109 * peut être désallouée.
110 */
111 PTemporary = (1 << 7),
112
113 /*! \brief Indique que la variable ne doit pas être restaurée.
114 *
115 * Une variable de ce type n'est pas sauvegardée ni restorée en cas
116 * de retour-arrière.
117 */
118 PNoRestore = (1 << 8),
119
120 /*! \brief Indique que la variable ne doit pas être échangée.
121 *
122 * Une variable de ce type n'est pas échangée lors d'un repartitionnement
123 * de maillage par exemple. Cela permet d'éviter l'envoie de données
124 * inutiles si cette variable n'est utilisée que temporairement ou
125 * qu'elle est recalculée dans un des points d'entrée appelé
126 * suite à un repartitionnement.
127 */
128 PNoExchange = (1 << 9),
129
130 /*!
131 * \brief Indique que la variable est persistante.
132 *
133 * Une variable persistante n'est pas détruite s'il n'existe plus de référence dessus.
134 */
135 PPersistant = (1 << 10),
136
137 /*!
138 * \brief Indique que la variable n'a pas forcément la même valeur
139 * entre les réplicas.
140 *
141 * Cela signifie qu'il est normal que les valeurs de la variable soient
142 * différentes sur les mêmes sous-domaines des autres réplicas.
143 */
144 PNoReplicaSync = (1 << 11)
145 };
146
147 public:
148
149 //! Tag utilisé pour indiquer si une variable sera post-traitée
150 static const char* TAG_POST_PROCESSING;
151
152 //! Tag utilisé pour indiquer si une variable sera post-traitée à cette itération
154
155 public:
156
157 friend class VariableMng;
158
159 public:
160
161 virtual ~IVariable() = default; //!< Libère les ressources
162
163 public:
164
165 //! Sous-domaine associé à la variable (TODO rendre obsolète fin 2023)
166 virtual ISubDomain* subDomain() = 0;
167
168 public:
169
170 //! Gestionnaire de variable associé à la variable
171 virtual IVariableMng* variableMng() const = 0;
172
173 //! Taille mémoire (en Koctet) utilisée par la variable
174 virtual Real allocatedMemory() const = 0;
175
176 //! Nom de la variable
177 virtual String name() const = 0;
178
179 //! Nom complet de la variable (avec le préfixe de la famille)
180 virtual String fullName() const = 0;
181
182 //! Type de la donnée gérée par la variable (Real, Integer, ...)
183 virtual eDataType dataType() const = 0;
184
185 /*!
186 * \brief Genre des entités du maillage sur lequel repose la variable.
187 *
188 * Pour les variables scalaire ou tableau, il n'y a pas de genre et la
189 * méthode retourne #IK_Unknown.
190 * Pour les autres variables, retourne le genre de l'élément de
191 * maillage (Node, Cell, ...), à savoir:
192 * - #IK_Node pour les noeuds
193 * - #IK_Edge pour les arêtes
194 * - #IK_Face pour les faces
195 * - #IK_Cell pour les mailles
196 * - #IK_Particle pour les particules
197 * - #IK_DoF pour les degrés de liberté
198 */
199 virtual eItemKind itemKind() const = 0;
200
201 /*!
202 * \brief Dimension de la variable.
203 *
204 * Les valeurs possibles sont les suivantes:
205 * - 0 pour une variable scalaire,.
206 * - 1 pour une variable tableau mono-dim ou variable scalaire du maillage.
207 * - 2 pour une variable tableau bi-dim ou variable tableau du maillage.
208 */
209 virtual Integer dimension() const = 0;
210
211 /*!
212 * \brief Indique si la variable est un tableau à taille multiple.
213 *
214 * Cette valeur n'est utile que pour les tableaux 2D ou plus.
215 * - 0 pour une variable scalaire ou tableau 2D standard.
216 * - 1 pour une variable tableau 2D à taille multiple.
217 * - 2 pour une variable tableau 2D ancient format (obsolète).
218 */
219 virtual Integer multiTag() const = 0;
220
221 /*!
222 * \brief Nombre d'éléments de la variable.
223 *
224 * Les valeurs retournées dépendent de la dimension de la variable:
225 * - pour une dimension 0, retourne 1,
226 * - pour une dimension 1, retourne le nombre d'éléments du tableau
227 * - pour une dimension 2, retourne le nombre total d'éléments en sommant
228 * le nombre d'éléments par dimension.
229 */
230 virtual Integer nbElement() const = 0;
231
232 //! Retourne les propriétés de la variable
233 virtual int property() const = 0;
234
235 //! Indique que les propriétés d'une des références à cette variable ont changé (interne)
237
238 /*!
239 * \brief Ajoute une référence à cette variable
240 *
241 * \pre \a var_ref ne doit pas déjà référencer une variable.
242 */
243 virtual void addVariableRef(VariableRef* var_ref) = 0;
244
245 /*!
246 * \brief Supprime une référence à cette variable
247 *
248 * \pre \a var_ref doit référencer cette variable (un appel à addVariableRef()
249 * doit avoir été effectué sur cette variable).
250 */
251 virtual void removeVariableRef(VariableRef* var_ref) = 0;
252
253 //! Première réference (ou null) sur cette variable
254 virtual VariableRef* firstReference() const = 0;
255
256 //! Nombre de références sur cette variable
257 virtual Integer nbReference() const = 0;
258
259 public:
260
261 ARCANE_DEPRECATED_REASON("Y2021: This method is a noop")
262 virtual void setTraceInfo(Integer id, eTraceType tt) = 0;
263
264 public:
265
266 /*!
267 * \brief Positionne le nombre d'éléments pour une variable tableau.
268 *
269 * Lorsque la variable est du type tableau 1D ou 2D, positionne le nombre
270 * d'éléments du tableau à \a new_size. Pour un tableau 2D, c'est le
271 * nombre d'éléments de la première dimension qui est modifié.
272 *
273 * Cette opération ne doit pas être appelée pour les variables du maillage
274 * car le nombre d'éléments est déterminé automatiquement en fonction du nombre
275 * d'entités du groupe sur lequel elle s'appuie. Pour ce type de variable,
276 * il faut appeler resizeFromGroup().
277 *
278 * Cette opération synchronise les références (syncReferences()).
279 */
280 virtual void resize(Integer new_size) = 0;
281
282 /*!
283 * \brief Positionne le nombre d'éléments pour une variable du maillage.
284 *
285 * Réalloue la taille de la variable du maillage à partir du groupe
286 * sur laquelle elle s'appuie.
287 *
288 * Cette opération n'a d'effet que pour les variables du maillage.
289 * Pour les autres, aucun action n'est effectuée.
290 *
291 * Cette opération synchronise les références (syncReferences()).
292 */
293 virtual void resizeFromGroup() = 0;
294
295 /*!
296 * \brief Libère l'éventuelle mémoire supplémentaire allouée pour
297 * les données.
298 *
299 * Cette méthode n'est utilie que pour les variables non scalaires
300 */
301 virtual void shrinkMemory() = 0;
302
303 //! Positionne les informations sur l'allocation
304 virtual void setAllocationInfo(const DataAllocationInfo& v) = 0;
305
306 //! Informations sur l'allocation
308
309 public:
310
311 /*!
312 * \brief Initialise la variable sur un groupe.
313 *
314 * Initialise la variable avec la valeur \a value pour tous les éléments du
315 * groupe \a group.
316 *
317 * Cette opération n'est utilisable qu'avec les variables de maillage.
318 *
319 * \param group_name groupe. Il doit correspondre à un groupe existant
320 * du type de la variable (par exemple CellGroup pour une variable au maille).
321 * \param value valeur d'initialisation. La chaîne doit pouvoir être convertie
322 * en le type de la variable.
323 *
324 * \retval true en cas d'erreur ou si la variable n'est pas une variable du
325 * maillage.
326 * \retval false si l'initialisation est un succès.
327 */
328 virtual bool initialize(const ItemGroup& group, const String& value) = 0;
329
330 //! @name Opérations de vérification
331 //@{
332 /*! \brief Vérifie si la variable est bien synchronisée.
333 *
334 * Cette opération ne fonctionne que pour les variables de maillage.
335 *
336 * Un variable est synchronisée lorsque ses valeurs sont les mêmes
337 * sur tous les sous-domaines à la fois sur les éléments propres et
338 * les éléments fantômes.
339 *
340 * Pour chaque élément non synchronisé, un message est affiché.
341 *
342 * \param max_print nombre maximum de messages à afficher.
343 * Si 0, aucun élément n'est affiché. Si positif, affiche au plus
344 * \a max_print élément. Si négatif, tous les éléments sont affichés.
345 *
346 * \return le nombre de valeurs différentes de la référence
347 */
348 virtual Int32 checkIfSync(Integer max_print = 0) = 0;
349
350 /*! \brief Vérifie que la variable est identique à une valeur de référence
351 *
352 * Cette opération vérifie que les valeurs de la variable sont identique
353 * à une valeur de référence qui est lu à partir du lecteur \a reader.
354 *
355 * Pour chaque valeur différente de la référence, un message est affiché.
356 *
357 * \param max_print nombre maximum de messages à afficher.
358 * Si 0, aucun élément n'est affiché. Si positif, affiche au plus
359 * \a max_print élément. Si négatif, tous les éléments sont affichés.
360 * \param compare_ghost si vrai, compare les valeurs à la fois sur les entités
361 * propres et les entités fantômes. Sinon, ne fait la comparaison que sur les
362 * entités propres.
363 *
364 * \return le nombre de valeurs différentes de la référence
365 */
366 virtual Int32 checkIfSame(IDataReader* reader, Integer max_print, bool compare_ghost) = 0;
367
368 /*!
369 * \brief Vérifie si la variable a les mêmes valeurs sur tous les réplicas.
370 *
371 * Compare les valeurs de la variable avec celle du même sous-domaine
372 * des autres réplicas. Pour chaque élément différent,
373 * un message est affiché.
374 *
375 * Cette méthode est collective sur le même sous-domaine des autres réplica.
376 * Il ne faut donc l'appeler que si la variable existe sur tous les sous-domaines
377 * sinon cela provoque un blocage.
378 *
379 * Cette méthode ne fonctionne que pour les variables sur les types numériques.
380 * Dans ce cas, elle renvoie une exception de type NotSupportedException.
381 *
382 * \param max_print nombre maximum de messages à afficher.
383 * Si 0, aucun élément n'est affiché. Si positif, affiche au plus
384 * \a max_print élément. Si négatif, tous les éléments sont affichés.
385 * Pour chaque élément différent est affiché la valeur minimale et
386 * maximale.
387 *
388 * \return le nombre de valeurs différentes de la référence.
389 */
390 virtual Int32 checkIfSameOnAllReplica(Integer max_print = 0) = 0;
391 //@}
392
393 /*!
394 * \brief Synchronise la variable.
395 *
396 La synchronisation ne peut se faire que sur les variables du maillage.
397 */
398 virtual void synchronize() = 0;
399
400 // TODO: à rendre virtuelle pure (décembre 2024)
401 /*!
402 * \brief Synchronise la variable sur une liste d'entités.
403 *
404 * La synchronisation ne peut se faire que sur les variables du maillage.
405 * Seules les entités listées dans \a local_ids seront synchronisées. Attention :
406 * une entité présente dans cette liste sur un sous-domaine doit être présente
407 * dans cette liste pour tout autre sous-domaine qui possède cette entité.
408 */
409 virtual void synchronize(Int32ConstArrayView local_ids);
410
411 /*!
412 * \brief Maillage auquel est associé la variable.
413 *
414 * Cette opération n'est significative que pour les variables sur des
415 * entités du maillage.
416 */
417 ARCCORE_DEPRECATED_2020("Use meshHandle() instead")
418 virtual IMesh* mesh() const = 0;
419
420 /*!
421 * \brief Maillage auquel est associé la variable.
422 *
423 * Cette opération n'est significative que pour les variables sur des
424 * entités du maillage.
425 */
426 virtual MeshHandle meshHandle() const = 0;
427
428 /*!
429 * \brief Groupe du maillage associé.
430 *
431 * \return le groupe du maillage associé si pour une variable du maillage
432 * ou le groupe nul si la variable n'est pas une variable du maillage.
433 *
434 * Si une variable n'est pas utilisée ou pas encore allouée,
435 * la valeur retournée est le group nul.
436 * Cependant, la variable peut quand même être associée à un groupe.
437 * Dans ce cas, il faut utiliser la fonction itemGroupName() pour
438 * récupérer le nom de ce groupe.
439 */
440 virtual ItemGroup itemGroup() const = 0;
441
442 //! Nom du groupe d'entité associée.
443 virtual String itemGroupName() const = 0;
444
445 /*!
446 * \brief Famille d'entité associée.
447 *
448 * \return la famille associée à la variable ou 0
449 * si la variable n'a pas de famille.
450 *
451 * Si une variable n'est pas utilisée ou pas encore allouée,
452 * la valeur retournée est nulle.
453 * Cependant, la variable peut quand même être associée à une famille.
454 * Dans ce cas, il faut utiliser la fonction itemFamilyName() pour
455 * récupérer le nom de cette famille.
456 */
457 virtual IItemFamily* itemFamily() const = 0;
458
459 //! Nom de la famille associée (nul si aucune).
460 virtual String itemFamilyName() const = 0;
461
462 //! Nom du maillage associé (nul si aucun).
463 virtual String meshName() const = 0;
464
465 /*!
466 * \brief Créé une instance contenant les meta-données de la variable.
467 *
468 * L'instance retournée doit être détruite par l'appel à l'opérateur delete.
469 */
470 ARCANE_DEPRECATED_REASON("Y2024: Use createMetaDataRef() instead")
471 virtual VariableMetaData* createMetaData() const = 0;
472
473 //! Créé une instance contenant les meta-données de la variable.
475
476 /*!
477 * \brief Synchronise les références.
478 *
479 * Synchronise les valeurs des références (VariableRef) à cette variable
480 * avec la valeur actuelle de la variable. Cette méthode est appelé
481 * automatiquement lorsqu'une variable scalaire est modifiée ou
482 * le nombre d'éléments d'une variable tableau change.
483 */
484 virtual void syncReferences() = 0;
485
486 public:
487
488 /*!
489 * \brief Positionne l'état d'utilisation de la variable
490 *
491 * Si \v est faux, la variable devient inutilisable
492 * et toutes les ressources associées sont libérées.
493 *
494 * Si \v est vrai, la variable est considérée comme utilisée et s'il s'agit
495 * d'une variable du maillage et que setItemGroup() n'a pas été appelé, la
496 * variable est allouée sur le groupe de toutes les entités.
497 */
498 virtual void setUsed(bool v) = 0;
499
500 //! Etat d'utilisation de la variable
501 virtual bool isUsed() const = 0;
502
503 /*!
504 * \brief Indique si la variable est partielle.
505 *
506 * Une variable est partielle lorsqu'elle n'est pas définie sur toutes les
507 * entités d'une famille. Dans ce cas, group()!=itemFamily()->allItems().
508 */
509 virtual bool isPartial() const = 0;
510
511 public:
512
513 /*!
514 * \brief Copie les valeurs des entités numéros @a source dans les entités
515 * numéro @a destination
516 *
517 * @note Cette opération est interne à Arcane et doit se faire en
518 * conjonction avec la famille d'entité correspondant à cette
519 * variable.
520 *
521 * @param source liste des @b localId source
522 * @param destination liste des @b localId destination
523 */
524 virtual void copyItemsValues(Int32ConstArrayView source, Int32ConstArrayView destination) = 0;
525
526 /*!
527 * \brief Copie les moyennes des valeurs des entités numéros
528 * @a first_source et @a second_source dans les entités numéros
529 * @a destination
530 *
531 * @param first_source liste des @b localId de la 1ère source
532 * @param second_source liste des @b localId de la 2ème source
533 * @param destination liste des @b localId destination
534 */
535 virtual void copyItemsMeanValues(Int32ConstArrayView first_source,
536 Int32ConstArrayView second_source,
537 Int32ConstArrayView destination) = 0;
538
539 /*!
540 * \brief Compacte les valeurs de la variable.
541 *
542 * Cette opération est interne à Arcane et doit se faire en
543 * conjonction avec la famille d'entité correspondant à cette
544 * variable.
545 */
546 virtual void compact(Int32ConstArrayView new_to_old_ids) = 0;
547
548 //! pH : EXPERIMENTAL
549 virtual void changeGroupIds(Int32ConstArrayView old_to_new_ids) = 0;
550
551 public:
552
553 //! Données associées à la variable
554 virtual IData* data() = 0;
555
556 //! Données associées à la variable
557 virtual const IData* data() const = 0;
558
559 //! Fabrique de données associées à la variable
560 virtual IDataFactoryMng* dataFactoryMng() const = 0;
561
562 //! @name Opérations de sérialisation
563 //@{
564 /*! Sérialize la variable.
565 *
566 * L'opération \a opération n'est significative qu'en lecture (ISerializer::ModeGet)
567 */
568 virtual void serialize(ISerializer* sbuffer, IDataOperation* operation = 0) = 0;
569
570 /*!
571 * \brief Sérialize la variable pour les identifiants \a ids.
572 *
573 * La sérialisation dépend de la dimension de la variable.
574 * Pour les variables scalaires (dimension=0), rien n'est fait.
575 * Pour les variables tableaux ou du maillage, \a ids correspond a un tableau
576 * d'indirection de la première dimension.
577 *
578 * L'opération \a opération n'est significative qu'en lecture (ISerializer::ModeGet)
579 */
580 virtual void serialize(ISerializer* sbuffer, Int32ConstArrayView ids, IDataOperation* operation = 0) = 0;
581
582 /*!
583 * \brief Sauve la variable
584 *
585 * \deprecated A remplacer par le code suivant:
586 * \code
587 * IVariable* var;
588 * var->notifyBeginWrite();
589 * writer->write(var,var->data());
590 * \endcode
591 */
592 virtual ARCANE_DEPRECATED_2018 void write(IDataWriter* writer) = 0;
593
594 /*!
595 * Relit la variable.
596 *
597 * \deprecated A remplacer par le code suivant:
598 * \code
599 * IVariable* var;
600 * reader->read(var,var->data());
601 * var->notifyEndRead();
602 * \endcode
603 */
604 virtual ARCANE_DEPRECATED_2018 void read(IDataReader* reader) = 0;
605
606 /*!
607 * \brief Notifie de la modification externe de data().
608 *
609 * Signale à l'instance la fin d'une opération de lecture qui a modifié
610 * data(). Cette méthode doit donc être appelée dès qu'on a effectué
611 * une modication de data(). Cette méthode déclenche les observables enregistrés
612 * dans readObservable().
613 */
614 virtual void notifyEndRead() = 0;
615
616 /*!
617 * \brief Notifie du début d'écriture de data().
618 *
619 * Cette méthode déclenche les observables enregistrés
620 * dans writeObservable().
621 */
622 virtual void notifyBeginWrite() = 0;
623
624 /*!
625 * \brief Observable en écriture.
626 *
627 * Les observateurs enregistrés dans cet observable sont appelés
628 * avant d'écrire la variable (opération write()).
629 */
631
632 /*! \brief Observable en lecture.
633 *
634 * Les observateurs enregistrés dans cet observable sont appelés
635 * après avoir lu la variable (opération read).
636 */
638
639 /*! \brief Observable en redimensionnement.
640 *
641 * Les observateurs enregistrés dans cet observable sont appelés
642 * lorsque le nombre d'éléments de la variable change.
643 * C'est le cas par exemple après un remaillage pour une variable aux mailles
644 */
646 //@}
647
648 //@{ @name Gestion des tags
649 //! Ajoute le tag \a tagname avev la valeur \a tagvalue
650 virtual void addTag(const String& tagname, const String& tagvalue) = 0;
651 /*! \brief Supprime le tag \a tagname
652 *
653 * Si le tag \a tagname n'est pas dans la liste, rien ne se passe.
654 */
655 virtual void removeTag(const String& tagname) = 0;
656 //! \a true si la variable possède le tag \a tagname
657 virtual bool hasTag(const String& tagname) = 0;
658 //! Valeur du tag \a tagname. La chaîne est nulle si le tag n'existe pas.
659 virtual String tagValue(const String& tagname) = 0;
660 //@}
661
662 public:
663
664 //! Imprime les valeurs de la variable sur le flot \a o
665 virtual void print(std::ostream& o) const = 0;
666
667 public:
668
669 //! @name Gestion des dépendances
670 //@{
671 /*!
672 * \brief Recalcule la variable si nécessaire
673 *
674 * Par le mécanisme de dépendances, cette opération est appelée récursivement
675 * sur toutes les variables dont dépend l'instance. La fonction de recalcul
676 * computeFunction() est ensuite appelée s'il s'avère qu'une des variables
677 * dont elle dépend a été modifiée plus récemment.
678 *
679 * \pre computeFunction() != 0
680 */
681 virtual void update() = 0;
682
683 virtual void update(Real wanted_time) = 0;
684
685 /*! \brief Indique que la variable vient d'être mise à jour.
686 *
687 * Pour une gestion correcte des dépendances, il faut que cette propriété
688 * soit appelée toutes les fois où la mise à jour d'une variable a été
689 * effectuée.
690 */
691 virtual void setUpToDate() = 0;
692
693 //! Temps auquel la variable a été mise à jour
694 virtual Int64 modifiedTime() = 0;
695
696 //! Ajoute \a var à la liste des dépendances
697 virtual void addDepend(IVariable* var, eDependType dt) = 0;
698
699 //! Ajoute \a var à la liste des dépendances avec les infos de trace \a tinfo
700 virtual void addDepend(IVariable* var, eDependType dt, const TraceInfo& tinfo) = 0;
701
702 /*! \brief Supprime \a var de la liste des dépendances
703 */
704 virtual void removeDepend(IVariable* var) = 0;
705
706 /*!
707 * \brief Positionne la fonction de recalcul de la variable.
708 *
709 * La fonction spécifiée \a v doit être allouée via l'opérateur new.
710 * Si une fonction de recalcule existait déjà, elle est détruite
711 * (via l'opérateur delete) et remplacée par celle-ci.
712 */
714
715 //! Fonction utilisée pour mettre à jour la variable
717
718 /*!
719 * \brief Infos de dépendances.
720 *
721 * Remplit le tableau \a infos avec les infos de dépendance.
722 */
723 virtual void dependInfos(Array<VariableDependInfo>& infos) = 0;
724 //@}
725
726 public:
727
728 ARCANE_DEPRECATED_REASON("Y2021: This method is a noop")
729 virtual IMemoryAccessTrace* memoryAccessTrace() const = 0;
730
731 /*!
732 * \brief Indique que la variable est synchronisée.
733 *
734 * Cette opération est collective.
735 */
736 virtual void setIsSynchronized() = 0;
737
738 /*!
739 * \brief Indique que la variable est synchronisée sur le group \a item_group
740 *
741 * Cette opération est collective.
742 */
743 virtual void setIsSynchronized(const ItemGroup& item_group) = 0;
744
745 public:
746
747 //! Incrémente le compteur de modification et retourne sa valeur avant modification
749
750 public:
751
752 //! API interne à Arcane
753 virtual IVariableInternal* _internalApi() = 0;
754};
755
756/*---------------------------------------------------------------------------*/
757/*---------------------------------------------------------------------------*/
758
759} // End namespace Arcane
760
761/*---------------------------------------------------------------------------*/
762/*---------------------------------------------------------------------------*/
763
764#endif
Déclarations de types sur les entités.
Classe de base des vecteurs 1D de données.
Informations sur l'allocation d'une donnée.
Interface de lecture des données d'une variable.
Definition IDataReader.h:34
Interface d'écriture des données d'une variable.
Definition IDataWriter.h:44
Interface d'une donnée.
Definition IData.h:33
Interface d'une famille d'entités.
Definition IItemFamily.h:84
Interface d'un observable.
Interface du gestionnaire d'un sous-domaine.
Definition ISubDomain.h:74
Interface de la classe functor de re-calcul d'une variable.
Interface du gestionnaire de variables.
Interface d'une variable.
Definition IVariable.h:39
virtual Real allocatedMemory() const =0
Taille mémoire (en Koctet) utilisée par la variable.
virtual void changeGroupIds(Int32ConstArrayView old_to_new_ids)=0
pH : EXPERIMENTAL
virtual eDataType dataType() const =0
Type de la donnée gérée par la variable (Real, Integer, ...)
virtual void addTag(const String &tagname, const String &tagvalue)=0
Ajoute le tag tagname avev la valeur tagvalue.
eDependType
Type des dépendances.
Definition IVariable.h:44
virtual String meshName() const =0
Nom du maillage associé (nul si aucun).
virtual void print(std::ostream &o) const =0
Imprime les valeurs de la variable sur le flot o.
virtual void setIsSynchronized()=0
Indique que la variable est synchronisée.
virtual bool hasTag(const String &tagname)=0
true si la variable possède le tag tagname
virtual void setUsed(bool v)=0
Positionne l'état d'utilisation de la variable.
virtual String itemFamilyName() const =0
Nom de la famille associée (nul si aucune).
virtual VariableMetaData * createMetaData() const =0
Créé une instance contenant les meta-données de la variable.
virtual void notifyEndRead()=0
Notifie de la modification externe de data().
virtual void setUpToDate()=0
Indique que la variable vient d'être mise à jour.
virtual String fullName() const =0
Nom complet de la variable (avec le préfixe de la famille)
@ 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
@ PHasTrace
Indique que la variable est tracée (uniquement en mode trace)
Definition IVariable.h:68
@ 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
@ PSubDomainPrivate
Indique que la variable est privée au sous-domaine.
Definition IVariable.h:84
@ 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 ARCANE_DEPRECATED_2018 void read(IDataReader *reader)=0
virtual bool initialize(const ItemGroup &group, const String &value)=0
Initialise la variable sur un groupe.
virtual int property() const =0
Retourne les propriétés de la variable.
virtual Ref< VariableMetaData > createMetaDataRef() const =0
Créé une instance contenant les meta-données de la variable.
virtual eItemKind itemKind() const =0
Genre des entités du maillage sur lequel repose la variable.
virtual Int64 modifiedTime()=0
Temps auquel la variable a été mise à jour.
virtual Integer nbReference() const =0
Nombre de références sur cette variable.
virtual String tagValue(const String &tagname)=0
Valeur du tag tagname. La chaîne est nulle si le tag n'existe pas.
virtual void synchronize()=0
Synchronise la variable.
virtual IDataFactoryMng * dataFactoryMng() const =0
Fabrique de données associées à la variable.
virtual ~IVariable()=default
Libère les ressources.
virtual bool isPartial() const =0
Indique si la variable est partielle.
virtual Integer dimension() const =0
Dimension de la variable.
virtual void resizeFromGroup()=0
Positionne le nombre d'éléments pour une variable du maillage.
virtual void notifyReferencePropertyChanged()=0
Indique que les propriétés d'une des références à cette variable ont changé (interne)
virtual void removeDepend(IVariable *var)=0
Supprime var de la liste des dépendances.
virtual IData * data()=0
Données associées à la variable.
virtual void syncReferences()=0
Synchronise les références.
virtual Int32 checkIfSync(Integer max_print=0)=0
Vérifie si la variable est bien synchronisée.
virtual VariableRef * firstReference() const =0
Première réference (ou null) sur cette variable.
virtual bool isUsed() const =0
Etat d'utilisation de la variable.
virtual void dependInfos(Array< VariableDependInfo > &infos)=0
Infos de dépendances.
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 ARCANE_DEPRECATED_2018 void write(IDataWriter *writer)=0
Sauve la variable.
virtual IVariableComputeFunction * computeFunction()=0
Fonction utilisée pour mettre à jour la variable.
virtual Int32 checkIfSame(IDataReader *reader, Integer max_print, bool compare_ghost)=0
Vérifie que la variable est identique à une valeur de référence.
virtual IMesh * mesh() const =0
Maillage auquel est associé la variable.
virtual DataAllocationInfo allocationInfo() const =0
Informations sur l'allocation.
virtual ISubDomain * subDomain()=0
Sous-domaine associé à la variable (TODO rendre obsolète fin 2023)
virtual IObservable * readObservable()=0
Observable en lecture.
virtual IObservable * onSizeChangedObservable()=0
Observable en redimensionnement.
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
virtual void compact(Int32ConstArrayView new_to_old_ids)=0
Compacte les valeurs de la variable.
virtual void addDepend(IVariable *var, eDependType dt)=0
Ajoute var à la liste des dépendances.
virtual void notifyBeginWrite()=0
Notifie du début d'écriture de data().
virtual Int32 checkIfSameOnAllReplica(Integer max_print=0)=0
Vérifie si la variable a les mêmes valeurs sur tous les réplicas.
virtual void setComputeFunction(IVariableComputeFunction *v)=0
Positionne la fonction de recalcul de la variable.
virtual IObservable * writeObservable()=0
Observable en écriture.
virtual void copyItemsMeanValues(Int32ConstArrayView first_source, Int32ConstArrayView second_source, Int32ConstArrayView destination)=0
Copie les moyennes des valeurs des entités numéros first_source et second_source dans les entités num...
virtual void removeTag(const String &tagname)=0
Supprime le tag tagname.
virtual void serialize(ISerializer *sbuffer, IDataOperation *operation=0)=0
virtual void setAllocationInfo(const DataAllocationInfo &v)=0
Positionne les informations sur l'allocation.
virtual Integer nbElement() const =0
Nombre d'éléments de la variable.
virtual IItemFamily * itemFamily() const =0
Famille d'entité associée.
virtual String itemGroupName() const =0
Nom du groupe d'entité associée.
virtual MeshHandle meshHandle() const =0
Maillage auquel est associé la variable.
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
virtual void addVariableRef(VariableRef *var_ref)=0
Ajoute une référence à cette variable.
virtual String name() const =0
Nom de la variable.
virtual void removeVariableRef(VariableRef *var_ref)=0
Supprime une référence à cette variable.
virtual void copyItemsValues(Int32ConstArrayView source, Int32ConstArrayView destination)=0
Copie les valeurs des entités numéros source dans les entités numéro destination.
virtual IVariableInternal * _internalApi()=0
API interne à Arcane.
virtual void shrinkMemory()=0
Libère l'éventuelle mémoire supplémentaire allouée pour les données.
virtual IVariableMng * variableMng() const =0
Gestionnaire de variable associé à la variable.
virtual void resize(Integer new_size)=0
Positionne le nombre d'éléments pour une variable tableau.
Groupe d'entités de maillage.
Definition ItemGroup.h:49
Handle sur un maillage.
Definition MeshHandle.h:47
Référence à une instance.
Chaîne de caractères unicode.
Informations sur une dépendance de variable.
Meta-données sur une variable.
Référence à une variable.
Definition VariableRef.h:56
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
std::int64_t Int64
Type entier signé sur 64 bits.
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
eTraceType
Type de trace possible.
Definition DataTypes.h:188
eItemKind
Genre d'entité de maillage.
double Real
Type représentant un réel.
eDataType
Type d'une donnée.
Definition DataTypes.h:39
std::int32_t Int32
Type entier signé sur 32 bits.