Tutoriel GVLE. Adapté à l environnement Record/VLE. Gauthier Quesnel Eric Casellas Éric Ramat

Transcription

1 Tutoriel GVLE Adapté à l environnement Record/VLE Gauthier Quesnel Eric Casellas Éric Ramat INRA (Institut National de la Recherche Agronomique) LIL (Laboratoire d Informatique du Littoral) (LIL, INRA) Tutoriel GVLE 1 / 73

2 Plan 1 Objectifs 2 Le projet 3 Le VPZ 4 Le modèle atomique 5 La dynamique 6 Les conditions 7 L expérience 8 Les vues 9 Le couplage (LIL, INRA) Tutoriel GVLE 2 / 73

4 Objectifs Objectifs du tutoriel Définir les concepts et le vocabulaire utilisé ; Présenter l interface graphique de gestion des modèles et des expériences (GVLE) à travers un exemple complet ; Donner quelques éléments de C++ pour l écriture d un modèle simple. (LIL, INRA) Tutoriel GVLE 4 / 73

5 Introduction GVLE Gui for the VLE Interface graphique de modélisation DEVS : Manipulation de la structure du modèle : Son rôle ajouts, suppressions de modèles ou de connexions copier coller importation exportation Ecriture des modèles, compilation et installation Manipulation des classes des modèles Saisie les conditions expérimentales Saisie les modèles à observer Exécution de simulations Cacher les procédures de compilation, d installation et d exécution Cacher la manipulation des fichiers XML VPZ (LIL, INRA) Tutoriel GVLE 5 / 73

7 Le projet Définition Un projet regroupe l ensemble des éléments d un projet de modélisation : les données (fichier météo,... ) ; la documentation ; les expériences ; le code C++ des modèles ; le code C++ compilé sous forme de bibliothèque ; les éléments pour prendre en charge la compilation, des fichiers annexes comme la licence, un fichier de description de l évolution du projet,... (LIL, INRA) Tutoriel GVLE 7 / 73

8 Le projet Création d un projet File New Project (ou CTRL + N) puis saisir le nom du nouveau projet. (LIL, INRA) Tutoriel GVLE 8 / 73

9 Le projet Création d un projet Un répertoire 2CV, notre projet, a été créé dans $HOME/.vle/pkgs sous Linux ou vle/pkgs dans le compte utilisateur sous Windows. L explorateur de fichiers permet la visualisation du contenu. (LIL, INRA) Tutoriel GVLE 9 / 73

10 Le projet Création d un projet cmake, CMakeCPack.cmake et CMakeLists.txt : macros et configuration pour la compilation ; data et doc : données et documentation du projet ; exp et output : expériences et résultats ; src et lib : sources C++ et bibliothèques; Authors.txt, ChangeLog.txt, License.txt, News.txt et Readme.txt : auteurs du modèle, les changements entre les différentes versions, la licence, les nouveautés de chaque version et les informations de compilation et d installation. (LIL, INRA) Tutoriel GVLE 10 / 73

12 Le VPZ VPZ VLE Project Zipped Un VPZ est un fichier XML (qui peut être compressé) et qui contient : la structure du modèle ; le lien avec la dynamique (le code C++) ; l expérience : la durée, les graines des générateurs aléatoires et le plan d expérience ; les conditions expérimentales ; les observations et le format des sorties ; (LIL, INRA) Tutoriel GVLE 12 / 73

13 Le VPZ Modèle atomique Un modèle atomique est la brique de base d un modèle global ; Seul lieu d expression de la dynamique (un modèle atomique = un ou plusieurs processus dynamique ) ; in1 et in2 sont les entrées du modèle et out1, out2 et out3 sont les sorties du modèle ; Les échanges entre modèles sont sous forme d événements. (LIL, INRA) Tutoriel GVLE 13 / 73

14 Le VPZ Événement Un événement est quelque chose qui se produit à un instant t et qui n a pas de durée ; Un événement est produit par un modèle et déposé sur l un de ses ports de sortie ; Un événement est distribué sur les ports d entrée de tous les modèles qui sont connectés au modèle qui l a produit ; Le temps de "transport" d un événement est nul ; Un événement peut transporter des informations. Un modèle peut recevoir plusieurs événements à la même date sur un même port ou sur des ports différents. (LIL, INRA) Tutoriel GVLE 14 / 73

