Demo_Fire 

Automate cellulaire feu de foret

Christophe Le Page, Francois Bousquet, Pierre Bommel (Cirad)

Objectif

Ce modele illustre les principes des automates cellulaires implémentés avec Cormas. Lentité spatiale du modele, 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 foret, et selon une probabilité 1-p, vide. On met le feu a une cellule et on suit la diffusion du feu de proche en proche a travers la grille spatiale selon la fonction de transition suivante: une cellule en foret prend feu au temps t si lune 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 modele FireAutomata Animation gif du modele FireAutomata
p = 0.53 p = 0.58

La probabilité dobserver un incendie restreint est tres grande si p est inférieur a 0.55, et au contraire si p est supérieur a 0.55, cest un incendie global qui a de fortes chances de se produire. Ce seuil dit de "percolation" caractérise ce type dautomate cellulaire représentant des processus de diffusion.
Voir aussi (pour les amateurs !) lanimation réalisée a partir dune grille de 100 x 100 cellules (p = 0.58).


Les quatre versions suivantes décrivent quatre manieres différentes dimplémenter un modele de diffusion du feu sur une grille.

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


Version 1 : automate cellulaire

    ** Sélectionner Fire_1_CA.pcl du modele Demo_Fire **

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



Pour créer lespace initial, il faut sélectionner une des 3 méthodes dinitialisation : 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 linitialisation générale suivante :

code initialization
A noter que xSize et ySize ont été déclarés comme 2 attributs du modele (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 facon suivante :

code of fire
Il est important de noter ici que létat de la cellule nest pas modifié mais uniquement son état tampon (bufferState). Par exemple, dans le cas dune cellule en foret en contact avec un feu, celle-ci garde son état foret, mais modifie juste son état tampon (self bufferState: #fire),  ce qui fait que cette cellule continue pour ce tour detre considérée par les autres cellules comme étant encore une foret.
Et au niveau de la méthode #step: t de lordonnanceur, il faut faire un simple appel a :
       self stepSynchronouslyCA: t.
La méthode #stepSynchronouslyCA: est défini au niveau de CormasModel. Elle exécute 2 boucles completes de lensemble des cellules. La 1ere boucle fait exécuter la méthode #newState a chaque cellule (donc sans changement effectif de létat), puis une deuxieme boucle fait exécuter la méthode #updateState. Cest seulement a ce moment-la que létat des cellules est effectivement modifié.

Version 2 : propagation a partir des cellules en feu

    ** Sélectionner Fire_2_CAoptimized.pcl du modele Demo_Fire **

Cette version propose une diffusion par les cellules en feu uniquement. Il sagit donc a chaque pas de temps de sélectionner les cellules en feu, puis dactiver pour chacune la propagation du feu sur les voisines. Par rapport a 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, lordonnanceur 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 foret

    ** Sélectionner Fire_3_FireAggregate.pcl du modele Demo_Fire **

Dans cette version, le feu représente une étendue spatiale qui se répand sur les cellules en foret qui la bordent. Cette entité est appelée FireAggregate ; cest 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 linstruction suivante :
    self swellConstraint: [: p | p state = #forest].
                         Une entité fireAggregate (avec son contour)

A noter que laffichage 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 modele Demo_Fire **

Dans cette version, des entités Feu (FireEntity) sont créées. Ce sont les seules entités activées par lordonnanceur. 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 dactiver lignition des cellules lors dun déplacement :


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

    ** Sélectionner Fire_5_FireEntityAging.pcl du modele Demo_Fire **

Cette version est une réplication du modele Fire de NetLogo. Apres avoir incendié une parcelle, lentité feu se consume et son intensité diminue progressivement jusqua 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 dinitialisation est proposée : #init_FireLine qui créée une grille de 100 x 100 avec un front de feu débutant sur la premiere colonne de la grille. 		              
Propagation du feu depuis la bordure Ouest de la grille