Aller au contenu principal

Débutant

[Texte] Fichiers de sortie de ViabLab

Niveau de difficulté
Thématique
Objectif

Décrire la syntaxe des fichiers issus des calculs de ViabLab.

Contenu

Les fichiers issus de l'exécution de ViabLab sont enregistrés dans le répertoire /OUTPUT.

Un calcul génère plusieurs fichiers qui sont nommés avec le même préfixe.
Les suffixes correspondent aux types d'informations contenues dans les fichiers. Ainsi, tous les fichiers de même suffixe suivent la même syntaxe. Sont listés ci-dessous tous les types de fichiers qu'un calcul de ViabLab peut produire : 

<prefixe>-grid_data.dat
Fichier de grille - lire le descriptif 

Le fichier de grille est un fichier permettant de connaître les dimensions et paramètres de la grille régulière à partir de laquelle s'est effectué le calcul, et ainsi pouvoir lire les autres fichiers. 
Ci-dessous l'exemple d'une sortie (du modèle SimplePopGrowth), la description est ajoutée en commentaires après un # : 

2  # Dimension de l'espace d'états (STATE_DIMENSION)
# Valeurs minimales des coordonnées d'un état (STATE_MIN_VALUES)
# Il y a autant de valeurs que de dimension de l'espace des états (STATE_DIMENSION)
-2 # première coordonnée du point inférieur (dans toutes les dimensions) de la grille 
-2 # seconde coordonnée du point inférieur (dans toutes les dimensions) de la grille
# Valeurs maximales des coordonnées d'un état (STATE_MAX_VALUES)
# Il y a autant de valeurs que de dimension de l'espace des états (STATE_DIMENSION)
2  # première coordonnée du point supérieur (dans toutes les dimensions) de la grille
2  # seconde coordonnée du point supérieur (dans toutes les dimensions) de la grille
# Nombre de points de grille par dimension (STATE_GRID_POINTS)
4001 # nombre de points de la grille selon le premier axe
4001 # nombre de points de la grille selon le second axe
# Indice des dimensions à conserver pour la coupe (SLICE_DIRS)
0
0    
# Valeur souhaitée pour la dimension fixée (SLICE_VALUES) 
1
1

<prefixe>-viab.dat
Fichier de noyau de viabilité complet - lire le descriptif 

Ce fichier contient des lignes représentant les coordonnées des points de grille et leur appartenance au noyau. Chaque ligne contient STATE_DIMENSION coordonnées de points de grille séparées par des espaces et en dernier une valeur.

La signification de la valeur en fin de ligne diffère selon le type de noyau de viabilité calculé (spécfié  GRID_METHOD).