15 Le VPZ Événement m1 peut produire des événements sur out1, out2 et out3 ; m2 va recevoir sur son port d entrée in1 les événements produits par m1 sur son port out1 ; (LIL, INRA) Tutoriel GVLE 15 / 73

16 Le VPZ Création d un VPZ File New VPZ (ou CTRL + Shift + N). Ne pas oublier de sauvegarder le VPZ (CTRL + S) ; un nom sera alors demandé. (LIL, INRA) Tutoriel GVLE 16 / 73

17 Le VPZ Création d un VPZ Par défaut, il existe un VPZ vide (empty.vpz) à la création d un projet. Lors de son ouverture, un message signale qu il n est pas complet. On peut l utiliser en ouvrant le répertoire exp et en double cliquant sur le fichier ou en faisant File Open VPZ (ou CTRL + Shift + O). On peut aussi le renommer via le menu contextuel (clic droit sur le fichier). (LIL, INRA) Tutoriel GVLE 17 / 73

19 Le VPZ Création d un modèle atomique Tools Add models (ou F2 ou clic sur l icône avec un +) puis clic dans la vue VPZ puis saisie du nom du modèle. (LIL, INRA) Tutoriel GVLE 19 / 73

20 Le VPZ Création d un modèle atomique Le modèle est apparu dans la zone Model. C est le seul lieu pour renommer un modèle avec le menu contectuel. (LIL, INRA) Tutoriel GVLE 20 / 73

21 Le VPZ Création des ports d entrée et sortie Tools Select (ou F1 ou clic sur l icône avec la main) puis double clic sur le modèle nouvellement créé ou double clic sur le modèle depuis la zone Model. C est une boîte de dialogue avec des onglets où chaque onglet permet de définir un aspect (ports, conditions, dynamics et views ) d un modèle atomique. (LIL, INRA) Tutoriel GVLE 21 / 73

22 Le VPZ Création des ports d entrée et sortie Clic sur l onglet Ports puis clic droit dans la partie Input ports (ou Output ports) puis Add puis saisie d un nom de port. Le menu contextuel permet aussi de renommer et de supprimer un port. (LIL, INRA) Tutoriel GVLE 22 / 73

23 Le VPZ Création des ports d entrée et sortie On créé DvtStade et TT en port d entrée et CropDepth en port de sortie. (LIL, INRA) Tutoriel GVLE 23 / 73

25 La dynamique Définition La dynamique est la partie comportementale d un modèle ; Elle décrit le processus de changement d état du modèle ; La dynamique est décrite sous forme d une classe C++. Deux étapes Ecriture du code C++ ; Déclaration de la dynamique associée à un modèle atomique. (LIL, INRA) Tutoriel GVLE 25 / 73

26 La dynamique Ecriture de la classe C++ On se sert de l extension DifferenceEquation pour illustrer l écriture de la classe C++ : le modèle est donc une équation aux différences. L équation si t = 0 ou DS(t) = Sowing alors RD(t) = 0 si DS(t) = Emergence et DS(t t) = Sowing alors RD(t) = InitDepth sinon RD(t) = RD(t) + min(min(soildepth RD(t t), MaxDepth RD(t t)), RateDepth (TT(t) TT(t t))) DS = DvtStade ; RD = RootDepth ; constantes : Emergence et Sowing ; paramètres : InitDepth, SoilDepth, MaxDepth et RateDepth. (LIL, INRA) Tutoriel GVLE 26 / 73

27 La dynamique Ecriture de la classe C++ Clic droit sur le répertoire src puis New File puis saisie du nom du fichier (CropRoot.cpp). Un nouvel onglet s ouvre avec un fichier texte vide. (LIL, INRA) Tutoriel GVLE 27 / 73

28 La dynamique Ecriture de la classe C++ 1 #include <vle/ extension/ DifferenceEquation.hpp > 2 3 namespace DeuxCV { 4 5 class CropRoot : public vle:: extension:: DifferenceEquation:: Multiple 6 { 7 public: 8 CropRoot(const vle:: devs:: DynamicsInit& init, 9 const vle:: devs:: InitEventList& events) : 0 vle:: extension:: DifferenceEquation:: Multiple(init, events) 1 { } 2 virtual ~CropRoot() {}; 3 4 virtual void compute(const vle:: devs:: Time& time) 5 { } 6 virtual void initvalue(const vle:: devs:: Time& time) 7 { } 8 }; 9 0 DECLARE_DYNAMICS(CropRoot); 1 2 } // namespace DeuxCV (LIL, INRA) Tutoriel GVLE 28 / 73

