Arcane  v3.16.2.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
TimeHistoryMngInternal.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/* TimeHistoryMngInternal.h (C) 2000-2025 */
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 localSubDomainId() const { return m_thpi.timeHistoryAddValueArg().localSubDomainId(); }
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
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_need_comm(false)
415 , m_th_meta_data(VariableBuildInfo(m_variable_mng, "TimeHistoryMngMetaData"))
416 , m_th_global_time(VariableBuildInfo(m_variable_mng, "TimeHistoryMngGlobalTime"))
417 , m_properties(properties)
418 , m_version(2)
419 {
420 // TODO AH : Avec la nouvelle API, cette variable devrait pouvoir être toujours true (grâce à m_need_comm). À garder pour l'IFPEN.
421 m_enable_non_io_master_curves = !platform::getEnvironmentVariable("ARCANE_ENABLE_NON_IO_MASTER_CURVES").null();
422
423 bool enable_all_replicats_write = !platform::getEnvironmentVariable("ARCANE_ENABLE_ALL_REPLICATS_WRITE_CURVES").null();
424
425 // Seul le sous-domaine maître des IO rend actif les time history.
426 IParallelReplication* pr = m_parallel_mng->replication();
427 if (pr->hasReplication()) {
428 m_is_master_io = (pr->isMasterRank() && m_parallel_mng->isMasterIO());
429 m_is_master_io_of_sd = (enable_all_replicats_write || pr->isMasterRank());
430 }
431 else {
432 m_is_master_io = m_parallel_mng->isMasterIO();
434 }
435 }
436
437 ~TimeHistoryMngInternal() override
438 {
440
441 m_curve_writers2.clear();
442 m_history_list.clear();
443 }
444
445 typedef std::map<String, TimeHistoryValue*> HistoryList;
446 typedef std::set<Ref<ITimeHistoryCurveWriter2>> CurveWriter2List;
447 typedef HistoryList::value_type HistoryValueType;
448
449 public:
450
451 void addValue(const TimeHistoryAddValueArgInternal& thpi, Real value) override
452 {
453 RealConstArrayView values(1, &value);
454 _addHistoryValue(thpi, values);
455 }
456 void addValue(const TimeHistoryAddValueArgInternal& thpi, Int64 value) override
457 {
458 Int64ConstArrayView values(1, &value);
459 _addHistoryValue(thpi, values);
460 }
461 void addValue(const TimeHistoryAddValueArgInternal& thpi, Int32 value) override
462 {
463 Int32ConstArrayView values(1, &value);
464 _addHistoryValue(thpi, values);
465 }
467 {
468 _addHistoryValue(thpi, values);
469 }
471 {
472 _addHistoryValue(thpi, values);
473 }
475 {
476 _addHistoryValue(thpi, values);
477 }
478
479 public:
480
481 void addNowInGlobalTime() override;
482 void updateGlobalTimeCurve() override;
483 void resizeArrayAfterRestore() override;
484 void dumpCurves(ITimeHistoryCurveWriter2* writer) override;
485 void dumpHistory() override;
486 void updateMetaData() override;
487 void readVariables(IMeshMng* mesh_mng, IMesh* default_mesh) override;
488
489 void addCurveWriter(Ref<ITimeHistoryCurveWriter2> writer) override;
490 void removeCurveWriter(const String& name) override;
492
493 void addObservers(IPropertyMng* prop_mng) override;
494 void editOutputPath(const Directory& directory) override;
495 void iterationsAndValues(const TimeHistoryAddValueArgInternal& thpi, UniqueArray<Int32>& iterations, UniqueArray<Real>& values) override;
496
497 public:
498
499 bool isShrinkActive() const override { return m_is_shrink_active; }
500 void setShrinkActive(bool is_active) override { m_is_shrink_active = is_active; }
501 bool active() const override { return m_is_active; }
502 void setActive(bool is_active) override { m_is_active = is_active; }
503 bool isDumpActive() const override { return m_is_dump_active; }
504 void setDumpActive(bool is_active) override { m_is_dump_active = is_active; }
505 bool isMasterIO() override { return m_is_master_io; }
506 bool isMasterIOOfSubDomain() override { return m_is_master_io_of_sd; }
508 bool isIOMasterWriteOnly() override { return m_io_master_write_only; }
509 void setIOMasterWriteOnly(bool is_active) override { m_io_master_write_only = is_active; }
510
511 private:
512
520 template <class DataType>
522
526 void _destroyAll();
527
532
538
545
551 void _fromLegacyFormat(IMesh* default_mesh);
552
556 void _saveProperties();
557
563
564 private:
565
566 IVariableMng* m_variable_mng;
567 ITraceMng* m_trace_mng;
568 IParallelMng* m_parallel_mng;
569 CommonVariables m_common_variables;
570 Directory m_directory;
571
580
581 String m_output_path;
582 ObserverPool m_observer_pool;
583 HistoryList m_history_list;
587 CurveWriter2List m_curve_writers2;
588 Ref<Properties> m_properties;
589 Integer m_version;
590};
591
592/*---------------------------------------------------------------------------*/
593/*---------------------------------------------------------------------------*/
594
595} // End namespace Arcane
596
597/*---------------------------------------------------------------------------*/
598/*---------------------------------------------------------------------------*/
599
600#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 des IO.
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.
bool m_is_master_io_of_sd
True si je suis le gestionnaire des IO pour mon sous-domaine.
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 isMasterIOOfSubDomain() override
Méthode permettant de savoir si notre processus est l'écrivain pour notre sous-domaine....
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_need_comm
Indique si au moins une courbe est non local (donc nécessite des communications).
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 localSubDomainId() 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