[Texte] Viablab - tous les paramètres du fichier .cpp

Niveau de difficulté

Thématique

Présentation formation

Cette page s'adresse aux utilisateurs de ViabLab qui souhaitent implémenter leur propre problème de viabilité dans ViabLab et qui ont donc à éditer deux fichiers , un .cpp et un json.

Nous décrivons ici toutes les fonctions à implémenter dans le fichier .cpp.

La liste suivante présente les différentes fonctions pouvant être utilisées pour décrire un modèle de viabilité dans VIABLAB. Selon les propriétés du problème à résoudre, seules les fonctions pertinentes doivent être définies.

IMPORTANT : les signatures des fonctions, telles que déclarées dans `WeakDeclarations.h` et décrites ici, doivent être strictement respectées pour que le code puisse compiler et s'exécuter correctement.

Contenu

Déclarations des fonctions à implémenter dans les fichiers de modèle .cpp

Les fonctions à implémenter dépendent des caractéristiques du calcul à effectuer spécifiées dans le .json, nous précisons donc les valeurs des clés pour lesquelles chaque fonction doit être implémentée.

Général
Fonctions

void loadModelData(const ParametersManager *PM);	Cette fonction est appelée au début de l'exécution du programme pour charger les données spécifiques au modèle. Elle peut servir à initialiser des paramètres, charger des données depuis des fichiers ou effectuer toute autre opération de configuration nécessaire avant le début des calculs.
void postProcess(const ParametersManager *PM);	Cette fonction est appelée à la fin de l'exécution du programme pour effectuer des opérations de post-traitement, telles que l'analyse des résultats, la génération de graphiques ou la libération des ressources allouées.

Systèmes continus non tychastiques : DYNAMICS_TYPE = "CC" (temps continu / état continu) ou "DC" (temps discret / état continu) et CONTROL_TYCHASTIC_DIMENSION = 0
Fonctions

void dynamics(const double x, const double u, double *image);	Cette fonction définit la dynamique du système. Elle prend en entrée l'état `x` et la commande `u`, et calcule l'image de la dynamique, c'est-à-dire la dérivée temporelle de l'état ("CC") ou l'état suivant ("DC")
double constraintsXU(const double x, const double u);	Cette fonction définit les contraintes sur la commande, c'est-à-dire l'ensemble U(x). Elle prend en entrée l'état `x` et la commande `u`, et renvoie une valeur de type `double` si les contraintes sont satisfaites, ou la constante `PLUS_INF` dans le cas contraire.	Uniquement si CONTROL_DIMENSION non nul
void jacobian(const double x, const double u, double **jacob);	cette fonction calcule la matrice jacobienne de la dynamique par rapport à l'état `x`. Elle est utilisée pour estimer la constante de Lipschitz de la dynamique lorsque l'option `"LIPSCHITZ_CONSTANT_COMPUTE_METHOD": "ANALYTICAL_CALC"` est sélectionnée. -	Uniquement si DYNAMICS_TYPE = "CC"
void localDynBounds(const double x, double res);	cette fonction calcule des bornes locales sur la dynamique à partir de l'état `x`. Elle est utilisée lorsque l'option `"DYN_BOUND_COMPUTE_METHOD": "ANALYTICAL_CALC"` est sélectionnée.	Uniquement si DYNAMICS_TYPE = "CC"
double constraintsX(const double *x);	Cette fonction définit les contraintes d'état, c'est-à-dire l'ensemble de viabilité K. Elle prend l'état `x` en entrée et renvoie un `double` si les contraintes sont satisfaites, ou la constante `PLUS_INF` dans le cas contraire.
double target(const double *x);	Cette fonction définit l'ensemble cible C. Elle ne doit être définie que pour les problèmes comportant une cible. Elle prend l'état `x` en entrée et renvoie un `double` si les contraintes sont satisfaites, ou la constante `PLUS_INF` dans le cas contraire.	Uniquement si SET_TYPE = "CAPT"
double l(const double x, const double u);	Cette fonction définit la fonction de coût instantané pour les modèles micro-macro. Elle prend en entrée l'état `x` et la commande `u`, et renvoie un nombre à virgule flottante (type `double`) représentant le coût associé au couple (x, u).	Uniquement si GRID_METHOD = "MM"
double m(const double x, const double u);	Cette fonction définit la fonction d'actualisation pour les modèles micro-macro. Elle prend en entrée l'état `x` et la commande `u`.	Uniquement si GRID_METHOD = "MM"