29 La dynamique Ecriture de la classe C++ Inclusion #include <vle/ extension/ DifferenceEquation.hpp > Afin d utiliser des types, des constantes, des fonctions,... de VLE, il faut inclure des fichiers de définitions (les fichiers.hpp). Dans le cas de l utilisation de l extension DifferenceEquation, il faut inclure DifferenceEquation.hpp. Namespace namespace DeuxCV {... } // namespace DeuxCV Le concept de namespace permet d isoler des définitions de classes, de fonctions,... au sein d un "espace de nommage". Par exemple, cela autorise la définition de deux classes de même nom placées dans des namespaces différents. VLE est entièrement basé sur ce concept. (LIL, INRA) Tutoriel GVLE 29 / 73

30 La dynamique Ecriture de la classe C++ Classe class CropRoot... {... }; Une classe est une structure dans laquelle on retouve des données (attributs) et des fonctions (méthodes) qui s appliquent sur les données ; Une variable de type classe est créée par instantiation d une classe ; chaque variable possède donc ses propres attributs mais partage les mêmes méthodes ; Sous VLE, la dynamique d un modèle est une classe ; à chaque modèle, on créé une instance de la dynamique. (LIL, INRA) Tutoriel GVLE 30 / 73

31 La dynamique Ecriture de la classe C++ Héritage class CropRoot : public vle:: extension:: DifferenceEquation:: Multiple L heritage permet à une classe d hériter des propriétés (attributs et méthodes) de ses classes mères ; Sous VLE, ça permet d offrir les mécanismes de couplage, de simulation,... pour un ensemble de formalismes tout en écrivant un minimum de choses ; Il "suffit" de déclarer quels attributs et d écrire quelques méthodes. (LIL, INRA) Tutoriel GVLE 31 / 73

32 La dynamique Ecriture de la classe C++ Visibilité public:... private:... La visibilité permet de déclarer que certains éléments (méthodes ou attributs) sont accessibles par d autres classes ; De manière générale, sous VLE, les méthodes liées à l héritage (par exemple, la méthode compute) et qui sont à écrire sont publiques ; Les méthodes que le modélisateur écrit en plus pour mieux structurer son code, sont privées ; Les attributs sont privées. (LIL, INRA) Tutoriel GVLE 32 / 73

33 La dynamique Ecriture de la classe C++ Constructeur / destructeur CropRoot(const vle:: devs:: DynamicsInit& init, const vle:: devs:: InitEventList& events) : vle:: extension:: DifferenceEquation:: Multiple(init, events) { } virtual ~CropRoot() {}; Le constructeur est une méthode spéciale qui est appelée à la création d une variable de type classe et a pour nom le nom de la classe ; Le destructeur est appelé lorsque la variable est détruite ; Sous VLE, le constructeur est toujours écrit de la même manière et le destructeur ne fait jamais rien sauf si le modélisateur utilise des allocations dynamiques (non recommandé!). (LIL, INRA) Tutoriel GVLE 33 / 73

34 La dynamique Ecriture de la classe C++ Méthodes virtual void compute(const vle:: devs:: Time& time) { } virtual void initvalue(const vle:: devs:: Time& time) { } Une méthode est une fonction qui s applique sur les données de la classe (les attributs) ; Sous VLE, chaque extension propose d écrire certaines méthodes : par exemple, compute et initvalue pour DifferenceEquation. Paramètres Dans l exemple, on passe en paramètre une variable de type Time (une classe de VLE qui représente le temps - une date ou une durée) qui est déclarée constante - on ne peut pas la modifier. (LIL, INRA) Tutoriel GVLE 34 / 73

35 La dynamique Ecriture de la classe C++ Attributs Un attribut est une donnée appartient à une classe ; Chaque variable créé à partir d une classe possède ses propres attributs ; Sous VLE, on préconise de déclarer les attributs en privé ; Un attribut peut représenter l état ou un paramètre du modèle. (LIL, INRA) Tutoriel GVLE 35 / 73

