Scilab : un
logiciel libre pour le calcul scientifique
7e Partie - Introduction à
Scicos (1/2)
Tous ces articles en ligne sur Scilab ont été écrits pour
LINUX MAGAZINE FRANCE par les
développeurs du Scilab Group. Les articles sont sous
licence FDL (Free Documentation
Licence)
L'article du numéro précédent nous a montré les
capacités de Scilab à simuler des systèmes dynamiques.
Mais pour cela il fallait représenter le modèle du système
à simuler sous forme d'un programme Scilab, C ou fortran. Scicos
est une boîte à outils de Scilab contenant un éditeur de
type schéma-blocs qui permet de construire ces modèles par
simples clics de souris.
Il est toujours possible de construire et de simuler des modèles de
systèmes dynamiques dans Scilab en utilisant les fonctions de base comme
ode (solveur de systèmes d'équations
différentielles). Mais cela nécessite en général
beaucoup de programmation en langage Scilab ou C. Ces programmes, en
particulier quand le système à simuler contient des composants
discrets, sont complexes, difficiles à déboguer et trop
particuliers pour conduire à du code ré-utilisable.
L'éditeur graphique de la boîte à outils Scicos permet
à l'utilisateur de décrire son système dynamique de
façon complètement modulaire. Le modèle ainsi obtenu peut
alors être compilé, et le résultat simulé, par le
simulateur Scicos. Les systèmes modélisables et simulables par
Scicos sont de nature très variée ; ils peuvent comporter
des composants évoluant en temps continu, en temps discret, et
même des composants événementiels. On les appelle des
systèmes hybrides. Dans cet article, on présente l'utilisation de
Scicos à travers plusieurs exemples ; pour cela on n'utilisera que
des blocs prédéfinis, fournis avec la boîte à
outils. Dans le prochain numéro, on abordera le problème de
construction de nouveaux blocs.
Un exemple simple
Supposons qu'on veuille simuler le fonctionnement d'un simple
intégrateur (un système dont la sortie est l'intégrale de
son entrée). En plus de l'intégrateur, il faut une entrée
et un affichage graphique pour visualiser la sortie. On commence par lancer
l'éditeur Scicos (dans Scilab) avec la commande :
--> scicos();
Cela ouvre la fenêtre principale de l'éditeur Scicos. La
fenêtre et le schéma correspondant sont intitulés par
défaut Untitled. Le schéma est bien évidemment
vide pour le moment.
Toutes les fonctionnalités de Scicos sont disponibles à travers
des menus déroulants. On devine assez facilement la fonction de chaque
bouton de chaque menu par son nom : Save pour enregistrer un
schéma, Load pour le charger, Copy pour copier un
bloc, Delete pour le supprimer, Color pour donner une couleur
au bloc, etc...
Il existe aussi un bouton Help qui se trouve dans le menu Misc
qui permet de consulter l'aide en ligne sur chaque menu. Pour cela, il
suffit de cliquer sur Help puis sur le bouton ad hoc. Le bouton help
permet aussi d'accéder à l'aide sur les blocs ; il suffit de
cliquer sur le bloc après avoir cliqué sur Help.
On commence par chercher les blocs dont on a besoin dans les
<<palettes>> Scicos. Une palette est un schéma contenant des
blocs que l'on peut utiliser pour construire d'autres schémas. Pour
ouvrir une palette, il faut cliquer sur le bouton palette du menu
Edit. On voit alors une liste de palettes ; choisissons la
palette Linear. On voit alors s'ouvrir la fenêtre graphique
qu'on voit dans la figure 1.
Figure 1: La palette Linear.
L'icone du bloc intégrateur est 1/s. Pour copier ce bloc dans
le schéma Untitled, il suffit de placer la souris sur ce bloc
et cliquer sur le bouton gauche de la souris, puis placer la souris dans la
fenêtre qui contient le schéma Untitled, à
l'endroit où on veut placer le bloc, et recliquer. Une copie du bloc
1/s apparait alors dans Untitled.
Il faut maintenant définir une entrée pour
l'intégrateur : par exemple un sinus. Pour cela, on va chercher
dans la palette Inputs_Outputs le bloc sinusoid_generator.
Pour connecter la sortie de sinusoid_generator à
l'entrée du bloc 1/s, on clique d'abord près du port de
sortie de sinusoid_generator puis près du port d'entrée
de 1/s (voir Figure 2).
Figure 2: Schéma Scicos simulable.
Le schéma ainsi obtenu est simulable mais pas intéressant
à simuler car nous ne verrons rien, il faut rajouter de quoi afficher le
résultat ! On place donc le bloc MScope (oscilloscope
à entrées multiples) dans le schéma et on connecte la
sortie de 1/s à sa première entrée et la sortie
de sinusoid_generator sur sa deuxième entrée. Comme la
sortie de sinusoid_generator est déjà branchée,
il faut placer la souris quelque part sur le lien qui sort de
sinusoid_generator et cliquer ; cela crée un branchement
et débute un lien, puis cliquer sur l'entrée de MScope.
Pour obtenir un schéma plus lisible, il est préférable de
ne pas créer dans ce dernier cas un lien direct qui passerait par dessus
le bloc 1/s, mais de le contourner. Pour cela, après avoir
débuté le lien, on peut cliquer sur des points
intermédiaires avant de cliquer sur l'entrée de MScope
.
Le bloc MScope est un bloc discret qui affiche les valeurs de ses
entrées quand il est activé. Pour activer ce bloc, il faut
envoyer un événement sur son port d'entrée
événement placé en haut du bloc. Dans ce cas on veut
envoyer une suite d'événements espacés de manière
régulière dans le temps. Pour cela on utilise le bloc horloge
d'événement (l'horloge rouge ayant une sortie en bas qui se
trouve dans la palette Inputs_Outputs ). Une fois ce bloc placé
et branché, le schéma complet doit ressembler a celui de la
Figure 3.
Figure 3: Schéma complet.
Le schéma peut alors être simulé. Cliquer sur le bouton
Run du menu Simulate. On observe alors l'ouverture d'une
fenêtre graphique fonctionnant comme une oscilloscope. Pour arrêter
la simulation il suffit de cliquer sur stop.
Figure 4: Résultat de la simulation affiché par l'oscilloscope.
On constate alors (voir Figure 4) que les
paramètres par défaut de l'oscilloscope ne sont pas bien
réglés ici; il faut faire en sorte que la première courbe
reste dans la fenêtre graphique. Pour changer les paramètres d'un
bloc, il suffit de cliquer sur le bloc, ce qui ouvre un dialogue (voir
Figure 5).
Figure 5: Paramètres par défaut de l'oscilloscope.
On peut régler le problème ici en changeant les premières
valeurs de Ymin_vector et Ymax_vector, par exemple on peut
remplacer le premier (qui vaut -1) par 0 et le deuxième par 2.
Les requins et les sardines
On est maintenant en mesure de construire des modèles plus
compliqués. Prenons par exemple le modèle de la population des
requins et des sardines présenté dans l'article
précédent : {
| x'(t)=a x(t)-b x(t)y(t)
a,b > 0 |
| y'(t)=c x(t)y(t)-d y(t)
c,d > 0 |
. où x(t) représente le nombre de sardines et
y(t) représente le nombre de requins. Ce modèle
approché, appelé aussi système de Lotka-Volterra, signifie
qu'en l'absence de requins les sardines prolifèrent
x'(t)=a x(t), qu'en l'absence de
sardines les requins disparaissent
y'(t)=-d y(t) et le terme en
x(t)y(t), qui représente la rencontre des
requins et des sardines, augmente le nombre de requins et diminue le nombre de
sardines (car ces dernières sont mangées par les requins).
Le schéma Scicos représentant ce modèle est donné
dans la Figure 6. On retrouve les états
x et y comme les sorties des deux intégrateurs (un
intégrateur pour chaque équation différetielle). Les
entrées de ses intégrateurs sont alors x' et
y' . Pour réaliser les équations définissant
x' et y' dans le schéma, on a utilisé des blocs
sommateurs, multiplicateurs et gains (multiplication par constante). On a pris
a=2, b=1, c=.3 et d=1.
Figure 6: Le schéma Scicos correspondant au modèle de la
population des requins et des sardines.
Le résultat de la simulation pour x(0)=2 et y(0)=1 est
donné dans la Figure 7. On retrouve alors le
comportement périodique attendu.
Figure 7: L'évolution de la population des requins (en haut) et des
sardines (en bas).
On constate donc qu'il peut exister une forte variation de la population des
sardines ; cela dépend des populations initiales des sardines et
des requins (x(0) et y(0)). Si on commence près des
populations d'équilibre, les variations sont moins fortes. Les
populations d'équilibre xe et ye correspondent à une condition initiale
pour laquellle l'état reste constant. Elles vérifient bien
entendu le système : {
| 0=a xe-b xeye
|
| 0=c xeye-d ye |
. ce qui (à part la solution évidente (0,0)) donne
xe=d/c et
ye=a/b.
La régulation par la pêche
On peut introduire l'influence de la pêche de sardines dans le
modèle précédent en modifiant l'équation de
x'(t) comme suit :
x'(t)=a x(t)-b x(t)y(t)+f x(t)
a,b > 0, f<0,
le coefficient f indique alors l'effort de pêche. Noter que cette
modification ne modifie pas le point d'équilibre xe.
Supposons maintenant que les autorités de pêche veuillent
réguler la population des sardines. Pour cela ils autorisent la
pêche (f<0) si la population des sardines dépasse un
certain seuil (x>xmax)
et ils interdisent la pêche (f=0) quand cette population passe en
dessous d'un autre seuil (x<xmin). Pour modéliser ce
<<régulateur>>, on note qu'il faut générer
deux événements : ces événements sont alors
utilisés pour modifier la valeur de f (voir Figure 8).
Figure 8: Le modèle de l'évolution de la population des sardines
et des requins régulé par la pêche.
Les blocs -to+ et +to- générent des
événements quand leur entrées traversent zéro dans
le sens négatif vers positif et positif vers négatif,
respectivement. Le bloc Selector copie la valeur qui se trouve sur sa
première entrée (ici 0) sur sa sortie quand il reçoit un
événement sur son premier port d'entrée
événement, et il copie la valeur sur sa deuxième
entrée (ici 1) quand il reçoit un événement sur
l'autre port. Donc quand x-3.4 dépasse 0, f devient -1 et
quand x-3.2 passe en dessous de 0, f devient 0. Ces valeurs sont
choisies pour pousser x vers sa valeur d'équilibre
xe=d/c=3.33. Le
bloc Mux permet de concaténer les deux entrées pour
former un signal vectoriel. Ce signal est affiché par MScope en
superposant les deux valeurs (voir Figure 9). La
courbe de dessous indique les périodes d'ouverture et de fermeture de la
pêche. On constate qu'après une période transitoire, le
système se stabilise au point d'équilibre (xe,ye) où l'on autorise la pêche ;
le régulateur n'est alors plus sollicité. Dans la pratique,
à cause des phénomènes que nous n'avons pas pris en compte
dans notre modèle simpliste, on s'écarte
régulièrement du point d'équilibre et donc le
régulateur doit rester en place.
Figure 9: L'évolution des populations dans le cas régulé.
En haut, en noir, on a la population des sardines et, en vert, la population
des requins. En bas, on trouve les périodes d'ouverture de la
pêche (f=-1).
Le système régulé peut, bien évidemment, être
simulé directement dans Scilab en utilisant la fonction ode.
Mais cela nécessiterait beaucoup de programmation dans le langage
Scilab. De plus, le résultat serait difficile à
ré-utiliser. Dans l'environnement Scicos, il serait facile de modifier
la structure du régulateur, rajouter d'autres populations animales en
interaction avec les sardines et les requins, etc... Ce type de modifications,
impliqueraient, très souvent, une réécriture
complète du programme Scilab.
Super Block
Le Schéma 8 est assez chargé, on
aimerait bien utiliser une description hiérarchique pour le simplifier
et le rendre plus lisible. Pour cela on peut utiliser un <<Super
Block>>, qui ressemble à un bloc normal mais qui peut contenir
tout un sous-schéma. Par exemple, pour mettre la partie
régulateur dans un <<Super Block>>, on peut cliquer sur le
bouton Region_to_SuperBlock du menu Diagram, puis
sélectionner la région correspondant au régulateur. Cette
région disparait alors et elle est remplacée par un seul bloc de
type <<Super Block>> (Fig. 10). Pour
accéder au schéma qui se trouve à l'intérieur de ce
bloc, il suffit de cliquer dessus, ce qui lance un nouvel éditeur
Scicos.
Figure 10: Mise en Super Block du régulateur.
On peut manipuler un <<Super Block>> comme n'importe quel autre
bloc, en particulier on peut le copier et l'utiliser plusieurs fois dans le
même schéma. De manière générale, on peut
utiliser un nombre illimité de <<Super Block>> par
schéma et on peut même placer des <<Super Block>> dans
d'autres <<Super Block>>.
Paramètres formels
Il est possible, et souvent souhaitable, de définir les
paramètres des blocs Scicos de manière formelle. Par exemple,
dans l'exemple précédent, au lieu de rentrer, dans les blocs, les
valeurs numériques des paramètres a, b, c,
etc..., on peut les définir dans le <<Context>> du
schéma comme variables Scilab puis utiliser leur noms comme
paramètres de blocs. Le <<Context>> peut être
invoqué en cliquant sur le bouton Context du menu Edit
(voir Figure 11). On peut mettre n'importe quelle
instruction Scilab dans le <<Context>>, le contenu est
exécuté comme un script.
Figure 11: Le Context du schéma Scicos.
Une fois ces variables définies, on peut les utiliser comme
paramètres de blocs (voir Figure 12).
Figure 12: Le modèle régulé avec le Context défini
dans la Figure
11 (à comparer à la
Figure
8).
Le <<Context>> est sauvé automatiquement avec le
schéma et il est évalué à chaque chargement.
Conclusion
Dans cet article on a montré comment on peut construire et simuler un
modèle de système dynamique comme un schéma Scicos en
utilisant des blocs prédéfinis. On peut ainsi construire beaucoup
de modèles mais souvent on a besoin de définir des blocs
spécifiques. Cela est bien évidemment possible dans Scicos. Le
prochain article sera consacré à cela.
Ramine Nikoukhah
Scilab Group
scilab@inria.fr
http://www-rocq.inria.fr/scilab/
This document was translated from LATEX
by HEVEA.