Si le noyau de viabilité est un ensemble quelconque (GRID_METHOD vaut “BS” (BitSet)), la dernière valeur vaut 1.0 si le point est dans le noyau de viabilité et 0.0 sinon. 
(A noter qu'il est possible de ne pas écrire les valeurs non contenues dans le noyau en mettant SAVE_VIABSET_LIGHT à True, dans quel cas le fichier ne contiendra que les lignes se terminant par 1.0.)

Si le noyau de viabilité est l'épigraphe d'une fonction valeur (GRID_METHOD vaut MM (MicroMacro)), la dernière valeur indique la valeur de la grille en cette position. La dernière valeur vaudra alors PLUS_INF (constante du programme valant 1015) si la valeur n’est pas contenue dans le noyau et une valeur strictement inférieure si elle appartient au noyau. Tout comme pour un méthode BS, il est possible de ne conserver que les lignes contenues dans le noyau de viabilité.


<prefixe>-viab-bound.dat
Fichier de la frontière du noyau de viabilité - lire le descriptif 

Ce fichier contient la liste des points représentant la frontière du noyau de viabilité, c'est à dire les coordonnées des points de la grille qui ont au moins un voisin qui n'appartient pas au noyau calculé. Ces points sont écrits sous forme de STATE_DIMENSION coordonnées séparées par des espaces. Il y a un point par ligne.


<prefixe>-traj-[i].dat et <prefixe>-traj-[i]-Discrete.dat 
Fichiers de trajectoires - lire le descriptif 

Les fichiers de trajectoire fonctionnent par paires. Chaque fichier de trajectoire “réelle” se terminant en -traj-[i].dat, avec i un entier, est accompagné d’un fichier de trajectoire discrète en traj-[i]-Discrete.dat.

Le fichier de trajectoire réelle est un ensemble de lignes représentant chacune un état, un temps (durée) depuis le début de la trajectoire et un contrôle. Chaque état est représenté par STATE_DIMENSION coordonnées et chaque contrôle par CONTROL_DIMENSION coordonnées.

Si jamais une trajectoire par stratégie est utilisée, et que le paramètre de trajectoire SAVE_PICKING_STRATEGY n’est pas false, la dernière colonne sera une liste de stratégies de la forme “NOM_STRATEGIE_1(indice_dans_liste_de_stratégies),NOM_STRATEGIE_2(indice_dans_liste_de_stratégies),…NOM_STRATEGIE_n(indice_dans_liste_de_stratégies)”. Chaque stratégie à l’intérieur de cette liste est alors une stratégie ayant contribué au choix (modifié la valeur) du contrôle retourné.

Une ligne est donc composée de:

  1. STATE_DIMENSION coordonnées séparées par des espaces représentant un état.
  2. Une durée depuis le début de la trajectoire.
  3. CONTROL_DIMENSION coordonnées séparées par des espaces représentant un contrôle.
  4. Optionellement, une liste de stratégies séparées par des virgules (,) au format “NOM(indice)”, avec “indice” un entier correspondant à l’indice dans la liste des stratégies et “NOM” le nom de la stratégie ayant cet indice dans le JSON.

Pour un schéma numérique donnée (Euler, Runge-Kutta d’ordre 2, Runge-Kutta d’ordre 4), il devrait être possible de retrouver la trajectoire obtenue à l’aide de la dynamique, notée $\Phi(x, u)$ avec $x$ l’état et $u$ le contrôle. On note $x_n$ l’état sur la ligne $n$, $t_n$ la durée en $n$ et $u_n$ le contrôle en $n$.

Pour la méthode d’Euler, on a par exemple que:

$$ x_{n+1} = x_n + (t_{n+1} - t_n)\Phi(x_n, u_n).$$


[Texte] ViabLab (version >=4.0) : première utilisation

Niveau de difficulté
Thématique
Objectif

Exécuter un des modèles déjà implémentés

En effet, vous avez peut-être remarqué qu'à la fin de l'installation en exécutant la commande 

make

les lignes suivantes listent le nom des modèles déjà implémentés :

[ 50%] Built target ARKerU_data
[ 52%] Built target ExempleViabi2D_data
[ 55%] Built target Exemple_multiDim_data
[ 57%] Built target VALIUM
[ 59%] Built target VALIUM_2f
[ 61%] Built target VALIUM_Hybrid
[ 64%] Built target ValiumGaranti_2f
[ 66%] Built target data_Coeur
[ 68%] Built target data_Demo
[ 70%] Built target data_Julia2D
[ 73%] Built target data_Lac
[ 75%] Built target data_LakeCollective
[ 77%] Built target data_LotkaVolterra
[ 79%] Built target data_SimplePopGrowth
[ 82%] Built target data_circle
[ 84%] Built target data_hybridTest
[ 86%] Built target data_labyrinthe
[ 88%] Built target equilibres4D_data
[ 91%] Built target pareto_data
[ 93%] Built target resilience_data
[ 95%] Built target testPendule_data
[ 97%] Built target zermelo_Lmin
[100%] Built target zermelo_tmin

 

Pré-requis

Avoir installé ViabLab

Etre allé jusqu'au bout de la procédure qui se termine par les deux commandes cmake < suite à spécifier> puis make (tutoriel d'installation). 

Contenu

Pour exécuter un code de modèle déjà présent, une seule ligne de commande est nécessaire. 