36 La dynamique Définition et initialisation des paramètres CropRoot(const vle:: devs:: DynamicsInit& init, 3 const vle:: devs:: InitEventList& events) : 4 vle:: extension:: DifferenceEquation:: Multiple(init, events) 5 { 6 minitdepth = vle:: value:: todouble(events.get(" initdepth")); 7 msoildepth = vle:: value:: todouble(events.get(" soildepth")); 8 mmaxdepth = vle:: value:: todouble(events.get("maxdepth")); 9 mratedepth = vle:: value:: todouble(events.get(" ratedepth")); 0 } private: 3 double minitdepth, msoildepth, mmaxdepth, mratedepth; 4 }; 5... Pour chaque paramètre, il faut déclarer un attribut (double minitdepth) et récupérer sa valeur dans le constructeur via la liste des événements d initialisation. La chaîne de caractères passe en paramètre de la méthode get sera réutilisée dans la partie Conditions. (LIL, INRA) Tutoriel GVLE 36 / 73

37 La dynamique Définition et initialisation des paramètres Il est possible de définir des valeurs par défaut aux paramètres en cas d absence du paramètre dans le fichier de définition de l expérience. minitdepth = events.exist(" initdepth")? vle:: value:: todouble(events.get(" initdepth")) : 100; (LIL, INRA) Tutoriel GVLE 37 / 73

38 La dynamique Les paramètres liés à l extension CropRoot(const vle:: devs:: DynamicsInit& init, 3 const vle:: devs:: InitEventList& events) : 4 vle:: extension:: DifferenceEquation:: Multiple(init, events) 5 { RootDepth = createvar(" RootDepth"); 8 DvtStade = createsync("dvtstade"); 9 TT = createsync("tt"); 0 } private: Var RootDepth; 5 Sync DvtStade, TT; 6 }; L extension DifferenceEquation impose certaines déclarations d attributs de type Var et Sync pour la représentation des variables d état et externes de l équation. (LIL, INRA) Tutoriel GVLE 38 / 73

39 La dynamique Les méthodes liées à l extension virtual void compute(const vle:: devs:: Time& time) 3 { 4 RootDepth = 0; 5 } 6 virtual void initvalue(const vle:: devs:: Time& time) 7 { 8 RootDepth = 0; 9 } 0... Pour l instant, nous allons mettre que la variable du modèle vaut toujours zéro. Le code C++ est maintenant prêt! (LIL, INRA) Tutoriel GVLE 39 / 73

40 La dynamique Ecriture de la classe C++ Saisir le code C++ dans CropRoot.cpp et File Save (ou CTRL + S). (LIL, INRA) Tutoriel GVLE 40 / 73

41 La dynamique Ecriture de la classe C++ Ouvrir le fichier CMakeLists.txt du répertoire src, changer emptylibrary par CropRoot et simple.cpp par CropRoot.cpp. (LIL, INRA) Tutoriel GVLE 41 / 73

42 La dynamique Ecriture de la classe C++ Ouvrir le fichier CMakeLists.txt à la racine du projet, changer emptyproject par 2CV, le nom du projet. (LIL, INRA) Tutoriel GVLE 42 / 73

43 La dynamique Ecriture de la classe C++ CMake La compilation est prise en charge par les outils cmake, make et g++. CMakeLists.txt Le fichier CMakeLists.txt définit les bibliothèques qui sont à produire à partir des sources C++ ; Pour chaque modèle, une bibliothèque sera créée ; il est donc nécessaire d avoir : ADD_LIBRARY : liste des fichiers C++ de la bibliothèque (normalement, il y a qu un seul fichier) ; TARGET_LINK_LIBRARY : liste des bibliothèques nécessaires au modèle ; INSTALL : le répertoire d installation (lib). (LIL, INRA) Tutoriel GVLE 43 / 73

44 La dynamique Ecriture de la classe C++ Project Configure puis Project Build. La partie inférieure de gvle présente les résultats de la compilation. (LIL, INRA) Tutoriel GVLE 44 / 73

45 La dynamique Affectation de la dynamique au modèle File Open VPZ (ou CTRL + shift + O) puis sélectionner 2CV.vpz puis double clic sur le modèle CropRoot puis activer l onglet Dynamics. Nous allons définir une dynamique et l attacher au modèle. (LIL, INRA) Tutoriel GVLE 45 / 73

46 La dynamique Affectation de la dynamique au modèle Clic droit dans Dynamics list puis Add puis saisir le nom de la dynamique (dynroot) et valider. Il faut maintenant faire le lien avec la classe C++. (LIL, INRA) Tutoriel GVLE 46 / 73

