Décroissance radioactive

par Jean Luc Leloire .

Simulation de la décroissance radioactive. Exportation des données. Utilisation du langage Python pour modéliser ces données et vérifier la loi de décroissance radioactive.

Les données de la simulation peuvent être exportées au format CSV pour utilisation dans Excel, LibreOffice, LatisPro, Regressi etc...
...et aussi dans un programme écrit en Python

1. La simulation

Cliquez sur la vidéo pour accéder à la ressource

Choix de la constante de proportionnalité λ

  • Chaque noyau a la même probabilité de se désintégrer λ
  • Le programme compte alors le nombre de noyaux qui se sont désintégrés pendant une durée d’une seconde et affiche sur les courbes le nombre de noyaux restants et l’activité mesurée
  • Lorsque le nombre de noyaux restants est égal à la moitié du nombre de noyaux initiaux, t1/2 est affichée

Choix du nombre de noyaux initiaux N0

  • Plus ce nombre est important, plus les courbes se rapprochent des lois exponentielles décroissantes
  • Un nombre petit de noyaux initiaux permet de montrer le caractère aléatoire de la désintégration de chaque noyau (prendre une constante λ petite)
  • Deux simulations successives sont alors nettement différentes

Modèle théorique

  • Lorsque la simulation s’arrête ou est arrêtée, un modèle théorique est proposé.
  • Les différences entre la simulation et la théorie est donc visible et montre que les lois ne sont valables que si le nombre initial de noyaux est suffisamment grand

Les désintégrations sont comptées et affichées sur une durée d’une seconde mais l’animation n’est pas en temps réel

2. Réutilisation des données dans un programme Python

A l’aide de la simulation ci-dessus, nous avons exporté les données pour N0=1600 et λ=0,03 dans un fichier appelé radioactivite.csv.
Ce fichier est placé dans le même répertoire que le programme Python ci-dessous.
Ce programme utilise ces données pour tracer la courbe et la modéliser.

  1. import matplotlib.pyplot as plt
  2. import numpy as np
  3. from scipy.optimize import curve_fit
  4.  
  5. #modélisation par une fonction exponentielle décroissante
  6. def modele(t, a, b):
  7.     """ Modèle d'une fonction exponentielle décroissante """
  8.     return a * np.exp(-b*t)
  9.  
  10.  
  11. #fonction de tracé d'une courbe avec sa modélisation
  12. def trace(nom,abscisse,ordonnee,couleur):
  13.     '''
  14.    Fonction traçant une courbe et sa modélisation
  15.    paramètres :
  16.        nom :chaine de caractères du type X=f(t)
  17.        abscisse : tableau numpy contenant les abscisses
  18.        ordonnée : tableau numpy contenant les ordonnées
  19.    '''
  20.      # tracé de la courbe expérimentale
  21.     plt.plot( abscisse,ordonnee, color = couleur, label = "Mesures : "+nom, marker = '+')
  22.     # calcul du modèle
  23.     parametres, covariance = curve_fit(modele, abscisse,ordonnee)
  24.     print(parametres)
  25.      # calcul des ordonnées du modèle avec la fonction du modèle et les paramètres optimisés
  26.     modelisation = modele(t, *parametres) #    *parametres -> unpacking des paramètres du modèle
  27.     #chaine de caractères représentant l'équation modélisée
  28.     N0 , lamb = parametres
  29.     expression="Modèle : "+nom[0]+"="+str(int(N0))+".exp(-"+str(round(lamb,3))+".t)"
  30.     #tracé du modèle
  31.     plt.plot(t, modelisation, label=expression, color='black')
  32.  
  33.  
  34. # Lecture des donnees du fichier csv
  35. t,N,A = np.loadtxt('radioactivite.csv', unpack=True, usecols=(0, 1,2), delimiter = ';', skiprows = 1)
  36.  
  37. #affichage des données chargées à partir du fichier
  38. print(t)
  39. print(N)
  40. print(A)
  41.  
  42. # Creation des graphiques
  43.  
  44. plt.figure('Décroissance radioactive',figsize=(16,7),dpi=80)
  45.  
  46. # Création du graphique N avec sa modélisation
  47. plt.subplot(2,1,1)
  48. plt.axis([1,t[-1],0,N[0]])
  49. plt.xlabel('Temps t(s)')
  50. plt.ylabel('Nombre de noyaux N')
  51. trace("N=f(t)",t,N,"red")
  52. plt.legend()
  53.  
  54.  
  55. # Creation du graphique A
  56. plt.subplot(2,1,2)
  57. plt.axis([1,t[-1],0,A[0]])
  58. plt.xlabel('Temps t(s)')
  59. plt.ylabel('Activité')
  60. trace("A=f(t)",t,A,"blue")
  61. plt.legend()
  62.  
  63. #affichage
  64. plt.show()

Télécharger

On retrouve bien les modèles attendus.

$$ N(t) = N_0 . e^{-\lambda.t} =1600 . e^{-0,03.t}$$

$$ A(t) = A_0 . e^{-\lambda.t} = \lambda.N_0 . e^{-\lambda.t} = 0,03 \times 1600 . e^{-0,03.t} = 48. e^{-0,03.t}$$

Remarque : les lignes 27 à 29 cassent l’universalité de la fonction trace. Sans ces lignes, cette fonction permet de tracer les données expérimentales et un modèle proposé de votre choix : il suffit pour cela de modifier la fonction modele.