Systèmes continus tychastiques : DYNAMICS_TYPE = "CC" (temps continu / état continu) ou "DC" (temps discret / état continu) et CONTROL_TYCHASTIC_DIMENSION > 0
Fonctions

void dynamics_tych(const double x, const double u, const double v, double image);	Cette fonction définit la dynamique du système lorsque l'incertitude est représentée par une variable de bruit `v`. Elle prend en entrée l'état `x`, la commande `u` et la variable tychastique `v`, et calcule l'image de la dynamique.
double constraintsXU(const double x, const double u);	Cette fonction définit les contraintes sur la commande, c'est-à-dire l'ensemble U(x). Elle prend en entrée l'état `x` et la commande `u`, et renvoie une valeur de type `double` si les contraintes sont satisfaites, ou la constante `PLUS_INF` dans le cas contraire.	Uniquement si CONTROL_DIMENSION non nul
double constraintsXV_tych(const double x, const double v);	Cette fonction définit les contraintes sur l'état et la variable tychastique, c'est-à-dire l'ensemble K. Elle prend en entrée l'état `x` et la variable tychastique `v`, et renvoie un `double` si les contraintes sont satisfaites, ou la constante `PLUS_INF` dans le cas contraire.
void jacobian_tych(const double x, const double u, const double v, double *jacob);	Cette fonction calcule la matrice jacobienne de la dynamique par rapport à l'état `x` lorsque l'incertitude est représentée par `v`. Elle est utilisée pour estimer la constante de Lipschitz lorsque l'option `"LIPSCHITZ_CONSTANT_COMPUTE_METHOD": "ANALYTICAL_CALC"` est sélectionnée.	Uniquement si DYNAMICS_TYPE = "CC"
void localDynBounds(const double x, double res);	cette fonction calcule des bornes locales sur la dynamique à partir de l'état `x`. Elle est utilisée lorsque l'option `"DYN_BOUND_COMPUTE_METHOD": "ANALYTICAL_CALC"` est sélectionnée.	Uniquement si DYNAMICS_TYPE = "CC"
double constraintsX(const double *x);	Cette fonction définit les contraintes d'état, c'est-à-dire l'ensemble de viabilité K. Elle prend l'état `x` en entrée et renvoie un `double` si les contraintes sont satisfaites, ou la constante `PLUS_INF` dans le cas contraire.
double target(const double *x);	Cette fonction définit l'ensemble cible C. Elle ne doit être définie que pour les problèmes comportant une cible. Elle prend l'état `x` en entrée et renvoie un `double` si les contraintes sont satisfaites, ou la constante `PLUS_INF` dans le cas contraire.	Uniquement si SET_TYPE = "CAPT"
double l_tych(const double x, const double u, const double *v);	Cette fonction définit la fonction de coût instantané pour les modèles micro-macro avec incertitude tychastique. Elle prend en entrée l'état `x`, la commande `u` et la variable tychastique `v`, et renvoie un `double` représentant le coût pour le triplet (x, u, v).	Uniquement si GRID_METHOD = "MM"
double m_tych(const double x, const double u, const double *v);	Cette fonction définit la fonction d'actualisation pour les modèles micro-macro avec incertitude tychastique. Elle prend en entrée l'état `x`, la commande `u` et la variable tychastique `v`.	Uniquement si GRID_METHOD = "MM"

Systèmes discrets en temps et espace : DYNAMICS_TYPE = "DD"
Fonctions