47 La dynamique Affectation de la dynamique au modèle Choisir 2CV dans la liste Package, puis choisir CropRoot dans la liste Library. Le champ Model n est pas renseigné car il n y a qu une classe par bibliothèque. (LIL, INRA) Tutoriel GVLE 47 / 73

48 La dynamique Affectation de la dynamique au modèle Les macros de déclaration Afin de déclarer une classe C++ comme une dynamique utilisable dans un modèle de simulation, il faut utiliser la macro DECLARE_DYNAMICS ; Le paramètre de la macro est le nom de la classe C++. Il est possible de mettre plusieurs classes dans une même bibliothèque en utilisant la macro DECLARE_NAMED_DYNAMICS(nom, nom de la classe) au lieu de DECLARE_DYNAMICS(nom) ; Le paramètre nom permet d attacher un identifiant à la classe C++ (très souvent identique au nom de la classe) ; Cet identifiant est utilisé dans le champ Model de la boîte dialogue de définition d une dynamique. (LIL, INRA) Tutoriel GVLE 48 / 73

50 Les conditions Une condition est un ensemble de paramètres associés à une ou plusieurs valeurs ; Les valeurs sont de type simple (double, integer, boolean et string) ou complexe : set : une liste de valeurs quelconques ; tuple : une liste de réels ; matrix : une matrice de valeurs quelconques ; table : une matrice de réels ; map : un tableau associatif ; xml. (LIL, INRA) Tutoriel GVLE 50 / 73

51 Les conditions Il existe deux stratégies de création des conditions : "à la main" : après la création d une condition et d un paramètre, on définit le type et sa ou ses valeurs ; avec un plugin : avec les extensions, il existe des plugins qui aident à la création des conditions. Il existe aussi deux types de paramètres : les hérités : ceux provenant des extensions ou des modèles génériques ; ceux définis dans la classe du modèle et affectés dans le constrcuteur. (LIL, INRA) Tutoriel GVLE 51 / 73

52 Les conditions Création d une condition Simulation Conditions (ou CTRL + shift + C). On obtient la liste des conditions définis dans le VPZ courant. (LIL, INRA) Tutoriel GVLE 52 / 73

53 Les conditions Création d une condition Clic droit dans la colonne Initial conditions puis Add puis saisir condroot puis Clic droit dans la colonne Initial conditions puis Edit puis DifferenceEquationMultiple. (LIL, INRA) Tutoriel GVLE 53 / 73

54 Les conditions Création d une condition Décocher Global? puis spécifier le pas de temps de l équation ; Cocher Port pour indiquer que les ports d entrée ont pour nom le nom des variables dont l équation dépend ; Ajouter dans la liste Variables le nom de la variable de l équation (RootDepth) : clic droit puis Add puis saisir RootDepth puis Valider (on ne donne pas de valeur d initialisation). (LIL, INRA) Tutoriel GVLE 54 / 73

55 Les conditions Création d une condition Trois paramètres spécifiques à l extension DifferenceEquation viennent d apparaître dans la condition condroot. Il faut maintenant ajouter les paramètres de l équation. (LIL, INRA) Tutoriel GVLE 55 / 73

56 Les conditions Création d une condition Clic droit dans Parameters puis Add puis saisir initdepth puis Valider puis clic droit dans la 3ème colonne puis Add puis Double. (LIL, INRA) Tutoriel GVLE 56 / 73

57 Les conditions Création d une condition Par défaut, un paramètre de type Double a pour valeur 0 ; On modifie sa valeur en double-cliquant dessus ; Le clic droit sur la 3ème colonne permet de supprimer une valeur ; Une condition et un paramètre peut être supprimer et renommer. Il faut réitérer le même processus pour les 3 autres paramètres ; Il reste une dernière manipulation : rattacher la condition créée au modèle ; Il est aussi possible de séparer les conditions liées à l extension DifferenceEquation des conditions liées au modèle, il faut pour cela : créer une nouvelle condition et y définir les paramètres ; attacher les deux conditions au modèle. (LIL, INRA) Tutoriel GVLE 57 / 73

58 Les conditions Création d une condition Double clic sur le modèle CropRoot puis activer l onglet Conditions puis cocher la condition CondRoot. (LIL, INRA) Tutoriel GVLE 58 / 73

