Arcane  v3.16.0.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
SimpleCsvComparatorService.cc
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2022 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/* SimpleCsvComparatorService.cc (C) 2000-2022 */
9/* */
10/* Service permettant de comparer un ISimpleTableOutput avec un fichier de */
11/* référence en format csv. */
12/*---------------------------------------------------------------------------*/
13/*---------------------------------------------------------------------------*/
14
15#include "arcane/std/SimpleCsvComparatorService.h"
16
17#include "arcane/Directory.h"
18#include "arcane/IMesh.h"
19#include "arcane/IParallelMng.h"
20#include "arcane/utils/Iostream.h"
21
22#include <optional>
23#include <regex>
24#include <string>
25
26/*---------------------------------------------------------------------------*/
27/*---------------------------------------------------------------------------*/
28
29namespace Arcane
30{
31
32/*---------------------------------------------------------------------------*/
33/*---------------------------------------------------------------------------*/
34
36init(ISimpleTableOutput* simple_table_output_ptr)
37{
38 // On enregistre le pointeur qui nous est donné.
39 ARCANE_CHECK_PTR(simple_table_output_ptr);
40 m_simple_table_output_ptr = simple_table_output_ptr;
41
42 if (!m_is_already_init) {
43 m_is_already_init = true;
44
45 m_simple_table_internal_reference = makeRef(new SimpleTableInternal(mesh()->parallelMng()));
46
47 m_simple_table_internal_comparator.setInternalRef(m_simple_table_internal_reference);
48 m_simple_csv_reader_writer.setInternal(m_simple_table_internal_reference);
49 }
50
51 m_simple_table_internal_to_compare = m_simple_table_output_ptr->internal();
52 m_simple_table_internal_comparator.setInternalToCompare(m_simple_table_internal_to_compare);
53
54 // On déduit l'emplacement des fichiers de réferences.
55 m_output_directory = m_simple_table_output_ptr->outputDirectory();
56 m_root_path = Directory(subDomain()->exportDirectory(), m_simple_table_output_ptr->fileType() + "_refs");
57 m_reference_path = Directory(m_root_path, m_output_directory);
58 m_table_name = m_simple_table_output_ptr->tableName();
59 m_file_name = m_table_name + "." + m_simple_table_output_ptr->fileType();
60}
61
62/*---------------------------------------------------------------------------*/
63/*---------------------------------------------------------------------------*/
64
66clear()
67{
68 m_simple_table_internal_comparator.clearComparator();
69 m_is_file_read = false;
70
71 if (m_is_already_init) {
72 m_simple_table_internal_reference->clear();
73 }
74}
75
76/*---------------------------------------------------------------------------*/
77/*---------------------------------------------------------------------------*/
78
80editRootDirectory(const Directory& root_directory)
81{
82 m_root_path = root_directory;
83 m_reference_path = Directory(m_root_path, m_output_directory);
84}
85
86/*---------------------------------------------------------------------------*/
87/*---------------------------------------------------------------------------*/
88
90print(Integer rank)
91{
92 if (rank != -1 && subDomain()->parallelMng()->commRank() != rank)
93 return;
94 m_simple_csv_reader_writer.print();
95}
96
97/*---------------------------------------------------------------------------*/
98/*---------------------------------------------------------------------------*/
104{
105 ARCANE_CHECK_PTR(m_simple_table_output_ptr);
106 // On sauvegarde les paramètres d'origines.
107 Integer save_preci = m_simple_table_output_ptr->precision();
108 bool save_scientific = m_simple_table_output_ptr->isForcedToUseScientificNotation();
109 bool save_fixed = m_simple_table_output_ptr->isFixed();
110
111 // On défini la précision max (+2 pour erreurs d'arrondis).
112 m_simple_table_output_ptr->setPrecision(std::numeric_limits<Real>::max_digits10);
113 m_simple_table_output_ptr->setForcedToUseScientificNotation(true);
114 m_simple_table_output_ptr->setFixed(false);
115
116 // On écrit nos fichiers de référence.
117 bool fin = m_simple_table_output_ptr->writeFile(m_root_path, rank);
118
119 // On remet les paramètres par défault.
120 m_simple_table_output_ptr->setPrecision(save_preci);
121 m_simple_table_output_ptr->setForcedToUseScientificNotation(save_scientific);
122 m_simple_table_output_ptr->setFixed(save_fixed);
123
124 return fin;
125}
126
127/*---------------------------------------------------------------------------*/
128/*---------------------------------------------------------------------------*/
129
132{
133 if (rank != -1 && subDomain()->parallelMng()->commRank() != rank)
134 return true;
135
136 m_is_file_read = m_simple_csv_reader_writer.readTable(m_reference_path, m_table_name);
137
138 return m_is_file_read;
139}
140
141/*---------------------------------------------------------------------------*/
142/*---------------------------------------------------------------------------*/
143
146{
147 if (rank != -1 && subDomain()->parallelMng()->commRank() != rank)
148 return true;
149
150 return SimpleTableReaderWriterUtils::isFileExist(m_reference_path, m_file_name);
151}
152
153/*---------------------------------------------------------------------------*/
154/*---------------------------------------------------------------------------*/
155
157compareWithReference(Integer rank, bool compare_dimension_too)
158{
159 // Si le proc appelant ne doit pas lire.
160 if (rank != -1 && subDomain()->parallelMng()->commRank() != rank) {
161 return true;
162 }
163 // Si le fichier ne peut pas être lu.
164 if (!m_is_file_read && !readReferenceFile(rank)) {
165 error() << "Error with the file reader: invalid file";
166 return false;
167 }
168
169 return m_simple_table_internal_comparator.compare(compare_dimension_too);
170}
171
172/*---------------------------------------------------------------------------*/
173/*---------------------------------------------------------------------------*/
174
176compareElemWithReference(const String& column_name, const String& row_name, Integer rank)
177{
178 // Si le proc appelant ne doit pas lire.
179 if (rank != -1 && subDomain()->parallelMng()->commRank() != rank) {
180 return true;
181 }
182 // Si le fichier ne peut pas être lu.
183 if (!m_is_file_read && !readReferenceFile(rank)) {
184 error() << "Error with the file reader: invalid file";
185 return false;
186 }
187
188 return m_simple_table_internal_comparator.compareElem(column_name, row_name);
189}
190
191/*---------------------------------------------------------------------------*/
192/*---------------------------------------------------------------------------*/
193
195compareElemWithReference(Real elem, const String& column_name, const String& row_name, Integer rank)
196{
197 // Si le proc appelant ne doit pas lire.
198 if (rank != -1 && subDomain()->parallelMng()->commRank() != rank) {
199 return true;
200 }
201 // Si le fichier ne peut pas être lu.
202 if (!m_is_file_read && !readReferenceFile(rank)) {
203 error() << "Error with the file reader: invalid file";
204 return false;
205 }
206
207 return m_simple_table_internal_comparator.compareElem(elem, column_name, row_name);
208}
209
210/*---------------------------------------------------------------------------*/
211/*---------------------------------------------------------------------------*/
212
214addColumnForComparing(const String& column_name)
215{
216 return m_simple_table_internal_comparator.addColumnForComparing(column_name);
217}
218
219/*---------------------------------------------------------------------------*/
220/*---------------------------------------------------------------------------*/
221
223addRowForComparing(const String& row_name)
224{
225 return m_simple_table_internal_comparator.addRowForComparing(row_name);
226}
227
228/*---------------------------------------------------------------------------*/
229/*---------------------------------------------------------------------------*/
230
232isAnArrayExclusiveColumns(bool is_exclusive)
233{
234 m_simple_table_internal_comparator.isAnArrayExclusiveColumns(is_exclusive);
235}
236
237/*---------------------------------------------------------------------------*/
238/*---------------------------------------------------------------------------*/
239
241isAnArrayExclusiveRows(bool is_exclusive)
242{
243 m_simple_table_internal_comparator.isAnArrayExclusiveRows(is_exclusive);
244}
245
246/*---------------------------------------------------------------------------*/
247/*---------------------------------------------------------------------------*/
248
250editRegexColumns(const String& regex_column)
251{
252 m_simple_table_internal_comparator.editRegexColumns(regex_column);
253}
254
255/*---------------------------------------------------------------------------*/
256/*---------------------------------------------------------------------------*/
257
259editRegexRows(const String& regex_row)
260{
261 m_simple_table_internal_comparator.editRegexRows(regex_row);
262}
263
264/*---------------------------------------------------------------------------*/
265/*---------------------------------------------------------------------------*/
266
268isARegexExclusiveColumns(bool is_exclusive)
269{
270 m_simple_table_internal_comparator.isARegexExclusiveColumns(is_exclusive);
271}
272
273/*---------------------------------------------------------------------------*/
274/*---------------------------------------------------------------------------*/
275
277isARegexExclusiveRows(bool is_exclusive)
278{
279 m_simple_table_internal_comparator.isARegexExclusiveRows(is_exclusive);
280}
281
282/*---------------------------------------------------------------------------*/
283/*---------------------------------------------------------------------------*/
284
286addEpsilonColumn(const String& column_name, Real epsilon)
287{
288 return m_simple_table_internal_comparator.addEpsilonColumn(column_name, epsilon);
289}
290
291/*---------------------------------------------------------------------------*/
292/*---------------------------------------------------------------------------*/
293
295addEpsilonRow(const String& row_name, Real epsilon)
296{
297 return m_simple_table_internal_comparator.addEpsilonRow(row_name, epsilon);
298}
299
300/*---------------------------------------------------------------------------*/
301/*---------------------------------------------------------------------------*/
302
303ARCANE_REGISTER_SERVICE_SIMPLECSVCOMPARATOR(SimpleCsvComparator, SimpleCsvComparatorService);
304
305/*---------------------------------------------------------------------------*/
306/*---------------------------------------------------------------------------*/
307
308} // End namespace Arcane
309
310/*---------------------------------------------------------------------------*/
311/*---------------------------------------------------------------------------*/
Classe gérant un répertoire.
Definition Directory.h:33
Interface représentant une sortie de tableau simple.
virtual Ref< SimpleTableInternal > internal()=0
Méthode permettant de récupérer une référence vers l'objet SimpleTableInternal utilisé.
void init(ISimpleTableOutput *simple_table_output_ptr) override
Méthode permettant d'initialiser le service.
bool addColumnForComparing(const String &column_name) override
Méthode permettant d'ajouter une colonne dans la liste des colonnes à comparer.
void editRegexColumns(const String &regex_column) override
Méthode permettant d'ajouter une expression régulière permettant de déterminer les colonnes à compare...
bool addRowForComparing(const String &row_name) override
Méthode permettant d'ajouter une ligne dans la liste des lignes à comparer.
void isAnArrayExclusiveColumns(bool is_exclusive) override
Méthode permettant de définir si le tableau de colonnes représente les colonnes à inclure dans la com...
bool addEpsilonRow(const String &row_name, Real epsilon) override
Méthode permettant de définir un epsilon pour une ligne donnée. Cet epsilon doit être positif pour êt...
void isARegexExclusiveColumns(bool is_exclusive) override
Méthode permettant de demander à ce que l'expression régulière exclut des colonnes au lieu d'en inclu...
void clear() override
Méthode permettant d'effacer les données lues par readReferenceFile().
void print(Integer rank) override
Méthode permettant d'afficher le tableau lu.
bool isReferenceExist(Integer rank) override
Méthode permettant de savoir si les fichiers de réferences existent.
void isAnArrayExclusiveRows(bool is_exclusive) override
Méthode permettant de définir si le tableau de lignes représente les lignes à inclure dans la compara...
bool compareWithReference(Integer rank, bool compare_dimension_too) override
Méthode permettant de comparer l'objet de type ISimpleTableOutput aux fichiers de réferences.
void editRegexRows(const String &regex_row) override
Méthode permettant d'ajouter une expression régulière permettant de déterminer les lignes à comparer.
bool readReferenceFile(Integer rank) override
Méthode permettant de lire les fichiers de références.
bool addEpsilonColumn(const String &column_name, Real epsilon) override
Méthode permettant de définir un epsilon pour une colonne donnée. Cet epsilon doit être positif pour ...
void isARegexExclusiveRows(bool is_exclusive) override
Méthode permettant de demander à ce que l'expression régulière exclut des lignes au lieu d'en inclure...
bool compareElemWithReference(const String &column_name, const String &row_name, Integer rank) override
Méthode permettant de comparer uniquement un élement. Les deux SimpleTableInternal sont représentés p...
void editRootDirectory(const Directory &root_directory) override
Méthode permettant de modifier le répertoire racine. Cela permet d'écrire ou de rechercher des fichie...
static bool isFileExist(const Directory &directory, const String &file)
Méthode statique permettant de vérifier l'existance d'un fichier.
Chaîne de caractères unicode.
TraceMessage error() const
Flot pour un message d'erreur.
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Int32 Integer
Type représentant un entier.
double Real
Type représentant un réel.
auto makeRef(InstanceType *t) -> Ref< InstanceType >
Créé une référence sur un pointeur.
Structure représentant un tableau simple.