Décroissance radioactive : simulation de lancers de dés (Python)

Où l’on simule un jeu de dés pour illustrer la désintégration d’un échantillon radioactif

Dans un autre article, j’utilise l’expérience de lancers de cubes successifs pour montrer aux élèves que le caractère aléatoire permet malgré tout d’aboutir à une loi exponentielle prévisible.

Ici, une simulation de lancers de dés avec Python permet d’augmenter significativement la taille de “l’échantillon” de dés.

J’ai trouvé ce code Python sur ce forum ; je n’ai pas retrouvé le message de l’auteur du code. S’il se reconnaît, je serai ravi de l’attribuer). On montre facilement qu’en augmentant fortement la population de dés, on tend vers une loi de décroissance exponentielle.

# programme de simulation de décroissance radioactive
# par le jet de dés
#source : physiquechimie.forum.free.fr
# importations de fonctions utiles
from random import  random
import matplotlib.pyplot as plt
import numpy as np

#--------------------------------------------------------------------------------------
# fonction permettant de lancer la simulation pour un
# nombre n d'atomes
def simulation(n):
     
    # initialisation des données
    nombrelance = 0 #compteur de lancers 
    n0=n
    nblancers = [0]
    desrestant = [n]
    if n0>=10:#calcul du pas des graduations verticales
        pasN=int(n0/10)
    else:
        pasN=1
    
    # coeur du programme
    while n > 0:
            desintegration = 0
            for i in range(int(n)):
                tirage = random()
                if tirage < 1/6 :
                    desintegration = desintegration + 1
            n = n - desintegration
            nombrelance = nombrelance + 1
            nblancers.append(nombrelance)
            desrestant.append(n)

    plt.yticks(np.arange(0, n0+pasN, pasN))
    plt.axis([0, nombrelance, 0, n0])#limites des axes, avec xmax égal au nombre total de lancers
    plt.plot(nblancers, desrestant, 'o')
    plt.grid()
    plt.xlabel("nombre de lancers")
    plt.ylabel("nombre de dés restants")
    plt.title('Tirage aléatoire de dés')
#   fin de la fonction

# utilisation
#n = int(input("combien de dés au départ ? "))# cette ligne OU la suivante, pour choisir le nombre inital
n=10
fig=plt.figure()

simulation(n)

fig.savefig("TirageAleatoireDes.png", dpi=300)
plt.show()
Avec un échantillon de 10 dés.

Je fais remarquer que, au début, il arrive souvent que plusieurs dès disparaissent au cours d’un même lancer, et que vers la fin, il est fréquent que des tirages laissent identique le nombre de dés. Une observation qui se retrouve dans les expériences suivantes.

Autrement dit, plus les dés sont nombreux, plus ils sont nombreux à disparaître à chaque instant.

Avec les classes qui voient la notion de dérivée et d’intégration, c’est d’ailleurs ce qui permet de poser :

 dN=-\lambda \cdot N

pour aboutir à une démonstration de la loi exponentielle décroissante. Cela explique la forme du nuage de points : forte diminution au départ, faible diminution ensuite.

Avec 50 dés.
Avec 100 dés

En lançant ce code à plusieurs reprises, en augmentant le nombre initial de dés, on voit bien l’évolution du nuage de points vers une courbe régulière :

Le code Python qui génère les 4 graphes :


Une version qui affiche un bouton pour lancer le tracé de la fonction exponentielle :

# programme de simulation de décroissance radioactive
# par le jet de dés

# importations de fonctions utiles
from random import  random
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.widgets import Button
#--------------------------------------------------------------------------------------
# fonction permettant de lancer la simulation pour un
# nombre n d'atomes
def simulation(n):
     
    # initialisation des données
    nombrelance = 0 #compteur de lancers 

    nblancers = [0]
    desrestant = [n]
    
    # coeur du programme
    while n > 0:
            desintegration = 0
            for i in range(n):
                tirage = random()
                if tirage < 1/6 :
                    desintegration = desintegration + 1
            n = n - desintegration
            nombrelance = nombrelance + 1
            nblancers.append(nombrelance)
            desrestant.append(n)
    plt.plot(nblancers, desrestant, 'bo')
    plt.grid()
    plt.xlabel("nombre de lancers")
    plt.ylabel("nombre de dés restants")
       


# utilisation
#n = int(input("combien de dés au départ ? "))
#ne pas dépasser 1e8 (trop long)
n=5000
n0=n

pas=int(n0/10)
fig=plt.figure(figsize=(9, 11))
ax=plt.subplot()
ax.axis([0, 30, 0, n0])#limites des axes
ax.set_yticks(np.arange(0, n0+pas, pas))

simulation(n)

#Affichage d'un bouton commandant l'affichage de la fonction expo :
# properties of the button
modele_button = Button(plt.axes([0.5, 0.75, 0.22, 0.05]), 'afficher le modèle', color='tab:orange')
def expo(val):
    t=np.linspace(0, 30, 101)
    ax.plot(t, n0*np.exp(-t/6), 'tab:red')#Affichage de la fonction exponentielle

# triggering event is the clicking
modele_button.on_clicked(expo)
fig.savefig("TirageAleatoireDesCourbe.png", dpi=300)
plt.show()

Soyez le premier à commenter

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée.