{"id":1049,"date":"2020-01-28T17:47:36","date_gmt":"2020-01-28T16:47:36","guid":{"rendered":"http:\/\/labodemaths.fr\/WordPress3\/?p=1049"},"modified":"2020-09-09T19:18:25","modified_gmt":"2020-09-09T17:18:25","slug":"tp-simulation-numerique-dexperiences-de-percolation","status":"publish","type":"post","link":"https:\/\/labodemaths.fr\/WordPress3\/tp-simulation-numerique-dexperiences-de-percolation\/","title":{"rendered":"NSI :TP simulation num\u00e9rique de percolation"},"content":{"rendered":"\n

1. Le principe de la percolation en physique.<\/h3>\n\n\n\n
TP_percolation<\/a>T\u00e9l\u00e9charger<\/a><\/div>\n\n\n\n

2. Mise en place de la recherche des amas et de l’existence ou non de la percolation<\/h3>\n\n\n\n

Proposition de correction pour la recherche d’amas :<\/p>\n\n\n\n

from random import *\nimport matplotlib.pyplot as plt\nimport numpy as np\n\ndef grille(largeur,hauteur,densite):\n    '''\n    g\u00e9n\u00e8re une grille sous la forme d'un tuple de tuples\n    de largeur et hauteur donn\u00e9es\n    chaque \u00e9l\u00e9ment de la grille a la probabilit\u00e9 densit\u00e9\n    d'\u00eatre plein\n    largeur : int\n    hauteur : int\n    densite : float\n    return : tuple\n    exemple : grille(10,10,0.1) retournera une grille al\u00e9atoire\n    du type\n    ((0, 0, 0, 0, 0, 0, 0, 0, 0, 0),\n    (0, 0, 0, 0, 0, 0, 0, 0, 0, 0),\n    (0, 1, 0, 0, 0, 0, 0, 0, 0, 0),\n    (0, 0, 0, 0, 0, 0, 0, 0, 0, 0),\n    (0, 0, 0, 0, 0, 1, 0, 0, 0, 1),\n    (0, 0, 0, 0, 0, 0, 0, 0, 1, 0),\n    (0, 0, 1, 0, 0, 0, 0, 1, 0, 0),\n    (0, 0, 0, 0, 0, 0, 0, 0, 1, 0),\n    (0, 0, 0, 1, 0, 1, 0, 0, 0, 1),\n    (0, 1, 0, 0, 0, 0, 0, 1, 0, 0))\n    '''\n    grille=()\n    for j in range(hauteur):\n        ligne=()\n        for i in range(largeur):\n            if random()<densite:\n                ligne+=(1,)\n            else :\n                ligne+=(0,)\n        grille+=(ligne,)\n    return grille\n                \ndef frequence(grille):\n    '''\n    retourne la frequence des 1 pr\u00e9sents dans la grille\n    grille : tuple de tuples\n    return : float\n    >>> g=((0, 0, 0, 0, 0, 0, 1, 0, 0, 0),\n    (0, 0, 0, 0, 0, 0, 0, 0, 0, 0),\n    (0, 0, 0, 0, 0, 0, 0, 1, 0, 1),\n    (0, 0, 0, 1, 1, 0, 0, 0, 0, 0),\n    (0, 0, 0, 0, 0, 0, 0, 1, 0, 0),\n    (0, 0, 0, 0, 0, 0, 0, 0, 0, 0),\n    (0, 0, 0, 0, 0, 0, 0, 0, 0, 0),\n    (0, 0, 0, 0, 0, 0, 0, 0, 0, 0),\n    (0, 0, 0, 0, 0, 0, 0, 0, 0, 0),\n    (0, 0, 0, 0, 0, 0, 0, 0, 0, 0))\n    >>>print(frequence(g))\n    0.06\n    '''\n    compteur=0\n    for j in range(len(grille)):\n        for i in range(len(grille)):\n            if grille[j][i]==1:\n                compteur+=1\n    return compteur\/((i+1)*(j+1))\n\ndef afficher(grille):\n    '''\n    affichage de la grille\n    '''\n    hauteur=len(grille)\n    largeur=len(grille[0])\n    grille_a_afficher=np.zeros((largeur,hauteur))\n    for i in range(hauteur):\n        for j in range(largeur):\n            grille_a_afficher[j,i]=grille[j][i]    \n    plt.spy(grille_a_afficher)\n    plt.show()\n\ndef afficher_amas(grille,mes_amas):\n    hauteur=len(grille)\n    largeur=len(grille[0])\n    grille_a_afficher=np.zeros((largeur,hauteur))\n    for i in range(hauteur):\n        for j in range(largeur):\n            if not(cellule_pas_dans_mes_amas(mes_amas,i,j)):\n                grille_a_afficher[j][i]=1\n    plt.spy(grille_a_afficher)\n    plt.show()\n    \n    \n    \ndef amas(grille):\n    '''\n    d\u00e9termine les amas de cases vides de la grille\n    en partant du haut et de mani\u00e8re ordonn\u00e9e\n    grille : tuple de tuples contenant des 0 et des 1\n    return : tuple constitu\u00e9 de tuples contenant les coordonn\u00e9es\n    des cases formant un m\u00eame amas\n    >>>g=(\n    (0, 0, 1, 0, 0, 0, 1, 0, 1, 1),\n    (1, 1, 0, 1, 0, 0, 1, 0, 0, 1),\n    (0, 0, 1, 1, 1, 1, 0, 1, 0, 1),\n    (1, 0, 1, 1, 1, 0, 0, 1, 0, 0),\n    (0, 1, 1, 1, 0, 1, 0, 1, 1, 0),\n    (1, 1, 0, 0, 0, 1, 1, 0, 0, 0),\n    (0, 1, 0, 1, 0, 0, 1, 0, 0, 1),\n    (1, 0, 1, 0, 0, 1, 0, 1, 0, 0),\n    (0, 0, 0, 1, 1, 0, 0, 1, 1, 0),\n    (1, 1, 1, 0, 0, 0, 0, 1, 0, 0))\n    >>> amas(grille)\n    (((0,0),(1,0)),\n    ((3,0),(4,0),(5,0),(4,1),(5,1)),\n    ((7,0),(7,1),(8,1),(8,2),(8,3),(9,3),\n    (9,4),(7,5),(8,5),(9,5),(7,6),(8,6),\n    (8,7),(9,7),(9,8),(8,9),(9,9)))\n    '''\n    mes_amas=()\n    for i in range(len(grille[0])):\n        if grille[0][i]==0 and cellule_pas_dans_mes_amas(mes_amas,i,0):\n            amas=((i,0),)\n            frontiere=bord_cellules_amas(amas,grille,mes_amas)\n            while len(frontiere)!=0:\n                amas+=frontiere\n                frontiere=bord_cellules_amas(frontiere,grille,amas)\n            mes_amas+=(amas,)\n    \n    \n    return mes_amas\n\ndef cellule_pas_dans_amas(mon_amas,x,y):\n    '''\n    d\u00e9termine si une case appartient \u00e0 un amas\n    : mes_amas : tuple de tuples contenant nos amas\n    : x,y : int coordonn\u00e9es de la case\n    : return : boll\u00e9en\n    >>> amas=(\n    ((0,0)),\n    ((3,0),(4,0),(4,1))\n    )\n    >>> cellule_pas_dans_amas_finaux(amas,4,0)\n    False\n    >>> cellule_pas_dans_amas_finaux(amas_finaux,3,1)\n    True\n    '''\n    if (x,y) in mon_amas :\n            return False\n    return True\n\ndef cellule_pas_dans_mes_amas(mes_amas,x,y):\n    '''\n    d\u00e9termine si une case appartient \u00e0 un ensemble d'amas\n    : mes_amas : tuple de tuples contenant nos amas\n    : x,y : int coordonn\u00e9es de la case\n    : return : boll\u00e9en\n    >>> amas=(\n    ((0,0)),\n    ((3,0),(4,0),(4,1))\n    )\n    >>> cellule_pas_dans_amas_finaux(amas,4,0)\n    False\n    >>> cellule_pas_dans_amas_finaux(amas_finaux,3,1)\n    True\n    '''\n    for amas in mes_amas:\n        if (x,y) in amas :\n            return False\n    return True\n               \n            \ndef bord_cellules_amas(amas,grille,mes_amas):\n    '''\n    d\u00e9termine les cellules adjacentes l'amas\n    et n'appartenant pas \u00e0 cet amas en construction et aux\n    amas d\u00e9j\u00e0 d\u00e9termin\u00e9s\n    : amas : tuple\n    : grille : tuple\n    : amas : tuple\n    : return : tuple contenant les coordonn\u00e9es des cellules voisines d'un amas\n    >>>g=(\n    (0, 0, 1, 0, 0, 0, 1, 0, 1, 1),\n    (1, 1, 0, 1, 0, 0, 1, 0, 0, 1),\n    (0, 0, 1, 1, 1, 1, 0, 1, 0, 1),\n    (1, 0, 1, 1, 1, 0, 0, 1, 0, 0),\n    (0, 1, 1, 1, 0, 1, 0, 1, 1, 0),\n    (1, 1, 0, 0, 0, 1, 1, 0, 0, 0),\n    (0, 1, 0, 1, 0, 0, 1, 0, 0, 1),\n    (1, 0, 1, 0, 0, 1, 0, 1, 0, 0),\n    (0, 0, 0, 1, 1, 0, 0, 1, 1, 0),\n    (1, 1, 1, 0, 0, 0, 0, 1, 0, 0))\n    >>> mes_amas=(\n    ((0,0),(1,0)),\n    ((3,0),(4,0)),\n    )\n    >>> amas=(\n    (5,0),(4,1)\n    )\n    >>> print(bord_cellules_amas(cases,g,mes_amas))\n    ((5,1),)\n    >>>>>> amas=(\n    (7,0),(1,0)\n    )\n    >>> print(bord_cellules_amas(cases,g,mes_amas))\n    ((7,1),)\n    '''\n    retour=()\n    for case in amas :\n        x=case[0]\n        y=case[1]\n        if x<len(grille[0])-1:\n            if grille[y][x+1]==0 and cellule_pas_dans_amas(mes_amas,x+1,y) and cellule_pas_dans_mes_amas(mes_amas,x+1,y):\n                retour+=((x+1,y),)\n        if x>0 :\n            if grille[y][x-1]==0 and cellule_pas_dans_amas(mes_amas,x-1,y) and cellule_pas_dans_mes_amas(mes_amas,x-1,y):\n                retour+=((x-1,y),)\n        if y>0 :\n            if grille[y-1][x]==0 and cellule_pas_dans_amas(mes_amas,x,y-1) and cellule_pas_dans_mes_amas(mes_amas,y-1,y):\n                retour+=((x,y-1),)\n        if y<len(grille)-1:\n            if grille[y+1][x]==0 and cellule_pas_dans_amas(mes_amas,x,y+1) and cellule_pas_dans_mes_amas(mes_amas,x,y+1):\n                retour+=((x,y+1),)\n    return on_enleve_les_doublons(retour)\n\ndef on_enleve_les_doublons(mon_tuple):\n    '''\n    retourne un tuple sans \u00e9l\u00e9ments en plusieurs exemplaires\n    : mon_tuple : tuple\n    : retour : tuple\n    >>> mon_tuple=((1,1),(0,1),(1,1),(2,1))\n    >>> print(on_enleve_les_doublons(mon_tuple))\n    ((1,1),(0,1),(2,1))\n    '''\n    retour =()\n    for elt in mon_tuple :\n        if not(elt in retour):\n            retour+=(elt,)\n    return retour\n\n\ng=grille(10,10,0.4)\nafficher(g)\nafficher_amas(g,amas(g))\n<\/code><\/pre>\n\n\n\n
3. Il ne reste plus qu’\u00e0 mettre en place une fonction permettant de d\u00e9terminer si il y a percolation ou non de notre milieu.<\/h3>\n\n\n\n
def percolation(grille,mes_amas):\n    '''\n    d\u00e9termine si un mas pr\u00e9sent dans les amas r\u00e9alise\n    la percolation\n    : grille : tuple de tuples\n    : mes_amas : tuple de tuples\n    : return : True si il y a percolation, False sinon\n    >>> g=((1, 0, 1, 1, 0, 1, 0, 1, 0, 1),\n    (0, 1, 1, 0, 1, 0, 1, 1, 1, 0),\n    (0, 0, 0, 0, 0, 1, 0, 0, 1, 0),\n    (0, 0, 0, 0, 0, 0, 0, 0, 0, 0),\n    (1, 1, 1, 0, 0, 0, 0, 0, 0, 0),\n    (0, 1, 0, 0, 0, 0, 1, 0, 1, 0),\n    (1, 1, 0, 0, 0, 1, 1, 0, 0, 0), \n    0, 0, 1, 0, 0, 0, 1, 1, 0, 0),\n    (1, 0, 1, 0, 0, 1, 0, 1, 1, 0),\n    (0, 1, 0, 0, 1, 1, 1, 1, 0, 1))\n    >>> amas=(((1, 0),), ((4, 0),), ((6, 0),), ((8, 0),))\n    >>> print(percolation(grille,mes_amas))\n    True\n    >>>g=((0, 0, 0, 0, 0, 0, 0, 0, 0, 0), \n    (0, 1, 0, 0, 1, 0, 1, 0, 0, 0), \n    (0, 0, 1, 1, 0, 0, 0, 1, 0, 0), \n    (0, 0, 1, 1, 1, 1, 1, 0, 1, 0), \n    (1, 0, 0, 1, 0, 0, 1, 0, 1, 1), \n    (1, 0, 0, 1, 0, 0, 1, 1, 0, 1), \n    (1, 1, 1, 0, 1, 0, 0, 0, 0, 0), \n    (0, 1, 0, 1, 0, 0, 0, 1, 1, 0), \n    (1, 0, 0, 0, 0, 0, 1, 1, 0, 0), \n    (0, 0, 1, 1, 1, 0, 0, 0, 0, 0))\n    >>> amas=(((0, 0), (1, 0), (0, 1), (2, 0), (0, 2), (3, 0), (2, 1), (1, 2), (0, 3), (4, 0), (3, 1), (1, 3), (5, 0), (1, 4), (6, 0), (5, 1), (2, 4), (1, 5), (7, 0), (5, 2), (2, 5), (8, 0), (7, 1), (6, 2), (4, 2), (9, 0), (8, 1), (9, 1), (8, 2), (9, 2), (9, 3)),)\n    >>> print(percolation(grille,mes_amas))\n    False\n    '''<\/code><\/pre>\n\n\n\n
4. Dictionnaires et \u00e9tude statistiques de ph\u00e9nom\u00e8ne de percolation.<\/h3>\n\n\n\n
Enregistrer le programme pr\u00e9c\u00e9dent dans un r\u00e9pertoire dans votre espace personnel avec le nom \u00ab\u00a0percolation.py\u00a0\u00bb.
Pour r\u00e9aliser l’\u00e9tude statistiques d’un certain nombre d’exp\u00e9riences, on va cr\u00e9er de nouvelles fonctions dans un nouveau programme.
On va importer dans celui-ci les fonctions de notre module \u00ab\u00a0percolation.py\u00a0\u00bb.
Ouvrir un nouveau fichier python et le nomme \u00ab\u00a0simulation_experiences.py\u00a0\u00bb.
Ajouter le code ci-dessous en d\u00e9but de programme<\/p>\n\n\n\n
# on importe le module percolation avec le prefixe perco\nimport percolation as perco\n# on peut utiliser les fonctions du module perco en les pr\u00e9fixant par perco\ng=perco.grille(10,10,0.8)\nperco.afficher(g)<\/code><\/pre>\n\n\n\n
On va s’int\u00e9resser \u00e0 pr\u00e9sent aux r\u00e9sultats de nos simulations de percolation.
Pour cela, on va utiliser un dictionnaire pour stocker les donn\u00e9es de nos exp\u00e9riences sous la forme :
 {‘dimensions’: (10, 10), ‘densit\u00e9’: 0.5, ‘fr\u00e9quence’: 0.43, ‘percolation’: False}<\/p>\n\n\n\n
Recopier et compl\u00e9ter la fonction ci-dessous :<\/strong><\/p>\n\n\n\n
def experience(largeur,hauteur,densite):\n    '''\n    donne le r\u00e9sultat de l'exp\u00e9rience sous la forme d'un dictionnaire\n    : largeur: int\n    : hauteur : int\n    : densit\u00e9 : float entre 0 et 1\n    '''\n    g=perco.grille(largeur,hauteur,densite)\n    amas=perco.amas(g)\n    retour=dict()\n    retour[\"dimensions\"]=\n    retour[\"densit\u00e9\"]=\n    retour[\"fr\u00e9quence\"]=\n    retour[\"percolation\"]=\n    return retour<\/code><\/pre>\n\n\n\n
On va \u00e0 pr\u00e9sent simuler un grand nombre d’exp\u00e9riences de m\u00eame taille et de m\u00eame densit\u00e9, pour \u00e9tudier la fr\u00e9quence de percolation en fonction de ces param\u00e8tres.
On va \u00e9galement faire appel \u00e0 un dictionnaire pour avoir un r\u00e9sultat du type, pour 10 exp\u00e9riences :
{‘taille’: (10, 10), ‘densit\u00e9’: 0.5, 0: True, 1: False, 2: True, 3: False, 4: False, 5: False, 6: True, 7: False, 8: False, 9: False}
<\/p>\n\n\n\n
Recopier et compl\u00e9ter la fonction suivante:<\/strong><\/p>\n\n\n\n
def serie_experiences(largeur,hauteur,densite,nombre):\n    '''\n    simule le nombre d'exp\u00e9riences d\u00e9sir\u00e9 et renvoie le\n    resultat de la percolation pour chaque experience.\n    Le resultat est stock\u00e9 sous la forme d'un dictionnaire.\n    largeur : int\n    hauteur : int\n    densite : float entre 0 et 1\n    nombre :int\n    retour : dict avec pour cl\u00e9s le numero de l'exp\u00e9rience et valeurs le r\u00e9sultat de la percolation\n    '''\n    retour={}\n    retour[\"taille\"]=\n    retour[\"densit\u00e9\"]=\n    for i in range(nombre):\n        resultat_exp=experience(largeur,hauteur,densite)\n        retour[i]=\n    return retour<\/code><\/pre>\n\n\n\n
On va d\u00e9terminer \u00e0 pr\u00e9sent la fr\u00e9quence de percolations sur notre \u00e9chantillon d’exp\u00e9riences<\/p>\n\n\n\n
Recopier et compl\u00e9ter la fonction suivante:<\/strong><\/p>\n\n\n\n
def frequence(serie):\n    '''\n    retourne le nombre de valeurs True pr\u00e9senter dans le dictionnaire\n    serie : dict\n    >>>d={'taille': (10, 10), 'densit\u00e9': 0.5, 0: False, 1: True, 2: False, 3: True, 4: False, 5: False, 6: False, 7: False, 8: False, 9: False}\n    >>>print(frequence(d))\n    0.2\n    '''<\/code><\/pre>\n\n\n\n
Un dernier effort<\/h3>\n\n\n\n
Il ne reste plus qu’\u00e0 d\u00e9finir une fonction qui permettra de d\u00e9terminer plus ou moins pr\u00e9cis\u00e9ment le seuil de percolation ( c’est \u00e0 dire la valeur approximative de la densit\u00e9 qui fait passer de la non percolation \u00e0 la percolation ) en fonction de la dimension.
Pour cela, on va effectuer un balayage des densit\u00e9s de 0 \u00e0 1 avec par exemple un pas de 0.1.
On renverra le r\u00e9sultats sous la forme d’un dictionnaire :<\/p>\n\n\n\n
Par exemple : 
{‘taille’: (10, 10), \u00ab\u00a0nombre d’exp\u00e9riences\u00a0\u00bb: 100, ‘densit\u00e9= 0’: 1.0, ‘densit\u00e9= 0.1’: 1.0, ‘densit\u00e9= 0.2’: 0.99, ‘densit\u00e9= 0.30000000000000004’: 0.9, ‘densit\u00e9= 0.4’: 0.52, ‘densit\u00e9= 0.5’: 0.14, ‘densit\u00e9= 0.6’: 0.01, ‘densit\u00e9= 0.7’: 0.0, ‘densit\u00e9= 0.7999999999999999’: 0.0, ‘densit\u00e9= 0.8999999999999999’: 0.0, ‘densit\u00e9= 0.9999999999999999’: 0.0}
Nous permet de dire que le seuil de percolation pour une dimension (10,10) est proche de 0.4<\/p>\n\n\n\n
On pourra am\u00e9liorer la lisibilit\u00e9 des r\u00e9sultats par une fonction affichage et un \u00e9ventuel graphique.<\/p>\n","protected":false},"excerpt":{"rendered":"
1. Le principe de la percolation en physique. 2. Mise en place de la recherche…<\/p>\n
Read the postNSI :TP simulation num\u00e9rique  de percolation<\/span><\/a><\/div>\n","protected":false},"author":2,"featured_media":1051,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[1],"tags":[],"_links":{"self":[{"href":"https:\/\/labodemaths.fr\/WordPress3\/wp-json\/wp\/v2\/posts\/1049"}],"collection":[{"href":"https:\/\/labodemaths.fr\/WordPress3\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/labodemaths.fr\/WordPress3\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/labodemaths.fr\/WordPress3\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/labodemaths.fr\/WordPress3\/wp-json\/wp\/v2\/comments?post=1049"}],"version-history":[{"count":3,"href":"https:\/\/labodemaths.fr\/WordPress3\/wp-json\/wp\/v2\/posts\/1049\/revisions"}],"predecessor-version":[{"id":1056,"href":"https:\/\/labodemaths.fr\/WordPress3\/wp-json\/wp\/v2\/posts\/1049\/revisions\/1056"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/labodemaths.fr\/WordPress3\/wp-json\/wp\/v2\/media\/1051"}],"wp:attachment":[{"href":"https:\/\/labodemaths.fr\/WordPress3\/wp-json\/wp\/v2\/media?parent=1049"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/labodemaths.fr\/WordPress3\/wp-json\/wp\/v2\/categories?post=1049"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/labodemaths.fr\/WordPress3\/wp-json\/wp\/v2\/tags?post=1049"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}