diff --git a/TP-FEMM/src/bobine.md b/TP-FEMM/src/bobine.md
index 0710e38b123de863e9a859cbd071e787666c0579..897ebcdd605e0bb639247f47b5d3bfcda343457a 100644
--- a/TP-FEMM/src/bobine.md
+++ b/TP-FEMM/src/bobine.md
@@ -125,10 +125,10 @@ femm.mi_addsegment(R,-b/2,R,b/2)
 
 
 
-> **Remarque :** Ceci est la façon la plus basique de procéder, on aurait pu utiliser des fonctions plus évoluées comme `mi_drawpolyline`, `mi_drawpolygon` ou, encore mieux dans notre cas, `mi_drawrectangle`. Pour notre rectangle, on aurait donc pu faire :
-> 1. `mi_drawpolyline([R,b/2;R+a,b/2;R+a,-b/2;R,-b/2;R,b/2])`
-> 2. `mi_drawpolygon([R,b/2;R+a,b/2;R+a,-b/2;R,-b/2])`
-> 3. `mi_drawrectangle(R,b/2,R+a,-b/2)`   
+> **Remarque :** Ceci est la façon la plus basique de procéder, on aurait pu utiliser des fonctions plus évoluées comme `mi_drawpolyline` (MATLAB uniquement), `mi_drawpolygon` (MATLAB uniquement) ou, encore mieux dans notre cas, `mi_drawrectangle`. Pour notre rectangle, on aurait donc pu faire :
+> 1. `mi_drawpolyline([R,b/2;R+a,b/2;R+a,-b/2;R,-b/2;R,b/2])` (MATLAB)
+> 2. `mi_drawpolygon([R,b/2;R+a,b/2;R+a,-b/2;R,-b/2])` (MATLAB)
+> 3. `mi_drawrectangle(R,b/2,R+a,-b/2)` (MATLAB ou Python)   
 > 
 > Ce qui est évidemment beaucoup plus compact...
 
diff --git a/TP-FEMM/src/chaufind.md b/TP-FEMM/src/chaufind.md
index 9a5d4afec5b4f85fad3a43a6994e9a315433a5d3..bef320cd893d1fc5fa482e6aacd48adeaa20f7d7 100644
--- a/TP-FEMM/src/chaufind.md
+++ b/TP-FEMM/src/chaufind.md
@@ -72,9 +72,14 @@ Pour commencer nous choisirons un courant d'alimentation de 10 A efficaces à 1
 **➤ Implantez le problème correspondant en laissant le maillage par défaut créé automatiquement par FEMM.**
 
 > On n'oubliera pas de définir le matériau de l'inducteur correctement :
+> * *MATLAB :*
 > ```Matlab
 > mi_addmaterial('Litz',1,1,0,0,sigmaCu,0,0,1,5,0,0,nbrins,dbrins);
 > ```
+> * *Python :*
+> ```Python
+> femm.mi_addmaterial('Litz',1,1,0,0,sigmaCu,0,0,1,5,0,0,nbrins,dbrins)
+>```
 > Et de donner la valeur max du courant dans le circuit.
 
 Vous pouvez alors constater les imprécisions dues au manque de finesse du maillage en traçant la densité de courants induits dans l'Inox.  
@@ -108,16 +113,21 @@ Vous avez dû observer que plus la fréquence est élevée, moins le champ pén
 
 Ceci se fait simplement en :
 1. ne créant pas pas de *label* dans le bloc ;