Pour le modèle SimplePopGrowth par exemple (qui utilise les fichiers data_SimplePopGrowth.cpp dans /source/data, et SimplePopGrowth_params.json dans /INPUT) :

  • Ouvrir un terminal (pour Windows : touche Windows + R, taper powershell).

  • Puis la commande :

./viabLab data_SimplePopGrowth.so

Les fichiers résultats dont les noms commencent par "SimplePopGrowth" sont crées dans le répertoire /OUTPUT.

[Texte] Désinstallation de ViabLab (version >=4.0)

Niveau de difficulté
Domaine
Thématique
Objectif

Désinstaller ViabLab

Contenu

Pour désinstaller ViabLab, il suffit de supprimer le répertoire qui le contient.

Pour désinstaller les librairies dont ViabLab dépend que vous avez peut-être dû installer (MySys2, gcc, cmake, make, boost, dlfcn, spdlog pour Windows ; gcc, g++, cmake, boost-devel/libboost-all-dev, spdlog-devel/libspdlog-dev, libcurl-devel/libcurl4 pour Linux ; gcc, g++, cmake, boost, spdlog, libomp pour MacOs) il faut vous reporter à leur propre guide de désintallation.

[Texte] Installation de ViabLab (version>= 4.0 ) à partir de GitHub

Niveau de difficulté
Thématique
Présentation formation

Comment installer et compiler ViabLab à partir de GitHub.

Contenu
MAC OS
Lire la suite 

Contenu à venir...


LINUX
Lire la suite 

FEDORA : 

Etape 1. Installation des dépendances

  • Mettre à jour le manager de paquets :

sudo dnf update
  • Installer les compilateurs C/C++:   

 Pour vérifier si gcc/g++ sont installés, dans un terminal : 

gcc --version
g++ --version

Si gcc/g++ ne sont pas installés sur votre système :        

sudo dnf install gcc
sudo dnf install g++
  • Installer Cmake (version >= 3.22.1) : 

Pour vérifier si cmake est installé et connaitre sa version, dans un terminal :

cmake --version

Si ce n'est pas la bonne version , supprimer les versions existantes de CMake, dans un terminal :

sudo dnf remove cmake

Puis

sudo dnf install cmake
  • Installer git (optionnel - si on souhaite cloner la dernière version de travail du code)

sudo dnf install git
  • Installer les librairies externes open source

sudo dnf install boost-devel
sudo dnf install spdlog-devel
sudo dnf install libcurl-devel

Etape 2. Copier VIABLAB à partir de GitHub 

Dans FileExplorer, créer un répertoire viablab qui contiendra le programme et les résultats

Pour copier ViabLab, trois possibilités :

      Dézipper VIABLAB-main.zip dans le répertoire viablab. 

  • Ouvrir un terminal dans le répertoire viablab et cloner le dépôt : 

git clone https://github.com/lastre-viab/VIABLAB.git

Etape 3. Compiler VIABLAB 

Vous êtes maintenant prêts à compiler le code de ViabLab. 

D'abord, aller dans le répertoire build (le créer s'il n'existe pas) de VIABLAB-main dans un terminal (le chemin dépend de votre installation). Par exemple : 

cd viablab/VIABLAB-main/build/

Ensuite, exécuter la commande cmake : 

cmake ../source

En cas d'erreur pendant le cmake, aller dans le répertoire build et effacer complètement son contenu avant de relancer la commande cmake.

La commande cmake ne doit être exécutée qu'à la première installation ; ensuite, la commande make ci-dessous sera suffisante pour compiler le code : 

make

Lorsque la compilation est terminée, l'exécutable viabLab.exe est généré dans le répertoire build. 

 

UBUNTU :

Etape 1. Installation des dépendances

  • Mettre à jour le manager de paquets apt :

sudo apt update
  • Installer les compilateurs C/C++:   

 Pour vérifier si gcc/g++ sont installés, dans un terminal : 

gcc --version
g++ --version

Si gcc/g++ ne sont pas installés sur votre système :        

sudo apt install gcc
sudo apt install g++
  • Installer Cmake (version >= 3.22.1) : 

