L'activité s'intéresse à la décoloration d'une solution d'érioglaucine (espèce notée $E$) dont la concentration initiale en érioglaucine est $\mathsf{C_0=1 \cdot 10^{-5} mol \cdot L^{-1}}$.
La décoloration de cette solution est provoquée par l'introduction d'eau de Javel. Les ions hypochlorite qu'elle contient oxydent l'érioglaucine et la transforment en une espèce chimique qui ne colore pas la solution.
La transformation est modélisée par l'équation de réaction : \begin{equation}\mathsf{ E(aq) + ClO^-(aq-) = P(aq) + Cl^-(aq) \\ } \end{equation} où :
Donnée : Les solutions d'érioglaucine sont colorées en bleu. La longueur d'onde du maximum d'absorbance est de 630 nm. A cette longueur d'onde, le coefficient d'absorption molaire vaut : \begin{equation}\mathsf{ \epsilon_{630 nm}=9,3 \cdot 10^4 L \cdot mol^{-1} \cdot cm^{-1} \\} \end{equation}
La loi de vitesse postulée s'écrit : \begin{equation}\mathsf{ v=k \cdot [E]^\alpha \cdot [ClO^-]^\beta \\} \end{equation}
L'objectif est de déterminer la valeur de l'ordre partiel $\alpha$.
La présence de deux concentrations dans la loi de vitesse conduit à proposer des conditions expérimentales en permettant la simplification. Dans l'expérience menée, les ions hypotchlorite seront introduits en grand excès par rapport à l'érioglaucine, de manière à pouvoir considérer leur concentration constante tout au long de l'expérience. Il y a dégénérescence de l'ordre, et la loi simplifiée s'écrit : \begin{equation}\mathsf{ v=k_{app} \cdot [E]^\alpha } \end{equation} avec : \begin{equation}\mathsf{ k_{app} = k \cdot [ClO^-]_0^\beta \\ } \end{equation} où $\mathsf{[ClO^-]_0}$ désigne la concentration initiale des ions hypochlorite dans le mélange initial.
La dégénérescence de l'ordre en ions hypochlorite est préférable à celle en érioglaucine :
□ Dans un bécher, introduire $\mathsf{25 mL}$ de solution d’érioglaucine de concentration $\mathsf{C_0 = 1,0 \cdot 10^{-5} mol \cdot L^{-1}}$.
□ Sous agitation, introduire $\mathsf{1,0 mL}$ d’eau de Javel concentrée ($\mathsf{[ClO^-] = 0,40 mol \cdot L^{-1}}$) et déclencher le chronomètre.
□ Mesurer l'absorbance de la solution toutes les 20 secondes pendant 8 minutes.
Dans le mélange, à l'instant initial, les quantités de matière des deux réactifs confirment l'hypothèse d'une dégénérescence de l'ordre :
Listes des valeurs mesurées : \begin{array}{c} t(s) & 0 & 20 & 40 & 60 & 80 & 100 & 120 & 140 \\ \hline A & 0,973 & 0,930 & 0,884 & 0,842 & 0,803 & 0,765 & 0,729 & 0,693 \end{array} \begin{array}{c} t(s) & 160 & 180 & 200 & 220 & 240 & 260 & 280 & 300\\ \hline A & 0,660 & 0,628 & 0,598 & 0,570 & 0,543 & 0,515 & 0,489 & 0,465\end{array} \begin{array}{c} t(s) & 320&340&360&380&400&420&440&460\\ \hline A & 0,443 & 0,425 & 0,402 & 0,380 & 0,360 & 0,342 & 0,328 & 0,309\end{array}
La bibliothèque numpy
est utilisée pour réaliser des calculs.
La bibliothèque matplolib
permet de tracer des graphiques.
#%%# Importation des bibliothèques
import numpy as np
import matplotlib.pyplot as plt
Les valeurs d'absorbance $A$ et les instants $t$ sont saisis dans des listes. La liste des absorbance permet de déterminer la concentration en érioglaucine à chaque instant. Les valeurs de concentration sont stockées dans une liste appelée $C$.
t=[0,20,40,60,80,100,120,140,160,180,200,220,240,260,280,300,320,340,360,380,400,420,440,460,480]
A=[0.973,0.930,0.884,0.842,0.803,0.765,0.729,0.693,0.660,0.628,0.598,0.570,0.5429,0.515,0.489,0.465,0.443,0.425,0.402,0.380,0.360,0.342,0.328,0.309,0.294]
""" Calcul des valeurs de concentration en érioglaucine """
C=[i/9.3E4 for i in A]
""" Concentration en fonction du temps """
plt.figure(1)
plt.plot(t,C,'+')
plt.xlabel('t en s')
plt.ylabel('C en mol.L^(-1)')
plt.grid()
plt.title("Concentration en érioglaucine en fonction du temps")
plt.show()
A partir des valeurs successives de la concentration, il est possible d'estimer la vitesse instantanée de consommation de l'érioglaucine, définie comme l'opposée de la dérivée temporelle de la concentration $\mathsf{C}$. La dérivée est ici approchée par le calcul d'un taux de variation.
D'autre part, la linéarisation de la loi de vitesse prévoit que le tracé de $\mathsf{ln(v)=f(ln[E])}$ fournisse une droite de coefficient directeur $\alpha$ si cet ordre existe. \begin{equation}\mathsf{ ln(v)=ln(k_{app}) + \alpha \cdot ln([E]) \\ } \end{equation}
Il faut noter que, du fait du mode de calcul du taux de variation, la liste des valeurs de vitesses contient une valeur de moins que celle des données expérimentales (t). On crée donc une nouvelle liste des concentrations en retirant la dernière valeur de la liste "C" afin de pouvoir procéder au tracé.
""" Création de listes : vitesse, ln(v) et ln(C)"""
v = [-(C[i+1]-C[i])/(t[i+1]-t[i]) for i in range(0,len(t)-1)]
Lv = [np.log(i) for i in v]
LC = [np.log(C[i]) for i in range(0,len(C)-1)]
""" Courbe ln(v) = f(ln(C)) """
plt.figure(2)
plt.plot(LC,Lv,'+')
plt.xlabel('ln(C)')
plt.ylabel('ln(v)')
plt.grid()
plt.title("ln(v) en fonction de ln(C)")
Le nuage de points semble raisonnablement assimilable à une droite. Une régression linéaire semble judicieuse.
La commande np.polyfit(x,y,1)
renvoie les coefficients optimisés du polynôme de degré 1 sous forme d'une liste [a,b]. La commande np.polyval(p,t)
renvoie la valeur du polynôme p pour la variable t.
""" Régression linéaire """
p=np.polyfit(LC,Lv,1)
""" Courbe ln(v) = f(ln(C)) + Droite de régression """
plt.figure(3)
plt.plot(LC,np.polyval(p,LC))
plt.plot(LC,Lv,'+')
plt.xlabel('ln(C)')
plt.ylabel('ln(v)')
plt.grid()
plt.title("ln(v) en fonction de ln(C)")
print(f'Coefficient directeur : {p[0]}')
Les résidus semblent aléatoires. Le coefficient directeur semble proche de 1. L'hypothèse d'un ordre $\mathsf{\alpha =1}$ sera prioritairement testée par la méthode intégrale.
La méthode intégrale nécessite d'intégrer l'équation différentielle obtenue en égalisant :
La courbe à tracer pour valider l'hypothèse d'un ordre partiel $\mathsf{\alpha=1}$ pour l'érioglaucine est : \begin{equation}\mathsf{ ln([E])=f(t) \\ } \end{equation}
"""Création des listes des valeurs de ln(C)"""
L1=[np.log(C[i]) for i in range(0,len(t))]
"""Visualisation du nuage de points ln(C) = f(t)"""
plt.figure(4)
plt.plot(t,L1,'+')
plt.xlabel('t en s')
plt.ylabel('ln(C)')
plt.title("ln(C) en fonction du temps")
plt.grid()
plt.show()
Le nuage de points semble raisonnablement assimilable à une droite. Une régression linéaire peut être menée. La courbe précédente est superposée à la courbe issue de la modélisation affine. Dans un second temps, les résidus sont calculés.
""" Régression linéaire """
p_int1=np.polyfit(t,L1,1)
""" Courbe ln(C) = f(t) + Droite de régression """
plt.figure(5)
plt.plot(t,np.polyval(p_int1,t))
plt.plot(t,L1,'+')
plt.xlabel('t (s)')
plt.ylabel('ln(C)')
plt.grid()
plt.title("ln(C) en fonction de t")
print(f'Coefficient directeur : {p_int1[0]}')
La droite modèle semble correctement modéliser le tracé issu des mesures expérimentales. Ceci pourrait valider l'hypothèse d'un ordre $\mathsf{\alpha=1}$. D'après l'expression littérale de la fonction $\mathsf{ln(C) = f(t)}$, le coefficient directeur de la droite modème s'identifie à l'opposé de la constante de vitesse apparente. \begin{equation}\mathsf{ k_{app}=2,5 \cdot 10^{-3} s^{-1} \\ } \end{equation}
Le code est organisé en 3 étapes :
import numpy as np
import matplotlib.pyplot as plt
t=[0,20,40,60,80,100,120,140,160,180,200,220,240,260,280,300,320,340,360,380,
400,420,440,460,480]
A=[0.973,0.930,0.884,0.842,0.803,0.765,0.729,0.693,0.660,0.628,0.598,0.570,
0.5429,0.515,0.489,0.465,0.443,0.425,0.402,0.380,0.360,0.342,0.328,0.309,0.294]
C=[i/9.3E4 for i in A]
#Méthode différentielle
v = [-(C[i+1]-C[i])/(t[i+1]-t[i]) for i in range(0,len(t)-1)]
Lv = [np.log(i) for i in v]
LC = [np.log(C[i]) for i in range(0,len(C)-1)]
p_diff=np.polyfit(LC,Lv,1) #régression linéaire
plt.figure(2)
plt.plot(LC,Lv,'+')
plt.plot(LC,np.polyval(p_diff,LC))
plt.xlabel('ln(C)')
plt.ylabel('ln(v)')
plt.grid()
plt.title("ln(v) en fonction de ln(C)")
print(f'Coefficient directeur Meth Diff : {p_diff[0]}')
#Méthode intégrale
L1=[np.log(C[i]) for i in range(0,len(t))]
p_int1=np.polyfit(t,L1,1)
plt.figure(3)
plt.plot(t,L1,'+')
plt.plot(t,np.polyval(p_int1,t))
plt.xlabel('t en s')
plt.ylabel('ln(C)')
plt.title("ln(C) en fonction du temps")
plt.grid()
plt.show()
print(f'Coefficient directeur Meth Int : {p_int1[0]}')
Les résidus correspondent aux écarts en ordonnée des points expérimentaux à la droite modèle. Pour pleinement valider un modèle affine, il faut que les résidus soient aléatoires.
La création de la liste des résidus nécessite de retrancher aux valeurs de la liste des ordonnées, la valeur obtenue avec le modèle affine. La fontion np.polyval(p,t)
permet de calculer facilement la valeur obtenue avec le polynôme issu de la modélisation affine.
""" Résidus pour la méthode différentielle """
Res_diff=[Lv[i] - np.polyval(p_diff,LC[i]) for i in range(0,len(LC))]
plt.figure(7)
plt.subplot(211)
plt.plot(LC,Lv,'+')
plt.plot(LC,np.polyval(p_diff,LC))
plt.xlabel('ln(C)')
plt.ylabel('ln(v)')
plt.grid()
plt.subplot(212)
plt.plot(LC,Res_diff,'+')
plt.xlabel('ln(C)')
plt.ylabel('Residus')
plt.axhline()
plt.grid()
plt.show()
Les résidus sont aléatoires ce qui tend à confirmer l'existence d'un ordre grâce à la méthode différentielle.
""" Résidus pour la méthode intégrale """
Res_int1=[L1[i] - np.polyval(p_int1,t[i]) for i in range(0,len(L1))]
plt.figure(8)
plt.subplot(211)
plt.plot(t,L1,'+')
plt.plot(t,np.polyval(p_int1,t))
plt.xlabel('ln(C)')
plt.ylabel('t (s)')
plt.grid()
plt.subplot(212)
plt.plot(t,Res_int1,'+')
plt.xlabel('t (s)')
plt.ylabel('Residus')
plt.axhline()
plt.grid()
plt.show()
L'analyse des résidus est moins convaincante puisque ceux-ci semblent d'abord tous négatifs, puis tous positifs, puis à nouveau tous négatifs. Cette tendance traduit une courbure du nuage de points expérimental autour de la droite modèle. La modélisation ne semble donc pas parfaitement adaptée. En revanche, il est peut-être prématuré pour rejeter l'hypothèse d'ordre 1 car :