-2. sélectionnant le segment de bloc situé sur l'axe et en le détruisant avec un `mi_deleteselectedsegments;`. (**Attention :** faites-le après avoir créé la boîte infinie, donc après le `mi_makeABC();`). 
+2. sélectionnant le segment de bloc situé sur l'axe et en le détruisant avec un `mi_deleteselectedsegments`. (**Attention :** faites-le après avoir créé la boîte infinie, donc après le `mi_makeABC()s`). 
 
 Les trois segments de la pièce en inox restants sont désormais des frontières du domaine, nous devons donc leur imposer une condition traduisant notre problème (équivalente à la présence du matériau de l'autre côté). À fréquence élevée, le champ magnétique est nul à l'intérieur de la pièce à chauffer, et la densité de courant est purement surfacique (comme si elle n'existait que sur une épaisseur \\(\delta\\) très petite. Ainsi, en développant le saut de la composante tangentielle de \\({\bf h}\\) sur les bords du conducteur, on obtient la condition mixte suivante :
 
 \\[\frac{\partial\\,{\bf \underline{a}}}{\partial n} + \frac{1+i}{\delta}\\,{\bf \underline{a}} = 0\\]
 
 Dans FEMM, une telle condition se crée facilement avec :
+* *MATLAB :*
 ```Matlab
 mi_addboundprop('Impedance_surface',0,0,0,0,mur,sigmaInox,0,0,1,0,0);
 ```
+* *Python :*
+```Python
+femm.mi_addboundprop('Impedance_surface',0,0,0,0,mur,sigmaInox,0,0,1,0,0)
+```
 
 Il nous reste un dernier petit souci à régler : le calcul de la densité de pertes dans la pièce en Inox. Puisqu'elle n'est plus maillée, on ne peut plus intégrer la densité de perte Joule à l'intérieur. Ce n'est pas gênant, on l'estimera par le calcul de la puissance dans l'inducteur vu ci-avant. 
 
@@ -134,10 +144,11 @@ Un exemple de calcul avec impédance de surface est donné ci-dessous :
 
 **➤ Forts des résultats précédents, faites une simulation à la vraie fréquence de fonctionnement de la plaque : 25 kHz (avec seulement la condition d'impédance de surface).**
 
-**➤ Trouvez la valeur du courant inducteur permettant d'atteindre l'ébullition en 2 minutes.**
+**➤ Trouvez la valeur du courant inducteur permettant d'atteindre l'ébullition en 2 minutes grâce à un couplage faible avec la thermique.**
 
 > **Cadeau :** Pour ce faire, je vous fournis ci-dessous un morceau de programme qui permet de résoudre le problème thermique (en transitoire) avec FEMM. Il est à exécuter après votre résolution magnétique permettant de calculer ce que j'ai appelée `Ptr` : la puissance transmise par l'inducteur à la casserole.
 
+* *MATLAB :*
 ```Matlab
 % A executer apres la resolution magnetoharmonique
 % --> prend en entree : Ptr (= puissance transmise a la casserole)
@@ -216,6 +227,103 @@ for n=1:npas
     ho_close();
 end
 plot(t,Tmoy,'linewidth',2));
+xlabel("Temps (en s)");
+ylabel("Temperature moyenne (en K)");
+title("Evolution de la temperature dans la casserole")
+grid on
+```
+* *Python :*
+```Python
+# A executer apres la resolution magnetoharmonique
+# --> prend en entree : Ptr (= puissance transmise a la casserole)
+import matplotlib.pyplot as plt
+
+R = 80   # inutile si deja defini
+ep = 10  # meme chose
+eb = 3   # epaisseur bord
+hc = 100 # hauteur casserole
+he = 80  # hauteur d'eau
+
+Ta = 273+20 # Temperature ambiante
+h = 10      # coeff. convection naturelle avec air
+
+femm.newdocument(2)  # nouveau pbm thermique
+femm.hi_probdef('millimeters','axi',1e-8)
+
+femm.hi_getmaterial('Water')   # eau
+femm.hi_modifymaterial('Water',0,'Eau')
+femm.hi_getmaterial('347 Stainless Steel')  # inox
+femm.hi_modifymaterial('347 Stainless Steel',0,'Inox')
+
+femm.hi_addboundprop('Convection',2, 0, 0, Ta, h, 0)
+femm.hi_addconductorprop('P_transmise', 0, Ptr, 0)
+femm.hi_addconductorprop('Temp_ini', Ta, 0, 1)
+
+femm.hi_drawline(0,0,R,0)
+femm.hi_drawline(R,0,R,ep)
+femm.hi_drawline(R,ep,R,ep+hc)
+femm.hi_drawline(R,ep+hc,R-eb,ep+hc)
+femm.hi_drawline(R-eb,ep+hc,R-eb,ep+he)
+femm.hi_drawline(R-eb,ep+he,R-eb,ep)
+femm.hi_drawline(R-eb,ep,0,ep)
+femm.hi_drawline(0,ep,0,0)
+femm.hi_addnode(0,ep+he)
+femm.hi_addsegment(0,ep,0,ep+he)
+femm.hi_addsegment(0,ep+he,R-eb,ep+he)
+femm.hi_zoomnatural()
+
+femm.hi_addblocklabel(R/2,ep/2)
+femm.hi_selectlabel(R/2,ep/2)
+femm.hi_setblockprop('Inox', 1, 0, 1)
+femm.hi_clearselected()
+femm.hi_addblocklabel(R/2,ep+he/2)
+femm.hi_selectlabel(R/2,ep+he/2)
+femm.hi_setblockprop('Eau', 1, 0, 1)
+femm.hi_clearselected()
+
+femm.hi_selectsegment(R/2,0)
+femm.hi_setsegmentprop('<none>', 0, 1, 0, 1, 'Temp_ini') # 1er calcul pour init
+femm.hi_clearselected()
+femm.hi_selectsegment(R,ep/2)
+femm.hi_selectsegment(R,ep+hc/2)
+femm.hi_selectsegment(R-eb/2,R-(hc-he)/2)
+femm.hi_selectsegment(R/2,ep+he)
+femm.hi_setsegmentprop('Convection', 0, 1, 0, 1, '<none>' )
+femm.hi_clearselected()
+
+# 1ere resolution pour fixer T = Ta partout
+femm.hi_saveas('Temp0.FEH')
+femm.hi_analyze()
+
+# puissance transmise par l'inducteur
+femm.hi_selectsegment(R/2,0)
+femm.hi_setsegmentprop('<none>', 0, 1, 0, 1,'P_transmise')
+
+# boucle pour regime transitoire
+deltaT = 4 # pas de temps en secondes
+npas = 30  # nombre de pas
+t = np.linspace(0,npas*deltaT,npas+1) # temps
+Tmoy = np.zeros(npas+1)   # initialisation
+Tmoy[0] = Ta
+for n in range(npas):
+    nomfichier = "Temp{}.anh".format(n)
+    femm.hi_probdef('millimeters','axi',1.e-8,1,30,nomfichier,deltaT)
+    femm.hi_saveas("Temp{}.feh".format(n+1))
+    femm.hi_analyze()
+    femm.hi_loadsolution()
+    # recuperation de la temperature moyenne sur le fond interieur
+    femm.ho_addcontour(0,ep)
+    femm.ho_addcontour(R-eb,ep)
+    res = femm.ho_lineintegral(3)
+    Tmoy[n+1] = res[0]
+    femm.ho_close()
+
+plt.plot(t,Tmoy,'b',lw=2)
+plt.title('Évolution de la température dans la casserole')
+plt.xlabel('Temps (en s)')
+plt.ylabel('Température moyenne (en K)')
+plt.grid()
+plt.show()
 ```
 
 > **Remarque :** Initialement, FEMM ne permettait de résoudre que des problèmes thermiques stationnaires. Depuis quelque temps, a été introduit un moyen permettant de résoudre le régime transitoire en chargeant une résolution précédente et un pas de temps dans la définition du problème. C'est ce qui est fait ci-dessus dans la boucle.
diff --git a/TP-FEMM/src/ventouse.md b/TP-FEMM/src/ventouse.md
index fc69ef80ab0c61a88642476d1da5c48cad0eea39..f0377795987a5434fe713d96e69513e43b0dd9af 100644
--- a/TP-FEMM/src/ventouse.md
+++ b/TP-FEMM/src/ventouse.md
@@ -41,11 +41,11 @@ Les valeurs des paramètres sont données par la table suivante :
 
 > **Remarque :** Pensez à définir votre problème comme 2D cartésien de profondeur Lz.   
 >     
-> En MATLAB :
+> * *MATLAB :*
 > ```Matlab
 > mi_probdef(0,'millimeters','planar',1e-8,Lz);  % 1e-8 = precision du solveur
 > ```
-> En Python :
+> * *Python :*
 > ```Python
 > femm.mi_probdef(0,'millimeters','planar',1e-8,Lz) # 1e-8 = precision du solveur
 > ```
@@ -89,6 +89,7 @@ Dans FEMM, vous pourrez :
 
 **➤ À l'aide du théorème d'Ampère, développez un modèle analytique approché permettant de calculer la force, et vérifiez la concordance des ordres de grandeur.**
 
+
 ### Force en fonction de la position
 
 Une fois que les calculs précédents validés, nous allons tracer la force en fonction de la position de la plaque (entrefer \\(e\\) variable).