Pour vérifier si cmake est installé et connaitre sa version, dans un terminal :

cmake --version

Si ce n'est pas la bonne version , supprimer les versions existantes de CMake, dans un terminal :

sudo apt remove --purge cmake

Puis

sudo apt install cmake
  • Installer git (optionnel - si on souhaite cloner la dernière version de travail du code)

sudo apt install git
  • Installer les librairies externes open source

sudo apt install libboost-all-dev
sudo apt install libspdlog-dev
sudo apt install libcurl4

Etape 2. Copier VIABLAB à partir de GitHub 

Dans FileExplorer, créer un répertoire viablab qui contiendra le programme et les résultats

Pour copier ViabLab, trois possibilités :

      Dézipper VIABLAB-main.zip dans le répertoire viablab. 

  • Ouvrir un terminal dans le répertoire viablab et cloner le dépôt : 

git clone https://github.com/lastre-viab/VIABLAB.git

Etape 3. Compiler VIABLAB 

Vous êtes maintenant prêts à compiler le code de ViabLab. 

D'abord, aller dans le répertoire build (le créer s'il n'existe pas) de VIABLAB-main dans un terminal (le chemin dépend de votre installation). Par exemple : 

cd viablab/VIABLAB-main/build/

Ensuite, exécuter la commande cmake : 

cmake ../source

En cas d'erreur pendant le cmake, aller dans le répertoire build et effacer complètement son contenu avant de relancer la commande cmake.

La commande cmake ne doit être exécutée qu'à la première installation ; ensuite, la commande make ci-dessous sera suffisante pour compiler le code : 

make

Lorsque la compilation est terminée, l'exécutable viabLab.exe est généré dans le répertoire build. 

 


WINDOWS 
Lire la suite 

 

Etape 1. Installer MSYS2 

Suivre les instructions https://www.msys2.org/

Télécharger et lancer l'installateur :

Welcome to the MSYS2 Setup 

Choisir le répertoire d'installation :

Installation folder

 

Suivre les étapes d'installation : 

Installation steps

Patienter jusqu'à la fin du processus d'installation : 

Wait...

 

Cliquer sur Finish : 

Finish

Une fois installé, le script bash MinGW64 peut être lancé depuis le menu Windows :

Windows menu

MinGW64

 

Etape 2. Installer les outils de compilation et les dépendances

Msys fournit un gestionnaire de paquets, appelé pacman, qui peut être utilisé pour installer tous les outils de compilation et les dépendances nécessaires. La documentation est ici : https://www.msys2.org/docs/package-management/

