Ubuntu-fr

baboo

A moi les programmeurs Python !!!

Bonjour à tous !

Je suis élève en classes préparatoires et je dois réaliser un TIPE (sorte d'exposé que que je présenterai lors des oraux).
Mon sujet est (roulement de tambours) : " Optimisation d'un virus à l'aide d'un algorithme cellulaire évolutif".

Pour ceux qui connaissent les TIPE, je les entends déjà crier que je suis méga en retard.
En réalité j'ai déjà en tête tous mon dossier, il ne me reste plus que la partie programmation.

Donc mon problème actuel est de réaliser:

-mon algorithme cellulaire (déjà fait, je mettrai mon code en fin d'article)

-inclure celui ci dans un programme supérieur qui ferait tourner l'algorithme cellulaire avec différents paramètres, comparerait les résultats (le but étant de faire tomber malade le plus de cellule possible, sans pour autant les faire mourir... je passe les détails pour l'instant), et afficherait au bout de plusieurs tests les paramètres optimum.

-trouver un moyen de présenter les résultats sous formes exploitables....

Voici pour commencer le premier algorithme cellulaire que j'ai réaliser. En publiant un truc pareil je vais sûrement m'attirer les foudres des puristes (rien ou presque n'est documenter et à mon avis la simplicité et l'efficacité est loin d'être le point fort de cette réalisation, mais sachez tout de même que c'est ma toute première réalisation !!! Et quelque soit le langage : j'ai commencé Python il y a quelques semaines seulement et c'est le premier langage que j'apprends. Il m'a parut être le plus simple pour commencer et l'interface graphique facilement réalisable tait rassurante.

#-*- coding : Latin-1 -*-



###################################################################
#Programme Python libre
#Auteur : Thibault HENRY
#
#
#
###################################################################



###################################################################
#Importation des modules necessaires

from math import *
from Tkinter import *
from random import *


###################################################################
#Définition de classes

class Cellule:
    "Representant d'un élément du damier"
    def __init__(self):
        "Constructeur d'une cellule"
        self.case=[damier.create_rectangle(x,y,x+3,y+3,fill='white',outline='white',width=0)]
        self.malade = 0
        self.etat_suivant = 0
        self.x = x
        self.y = y
        self.compteur = 0
        self.immunise = 0
        self.temps_immunisation = randrange(1,30)
        self.resistance = randrange (1,6)


    def transition(self):
        if self.immunise==0:
            if self.malade==1:
                if self.compteur<self.temps_immunisation:
                    self.compteur+=1
                elif self.compteur>=self.temps_immunisation:
                    self.immunise=1
                    self.malade=0
            elif self.malade==0:
                if self.etat_suivant==1:
                    self.malade=1
                elif self.etat_suivant==0:
                    self.malade=0
        elif self.immunise==1:
            self.malade=0


##################################################################
#Definition de la boucle

def evolution():
    for i in range(1,199):
        for j in range(1,199):
            if population[i,j].immunise!=1:
                s=population[i-1,j-1].malade + population[i,j-1].malade + \
                   population[i+1,j-1].malade + population[i-1,j].malade + \
                   population[i+1,j].malade + population[i-1,j+1].malade + \
                   population[i,j+1].malade + population[i+1,j+1].malade
                if s>=population[i,j].resistance:
                    population[i,j].etat_suivant=1

    if population[0,0].immunise!=1:
        s00=population[0,1].malade + population[1,0].malade + \
             population[1,1].malade
        if s00>=population[0,0].resistance:
            population[0,0].etat_suivant=1

    if population[0,199].immunise!=1:
        s01=population[0,198].malade + population[1,198].malade + \
             population[1,198].malade
        if s01>=population[0,199].resistance:
            population[0,199].etat_suivant=1

    if population[199,0].immunise!=1:
        sh0=population[198,0].malade + population[198,1].malade + \
             population[199,1].malade
        if sh0>=population[199,0].resistance:
            population[199,0].etat_suivant=1

    if population[199,199].immunise!=1:
        shl=population[198,199].malade + population[198,198].malade + \
             population[199,198].malade
        if shl>=population[199,199].resistance:
            population[199,199].etat_suivant=1

    for k in range(1,199):
        sh=population[0,k-1].malade + population[0,k+1].malade + \
            population[1,k-1].malade + population[1,k+1].malade + \
            population[1,k].malade

        sb=population[199,k-1].malade + population[199,k+1].malade + \
            population[198,k-1].malade + population[198,k+1].malade + \
            population[198,k].malade

        sg=population[k-1,0].malade + population[k+1,0].malade + \
            population[k-1,1].malade + population[k,1].malade + \
            population[k+1,1].malade

        sd=population[k-1,199].malade + population[k+1,199].malade + \
            population[k-1,198].malade + population[k+1,198].malade + \
            population[k,198].malade

        if sh>=population[0,k].resistance:
            population[0,k].etat_suivant=1

        if sb>=population[199,k].resistance:
            population[199,k].etat_suivant=1

        if sg>=population[k,0].resistance:
            population[k,0].etat_suivant=1

        if sd>=population[k,199].resistance:
            population[k,199].etat_suivant=1


#############################################################################
#Programmation des fonctions gestionnaires d'evenements
#############################################################################


#############################################################################
#Fonctions en charge de la matrice et de son évolution

def generate_matrix():
    "Creation de la matrice de cellule"
    global x, y, population
    population={}
    for i in range (200):
        for j in range (200):
            x=i*3
            y=j*3
            population[i,j] = Cellule()

def creation_fichier():
    obFichier=open('FirstGen','w')
    for i in range(200):
        for j in range(200):
            a=randrange(200)
            if a == 0:
                obFichier.write(str(1))
            else:
                obFichier.write(str(0))
        obFichier.write('\n')
    obFichier.close()

def generation_aleatoire():
    creation_fichier()
    obFichier=open('FirstGen','r')
    for i in range(200):
        valeurs = obFichier.readline()
        for j in range(200):
            population[i,j].malade=int(valeurs[j])
    obFichier.close()

def evolution_graphique():
    for i in range(200):
        for j in range(200):
            if population[i,j].immunise==1:
                damier.itemconfigure(population[i,j].case,fill='blue',outline='blue')
            elif population[i,j].malade==0:
                damier.itemconfigure(population[i,j].case,fill='white',outline='white')
            elif population[i,j].malade==1:
                damier.itemconfigure(population[i,j].case,fill='black',outline='black')

def evolution_interne():
    for i in range(200):
        for j in range(200):
            population[i,j].transition()

def distrib():
    generation_aleatoire()
    evolution_graphique()
    evolution_interne()

def evoluer_matrice():
    evolution()
    evolution_graphique()
    evolution_interne()


############################################################################
#Fontions en charge du trace du graphe

def somme_malade():
    somme = 0
    for i in range(200):
        for j in range(200):
            somme = somme + population[i,j].malade
    return somme

def somme_immunise():
    somme = 0
    for i in range(200):
        for j in range(200):
            somme = somme + population[i,j].immunise
    return somme

def evoluer_graphique():
    sm = somme_malade()
    si = somme_immunise()
    ss = 40000-sm-si
    graph.create_rectangle( (int(compteur) *4) +1, 600-((int(sm)*3)/200) ,(int(compteur) *4) +2 , 600-((int(sm)*3)/200) +1,\
                 fill='black', outline='black',width=4)
    graph.create_rectangle( (int(compteur) *4) +1, 600-((int(si)*3)/200) ,(int(compteur) *4) +2 , 600-((int(si)*3)/200) +1,\
                 fill='blue', outline='blue',width=4)
    graph.create_rectangle( (int(compteur) *4) +1, 600-((int(ss)*3)/200) ,(int(compteur) *4) +2 , 600-((int(ss)*3)/200) +1,\
                 fill='green', outline='green',width=4)

###############################################################################
#Fontions en charge de l'évolution commune

def distribuer():
    distrib()
    evoluer_graphique()

def evoluer_commun():
    global compteur
    evoluer_matrice()
    evoluer_graphique()
    compteur+=1
    if flag>0:
        fen.after(10,evoluer_commun)

def evoluer_commun_continu():
    global flag
    if flag==0:
        flag=1
        evoluer_commun()

def stop():
    global flag
    flag=0

###########################################################################
#----------------Programme principal-------------------------------------
###########################################################################


###########################################################################
#Les varaibles suivantes seront utilisées de manière globale

flag=0
h=600
l=600
compteur=0

###########################################################################
#Creation du widget principal

fen=Tk()
fen.title('Modelisation epidomiologique')

###########################################################################
#Creation des widgets esclaves

damier = Canvas(fen,bg='white',height=h,width=l)
damier.grid(row=1,column=1)
graph = Canvas(fen, bg='white',height=h,width=l)
graph.grid(row=1,column=3)

Button(fen,text='Clear',command=generate_matrix).grid(row=3,column=1)
Button(fen,text='Distribuer',command=distribuer).grid(row=2,column=1)
generate_matrix()

Button(fen,text='Evoluer',command=evoluer_commun).grid(row=2,column=3)

Button(fen,text='Start',command=evoluer_commun_continu).grid(row=2,column=2)
Button(fen,text='Stop',command=stop).grid(row=3,column=2)

Button(fen,text='Quitter', command=fen.quit).grid(row=3,column=3)

fen.mainloop()

fen.destroy()

Je vais éditer ce post dès maintenant pour documenter le code et peut être commencer quelques modifications. Ensuite j'exposerai mes problèmes au fur et à mesure.

Si pour commencer vous pouvez suivre un minimum mon sujet et me donner des conseils pour améliorer ce premier code ce serait sympa.

Merci d'avance pour toute réponse, et surtout poser des questions dès qu'elles vous passent par la tête, d'une façon ou d'une autre elles pourront peut être m'aider.

Dernière modification par baboo (Le 15/05/2008, à 22:25)