Arcane  v3.16.8.0
Documentation utilisateur
Chargement...
Recherche...
Aucune correspondance
ITimeLoopMng.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/* ITimeLoopMng.h (C) 2000-2025 */
9/* */
10/* Interface du gestionnaire de la boucle en temps. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_CORE_ITIMELOOPMNG_H
13#define ARCANE_CORE_ITIMELOOPMNG_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
18
19/*---------------------------------------------------------------------------*/
20/*---------------------------------------------------------------------------*/
21
22namespace Arcane
23{
24class IBackwardMng;
25
26/*---------------------------------------------------------------------------*/
27/*---------------------------------------------------------------------------*/
28
29enum class eTimeLoopEventType
30{
31 BeginEntryPoint,
32 EndEntryPoint,
33 BeginIteration,
34 EndIteration
35};
36
37/*---------------------------------------------------------------------------*/
38/*---------------------------------------------------------------------------*/
39/*!
40 * \brief Raison pour laquelle on arrête le code.
41 */
43{
44 //! Indique qu'on n'est pas encore en mode d'arrête du code.
46 //! Pas de raison spécifique
48 //! Arrêt sur une erreur
50 //! Arrêt car temps final atteint
52 //! Arrêt car nombre d'itération maximal spécifié atteint.
54};
55
56/*---------------------------------------------------------------------------*/
57/*---------------------------------------------------------------------------*/
58/*!
59 * \brief Interface du gestionnaire de la boucle en temps.
60 *
61 La boucle en temps est composée de trois parties, exécutées dans l'ordre
62 suivant:
63 \arg l'initialisation (Init)
64 \arg la boucle de calcul (ComputeLoop)
65 \arg la terminaison (Exit)
66
67 L'initialisation et la terminaison ne sont appelés qu'une seule fois.
68 Par contre, la boucle de calcul est exécutée tant que personne ne demande
69 l'arrêt explicite par la méthode stopComputeLoop()
70 */
72{
73 public:
74
75 virtual ~ITimeLoopMng() {} //!< Libère les ressources.
76
77 public:
78
79 virtual void build() =0;
80
81 //virtual void initialize() =0;
82
83 public:
84
85 //!< Retourne le gestionnaire du sous-domaine
86 virtual ISubDomain* subDomain() const =0;
87
88 //! Exécute les points d'entrée de terminaison
89 virtual void execExitEntryPoints() =0;
90
91 //! Exécute les points d'entrée de construction
92 virtual void execBuildEntryPoints() =0;
93
94 /*! \brief Exécute les points d'entrée d'initialisation.
95 * \param is_continue est vrai si on est en reprise */
96 virtual void execInitEntryPoints(bool is_continue) =0;
97
98 //! Exécute les points d'entrée après rééquilibrage
99 //virtual void execLoadBalanceEntryPoints() =0;
100
101 //! Exécute les points d'entrée après rééquilibrage
103
104 //! Exécute les points d'entrée après raffinement
106
107 /*!
108 * \brief Indique que la boucle de calcul doit s'interrompre.
109 *
110 * Si \a is_final_time est vrai, cela indique que le temps final est atteint.
111 * Si \a has_error est vrai, cela indique que le calcul est arrété suite à une
112 * erreur. Dans ce cas, le code de retour de l'application sera différent de 0.
113 */
114 virtual void stopComputeLoop(bool is_final_time,bool has_error=false) =0;
115
116 //! Retourne \a true si le temps final est atteint.
117 virtual bool finalTimeReached() const =0;
118
119 //! Retourne le temps CPU utilisé en secondes.
120 virtual Real cpuTimeUsed() const =0;
121
122 //! Retourne la liste des points d'entrée de type 'ComputeLoop' de la boucle en temps.
124
125 //! Liste de tous les points d'entrée pour la boucle en temps actuelle.
127
128 /*!
129 * Exécute le point d'entrée suivant.
130 *
131 * Retourne dans \a is_last \e true si le point d'entrée qui vient d'être
132 * exécuté est le dernier de l'itération.
133 */
134 virtual void doExecNextEntryPoint(bool& is_last) =0;
135
136 //! Retourne le prochain point d'entrée à exécuter ou 0 s'il n'y en a pas
138
139 //! Retourne le point d'entrée en cours d'exécution ou 0 s'il n'y en a pas
141
142 /*!
143 * \brief Lance l'exécution d'une itération de la boucle de calcul.
144 *
145 * \retval 0 si le code doit continuer.
146 * \retval >0 si le calcul s'arrête normalement.
147 * \retval <0 si le calcul s'arrête suite à une erreur.
148 */
149 virtual int doOneIteration() =0;
150
151 /*!
152 * \brief Exécute la boucle de calcul.
153 *
154 * La boucle de calcul est exécutée jusqu'à l'appel à la méthode
155 * stopComputeLoop() ou que le nombre de boucles effectuées est égal
156 * à \a max_loop si \a max_loop est différent de 0.
157 * \retval 1 si le code s'arrête normalement suite au temps final atteint
158 * \retval 2 si le code s'arrête normalement suite à \a max_loop atteint
159 * \retval <0 si le calcul s'arrête suite à une erreur.
160 */
161 virtual int doComputeLoop(Integer max_loop=0) =0;
162
163 //@{
164 //! Enregistrement et choix de la boucle en temps.
165 /*!
166 * \brief Enregistre une boucle en temps.
167 * Enregistre la boucle en temps \a time_loop.
168 *
169 * Si une boucle en temps de même nom que \a time_loop est déjà référencée,
170 * la nouvelle remplace l'ancienne.
171 */
172 virtual void registerTimeLoop(ITimeLoop* time_loop) =0;
173
174 /*! \brief Positionne la boucle en temps à exécuter.
175 * Sélectionne la boucle en temps de nom \a name comme celle qui sera
176 * exécutée. Cette méthode effectue les opérations suivantes:
177 * <ul>
178 * <li>à partir du nom \a name, recherche la boucle en temps à utiliser.
179 * Cette boucle en temps doit avoir été référencée par l'appel à
180 * registerTimeLoop()</li>
181 * <li>pour chaque nom de point d'entrée de la boucle en temps,
182 * recherche le point d'entrée (IEntryPoint) correspondant enregistré dans
183 * l'architecture</li>
184 * <li>contruit la liste des points d'entrée à appeler lors de
185 * l'initialisation, dans la boucle de calcul et lors de la terminaison
186 * en prenant en compte les points d'entrée qui sont chargés automatiquement.</li>
187 * <li>détermine la liste des modules utilisés en considérant qu'un module
188 * est utilisé si et seulement si l'un de ses points d'entrée est utilisé</li>
189 * </ul>
190 *
191 * L'opération est un échec et provoque une erreur fatal dans l'un
192 * des cas suivants:
193 * \arg cette méthode a déjà été appelée,
194 * \arg aucune boucle en temps de nom \a name n'est enregistrée,
195 * \arg un des noms des points d'entrée de la liste ne correspondant à
196 * aucun point d'entrée référencé.
197 *
198 * Si \a name est nulle, la boucle en temps utilisée est la boucle par
199 * défaut qui ne contient aucune point d'entrée explicite. Elle contient
200 * uniquement les points d'entrée automatiquement enregistrés.
201 *
202 * \retval true en cas d'erreur,
203 * \retval false sinon.
204 */
205 virtual void setUsedTimeLoop(const String& name) =0;
206 //@}
207
208 //! Retourne la boucle en temps utilisée
209 virtual ITimeLoop* usedTimeLoop() const =0;
210
211 virtual void setBackwardMng(IBackwardMng* backward_mng) = 0;
212
213 virtual IBackwardMng * getBackwardMng() const = 0;
214
215 /*!
216 * \brief Effectue un retour arrière.
217 *
218 * Cette méthode positionne juste un marqueur. Le retour arrière a
219 * effectivement lieu lorsque le point d'entrée actuellement en cours
220 * d'exécution se termine.
221 *
222 * Après retour-arrière, les points d'entrée de retour-arrière sont
223 * appelés.
224 *
225 * \warning Lors d'une exécution parallèle, cette méthode doit être
226 * appelée par tous les sous-domaines.
227 */
228 virtual void goBackward() =0;
229
230 /*! \brief Vrai si on est actuellement dans un retour-arrière.
231 *
232 * Un retour arrière est actif tant que le temps physique est inférieur
233 * au temps physique atteint avant le déclechement du retout-arrière.
234 */
235 virtual bool isDoingBackward() =0;
236
237 /*!
238 * \brief Programme un repartitionnement du maillage avec l'outil
239 * de partition \a mesh_partitioner.
240 *
241 * Cette méthode positionne juste un marqueur. Le repartitionnement a
242 * effectivement lieu lorsque le dernier point d'entrée de la boucle
243 * de calcul est terminé (fin d'une itération).
244 *
245 * Après partitionnement, les points d'entrée de changement de maillage sont
246 * appelés.
247 *
248 * \warning Lors d'une exécution parallèle, cette méthode doit être
249 * appelée par tous les sous-domaines.
250 */
251 virtual void registerActionMeshPartition(IMeshPartitionerBase* mesh_partitioner) =0;
252
253 /*!
254 * \brief Positionne la période entre deux sauvegarde pour le retour arrière.
255 * Si cette valeur est nulle, le retour arrière est désactivé.
256 */
257 virtual void setBackwardSavePeriod(Integer n) =0;
258
259 /*!
260 * \brief Positionne l'état du mode de vérification
261 */
262 virtual void setVerificationActive(bool is_active) =0;
263
264 /*!
265 * \brief Effectue une vérification.
266 *
267 * Cette opération est collective.
268 *
269 * Cette opération permet d'effectuer manuellement une opération de
270 * vérification, dont le nom est \a name. Ce nom \a name doit être
271 * unique pour une itération donnée.
272 */
273 virtual void doVerification(const String& name) =0;
274
275 /*!
276 * \brief Retourne dans \a names la liste des noms des boucles en temps.
277 */
278 virtual void timeLoopsName(StringCollection& names) const =0;
279
280 //! Retourne dans \a time_loops la liste des boucles en temps.
281 virtual void timeLoops(TimeLoopCollection& time_loops) const =0;
282
283 //! Crée une boucle en temps de nom \a name.
284 virtual ITimeLoop* createTimeLoop(const String& name) =0;
285
286 //! Nombre de boucles de calcul (ComputeLoop) effectuées.
287 virtual Integer nbLoop() const =0;
288
289 /*!
290 * \brief Observable sur l'instance.
291 *
292 * Le type de l'observable est donné par \a type
293 */
294 virtual IObservable* observable(eTimeLoopEventType type) =0;
295
296 //! Positionne la raison pour laquelle on arrête le code
297 virtual void setStopReason(eTimeLoopStopReason reason) =0;
298
299 /*!
300 * \brief Raison pour laquelle on arrête le code.
301 *
302 * Si la valeur est eTimeLoopStopReason::NoStop, alors le code
303 * n'est pas en arrêt.
304 */
305 virtual eTimeLoopStopReason stopReason() const =0;
306};
307
308/*---------------------------------------------------------------------------*/
309/*---------------------------------------------------------------------------*/
310
311ARCANE_END_NAMESPACE
312
313/*---------------------------------------------------------------------------*/
314/*---------------------------------------------------------------------------*/
315
316#endif
317
Déclarations des types généraux de Arcane.
Interface d'un point d'entrée d'un module.
Definition IEntryPoint.h:34
Interface d'un partitionneur de maillage.
Interface d'un observable.
Interface du gestionnaire d'un sous-domaine.
Definition ISubDomain.h:74
Interface du gestionnaire de la boucle en temps.
virtual EntryPointCollection loopEntryPoints()=0
Retourne la liste des points d'entrée de type 'ComputeLoop' de la boucle en temps.
virtual Integer nbLoop() const =0
Nombre de boucles de calcul (ComputeLoop) effectuées.
virtual void timeLoopsName(StringCollection &names) const =0
Retourne dans names la liste des noms des boucles en temps.
virtual void timeLoops(TimeLoopCollection &time_loops) const =0
Retourne dans time_loops la liste des boucles en temps.
virtual ITimeLoop * createTimeLoop(const String &name)=0
Crée une boucle en temps de nom name.
virtual int doComputeLoop(Integer max_loop=0)=0
Exécute la boucle de calcul.
virtual void execBuildEntryPoints()=0
Exécute les points d'entrée de construction.
virtual IEntryPoint * currentEntryPoint()=0
Retourne le point d'entrée en cours d'exécution ou 0 s'il n'y en a pas.
virtual EntryPointCollection usedTimeLoopEntryPoints()=0
Liste de tous les points d'entrée pour la boucle en temps actuelle.
virtual void goBackward()=0
Effectue un retour arrière.
virtual eTimeLoopStopReason stopReason() const =0
Raison pour laquelle on arrête le code.
virtual void setVerificationActive(bool is_active)=0
Positionne l'état du mode de vérification.
virtual void doVerification(const String &name)=0
Effectue une vérification.
virtual ITimeLoop * usedTimeLoop() const =0
Retourne la boucle en temps utilisée.
virtual IEntryPoint * nextEntryPoint()=0
Retourne le prochain point d'entrée à exécuter ou 0 s'il n'y en a pas.
virtual void execOnMeshRefinementEntryPoints()=0
Exécute les points d'entrée après raffinement.
virtual bool isDoingBackward()=0
Vrai si on est actuellement dans un retour-arrière.
virtual void execInitEntryPoints(bool is_continue)=0
Exécute les points d'entrée d'initialisation.
virtual void stopComputeLoop(bool is_final_time, bool has_error=false)=0
Indique que la boucle de calcul doit s'interrompre.
virtual void setStopReason(eTimeLoopStopReason reason)=0
Positionne la raison pour laquelle on arrête le code.
virtual void registerTimeLoop(ITimeLoop *time_loop)=0
Enregistrement et choix de la boucle en temps.
virtual void setBackwardSavePeriod(Integer n)=0
Positionne la période entre deux sauvegarde pour le retour arrière. Si cette valeur est nulle,...
virtual Real cpuTimeUsed() const =0
Retourne le temps CPU utilisé en secondes.
virtual IObservable * observable(eTimeLoopEventType type)=0
Observable sur l'instance.
virtual void setUsedTimeLoop(const String &name)=0
Positionne la boucle en temps à exécuter. Sélectionne la boucle en temps de nom name comme celle qui ...
virtual ~ITimeLoopMng()
Libère les ressources.
virtual void registerActionMeshPartition(IMeshPartitionerBase *mesh_partitioner)=0
Programme un repartitionnement du maillage avec l'outil de partition mesh_partitioner.
virtual int doOneIteration()=0
Lance l'exécution d'une itération de la boucle de calcul.
virtual void doExecNextEntryPoint(bool &is_last)=0
virtual void execOnMeshChangedEntryPoints()=0
Exécute les points d'entrée après rééquilibrage.
virtual bool finalTimeReached() const =0
Retourne true si le temps final est atteint.
virtual void execExitEntryPoints()=0
Exécute les points d'entrée de terminaison.
virtual ISubDomain * subDomain() const =0
< Retourne le gestionnaire du sous-domaine
Interface d'une boucle en temps.
Definition ITimeLoop.h:32
Chaîne de caractères unicode.
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
eTimeLoopStopReason
Raison pour laquelle on arrête le code.
@ MaxIterationReached
Arrêt car nombre d'itération maximal spécifié atteint.
@ NoStop
Indique qu'on n'est pas encore en mode d'arrête du code.
@ FinalTimeReached
Arrêt car temps final atteint.
@ NoReason
Pas de raison spécifique.
@ Error
Arrêt sur une erreur.
Int32 Integer
Type représentant un entier.
Collection< String > StringCollection
Collection de chaînes de caractères.
Definition UtilsTypes.h:593
Collection< ITimeLoop * > TimeLoopCollection
Collection de boucles en temps.
double Real
Type représentant un réel.
Collection< IEntryPoint * > EntryPointCollection
Collection de points d'entrées.