Ce tutoriel vous conduit à travers le processus de réalisation d'un modèle complet, construit étape par étape, chaque étape étant expliquée pas à pas.
Dans le Tutoriel 2, vous avez appris à utiliser le Centre de commande et les Moniteurs d'agent pour inspecter et modifier les agents et les obliger à faire certaines choses. Nous sommes maintenant prêts pour apprendre à utiliser le véritable coeur des modèles NetLogo : le panneau des Procédures "Procedures".
Vous avez déjà utilisé des types d'agents auxquels vous pouvez donner des commandes en NetLogo : les patches, les tortues, les liens et l'observateur. Les patches sont immobiles et disposés sur une grille. Les tortues se déplacent sur cette grille. Les liens établissent une connection entre deux tortues. L'observateur surveille (et voit) tout ce qui se passe et fait tout ce que les tortues, les patches ou les liens ne peuvent pas faire eux-mêmes.
Tous les agents appartenant à ces quatre types peuvent exécuter des primitives NetLogo. Et tous les quatre peuvent aussi exécuter des procédures. Une procédure, que vous devez définir, réunit une série de commandes NetLogo pour n'en former plus qu'une seule.
Vous allez maintenant apprendre à écrire des procédures qui font bouger les tortues, les font manger, se reproduire et mourir. Vous allez aussi apprendre comment créer des moniteurs, des curseurs et des trapceurs de courbes. Le modèle que nous allons construire est un modèle d'un écosystème simple, un peu dans le genre du modèle Prédation Loups-Moutons du Tutoriel 1.
Pour créer un nouveau modèle, sélectionnez "New" dans le menu "File". Puis commencez par créer un bouton d'initialisation "PREPARER" :
- Cliquez l'icône "Button" dans la barre d'outils placée au sommet du panneau "Interface".
- Cliquez dans la zone vide, blanche, du panneau "Interface", là où vous voulez mettre le bouton.
- Une boîte de dialogue d'édition de bouton s'ouvre. Écrivez PREPARER dans le champ texte appelé "Commands".
- Pressez le bouton "OK" quand vous avez terminé. La boîte de dialogue se ferme.
Vous avez maintenant un bouton "PREPARER" (setup). Presser ce bouton devrait déclencher l'exécution d'une procédure PREPARER. Une procédure est une séquence de commandes NetLogo à laquelle un nouveau nom a été donné. Mais nous n'avons pas encore défini cette procédure (nous le ferons bientôt). Puisque le bouton fait référence à une procédure qui n'existe pas encore, son intitulé est rouge (tout comme le texte de l'onglet "Interface") :
Si vous voulez voir le message d'erreur, cliquez le bouton.
Nous allons maintenant créer la procédure PREPARER, ce qui fera disparaître le message d'erreur :
- Allez dans le panneau "Procedures".
- Écrivez les lignes de code suivantes :
to PREPARER clear-all create-turtles 100 ask turtles [ setxy random-xcor random-ycor ] end
Quand vous avez terminé, le panneau "Procedures" ressemble à ceci :
Notez que certaines lignes sont indentées à différents degrés. La plupart des programmeurs trouvent utile d'indenter leur code de cette manière, mais ce n'est pas une obligation. Cela rend le code plus facile à lire (et donc à comprendre) et à modifier. La procédure commence par le mot to et se termine par le mot end. Toute nouvelle procédure que vous créez devra commencer et se terminer par ces deux mots.
Examinons ce que vous avez écrit et voyons ce que fait chaque ligne de cette procédure :
Quand vous aurez fini d'écrire, revenez dans le panneau "Interface". Remarquez que les intitulés rouges sont redevenus noirs car le bouton "PREPARER" a maintenant une procédure PREPARER à laquelle s'adresser.
Pressez le bouton "PREPARER" et vous verrez toutes les tortues se disperser dans leur monde.
Pressez le bouton "PREPARER" encore quelques fois et observez comment les positions des tortues sont à chaque fois différentes. Notez que certaines tortues peuvent se retrouver « à cheval » sur d'autres tortues.
Réfléchissez un petit peu à ce que vous avez dû faire pour arriver à ce résultat. Vous avez dû placer un bouton dans l'interface et créer une procédure que ce bouton utilise (appelle). Le bouton ne fonctionne qu'une fois ces deux opérations distinctes achevées. Dans la suite de ce tutoriel, vous aurez souvent à accomplir deux ou plusieurs étapes semblables pour ajouter une nouvelle fonctionnalité au modèle. Si quelque chose semble ne pas fonctionner une fois terminé ce qui vous semble être la dernière étape de l'élaboration d'une nouvelle fonctionnalité, continuez de lire plus loin pour voir s'il n'y a pas encore quelque chose à faire. Une fois que vous aurez lu quelques paragraphes, reprenez en sens inverses les différentes directives pour voir si vous n'auriez pas oublié une étape.
Créez maintenant un bouton appelé "GO". Suivez les mêmes étapes que celles accomplies pour créer le bouton "PREPARER", sauf :
- Dans "Commands" entrez GO au lieu de PREPARER.
- Cochez le bouton "Forever" dans la boîte de dialogue "Button".
L'activation du bouton "Forever" force le bouton "GO" à rester enfoncé une fois qu'il a été pressé, ce qui fait que ses commandes seront exécutées en boucle (encore et encore) et pas seulement une fois.
to GO bouge-tortues end
Mais qu'est-ce que bouge-tortues? Est-ce une primitive (en d'autres mots, une commande prédéfinie de NetLogo), comme l'est clear-all? Non, il s'agit d'une autre procédure que vous devrez créer. Jusqu'ici, vous avez déjà ajouté deux procédure que vous avez créées : PREPARER et GO.
- Ajoutez la procédure bouge-tortues en dessous de la procédure GO :
to GO bouge-tortues end
to bouge-tortues ask turtles [ right random 360 forward 1 ] end
Notez qu'il n'y a pas d'espaces autour du tiret dans bouge-tortues. Dans le Tutoriel 2 nous avions utilisé red - 2 avec des espaces autour du signe moins dans le but de soustraire deux nombres, mais ici, nous devons écrire bouge-tortues sans espaces. Le tiret "-" réunit les mots bouge et tortues en un seul mot.
Voici ce que fait chaque commande de la procédure bouge-tortues :
Pourquoi ne pourrions-nous pas tout simplement écrire toutes ces commandes dans la procédure GO plutôt que dans une procédure séparée? Nous aurions pu le faire, mais au cours du développement du projet, il est presque sûr que vous y ajouterez bien d'autres parties. Nous aimerions garder GO aussi simple que possible de manière à ce que cette procédure soit facilement compréhensible. Par la suite, ce modèle comportera bien d'autres choses que vous voudrez voir se faire quand la simulation tournera, telles que le calcul de certaines valeurs ou l'affichage de résultats. Chacune de ces choses à faire aura sa propre procédure et chaque procédure devra avoir son propre nom, unique dans le programme.
Le bouton "GO" que vous avez créé dans le panneau interface est un bouton « pour toujours », ce qui signifie qu'il exécutera continuellement ses commandes jusqu'à ce que vous le déclenchiez (en le cliquant une seconde fois). Après avoir pressé le bouton "PREPARER" une fois pour créer les tortues, pressez le bouton "GO". Observez ce qui se passe. Désactivez-le, et vous verrez que toutes les tortues s'arrêtent instantanément sur leur chemin.
Notez que si une tortue se déplace au-delà du bord du monde, elle «s'enroule», ce qui signifie qu'elle réapparaît au côté opposé. (C'est le comportement des tortues par défaut qui peut être modifié. Consultez à ce sujet la section Topologie du Guide de la programmation pour en savoir plus.)
Nous vous suggérons d'essayer d'autres commandes de tortue.
Écrivez des commandes (telles que turtles> set color red) dans le Centre de commande ou ajoutez des commandes aux procédures PREPARER, GO, ou bouge-tortues.
Notez que quand vous entrez des commandes dans le Centre de commande, vous devez sélectionner "turtles>", "patches>", ou "observer>" dans le menu placé à gauche, en fonction du type d'agents qui devra exécuter ces commandes. Cette manière de faire revient au même que de taper ask turtles ou ask patches, mais épargne des frappes claviers. Vous pouvez aussi utiliser la touche Tab pour passer d'un type d'agents à l'autre, ce que vous trouverez certainement plus pratique que l'utilisation du menu.
Essayer de taper turtles> pen-down dans le Centre de commande puis de pressez le bouton "GO".
De même, dans la procédure bouge-tortues , essayez de remplacer right random 360 par right random 45.
Amusez-vous. C'est facile et les résultats sont immédiatement visibles (caractéristique qui est l'un des nombreux points forts de NetLogo).
Quand vous aurez l'impression d'avoir fait (pour le moment) toutes les expérimentations que vous souhaitez, vous êtes prêts pour poursuivre l'amélioration du modèle que vous êtes en train de construire.
Nous avons maintenant 100 tortues qui errent sans but, ignorant absolument tout ce qui les entoure. Rendons les choses un peu plus intéressantes en donnant à ces tortues un joli arrière-plan sur lequel se déplacer.
- Revenez à la procédure PREPARER. Nous pouvons la modifier comme suit :
to PREPARER clear-all prepare-patches prepare-tortues end- La nouvelle définition de PREPARER fait appel à deux nouvelles procédures. Pour définir prepare-patches, ajoutez ceci :
to prepare-patches ask patches [ set pcolor green ] endLa procédure prepare-patches donne d'abord la couleur verte à chaque patch. (La variable servant à spécifier la couleur d'une tortue est color, celle pour la couleur d'un patch est pcolor.)
La seule partie encore non définie de notre nouvelle procédure "PREPARER" est prepare-tortues.
- Ajoutez aussi cette procédure :
to prepare-turtles create-turtles 100 ask turtles [ setxy random-xcor random-ycor ] endAvez-vous remarqué que la nouvelle procédure prepare-tortues a presque les même commandes que l'ancienne procédure PREPARER ?
- Revenez dans le panneau "Interface".
- Pressez le bouton "PREPARER".
Et voila! Un paysage NetLoGO luxuriant avec des tortues colorées et des patches verts apparaît :
Après avoir observé quelques fois le fonctionnement de la nouvelle procédure PREPARER, il ne serait pas inutile de relire encore une fois les définitions de toutes les procédures.
Nous avons maintenant quelques tortues qui courent encore et toujours sans buts dans toute la verte campagne, mais qui ne font rien de plus et ignorent complètement leur environnement. Ajoutons donc quelques interactions entre les tortues et les patches.
Nous allons faire en sorte que les tortues mangent de l'herbe (les patches verts), se reproduisent et meurent après un certain temps. L'herbe devra repousser petit à petit après avoir été mangée.
Nous avons besoin d'un moyen pour contrôler quand une tortue se reproduit et quand elle meurt. Nous allons déterminer ces moments en gardant la trace de la quantité « d'énergie » que possède chaque tortue. Cette valeur devra être stockée dans une variable tortue que nous appellerons energie.
Nous avons déjà rencontré des variables tortue prédéfinies telles que color. Toutefois, NetLogo ne connaît pas de variable tortue energie mais nous permet d'en créer une. en ajoutant la déclaration turtles-own au tout début du code (dans le panneau "Procedures"), avant les définitions de toutes les procédures :
- Revenez dans le panneau " Procedures ".
- Définissez la nouvelle variable energie au moyen de la déclaration turtles-own à la première ligne du code.
turtles-own [energie]
Utilisons cette nouvelle variable (energie) pour permettre aux tortue de manger.
- Récrivez la procédure GO de la manière suivante :
to GO bouge-tortues mange-herbe end- Ajoutez une nouvelle procédure mange-herbe :
to mange-herbe ask turtles [ if pcolor = green [ set pcolor black set energie (energie + 10) ] ] end
Nous utilisons la commande if pour la première fois. Examinez attentivement le code. Chaque tortue, quand elle exécute cette commande, compare la valeur de la couleur du patch (pcolor) sur lequel elle se trouve à la valeur de green, valeur numérique spécifiant la couleur verte de base dans NetLogo. (Une tortue a un accès direct aux variables du patch sur lequel elle se trouve.) Si la couleur du patch est green, la comparaison retourne true, et dans ce cas seulement la tortue exécutera les commandes qui sont entre les crochets (sinon, elle les saute). Ces commandes font que la tortue change la couleur du patch en noir et augmente sa réserve d'énergie de 10 unités. La patch devient noir pour montrer que l'herbe qu'il portait a été mangée et que la tortue a gagné de l'énergie car elle vient de manger l'herbe.
Puis faisons en sorte que les mouvements des tortues consomment un peu de cette énergie.
- Réécrivez bouge-tortues de la manière suivante :
to bouge-tortues ask turtles [ right random 360 forward 1 set energie energie - 1 ] end
Maintenant, quand une tortue se déplace, elle perd une unité d'énergie à chaque pas.
- Passez dans le panneau "Interface" et pressez les boutons "PREPARER" puis "GO".
Vous verrez les patches devenir noirs quand les tortues leur passent dessus.
![]()
Nous allons ensuite placer deux moniteurs dans le panneau "Interface" à l'aide de la barre d'outils. (Ils se construisent exactement de la même manière que les boutons et les curseurs, en utilisant le menu déroulant de la barre d'outils). Créons le premier moniteur.
- Créez un moniteur en ouvrant le menu déroulant de la barre d'outils et en y sélectionnant la commande "Monitor", puis cliquez dans une zone non occupée de l'Interface pour le placer.
Une boîte de dialogue apparaît.
- Écrivez count turtles dans la zone "Reporter" de cette boîte de dialogue (voir l'image ci-dessous).
- Écrivez Nombre d'animaux dans le champ "Display name"
- Pressez le bouton "OK" pour fermer la boîte de dialogue.
Dans ce que vous venez d'écrire turtles est un « ensemble d'agents », ici, l'ensemble de toutes les tortues et count nous indique combien d'agents il y a dans cet ensemble.
Construisons maintenant le second moniteur :
- Créez un moniteur en utilisant le bouton "Add" de la barre d'outils et cliquez dans une zone non occupée de l' "Interface" pour le placer (Ce bouton permet d'ajouter un contrôle de type affiché dans le menu placé à sa droite.).
Une boîte de dialogue apparaît.
- Dans la zone "Reporter" de la boîte de dialogue, écrivez : count patches with [pcolor = green]
- Dans la zone "Display name" de la boîte de dialogue, écrivez : Carrés d'herbe
- Pressez le bouton "OK" pour fermer la boîte de dialogue.
Ici, nous utilisons encore une fois count pour voir combien il y a d'agents dans un ensemble d'agents. patches est l'ensemble de tous les patches, mais nous ne voulons justement pas savoir combien il y a de patches au total; nous voulons savoir combien de patches ont de l'herbe, donc combien il y a de patches verts. C'est ce que fait with. Il construit un sous-ensemble d'agents constitué uniquement des agents pour lesquels la condition formulée entre crochets est vraie. Cette condition étant pcolor = green, with nous retourne bien le nombre de patches verts.
Il y a maintenant deux moniteurs qui vont nous indiquer combien de tortues et combien de patches verts nous avons, dans le but de nous aider à suivre ce qui se passe au cours de la simulation. Les valeurs affichées dans les moniteurs sont automatiquement mises à jours tout au long de la simulation.
- Utilisez les boutons "PREPARER" et "GO" et observez comment l'affichage des valeurs change dans les moniteurs.
Les tortues ne se contentent pas de changer la couleur des patches en noir, elles gagnent et perdent aussi de l'énergie. Essayez d'utiliser un moniteur tortue pour voir l'augmentation ou la diminution d'énergie d'une tortue au cours de la simulation.
Ce serait une bonne chose de pouvoir prendre connaissance à tout moment de l'énergie propre à chaque tortue. Et c'est exactement ce que nous allons faire en ajoutant un commutateur (switch) afin de pouvoir activer ou désactiver l'affichage de ces informations.
- Pour créez un commutateur, sélectionnez la commande "Switch" dans le menu déroulant de la barre d'outils du panneau "Interface" et cliquez dans une zone non occupée de l'Interface pour placer ce commutateur.
Une boîte de dialogue apparaît.
- Ecrivez AFFICHER_ENERGIE? dans le champ "Global variable" de la boîte de dialogue et n'oubliez pas de mettre le point d'interrogation à la suite du nom. (Voir l'image ci-dessous.)
- Retournez maintenant à la procédure mange-herbe (dans le panneau "Procedures").
- Modifiez la procédure mange-herbe comme suit :
to mange-herbe ask turtles [ if pcolor = green [ set pcolor black set energie (energie + 10) ] ifelse AFFICHER_ENERGIE? [ set label energie ] [ set label "" ] ] end
La procédure mange-herbe utilise la commande ifelse. Examinez soigneusement le code. Chaque tortue, quand elle exécute cette nouvelle commande, teste la valeur de AFFICHER_ENERGIE? (qui est déterminée par la position du commutateur). Si le commutateur est enclenché, la comparaison est vraie et la tortue exécute les commandes qui sont à l'intérieur de la première paire de crochets. Dans ce cas, elle transmet la valeur de l'énergie de la tortue à l'étiquette de cette tortue. Si la comparaison est fausse (le commutateur est déclenché), la tortue exécute les commandes placées dans le seconde paire de crochets. Dans ce cas, elle efface le texte de l'étiquette (en demandant à l'étiquette d'afficher une chaîne de caractères vide)
En NetLogo, un bout de texte est appelé une chaîne de caractères ou plus simplement une chaîne (string). Une chaîne est une suite de lettres et/ou d'autres caractères, écrits entre des guillemets anglais doubles. Ici, nous avons deux doubles guillemets qui se suivent sans aucun espace entre eux. C'est une chaîne vide. Si une étiquette de tortue reçoit une chaîne vide, elle n'affiche rien et aucun texte n'est attaché à la tortue.)
- Testez ces modifications dans le panneau "Interface" en faisant tourner la simulation (utilisez les boutons "PREPARER" et "GO", puis enclenchez et déclenchez le commutateur AFFICHER_ENERGIE?).
Quand ce commutateur est enclenché, vous verrez l'énergie de chaque tortue augmenter chaque fois qu'elle mange de l'herbe. Vous verrez aussi son énergie diminuer chaque fois qu'elle se déplace.
Maintenant que nos tortues peuvent manger, faisons en sorte qu'elles puissent aussi se reproduire et même mourir. Il serait bien aussi que l'herbe puisse repousser. Nous allons ajouter ces trois comportements en créant trois procédures distinctes, une pour chaque comportement.
- Allez dans le panneau "Procedures".
- Complétez la procédure GO de la manière suivante :
to GO bouge-tortues mange-herbe reproduit-mouton teste-mort repousse-herbe end- Ajouter les procédures reproduit-mouton, teste-mort et repousse-herbe ci-dessous :
to reproduit-mouton ask turtles [ if energie > 50 [ set energie energie - 50 hatch 1 [ set energie 50 ] ] ] end
to teste-mort ask turtles [ if energie <= 0 [ die ] ] end
to repousse-herbe ask patches [ if random 100 < 3 [ set pcolor green ] ] end
Chacune de ces procédures utilise la commande if. Chaque tortue, quand elle exécute reproduire-mouton, teste la valeur de la variable energie de la tortue. Si cette valeur est plus grande que 50, alors la tortue exécute les commandes placées à l'intérieur de la première paire de crochets. Dans ce cas, ces commandes diminuent l'énergie de la tortue de 50 unités puis font naître une nouvelle tortue dotée de 50 unités d'énergie. La commande hatch est une primitive NetLogo qui s'utilise selon le schéma : hatch nombre [ commandes ]. Cette tortue crée nombre nouvelles tortues, chacune identique à son parent, et demande à la (aux) nouvelle(s) tortue(s) qui a (ont) été créée(s) d'exécuter les commandes. Vous pouvez utiliser ces commandes pour donner aux nouvelles tortues d'autres couleurs, d'autres caps ou n'importe quoi d'autre. Dans notre cas, nous n'exécutons qu'une seule commande : nous donnons à la nouvelle tortue 50 unités d'énergie.
Quand chaque tortue exécute teste-mort, elle fait un test pour voir si son énergie est inférieure ou égale à 0. Si le test est vrai, la tortue doit exécuter die (c'est-à-dire mourir). (die est une primitive de NetLogo.)
Quand chaque patch exécute repousse-herbe, il fait un test pour voir si un nombre entier, généré aléatoirement entre 0 et 99, est inférieur à 3. Si c'est le cas, le patch retrouve une couleur verte. La probabilité de ce changement de couleur est en moyenne de 3%. Un patch « passe » 3% de son temps à verdir, puisqu'il y a trois nombres (0, 1 et 2), sur les 100 possibles, qui sont inférieurs à 3.
- Revenez dans le panneau "Interface" et pressez les boutons "PREPARER" et "GO".
Vous devriez maintenant observer un certain nombre de comportements intéressants au cours de la simulation. Certaines tortues meurent, d'autres sont créées (naissent) et l'herbe de certains patches repousse. C'est exactement ce que nous avons essayé d'obtenir.
Si vous observez les moniteurs pendant un certain temps, vous verrez que les valeurs affichées dans "Nombre d'animaux" et dans "Carrés d'herbe" varient au cours de la simulation. Est-ce que ces fluctuations obéissent à un certain schéma et est-ce que ce schéma est prévisible? Y a-t-il un lien de cause à effet entre ces deux variables?
Il serait intéressant d'avoir un moyen plus pratique de suivre les fluctuations de certaines variables du modèle au cours du temps. NetLogo nous offre la possibilité d'afficher les données sous forme de courbes en fonction du temps, et ce pendant tout le déroulement de la simulation. Ce sera notre prochaine étape.
Pour pouvoir afficher des graphiques, nous devons d'abord créer un «grapheur» dans le panneau "Interface" et y faire quelques réglages. Nous devrons aussi ajouter une procédure supplémentaire dans le panneau "Procedures", procédure dont la fonction sera de tenir le graphique à jour.
Commençons par le panneau Procédure.
- Modifiez PREPARER pour qu'elle appelle une nouvelle procédure, dessine-graphes, que nous créerons dans un moment :
to PREPARER clear-all prepare-patches prepare-tortues dessine-graphes end- Modifiez aussi GO pour appeler la procédure dessine-graphes :
to GO bouge-tortues mange-herbe reproduit-mouton teste-mort repousse-herbe dessine-graphes end- Ajoutez maintenant la nouvelle procédure. Nous allons représenter graphiquement le nombre de tortues et le nombre de patches verts en fonction du temps. À chaque cycle (un cycle correspondant à une seule exécution de la procédure GO ), les valeurs calculées sont ajoutées aux graphiques du traceur.
to dessine-graphes set-current-plot "Totaux" ;; le traceur set-current-plot-pen "turtles" ;; le crayon pour les tortues plot count turtles ;; dessiner la courbe des tortues set-current-plot-pen "grass" ;; le crayon pour l'herbe plot count patches with [pcolor = green] ;; dessiner la « quantité » d'herbe end
Notez que nous utilisons la commande plot pour ajouter le point suivant au graphique. Toutefois, avant de pouvoir le faire, nous devons dire deux choses à NetLogo. Premièrement, nous devons spécifier quel traceur nous voulons utiliser (puisque par la suite notre modèle pourrait avoir plus d'un traceur), et deuxièmement nous devons spécifier quel crayon nous voulons utiliser pour tracer la courbe (nous utiliserons deux crayons dans ce traceur).
La commande plot déplace le crayon de la courbe courante sur le point dont la coordonnée X est d'une unité supérieure à la coordonnée X du point précédent et dont la coordonnée Y correspondant à la valeur transmise à la commande plot (dans le premier cas, le nombre de tortues, dans le second cas, le nombres de patches verts). Quand les crayons se déplacent, ils dessinent chacun leur propre ligne.
Pour que la commande set-current-plot "Totaux" puisse fonctionner, vous devez ajouter un traceur dans le panneau "Interface" du modèle, puis le paramétrer de manière à ce que son nom soit le même que le nom utilisé dans la procédure, ici Totaux. Même un espace non prévu dans le nom suffit à le faire rejeter : il doit être orthographié exactement de la même manière aux deux endroits.
- Créez un grapheur en utilisant la commande "Plot" du menu "Add" de la barre d'outils puis cliquez dans un endroit libre de l'Interface.
- Écrivez le nom Totaux dans le champ "Name" (voir l'image ci-dessous).
- Écrivez temps dans le champ "X axis label".
- Écrivez totaux dans le champ "Y axis label".
Vous devez ensuite créer les deux crayons.
- Dans la boîte de dialogue "Plot" toujours ouverte, pressez le bouton "Create" pour créer un nouveau crayon.
- Entrez turtles, le nom de ce crayon, dans le champ "Enter a name for the pen:" de la boîte "Enter Pen Name" et pressez "OK" (voir image ci-dessous).
- Pressez encore une fois le bouton "Create" de la boîte de dialogue "Plot" pour créer un second crayon.
- Entrez grass, le nom de ce crayon, dans le champ "Enter a name for the pen:" de la boîte "Enter Pen Name" et pressez "OK" (voir image ci-dessous).
- Cliquez le menu "Color" de la boîte "Plot" et sélectionnez "green" dans le menu qui s'ouvre pour que la courbe de l'herbe soit verte.
- Cliquez "OK" pour valider et fermer la boîte de dialogue "Plot".
Notez que, quand vous créez et paramétrez un traceur, vous pouvez aussi spécifier les valeurs maximales et maximales pour les axes X et Y. Vous pouvez aussi laisser la coche dans la case à cocher "Autoplot?" de manière à ce que si les valeurs à représenter dépassent les valeurs minimales et/ou maximales de ces axes, l'échelle de ceux-ci s'adapte automatiquement afin que toutes les données puissent êtres affichées.
- Initialisez (bouton "PREPARER") et lancez (bouton "GO") la simulation encore une fois.
Vous pouvez maintenant voir les graphiques se dessiner au fur et à mesure que la simulation se déroule. Le traceur devrait ressembler à celui montré ci-dessous, mais il ne doit pas en être la copie conforme.
Rappelez-vous que nous avions laissé "Autoplot?" actif, ce qui permet au graphe de se réajuster lorsque les valeurs deviennent trop grandes.
Remarque : La case à cocher "Show legend" de la boîte de dialogue "Plot" permet d'activer ou de désactiver l'affichage des légendes des courbes dans la marge droite du grapheur. Cette boîte de dialogue peut en tout temps être ouverte par un clic droit sur le grapheur et la sélection de la commande "Edit..." dans le menu qui s'affiche.
Vous devriez faire tourner la simulation plusieurs fois de suite pour voir quels aspects des courbes sont constants et quels aspects changent au gré des simulations.
Pour pouvoir comparer les graphes obtenus par plusieurs simulations successives, il est souvent utile de comparer des simulations de même durée. Savoir comment stopper ou démarrer une action à un moment spécifique peut y contribuer en arrêtant la simulation au même endroit lors chaque passe. Garder la trace du nombre de fois que la procédure GO a été exécutée est un moyen utile pour intercaler de telles actions.
Pour garder cette trace, nous utiliserons le compteur de cycles interne de NetLogo.
- Modifiez la procédure GO de la manière suivante :
to go if ticks >= 500 [ stop ] bouge-tortues mange-herbe reproduit-mouton teste-mort repousse-herbe tick ;; faire avancer d'un pas le compteur de cycle dessine-graphes end- Initialisez (bouton "PREPARER") et lancez (bouton "GO") la simulation.
Maintenant, la simulation et le dessin des graphiques ne se poursuivent plus jusqu'à l'infini. Ils s'arrêtent automatiquement lorsque le compteur de cycles de la barre d'outils du panneau "Interface" atteint 500.
La commande tick avance le compteur de cycles par pas de 1. ticks est un reporter qui retourne la valeur courante du compteur de cycle. clear-all de la procédure PREPARER se charge de remettre de compteur de cycles à 0 quand on démarre une nouvelle simulation.
Notez que nous avons mis tick avant dessine-graphes. Nous procédons ainsi car si nous écrivons du code pour un traceur qui utilise la valeur du compteur de cycle, il verra la nouvelle valeur, pas l'ancienne. (Dans ce tutoriel, nous ne voulons pas écrire un code de ce type, mais quoi qu'il en soit, c'est une bonne habitude que d'appeler tick après que les agents aient fait leur travail mais avant que vous n'actualisiez les graphes.)
Maintenant que votre modèle utilise les cycles, vous voudrez probablement utiliser le menu placé dans le haut du panneau "Interface" pour passer d'une mise à jour continue ("continuous") à une mise à jour basée sur les cycles ("on ticks"). Cela signifie que NetLogo ne mettra à jour (c'est-à-dire ne redessinera) la Vue (autrement dit la zone dans laquelle vous voyez les agents) qu'à la fin de chaque cycle, jamais au milieu d'un cycle. Ce réglage permet une simulation plus rapide et assure une apparence consistante des résultats (puisque les rafraîchissements ne se font qu'à des moments précis). Voir le Guide de Programmation pour une discussion complète et approfondie du rafraîchissement de la vue.
Premièrement, plutôt que d'avoir toujours 100 tortues, vous pouvez spécifier un nombre de tortues variable.
- Créez un curseur de variable appelé "Nombre_tortues", au moyen de la commande "Monitor" de la barre d'outils, puis cliquez dans une zone libre de l'Interface. Essayez de modifier les valeurs maximales et minimales du curseur.
- Puis, dans le procédure prepare-tortues, remplacez create-turtles 100 de la manière suivante :
to prepare-tortues create-turtles Nombre_tortues ask turtles [ setxy random-xcor random-ycor ] end
Testez cette modification et comparez comment le fait d'avoir plus ou moins de tortues initiales affecte les courbes en fonction du temps.
Deuxièmement, ne serait-il pas intéressant de pouvoir modifier les quantités d'énergie que les tortues gagnent ou perdent quand elles mangent de l'herbe ou se reproduisent?
- Créez un curseur appelé energie-herbe.
- Créez un autre curseur appelé energie-reproduction.
- Puis, dans la procédure mange-herbe, apportez les modifications suivantes :
to mange-herbe ask turtles [ if pcolor = green [ set pcolor black set energie (energie + energie-herbe) ] ifelse AFFICHER_ENERGIE? [ set label energie ] [ set label "" ] ] end- Et modifiez la procédure reproduit-mouton de la manière suivante :
to reproduit-mouton ask turtles [ if energie > energie-reproduction [ set energie energie - energie-reproduction hatch 1 [ set energie energie-reproduction ] ] ] end
Finalement, quel autre curseur pourriez-vous ajouter pour agir sur la repousse de l'herbe? Y a-t-il des règles que vous pourriez ajouter aux déplacements des tortues ou au comportement des tortues nouveaux-nés qui ne s'appliqueraient qu'à certains moments? Essayez de les écrire.
Vous avez maintenant un modèle simple d'un écosystème. Les patches font pousser de l'herbe, les tortues se promènent, mangent de l'herbe, se reproduisent et meurent. Vous avez créé une interface contenant des boutons, des curseurs, des commutateurs et un traceur. Vous avez même écrit une série de procédures pour donner quelque chose à faire aux tortues.
C'est donc ici que ce tutoriel s'achève.
Si vous voulez consulter plus de documentation au sujet de NetLogo, la section Guide de l'interface de ce manuel vous emmène visiter tous les éléments de l'interface de NetLogo et vous en explique le fonctionnement. Pour une description détaillée sur la manière d'écrire des procédures, référez-vous au Guide de la programmation. Toutes les primitives sont décrites dans le Dictionnaire NetLogo.
Vous pouvez aussi continuer d'expérimenter et de compléter ce modèle si vous le désirez, en testant différentes variables et différents comportements pour les agents.
Mais vous pouvez aussi revoir le premier modèle de ces tutoriels, la Prédation Loups-Moutons. Il s'agit du modèle utilisé dans le Tutoriel 1. Dans ce modèle Prédation Loups-Moutons, vous avez vu des moutons se déplacer, consommer des ressources qui sont occasionnellement renouvelées (l'herbe), se reproduire dans certaines conditions, et mourir quand ils viennent à manquer de ressources. Mais ce modèle possède aussi un autre type de créatures, les loups. L'entrée en scène des loups demande quelques procédures supplémentaires et l'utiliation de quelques nouvelles primitives. Les loups et les moutons sont deux différentes « races » de tortues. Pour voir comment utiliser les races, étudiez le modèle Prédation Loups-Moutons.
Vous avez encore la possibilité d'étudier d'autres modèles (y compris les nombreux modèles de la section "Code Examples" de la Bibliothèque des modèles) ou même d'aller de l'avant et de construire vos propres modèles. Vous n'avez même pas besoin de modéliser quoi que ce soit. Il peut aussi être intéressant de simplement observer les patches et les tortues former des dessins, d'essayer de créer des jeux, ou encore de faire «n'importe quoi».
Espérons que vous avez appris certaines choses, aussi bien en langage NetLogo que dans la manière de s'y prendre pour créer des modèles. Toutes les procédures créées au cours de ce tutoriel sont regroupées (et commentées) ci-dessous.
Le code complet de ce modèle est aussi disponible dans la "Bibliothèque des modèles NetLogo", dans la section "Code Examples". Il est intitulé "Tutorial 3". Sa version française "Tutorial 3_fr.nlogo" se trouve dans le dossier "Code Examples-fr".
Notez que ce code est plein de commentaires, qui commencent par un point-virgule. Les commentaires permettent de placer des explications dans le code lui-même, aux endroits où elles sont le plus utiles. Vous pouvez utiliser les commentaires pour aider les autres à comprendre le fonctionnement de votre modèle ou tout simplement comme notes pour votre usage personnel.
Dans le panneau "Procedures", les commentaires sont affichés en gris afin qu'ils puissent être facilement repérés.
turtles-own [energie] ;; pour savoir quand la tortue est prête ;; pour se reproduire et quand elle doit mourir to PREPARER clear-all prepare-patches prepare-tortues dessine-graphes end to prepare-patches ask patches [ set pcolor green ] end to prepare-tortues create-turtles Nombre_tortues ;; utilise la valeur du curseur Nombre_tortues pour créer les tortues ask turtles [ setxy random-xcor random-ycor ] end to GO if ticks >= 500 [ stop ] ;; stoppe après 500 cycles bouge-tortues mange-herbe reproduit-tortue teste-mort repousse-herbe tick ;; augmente le compteur de cycle de 1 à chaque cycle dessine-graphes end to bouge-tortues ask turtles [ right random 360 forward 1 set energie energie - 1 ;; quand la tortue se déplace, elle perd 1 unité d'énergie ] end to mange-herbe ask turtles [ if pcolor = green [ set pcolor black ;; la valeur du curseur energie-herbe est ajoutée à energie set energie (energie + energie-herbe) ] ifelse AFFICHER_ENERGIE? [ set label energie ] ;; l'étiquette est réglée pour afficher la valeur de energie [ set label "" ] ;; l'étiquette reçoit une chaîne vide pour s'effacer ] end to reproduit-tortue ask turtles [ if energie > energie-reproduction [ set energie energie - energie-reproduction ;; ôte energie-reproduction pour donner une naissance hatch 1 [ set energie energie-reproduction ] ;; donne cette energie-reproduction au nouveau-né ] ] end to teste-mort ask turtles [ if energie <= 0 [ die ] ;; enlève la tortue si elle n'a plus d'énergie ] end to repousse-herbe ask patches [ ;; 3 cycles sur 100, la patch reçoit une couleur verte if random 100 < 3 [ set pcolor green ] ] end to dessine-graphes set-current-plot "Totaux" ;; quel traceur utiliser set-current-plot-pen "tortues" ;; quel crayon utiliser plot count turtles ;; ce qui sera dessiné avec le crayon courant set-current-plot-pen "herbe" ;; quel crayon utiliser plot count patches with [pcolor = green] ;; ce qui sera dessiné avec le crayon courant end
Et voici le code original, non traduit :
turtles-own [energy] ;; for keeping track of when the turtle is ready ;; to reproduce and when it will die to setup clear-all setup-patches setup-turtles do-plots end to setup-patches ask patches [ set pcolor green ] end to setup-turtles create-turtles number ;; uses the value of the number slider to create turtles ask turtles [ setxy random-xcor random-ycor ] end to go if ticks >= 500 [ stop ] ;; stop after 500 ticks move-turtles eat-grass reproduce check-death regrow-grass tick ;; increase the tick counter by 1 each time through do-plots end to move-turtles ask turtles [ right random 360 forward 1 set energy energy - 1 ;; when the turtle moves it looses one unit of energy ] end to eat-grass ask turtles [ if pcolor = green [ set pcolor black ;; the value of energy-from-grass slider is added to energy set energy (energy + energy-from-grass) ] ifelse show-energy? [ set label energy ] ;; the label is set to be the value of the energy [ set label "" ] ;; the label is set to an empty text value ] end to reproduce ask turtles [ if energy > birth-energy [ set energy energy - birth-energy ;; take away birth-energy to give birth hatch 1 [ set energy birth-energy ] ;; give this birth-energy to the offspring ] ] end to check-death ask turtles [ if energy <= 0 [ die ] ;; removes the turtle if it has no energy left ] end to regrow-grass ask patches [ ;; 3 out of 100 times, the patch color is set to green if random 100 < 3 [ set pcolor green ] ] end to do-plots set-current-plot "Totals" ;; which plot we want to use next set-current-plot-pen "turtles" ;; which pen we want to use next plot count turtles ;; what will be plotted by the current pen set-current-plot-pen "grass" ;; which pen we want to use next plot count patches with [pcolor = green] ;; what will be plotted by the current pen end