Arcane  v3.16.0.0
Documentation développeur
Tout Classes Espaces de nommage Fichiers Fonctions Variables Définitions de type Énumérations Valeurs énumérées Amis Macros Groupes Pages Concepts
TimeHistoryMngInternal.h
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2024 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
4// See the top-level COPYRIGHT file for details.
5// SPDX-License-Identifier: Apache-2.0
6//-----------------------------------------------------------------------------
7/*---------------------------------------------------------------------------*/
8/* TimeHistoryMngInternal.h (C) 2000-2024 */
9/* */
10/* Classe interne gérant un historique de valeurs. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_IMPL_INTERNAL_TIMEHISTORYMNGINTERNAL_H
13#define ARCANE_IMPL_INTERNAL_TIMEHISTORYMNGINTERNAL_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17#include "arcane/utils/Iostream.h"
18#include "arcane/utils/Iterator.h"
19#include "arcane/utils/ScopedPtr.h"
20#include "arcane/utils/ITraceMng.h"
21#include "arcane/utils/PlatformUtils.h"
22#include "arcane/utils/OStringStream.h"
23
24#include "arcane/core/IIOMng.h"
25#include "arcane/core/CommonVariables.h"
26#include "arcane/core/Directory.h"
27#include "arcane/core/ObserverPool.h"
28#include "arcane/core/IVariableMng.h"
29#include "arcane/core/IParallelMng.h"
30#include "arcane/core/ITimeHistoryCurveWriter2.h"
31#include "arcane/core/ITimeHistoryTransformer.h"
32#include "arcane/core/XmlNode.h"
33#include "arcane/core/XmlNodeList.h"
34#include "arcane/core/IXmlDocumentHolder.h"
35#include "arcane/core/ServiceBuilder.h"
36#include "arcane/core/Properties.h"
37#include "arcane/core/IParallelReplication.h"
38
39#include "arcane/datatype/DataTypeTraits.h"
40
41#include "arcane/core/internal/ITimeHistoryMngInternal.h"
42
43#include <map>
44#include <set>
45
46/*---------------------------------------------------------------------------*/
47/*---------------------------------------------------------------------------*/
48
49namespace Arcane
50{
51
58class TimeHistoryValue
59{
60 public:
61
62 TimeHistoryValue(const TimeHistoryAddValueArgInternal& thpi, eDataType dt, Integer index, Integer sub_size)
63 : m_data_type(dt)
64 , m_index(index)
65 , m_sub_size(sub_size)
66 , m_thpi(thpi)
67 {}
68
69 virtual ~TimeHistoryValue() = default;
70
71 public:
72
80 virtual void fromOldToNewVariables(IVariableMng* vm, IMesh* default_mesh) = 0;
81
83 virtual void dumpValues(ITraceMng* msg,
85 const TimeHistoryCurveWriterInfo& infos) const = 0;
86
94 virtual void arrayToWrite(UniqueArray<Int32>& iterations,
95 UniqueArray<Real>& values,
96 const TimeHistoryCurveWriterInfo& infos) const = 0;
97
107
113 virtual Integer size() const = 0;
114
120 virtual void removeAfterIteration(Integer last_iteration) = 0;
121
123 const String& name() const { return m_thpi.timeHistoryAddValueArg().name(); }
124
126 eDataType dataType() const { return m_data_type; }
127
129 Integer index() const { return m_index; }
130
131 Integer subSize() const { return m_sub_size; }
132
140 const MeshHandle& meshHandle() const { return m_thpi.meshHandle(); }
141
148 bool isLocal() const { return m_thpi.timeHistoryAddValueArg().isLocal(); }
149
155 Integer localProcId() const { return m_thpi.timeHistoryAddValueArg().localProcId(); }
156
157 private:
158
161 Integer m_sub_size;
163};
164
165/*---------------------------------------------------------------------------*/
166/*---------------------------------------------------------------------------*/
178template <typename DataType>
180: public TimeHistoryValue
181{
182 /*
183 * ATTENTION CE QUI EST DECRIT DANS CE COMMENTAIRE N'EST PAS ENCORE OPERATIONNEL
184 * Lorsqu'il y a beaucoup de courbes et que le nombre d'itérations
185 * devient important, le stockage consomme de la mémoire. Pour éviter
186 * cela, il est possible de compresser le tableau des itérations.
187 * Si c'est le cas et que les itérations sont consécutives, on
188 * conserve uniquement la première et la dernière. Dans ce cas,
189 * m_iterations à 3 valeurs: [0] = COMPRESSED_TAG, [1] = première
190 * et [2] = dernière.
191 */
192 public:
193
194 typedef VariableRefArrayT<DataType> ValueList;
195 typedef VariableRefArrayT<Int32> IterationList;
196 static const Integer COMPRESSED_TAG = -15;
197
198 public:
199
201
202 public:
203
214 : TimeHistoryValue(thpi, DataTypeTraitsT<DataType>::type(), index, nb_element)
215 , m_values(VariableBuildInfo(vm, String("TimeHistoryMngValues") + index, VAR_BUILD_FLAGS))
216 , m_iterations(VariableBuildInfo(vm, String("TimeHistoryMngIterations") + index, VAR_BUILD_FLAGS))
217 , m_use_compression(false)
218 , m_shrink_history(shrink)
219 {
220 }
221
231 : TimeHistoryValue(thpi, DataTypeTraitsT<DataType>::type(), index, nb_element)
232 , m_values(VariableBuildInfo(thpi.meshHandle(), String("TimeHistoryMngValues") + index, VAR_BUILD_FLAGS))
233 , m_iterations(VariableBuildInfo(thpi.meshHandle(), String("TimeHistoryMngIterations") + index, VAR_BUILD_FLAGS))
234 , m_use_compression(false)
235 , m_shrink_history(shrink)
236 {
237 }
238
239 public:
240
241 void fromOldToNewVariables(IVariableMng* vm, IMesh* default_mesh) override
242 {
243 IVariable* ptr_old_values = vm->findMeshVariable(default_mesh, String("TimeHistory_Values_") + index());
244 IVariable* ptr_old_iterations = vm->findMeshVariable(default_mesh, String("TimeHistory_Iterations_") + index());
245 if (ptr_old_values == nullptr || ptr_old_iterations == nullptr)
246 ARCANE_FATAL("Unknown old variable");
247
248 ValueList old_values(ptr_old_values);
249 IterationList old_iterations(ptr_old_iterations);
250
251 m_values.resize(old_values.size());
252 m_values.copy(old_values);
253
254 m_iterations.resize(old_iterations.size());
255 m_iterations.copy(old_iterations);
256
257 old_values.resize(0);
258 old_iterations.resize(0);
259 }
260
261 Integer size() const override
262 {
263 return m_iterations.size();
264 }
265
273 {
274 Integer nb_iteration = m_iterations.size();
275 Integer nb_value = m_values.size();
276 Integer sub_size = values.size();
277 if (nb_iteration != 0)
278 if (m_iterations[nb_iteration - 1] == iteration) {
279 // Remplace la valeur
280 for (Integer i = 0; i < sub_size; ++i)
281 m_values[nb_value - sub_size + i] = values[i];
282 return;
283 }
284 Integer add_nb_iter = math::max(128, nb_iteration / 20);
285 Integer add_nb_value = math::max(1024, nb_value / 20);
286 m_iterations.resizeWithReserve(nb_iteration + 1, add_nb_iter);
287 m_values.resizeWithReserve(nb_value + sub_size, add_nb_value);
288 m_iterations[nb_iteration] = iteration;
289 for (Integer i = 0; i < sub_size; ++i)
290 m_values[nb_value + i] = values[i];
291 }
292
293 void removeAfterIteration(Integer last_iteration) override
294 {
295 Integer size = m_iterations.size();
296 Integer last_elem = size;
297 for (Integer i = 0; i < size; ++i)
298 if (m_iterations[i] >= last_iteration) {
299 last_elem = i;
300 break;
301 }
302 if (last_elem != size) {
303 m_iterations.resize(last_elem);
304 m_values.resize(last_elem * subSize());
305 }
306 }
307
308 // Ecriture d'une courbe pour les écrivains version 2.
311 const TimeHistoryCurveWriterInfo& infos) const override
312 {
313 ARCANE_UNUSED(msg);
314
315 // Pour l'instant, on ne fait rien
316 if (m_shrink_history)
317 return;
318
319 UniqueArray<Real> values_to_write;
320 UniqueArray<Int32> iterations_to_write;
321
322 arrayToWrite(iterations_to_write, values_to_write, infos);
323
324 Integer sd = localProcId();
325 if (!meshHandle().isNull()) {
326 TimeHistoryCurveInfo curve_info(name(), meshHandle().meshName(), iterations_to_write, values_to_write, subSize(), sd);
327 writer->writeCurve(curve_info);
328 }
329 else {
330 TimeHistoryCurveInfo curve_info(name(), iterations_to_write, values_to_write, subSize(), sd);
331 writer->writeCurve(curve_info);
332 }
333 }
334
336 {
338 ci.name = name();
339 SharedArray<Int32> iterations(m_iterations.asArray());
340 ci.iterations = iterations;
341 Integer sub_size = subSize();
342 ci.sub_size = subSize();
343
344 SharedArray<DataType> values(m_values.asArray());
345
346 v->transform(ci, values);
347
348 Integer nb_iteration = iterations.size();
349 Integer nb_value = values.size();
350 if (nb_iteration * sub_size != nb_value) {
351 msg->warning() << "Bad size after history transformation";
352 return;
353 }
354
355 m_iterations.resize(nb_iteration);
356 for (Integer i = 0; i < nb_iteration; ++i)
357 m_iterations[i] = iterations[i];
358
359 m_values.resize(nb_value);
360 for (Integer i = 0; i < nb_value; ++i)
361 m_values[i] = values[i];
362 }
363
364 void arrayToWrite(UniqueArray<Int32>& iterations, UniqueArray<Real>& values, const TimeHistoryCurveWriterInfo& infos) const override
365 {
366 // Pour vérifier qu'on ne sauve pas plus d'itérations qu'il y en
367 // a actuellement (ce qui peut arriver en cas de retour arrière).
368 Integer max_iter = infos.times().size();
369 Integer nb_iteration = m_iterations.size();
370 Integer sub_size = subSize();
371 iterations.clear();
372 iterations.reserve(nb_iteration);
373 values.clear();
374 values.reserve(nb_iteration * sub_size);
375 for (Integer i = 0, is = nb_iteration; i < is; ++i) {
376 Integer iter = m_iterations[i];
377 if (iter < max_iter) {
378 for (Integer z = 0; z < sub_size; ++z) {
379 values.add(Convert::toReal(m_values[(i * sub_size) + z]));
380 }
381 iterations.add(iter);
382 }
383 }
384 }
385
386 const ValueList& values() const { return m_values; }
387 const IterationList& iterations() const { return m_iterations; }
388
389 private:
390
391 ValueList m_values;
392 IterationList m_iterations;
393 bool m_use_compression;
394 bool m_shrink_history;
395};
396
397/*---------------------------------------------------------------------------*/
398/*---------------------------------------------------------------------------*/
399
400class TimeHistoryMngInternal
402{
403 public:
404
405 explicit TimeHistoryMngInternal(IVariableMng* vm, const Ref<Properties>& properties)
406 : m_variable_mng(vm)
407 , m_trace_mng(m_variable_mng->traceMng())
408 , m_parallel_mng(m_variable_mng->parallelMng())
409 , m_common_variables(m_variable_mng)
410 , m_is_active(true)
411 , m_is_shrink_active(false)
412 , m_is_dump_active(true)
414 , m_th_meta_data(VariableBuildInfo(m_variable_mng, "TimeHistoryMngMetaData"))
415 , m_th_global_time(VariableBuildInfo(m_variable_mng, "TimeHistoryMngGlobalTime"))
416 , m_properties(properties)
417 , m_version(2)
418 {
419 m_enable_non_io_master_curves = !platform::getEnvironmentVariable("ARCANE_ENABLE_NON_IO_MASTER_CURVES").null();
420
421 // Seul le sous-domaine maître des IO rend actif les time history.
422 IParallelReplication* pr = m_parallel_mng->replication();
423 m_is_master_io = (pr->hasReplication()) ? pr->isMasterRank() : m_parallel_mng->isMasterIO();
424 }
425
426 ~TimeHistoryMngInternal() override
427 {
429
430 m_curve_writers2.clear();
431 m_history_list.clear();
432 }
433
434 typedef std::map<String, TimeHistoryValue*> HistoryList;
435 typedef std::set<Ref<ITimeHistoryCurveWriter2>> CurveWriter2List;
436 typedef HistoryList::value_type HistoryValueType;
437
438 public:
439
440 void addValue(const TimeHistoryAddValueArgInternal& thpi, Real value) override
441 {
442 RealConstArrayView values(1, &value);
443 _addHistoryValue(thpi, values);
444 }
445 void addValue(const TimeHistoryAddValueArgInternal& thpi, Int64 value) override
446 {
447 Int64ConstArrayView values(1, &value);
448 _addHistoryValue(thpi, values);
449 }
450 void addValue(const TimeHistoryAddValueArgInternal& thpi, Int32 value) override
451 {
452 Int32ConstArrayView values(1, &value);
453 _addHistoryValue(thpi, values);
454 }
456 {
457 _addHistoryValue(thpi, values);
458 }
460 {
461 _addHistoryValue(thpi, values);
462 }
464 {
465 _addHistoryValue(thpi, values);
466 }
467
468 public:
469
470 void addNowInGlobalTime() override;
471 void updateGlobalTimeCurve() override;
472 void resizeArrayAfterRestore() override;
473 void dumpCurves(ITimeHistoryCurveWriter2* writer) override;
474 void dumpHistory() override;
475 void updateMetaData() override;
476 void readVariables(IMeshMng* mesh_mng, IMesh* default_mesh) override;
477
478 void addCurveWriter(Ref<ITimeHistoryCurveWriter2> writer) override;
479 void removeCurveWriter(const String& name) override;
481
482 void addObservers(IPropertyMng* prop_mng) override;
483 void editOutputPath(const Directory& directory) override;
484 void iterationsAndValues(const TimeHistoryAddValueArgInternal& thpi, UniqueArray<Int32>& iterations, UniqueArray<Real>& values) override;
485
486 public:
487
488 bool isShrinkActive() const override { return m_is_shrink_active; }
489 void setShrinkActive(bool is_active) override { m_is_shrink_active = is_active; }
490 bool active() const override { return m_is_active; }
491 void setActive(bool is_active) override { m_is_active = is_active; }
492 bool isDumpActive() const override { return m_is_dump_active; }
493 void setDumpActive(bool is_active) override { m_is_dump_active = is_active; }
494 bool isMasterIO() override { return m_is_master_io; }
496 bool isIOMasterWriteOnly() override { return m_io_master_write_only; }
497 void setIOMasterWriteOnly(bool is_active) override { m_io_master_write_only = is_active; }
498
499 private:
500
508 template <class DataType>
510
514 void _destroyAll();
515
520
526
533
539 void _fromLegacyFormat(IMesh* default_mesh);
540
544 void _saveProperties();
545
551
552 private:
553
554 IVariableMng* m_variable_mng;
555 ITraceMng* m_trace_mng;
556 IParallelMng* m_parallel_mng;
557 CommonVariables m_common_variables;
558 Directory m_directory;
559
566
567 String m_output_path;
568 ObserverPool m_observer_pool;
569 HistoryList m_history_list;
573 CurveWriter2List m_curve_writers2;
574 Ref<Properties> m_properties;
575 Integer m_version;
576};
577
578/*---------------------------------------------------------------------------*/
579/*---------------------------------------------------------------------------*/
580
581} // End namespace Arcane
582
583/*---------------------------------------------------------------------------*/
584/*---------------------------------------------------------------------------*/
585
586#endif
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
constexpr Integer size() const noexcept
Retourne la taille du tableau.
Variables communes d'un cas.
Vue constante d'un tableau de type T.
constexpr Integer size() const noexcept
Nombre d'éléments du tableau.
Classe gérant un répertoire.
Definition Directory.h:33
Interface du gestionnaire des maillages.
Definition IMeshMng.h:40
Interface du gestionnaire de parallélisme pour un sous-domaine.
Informations sur la réplication des sous-domaines en parallèle.
virtual bool hasReplication() const =0
Indique si la réplication est active.
virtual bool isMasterRank() const =0
Indique si ce rang de réplication est le maître.
Interface du gestionnaire des propriétés.
Interface d'un écrivain d'une courbe.
virtual void writeCurve(const TimeHistoryCurveInfo &infos)=0
Ecrit une courbe.
Interface de la partie interne d'un gestionnaire d'historique de valeur.
Integer sub_size
Nombre de valeurs par courbe.
Int32SharedArray iterations
Liste des itérations.
Interface d'un objet transformant les courbes d'historiques.
virtual void transform(CommonInfo &infos, RealSharedArray values)=0
Applique la transformation pour une courbe avec des valeurs Real.
Interface du gestionnaire de traces.
virtual TraceMessage warning()=0
Flot pour un message d'avertissement.
Interface du gestionnaire de variables.
virtual IVariable * findMeshVariable(IMesh *mesh, const String &name)=0
Retourne la variable du maillage de nom name ou 0 si aucune de se nom existe.
Interface d'une variable.
Definition IVariable.h:56
@ PNoReplicaSync
Indique que la variable n'a pas forcément la même valeur entre les réplicas.
Definition IVariable.h:161
@ PExecutionDepend
Indique que la valeur de la variable est dépendante de l'exécution.
Definition IVariable.h:108
@ PNoRestore
Indique que la variable ne doit pas être restaurée.
Definition IVariable.h:135
Handle sur un maillage.
Definition MeshHandle.h:47
Liste d'observateurs.
Référence à une instance.
Vecteur 1D de données avec sémantique par référence.
Chaîne de caractères unicode.
bool null() const
Retourne true si la chaîne est nulle.
Definition String.cc:304
Classe étendant les arguments lors d'un ajout de valeur dans un historique de valeur.
Informations pour l'écriture d'une courbe.
Informations sur l'écriture des courbes.
RealConstArrayView times() const
Liste des temps.
void setIOMasterWriteOnly(bool is_active) override
Méthode permettant de définir si seul le processus maitre appelle les écrivains.
bool isShrinkActive() const override
Retourne un booléen indiquant si l'historique est compressé
void updateMetaData() override
Méthode permettant de mettre à jour les méta-données des courbes.
bool m_is_master_io
True si je suis le gestionnaire actif.
bool m_is_shrink_active
Indique si la compression de l'historique est active.
void addNowInGlobalTime() override
Méthode permettant d'ajouter le GlobalTime actuel au tableau des GlobalTimes.
bool isMasterIO() override
Méthode permettant de savoir si notre processus est l'écrivain.
void addValue(const TimeHistoryAddValueArgInternal &thpi, Real value) override
Méthode permettant d'ajouter une valeur à un historique.
void _dumpSummaryOfCurves()
Méthode permettant de sortir un fichier JSON avec le nom de chaque courbe sortie en format GNUPLOT ai...
void addValue(const TimeHistoryAddValueArgInternal &thpi, Int32 value) override
Méthode permettant d'ajouter une valeur à un historique.
void _removeCurveWriter(const Ref< ITimeHistoryCurveWriter2 > &writer)
Méthode permettant de retirer un écrivain.
void updateGlobalTimeCurve() override
Méthode permettant de copier le tableau de GlobalTime dans la variable globale GlobalTime.
void resizeArrayAfterRestore() override
Méthode permettant de redimensionner les tableaux de valeurs après une reprise.
void addObservers(IPropertyMng *prop_mng) override
Méthode permettant de rajouter les observers sauvegardant l'historique avant une protection.
bool isDumpActive() const override
Indique l'état d'activation des sorties.
bool m_is_dump_active
Indique si les dump sont actifs.
void removeCurveWriter(const String &name) override
Méthode permettant de retirer un écrivain.
void readVariables(IMeshMng *mesh_mng, IMesh *default_mesh) override
Méthode permettant de récupérer les courbes précédemment écrites lors d'une reprise.
void setDumpActive(bool is_active) override
Positionne l'état d'activation des sorties.
void addValue(const TimeHistoryAddValueArgInternal &thpi, Int32ConstArrayView values) override
Méthode permettant d'ajouter des valeurs à un historique.
void dumpHistory() override
Méthode permettant d'écrire toutes les courbes à l'aide de tous les writers enregistrés.
void _dumpSummaryOfCurvesLegacy()
Méthode permettant de sortir un fichier XML avec le nom de chaque courbe sortie en format GNUPLOT.
void addValue(const TimeHistoryAddValueArgInternal &thpi, Int64ConstArrayView values) override
Méthode permettant d'ajouter des valeurs à un historique.
HistoryList m_history_list
Liste des historiques.
void _addHistoryValue(const TimeHistoryAddValueArgInternal &thpi, ConstArrayView< DataType > values)
Méthode permettant d'ajouter des valeurs à un historique de valeurs.
VariableArrayReal m_th_global_time
Tableau des instants de temps.
bool isNonIOMasterCurvesEnabled() override
Méthode permettant de savoir si tous les processus peuvent avoir un historique de valeurs.
bool m_enable_non_io_master_curves
Indique si l'ecriture de courbes par des procs non io_master est possible.
void _dumpCurvesAllWriters()
Méthode permettant de sortir toutes les courbes avec tous les writers.
void setActive(bool is_active) override
Positionne l'état d'activation.
void applyTransformation(ITimeHistoryTransformer *v) override
Applique la transformation v à l'ensemble des courbes.
void iterationsAndValues(const TimeHistoryAddValueArgInternal &thpi, UniqueArray< Int32 > &iterations, UniqueArray< Real > &values) override
Méthode permettant de sortir les itérations et les valeurs d'un historique.
void dumpCurves(ITimeHistoryCurveWriter2 *writer) override
Méthode permettant d"écrire les courbes à l'aide du writer fourni.
bool m_io_master_write_only
Indique si les writers doivent être appelé par tous les processus.
bool isIOMasterWriteOnly() override
Méthode permettant de savoir s'il n'y a que le processus maitre qui appelle les écrivains.
bool active() const override
Indique l'état d'activation.
void addValue(const TimeHistoryAddValueArgInternal &thpi, RealConstArrayView values) override
Méthode permettant d'ajouter des valeurs à un historique.
void _saveProperties()
Méthode permettant de sauver les propriétés des metadatas.
void addValue(const TimeHistoryAddValueArgInternal &thpi, Int64 value) override
Méthode permettant d'ajouter une valeur à un historique.
void setShrinkActive(bool is_active) override
Positionne le booléen indiquant si l'historique est compressé
VariableScalarString m_th_meta_data
Infos des historiques.
void _fromLegacyFormat(IMesh *default_mesh)
Méthode permettant de convertir l'ancien format vers le nouveau.
void editOutputPath(const Directory &directory) override
Méthode permettant de changer le répertoire de sortie des courbes.
RealUniqueArray m_global_times
Liste des temps globaux.
bool m_is_active
Indique si le service est actif.
void addCurveWriter(Ref< ITimeHistoryCurveWriter2 > writer) override
Méthode permettant d'ajouter un écrivain pour la sortie des courbes.
TimeHistoryValueT(const TimeHistoryAddValueArgInternal &thpi, Integer index, Integer nb_element, bool shrink)
Constructeur permettant de construire un historique de valeur lié à un maillage.
void applyTransformation(ITraceMng *msg, ITimeHistoryTransformer *v) override
Méthode permettant d'appliquer une transformation sur les valeurs de l'historique de valeur.
Integer size() const override
Méthode permettant de récupérer le nombre de valeurs enregistrées.
void dumpValues(ITraceMng *msg, ITimeHistoryCurveWriter2 *writer, const TimeHistoryCurveWriterInfo &infos) const override
Imprime les valeurs de l'historique avec l'écrivain writer.
void addValue(ConstArrayView< DataType > values, Integer iteration)
Méthode permettant d'ajouter des valeurs à une itération.
void removeAfterIteration(Integer last_iteration) override
Méthode permettant de retirer toutes les valeurs après une certaine itération.
void arrayToWrite(UniqueArray< Int32 > &iterations, UniqueArray< Real > &values, const TimeHistoryCurveWriterInfo &infos) const override
Méthode permettant de récupérer les itérations et les valeurs d'un historique de valeur.
TimeHistoryValueT(IVariableMng *vm, const TimeHistoryAddValueArgInternal &thpi, Integer index, Integer nb_element, bool shrink)
Constructeur permettant de construire un historique de valeur non lié à un maillage.
void fromOldToNewVariables(IVariableMng *vm, IMesh *default_mesh) override
Méthode permettant de convertir les variables d'anciennes sauvegardes vers le nouveau format.
Integer index() const
Index de l'historique dans la liste.
virtual Integer size() const =0
Méthode permettant de récupérer le nombre de valeurs enregistrées.
const MeshHandle & meshHandle() const
Méthode permettant de récupérer le MeshHandle enregistré.
virtual void removeAfterIteration(Integer last_iteration)=0
Méthode permettant de retirer toutes les valeurs après une certaine itération.
const String & name() const
Nom de l'historique.
eDataType dataType() const
Type de données de l'historique.
virtual void applyTransformation(ITraceMng *msg, ITimeHistoryTransformer *v)=0
Méthode permettant d'appliquer une transformation sur les valeurs de l'historique de valeur.
Integer m_index
Index de l'historique dans la liste.
virtual void fromOldToNewVariables(IVariableMng *vm, IMesh *default_mesh)=0
Méthode permettant de convertir les variables d'anciennes sauvegardes vers le nouveau format.
virtual ~TimeHistoryValue()=default
Libére les ressources.
Integer localProcId() const
Méthode permettant de récupérer l'id du sous-domaine à qui appartient cet historique.
virtual void arrayToWrite(UniqueArray< Int32 > &iterations, UniqueArray< Real > &values, const TimeHistoryCurveWriterInfo &infos) const =0
Méthode permettant de récupérer les itérations et les valeurs d'un historique de valeur.
bool isLocal() const
Méthode permettant de savoir si c'est un historique global ou local à un sous-domaine.
eDataType m_data_type
Type de la donnée.
virtual void dumpValues(ITraceMng *msg, ITimeHistoryCurveWriter2 *writer, const TimeHistoryCurveWriterInfo &infos) const =0
Imprime les valeurs de l'historique avec l'écrivain writer.
Vecteur 1D de données avec sémantique par valeur (style STL).
Paramètres nécessaires à la construction d'une variable.
virtual void resize(Integer new_size)
Redimensionne le tableau pour contenir new_size éléments.
T max(const T &a, const T &b, const T &c)
Retourne le maximum de trois éléments.
Definition MathUtils.h:392
VariableRefArrayT< Real > VariableArrayReal
Variable tableau de type réels.
VariableRefScalarT< String > VariableScalarString
Variable scalaire de type chaine de caractère.
Real toReal(Real r)
Converti r en un Real.
Definition Convert.h:80
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 -*-
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
ConstArrayView< Int64 > Int64ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 64 bits.
Definition UtilsTypes.h:567
Integer arcaneCallFunctionAndCatchException(std::function< void()> function)
UniqueArray< Real > RealUniqueArray
Tableau dynamique à une dimension de réels.
Definition UtilsTypes.h:436
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.
ConstArrayView< Real > RealConstArrayView
Equivalent C d'un tableau à une dimension de réels.
Definition UtilsTypes.h:575