60 L expérience Une expérience se compose d un modèle, de conditions expérimentales et d observations ainsi que d informations complémentaires (durée, graines, auteurs, version,... ). Durée et début La durée d une expérience est un nombre réel qui représente le nombre d unité de temps de la simulation ; l unité n est pas définie mais il peut être le jour ; Par défaut, la simulation commence à 0 ; on peut spécifier un début soit quelconque (même négatif) soit selon un calendrier (en jour julien) l unité du temps est alors le jour. Graines Si votre modèle est stochastique, il est possible de fixer les graines utilisées par les générateurs aléatoires de VLE. Les graines permettent de réitérer les simulations avec les mêmes séries aléatoires. (LIL, INRA) Tutoriel GVLE 60 / 73

61 L expérience Simulation Project ; Fixer l auteur ; Fixer la date de création ou de mise à jour ; Fixer la version du modèle ; Donner un nom à l expérience (ce nom est réutilisé pour les fichiers de résultats) ; Fixer la durée de la simulation (sans début pour l instant) ; (LIL, INRA) Tutoriel GVLE 61 / 73

62 L expérience La grain (seed) n est pas nécessaire ; On peut maintenant lancer la simulation. Naturellement, aucune sortie n aura lieu. (LIL, INRA) Tutoriel GVLE 62 / 73

63 L expérience Lancement de la simulation Simulation Launch Simulation (ou CTRL + shift + L) puis clic sur le bouton avec le triangle. (LIL, INRA) Tutoriel GVLE 63 / 73

65 Les vues Une vue est une série d observations réalisées sur les modèles atomiques ; Une vue est associée à un format de sortie : soit de type fichier (texte, csv, rdata) ; soit de type graphique (cairoplot, cairocaview,... ) ; soit de type storage (pour manipuler les données de sorties sous R ou en Python). Observation Un modèle est observé via des observables ; Un observable est une liste de ports d observation ; Un modèle répond aux observations via la notion de port ; Un port d observation est rattaché à une ou plusieurs vues. (LIL, INRA) Tutoriel GVLE 65 / 73

66 Les vues Création d une vue Simulation Views (ou CTRL + shift + V) puis clic droit sur la liste Views puis Add puis choisir csv dans la liste Output type. (LIL, INRA) Tutoriel GVLE 66 / 73

67 Les vues Type de vues Il existe trois types de vues : timed : le modèle est observé selon un certain pas de temps (Timestep) ; event : le modèle est observé à chaque événement ; finish : le modèle est observé à la fin de la simulation. Destination La sortie peut se faire : soit localement (par défaut, dans le répertoire output) ; soit à distance via oov ou eov. Output type Le choix des types de sortie se fait à l aide d une liste et certains types étant complexes, disposent un plugin de configuration. (LIL, INRA) Tutoriel GVLE 67 / 73

68 Les vues Création de l observable Double clic sur le modèle CropRoot puis activer l onglet Views puis Add puis saisir obsroot puis clic droit sur obsroot puis Edit. (LIL, INRA) Tutoriel GVLE 68 / 73

69 Les vues Création de l observable Clic droit sur la liste ObservablePorts puis Add puis saisir RootDepth puis drag n grop de ViewRoot sur RootDepth. Le port observé possède le même nom que la variable du modèle (c est une convention liée à l extension DifferenceEquation). (LIL, INRA) Tutoriel GVLE 69 / 73

71 Le couplage La construction d un modèle global passe par le couplage de modèles atomiques et la construction de modèles couplés ; Coupler deux modèles consiste à connecter un port de sortie d un modèle à un port d entrée d un autre modèle ; Au préalable, il faut avoir créé quelques modèles atomiques supplémentaires. Tools Add links (ou F3 ou clic sur l icône avec une prise électrique) puis clic sur le modèle source puis tout en maintenant le bouton de la souris apppuyé, relacher le bouton lorsque la souris est sur le modèle destination. (LIL, INRA) Tutoriel GVLE 71 / 73

72 Le couplage (LIL, INRA) Tutoriel GVLE 72 / 73

73 Tutoriel GVLE Auteurs Gauthier Quesnel Éric Casellas Éric Ramat Licence Copyright (C) INRA - LIL Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the section entitled "GNU Free Documentation License". (LIL, INRA) Tutoriel GVLE 73 / 73