Installer les paquets suivants (utiliser les commandes ci-dessous ou chercher dans https://packages.msys2.org/queue en choisissant Mingw64 binaries) : 

  • GCC: 

    pacman -S mingw-w64-x86_64-gcc
  • CMake: 

    pacman -S mingw-w64-x86_64-ccmake
  • Make: 

    pacman -S mingw-w64-x86_64-make
  • Boost: 

    pacman -S mingw-w64-x86_64-boost
  • Dlfcn: 

    pacman -S mingw-w64-x86_64-dlfcn
  • Spdlog: 

    pacman -S mingw-w64-x86_64-spdlog

Pour finir l'installation, ajouter à la variable System Path le chemin d'accès aux binaires Mingw64

C:\msys64\mingw64\bin :

Add path variable

Cette opération peut nécessiter le redémarrage de votre ordinateur pour s'assurer que les modifications de la variable System Path ont bien été enregistrées.


Etape 3. Copier VIABLAB dans le répertoire de MSyS 

A l'adresse https://github.com/lastre-viab/VIABLAB, cliquer sur le bouton Code et télécharger le fichier .zip VIABLAB-main.zip. 

Par défaut, l'interpréteur de commandes MSyS est ouvert dans le dossier /home/nom_utilisateur. Vous pouvez le voir dans l'explorateur de fichiers. 



 

Ouvrir ce dossier dans FileExplorer, créer le dossier dev-cpp qui contiendra le program et les fichiers de sorties et y dézipper VIABLAB-main.zip. Example : 


Etape 5. Compiler VIABLAB dans le dossier MSyS 

Retourner dans l'interface MSyS MINGW64 (le script bash MinGW64 peut être lancé depuis le menu Windows). Vous êtes prêt pour compiler le code de ViabLab. 

First, go to the build folder (create it if it doesn't exist) of VIABLAB in bash (depending on your personal installation). With the example folder shown above : 

cd dev-cpp/VIABLAB-main/build/

Then cmake command : 

  • cmake -G"MinGW Makefiles" -D BUILD_LIB=OFF ../source

  • If you use Eclipse C++ IDE, you can use the cmake command below to generate Eclipse project settings and enable debugging in Eclipse :

    cmake -G"Eclipse CDT4 - MinGW Makefiles" -D CMAKE_BUILD_TYPE=Debug -D BUILD_LIB=OFF ../source

    After running CMake, the project is ready to be imported into Eclipse: the build directory (initially empty) contains the data generated by CMake.

    In Eclipse, go to the File menu => Import and select the Existing Projects into Workspace option.

    Click Next.

    Then, in the following window, select the build directory.

    Click Finish.

    After the import, you will see the project tree in the left panel.

Note that cmake command must be executed only once, on first installation; further, only the make command below will be sufficient to build the code : 

mingw32-make

Once the compilation process finished, the executable viabLab.exe is created in build folder. 

 

[Texte] Installation ViabLab with Gui v3.0

Niveau de difficulté
Thématique
Présentation formation

Sous MAC

Pas possible pour le moment, le fichier binaire n'est disponible que pour Linux et Windows, il faut cloner à partir d'un dépôt.

 

Sous LINUX

Prérequis : 

  • Avoir installé g++ :   

 Pour vérifier si g++ est installé, dans un terminal : 

g++ --version

Si g++ n'est pas encore installé sur votre système :        

sudo apt install g++
  • Avoir installé cmake version 3.22.1 : 

Pour vérifier si cmake est installé et connaitre sa version, dans un terminal :

cmake --version

Si ce n'est pas la bonne version , supprimer les versions existantes de CMake, dans un terminal :

sudo apt remove --purge cmake

Vérifier la version de votre Ubuntu, dans un terminal : 

lsb_release -a

 Si votre version est 22.04, installer CMake 3.22.1 automatiquement :

    sudo apt update
    sudo apt install cmake

Si votre version n’est pas 22.04, installer les dépendances nécessaires :
 

    sudo apt update
    sudo apt install -y build-essential libssl-dev

 Télécharger CMake 3.22.1 :

       wget https://github.com/Kitware/CMake/releases/download/v3.22.1/cmake-3.22.1.tar.gz

  Extraire l'archive :

    tar -zxvf cmake-3.22.1.tar.gz
    cd cmake-3.22.1

    Construire et installer :

    ./bootstrap
    make -j$(nproc)      # Compiles using all available CPU cores
    sudo make install

Vérifier la version de cmake, dans un terminal :

cmake --version

Doit afficher  cmake version 3.22.1.

  • Avoir installé l'IDE Eclipse (facultatif)

    sudo apt-get install -y eclipse-cdt

 

Installation de Viablab :

chmod +x InstallerViabLabGui_v1_linux.run
  • Pour exécuter l'installeur
./InstallerViabLabGui_v1_linux.run
  • Next - Next - Next - Install - Finish
  • Puis se placer à l’aide de la commande cd dans le répertoire build : ~/ViabLabGui/bin/VIABLAB/build  
  • puis, pour une utilisation sans l'IDE Eclipse :
cmake -G "Unix Makefiles" ../source
make

 L'exécutable viabLabExe apparaît dans le répertoire build ! 

  • ou, pour une utilisation avec Eclipse :
cmake -D_ECLIPSE_VERSION=4.5 -DCMAKE_BUILD_TYPE=Debug ../source -G"Eclipse CDT4 - Unix Makefiles" -DCMAKE_ECLIPSE_GENERATE_SOURCE_PROJECT=TRUE

 

Sous WINDOWS :

Prérequis : 

  • Avoir installé MinGW, une distribution de compilateurs C/C++ GNU pour Windows :   

 A l'adresse https://sourceforge.net/projects/mingw/files/latest/download , téléchargez l'application MinGW Installation Manager.

Ouvrir cette application 

Dans le panneau gauche, développer All packages => MinGW, sélectionner MinGW Base System. Sélectionner dans la liste des packages tous les packages dont le nom contient « pthread », choisir Mark For Installation. Faire de même pour les packages gcc, omp, g++, libstd, mingw s’ils ne sont pas sélectionnés.

Une fois les packages sélectionnés, dans le menu Installation, cliquer sur Apply changes et attendre la fin d’installation.

Ajouter l’emplacement de l’installation MinGW dans la variable PATh du système :

Dans paramètres/settings du système, on cherche environmental/environnement et on clique dans «edit environment variables for your account »

Aller dans Path, edit, new et on copie colle : C:\MinGW\bin

Eteindre et redémarrer l'ordinateur.
 

  • Avoir installé cmake version 3.31.7:

Pour vérifier si cmake est installé et connaitre sa version, dans un terminal :

??

Si ce n'est pas la bonne version , supprimer les versions existantes de CMake, dans un terminal :

??

 Aller à l'adresse https://github.com/Kitware/CMake/releases/download/v3.31.7/cmake-3.31.7-windows-x86_64.msi pour télécharger le Windows x64 installer.

Vérifier la version de cmake, dans un terminal :

????

Doit afficher  cmake version 3.31.7.

  • Avoir installé Eclipse Environnement de développement intégré) (facultatif) :  

Aller à l'adresse  https://www.eclipse.org/downloads/packages/release/kepler/sr2/eclipse-ide-cc-developers

Cliquer sur download, à nouveau sur download.

Une fois téléchargé, cliquer sur l’installeur et chosir  Eclipse IDE for C/C++ developers

On ‘’launch’’ par la suite (première exécution pour voir que tout fonctionne)

On ‘’launch’’ de nouveau.

 

Installation de Viablab :

??
  • Pour exécuter l'installeur
??
  • Next - Next - Next - Install - Finish
  • Puis ouvrir un PowerShell, se placer à l’aide de la commande cd dans le répertoire build : ~/ViabLabGui/bin/VIABLAB/build  
  • puis, pour une utilisation sans l'IDE Eclipse :
cmake -G "MinGW Makefiles" ../source
make

 L'exécutable viabLabExe apparaît dans le répertoire build

  • ou, pour une utilisation avec Eclipse :
cmake -G"Eclipse CDT4 - MinGW Makefiles" -D CMAKE_BUILD_TYPE=Debug ../source

Après l’exécution de cmake le projet est prêt pour être importé dans Eclipse : le répertoire build ( vide au début) contient les données générées par cmake.

Dans Eclipse, aller dans le menu File => Import et sélectionner l’option Existing Projects into Workspace

Cliquer sur Next

Ensuite dans le fenêtre suivante sélectionner le répertoire build

Cliquer sur Finish

Après l’import on voit l’arborescence du projet dans le panneau gauche

Viability Theory

Type de document
Editeur
Birkhäuser
Revue
NON NON
Volume
NON NON
Collection
NON NON
Lieu
Boston
Année de publication
1991
Sous titre
Systems & Control: Formations & Applications
Auteur(s)
Jean-Pierre Aubin
Niveau de difficulté
Identifiant
ISBN : 978-1-4612-0451-8
photo

Ce livre fondateur développe les outils mathématiques de la théorie de la viabilité, utilisés pour étudier des systèmes dynamiques sous contraintes.

Algorithmes de viabilité pour la robotique autonome

Lieu
CNRS Toulouse
Date
28-06-2023
Langue de la conférence
Niveau de difficulté
Description

Utilisation d’algorithmes de viabilité pour garantir la sécurité et la performance des robots évoluant dans des environnements incertains.

Intervenant(s)
Eng. Thomas Bernard (CNRS-LAAS), Contenu à venir !