Arcane  v3.16.2.0
Documentation utilisateur
Chargement...
Recherche...
Aucune correspondance
VariableComparer.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/* VariableComparer.h (C) 2000-2025 */
9/* */
10/* Classe pour effectuer des comparaisons entre les variables. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_CORE_VARIABLECOMPARER_H
13#define ARCANE_CORE_VARIABLECOMPARER_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17#include "arcane/utils/TraceAccessor.h"
18
20
21/*---------------------------------------------------------------------------*/
22/*---------------------------------------------------------------------------*/
23
24namespace Arcane
25{
26
27/*---------------------------------------------------------------------------*/
28/*---------------------------------------------------------------------------*/
29
30//! Méthode de comparaison à utiliser
32{
33 //! Compare avec une référence
34 Same = 0,
35 //! Vérifie que la variable est bien synchronisée
36 Sync = 1,
37 //! Vérifie que les valeurs de la variable sont les même sur tous les replica
39};
40
41//! Méthode utilisée pour calculer la différence entre deux valeurs \a v1 et \a v2.
43{
44 //! Utilise (v1-v2) / v1
46 /*!
47 * \brief Utilise (v1-v2) / local_norm_max.
48 *
49 * \a local_norm_max est le maximum des math::abs() des valeurs sur le sous-domaine.
50 */
52};
53
54/*---------------------------------------------------------------------------*/
55/*---------------------------------------------------------------------------*/
56/*!
57 * \brief Arguments des méthodes de VariableComparer.
58 */
59class ARCANE_CORE_EXPORT VariableComparerArgs
60{
61 public:
62
63 /*!
64 * \brief Positionne le nombre d'erreurs à afficher dans le listing.
65 *
66 * Si 0, aucun élément n'est affiché. Si positif, affiche au plus
67 * \a v élément. Si négatif, tous les éléments sont affichés.
68 */
69 void setMaxPrint(Int32 v) { m_max_print = v; }
70 Int32 maxPrint() const { return m_max_print; }
71
72 /*!
73 * \brief Indique sur quelles entités on fait la comparaison.
74 *
75 * Si \a v si vrai, compare les valeurs à la fois sur les entités
76 * propres et les entités fantômes. Sinon, ne fait la comparaison que sur les
77 * entités propres.
78 *
79 * Ce paramètre n'est utilisé que si compareMode() vaut eCompareMode::Same.
80 */
81 void setCompareGhost(bool v) { m_is_compare_ghost = v; }
82 bool isCompareGhost() const { return m_is_compare_ghost; }
83
84 void setDataReader(IDataReader* v) { m_data_reader = v; }
85 IDataReader* dataReader() const { return m_data_reader; }
86
87 void setCompareMode(eVariableComparerCompareMode v) { m_compare_mode = v; }
88 eVariableComparerCompareMode compareMode() const { return m_compare_mode; }
89
90 void setComputeDifferenceMethod(eVariableComparerComputeDifferenceMethod v) { m_compute_difference_method = v; }
91 eVariableComparerComputeDifferenceMethod computeDifferenceMethod() const { return m_compute_difference_method; }
92
93 private:
94
95 Int32 m_max_print = 0;
96 bool m_is_compare_ghost = false;
97 IDataReader* m_data_reader = nullptr;
98 eVariableComparerCompareMode m_compare_mode = eVariableComparerCompareMode::Same;
99 eVariableComparerComputeDifferenceMethod m_compute_difference_method = eVariableComparerComputeDifferenceMethod::Relative;
100};
101
102/*---------------------------------------------------------------------------*/
103/*---------------------------------------------------------------------------*/
104/*!
105 * \brief Résultats d'une opération de comparaison.
106 */
107class ARCANE_CORE_EXPORT VariableComparerResults
108{
109 public:
110
111 VariableComparerResults() = default;
112 explicit VariableComparerResults(Int32 nb_diff)
113 : m_nb_diff(nb_diff)
114 {}
115
116 public:
117
118 void setNbDifference(Int32 v) { m_nb_diff = v; }
119 Int32 nbDifference() const { return m_nb_diff; }
120
121 public:
122
123 Int32 m_nb_diff = 0;
124};
125
126/*---------------------------------------------------------------------------*/
127/*---------------------------------------------------------------------------*/
128/*!
129 * \brief Classe pour effectuer des comparaisons entre les variables.
130 *
131 * Pour utiliser cette classe, il faut créer une instance de
132 * VariableComparerArgs via une des méthodes suivantes:
133 *
134 * - buildForCheckIfSame()
135 * - buildForCheckIfSync()
136 * - buildForCcheckIfSameOnAllReplica()
137 *
138 * Il faut ensuite appeler la méthode apply() avec l'instance créée pour
139 * chaque variable pour laquelle on souhaite faire la comparaison.
140 */
141class ARCANE_CORE_EXPORT VariableComparer
142{
143 public:
144
145 VariableComparer() = default;
146
147 public:
148
149 /*!
150 * \brief Créé une comparaison pour vérifie qu'une variable est
151 * bien synchronisée.
152 *
153 * Cette opération ne fonctionne que pour les variables de maillage.
154 *
155 * Un variable est synchronisée lorsque ses valeurs sont les mêmes
156 * sur tous les sous-domaines à la fois sur les éléments propres et
157 * les éléments fantômes.
158 *
159 * Il est possible d'appeler sur l'instance retournée les méthodes
160 * VariableComparerArgs::setMaxPrint(),
161 * VariableComparerArgs::setCompareGhost()
162 * ou VariableComparerArgs::setComputeDifferenceMethod() pour modifier
163 * le comportement.
164 */
166
167 /*!
168 * \brief Créé une comparaison pour vérifie qu'une variable est identique
169 * sur tous les réplicas.
170 *
171 * Compare les valeurs de la variable avec celle du même sous-domaine
172 * des autres réplicas. Pour chaque élément différent,
173 * un message est affiché.
174 *
175 * L'utilisation de apply() pour les comparaisons de ce type est une
176 * méthode collective sur le replica de la variable passée en argument.
177 * Il ne faut donc l'appeler que si la variable existe sur tous les sous-domaines
178 * sinon cela provoque un blocage.
179 *
180 * Cette comparaison ne fonctionne que pour les variables sur les types numériques.
181 * Dans ce cas, elle renvoie une exception de type NotSupportedException.
182 *
183 * Il est possible d'appeler sur l'instance retournée les méthodes
184 * VariableComparerArgs::setMaxPrint() ou
185 * VariableComparerArgs::setComputeDifferenceMethod() pour modifier le comportement.
186 */
188
189 public:
190
191 /*!
192 * \brief Créé une comparaison pour vérifie qu'une variable est identique
193 * à une valeur de référence.
194 *
195 * Cette opération vérifie que les valeurs de la variable sont identiques
196 * à une valeur de référence qui sera lue à partir du lecteur \a data_reader.
197 *
198 * Il est possible d'appeler sur l'instance retournée les méthodes
199 * VariableComparerArgs::setMaxPrint(),
200 * VariableComparerArgs::setCompareGhost() ou
201 * VariableComparerArgs::setComputeDifferenceMethod() pour modifier le comportement.
202 *
203 * Il est ensuite possible d'appeler la méthode apply() sur l'instance
204 * retournée pour effectuer les comparaisons sur une variable.
205 */
207
208 public:
209
210 //! Applique la comparaison \a compare_args à la variable \a var
212};
213
214/*---------------------------------------------------------------------------*/
215/*---------------------------------------------------------------------------*/
216
217} // namespace Arcane
218
219/*---------------------------------------------------------------------------*/
220/*---------------------------------------------------------------------------*/
221
222#endif
Déclarations des types généraux de Arcane.
Interface de lecture des données d'une variable.
Definition IDataReader.h:41
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.
VariableComparerArgs buildForCheckIfSameOnAllReplica()
Créé une comparaison pour vérifie qu'une variable est identique sur tous les réplicas.
VariableComparerResults apply(IVariable *var, const VariableComparerArgs &compare_args)
Applique la comparaison compare_args à la variable var.
VariableComparerArgs buildForCheckIfSame(IDataReader *data_reader)
Créé une comparaison pour vérifie qu'une variable est identique à une valeur de référence.
VariableComparerArgs buildForCheckIfSync()
Créé une comparaison pour vérifie qu'une variable est bien synchronisée.
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
eVariableComparerComputeDifferenceMethod
Méthode utilisée pour calculer la différence entre deux valeurs v1 et v2.
@ LocalNormMax
Utilise (v1-v2) / local_norm_max.
eVariableComparerCompareMode
Méthode de comparaison à utiliser.
@ SameOnAllReplica
Vérifie que les valeurs de la variable sont les même sur tous les replica.
@ Same
Compare avec une référence.
@ Sync
Vérifie que la variable est bien synchronisée.
std::int32_t Int32
Type entier signé sur 32 bits.