void dynamics_fd(const unsigned long long int x, const unsigned long long int u, unsigned long long int *image);	Cette fonction définit la dynamique des systèmes discrets. Elle prend en entrée l'état `x` et la commande `u`, et calcule l'image de la dynamique, c'est-à-dire le nouvel état après application de la commande.
void dynamics_tych_fd(const unsigned long long int x, const unsigned long long int u, const unsigned long long int v, unsigned long long int image);	Cette fonction définit la dynamique de systèmes discrets soumis à une incertitude. Elle prend en entrée l'état `x`, la commande `u` et la variable tychastique `v`, et calcule le nouvel état après application de la commande et de la perturbation tychastique.	Uniquement si CONTROL_TYCHASTIC_DIMENSION>0
double constraintsXU_fd(const unsigned long long int x, const unsigned long long int u);	Cette fonction définit les contraintes de commande pour les systèmes discrets, c'est-à-dire l'ensemble U(x). Elle prend en entrée l'état `x` et la commande `u`, et renvoie un `double` si les contraintes sont satisfaites, ou la constante `PLUS_INF` dans le cas contraire.	Uniquement si CONTROL_DIMENSION>0
double constraintsXUY_fd(const unsigned long long int x, const unsigned long long int u);	????Cette fonction définit des contraintes intégrales sur la commande et l'état.	Uniquement si GRID_METHOD = "MM"
??? y a pas une fonction costraintsXV_fd ???
double constraintsX_fd(const unsigned long long int *x);	Cette fonction définit les contraintes d'état pour les systèmes discrets, c'est-à-dire l'ensemble de viabilité K. Elle prend en entrée l'état `x` et renvoie un `double` si les contraintes sont satisfaites, ou la constante `PLUS_INF` dans le cas contraire.
double target_fd(const unsigned long long int *x);	Cette fonction définit l'ensemble cible C pour les systèmes discrets. Elle prend en entrée l'état `x` et renvoie un `double` si les contraintes sont satisfaites, ou la constante `PLUS_INF` dans le cas contraire.	Uniquement si SET_TYPE = "CAPT"
double l_fd(const unsigned long long int x, const unsigned long long int u);	Cette fonction définit la fonction de coût instantané pour les modèles micro-macro avec des systèmes discrets. Elle prend en entrée l'état `x` et la commande `u`, et renvoie un `double` représentant le coût pour le couple (x, u).
double l_tych_fd(const unsigned long long int x, const unsigned long long int u, const unsigned long long int *v);	Cette fonction définit la fonction de coût instantané pour les modèles micro-macro avec des systèmes tychastiques discrets. Elle prend en entrée l'état `x`, la commande `u` et la variable tychastique `v`, et renvoie une valeur de type `double` représentant le coût associé au triplet (x, u, v).	Uniquement si CONTROL_TYCHASTIC_DIMENSION>0

Systèmes hybrides : DYNAMICS_TYPE = "HC" ou "HD"
Fonctions

Contenu à venir...

void dynamics_hybrid_c(const double x, const unsigned long long int xd, const double u, double image);	Cette fonction définit la partie continue de la dynamique pour les systèmes hybrides. Elle prend en entrée l'état continu `x`, l'état discret `xd` et la commande `u`, et calcule l'image de la dynamique continue.
void dynamics_hybrid_d(const double x, const unsigned long long int xd, const unsigned long long int u, unsigned long long int image);	Cette fonction définit la partie discrète de la dynamique pour les systèmes hybrides. Elle prend en entrée l'état continu `x`, l'état discret `xd` et la commande discrète `u`, et calcule l'image de la dynamique discrète.
void resetMap_hybrid(const double * xc, const unsigned long long int* xd, const unsigned long long int* resetControl, double * imagec, unsigned long long int* imaged);	Cette fonction décrit les « sauts » ou « transitions impulsionnelles » de l'état du système hybride. Elle prend en entrée l'état continu `xc`, l'état discret `xd` et la commande de réinitialisation `resetControl`, et calcule les états continu et discret résultant de la réinitialisation.
double constraintsXU_hybrid(const double x, const unsigned long long int xd, const double u, const unsigned long long int ud);	Cette fonction définit les contraintes de commande pour les systèmes hybrides, c'est-à-dire l'ensemble U(x, xd). Elle prend en entrée l'état continu `x`, l'état discret `xd`, la commande continue `u` et la commande discrète `ud`, et renvoie un `double` si les contraintes sont satisfaites, ou la constante `PLUS_INF` dans le cas contraire.	Uniquement si CONTROL_DIMENSION>0
void jacobian_hybrid(const double x, const unsigned long long int xd, const double u, double *jacob);	Cette fonction calcule la matrice jacobienne de la partie continue de la dynamique par rapport à l'état continu `x` pour les systèmes hybrides. Elle est utilisée pour estimer la constante de Lipschitz de la dynamique continue lorsque l'option `"LIPSCHITZ_CONSTANT_COMPUTE_METHOD": "ANALYTICAL_CALC"` est sélectionnée.
void localDynBounds_hybrid(const double x, const unsigned long long int xd, double *res);	Cette fonction calcule des bornes locales sur la partie continue de la dynamique à partir de l'état continu `x` et de l'état discret `xd`. Elle est utilisée lorsque l'option `"DYN_BOUND_COMPUTE_METHOD": "ANALYTICAL_CALC"` est sélectionnée pour les systèmes hybrides.
double constraintsX_hybrid(const double x, const unsigned long long int xd);	Cette fonction définit les contraintes d'état pour les systèmes hybrides, c'est-à-dire l'ensemble de viabilité K. Elle prend en entrée l'état continu `x` et l'état discret `xd`, et renvoie un `double` si les contraintes sont satisfaites, ou la constante `PLUS_INF` dans le cas contraire.