AccueilDemarcheLogicielApplicationsBiblioFormationReseaux

 

 

 

 

 

Demo_Fire 

Automate cellulaire feu de forêt

Christophe Le Page, François Bousquet, Pierre Bommel (Cirad)

Objectif

Ce modèle illustre les principes des automates cellulaires implémentés avec Cormas. L'entité spatiale du modèle, Plot, peut se trouver dans quatre états: #fire (rouge); #forest (vert); #ash (gris); #empty (blanc). Chaque cellule de la grille spatiale est initialement, selon une probabilité p, une forêt, et selon une probabilité 1-p, vide. On met le feu à une cellule et on suit la diffusion du feu de proche en proche à travers la grille spatiale selon la fonction de transition suivante: une cellule en forêt prend feu au temps t si l'une au moins de ses 4 voisines (nord, est, sud, ouest) est en feu au temps t-1. Les cellules en feu passeront en cendres au temps suivant, les cellules en cendres deviendront vides au temps suivant.

Animation gif du modèle FireAutomata   Animation gif du modèle FireAutomata
p = 0.53   p = 0.58

La probabilité d'observer un incendie restreint est très grande si p est inférieur à 0.55, et au contraire si p est supérieur à 0.55, c'est un incendie global qui a de fortes chances de se produire. Ce seuil dit de "percolation" caractérise ce type d'automate cellulaire représentant des processus de diffusion.
Voir aussi (pour les amateurs !) l'animation réalisée à partir d'une grille de 100 x 100 cellules (p = 0.58).


Les quatre versions suivantes décrivent quatre manières différentes d'implémenter un modèle de diffusion du feu sur une grille.

Pour ces 4 versions, nous considérons uniquement trois états possibles : en forêt, en feu, ou vide (#forest, #fire, #empty). Le feu ne s'éteind pas de lui-même (sauf pour la version 4b).

Version 1 : automate cellulaire

    ** Sélectionner Fire_1_CA.pcl du modèle Demo_Fire **

Cette version propose une version classique d'automate cellulaire. Ici, seule une classe est créée (Plot), sous classe de SpatialEntityCell. Elle contient donc déjà deux attributs : state et bufferState. Ici, nous déclarons #empty comme valeur par défaut :



Pour créer l'espace initial, il faut sélectionner une des 3 méthodes d'initialisation : init_4 (qui créé un espace de voisinage 4), init_6 (voisinage de 6, ou init_8 (voisinage de Moore). Chacune de ces méthodes utilise l'initialisation générale suivante :

code initialization
A noter que xSize et ySize ont été déclarés comme 2 attributs du modèle (avec 50 comme valeur par défaut).

Pour la dynamique du feu, il faut redéfinir la méthode #newState (aussi appelée "Fonction de transition") au niveau de la classe Plot, de la façon suivante :

code of fire
Il est important de noter ici que l'état de la cellule n'est pas modifié mais uniquement son état tampon (bufferState). Par exemple, dans le cas d'une cellule en forêt en contact avec un feu, celle-ci garde son état forêt, mais modifie juste son état tampon (self bufferState: #fire),  ce qui fait que cette cellule continue pour ce tour d'être considérée par les autres cellules comme étant encore une forêt.
Et au niveau de la méthode #step: t de l'ordonnanceur, il faut faire un simple appel à :
       self stepSynchronouslyCA: t.
La méthode #stepSynchronouslyCA: est défini au niveau de CormasModel. Elle exécute 2 boucles complètes de l'ensemble des cellules. La 1ère boucle fait exécuter la méthode #newState à chaque cellule (donc sans changement effectif de l'état), puis une deuxième boucle fait exécuter la méthode #updateState. C'est seulement à ce moment-là que l'état des cellules est effectivement modifié.

Version 2 : propagation à partir des cellules en feu

    ** Sélectionner Fire_2_CAoptimized.pcl du modèle Demo_Fire **

Cette version propose une diffusion par les cellules en feu uniquement. Il s'agit donc à chaque pas de temps de sélectionner les cellules en feu, puis d'activer pour chacune la propagation du feu sur les voisines. Par rapport à la version 1, deux méthodes sont ajoutées dans la classe Plot : #ignite (qui change l'état de la cellule en feu) et #spreadFire (qui propage le feu sur les cellules forets voisines).
Pour éviter les artéfacts liés au parcours régulier des cellules, l'ordonnanceur doit sélectionner au préalable les cellules en feu, puis activer leur diffusion :


Cette version propose également une procédure plus optimisée qui évite le parcours au préalable de la grille pour ne sélectionner que les cellules en feu (cf. methode #step: t).

Version 3 : une entité spatiale (agrégat) se répand sur les cellules en forêt

    ** Sélectionner Fire_3_FireAggregate.pcl du modèle Demo_Fire **

Dans cette version, le feu représente une étendue spatiale qui se répand sur les cellules en forêt qui la bordent. Cette entité est appelée FireAggregate ; c'est une sous-classe de SpatialEntityAggregate. Ici, seules les entités FireAggregates sont activées :
    self theFireAggregates do: [: f | f spread].
 Chaque agrégat exécute alors la méthode #spread qui se compose de l'instruction suivante :
    self swellConstraint: [: p | p state = #forest].
                         Une entité fireAggregate (avec son contour)

A noter que l'affichage du contour des agrégats ralenti la simulation. Sans cet affichage (pov -> FireAggregate -> #nil), les simulations sont aussi rapides que dans la version 2.

Version 4 : des entités Feu se déplacent

    ** Sélectionner Fire_4_FireEntity.pcl du modèle Demo_Fire **

Dans cette version, des entités Feu (FireEntity) sont créées. Ce sont les seules entités activées par l'ordonnanceur. Considérées comme des agents actifs, ces entités se propagent en créant de nouvelles entités feu sur les cellules voisines :



La méthode #moveTo: a été redéfinie afin d'activer l'ignition des cellules lors d'un déplacement :


Version 4b : des entités Feu se consument et s'éteignent

    ** Sélectionner Fire_5_FireEntityAging.pcl du modèle Demo_Fire **

Cette version est une réplication du modèle Fire de NetLogo. Après avoir incendié une parcelle, l'entité feu se consume et son intensité diminue progressivement jusqu'à extinction (12 pas de temps).
Dans cette version, la couleur du feu en fonction de son age est supportée par EntityFire qui défini un point de vue spécifique (#povAge).
Comme pour les versions antérieures, une méthode d'initialisation est proposée : #init_FireLine qui créée une grille de 100 x 100 avec un front de feu débutant sur la première colonne de la grille.
              
Propagation du feu depuis la bordure Ouest de la grille


Le Cirad Centre de coopération internationale en recherche agronomique pour le développement
Informations légales © Copyright Cirad 2001-2015 cormas-webmaster@cirad.fr